edits

diff --git a/version2/src/C/Abort.cpp b/version2/src/C/Abort.cpp
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/Abort.h b/version2/src/C/Abort.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/ArbitrationRound.cpp b/version2/src/C/ArbitrationRound.cpp
old mode 100644 (file)
new mode 100755 (executable)
index cc316f0..ef442ca
--- a/version2/src/C/ArbitrationRound.cpp
+++ b/version2/src/C/ArbitrationRound.cpp
@@ -4,7 +4,7 @@
 
 ArbitrationRound::ArbitrationRound(Commit *_commit, Hashset<Abort *> *_abortsBefore) :
        abortsBefore(_abortsBefore),
-       parts(new Vector<Entry *>()),
+       parts(new MyVector<Entry *>()),
        commit(_commit),
        currentSize(0),
        didSendPart(false),
@@ -45,7 +45,7 @@ void ArbitrationRound::generateParts() {
                parts->add((Entry *)abit->next());
        delete abit;
        if (commit != NULL) {
-               Vector<CommitPart *> *cParts = commit->getParts();
+               MyVector<CommitPart *> *cParts = commit->getParts();
                uint cPartsSize = cParts->size();
                for (uint i = 0; i < cPartsSize; i++) {
                        CommitPart * part = cParts->get(i);
@@ -55,11 +55,11 @@ void ArbitrationRound::generateParts() {
        }
 }
 
-Vector<Entry *> *ArbitrationRound::getParts() {
+MyVector<Entry *> *ArbitrationRound::getParts() {
        return parts;
 }
 
-void ArbitrationRound::removeParts(Vector<Entry *> *removeParts) {
+void ArbitrationRound::removeParts(MyVector<Entry *> *removeParts) {
        uint size = removeParts->size();
        for(uint i=0; i < size; i++) {
                Entry * e = removeParts->get(i);

diff --git a/version2/src/C/ArbitrationRound.h b/version2/src/C/ArbitrationRound.h
old mode 100644 (file)
new mode 100755 (executable)
index ba4ed86..edec4df
--- a/version2/src/C/ArbitrationRound.h
+++ b/version2/src/C/ArbitrationRound.h
@@ -7,7 +7,7 @@
 class ArbitrationRound {
 private:
        Hashset<Abort *> *abortsBefore;
-       Vector<Entry *> *parts;
+       MyVector<Entry *> *parts;
        Commit *commit;
        int currentSize;
        bool didSendPart;
@@ -18,8 +18,8 @@ public:
        ~ArbitrationRound();
        void generateParts();
        Commit *getCommit();
-       Vector<Entry *> *getParts();
-       void removeParts(Vector<Entry *> *removeParts);
+       MyVector<Entry *> *getParts();
+       void removeParts(MyVector<Entry *> *removeParts);
        bool isDoneSending();
        void setCommit(Commit *_commit);
        void addAbort(Abort *abort);

diff --git a/version2/src/C/ByteBuffer.cpp b/version2/src/C/ByteBuffer.cpp
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/ByteBuffer.h b/version2/src/C/ByteBuffer.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/CloudComm.cpp b/version2/src/C/CloudComm.cpp
old mode 100644 (file)
new mode 100755 (executable)
index 4f97029..3e649c3
--- a/version2/src/C/CloudComm.cpp
+++ b/version2/src/C/CloudComm.cpp
@@ -135,10 +135,10 @@ IoTString *CloudComm::buildRequest(bool isput, int64_t sequencenumber, int64_t m
        return urlstr;
 }
 
-void loopWrite(TCPClient client, char *array, int bytestowrite) {
+void loopWrite(TCPClient * client, char *array, int bytestowrite) {
        int byteswritten = 0;
        while (bytestowrite) {
-               int bytes = client.write(&array[byteswritten], bytestowrite);
+               int bytes = client->write((const unsigned char *) &array[byteswritten], bytestowrite);
                if (bytes >= 0) {
                        byteswritten += bytes;
                        bytestowrite -= bytes;
@@ -149,10 +149,10 @@ void loopWrite(TCPClient client, char *array, int bytestowrite) {
        }
 }
 
-void loopRead(TCPClient client, char *array, int bytestoread) {
+void loopRead(TCPClient * client, char *array, int bytestoread) {
        int bytesread = 0;
        while (bytestoread) {
-               int bytes = client.read(&array[bytesread], bytestoread);
+               int bytes = client->read((unsigned char *) &array[bytesread], bytestoread);
                if (bytes >= 0) {
                        bytesread += bytes;
                        bytestoread -= bytes;
@@ -206,7 +206,7 @@ WebConnection openURL(IoTString *url) {
        
        /* send the request */
        int total = strlen(message);
-       loopWrite(sockfd, message, total);
+       loopWrite(&wc.client, message, total);
        free(message);
        return wc;
 }
@@ -234,7 +234,6 @@ TCPClient createSocket(IoTString *name, int port) {
 
 TCPServer createSocket(int port) {
        int fd;
-       struct sockaddr_in sin;
        TCPServer server = TCPServer(port);
        server.begin();
 
@@ -242,11 +241,11 @@ TCPServer createSocket(int port) {
 }
 
 
-void writeSocketData(int fd, Array<char> *data) {
+void writeSocketData(TCPClient * fd, Array<char> *data) {
        loopWrite(fd, data->internalArray(), data->length());
 }
 
-void writeSocketInt(int fd, int32_t value) {
+void writeSocketInt(TCPClient * fd, int32_t value) {
        char array[4];
        array[0] = value >> 24;
        array[1] = (value >> 16) & 0xff;
@@ -255,7 +254,7 @@ void writeSocketInt(int fd, int32_t value) {
        loopWrite(fd, array, 4);
 }
 
-int readSocketInt(int fd) {
+int readSocketInt(TCPClient * fd) {
        char array[4];
        loopRead(fd, array, 4);
        return (((int32_t)(unsigned char) array[0]) << 24) |
@@ -264,26 +263,28 @@ int readSocketInt(int fd) {
                                 ((int32_t)(unsigned char) array[3]);
 }
 
-void readSocketData(int fd, Array<char> *data) {
+void readSocketData(TCPClient * fd, Array<char> *data) {
        loopRead(fd, data->internalArray(), data->length());
 }
 
 void writeURLDataAndClose(WebConnection *wc, Array<char> *data) {
-       dprintf(wc->fd, "Content-Length: %d\r\n\r\n", data->length());
-       loopWrite(wc->fd, data->internalArray(), data->length());
+       char buffer[300];
+       sprintf(buffer, "Content-Length: %d\r\n\r\n", data->length());
+       wc->client.print(buffer);
+       loopWrite(&wc->client, data->internalArray(), data->length());
 }
 
 void closeURLReq(WebConnection *wc) {
-       dprintf(wc->fd, "\r\n");
+       wc->client.println("");
 }
 
 void readURLData(WebConnection *wc, Array<char> *output) {
-       loopRead(wc->fd, output->internalArray(), output->length());
+       loopRead(&wc->client, output->internalArray(), output->length());
 }
 
 int readURLInt(WebConnection *wc) {
        char array[4];
-       loopRead(wc->fd, array, 4);
+       loopRead(&wc->client, array, 4);
        return (((int32_t)(unsigned char) array[0]) << 24) |
                                 (((int32_t)(unsigned char) array[1]) << 16) |
                                 (((int32_t)(unsigned char) array[2]) << 8) |
@@ -294,7 +295,7 @@ void readLine(WebConnection *wc, char *response, int numBytes) {
        int offset = 0;
        char newchar;
        while (true) {
-               int bytes = read(wc->fd, &newchar, 1);
+               int bytes = wc->client.read((unsigned char *) &newchar, 1);
                if (bytes <= 0)
                        break;
                if (offset == (numBytes - 1)) {
@@ -360,7 +361,7 @@ void CloudComm::setSalt() {
                        //throw new Error("Invalid response");
                        myerror("Invalid response\n");
                }
-               close(wc.fd);
+               wc.client.stop();
 
                timer->endTime();
                salt = saltTmp;
@@ -371,7 +372,8 @@ void CloudComm::setSalt() {
 }
 
 bool CloudComm::getSalt() {
-       WebConnection wc = {-1, -1};
+       WebConnection wc;
+       wc.numBytes = -1;
        IoTString *urlstr = NULL;
 
        //      try {
@@ -412,7 +414,7 @@ bool CloudComm::getSalt() {
                }
                if (wc.numBytes == 0) {
                        timer->endTime();
-                       close(wc.fd);
+                       wc.client.stop();
                        return false;
                }
 
@@ -420,7 +422,7 @@ bool CloudComm::getSalt() {
                int salt_length = readURLInt(&wc);
                Array<char> *tmp = new Array<char>(salt_length);
                readURLData(&wc, tmp);
-               close(wc.fd);
+               wc.client.stop();
 
                salt = tmp;
                timer->endTime();
@@ -532,15 +534,15 @@ Array<Slot *> *CloudComm::putSlot(Slot *slot, int max) {
                if (resptype->equals(getslot)) {
                        delete resptype;
                        Array<Slot *> *tmp = processSlots(&wc);
-                       close(wc.fd);
+                       wc.client.stop();
                        return tmp;
                } else if (resptype->equals(putslot)) {
                        delete resptype;
-                       close(wc.fd);
+                       wc.client.stop();
                        return NULL;
                } else {
                        delete resptype;
-                       close(wc.fd);
+                       wc.client.stop();
                        //throw new Error("Bad response to putslot");
                        myerror("Bad response to putslot\n");
                }
@@ -602,7 +604,7 @@ Array<Slot *> *CloudComm::getSlots(int64_t sequencenumber) {
 
                delete resptype;
                Array<Slot *> *tmp = processSlots(&wc);
-               close(wc.fd);
+               wc.client.stop();
                return tmp;
                /*      } catch (SocketTimeoutException *e) {
                timer->endTime();
@@ -652,21 +654,21 @@ Array<char> *CloudComm::sendLocalData(Array<char> *sendData, int64_t localSequen
                Array<char> *encryptedData = encryptSlotAndPrependIV(totalData, iv);
 
                // Open a TCP socket connection to a local device
-               int socket = createSocket(host, port);
+               TCPClient socket = createSocket(host, port);
 
                timer->startTime();
                // Send data to output (length of data, the data)
-               writeSocketInt(socket, encryptedData->length());
-               writeSocketData(socket, encryptedData);
+               writeSocketInt(&socket, encryptedData->length());
+               writeSocketData(&socket, encryptedData);
 
-               int lengthOfReturnData = readSocketInt(socket);
+               int lengthOfReturnData = readSocketInt(&socket);
                Array<char> *returnData = new Array<char>(lengthOfReturnData);
-               readSocketData(socket, returnData);
+               readSocketData(&socket, returnData);
                timer->endTime();
                returnData = stripIVAndDecryptSlot(returnData);
 
                // We are done with this socket
-               close(socket);
+               socket.stop();
                mac->update(returnData, 0, returnData->length() - CloudComm_HMAC_SIZE);
                Array<char> *realmac = mac->doFinal();
                Array<char> *recmac = new Array<char>(CloudComm_HMAC_SIZE);

diff --git a/version2/src/C/CloudComm.h b/version2/src/C/CloudComm.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/Commit.cpp b/version2/src/C/Commit.cpp
old mode 100644 (file)
new mode 100755 (executable)
index 7665841..3078bc1
--- a/version2/src/C/Commit.cpp
+++ b/version2/src/C/Commit.cpp
@@ -4,7 +4,7 @@
 #include "IoTString.h"
 
 Commit::Commit() :
-       parts(new Vector<CommitPart *>()),
+       parts(new MyVector<CommitPart *>()),
        partCount(0),
        missingParts(NULL),
        fldisComplete(false),
@@ -19,7 +19,7 @@ Commit::Commit() :
 }
 
 Commit::Commit(int64_t _sequenceNumber, int64_t _machineId, int64_t _transactionSequenceNumber) :
-       parts(new Vector<CommitPart *>()),
+       parts(new MyVector<CommitPart *>()),
        partCount(0),
        missingParts(NULL),
        fldisComplete(true),
@@ -112,7 +112,7 @@ int64_t Commit::getTransactionSequenceNumber() {
        return transactionSequenceNumber;
 }
 
-Vector<CommitPart *> *Commit::getParts() {
+MyVector<CommitPart *> *Commit::getParts() {
        return parts;
 }
 

diff --git a/version2/src/C/Commit.h b/version2/src/C/Commit.h
old mode 100644 (file)
new mode 100755 (executable)
index d9f05a9..b7b1978
--- a/version2/src/C/Commit.h
+++ b/version2/src/C/Commit.h
@@ -5,7 +5,7 @@
 
 class Commit {
 private:
-       Vector<CommitPart *> *parts;
+       MyVector<CommitPart *> *parts;
        uint32_t partCount;
        Hashset<int32_t> *missingParts;
        bool fldisComplete;
@@ -27,7 +27,7 @@ public:
        void addPartDecode(CommitPart *newPart);
        int64_t getSequenceNumber();
        int64_t getTransactionSequenceNumber();
-       Vector<CommitPart *> *getParts();
+       MyVector<CommitPart *> *getParts();
        void addKV(KeyValue *kv);
        void invalidateKey(IoTString *key);
        Hashset<KeyValue *, uintptr_t, 0> *getKeyValueUpdateSet();

diff --git a/version2/src/C/CommitPart.cpp b/version2/src/C/CommitPart.cpp
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/CommitPart.h b/version2/src/C/CommitPart.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/Crypto.cpp b/version2/src/C/Crypto.cpp
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/Crypto.h b/version2/src/C/Crypto.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/Entry.cpp b/version2/src/C/Entry.cpp
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/Entry.h b/version2/src/C/Entry.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/Error.h b/version2/src/C/Error.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/IoTString.h b/version2/src/C/IoTString.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/KeyValue.cpp b/version2/src/C/KeyValue.cpp
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/KeyValue.h b/version2/src/C/KeyValue.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/LastMessage.cpp b/version2/src/C/LastMessage.cpp
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/LastMessage.h b/version2/src/C/LastMessage.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/Liveness.h b/version2/src/C/Liveness.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/LocalComm.cpp b/version2/src/C/LocalComm.cpp
old mode 100644 (file)
new mode 100755 (executable)
index a019bc2..b587ba6
--- a/version2/src/C/LocalComm.cpp
+++ b/version2/src/C/LocalComm.cpp
@@ -11,7 +11,7 @@ Array<char> *LocalComm::sendDataToLocalDevice(int64_t deviceId, Array<char> *dat
                // return t2.localCommInput(data);
        } else {
                //throw new Error("Cannot send to deviceId using this local comm");
-               error("Cannot send to deviceId using this local comm");
+               myerror("Cannot send to deviceId using this local comm");
        }
 
        return new Array<char>((uint32_t)0);

diff --git a/version2/src/C/LocalComm.h b/version2/src/C/LocalComm.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/Mac.cpp b/version2/src/C/Mac.cpp
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/Mac.h b/version2/src/C/Mac.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/NewKey.cpp b/version2/src/C/NewKey.cpp
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/NewKey.h b/version2/src/C/NewKey.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/Pair.h b/version2/src/C/Pair.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/PendingTransaction.cpp b/version2/src/C/PendingTransaction.cpp
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/PendingTransaction.h b/version2/src/C/PendingTransaction.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/RejectedMessage.cpp b/version2/src/C/RejectedMessage.cpp
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/RejectedMessage.h b/version2/src/C/RejectedMessage.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/SecureRandom.cpp b/version2/src/C/SecureRandom.cpp
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/SecureRandom.h b/version2/src/C/SecureRandom.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/Slot.cpp b/version2/src/C/Slot.cpp
old mode 100644 (file)
new mode 100755 (executable)
index 2233b0e..d708a79
--- a/version2/src/C/Slot.cpp
+++ b/version2/src/C/Slot.cpp
@@ -12,7 +12,7 @@ Slot::Slot(Table *_table, int64_t _seqnum, int64_t _machineid, Array<char> *_pre
        prevhmac(_prevhmac),
        hmac(_hmac),
        machineid(_machineid),
-       entries(new Vector<Entry *>()),
+       entries(new MyVector<Entry *>()),
        livecount(1),
        seqnumlive(true),
        freespace(SLOT_SIZE - getBaseSize()),
@@ -26,7 +26,7 @@ Slot::Slot(Table *_table, int64_t _seqnum, int64_t _machineid, Array<char> *_pre
        prevhmac(_prevhmac),
        hmac(NULL),
        machineid(_machineid),
-       entries(new Vector<Entry *>()),
+       entries(new MyVector<Entry *>()),
        livecount(1),
        seqnumlive(true),
        freespace(SLOT_SIZE - getBaseSize()),
@@ -40,7 +40,7 @@ Slot::Slot(Table *_table, int64_t _seqnum, int64_t _machineid, int64_t _localSeq
        prevhmac(new Array<char>(HMAC_SIZE)),
        hmac(NULL),
        machineid(_machineid),
-       entries(new Vector<Entry *>()),
+       entries(new MyVector<Entry *>()),
        livecount(1),
        seqnumlive(true),
        freespace(SLOT_SIZE - getBaseSize()),
@@ -83,7 +83,7 @@ bool Slot::hasSpace(Entry *e) {
        return newfreespace >= 0;
 }
 
-Vector<Entry *> *Slot::getEntries() {
+MyVector<Entry *> *Slot::getEntries() {
        return entries;
 }
 
@@ -98,7 +98,7 @@ Slot *Slot_decode(Table *table, Array<char> *array, Mac *mac) {
        bb->get(prevhmac);
        if (!realmac->equals(hmac))
                //throw new Error("Server Error: Invalid HMAC!  Potential Attack!");
-               error("Server Error: Invalid HMAC!  Potential Attack!\n");
+               myerror("Server Error: Invalid HMAC!  Potential Attack!\n");
        delete realmac;
        
        int64_t seqnum = bb->getLong();
@@ -149,8 +149,8 @@ Array<char> *Slot::encode(Mac *mac) {
  * itself.
  */
 
-Vector<Entry *> *Slot::getLiveEntries(bool resize) {
-       Vector<Entry *> *liveEntries = new Vector<Entry *>();
+MyVector<Entry *> *Slot::getLiveEntries(bool resize) {
+       MyVector<Entry *> *liveEntries = new MyVector<Entry *>();
        for (uint ei = 0; ei < entries->size(); ei++) {
                Entry *entry = entries->get(ei);
                if (entry->isLive()) {

diff --git a/version2/src/C/Slot.h b/version2/src/C/Slot.h
old mode 100644 (file)
new mode 100755 (executable)
index d00cf4e..5de0818
--- a/version2/src/C/Slot.h
+++ b/version2/src/C/Slot.h
@@ -17,8 +17,8 @@ private:
        Array<char> *hmac;
        /** Machine that sent this slot. */
        int64_t machineid;
-       /** Vector of entries in this slot. */
-       Vector<Entry *> *entries;
+       /** MyVector of entries in this slot. */
+       MyVector<Entry *> *entries;
        /** Pieces of information that are live. */
        int livecount;
        /** Flag that indicates whether this slot is still live for
@@ -43,10 +43,10 @@ public:
        Entry *addEntry(Entry *e);
        void addShallowEntry(Entry *e);
        bool hasSpace(Entry *e);
-       Vector<Entry *> *getEntries();
+       MyVector<Entry *> *getEntries();
        Array<char> *encode(Mac *mac);
        int getBaseSize() { return 2 * HMAC_SIZE + 2 * sizeof(int64_t) + sizeof(int); }
-       Vector<Entry *> *getLiveEntries(bool resize);
+       MyVector<Entry *> *getLiveEntries(bool resize);
        int64_t getSequenceNumber() { return seqnum; }
        int64_t getMachineID() { return machineid; }
        void setDead();

diff --git a/version2/src/C/SlotBuffer.cpp b/version2/src/C/SlotBuffer.cpp
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/SlotBuffer.h b/version2/src/C/SlotBuffer.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/SlotIndexer.cpp b/version2/src/C/SlotIndexer.cpp
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/SlotIndexer.h b/version2/src/C/SlotIndexer.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/Table.cpp b/version2/src/C/Table.cpp
old mode 100644 (file)
new mode 100755 (executable)
index 896af0a..4db92da
--- a/version2/src/C/Table.cpp
+++ b/version2/src/C/Table.cpp
@@ -66,7 +66,7 @@ Table::Table(IoTString *baseurl, IoTString *password, int64_t _localMachineId, i
        pendingTransactionSpeculatedKeyValueTable(NULL),
        liveNewKeyTable(NULL),
        lastMessageTable(NULL),
-       rejectedMessageWatchVectorTable(NULL),
+       rejectedMessageWatchMyVectorTable(NULL),
        arbitratorTable(NULL),
        liveAbortTable(NULL),
        newTransactionParts(NULL),
@@ -77,7 +77,7 @@ Table::Table(IoTString *baseurl, IoTString *password, int64_t _localMachineId, i
        liveCommitsTable(NULL),
        liveCommitsByKeyTable(NULL),
        lastCommitSeenSequenceNumberByArbitratorTable(NULL),
-       rejectedSlotVector(NULL),
+       rejectedSlotMyVector(NULL),
        pendingTransactionQueue(NULL),
        pendingSendArbitrationRounds(NULL),
        pendingSendArbitrationEntriesToDelete(NULL),
@@ -128,7 +128,7 @@ Table::Table(CloudComm *_cloud, int64_t _localMachineId) :
        pendingTransactionSpeculatedKeyValueTable(NULL),
        liveNewKeyTable(NULL),
        lastMessageTable(NULL),
-       rejectedMessageWatchVectorTable(NULL),
+       rejectedMessageWatchMyVectorTable(NULL),
        arbitratorTable(NULL),
        liveAbortTable(NULL),
        newTransactionParts(NULL),
@@ -139,7 +139,7 @@ Table::Table(CloudComm *_cloud, int64_t _localMachineId) :
        liveCommitsTable(NULL),
        liveCommitsByKeyTable(NULL),
        lastCommitSeenSequenceNumberByArbitratorTable(NULL),
-       rejectedSlotVector(NULL),
+       rejectedSlotMyVector(NULL),
        pendingTransactionQueue(NULL),
        pendingSendArbitrationRounds(NULL),
        pendingSendArbitrationEntriesToDelete(NULL),
@@ -177,10 +177,10 @@ Table::~Table() {
        if (pendingTransactionBuilder != NULL)
                delete pendingTransactionBuilder;
        {
-               SetIterator<int64_t, Hashset<RejectedMessage *> *> *rmit = getKeyIterator(rejectedMessageWatchVectorTable);
+               SetIterator<int64_t, Hashset<RejectedMessage *> *> *rmit = getKeyIterator(rejectedMessageWatchMyVectorTable);
                while(rmit->hasNext()) {
                        int64_t machineid = rmit->next();
-                       Hashset<RejectedMessage *> * rmset = rejectedMessageWatchVectorTable->get(machineid);
+                       Hashset<RejectedMessage *> * rmset = rejectedMessageWatchMyVectorTable->get(machineid);
                        SetIterator<RejectedMessage *, RejectedMessage *> * mit = rmset->iterator();
                        while (mit->hasNext()) {
                                RejectedMessage * rm = mit->next();
@@ -190,7 +190,7 @@ Table::~Table() {
                        delete rmset;
                }
                delete rmit;
-               delete rejectedMessageWatchVectorTable;
+               delete rejectedMessageWatchMyVectorTable;
        }
        delete arbitratorTable;
        delete liveAbortTable;
@@ -253,7 +253,7 @@ Table::~Table() {
        }
        delete liveCommitsByKeyTable;
        delete lastCommitSeenSequenceNumberByArbitratorTable;
-       delete rejectedSlotVector;
+       delete rejectedSlotMyVector;
        {
                uint size = pendingTransactionQueue->size();
                for (uint iter = 0; iter < size; iter++) {
@@ -263,7 +263,7 @@ Table::~Table() {
        }
        delete pendingSendArbitrationEntriesToDelete;
        {
-               SetIterator<Transaction *, Vector<int> *> *trit = (SetIterator<Transaction *, Vector<int> *> *) getKeyIterator(transactionPartsSent);
+               SetIterator<Transaction *, MyVector<int> *> *trit = (SetIterator<Transaction *, MyVector<int> *> *) getKeyIterator(transactionPartsSent);
                while (trit->hasNext()) {
                        Transaction *transaction = trit->next();
                        delete trit->currVal();
@@ -303,7 +303,7 @@ void Table::init() {
        pendingTransactionSpeculatedKeyValueTable = new Hashtable<IoTString *, KeyValue *, uintptr_t, 0, hashString, StringEquals>();
        liveNewKeyTable = new Hashtable<IoTString *, NewKey *, uintptr_t, 0, hashString, StringEquals >();
        lastMessageTable = new Hashtable<int64_t, Pair<int64_t, Liveness *> * >();
-       rejectedMessageWatchVectorTable = new Hashtable<int64_t, Hashset<RejectedMessage *> * >();
+       rejectedMessageWatchMyVectorTable = new Hashtable<int64_t, Hashset<RejectedMessage *> * >();
        arbitratorTable = new Hashtable<IoTString *, int64_t, uintptr_t, 0, hashString, StringEquals>();
        liveAbortTable = new Hashtable<Pair<int64_t, int64_t> *, Abort *, uintptr_t, 0, pairHashFunction, pairEquals>();
        newTransactionParts = new Hashtable<int64_t, Hashtable<Pair<int64_t, int32_t> *, TransactionPart *, uintptr_t, 0, pairHashFunction, pairEquals> *>();
@@ -314,16 +314,16 @@ void Table::init() {
        liveCommitsTable = new Hashtable<int64_t, Hashtable<int64_t, Commit *> * >();
        liveCommitsByKeyTable = new Hashtable<IoTString *, Commit *, uintptr_t, 0, hashString, StringEquals>();
        lastCommitSeenSequenceNumberByArbitratorTable = new Hashtable<int64_t, int64_t>();
-       rejectedSlotVector = new Vector<int64_t>();
-       pendingTransactionQueue = new Vector<Transaction *>();
-       pendingSendArbitrationEntriesToDelete = new Vector<Entry *>();
-       transactionPartsSent = new Hashtable<Transaction *, Vector<int32_t> *>();
+       rejectedSlotMyVector = new MyVector<int64_t>();
+       pendingTransactionQueue = new MyVector<Transaction *>();
+       pendingSendArbitrationEntriesToDelete = new MyVector<Entry *>();
+       transactionPartsSent = new Hashtable<Transaction *, MyVector<int32_t> *>();
        outstandingTransactionStatus = new Hashtable<int64_t, TransactionStatus *>();
        liveAbortsGeneratedByLocal = new Hashtable<int64_t, Abort *>();
        offlineTransactionsCommittedAndAtServer = new Hashset<Pair<int64_t, int64_t> *, uintptr_t, 0, pairHashFunction, pairEquals>();
        localCommunicationTable = new Hashtable<int64_t, Pair<IoTString *, int32_t> *>();
        lastTransactionSeenFromMachineFromServer = new Hashtable<int64_t, int64_t>();
-       pendingSendArbitrationRounds = new Vector<ArbitrationRound *>();
+       pendingSendArbitrationRounds = new MyVector<ArbitrationRound *>();
        lastArbitrationDataLocalSequenceNumberSeenFromArbitrator = new Hashtable<int64_t, int64_t>();
 
        // Other init stuff
@@ -617,7 +617,7 @@ int64_t Table::getLocalSequenceNumber() {
 }
 
 void Table::processTransactionList(bool handlePartial) {
-       SetIterator<Transaction *, Vector<int> *> *trit = (SetIterator<Transaction *, Vector<int> *> *)getKeyIterator(lastTransactionPartsSent);
+       SetIterator<Transaction *, MyVector<int> *> *trit = (SetIterator<Transaction *, MyVector<int> *> *)getKeyIterator(lastTransactionPartsSent);
        while (trit->hasNext()) {
                Transaction *transaction = trit->next();
                transaction->resetServerFailure();
@@ -677,7 +677,7 @@ NewKey * Table::handlePartialSend(NewKey * newKey) {
                        }
                }
                
-               SetIterator<Transaction *, Vector<int> *> *trit = (SetIterator<Transaction *, Vector<int> *> *)getKeyIterator(lastTransactionPartsSent);
+               SetIterator<Transaction *, MyVector<int> *> *trit = (SetIterator<Transaction *, MyVector<int> *> *)getKeyIterator(lastTransactionPartsSent);
                while (trit->hasNext()) {
                        Transaction *transaction = trit->next();
                        transaction->resetServerFailure();
@@ -703,7 +703,7 @@ NewKey * Table::handlePartialSend(NewKey * newKey) {
 
                        processTransactionList(true);
                } else {
-                       SetIterator<Transaction *, Vector<int> *> *trit = (SetIterator<Transaction *, Vector<int> *> *) getKeyIterator(lastTransactionPartsSent);
+                       SetIterator<Transaction *, MyVector<int> *> *trit = (SetIterator<Transaction *, MyVector<int> *> *) getKeyIterator(lastTransactionPartsSent);
                        while (trit->hasNext()) {
                                Transaction *transaction = trit->next();
                                transaction->resetServerFailure();
@@ -725,7 +725,7 @@ NewKey * Table::handlePartialSend(NewKey * newKey) {
 void Table::clearSentParts() {
        // Clear the sent data since we are trying again
        pendingSendArbitrationEntriesToDelete->clear();
-       SetIterator<Transaction *, Vector<int> *> *trit = (SetIterator<Transaction *, Vector<int> *> *) getKeyIterator(transactionPartsSent);
+       SetIterator<Transaction *, MyVector<int> *> *trit = (SetIterator<Transaction *, MyVector<int> *> *) getKeyIterator(transactionPartsSent);
        while (trit->hasNext()) {
                Transaction *transaction = trit->next();
                delete trit->currVal();
@@ -764,7 +764,7 @@ bool Table::sendToServer(NewKey *newKey) {
 
                        if (needsResize) {
                                // Reset which transaction to send
-                               SetIterator<Transaction *, Vector<int> *> *trit = (SetIterator<Transaction *, Vector<int> *> *) getKeyIterator(transactionPartsSent);
+                               SetIterator<Transaction *, MyVector<int> *> *trit = (SetIterator<Transaction *, MyVector<int> *> *) getKeyIterator(transactionPartsSent);
                                while (trit->hasNext()) {
                                        Transaction *transaction = trit->next();
                                        transaction->resetNextPartToSend();
@@ -827,7 +827,7 @@ bool Table::sendToServer(NewKey *newKey) {
                                processTransactionList(false);
                        } else {
                                // Reset which transaction to send
-                               SetIterator<Transaction *, Vector<int> *> *trit = (SetIterator<Transaction *, Vector<int> *> *) getKeyIterator(transactionPartsSent);
+                               SetIterator<Transaction *, MyVector<int> *> *trit = (SetIterator<Transaction *, MyVector<int> *> *) getKeyIterator(transactionPartsSent);
                                while (trit->hasNext()) {
                                        Transaction *transaction = trit->next();
                                        transaction->resetNextPartToSend();
@@ -852,7 +852,7 @@ bool Table::sendToServer(NewKey *newKey) {
                /*      } catch (ServerException *e) {
                if (e->getType() != ServerException_TypeInputTimeout) {
                        // Nothing was able to be sent to the server so just clear these data structures
-                       SetIterator<Transaction *, Vector<int> *> *trit = (SetIterator<Transaction *, Vector<int> *> *) getKeyIterator(transactionPartsSent);
+                       SetIterator<Transaction *, MyVector<int> *> *trit = (SetIterator<Transaction *, MyVector<int> *> *) getKeyIterator(transactionPartsSent);
                        while (trit->hasNext()) {
                                Transaction *transaction = trit->next();
                                transaction->resetNextPartToSend();
@@ -868,7 +868,7 @@ bool Table::sendToServer(NewKey *newKey) {
                        hadPartialSendToServer = true;
 
                        // Nothing was able to be sent to the server so just clear these data structures
-                       SetIterator<Transaction *, Vector<int> *> *trit = (SetIterator<Transaction *, Vector<int> *> *) getKeyIterator(transactionPartsSent);
+                       SetIterator<Transaction *, MyVector<int> *> *trit = (SetIterator<Transaction *, MyVector<int> *> *) getKeyIterator(transactionPartsSent);
                        while (trit->hasNext()) {
                                Transaction *transaction = trit->next();
                                transaction->resetNextPartToSend();
@@ -946,7 +946,7 @@ Pair<bool, bool> Table::sendTransactionToLocal(Transaction *transaction) {
        // Get the size of the send data
        int sendDataSize = sizeof(int32_t) + sizeof(int64_t);
        {
-               Vector<TransactionPart *> *tParts = transaction->getParts();
+               MyVector<TransactionPart *> *tParts = transaction->getParts();
                uint tPartsSize = tParts->size();
                for (uint i = 0; i < tPartsSize; i++) {
                        TransactionPart *part = tParts->get(i);
@@ -967,7 +967,7 @@ Pair<bool, bool> Table::sendTransactionToLocal(Transaction *transaction) {
        bbEncode->putLong(lastArbitrationDataLocalSequenceNumber);
        bbEncode->putInt(transaction->getParts()->size());
        {
-               Vector<TransactionPart *> *tParts = transaction->getParts();
+               MyVector<TransactionPart *> *tParts = transaction->getParts();
                uint tPartsSize = tParts->size();
                for (uint i = 0; i < tPartsSize; i++) {
                        TransactionPart *part = tParts->get(i);
@@ -1063,10 +1063,10 @@ Array<char> *Table::acceptDataFromLocal(Array<char> *data) {
 
        // The data to send back
        int returnDataSize = 0;
-       Vector<Entry *> *unseenArbitrations = new Vector<Entry *>();
+       MyVector<Entry *> *unseenArbitrations = new MyVector<Entry *>();
 
        // Get the aborts to send back
-       Vector<int64_t> *abortLocalSequenceNumbers = new Vector<int64_t>();
+       MyVector<int64_t> *abortLocalSequenceNumbers = new MyVector<int64_t>();
        {
                SetIterator<int64_t, Abort *> *abortit = getKeyIterator(liveAbortsGeneratedByLocal);
                while (abortit->hasNext())
@@ -1091,7 +1091,7 @@ Array<char> *Table::acceptDataFromLocal(Array<char> *data) {
        // Get the commits to send back
        Hashtable<int64_t, Commit *> *commitForClientTable = liveCommitsTable->get(localMachineId);
        if (commitForClientTable != NULL) {
-               Vector<int64_t> *commitLocalSequenceNumbers = new Vector<int64_t>();
+               MyVector<int64_t> *commitLocalSequenceNumbers = new MyVector<int64_t>();
                {
                        SetIterator<int64_t, Commit *> *commitit = getKeyIterator(commitForClientTable);
                        while (commitit->hasNext())
@@ -1110,7 +1110,7 @@ Array<char> *Table::acceptDataFromLocal(Array<char> *data) {
                        }
 
                        {
-                               Vector<CommitPart *> *parts = commit->getParts();
+                               MyVector<CommitPart *> *parts = commit->getParts();
                                uint nParts = parts->size();
                                for (uint i = 0; i < nParts; i++) {
                                        CommitPart *commitPart = parts->get(i);
@@ -1174,7 +1174,7 @@ bool Table::checkSend(Array<Slot *> * array, Slot *checkSlot) {
                Slot *s = array->get(i);
                
                // Process each entry in the slot
-               Vector<Entry *> *entries = s->getEntries();
+               MyVector<Entry *> *entries = s->getEntries();
                uint eSize = entries->size();
                for (uint ei = 0; ei < eSize; ei++) {
                        Entry *entry = entries->get(ei);
@@ -1204,7 +1204,7 @@ bool Table::sendSlotsToServer(Slot *slot, int newSize, bool isNewKey, bool *isIn
        if (*array == NULL) {
                *array = new Array<Slot *>(1);
                (*array)->set(0, slot);
-               rejectedSlotVector->clear();
+               rejectedSlotMyVector->clear();
                *isInserted = false;
                return true;
        } else {
@@ -1217,12 +1217,12 @@ bool Table::sendSlotsToServer(Slot *slot, int newSize, bool isNewKey, bool *isIn
                        *isInserted = checkSend(*array, slot);
 
                        if (!(*isInserted)) {
-                               rejectedSlotVector->add(slot->getSequenceNumber());
+                               rejectedSlotMyVector->add(slot->getSequenceNumber());
                        }
                        
                        return false;
                } else {
-                       rejectedSlotVector->add(slot->getSequenceNumber());
+                       rejectedSlotMyVector->add(slot->getSequenceNumber());
                        *isInserted = false;
                        return false;
                }
@@ -1276,7 +1276,7 @@ bool Table::fillSlot(Slot *slot, bool resize, NewKey *newKeyEntry, int & newSize
                ArbitrationRound *round = pendingSendArbitrationRounds->get(i);
                bool isFull = false;
                round->generateParts();
-               Vector<Entry *> *parts = round->getParts();
+               MyVector<Entry *> *parts = round->getParts();
 
                // Insert pending arbitration data
                uint vsize = parts->size();
@@ -1320,9 +1320,9 @@ bool Table::fillSlot(Slot *slot, bool resize, NewKey *newKeyEntry, int & newSize
 
                        if (slot->hasSpace(part)) {
                                slot->addEntry(part);
-                               Vector<int32_t> *partsSent = transactionPartsSent->get(transaction);
+                               MyVector<int32_t> *partsSent = transactionPartsSent->get(transaction);
                                if (partsSent == NULL) {
-                                       partsSent = new Vector<int32_t>();
+                                       partsSent = new MyVector<int32_t>();
                                        transactionPartsSent->put(transaction, partsSent);
                                }
                                partsSent->add(part->getPartNumber());
@@ -1340,22 +1340,22 @@ bool Table::fillSlot(Slot *slot, bool resize, NewKey *newKeyEntry, int & newSize
 }
 
 void Table::doRejectedMessages(Slot *s) {
-       if (!rejectedSlotVector->isEmpty()) {
+       if (!rejectedSlotMyVector->isEmpty()) {
                /* TODO: We should avoid generating a rejected message entry if
                 * there is already a sufficient entry in the queue (e->g->,
                 * equalsto value of true and same sequence number)->  */
 
-               int64_t old_seqn = rejectedSlotVector->get(0);
-               if (rejectedSlotVector->size() > Table_REJECTED_THRESHOLD) {
-                       int64_t new_seqn = rejectedSlotVector->lastElement();
+               int64_t old_seqn = rejectedSlotMyVector->get(0);
+               if (rejectedSlotMyVector->size() > Table_REJECTED_THRESHOLD) {
+                       int64_t new_seqn = rejectedSlotMyVector->lastElement();
                        RejectedMessage *rm = new RejectedMessage(s, s->getSequenceNumber(), localMachineId, old_seqn, new_seqn, false);
                        s->addShallowEntry(rm);
                } else {
                        int64_t prev_seqn = -1;
                        uint i = 0;
                        /* Go through list of missing messages */
-                       for (; i < rejectedSlotVector->size(); i++) {
-                               int64_t curr_seqn = rejectedSlotVector->get(i);
+                       for (; i < rejectedSlotMyVector->size(); i++) {
+                               int64_t curr_seqn = rejectedSlotMyVector->get(i);
                                Slot *s_msg = buffer->getSlot(curr_seqn);
                                if (s_msg != NULL)
                                        break;
@@ -1367,8 +1367,8 @@ void Table::doRejectedMessages(Slot *s) {
                                s->addShallowEntry(rm);
                        }
                        /* Generate rejected message entries for present messages */
-                       for (; i < rejectedSlotVector->size(); i++) {
-                               int64_t curr_seqn = rejectedSlotVector->get(i);
+                       for (; i < rejectedSlotMyVector->size(); i++) {
+                               int64_t curr_seqn = rejectedSlotMyVector->get(i);
                                Slot *s_msg = buffer->getSlot(curr_seqn);
                                int64_t machineid = s_msg->getMachineID();
                                RejectedMessage *rm = new RejectedMessage(s, s->getSequenceNumber(), machineid, curr_seqn, curr_seqn, true);
@@ -1407,7 +1407,7 @@ ThreeTuple<bool, bool, int64_t> Table::doMandatoryRescue(Slot *slot, bool resize
                seenLiveSlot = true;
 
                // Get all the live entries for a slot
-               Vector<Entry *> *liveEntries = previousSlot->getLiveEntries(resize);
+               MyVector<Entry *> *liveEntries = previousSlot->getLiveEntries(resize);
 
                // Iterate over all the live entries and try to rescue them
                uint lESize = liveEntries->size();
@@ -1442,7 +1442,7 @@ void Table::doOptionalRescue(Slot *s, bool seenliveslot, int64_t seqn, bool resi
                if (!prevslot->isLive())
                        continue;
                seenliveslot = true;
-               Vector<Entry *> *liveentries = prevslot->getLiveEntries(resize);
+               MyVector<Entry *> *liveentries = prevslot->getLiveEntries(resize);
                uint lESize = liveentries->size();
                for (uint i = 0; i < lESize; i++) {
                        Entry *liveentry = liveentries->get(i);
@@ -1711,7 +1711,7 @@ void Table::arbitrateFromServer() {
        }
 
        // Get the transaction sequence numbers and sort from oldest to newest
-       Vector<int64_t> *transactionSequenceNumbers = new Vector<int64_t>();
+       MyVector<int64_t> *transactionSequenceNumbers = new MyVector<int64_t>();
        {
                SetIterator<int64_t, Transaction *> *trit = getKeyIterator(liveTransactionBySequenceNumberTable);
                while (trit->hasNext())
@@ -1818,7 +1818,7 @@ void Table::arbitrateFromServer() {
                // Append all the commit parts to the end of the pending queue
                // waiting for sending to the server
                // Insert the commit so we can process it
-               Vector<CommitPart *> *parts = newCommit->getParts();
+               MyVector<CommitPart *> *parts = newCommit->getParts();
                uint partsSize = parts->size();
                for (uint i = 0; i < partsSize; i++) {
                        CommitPart *commitPart = parts->get(i);
@@ -1834,7 +1834,7 @@ void Table::arbitrateFromServer() {
                if (compactArbitrationData()) {
                        ArbitrationRound *newArbitrationRound = pendingSendArbitrationRounds->get(pendingSendArbitrationRounds->size() - 1);
                        if (newArbitrationRound->getCommit() != NULL) {
-                               Vector<CommitPart *> *parts = newArbitrationRound->getCommit()->getParts();
+                               MyVector<CommitPart *> *parts = newArbitrationRound->getCommit()->getParts();
                                uint partsSize = parts->size();
                                for (uint i = 0; i < partsSize; i++) {
                                        CommitPart *commitPart = parts->get(i);
@@ -1895,7 +1895,7 @@ Pair<bool, bool> Table::arbitrateOnLocalTransaction(Transaction *transaction) {
 
                if (compactArbitrationData()) {
                        ArbitrationRound *newArbitrationRound = pendingSendArbitrationRounds->get(pendingSendArbitrationRounds->size() - 1);
-                       Vector<CommitPart *> *parts = newArbitrationRound->getCommit()->getParts();
+                       MyVector<CommitPart *> *parts = newArbitrationRound->getCommit()->getParts();
                        uint partsSize = parts->size();
                        for (uint i = 0; i < partsSize; i++) {
                                CommitPart *commitPart = parts->get(i);
@@ -1903,7 +1903,7 @@ Pair<bool, bool> Table::arbitrateOnLocalTransaction(Transaction *transaction) {
                        }
                } else {
                        // Insert the commit so we can process it
-                       Vector<CommitPart *> *parts = newCommit->getParts();
+                       MyVector<CommitPart *> *parts = newCommit->getParts();
                        uint partsSize = parts->size();
                        for (uint i = 0; i < partsSize; i++) {
                                CommitPart *commitPart = parts->get(i);
@@ -1949,7 +1949,7 @@ Pair<bool, bool> Table::arbitrateOnLocalTransaction(Transaction *transaction) {
                        if (compactArbitrationData()) {
                                ArbitrationRound *newArbitrationRound = pendingSendArbitrationRounds->get(pendingSendArbitrationRounds->size() - 1);
 
-                               Vector<CommitPart *> *parts = newArbitrationRound->getCommit()->getParts();
+                               MyVector<CommitPart *> *parts = newArbitrationRound->getCommit()->getParts();
                                uint partsSize = parts->size();
                                for (uint i = 0; i < partsSize; i++) {
                                        CommitPart *commitPart = parts->get(i);
@@ -2124,7 +2124,7 @@ bool Table::updateCommittedTable() {
                Hashtable<int64_t, Commit *> *commitForClientTable = liveCommitsTable->get(arbitratorId);
 
                // Sort the commits in order
-               Vector<int64_t> *commitSequenceNumbers = new Vector<int64_t>();
+               MyVector<int64_t> *commitSequenceNumbers = new MyVector<int64_t>();
                {
                        SetIterator<int64_t, Commit *> *clientit = getKeyIterator(commitForClientTable);
                        while (clientit->hasNext())
@@ -2282,7 +2282,7 @@ bool Table::updateSpeculativeTable(bool didProcessNewCommits) {
 
        // Create a list of the transaction sequence numbers and sort them
        // from oldest to newest
-       Vector<int64_t> *transactionSequenceNumbersSorted = new Vector<int64_t>();
+       MyVector<int64_t> *transactionSequenceNumbersSorted = new MyVector<int64_t>();
        {
                SetIterator<int64_t, Transaction *> *trit = getKeyIterator(liveTransactionBySequenceNumberTable);
                while (trit->hasNext())
@@ -2474,7 +2474,7 @@ void Table::processSlot(SlotIndexer *indexer, Slot *slot, bool acceptUpdatesToLo
        updateLastMessage(slot->getMachineID(), slot->getSequenceNumber(), slot, acceptUpdatesToLocal, machineSet);
 
        // Process each entry in the slot
-       Vector<Entry *> *entries = slot->getEntries();
+       MyVector<Entry *> *entries = slot->getEntries();
        uint eSize = entries->size();
        for (uint ei = 0; ei < eSize; ei++) {
                Entry *entry = entries->get(ei);
@@ -2600,7 +2600,7 @@ void Table::processEntry(RejectedMessage *entry, SlotIndexer *indexer) {
                if (entrySequenceNumber < seq) {
                        // Add this rejected message to the set of messages that this
                        // machine ID did not see yet
-                       addWatchVector(lastMessageEntryMachineId, entry);
+                       addWatchMyVector(lastMessageEntryMachineId, entry);
                        // This client did not see this rejected message yet so add it
                        // to the watch set to monitor
                        deviceWatchSet->add(lastMessageEntryMachineId);
@@ -2759,7 +2759,7 @@ void Table::updateLastMessage(int64_t machineId, int64_t seqNum, Liveness *liven
        machineSet->remove(machineId);
 
        // Get the set of rejected messages that this machine Id is has not seen yet
-       Hashset<RejectedMessage *> *watchset = rejectedMessageWatchVectorTable->get(machineId);
+       Hashset<RejectedMessage *> *watchset = rejectedMessageWatchMyVectorTable->get(machineId);
        // If there is a rejected message that this machine Id has not seen yet
        if (watchset != NULL) {
                // Go through each rejected message that this machine Id has not
@@ -2858,12 +2858,12 @@ void Table::updateLastMessage(int64_t machineId, int64_t seqNum, Liveness *liven
  * which clients have seen that rejected message entry and which have
  * not.
  */
-void Table::addWatchVector(int64_t machineId, RejectedMessage *entry) {
-       Hashset<RejectedMessage *> *entries = rejectedMessageWatchVectorTable->get(machineId);
+void Table::addWatchMyVector(int64_t machineId, RejectedMessage *entry) {
+       Hashset<RejectedMessage *> *entries = rejectedMessageWatchMyVectorTable->get(machineId);
        if (entries == NULL) {
                // There is no set for this machine ID yet so create one
                entries = new Hashset<RejectedMessage *>();
-               rejectedMessageWatchVectorTable->put(machineId, entries);
+               rejectedMessageWatchMyVectorTable->put(machineId, entries);
        }
        entries->add(entry);
 }

diff --git a/version2/src/C/Table.h b/version2/src/C/Table.h
old mode 100644 (file)
new mode 100755 (executable)
index 7133277..6df2fd7
--- a/version2/src/C/Table.h
+++ b/version2/src/C/Table.h
@@ -54,8 +54,8 @@ private:
        Slot *lastSlotAttemptedToSend;
        bool lastIsNewKey;
        int lastNewSize;
-       Hashtable<Transaction *, Vector<int32_t> *> *lastTransactionPartsSent;
-       Vector<Entry *> *lastPendingSendArbitrationEntriesToDelete;
+       Hashtable<Transaction *, MyVector<int32_t> *> *lastTransactionPartsSent;
+       MyVector<Entry *> *lastPendingSendArbitrationEntriesToDelete;
        NewKey *lastNewKey;
        void processTransactionList(bool handlePartial);
        void clearSentParts();
@@ -66,7 +66,7 @@ private:
        Hashtable<IoTString *, KeyValue *, uintptr_t, 0, hashString, StringEquals> *pendingTransactionSpeculatedKeyValueTable;  // Table of speculated key value pairs, if there is a speculative value from the pending transactions
        Hashtable<IoTString *, NewKey *, uintptr_t, 0, hashString, StringEquals> *liveNewKeyTable;      // Table of live new keys
        Hashtable<int64_t, Pair<int64_t, Liveness *> *> *lastMessageTable;      // Last message sent by a client machine id -> (Seq Num, Slot or LastMessage);
-       Hashtable<int64_t, Hashset<RejectedMessage *> *> *rejectedMessageWatchVectorTable;      // Table of machine Ids and the set of rejected messages they have not seen yet
+       Hashtable<int64_t, Hashset<RejectedMessage *> *> *rejectedMessageWatchMyVectorTable;    // Table of machine Ids and the set of rejected messages they have not seen yet
        Hashtable<IoTString *, int64_t, uintptr_t, 0, hashString, StringEquals> *arbitratorTable;// Table of keys and their arbitrators
        Hashtable<Pair<int64_t, int64_t> *, Abort *, uintptr_t, 0, pairHashFunction, pairEquals> *liveAbortTable;// Table live abort messages
        Hashtable<int64_t, Hashtable<Pair<int64_t, int32_t> *, TransactionPart *, uintptr_t, 0, pairHashFunction, pairEquals> *> *newTransactionParts;  // transaction parts that are seen in this latest round of slots from the server
@@ -77,11 +77,11 @@ private:
        Hashtable<int64_t, Hashtable<int64_t, Commit *> *> *liveCommitsTable;
        Hashtable<IoTString *, Commit *, uintptr_t, 0, hashString, StringEquals> *liveCommitsByKeyTable;
        Hashtable<int64_t, int64_t> *lastCommitSeenSequenceNumberByArbitratorTable;
-       Vector<int64_t> *rejectedSlotVector;    // Vector of rejected slots that have yet to be sent to the server
-       Vector<Transaction *> *pendingTransactionQueue;
-       Vector<ArbitrationRound *> *pendingSendArbitrationRounds;
-       Vector<Entry *> *pendingSendArbitrationEntriesToDelete;
-       Hashtable<Transaction *, Vector<int32_t> *> *transactionPartsSent;
+       MyVector<int64_t> *rejectedSlotMyVector;        // MyVector of rejected slots that have yet to be sent to the server
+       MyVector<Transaction *> *pendingTransactionQueue;
+       MyVector<ArbitrationRound *> *pendingSendArbitrationRounds;
+       MyVector<Entry *> *pendingSendArbitrationEntriesToDelete;
+       Hashtable<Transaction *, MyVector<int32_t> *> *transactionPartsSent;
        Hashtable<int64_t, TransactionStatus *> *outstandingTransactionStatus;
        Hashtable<int64_t, Abort *> *liveAbortsGeneratedByLocal;
        Hashset<Pair<int64_t, int64_t> *, uintptr_t, 0, pairHashFunction, pairEquals> *offlineTransactionsCommittedAndAtServer;
@@ -234,7 +234,7 @@ private:
         * Add a rejected message entry to the watch set to keep track of which clients have seen that
         * rejected message entry and which have not.
         */
-       void addWatchVector(int64_t machineId, RejectedMessage *entry);
+       void addWatchMyVector(int64_t machineId, RejectedMessage *entry);
 
        /**
         * Check if the HMAC chain is not violated

diff --git a/version2/src/C/TableStatus.cpp b/version2/src/C/TableStatus.cpp
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/TableStatus.h b/version2/src/C/TableStatus.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/ThreeTuple.h b/version2/src/C/ThreeTuple.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/TimingSingleton.h b/version2/src/C/TimingSingleton.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/Transaction.cpp b/version2/src/C/Transaction.cpp
old mode 100644 (file)
new mode 100755 (executable)
index b0d3c5b..e11bbc8
--- a/version2/src/C/Transaction.cpp
+++ b/version2/src/C/Transaction.cpp
@@ -6,10 +6,10 @@
 #include "TransactionStatus.h"
 
 Transaction::Transaction() :
-       parts(new Vector<TransactionPart *>()),
+       parts(new MyVector<TransactionPart *>()),
        partCount(0),
        missingParts(NULL),
-       partsPendingSend(new Vector<int32_t>()),
+       partsPendingSend(new MyVector<int32_t>()),
        fldisComplete(false),
        hasLastPart(false),
        keyValueGuardSet(new Hashset<KeyValue *>()),
@@ -151,7 +151,7 @@ int64_t Transaction::getClientLocalSequenceNumber() {
        return clientLocalSequenceNumber;
 }
 
-Vector<TransactionPart *> *Transaction::getParts() {
+MyVector<TransactionPart *> *Transaction::getParts() {
        return parts;
 }
 
@@ -195,7 +195,7 @@ TransactionStatus *Transaction::getTransactionStatus() {
        return transactionStatus;
 }
 
-void Transaction::removeSentParts(Vector<int32_t> *sentParts) {
+void Transaction::removeSentParts(MyVector<int32_t> *sentParts) {
        nextPartToSend = 0;
        bool changed = false;
        uint lastusedindex = 0;

diff --git a/version2/src/C/Transaction.h b/version2/src/C/Transaction.h
old mode 100644 (file)
new mode 100755 (executable)
index a997382..77f49a5
--- a/version2/src/C/Transaction.h
+++ b/version2/src/C/Transaction.h
@@ -6,10 +6,10 @@
 
 class Transaction {
 private:
-       Vector<TransactionPart *> *parts;
+       MyVector<TransactionPart *> *parts;
        uint partCount;
        Hashset<int32_t> *missingParts;
-       Vector<int32_t> *partsPendingSend;
+       MyVector<int32_t> *partsPendingSend;
        bool fldisComplete;
        bool hasLastPart;
        Hashset<KeyValue *> *keyValueGuardSet;
@@ -36,7 +36,7 @@ public:
        int64_t getSequenceNumber();
        void setSequenceNumber(int64_t _sequenceNumber);
        int64_t getClientLocalSequenceNumber();
-       Vector<TransactionPart *> *getParts();
+       MyVector<TransactionPart *> *getParts();
        bool didSendAPartToServer();
        void resetNextPartToSend();
        TransactionPart *getNextPartToSend();
@@ -45,7 +45,7 @@ public:
        void resetServerFailure();
        void setTransactionStatus(TransactionStatus *_transactionStatus);
        TransactionStatus *getTransactionStatus();
-       void removeSentParts(Vector<int32_t> *sentParts);
+       void removeSentParts(MyVector<int32_t> *sentParts);
        bool didSendAllParts();
        Hashset<KeyValue *> *getKeyValueUpdateSet();
        int getNumberOfParts();

diff --git a/version2/src/C/TransactionPart.cpp b/version2/src/C/TransactionPart.cpp
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/TransactionPart.h b/version2/src/C/TransactionPart.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/TransactionStatus.h b/version2/src/C/TransactionStatus.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/URL.h b/version2/src/C/URL.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/aes.cpp b/version2/src/C/aes.cpp
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/aes.h b/version2/src/C/aes.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/array.h b/version2/src/C/array.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/common.h b/version2/src/C/common.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/hashset.h b/version2/src/C/hashset.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/hashtable.h b/version2/src/C/hashtable.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/mymemory.h b/version2/src/C/mymemory.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/pbkdf2-sha256.cpp b/version2/src/C/pbkdf2-sha256.cpp
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/pbkdf2-sha256.h b/version2/src/C/pbkdf2-sha256.h
old mode 100644 (file)
new mode 100755 (executable)

diff --git a/version2/src/C/vector.h b/version2/src/C/vector.h
old mode 100644 (file)
new mode 100755 (executable)
index 5ca954b..5825408
--- a/version2/src/C/vector.h
+++ b/version2/src/C/vector.h
@@ -4,22 +4,22 @@
 #define VECTOR_DEFCAP 8
 
 template<typename type>
-class Vector {
+class MyVector {
 public:
-       Vector(uint _capacity = VECTOR_DEFCAP) :
+       MyVector(uint _capacity = VECTOR_DEFCAP) :
                fldsize(0),
                capacity(_capacity),
                array((type *) ourmalloc(sizeof(type) * _capacity)) {
        }
 
-       Vector(uint _capacity, type *_array)  :
+       MyVector(uint _capacity, type *_array)  :
                fldsize(_capacity),
                capacity(_capacity),
                array((type *) ourmalloc(sizeof(type) * _capacity)) {
                memcpy(array, _array, capacity * sizeof(type));
        }
 
-       Vector(Vector<type> *v) :
+       MyVector(MyVector<type> *v) :
                fldsize(v->fldsize),
                capacity(v->capacity),
                array((type *) ourmalloc(sizeof(type) * v->capacity)) {
@@ -66,13 +66,13 @@ public:
                fldsize = _size;
        }
 
-       void addAll(Vector<type> *v) {
+       void addAll(MyVector<type> *v) {
                int oldsize = fldsize;
                setSize(fldsize + v->fldsize);
                memcpy(&array[fldsize], v->array, v->fldsize * sizeof(type));
        }
 
-       void removeAll(Vector<type> *v) {
+       void removeAll(MyVector<type> *v) {
                uint vsize = v->size();
                for (uint i = 0; i < vsize; i++)
                        remove(v->get(i));
@@ -121,7 +121,7 @@ public:
                return fldsize == 0;
        }
 
-       ~Vector() {
+       ~MyVector() {
                ourfree(array);
        }