parser.cpp

funambol windows mobile plugin source code, the source code is taken from the funambol site

    // Alert
    pos = 0, previous = 0;
    t = XMLProcessor::copyElementContentLevel(&xml[pos], ALERT, &pos);
    while ((alert = getAlert(t)) != NULL) {
        if (alert) {
            list->add(*alert); // in the ArrayList NULL element cannot be inserted
            deleteAlert(&alert);
        }
        pos += previous;
        previous = pos;
        if (t) { delete [] t; t = NULL; }
        t = XMLProcessor::copyElementContentLevel(&xml[pos], ALERT, &pos);
    }
    if (t) {delete [] t; t = NULL;}
    if (list && list->size() > 0) {
        for (int i = 0; i < list->size(); i++) {
            commands->add(*list->get(i));
        }
    }
    deleteArrayList(&list);

    // Map
    pos = 0, previous = 0;
    t = XMLProcessor::copyElementContentLevel(&xml[pos], MAP, &pos);
    while ((map = getMap(t)) != NULL) {
        if (map) {
            list->add(*map); // in the ArrayList NULL element cannot be inserted
            deleteMap(&map);
        }
        pos += previous;
        previous = pos;
        if (t) { delete [] t; t = NULL; }
        t = XMLProcessor::copyElementContentLevel(&xml[pos], MAP, &pos);
    }
    if (t) {delete [] t; t = NULL;}
    if (list && list->size() > 0) {
        for (int i = 0; i < list->size(); i++) {
            commands->add(*list->get(i));
        }
    }

    deleteArrayList(&list);

    // Get
    pos = 0, previous = 0;
    t = XMLProcessor::copyElementContentLevel(&xml[pos], GET, &pos);
    while ((get = getGet(t)) != NULL) {
        if (get) {
            list->add(*get); // in the ArrayList NULL element cannot be inserted
            deleteGet(&get);
        }
        pos += previous;
        previous = pos;
        if (t) { delete [] t; t = NULL; }
        t = XMLProcessor::copyElementContentLevel(&xml[pos], GET, &pos);
    }
    if (t) {delete [] t; t = NULL;}
    if (list && list->size() > 0) {
        for (int i = 0; i < list->size(); i++) {
            commands->add(*list->get(i));
        }
    }
    deleteArrayList(&list);

    // Exec
    pos = 0, previous = 0;
    t = XMLProcessor::copyElementContentLevel(&xml[pos], EXEC, &pos);
    while ((exec = getExec(t)) != NULL) {
        if (exec) {
            list->add(*exec); // in the ArrayList NULL element cannot be inserted
            deleteExec(&exec);
        }
        pos += previous;
        previous = pos;
        if (t) { delete [] t; t = NULL; }
        t = XMLProcessor::copyElementContentLevel(&xml[pos], EXEC, &pos);
    }
    if(t) {delete [] t; t = NULL;}

    if (list && list->size() > 0) {
        for (int i = 0; i < list->size(); i++) {
            commands->add(*list->get(i));
        }
    }
    deleteArrayList(&list);

    char* element = XMLProcessor::copyElementContentLevel (xml,  SYNC, NULL);

    if (element) {
        sync = getSync(element);
        if (sync) {
            commands->add(*sync);
            deleteSync(&sync);
        }
        safeDel(&element);
    }

    element = XMLProcessor::copyElementContentLevel (xml,  ATOMIC, NULL);

    if (element) {
        atomic = getAtomic(element);
        if (atomic) {
            commands->add(*atomic);
            deleteAtomic(&atomic);
        }
        safeDel(&element);
    }


    if ((cmdID)   ||
        (meta)    ||
        NotZeroArrayLenght(1, commands)) {

        ret = new Sequence(cmdID, noResp, meta, commands);
    }

    deleteMeta(&meta);
    deleteCmdID(&cmdID);
    deleteArrayList(&commands);

    return ret;
}

/*
* The Atomic tag can contains the common commands (Add, Replace, Delete, Copy) and
* Alert
* Exec
* Get
* Map
*
* Atomic
* Sync
* Sequence
*/
Atomic* Parser::getAtomic(const char*xml) {

    Atomic* ret             = NULL;

    Meta*   meta            = NULL;
    BOOL    noResp          = NULL;
    CmdID*  cmdID           = NULL;
    ArrayList* commands     = new ArrayList();
    Sync* sync              = NULL;
    Sequence* sequence      = NULL;
    char* element = NULL;

    Alert* alert            = NULL;
    Map*   map              = NULL;
    Get*   get              = NULL;
    Exec* exec              = NULL;

    ArrayList* list     = new ArrayList();
    unsigned int pos = 0, previous = 0;
    char* t = NULL;
    t = XMLProcessor::copyElementContent(xml, CMD_ID, NULL);
    cmdID    = getCmdID(t);
    if (t) {delete [] t; t = NULL;}
    t = XMLProcessor::copyElementContentLevel(xml,  META  , NULL);
    meta     = getMeta       (t);
    if (t) {delete [] t; t = NULL;}
    t = XMLProcessor::copyElementContent(xml, NO_RESP, NULL);
    noResp   = getNoResp(t);
    if (t) {delete [] t; t = NULL;}
    // list of commands that must not be leaf of Sync and Atomic
    commands = getCommonCommandList(xml, "Sync&Sequence");

    // Alert
    pos = 0, previous = 0;
    t = XMLProcessor::copyElementContentLevel(&xml[pos], ALERT, &pos);
    while ((alert = getAlert(t)) != NULL) {
        if (alert) {
            list->add(*alert); // in the ArrayList NULL element cannot be inserted
            deleteAlert(&alert);
        }
        pos += previous;
        previous = pos;
        if (t) { delete [] t; t = NULL; }
        t = XMLProcessor::copyElementContentLevel(&xml[pos], ALERT, &pos);
    }
    if (t) {delete [] t; t = NULL;}

    if (list && list->size() > 0) {
        for (int i = 0; i < list->size(); i++) {
            commands->add(*list->get(i));
        }
    }
    deleteArrayList(&list);

    // Map
    pos = 0, previous = 0;
    t = XMLProcessor::copyElementContentLevel(&xml[pos], MAP, &pos);
    while ((map = getMap(t)) != NULL) {
        if (map) {
            list->add(*map); // in the ArrayList NULL element cannot be inserted
            deleteMap(&map);
        }
        pos += previous;
        previous = pos;
        if (t) { delete [] t; t = NULL; }
        t = XMLProcessor::copyElementContentLevel(&xml[pos], MAP, &pos);
    }
    if (t) {delete [] t; t = NULL;}

    if (list && list->size() > 0) {
        for (int i = 0; i < list->size(); i++) {
            commands->add(*list->get(i));
        }
    }

    deleteArrayList(&list);

    // Get
    pos = 0, previous = 0;
    t = XMLProcessor::copyElementContentLevel(&xml[pos], GET, &pos);
    while ((get = getGet(t)) != NULL) {
        if (get) {
            list->add(*get); // in the ArrayList NULL element cannot be inserted
            deleteGet(&get);
        }
        pos += previous;
        previous = pos;
        if (t) { delete [] t; t = NULL; }
        t = XMLProcessor::copyElementContentLevel(&xml[pos], GET, &pos);
    }
    if (t) {delete [] t; t = NULL;}

    if (list && list->size() > 0) {
        for (int i = 0; i < list->size(); i++) {
            commands->add(*list->get(i));
        }
    }
    deleteArrayList(&list);

    // Exec
    pos = 0, previous = 0;
    t = XMLProcessor::copyElementContentLevel(&xml[pos], EXEC, &pos);
    while ((exec = getExec(t)) != NULL) {
        if (exec) {
            list->add(*exec); // in the ArrayList NULL element cannot be inserted
            deleteExec(&exec);
        }
        pos += previous;
        previous = pos;
        if (t) { delete [] t; t = NULL; }
        t = XMLProcessor::copyElementContentLevel(&xml[pos], EXEC, &pos);
    }
    if (t) {delete [] t; t = NULL;}

    if (list && list->size() > 0) {
        for (int i = 0; i < list->size(); i++) {
            commands->add(*list->get(i));
        }
    }
    deleteArrayList(&list);

    element = XMLProcessor::copyElementContentLevel (xml,  SYNC , NULL);

    if (element) {
        sync = getSync(element);
        if (sync) {
            commands->add(*sync);
            deleteSync(&sync);
        }
        safeDel(&element);
    }

    element = XMLProcessor::copyElementContentLevel (xml,  SEQUENCE, NULL);

    if (element) {
        sequence = getSequence(element);
        if (sequence) {
            commands->add(*sequence);
            deleteSequence(&sequence);
        }
        safeDel(&element);
    }

    //
    // TBD: Atomic
    //


    if ((cmdID)   ||
        (meta)    ||
        NotZeroArrayLenght(1, commands)) {

        ret = new Atomic(cmdID, noResp, meta, commands);
    }

    deleteMeta(&meta);
    deleteCmdID(&cmdID);
    deleteArrayList(&commands);

    return ret;
}

/*
* Contains the commands that the <sync> tag can have.
*    Add
*    Replace
*    Delete
*    Copy
*    Atomic
*    Map
*    Sync
*/

Sync* Parser::getSync(const char*xml) {

    Sync* ret               = NULL;
    Sequence* sequence      = NULL;
    Atomic* atomic          = NULL;
    Cred*   cred            = NULL;
    Meta*   meta            = NULL;
    BOOL    noResp          = NULL;
    CmdID*  cmdID           = NULL;
    Target* target          = NULL;
    Source* source          = NULL;
    ArrayList* commands     = new ArrayList();
    long numberOfChanges    = -1;
    char* numberOfChangesW = NULL;

    unsigned int pos = 0;
    char* t = NULL;
    t = XMLProcessor::copyElementContent(xml, CMD_ID,  NULL);
    cmdID    = getCmdID      (t);
    if (t) {delete [] t; t = NULL;}
    t = XMLProcessor::copyElementContent(xml, TARGET,  NULL);
    target   = getTarget     (t);
    if (t) {delete [] t; t = NULL;}
    t = XMLProcessor::copyElementContent(xml, SOURCE,  NULL);
    source   = getSource     (t);
    if (t) {delete [] t; t = NULL;}
    t = XMLProcessor::copyElementContentLevel (xml,  META  ,NULL);
    meta     = getMeta       (t);
    if (t) {delete [] t; t = NULL;}
    numberOfChangesW = XMLProcessor::copyElementContent (xml,  NUMBER_OF_CHANGES ,NULL);
    if (numberOfChangesW) {
        numberOfChanges = strtol(numberOfChangesW, NULL, 10);
    }

    t = XMLProcessor::copyElementContent (xml, CRED   ,NULL);
    cred     = getCred       (t);
    if (t) {delete [] t; t = NULL;}
    t = XMLProcessor::copyElementContent (xml, NO_RESP, NULL);
    noResp   = getNoResp    (t);
    if (t) {delete [] t; t = NULL;}
    commands = getCommonCommandList(xml, "Atomic&Sequence");

    char* element = XMLProcessor::copyElementContentExcept(xml,  SEQUENCE, "Atomic", NULL);

    if (element) {
        sequence = getSequence(element);
        if (sequence) {
            commands->add(*sequence);
            deleteSequence(&sequence);
        }
        safeDel(&element);
    }

    element = XMLProcessor::copyElementContentExcept(xml,  ATOMIC, "Atomic&Sequence", NULL);

    if (element) {
        atomic = getAtomic(element);
        if (atomic) {
            commands->add(*atomic);
            deleteAtomic(&atomic);
        }
        safeDel(&element);
    }

    if ((cmdID)   ||
        (cred)    ||
        (target)  ||
        (source)  ||
        (meta)    ||
        NotZeroArrayLenght(1, commands)) {

        ret = new Sync(cmdID, noResp, cred, target, source, meta, numberOfChanges, commands);
    }

    deleteCred(&cred);
    deleteMeta(&meta);
    deleteCmdID(&cmdID);
    deleteTarget(&target);
    deleteSource(&source);
    deleteArrayList(&commands);

    return ret;
}

ArrayList* Parser::getCommonCommandList(const char*xml, const char*except) {

    ArrayList* commands = new ArrayList();
    ArrayList* list = new ArrayList();

    //
    //Delete
    //
    list = getDels(xml, except);
    if (list && list->size() > 0) {
        for (int i = 0; i < list->size(); i++) {
            commands->add(*list->get(i));
        }
    }
    deleteArrayList(&list);

    //
    //Add
    //
    list = getAdds(xml, except);
    if (list && list->size() > 0) {
        for (int i = 0; i < list->size(); i++) {
            commands->add(*list->get(i));
        }
    }
    deleteArrayList(&list);

    //
    //Replace
    //
    list = getReplaces(xml, except);
    if (list && list->size() > 0) {
        for (int i = 0; i < list->size(); i++) {
            commands->add(*list->get(i));
        }
    }
    deleteArrayList(&list);


    //
    //Copy
    //
    list = getCopies(xml, except);
    if (list && list->size() > 0) {
        for (int i = 0; i < list->size(); i++) {
            commands->add(*list->get(i));
        }
    }
    deleteArrayList(&list);

    return commands;