space hacks

[iotcloud.git] / version2 / src / C / IoTString.h

diff --git a/version2/src/C/IoTString.h b/version2/src/C/IoTString.h
index bbd0c775df095b87fdb5a1748e3669bddc8220f6..99e45bb2f287be3ce0e4e549ca812819b8b54ea1 100644 (file)
--- a/version2/src/C/IoTString.h
+++ b/version2/src/C/IoTString.h
@@ -2,17 +2,29 @@
 #define IOTSTRING_H
 
 #include "array.h"
-
+#include <string.h>
+#include <stdio.h>
 /**
  * IoTString wraps the underlying char string.
  * @author Brian Demsky <bdemsky@uci.edu>
  * @version 1.0
  */
 
-public class IoTString {
+inline unsigned int hashCharArray(Array<char> *array) {
+       uint len = array->length();
+       unsigned int hash = 0;
+       for (uint i = 0; i < len; i++) {
+               hash = 31 * hash + ((unsigned int) array->get(i));
+       }
+       return hash;
+}
+
+class IoTString {
 private:
        Array<char> *array;
-       IoTString() {}
+       unsigned int hashvalue;
+       unsigned int refCount;
+  IoTString() : refCount (1) {}
 
        /**
         * Builds an IoTString object around the char array.  This
@@ -20,8 +32,46 @@ private:
         */
 
 public:
-       IoTString(Array<char> *_array) : array(new Array<char>(_array)) {}
-       ~IoTString() {}
+       IoTString(Array<char> *_array) :
+               array(new Array<char>(_array)),
+                       hashvalue(hashCharArray(array)),
+                       refCount(1) {
+       }
+
+       IoTString(const char *_array) {
+               int32_t len = strlen(_array);
+               array = new Array<char>(len);
+               memcpy(array->internalArray(), _array, len);
+               hashvalue = hashCharArray(array);
+               refCount = 1;
+       }
+
+       IoTString(IoTString *string) :
+         array(new Array<char>(string->array)),
+                       hashvalue(string->hashvalue),
+                       refCount(1) {
+       }
+
+       IoTString * acquireRef() {
+               refCount++;
+               return this;
+       }
+
+       void releaseRef() {
+               if ((--refCount) == 0)
+                       delete this;
+       }
+       
+       ~IoTString() {
+               delete array;
+       }
+
+       void print() {
+               for(uint i=0; i < array->length(); i++)
+                       printf("%c", array->get(i));
+       };
+       
+       char get(uint i) {return array->get(i);}
 
        /**
         * Internal method to grab a reference to our char array.  Caller
@@ -34,19 +84,40 @@ public:
         * Returns a copy of the underlying char string.
         */
 
-       Array<char> *getBytes() { return new Array<Char>(&array); }
+       Array<char> *getBytes() { return new Array<char>(array); }
 
        /**
         * Returns the length in chars of the IoTString.
         */
 
+       
+       bool equals(IoTString *str) {
+               uint strlength = str->array->length();
+               uint thislength = array->length();
+               if (strlength != thislength)
+                       return false;
+
+               int result = memcmp(str->array->internalArray(), array->internalArray(), strlength);
+               return result == 0;
+       }
+
+       unsigned int hashValue() { return hashvalue;}
        int length() { return array->length(); }
        friend IoTString *IoTString_shallow(Array<char> *_array);
 };
 
-IoTString *IoTString_shallow(Array<char> *_array) {
+inline IoTString *IoTString_shallow(Array<char> *_array) {
        IoTString *str = new IoTString();
        str->array = _array;
+       str->hashvalue = hashCharArray(_array);
        return str;
 }
+
+inline unsigned int hashString(IoTString *a) {
+       return a->hashValue();
+}
+
+inline bool StringEquals(IoTString *a, IoTString *b) {
+       return a->equals(b);
+}
 #endif