DataMessage.h

Go to the documentation of this file.

 
#if !defined(_DATAMESSAGE_H_)
#define _DATAMESSAGE_H_
 
// Data Message Version History
// Initial version:
// - data->cid = DATAMESSAGEOLDID
// - does not contain cver, cenc, cyclecputime, cyclewalltime, chaincputime, chainwalltime
// Version 10:
// - data->cid = DATAMESSAGEID
// - now contains cver, cenc, cyclecputime, cyclewalltime, chaincputime, chainwalltime
 
#define CURRENTDATAMESSAGEVERSION 10
 
#include "Types.h"
#include "ObjectIDs.h"
//#include "Collections.h"
#include "Utils.h"
 
namespace cmlabs {

struct DataMessageEntryHeader {
    uint32  size;   
    uint32  cid;    
};

struct DataMessageHeader_Old {
    uint32      size;           // auto
    uint32      cid;            // auto
    uint64      memid;          // auto
    uint64      time;           // auto
    uint64      sendtime;       // api
    uint64      recvtime;       // api
    uint16      origin;         // NodeID, api
    uint16      destination;    // NodeID, api
 
    uint64      ttl;            // spec
    uint16      priority;       // spec
    uint8       policy;         // spec
 
    uint32      from;           // user
    uint32      to;             // user
 
    PsyType     type;           // api/user
    uint32      tag;            // api/user
    uint16      status;         // api/user
    uint64      reference;      // api
    uint64      serial;         // api/user
    PsyContext  contextchange;  // api/user
 
    uint32 userSize;    // size of user data
    uint32 userCount;   // number of user data entries
};

struct DataMessageHeader {
    uint32      size;           
    uint32      cid;            
    uint16      cver;           
    uint16      cenc;           
    uint64      memid;          
    uint64      time;           
    uint64      sendtime;       
    uint64      recvtime;       
    uint16      origin;         
    uint16      destination;    
 
    uint64      ttl;            
    uint16      priority;       
    uint8       policy;         
 
    uint32      from;           
    uint32      to;             
 
    PsyType     type;           
    uint32      tag;            
    uint16      status;         
    uint64      reference;      
    uint64      serial;         
    PsyContext  contextchange;  
 
    uint32 userSize;    
    uint32 userCount;   
 
    uint32      cyclecputime;   
    uint32      cyclewalltime;  
    uint32      chaincputime;   
    uint32      chainwalltime;  
    uint32      chaincount;     
 
    uint32      systemid;       

    std::string toJSON(std::map<uint16, std::string>* subtypes = NULL, std::map<uint16, std::string>* subcontexts = NULL, std::map<uint32, std::string>* compNames = NULL);
    std::string toXML(std::map<uint16, std::string>* subtypes = NULL, std::map<uint16, std::string>* subcontexts = NULL, std::map<uint32, std::string>* compNames = NULL);
};

class DataMessage {
public:
    static DataMessage* FindClosestMessage(uint64 t, std::map<uint64, DataMessage*> &messages);

    static bool ConvertDataFromOlderMessageFormat(const char* data, char **newData);

    static bool UnitTest();

    DataMessage();
    DataMessage(PsyType type, uint32 from);
    DataMessage(PsyType type, uint32 from, uint32 to, uint64 ttl = 0, uint16 priority = 0);
    DataMessage(PsyType type, uint32 from, uint32 to, uint32 tag, uint64 time, uint64 ttl = 0, uint16 priority = 0);
    DataMessage(char* data, bool copy = false);
    DataMessage(const char* data);
    DataMessage(const DataMessage& msg);
    DataMessage(const char* data, uint32 maxDraftSize);
    DataMessage(const DataMessage& msg, uint32 maxDraftSize);
    ~DataMessage();

    DataMessage* copy() {
        return new DataMessage((const char*)(this->data));
    }

    
    const char* swapMessageData(const char* data);
    
    bool fillInDraftUserDataFrom(const char* data, uint32 maxDraftSize);

    bool isValid() {return data && GetObjID(data) == DATAMESSAGEID; }
 
    // User
    
    
    uint32 getContentType(const char* key);
    
    
    uint32 getContentSize(const char* key);

 
    bool getAsBool(const char* key);

    
    std::string getAsString(const char* key);

 
    int64 getAsInt(const char* key);

 
    uint64 getAsTime(const char* key);

 
    float64 getAsFloat(const char* key);

    
    uint64 getTime(const char* key);
    
    
    const char* getString(const char* key);
    
    
    const char* getString(const char* key, uint32 &size);
    
    
    bool getInt(const char* key, int64& value);
    
    
    bool getDouble(const char* key, double& value);
    
    
    bool getFloat(const char* key, float64& value);
    
    
    const char* getData(const char* key, uint32& size);
    
    
    char* getDataCopy(const char* key, uint32& size);
    
    
    DataMessage* getAttachedMessageCopy(const char* key);
 
   
    
    
    
    uint64 getTime(const char* key, bool& success);
   
    
    
    const char* getString(const char* key, bool& success);
    
    
    const char* getString(const char* key, uint32 &size, bool& success);
    
    
    
    int64 getInt(const char* key, bool& success);
    
    
    double getDouble(const char* key, bool& success);
    
    
    float64 getFloat(const char* key, bool& success);
    
    
    const char* getData(const char* key, uint32& size, bool& success);
    
    
    char* getDataCopy(const char* key, uint32& size, bool& success);
    
    
    DataMessage* getAttachedMessageCopy(const char* key, bool& success);
 
    
    
    int64 getInt(const char* key);
    
    
    double getDouble(const char* key);
    
   
    
    float64 getFloat(const char* key);
 
    // *** setting all of the above, returns success or fail (usually because the message is not valid)
    
    bool setTime(const char* key, uint64 value);
    
    bool setString(const char* key, const char* value);
    
    bool setInt(const char* key, int64 value);
    
    bool setDouble(const char* key, double value);
    
    bool setFloat(const char* key, float64 value);
    
    bool setData(const char* key, const char* value, uint32 size);
    
    bool setAttachedMessage(const char* key, DataMessage* msg);

    uint32 getUserSize() {
        return data->userSize;
    }

    uint32 getUserCount() {
        return data->userCount;
    }
 
    // Arrays
    // *** Same as above for single values, but now getting and setting entries in arrays
    // myval[0] = val, myval[1] = val, myval[2] = val, etc.
 
    enum KeyType {NONE, SINGLE, ARRAY, MAP};

 
    KeyType getKeyType(const char* key);

    bool isArrayContent(const char* key);

    bool isMapContent(const char* key);

    bool isSingleValue(const char* key);
 

    bool hasKey(const char* key);

    bool hasString(const char* key);

    bool hasInteger(const char* key);

    bool hasFloat(const char* key);

    bool hasTime(const char* key);

    bool hasData(const char* key);

    bool hasMessage(const char* key);
 

    uint32 getContentType(int64 i, const char* key);
    
    uint32 getContentSize(int64 i, const char* key);
     
    uint64 getTime(int64 i, const char* key);
    
    std::string getAsString(int64 i, const char* key);
    
    int64 getAsInt(int64 i, const char* key);

    uint64 getAsTime(int64 i, const char* key);

    float64 getAsFloat(int64 i, const char* key);

    const char* getString(int64 i, const char* key);
    
    const char* getString(int64 i, const char* key, uint32 &size);
    
    bool getInt(int64 i, const char* key, int64& value);
    
    bool getDouble(int64 i, const char* key, double& value);
    
    bool getFloat(int64 i, const char* key, float64& value);
    
    int64 getInt(int64 i, const char* key, bool& success);
    double getDouble(int64 i, const char* key, bool& success);
    float64 getFloat(int64 i, const char* key, bool& success);
    int64 getInt(int64 i, const char* key);
    double getDouble(int64 i, const char* key);
    float64 getFloat(int64 i, const char* key);
    
    const char* getData(int64 i, const char* key, uint32& size);
    
    char* getDataCopy(int64 i, const char* key, uint32& size);
    
    DataMessage* getAttachedMessageCopy(int64 i, const char* key);

    
    bool setTime(int64 i, const char* key, uint64 value);
    
    bool setString(int64 i, const char* key, const char* value);
    
    bool setInt(int64 i, const char* key, int64 value);
    
    bool setDouble(int64 i, const char* key, double value);
    
    bool setFloat(int64 i, const char* key, float64 value);
    bool setData(int64 i, const char* key, const char* value, uint32 size);
    //    bool setData(int64 i, const char* key, const void* value, uint32 size);
    
    bool setAttachedMessage(int64 i, const char* key, DataMessage* msg);
 
    // *** Same as above but reading whole arrays in one go
    std::map<int64, uint64> getTimeArray(const char* key);
    std::map<int64, std::string> getAsStringArray(const char* key);
    std::map<int64, int64> getAsIntArray(const char* key);
    std::map<int64, float64> getAsFloatArray(const char* key);
    std::map<int64, std::string> getStringArray(const char* key);
    std::map<int64, int64> getIntArray(const char* key);
    std::map<int64, double> getDoubleArray(const char* key);
    std::map<int64, float64> getFloatArray(const char* key);
    std::map<int64, DataMessage*> getAttachedMessageArray(const char* key);

    uint32 getArraySize(const char* key);

    uint32 getArrayCount(const char* key);

    uint32 getMapSize(const char* key);

    uint32 getMapCount(const char* key);
 

    // *** Same as above but setting whole arrays in one go
    bool setTimeArray(const char* key, std::map<int64, uint64>& map);
    
    bool setStringArray(const char* key, std::map<int64, std::string>& map);
    
    bool setIntArray(const char* key, std::map<int64, int64>& map);
    
    bool setDoubleArray(const char* key, std::map<int64, double>& map);
    
    bool setFloatArray(const char* key, std::map<int64, float64>& map);
    
    bool setAttachedMessageArray(const char* key, std::map<int64, DataMessage*>& map);
 
    // Maps
    
    // *** Same as for arrays, but now with maps
    // myval["up"] = val, myval["down"] = val, myval["left"] = val, etc.
    
    uint32 getContentType(const char* idx, const char* key);
    
    uint32 getContentSize(const char* idx, const char* key);
    
    uint64 getTime(const char* idx, const char* key);
    std::string getAsString(const char* idx, const char* key);
    int64 getAsInt(const char* idx, const char* key);
    uint64 getAsTime(const char* idx, const char* key);
    float64 getAsFloat(const char* idx, const char* key);
    const char* getString(const char* idx, const char* key);
    const char* getString(const char* idx, const char* key, uint32 &size);
    
    bool getInt(const char* idx, const char* key, int64& value);
    bool getDouble(const char* idx, const char* key, double& value);
    bool getFloat(const char* idx, const char* key, float64& value);
    int64 getInt(const char* idx, const char* key, bool& success);
    double getDouble(const char* idx, const char* key, bool& success);
    float64 getFloat(const char* idx, const char* key, bool& success);
    int64 getInt(const char* idx, const char* key);
    double getDouble(const char* idx, const char* key);
    float64 getFloat(const char* idx, const char* key);
    const char* getData(const char* idx, const char* key, uint32& size);
    
    char* getDataCopy(const char* idx, const char* key, uint32& size);
    DataMessage* getAttachedMessageCopy(const char* idx, const char* key);
    bool setTime(const char* idx, const char* key, uint64 value);
    bool setString(const char* idx, const char* key, const char* value);
    bool setInt(const char* idx, const char* key, int64 value);
    bool setDouble(const char* idx, const char* key, double value);
    bool setFloat(const char* idx, const char* key, float64 value);
    bool setData(const char* idx, const char* key, const char* value, uint32 size);
    bool setAttachedMessage(const char* idx, const char* key, DataMessage* msg);

    std::map<std::string, uint64> getTimeMap(const char* key);
    std::map<std::string, std::string> getAsStringMap(const char* key);
    std::map<std::string, int64> getAsIntMap(const char* key);
    std::map<std::string, float64> getAsFloatMap(const char* key);
    std::map<std::string, std::string> getStringMap(const char* key);
    std::map<std::string, int64> getIntMap(const char* key);
    std::map<std::string, double> getDoubleMap(const char* key);
    std::map<std::string, float64> getFloatMap(const char* key);
    std::map<std::string, DataMessage*> getAttachedMessageMap(const char* key);
    bool setTimeMap(const char* key, std::map<std::string, uint64>& map);
    bool setStringMap(const char* key, std::map<std::string, std::string>& map);
    bool setIntMap(const char* key, std::map<std::string, int64>& map);
    bool setDoubleMap(const char* key, std::map<std::string, double>& map);
    bool setFloatMap(const char* key, std::map<std::string, float64>& map);
    bool setAttachedMessageMap(const char* key, std::map<std::string, DataMessage*>& map);

    
    
    std::string toJSON(std::map<uint16, std::string>* subtypes = NULL, std::map<uint16, std::string>* subcontexts = NULL, std::map<uint32, std::string>* compNames = NULL);
    
    
    std::string toXML(std::map<uint16, std::string>* subtypes = NULL, std::map<uint16, std::string>* subcontexts = NULL, std::map<uint32, std::string>* compNames = NULL);

 
    std::string toCSV(const char* separator = NULL, const char* preample = NULL, std::map<uint16, std::string>* subtypes = NULL, std::map<uint16, std::string>* subcontexts = NULL, std::map<uint32, std::string>* compNames = NULL);

 
    static std::string GetCSVHeader(const char* separator = NULL, const char* preample = NULL);
 

    uint32 copyUserEntriesFromMessage(DataMessage* msg);

    std::string getUserEntriesAsString();

    std::string getUserEntriesAsJSON(bool asText);
 
 
    // API - inline

    char* getRawData() {
        if (data->cid != DATAMESSAGEID) return NULL;
        return (char*)data;
    }

 
    uint16 getOrigin() {
        if (data->cid != DATAMESSAGEID) return 0;
        return data->origin;
    }

    uint16 getDestination() {
        if (data->cid != DATAMESSAGEID) return 0;
        return data->destination;
    }

    bool setOrigin(uint16 addr) {
        if (data->cid != DATAMESSAGEID) return false;
        data->origin = addr;
        return true;
    }

    bool setDestination(uint16 addr) {
        if (data->cid != DATAMESSAGEID) return false;
        data->destination = addr;
        return true;
    }

    uint32 getSize() {
        if (data->cid != DATAMESSAGEID) return 0;
        return data->size;
    }

    bool setMultiple(uint32 from, uint32 to, uint32 tag, uint64 ttl, uint8 policy, uint64 sendtime) {
        if (data->cid != DATAMESSAGEID) return false;
        if (from) data->from = from;
        if (to) data->to = to;
        if (tag) data->tag = tag;
        if (ttl) data->ttl = ttl;
        if (policy) data->policy = policy;
        if (sendtime) data->sendtime = sendtime;
        return true;
    }

    uint32 getTag() {
        if (data->cid != DATAMESSAGEID) return 0;
        return data->tag;
    }

    bool setTag(uint32 tag) {
        if (data->cid != DATAMESSAGEID) return false;
        data->tag = tag;
        return true;
    }

    uint64 getReference() {
        if (data->cid != DATAMESSAGEID) return 0;
        return data->reference;
    }

    bool setReference(uint64 ref) {
        if (data->cid != DATAMESSAGEID) return false;
        data->reference = ref;
        return true;
    }
 

    uint32 getSystemID() {
        if (data->cid != DATAMESSAGEID) return 0;
        return data->systemid;
    }

    bool setSystemID(uint32 id) {
        if (data->cid != DATAMESSAGEID) return false;
        data->systemid = id;
        return true;
    }

    uint64 getMemID() {
        if (data->cid != DATAMESSAGEID) return 0;
        return data->memid;
    }

    bool setMemID(uint64 id) {
        if (data->cid != DATAMESSAGEID) return false;
        data->memid = id;
        return true;
    }

    uint32 getFrom() {
        if (data->cid != DATAMESSAGEID) return 0;
        return data->from;
    }

 
    bool setFrom(uint32 from) {
        if (data->cid != DATAMESSAGEID) return false;
        data->from = from;
        return true;
    }

 
    uint32 getTo() {
        if (data->cid != DATAMESSAGEID) return 0;
        return data->to;
    }

 
    bool setTo(uint32 to) {
        if (data->cid != DATAMESSAGEID) return false;
        data->to = to;
        return true;
    }

 
    PsyType getType() {
        PsyType t = NOTYPE;
        if (data->cid != DATAMESSAGEID) return t;
        return data->type;
    }

 
    bool setType(PsyType &type) {
        if (data->cid != DATAMESSAGEID) return false;
        data->type = type;
        return true;
    }

 
    PsyContext getContextChange() {
        PsyContext c = NOCONTEXT;
        if (data->cid != DATAMESSAGEID) return c;
        return data->contextchange;
    }

 
    bool setContextChange(PsyContext& context) {
        if (data->cid != DATAMESSAGEID) return false;
        data->contextchange = context;
        return true;
    }

 
    uint64 getTTL() {
        if (data->cid != DATAMESSAGEID) return 0;
        return data->ttl;
    }

 
    uint64 getEOL() {
        if (data->cid != DATAMESSAGEID) return 0;
        if (!data->ttl)
            return 0;
        return data->time + data->ttl;
    }

 
    bool setTTL(uint64 ttl) {
        if (data->cid != DATAMESSAGEID) return false;
        data->ttl = ttl;
        return true;
    }

 
    bool setEOL(uint64 eol) {
        if (data->cid != DATAMESSAGEID) return false;
        int64 ttl = eol - data->time;
        if (ttl > 0) {
            data->ttl = (uint64)ttl;
            return true;
        }
        else
            return false;
    }

 
    uint16 getPriority() {
        if (data->cid != DATAMESSAGEID) return 0;
        return data->priority;
    }

 
    bool setPriority(uint16 priority) {
        if (data->cid != DATAMESSAGEID) return false;
        data->priority = priority;
        return true;
    }

 
    uint8 getPolicy() {
        if (data->cid != DATAMESSAGEID) return 0;
        return data->policy;
    }

 
    bool setPolicy(uint8 policy) {
        if (data->cid != DATAMESSAGEID) return false;
        data->policy = policy;
        return true;
    }

 
    uint64 getSendTime() {
        if (data->cid != DATAMESSAGEID) return 0;
        return data->sendtime;
    }

 
    bool setSendTime(uint64 time) {
        if (data->cid != DATAMESSAGEID) return false;
        data->sendtime = time;
        return true;
    }

 
    uint64 getRecvTime() {
        if (data->cid != DATAMESSAGEID) return 0;
        return data->recvtime;
    }

 
    bool setRecvTime(uint64 time) {
        if (data->cid != DATAMESSAGEID) return false;
        data->recvtime = time;
        return true;
    }

 
    uint64 getCreatedTime() {
        if (data->cid != DATAMESSAGEID) return 0;
        return data->time;
    }

 
    bool setCreatedTime(uint64 t) {
        if (data->cid != DATAMESSAGEID) return 0;
        data->time = t;
        return true;
    }

 
    uint16 getStatus() {
        if (data->cid != DATAMESSAGEID) return 0;
        return data->status;
    }

 
    bool setStatus(uint16 status) {
        if (data->cid != DATAMESSAGEID) return false;
        data->status = status;
        return true;
    }

 
    uint64 getSerial() {
        if (data->cid != DATAMESSAGEID) return 0;
        return data->serial;
    }

 
    bool setSerial(uint64 serial) {
        if (data->cid != DATAMESSAGEID) return false;
        data->serial = serial;
        return true;
    }
 
 
 
 
 
 
 
 

 
    bool addTimeUsage(uint32 cycleCPUTime, uint32 cycleWallTime, uint32 chainCPUTime = 0, uint32 chainWallTime = 0, uint32 chainCount = 0);
 

 
    uint16 getCycleCPUTime() {
        if (data->cid != DATAMESSAGEID) return 0;
        return data->cyclecputime;
    }

 
    bool setCycleCPUTime(uint32 t) {
        if (data->cid != DATAMESSAGEID) return false;
        data->cyclecputime = t;
        return true;
    }
 
 
 

 
    uint16 getCycleWallTime() {
        if (data->cid != DATAMESSAGEID) return 0;
        return data->cyclewalltime;
    }

 
    bool setCycleWallTime(uint32 t) {
        if (data->cid != DATAMESSAGEID) return false;
        data->cyclewalltime = t;
        return true;
    }
 
 
 
 

 
    uint16 getChainCPUTime() {
        if (data->cid != DATAMESSAGEID) return 0;
        return data->chaincputime;
    }

 
    bool setChainCPUTime(uint32 t) {
        if (data->cid != DATAMESSAGEID) return false;
        data->chaincputime = t;
        return true;
    }
 
 
 

 
    uint16 getChainWallTime() {
        if (data->cid != DATAMESSAGEID) return 0;
        return data->chainwalltime;
    }

 
    bool setChainWallTime(uint32 t) {
        if (data->cid != DATAMESSAGEID) return false;
        data->chainwalltime = t;
        return true;
    }
 
 

 
    uint32 getChainCount() {
        if (data->cid != DATAMESSAGEID) return 0;
        return data->chaincount;
    }

 
    bool setChainCount(uint32 count) {
        if (data->cid != DATAMESSAGEID) return false;
        data->chaincount= count;
        return true;
    }

 
    bool deleteEntry(const char* key) {
        if (data->cid != DATAMESSAGEID) return false;
        return removeEntry(key);
    }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

    DataMessageHeader* data;
 
    mutable std::string _lastFindKey;           
    mutable char* _lastFindKeyResult = NULL;    

    void invalidateFindKeyCache() {
        _lastFindKey.clear();
        _lastFindKeyResult = NULL;
    }
 
protected:
    bool setRawData(const char* key, const char* value, uint32 size, uint32 datatype);

    char* findKey(const char* key) {
        if (data->cid != DATAMESSAGEID) return NULL;
        if (!_lastFindKey.empty() && stricmp(key, _lastFindKey.c_str()) == 0)
            return _lastFindKeyResult;
        char* src = (char*)data + sizeof(DataMessageHeader);
        char* srcEnd = (char*)data + data->size;
        while (src < srcEnd) {
            if (((DataMessageEntryHeader*)src)->cid == CONSTCHARID) {
                if (stricmp(key, src+sizeof(DataMessageEntryHeader)) == 0) {
                    _lastFindKey = key;
                    _lastFindKeyResult = src;
                    return src;
                }
            }
            src += ((DataMessageEntryHeader*)src)->size;
        }
        _lastFindKey = key;
        _lastFindKeyResult = NULL;
        return NULL;
    }

 
    char* findEntry(const char* key) {
        char* src = findKey(key);
        if (src == NULL) return NULL;
        return src + sizeof(DataMessageEntryHeader) + strlen(key) + 1;
    }

 
    bool removeEntry(const char* key) {
        char* src = findKey(key);
        if (src == NULL) return true;
        ((DataMessageEntryHeader*)src)->cid = UNUSEDID;
        data->userCount--;
        data->userSize -= ((DataMessageEntryHeader*)src)->size;
        invalidateFindKeyCache();
        return true;
    }

 
    char* findSpace(uint32 space) {
        if (data->cid != DATAMESSAGEID) return NULL;
        char* src = (char*)data + sizeof(DataMessageHeader);
        char* srcEnd = (char*)data + data->size;
        while (src < srcEnd) {
            if ( (((DataMessageEntryHeader*)src)->cid == UNUSEDID) &&
                (((DataMessageEntryHeader*)src)->size == space)) {
                // Used to allow anything smaller, but that needs fixing permanently first
                // (((DataMessageEntryHeader*)src)->size >= space) ) {
                    return src;
            }
            src += ((DataMessageEntryHeader*)src)->size;
        }
        return NULL;
    }
 
};
 
} // namespace cmlabs
 
#endif //_DATAMESSAGE_H_