formatter.cpp

来自「funambol window mobile客户端源代码」· C++ 代码 · 共 2,229 行 · 第 1/5 页

    }

    StringBuffer* t1 = NULL;
    for (int i=0; i<nProps; ++i) {
        t1 = getProperty((Property*)properties->get(i));
        s.append(t1);
        delete t1; t1 = NULL;
    }

    return getValue(DATA, &s);
}

StringBuffer* Formatter::getDevInf(DevInf* devInf) {

    if (!devInf)
        return NULL;

    StringBuffer* ret = NULL;
    StringBuffer* s   = NULL;

    StringBuffer* verDTD    = NULL;
    StringBuffer* man       = NULL;
    StringBuffer* mod       = NULL;
    StringBuffer* oem       = NULL;
    StringBuffer* fwV       = NULL;
    StringBuffer* swV       = NULL;
    StringBuffer* hwV       = NULL;
    StringBuffer* devID     = NULL;
    StringBuffer* devTyp    = NULL;

    StringBuffer* dataStores= NULL;     //DataStore[]
    //StringBuffer* ctCaps    = NULL;     // CTCap[]
    StringBuffer* exts      = NULL;         // Ext[]

    StringBuffer* utc                    = NULL;
    StringBuffer* supportLargeObjs       = NULL;
    StringBuffer* supportNumberOfChanges = NULL;

    StringBuffer* syncCap   = NULL;

    // verDTD must always be sent!
    verDTD  = getVerDTD         (devInf->getVerDTD());

    // These elements should not be inserted if value is empty.
    man     = getValueNotEmpty  (MAN, devInf->getMan());
    mod     = getValueNotEmpty  (MOD, devInf->getMod());
    oem     = getValueNotEmpty  (OEM, devInf->getOEM());
    fwV     = getValueNotEmpty  (FWV, devInf->getFwV());
    swV     = getValueNotEmpty  (SWV, devInf->getSwV());
    hwV     = getValueNotEmpty  (HWV, devInf->getHwV());
    devID   = getValueNotEmpty  (DEV_ID, devInf->getDevID());
    devTyp  = getValueNotEmpty  (DEV_TYP, devInf->getDevTyp());

    dataStores = getDataStores(devInf->getDataStore());
    syncCap    = getSyncCap(devInf->getSyncCap());
    //ctCaps     = getCTCaps(devInf->getCTCap());
    exts       = getExts(devInf->getExt());

    // These elements are inserted empty if the boolean value is true.
    utc                     = getValue    (UTC, devInf->getUTC());
    supportLargeObjs        = getValue    (SUPPORT_LARGE_OBJECT, devInf->getSupportLargeObjs());
    supportNumberOfChanges  = getValue    (SUPPORT_NUMBER_OF_CHANGES, devInf->getSupportNumberOfChanges());

    if (NotZeroStringBufferLenght(15, verDTD, man, mod, oem, fwV, swV, hwV, devID, devTyp,
                                      dataStores, syncCap, /*ctCaps,*/ utc, supportLargeObjs, supportNumberOfChanges)) {
        s = new StringBuffer();
        s->append(verDTD);
        s->append(man);
        s->append(mod);
        s->append(oem);
        s->append(fwV);
        s->append(swV);
        s->append(hwV);
        s->append(devID);
        s->append(devTyp);
        s->append(utc);
        s->append(supportLargeObjs);
        s->append(supportNumberOfChanges);
        s->append(dataStores);
        //s->append(ctCaps);
        s->append(exts);
        s->append(syncCap);


    }

    // TODO: getValue() should accept const strings
    ret = getValue((char *)DEV_INF, (char *)s->c_str(), (char *)DEVINF);

    deleteAllStringBuffer(16, &s, &verDTD, &man, &mod, &oem, &fwV, &swV, &hwV,
                              &devID, &devTyp, &dataStores, /*&ctCaps,*/ &exts, &utc,
                              &supportLargeObjs, &supportNumberOfChanges);

    return ret;
}

/*
* Returns a series of
*  <Ext> ... </Ext>
*  <Ext> ... </Ext>
*  <Ext> ... </Ext>
*
*/
StringBuffer* Formatter::getExts(ArrayList* exts) {

    if (!exts || !NotZeroArrayLenght(1, exts))
        return NULL;

    StringBuffer* ret = new StringBuffer();
    StringBuffer* tmp = NULL;

    for (int i = 0; i < exts->size(); i++) {
        tmp = getExt(((Ext*)exts->get(i)));
        ret->append(tmp);
        if (tmp) { delete tmp; tmp = NULL; }
    }
    return ret;
}

StringBuffer* Formatter::getExt(Ext* ext) {

    if (!ext)
        return NULL;

    StringBuffer* ret = NULL;
    StringBuffer* s   = NULL;

    StringBuffer*  xNam    = NULL;
    StringBuffer*  xVals   = NULL;

    xNam  = getValue (XNAM, ext->getXNam());
    xVals = getXVals (ext->getXVal());

    if (NotZeroStringBufferLenght(2, xNam, xVals)) {
        s = new StringBuffer();
        s->append(xNam);
        s->append(xVals);
    }

    ret = getValue(EXT, s);
    deleteAllStringBuffer(3, &s, &xNam, &xVals);

    return ret;
}


/*
* Returns a series of
*  <XVal> ... </XVal>
*  <XVal> ... </XVal>
*  <XVal> ... </XVal>
*
*/
StringBuffer* Formatter::getXVals(ArrayList* xVals) {

    if (!xVals || !NotZeroArrayLenght(1, xVals))
        return NULL;

    StringBuffer* ret = new StringBuffer();
    StringBuffer* tmp = NULL;

    for (int i = 0; i < xVals->size(); i++) {
        tmp = getXVal(((StringElement*)xVals->get(i)));
        ret->append(tmp);
        if (tmp) { delete tmp; tmp = NULL; }
    }
    return ret;
}

StringBuffer* Formatter::getXVal(StringElement* xVal) {

    if (!xVal)
        return NULL;

    StringBuffer* ret = NULL;
    ret  = getValue (XVAL, xVal->getValue());
    return ret;
}


/*
* Returns a series of
*  <DataStore> ... </DataStore>
*  <DataStore> ... </DataStore>
*  <DataStore> ... </DataStore>
*
*/
StringBuffer* Formatter::getDataStores(ArrayList* dataStores) {

    if (!dataStores || !NotZeroArrayLenght(1, dataStores))
        return NULL;

    StringBuffer* ret = new StringBuffer();
    StringBuffer* tmp = NULL;

    for (int i = 0; i < dataStores->size(); i++) {
        tmp = getDataStore(((DataStore*)dataStores->get(i)));
        ret->append(tmp);
        if (tmp) { delete tmp; tmp = NULL; }
    }
    return ret;
}

StringBuffer* Formatter::getDataStore(DataStore* dataStore) {

    if (!dataStore)
        return NULL;

    StringBuffer* ret = NULL;
    StringBuffer* s   = NULL;

    StringBuffer*    sourceRef      = NULL;
    StringBuffer*    displayName    = NULL;
    StringBuffer*    maxGUIDSize    = NULL;
    StringBuffer*    rxPref         = NULL;
    StringBuffer*    rx             = NULL; // ContentTypeInfo[]
    StringBuffer*    txPref         = NULL;
    StringBuffer*    tx             = NULL; // ContentTypeInfo[]
    StringBuffer*    ctCaps         = NULL;
    StringBuffer*    dsMem          = NULL;
    StringBuffer*    syncCap        = NULL;

    sourceRef   = getSourceRef(dataStore->getSourceRef());
    displayName = getValue(DISPLAY_NAME, dataStore->getDisplayName());
    int maxGUIDSizeVal = dataStore->getMaxGUIDSize();
    maxGUIDSize = maxGUIDSizeVal > 0 ?
        getValue(MAX_GUID_SIZE, maxGUIDSizeVal) :
        new StringBuffer;
    rxPref      = getContentTypeInfo(dataStore->getRxPref(), RX_PREF);
    rx          = getContentTypeInfos(dataStore->getRx(), RX);
    txPref      = getContentTypeInfo(dataStore->getTxPref(), TX_PREF);
    tx          = getContentTypeInfos(dataStore->getTx(), TX);
    ctCaps      = getCTCaps(dataStore->getCtCaps());
    dsMem       = getDSMem(dataStore->getDSMem());
    syncCap     = getSyncCap(dataStore->getSyncCap());

    if (NotZeroStringBufferLenght(9, sourceRef, displayName, maxGUIDSize, rxPref, rx, txPref, tx, ctCaps, dsMem, syncCap)) {
        s = new StringBuffer();
        s->append(sourceRef);
        s->append(displayName);
        if (maxGUIDSize->length()) {
            s->append(maxGUIDSize);
        }
        s->append(rxPref);
        s->append(rx);
        s->append(txPref);
        s->append(tx);
        s->append(ctCaps);
        s->append(dsMem);
        s->append(syncCap);
    }

    ret = getValue(DATA_STORE, s);
    deleteAllStringBuffer(10, &s, &sourceRef  ,&displayName, &maxGUIDSize, &rxPref, &rx, &txPref, &tx, &ctCaps, &dsMem, &syncCap);

    return ret;
}

StringBuffer* Formatter::getSyncCap(SyncCap* syncCap) {

    if (!syncCap)
        return NULL;

    StringBuffer* ret = NULL;
    StringBuffer* s   = NULL;

    StringBuffer* syncTypes   = NULL;

    syncTypes   = getSyncTypes(syncCap->getSyncType());

    if (NotZeroStringBufferLenght(1, syncTypes)) {
        s = new StringBuffer();
        s->append(syncTypes);
    }

    ret = getValue(SYNC_CAP, s);
    deleteAllStringBuffer(2, &s, &syncTypes);

    return ret;
}

StringBuffer* Formatter::getSyncTypes(ArrayList* syncTypes) {

    if (!syncTypes || !NotZeroArrayLenght(1, syncTypes))
        return NULL;

    StringBuffer* ret = new StringBuffer();
    StringBuffer* tmp = NULL;

    for (int i = 0; i < syncTypes->size(); i++) {
        tmp = getSyncType(((SyncType*)syncTypes->get(i)));
        ret->append(tmp);
        if (tmp) { delete tmp; tmp = NULL; }
    }
    return ret;
}

StringBuffer* Formatter::getSyncType(SyncType* syncType) {

    if (!syncType)
        return NULL;

    StringBuffer* ret = NULL;
    StringBuffer* s   = NULL;
    int  value  = -1;

    value   = syncType->getType();

    if (value > -1) {
        s = new StringBuffer();
        s->append(value);
    }

    ret = getValue(SYNC_TYPE, s);
    deleteAllStringBuffer(1, &s);

    return ret;
}


StringBuffer* Formatter::getDSMem(DSMem* dsMem) {
    if (!dsMem)
        return NULL;

    StringBuffer* ret = new StringBuffer();
    StringBuffer* tmp = NULL;

    tmp = getValue(SHARED_MEM, dsMem->getSharedMem());
    ret->append(tmp);
    if (tmp) { delete tmp; tmp = NULL; }

    tmp = getValue(MAX_MEM,    dsMem->getMaxMem());
    ret->append(tmp);
    if (tmp) { delete tmp; tmp = NULL; }

    tmp = getValue(MAX_ID,     dsMem->getMaxID());
    ret->append(tmp);
    if (tmp) { delete tmp; tmp = NULL; }

    return ret;
}


StringBuffer* Formatter::getContentTypeInfos(ArrayList* contentTypeInfos, const char*TAG) {

    if (!contentTypeInfos || !NotZeroArrayLenght(1, contentTypeInfos))
        return NULL;

    StringBuffer* ret = new StringBuffer();
    StringBuffer* tmp = NULL;

    for (int i = 0; i < contentTypeInfos->size(); i++) {
        tmp = getContentTypeInfo(((ContentTypeInfo*)contentTypeInfos->get(i)), TAG);
        ret->append(tmp);
        if (tmp) { delete tmp; tmp = NULL; }
    }
    return ret;
}


StringBuffer* Formatter::getContentTypeInfo(ContentTypeInfo* contentTypeInfo, const char*TAG) {

    if (!contentTypeInfo)
        return NULL;

    StringBuffer* ret = NULL;
    StringBuffer* s   = NULL;

    StringBuffer*  ctType  = NULL;
    StringBuffer*  verCT   = NULL;

    ctType  = getValue (CT_TYPE, contentTypeInfo->getCTType());
    verCT   = getValue (VER_CT, contentTypeInfo->getVerCT());

    if (NotZeroStringBufferLenght(2, ctType, verCT)) {
        s = new StringBuffer();
        s->append(ctType);
        s->append(verCT);
    }

    ret = getValue(TAG, s);
    deleteAllStringBuffer(3, &s, &ctType, &verCT);

    return ret;
}

StringBuffer* Formatter::getTargetRefs(ArrayList* targetRefs) {

    if (!targetRefs || !NotZeroArrayLenght(1, targetRefs))
        return NULL;

    StringBuffer* ret = new StringBuffer();
    StringBuffer* tmp = NULL;

    for (int i = 0; i < targetRefs->size(); i++) {
        tmp = getTargetRef(((TargetRef*)targetRefs->get(i)));
        ret->append(tmp);
        if (tmp) { delete tmp; tmp = NULL; }
    }
    return ret;
}

StringBuffer* Formatter::getTargetRef(TargetRef* targetRef) {

    if (!targetRef)
        return NULL;

    StringBuffer* ret = NULL;
    StringBuffer* s   = NULL;

    char*       value  = NULL;
    StringBuffer*  target = NULL;

    if ((value = (char*)targetRef->getValue()) != NULL) {
        ;  // the value value is arleady set.
    } else {
        target = getTarget(targetRef->getTarget());
    }

    if (value || NotZeroStringBufferLenght(1, target)) {
        s = new StringBuffer();
        s->append(value);
        s->append(target);
    }

    ret = getValue(TARGET_REF, s);
    deleteAllStringBuffer(2, &s, &target);


    return ret;
}


StringBuffer* Formatter::getSourceRefs(ArrayList* sourceRefs) {

    if (!sourceRefs || !NotZeroArrayLenght(1, sourceRefs))
        return NULL;

    StringBuffer* ret = new StringBuffer();
    StringBuffer* tmp = NULL;

    for (int i = 0; i < sourceRefs->size(); i++) {
        tmp = getSourceRef(((SourceRef*)sourceRefs->get(i)));
        ret->append(tmp);
        if (tmp) { delete tmp;