C++ XMLwrapper类代码示例

void Presets::copy(const char *name)
{
    XMLwrapper *xml = new XMLwrapper();

    //used only for the clipboard
    if(name == NULL)
        xml->minimal = false;

    char type[MAX_PRESETTYPE_SIZE];
    strcpy(type, this->type);
    //strcat(type, "n");
    if(name == NULL)
        if(strstr(type, "Plfo") != NULL)
            strcpy(type, "Plfo");

    xml->beginbranch(type);
    add2XML(xml);
    xml->endbranch();

    if(name == NULL)
        presetsstore.copyclipboard(xml, type);
    else
        presetsstore.copypreset(xml, type, name);

    delete (xml);
}

void doArrayPaste(MiddleWare &mw, int field, string url, string type,
        XMLwrapper &xml, Ts&&... args)
{
    //Generate a new object
    T *t = new T(std::forward<Ts>(args)...);

    if(xml.enterbranch(type+"n") == 0) {
        delete t;
        return;
    }
    t->defaults(field);
    t->getfromXMLsection(xml, field);
    xml.exitbranch();

    //Send the pointer
    string path = url+"paste-array";
    char buffer[1024];
    rtosc_message(buffer, 1024, path.c_str(), "bi", sizeof(void*), &t, field);
    if(!Master::ports.apropos(path.c_str()))
        fprintf(stderr, "Warning: Missing Paste URL: '%s'\n", path.c_str());
    //printf("Sending info to '%s'<%d>\n", buffer, field);
    mw.transmitMsg(buffer);

    //Let the pointer be reclaimed later
}

static bvec loadCache(void)
{
    bvec cache;
    XMLwrapper xml;
    xml.loadXMLfile(getCacheName());
    if(xml.enterbranch("bank-cache")) {
        auto nodes = xml.getBranch();

        for(auto node:nodes) {
            BankEntry be;
#define bind(x,y) if(node.has(#x)) {be.x = y(node[#x].c_str());}
            bind(file, string);
            bind(bank, string);
            bind(name, string);
            bind(comments, string);
            bind(author, string);
            bind(type, atoi);
            bind(id, atoi);
            bind(add, atoi);
            bind(pad, atoi);
            bind(sub, atoi);
            bind(time, atoi);
#undef bind
            cache.push_back(be);
        }
    }
    return cache;
}

bool Bank::addtobank(size_t rootID, size_t bankID, int pos, const string filename, const string name)
{    
    BankEntry &bank = roots [rootID].banks [bankID];
    if (pos >= 0 && pos < BANK_SIZE)
    {
        if (bank.instruments [pos].used)
        {
            pos = -1; // force it to find a new free position
        }
    }
    else if (pos >= BANK_SIZE)
        pos = -1;

    if (pos < 0)
    {

        if(!bank.instruments.empty() && bank.instruments.size() > BANK_SIZE)
        {
            pos = bank.instruments.rbegin()->first + 1;
        }
        else
        {
            pos = BANK_SIZE-1;
            while (!emptyslotWithID(rootID, bankID, pos))
            {
                pos -= 1;
                if(pos < 0)
                {
                    break;
                }
            }
        }
    }
    if (pos < 0)
        return -1; // the bank is full

    deletefrombank(rootID, bankID, pos);
    InstrumentEntry &instrRef = getInstrumentReference(rootID, bankID, pos);
    instrRef.used = true;
    instrRef.name = name;
    instrRef.filename = filename;
    instrRef.PADsynth_used = false;
    instrRef.ADDsynth_used = false;
    instrRef.SUBsynth_used = false;

    // see which engines are used
    if (synth->getRuntime().checksynthengines)
    {
        XMLwrapper *xml = new XMLwrapper(synth);
        xml->checkfileinformation(getFullPath(rootID, bankID, pos));
        instrRef.PADsynth_used = xml->information.PADsynth_used;
        instrRef.ADDsynth_used = xml->information.ADDsynth_used;
        instrRef.SUBsynth_used = xml->information.SUBsynth_used;
        delete xml;
    }
    return 0;
}

void FilterParams::add2XMLsection(XMLwrapper& xml, int n)
{
    int nvowel = n;
    for(int nformant = 0; nformant < FF_MAX_FORMANTS; ++nformant) {
        xml.beginbranch("FORMANT", nformant);
        xml.addpar("freq", Pvowels[nvowel].formants[nformant].freq);
        xml.addpar("amp", Pvowels[nvowel].formants[nformant].amp);
        xml.addpar("q", Pvowels[nvowel].formants[nformant].q);
        xml.endbranch();
    }
}

int Part::saveXML(const char *filename)
{
    XMLwrapper xml;

    xml.beginbranch("INSTRUMENT");
    add2XMLinstrument(&xml);
    xml.endbranch();

    int result = xml.saveXMLfile(filename, gzip_compression);
    return result;
}

int Microtonal::saveXML(const char *filename) const
{
    XMLwrapper *xml = new XMLwrapper();

    xml->beginbranch("MICROTONAL");
    add2XML(xml);
    xml->endbranch();

    int result = xml->saveXMLfile(filename);
    delete (xml);
    return result;
}

int Part::loadXMLinstrument(const char *filename)
{
    XMLwrapper xml;
    if(xml.loadXMLfile(filename) < 0) {
        return -1;
    }

    if(xml.enterbranch("INSTRUMENT") == 0)
        return -10;
    getfromXMLinstrument(&xml);
    xml.exitbranch();

    return 0;
}

int Bank::addtobank(int pos, const char *filename, const char *name)
{
    if((pos >= 0) && (pos < BANK_SIZE)) {
        if(ins[pos].used)
            pos = -1;             //force it to find a new free position
    }
    else
    if(pos >= BANK_SIZE)
        pos = -1;


    if(pos < 0) { //find a free position
        for(int i = BANK_SIZE - 1; i >= 0; i--)
            if(!ins[i].used) {
                pos = i;
                break;
            }
        ;
    }

    if(pos < 0)
        return -1;         //the bank is full

    // printf("%s   %d\n",filename,pos);

    deletefrombank(pos);

    ins[pos].used = true;
    snprintf(ins[pos].name, PART_MAX_NAME_LEN, "%s", name);

    snprintf(tmpinsname[pos], PART_MAX_NAME_LEN + 10, " ");

    int len = strlen(filename) + 1 + strlen(dirname);
    ins[pos].filename = new char[len + 2];
    ins[pos].filename[len + 1] = 0;
    snprintf(ins[pos].filename, len + 1, "%s/%s", dirname, filename);

    //see if PADsynth is used
    if(config.cfg.CheckPADsynth) {
        XMLwrapper *xml = new XMLwrapper();
        xml->loadXMLfile(ins[pos].filename);

        ins[pos].info.PADsynth_used = xml->hasPadSynth();
        delete xml;
    }
    else
        ins[pos].info.PADsynth_used = false;

    return 0;
}

void LFOParams::getfromXML(XMLwrapper& xml)
{
    Pfreq       = xml.getparreal("freq", Pfreq, 0.0f, 1.0f);
    Pintensity  = xml.getpar127("intensity", Pintensity);
    Pstartphase = xml.getpar127("start_phase", Pstartphase);
    PLFOtype    = xml.getpar127("lfo_type", PLFOtype);
    Prandomness = xml.getpar127("randomness_amplitude", Prandomness);
    Pfreqrand   = xml.getpar127("randomness_frequency", Pfreqrand);
    Pdelay      = xml.getpar127("delay", Pdelay);
    Pstretch    = xml.getpar127("stretch", Pstretch);
    Pcontinous  = xml.getparbool("continous", Pcontinous);
}

void LFOParams::add2XML(XMLwrapper& xml)
{
    xml.addparreal("freq", Pfreq);
    xml.addpar("intensity", Pintensity);
    xml.addpar("start_phase", Pstartphase);
    xml.addpar("lfo_type", PLFOtype);
    xml.addpar("randomness_amplitude", Prandomness);
    xml.addpar("randomness_frequency", Pfreqrand);
    xml.addpar("delay", Pdelay);
    xml.addpar("stretch", Pstretch);
    xml.addparbool("continous", Pcontinous);
}

void doPaste(MiddleWare &mw, string url, string type, XMLwrapper &xml, Ts&&... args)
{
    //Generate a new object
    T *t = new T(std::forward<Ts>(args)...);
    
    //Old workaround for LFO parameters
    if(strstr(type.c_str(), "Plfo"))
        type = "Plfo";

    if(xml.enterbranch(type) == 0)
        return;

    t->getfromXML(xml);

    //Send the pointer
    string path = url+"paste";
    char buffer[1024];
    rtosc_message(buffer, 1024, path.c_str(), "b", sizeof(void*), &t);
    if(!Master::ports.apropos(path.c_str()))
        fprintf(stderr, "Warning: Missing Paste URL: '%s'\n", path.c_str());
    //printf("Sending info to '%s'\n", buffer);
    mw.transmitMsg(buffer);

    //Let the pointer be reclaimed later
}

void FilterParams::getfromXMLsection(XMLwrapper& xml, int n)
{
    int nvowel = n;
    for(int nformant = 0; nformant < FF_MAX_FORMANTS; ++nformant) {
        if(xml.enterbranch("FORMANT", nformant) == 0)
            continue;
        Pvowels[nvowel].formants[nformant].freq = xml.getpar127(
            "freq",
            Pvowels[nvowel
            ].formants[nformant].freq);
        Pvowels[nvowel].formants[nformant].amp = xml.getpar127(
            "amp",
            Pvowels[nvowel
            ].formants[nformant].amp);
        Pvowels[nvowel].formants[nformant].q =
            xml.getpar127("q", Pvowels[nvowel].formants[nformant].q);
        xml.exitbranch();
    }
}

void presetPasteArray(MiddleWare &mw, std::string url, int field, std::string name)
{
    (void) name;
    //printf("PresetArrayPaste()\n");
    string data = "";
    XMLwrapper xml;
    if(name.empty()) {
        data = mw.getPresetsStore().clipboard.data;
        if(data.length() < 20)
            return;
        if(!xml.putXMLdata(data.c_str()))
            return;
    } else {
        if(xml.loadXMLfile(name))
            return;
    }
    //printf("Performing Paste...\n");
    doClassArrayPaste(getUrlType(url), getUrlPresetType(url, mw), field, mw, url, xml);
}

void Resonance::add2XML(XMLwrapper& xml)
{
    xml.addparbool("enabled", Penabled);

    if((Penabled == 0) && (xml.minimal))
        return;

    xml.addpar("max_db", PmaxdB);
    xml.addpar("center_freq", Pcenterfreq);
    xml.addpar("octaves_freq", Poctavesfreq);
    xml.addparbool("protect_fundamental_frequency", Pprotectthefundamental);
    xml.addpar("resonance_points", N_RES_POINTS);
    for(int i = 0; i < N_RES_POINTS; ++i) {
        xml.beginbranch("RESPOINT", i);
        xml.addpar("val", Prespoints[i]);
        xml.endbranch();
    }
}