Object.cpp

Go to the documentation of this file.

/***************************** License **********************************

 Copyright (C) 2008 by Communicative Machines
 http://www.cmlabs.com   All rights reserved.

 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) any later version.

 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

************************************************************************/
// Object.cpp: implementation of the Object class.
//
//////////////////////////////////////////////////////////////////////

#include "Object.h"

#include "XMLParser.h"
#include "UninstantiatedXMLObject.h"

// Including all the objects we wish to auto convert from XML
#include "AutoXML.cheader"

#ifdef WIN32
#else
        #include "sysdep.h"
        #include "uuid.h"
        #include "uuidlib.h"
#endif


namespace cmlabs {

static int processid = 0;

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

Object::Object()
{
        unitTestLog = NULL;
}

Object::~Object()
{
}

bool Object::equals(const Object* o2) const
{
        return (this == o2);
}

int Object::compare(const Object* o2) const {
        return 0;
}

bool Object::unitTest()
{
        // Should be overwritten!!!
        return false;
}

JString Object::print() {
        return getClass();
}

JString Object::toHTML() {
        return print();
}

JString Object::toXML() {
        return this->print();
}

bool Object::fromXML(const JString& xml) {

        if (xml.length() == 0)
                return false;

        XMLParser* xmlParser = new XMLParser();
        xmlParser->parse(xml);
        bool ret = fromXML(xmlParser->getRootNode());
        delete(xmlParser);
        return ret;
}

bool Object::fromXML(XMLNode* node) {
        return true;
}


Object* Object::createObjectFromXML(const JString& xml) {
        if (xml.length() == 0)
                return NULL;

        XMLParser* xmlParser = new XMLParser();
        xmlParser->parse(xml);
        XMLNode* rootNode = xmlParser->getRootNode();
        Object* obj = createObjectFromXML(rootNode);
        delete(xmlParser);
        return obj;
}

Object* Object::createObjectFromXML(XMLNode* rootNode) {

        if (rootNode == NULL) return NULL;

        JString tagName = rootNode->getTag();

        Object* obj = NULL;

        if (tagName.equalsIgnoreCase("UninstantiatedXMLObject")) {
                // Create an instance of the object UninstantiatedXMLObject
                obj = (Object*) new UninstantiatedXMLObject(rootNode);
        }
        
        #include "AutoXML.code"

        else {
                if (DEBUGLEVEL(KITCHENSINK)) {
                        printf("\n[Object] ################# Object::createObjectFromXML: %s unsupported #################\n\n", (char*) tagName);
                }
                // Create an instance of the object UninstantiatedXMLObject
                obj = (Object*) new UninstantiatedXMLObject(rootNode);
        }

        return obj;

/*      // Find the first tag "<xxxxx yyyyy zzzzz>"
        int n = xml.indexOf("<");
        int m = xml.indexOf(">");

        if ((m < n) || (n < 0) || (m < 0))
                return NULL;

        JString str = xml.substring(n+1, m);

        if (str.length() == 0)
                return NULL;

        // Now str contains "xxxxx yyyyy zzzzz"
        
        Collection oc = str.split(" ");

        str = oc.get(0);

        if (str.length() == 0)
                return NULL;

        Object* obj = NULL;

        // Now str contains "xxxxx" = the name of the object class

        if (str.equals("message")) {
                obj = (Object*) new Message(xml);
        }
        else if (str.equals("collection")) {
                obj = (Object*) new CollectionBase(xml);
        }
        else if (str.equals("string")) {
                JString* newstr = new JString();
                newstr->fromXML(xml);
                obj = newstr;
        }
        else if (str.equals("tcplocation")) {
                obj = (Object*) new TCPLocation(xml);
        }
        else if (str.equals("httprequest")) {
                obj = (Object*) new HTTPRequest(xml);
        }
        else {
                if (DEBUGLEVEL(KITCHENSINK)) {
                        printf("\n[Object] ################# Object::createObjectFromXML: %s unsupported #################\n\n", (char*) str);
                }
        }

        return obj;
        */
}

double Object::getRandomNumber() {
        
        double d = 0;
        double t = (1.0/((RAND_MAX + 1.0)*(RAND_MAX + 1.0)*(RAND_MAX + 1.0)));
    do {
       d = (rand () * ((RAND_MAX + 1.0) * (RAND_MAX + 1.0))
          + rand () * (RAND_MAX + 1.0)
          + rand ()) * t;
    } while (d >= 1); /* Round off */
    return d;
}

JString Object::getCoreLibraryVersion() {
        return CLVERSION;
}

JString Object::createUniqueID() {
        JString str = "";
        #ifdef WIN32
                #ifdef _WIN32_WCE

                        SYSTEMTIME systime;
                        FILETIME filetime;

                        // construct GUID
                        GetSystemTime(&systime);
                        SystemTimeToFileTime(&systime,&filetime);
                        DWORD tick=GetTickCount();
                        DWORD highWord=filetime.dwHighDateTime+0x146BF4;

                        str = JString::format("%08.8x-%04.4x-%04.4x-%04.4x-%04.4x%04.4x%04.4x",
                                filetime.dwLowDateTime,
                                LOWORD(highWord),
                                HIWORD(highWord |0x10000000),
                                LOWORD(rand()),
                                HIWORD(tick),
                                LOWORD(tick),
                                LOWORD(rand()));

                        // str = JString(rand());
                #else
                        unsigned char* chstr;
                        UUID uuid;
                        // Creates the safe UUID without embedded hardware info
                        UuidCreate(&uuid);
                        // Creates the standard UUID with embedded hardware info like other OSes
                        // UuidCreateSequential(&uuid);
                        UuidToString(&uuid, &chstr);
                        str = (char*) chstr;
                        RpcStringFree(&chstr);
                        //printf("***** UUID: %s\n", (char*) str);
                        //str.wait(5000);
                #endif
        #else
            uuid__t u;
            uuid_create(&u);
                char s[40];
                sprintf(s, "%8.8x-%4.4x-%4.4x-%2.2x%2.2x-%2.2x%2.2x%2.2x%2.2x%2.2x%2.2x",
                        u.time_low, u.time_mid, u.time_hi_and_version, u.clock_seq_hi_and_reserved, u.clock_seq_low,
                        u.node[0], u.node[1], u.node[2], u.node[3], u.node[4], u.node[5]);
                        str = s;
                //printf("***** UUID: %s\n", (char*) str);
                //str.wait(5000);
        //      uuid_t uuid;
        //      char uuidstr[40];
        //      uuid_generate(uuid);
        //      uuid_unparse(uuid, uuidstr);
        //      str = uuidstr;
        #endif // WIN32
        return str;
}

JString Object::createUniqueID(const JString& title) {
        if (title.length() > 0)
                return JString::format("%s:%s", (char*) title, (char*) createUniqueID());
        else
                return createUniqueID();
}

JString Object::extractIDLabel(const JString& id) {
        const char *pos = id, *p;
        while ( (p = strstr((const char*)pos, ":")) != NULL)
                pos = p+1;
        if (pos <= id)
                return "";
        return id.substring(0, pos-id-1);
}

void Object::addUnitTestLog(const JString& str) {

        // printf(">>> %s\n", (char*) str); fflush(stdout);
        JString s = JString(unitTestLog) + str + "\n";
        delete [] unitTestLog;
        int len;
        unitTestLog = s.getCharCopy(len);

        /* if (unitTestLog == NULL) {
                unitTestLog = new char[30000];
                unitTestLog[0] = 0;
        }
        
        printf("Creating unitTestLog: %s\n", (char*)str);
        unitTestLog = strcat(unitTestLog, (char*) str);*/

//      unitTestLog += str + "\n";
}


JString Object::getUnitTestLog() {
        if (unitTestLog != NULL) {
                JString str = unitTestLog;
                delete [] unitTestLog;
                unitTestLog = NULL;
                return str;
        }
        else
                return "";
}

Object* Object::clone() const {
        return NULL;
}

bool Object::isSameClass(const Object* o2) const {
        if (o2 == NULL)
                return false;
        try {
                if ((typeid(*this) == typeid(*o2)) != 0) {
                        return true;
                }
                else {
                        // Not same class, run additional test
                        return this->getClass().equals(o2->getClass());
                }
        }
        catch(...) {}
        printf("Object::isSameClass Exception\n");

        return this->getClass().equals(o2->getClass());

//      return false;
}

JString Object::getClass() const {
//      #ifdef __TYPEINFO__
        const char* str;
        try {
                str = typeid(*this).name();
        }
        catch(...) {
                printf("Object::getClass Exception reading Object TypeInfo String\n");
                return "";
        }

        try {
                const char* str_object;
                const char* str_cmlabs = strstr(str, "cmlabs");
                if (str_cmlabs == NULL) {
                        // printf("Object::getClass: Non CoreLibrary Object '%s'\n", (char*)str);
                        return str;
                }

                // The Win32 way: "class cmlabs::MyClass" ("class MyClass")
                if (strstr(str, "class") == str) {
                        if (strlen(str_cmlabs) > 8) {
                                str_object = str_cmlabs + 8;
                                return str_object;
                        }
                }
                // The Linux way: "N6cmlabs7MessageE" ("7MyClass")
                else if (strstr(str, "N6cmlabs") == str) {
                        if (strlen(str_cmlabs) > 7) {
                                str_object = str_cmlabs + 6;
                                int count = atoi(str_object);
                                int len = 1;
                                if (count > 9)
                                        len = 2;
                                if (count > 99)
                                        len = 3;
                                // now we know to copy from str_object + len and count chars
                                char name[256];
                                memcpy(name, str_object+len, count);
                                name[count] = 0;
                                return name;
                        }
                }

                printf("Object::getClass: Unknown Object TypeInfo String: %s\n", (char*)str);
                return str;

/*              JString str = typeid(*this).name();
                // The Win32 way: "class cmlabs::MyClass" ("class MyClass")
                if (str.startsWith("class ")) {
                        Collection oc = str.splitOnWhiteSpaces();
                        if (oc.getCount() < 2)
                                return "Object";
                        return oc.get(1);
                }
                // The Linux way: "N6cmlabs7MessageE" ("7MyClass")
                else if ( (n=str.toInt()) > 0) {
                        JString pre = JString(n);
                        str = str.substring(pre.length());
                        return str;
                }
                else {
                        printf("typeid: %s\n", (char*)str);
                }*/
        }
        catch(...) {
                printf("Object::getClass Exception: Unknown Object TypeInfo String: %s\n", (char*)str);
                return "Object";
        }
//      #endif // __TYPEINFO__
}


bool Object::wait(long ms) {

        #ifdef WIN32
                if (ms <= 0)
                        Sleep(0);
                else
                        Sleep(ms);
        #else
                if (ms <= 0)
                        sched_yield();
                else
                        usleep(ms * 1000);
        #endif // WIN32

        return true;
}
/*
bool Object::wait(long ms) const {

        #ifdef WIN32
                if (ms <= 0)
                        Sleep(0);
                else
                        Sleep(ms);
        #else
                if (ms <= 0)
                        sched_yield();
                else
                        usleep(ms * 1000);
        #endif // WIN32

        return true;
}
*/
int Object::getProcID() {

        int id;

        #ifdef WIN32
                id = GetCurrentProcessId();
        #else
                if (processid == 0)
                        processid = getpid();
                id = processid;
        #endif // WIN32

        return id;
}

//! Get the size of any binary data
long Object::getBinarySize(int chunk) {
        return 0;
}

//! Get the number of data chunks
int Object::getBinaryChunkCount() {
        return 0;
}

//! Get a pointer to the binary data at chunk number 'chunk'
long Object::toBinaryBuffer(int chunk, char* buffer, int maxlen) {
        return 0;
}

//! Set the data after separate reception
bool Object::fromBinaryBuffer(int chunk, char* buffer, long len) {
        return false;
}

bool Object::isCollection() const {
        return false;
}

//! Get total size of payload
unsigned long Object::getPayloadSize() const {
        return 0;
}

unsigned long Object::getHash() const {
        unsigned long key = (unsigned long) this;
        return (key >> 3) * 2654435761u;
        // 32-bit integer hash function
        //key += ~(key << 15);
        //key ^=  (key >>> 10);
        //key +=  (key << 3);
        //key ^=  (key >>> 6);
        //key += ~(key << 11);
        //key ^=  (key >>> 16);
        // 64-bit integer hash function
        //key += ~(key << 32);
        //key ^= (key >>> 22);
        //key += ~(key << 13);
        //key ^= (key >>> 8);
        //key += (key << 3);
        //key ^= (key >>> 15);
        //key += ~(key << 27);
        //key ^= (key >>> 31);
}


SysInfo Object::getSystemInfo() {
        SysInfo info;
        info.update();
        return info;
}



ObjectLink::ObjectLink() {
        object = NULL;
        active = NULL;
        stopUsing = false;
}

ObjectLink::~ObjectLink() {
        *active = false;
}

Object* ObjectLink::clone() const {
        return new ObjectLink();
}

JString ObjectLink::toXML() {return "<objectlink />";}

bool ObjectLink::isValid() {
        return ((object != NULL) && (!stopUsing));
}


ObjectLinkProvider::ObjectLinkProvider(ObjectLink* link, Object* object) {
        active = ( (link != NULL) && (object != NULL) );
        this->link = link;
        if (link != NULL) {
                link->active = &this->active;
                link->object = object;
                link->stopUsing = false;
        }
}

ObjectLinkProvider::~ObjectLinkProvider() {
        if (isInUse()) {
                link->stopUsing = true;
                link->object = NULL;
        }
}

Object* ObjectLinkProvider::clone() const {
        return new ObjectLinkProvider(NULL, NULL);
}

bool ObjectLinkProvider::isInUse() {
        return active;
}

bool ObjectLinkProvider::stopUsingMe() {
        link->stopUsing = true;
        return true;
}










} // namespace cmlabs

---