C++ CompoundValue::parseString方法代码示例

bool ClassDiagram::loadDiagram(File &file)
    {
    NameValueFile nameValFile;
    bool success = nameValFile.readFile(file);
    if(success)
        {
        CompoundValue names;
        names.parseString(nameValFile.getValue("Names"));
        CompoundValue xPositions;
        xPositions.parseString(nameValFile.getValue("XPositions"));
        CompoundValue yPositions;
        yPositions.parseString(nameValFile.getValue("YPositions"));
        std::vector<ClassNode> &nodes = getNodes();
        for(size_t i=0; i<names.size(); i++)
            {
            OovString name = names[i];
            if(i == 0)
                {
                // The node at index zero is the graph key, and is not stored in
                // the graph with a name or type.
                // The node at index one is the first class, which is typically the
                // same as the drawing name.
                eDiagramStorageTypes drawingType;
                OovString drawingName;
                DiagramStorage::getDrawingHeader(nameValFile, drawingType, drawingName);
                // This adds the key automatically as item index zero.
                // Call this function to set the last selected class name for the journal.
                clearGraphAndAddClass(drawingName, ClassGraph::AN_All,
                        ClassDiagram::DEPTH_SINGLE_CLASS, false);
                int x=0;
                int y=0;
                xPositions[i].getInt(0, INT_MAX, x);
                yPositions[i].getInt(0, INT_MAX, y);
                nodes[0].setPosition(GraphPoint(x, y));
                }
            else
                {
                // This will not add duplicates, so if the name is different
                // from the drawingName, it will be added.
                addClass(name, ClassGraph::AN_All,
                    ClassDiagram::DEPTH_SINGLE_CLASS, false);
                }

            auto nodeIter = std::find_if(nodes.begin(), nodes.end(),
                [&name](ClassNode &node)
                { return(node.getType() && name == node.getType()->getName()); });
            if(nodeIter != nodes.end())
                {
                int x=0;
                int y=0;
                xPositions[i].getInt(0, INT_MAX, x);
                yPositions[i].getInt(0, INT_MAX, y);
                nodeIter->setPosition(GraphPoint(x, y));
                }
            }
        }
    return success;
    }

Package AvailablePackages::getPackage(OovStringRef const pkgName) const
    {
    /// @todo - should check if all paths are ok with this.
    Package pkg(pkgName, "/usr");

    TextProcessor proc;
    OovProcessChildArgs args;
    args.addArg("pkg-config");
    args.addArg(pkgName);
    args.addArg("--cflags");
    if(proc.spawn("pkg-config", args.getArgv()))
        {
        CompoundValue pkgflags;
        CompoundValue incFlags;
        CompoundValue cppFlags;
        pkgflags.parseString(proc.mText, ' ');
        for(auto &flag : pkgflags)
            {
            if(flag[0] == '-' && flag[1] == 'I')
                {
                flag.erase(0, 2);
                if(flag.compare(0, pkg.getRootDir().length(), pkg.getRootDir()) == 0)
                    flag.erase(0, pkg.getRootDir().length());
                incFlags.push_back(flag);
                }
            else if(flag[0] == '-')
                cppFlags.push_back(flag);
            }
        pkg.setCompileInfo(incFlags.getAsString(), cppFlags.getAsString());
        }
    args.clearArgs();
    args.addArg("pkg-config");
    args.addArg(pkgName);
    args.addArg("--libs");
    if(proc.spawn("pkg-config", args.getArgv()))
        {
        CompoundValue pkgFlags;
        CompoundValue libFlags;
        CompoundValue linkFlags;
        pkgFlags.parseString(proc.mText, ' ');
        for(auto &flag : pkgFlags)
            {
            if(flag[0] == '-' && flag[1] == 'l')
                {
                flag.erase(0, 2);
                libFlags.push_back(flag);
                }
            else if(flag[0] == '-')
                {
                linkFlags.push_back(flag);
                }
            }
        pkg.setLinkInfo("lib", libFlags.getAsString(), linkFlags.getAsString());
        }
    return pkg;
    }

bool IncDirDependencyMap::includedPathsChanged(OovStringRef includerFn,
        std::set<std::string> const &includedInfoStr) const
    {
    bool changed = false;

    // First check if the includer filename exists in the dependency file.
    OovString origIncludedInfoStr = getValue(includerFn);
    if(origIncludedInfoStr.size() > 0)
        {
        CompoundValue origIncludedInfoCompVal;
        // get the changed time, which is the first value and discard
        // everything else.
        origIncludedInfoCompVal.parseString(origIncludedInfoStr);
        // Check that counts of the number of includes is the same in
        // the new and original map.  This will detect deleted includes.
        if(origIncludedInfoCompVal.size()-IncDirMapNumTimeVals !=
                (includedInfoStr.size() * IncDirMapNumIncPathParts))
            {
            changed = true;
            }
        else
            {
            // Every included file in the new map must exist in the
            // original map.
            for(const auto &included : includedInfoStr)
                {
                CompoundValue incPathParts;
                incPathParts.parseString(included);
                if(incPathParts.size() == 2)
                    {
                    if(std::find(origIncludedInfoCompVal.begin(),
                            origIncludedInfoCompVal.end(), incPathParts[1]) ==
                            origIncludedInfoCompVal.end())
                        {
                        changed = true;
                        }
                    }
                else
                    {
                    changed = true;
                    }
                }
            }
        }
    else
        {
        changed = true;
        }
    return changed;
    }

void OptionsDialog::addConfig()
    {
    GtkEntry *newNameEntry = GTK_ENTRY(Builder::getBuilder()->getWidget("NewConfigNameEntry"));

    // Update the build config option
    std::string compStr = mProjectOptions.getValue(OptBuildConfigs);
    CompoundValue compVal;
    compVal.parseString(compStr);
    OovString newName = Gui::getText(newNameEntry);

    OovStringVec cfgs = compVal;
    cfgs.push_back(BuildConfigAnalysis);
    cfgs.push_back(BuildConfigDebug);
    cfgs.push_back(BuildConfigRelease);
    bool found = std::find(cfgs.begin(), cfgs.end(), newName) != cfgs.end();
    if(!found)
        {
        compVal.addArg(newName);
        mProjectOptions.setNameValue(OptBuildConfigs, compVal.getAsString());

        // Leave what is on the screen, and change the config name.Save the
        // screen data to the new config.
        mCurrentBuildConfig = newName;
    //    ScreenOptions options(mCurrentBuildConfig);
     //   options.screenToOptions();

        updateBuildConfig();
        }
    else
        Gui::messageBox("Configuration already exists", GTK_MESSAGE_INFO);
    }

void TextViewOption::screenToOption(NameValueFile &file) const
    {
    GtkTextView *view = GTK_TEXT_VIEW(Builder::getBuilder()->getWidget(mWidgetName));
    std::string str = Gui::getText(view);
    CompoundValue cppArgs;
    cppArgs.parseString(str, '\n');
    std::string newCppArgsStr = cppArgs.getAsString();
    file.setNameValue(mOptionName, newCppArgsStr);
    }

void TextViewOption::optionToScreen(NameValueFile const &file) const
    {
    CompoundValue cppArgs;
    cppArgs.parseString(file.getValue(mOptionName));
    GtkTextView *view = GTK_TEXT_VIEW(Builder::getBuilder()->getWidget(mWidgetName));
    Gui::clear(view);
    std::string str = cppArgs.getAsString('\n');
    Gui::appendText(view, str);
    }

void ProjectBuildArgs::updateArgs()
    {
    OovStringVec args;
    CompoundValue baseArgs;
    baseArgs.parseString(mBuildEnv.getValue(OptCppArgs));
    for(auto const &arg : baseArgs)
        {
        args.push_back(arg);
        }
    parseArgs(args);
    }

CompoundValue ProjectBuildArgs::getProjectExcludeDirs() const
    {
    CompoundValue val;
    val.parseString(mProjectOptions.getValue(OptProjectExcludeDirs));
// This doesn't work.
//    val.push_back(sCoverageSourceDir);
//    val.push_back(sCoverageProjectDir);
    for(size_t i=0; i<val.size(); i++)
        {
        val[i] = getAbsoluteDirFromSrcRootDirRelativeDir(val[i]);
        }
    return val;
    }

void BuildSettingsDialog::loadToScreen(std::string const &compName)
    {
    if(compName.length())
        {
        GtkComboBoxText *typeBox = GTK_COMBO_BOX_TEXT(Builder::getBuilder()->getWidget(
                "ComponentTypeComboboxtext"));
        GtkTextView *argsView = GTK_TEXT_VIEW(Builder::getBuilder()->getWidget(
                "ComponentBuildArgsTextview"));

        int index = mComponentFile.getComponentType(compName);
        Gui::setSelected(GTK_COMBO_BOX(typeBox), index);

        CompoundValue cppArgs;
        cppArgs.parseString(mComponentFile.getComponentBuildArgs(compName));
        std::string str = cppArgs.getAsString('\n');
        Gui::setText(argsView, str);
        }
    }

void BuildSettingsDialog::saveFromScreen(std::string const &compName)
    {
    GtkComboBoxText *typeBox = GTK_COMBO_BOX_TEXT(Builder::getBuilder()->getWidget(
            "ComponentTypeComboboxtext"));
    GtkTextView *argsView = GTK_TEXT_VIEW(Builder::getBuilder()->getWidget(
            "ComponentBuildArgsTextview"));

    char const * const boxValue = gtk_combo_box_text_get_active_text(typeBox);
    // If the cursor is changed during construction, boxValue will be NULL.
    if(compName.length())
        {
        if(boxValue)
            {
            mComponentFile.setComponentType(compName, boxValue);
            }
        std::string str = Gui::getText(argsView);
        CompoundValue buildArgs;
        buildArgs.parseString(str, '\n');
        std::string newBuildArgsStr = buildArgs.getAsString();
        mComponentFile.setComponentBuildArgs(compName, newBuildArgsStr);
        }
    }

void OptionsDialog::updateBuildConfig()
    {
    if(mBuildConfigList.getSelected().length() == 0)
        {
        mCurrentBuildConfig = BuildConfigAnalysis;
        mBuildConfigList.setSelected(BuildConfigAnalysis);
        }

    mBuildConfigList.clear();
    mBuildConfigList.appendText(BuildConfigAnalysis);
    mBuildConfigList.appendText(BuildConfigDebug);
    mBuildConfigList.appendText(BuildConfigRelease);

    std::string confStr = mProjectOptions.getValue(OptBuildConfigs);
    CompoundValue configVals;
    configVals.parseString(confStr);
    for(const auto &config:configVals)
        {
        mBuildConfigList.appendText(config);
        }
    updateBuildMenu(configVals);
    }