C++ OovString::find方法代码示例

bool ModelStatement::hasBaseClassRef() const
    {
    OovString attrName = getName();
    bool present = attrName.find(getBaseClassMemberRefSep()) != std::string::npos;
    if(!present)
        {
        present = attrName.find(getBaseClassMemberCallSep()) != std::string::npos;
        }
    return(present);
    }

void NameValueRecord::insertLine(OovString lineBuf)
    {
    size_t colonPos = lineBuf.find(mapDelimiter);
    if(colonPos != std::string::npos)
        {
        std::string key = lineBuf.substr(0, colonPos);
        size_t termPos = lineBuf.find('\n');
        std::string value = lineBuf.substr(colonPos+1, termPos-(colonPos+1));
        setNameValue(key, value);
        }
    }

size_t FilePathGetPosSegment(OovStringRef const path, OovStringRef const seg)
{
    OovString lowerPath;
    // Only do case insensitive compares for Windows.
#ifdef __linux__
    lowerPath = path;
#else
    lowerPath.setLowerCase(path);
#endif
    OovString lowerSeg;
#ifdef __linux__
    lowerSeg = seg;
#else
    lowerSeg.setLowerCase(seg);
#endif
    size_t pos = lowerPath.find(lowerSeg);
    size_t foundPos = std::string::npos;
    if(pos != std::string::npos)
    {
        if(pos > 0)
        {
            size_t endPos = pos + lowerSeg.length();
            if(FilePathIsPathSep(path, pos-1) &&
                    FilePathIsPathSep(path, endPos))
            {
                foundPos = pos-1;
            }
        }
    }
    return foundPos;
}

// returns std::string::npos if not found.
static size_t findPathSep(OovStringRef const path, size_t startPos = 0)
{
    const OovString str = path;
    size_t bpos = str.find('\\', startPos);
    size_t fpos = str.find('/', startPos);
    size_t pos = std::string::npos;
    if(bpos != std::string::npos && fpos != std::string::npos)
    {
        pos = (bpos > fpos) ? fpos : bpos;
    }
    else if(bpos != std::string::npos)
        pos = bpos;
    else if(fpos != std::string::npos)
        pos = fpos;
    return pos;
}

static bool mapPath(ZonePathMap const &map, OovString const &origName,
        OovString &newName)
    {
    bool replaced = false;
    size_t starti = 0;
    newName = origName;
    do
        {
        size_t firstFoundi = OovString::npos;
        ZonePathReplaceItem const *repItem = nullptr;
        for(auto const &mapItem : map)
            {
            size_t foundi = newName.find(mapItem.mSearchPath, starti);
            if(foundi < firstFoundi)
                {
                repItem = &mapItem;
                firstFoundi = foundi;
                }
            }
        if(firstFoundi != OovString::npos)
            {
            newName.replace(firstFoundi, repItem->mSearchPath.length(),
                    repItem->mReplacePath);
            starti = firstFoundi + repItem->mReplacePath.length();
            replaced = true;
            }
        else
            starti = OovString::npos;
        } while(starti != OovString::npos);
    return replaced;
    }

static bool isDevelopment()
    {
    static enum eDevel { Uninit, Devel, Deploy } devel;
    if(devel == Uninit)
        {
        OovString path = Project::getBinDirectory();
        size_t pos = path.find("bin");
        if(pos != std::string::npos)
            {
            path.replace(pos, 3, "lib");
            }
        OovStatus status(true, SC_File);
        if(FileIsDirOnDisk(path, status))
            {
            devel = Deploy;
            }
        else
            {
            devel = Devel;
            }
        if(status.needReport())
            {
            status.reported();
            }
        }
    return(devel == Devel);
    }

/// Copy a single source file and make a comment that contains the hit count
/// for each instrumented line.
static void updateCovSourceCounts(OovStringRef const relSrcFn,
        std::vector<int> &counts)
    {
    FilePath srcFn(Project::getCoverageSourceDirectory(), FP_Dir);
    srcFn.appendFile(relSrcFn);
    FilePath dstFn(Project::getCoverageProjectDirectory(), FP_Dir);
    dstFn.appendFile(relSrcFn);
    File srcFile;
    OovStatus status = srcFile.open(srcFn, "r");
    if(status.ok())
        {
        status = FileEnsurePathExists(dstFn);
        if(status.ok())
            {
            File dstFile;
            status = dstFile.open(dstFn, "w");
            if(status.ok())
                {
                char buf[1000];
                size_t instrCount = 0;
                while(srcFile.getString(buf, sizeof(buf), status))
                    {
                    if(strstr(buf, "COV_IN("))
                        {
                        if(instrCount < counts.size())
                            {
                            OovString countStr = "    // ";
                            countStr.appendInt(counts[instrCount]);
                            OovString newStr = buf;
                            size_t pos = newStr.find('\n');
                            newStr.insert(pos, countStr);
                            if(newStr.length() < sizeof(buf)-1)
                                {
                                strcpy(buf, newStr.getStr());
                                }
                            }
                        instrCount++;
                        }
                    status = dstFile.putString(buf);
                    if(!status.ok())
                        {
                        break;
                        }
                    }
                }
            }
        }
    if(status.needReport())
        {
        OovString err = "Unable to transfer coverage ";
        err += srcFn;
        err += " ";
        err += dstFn;
        status.report(ET_Error, err);
        }
    }

OovString Project::getSrcRootDirRelativeSrcFileName(OovStringRef const srcFileName,
        OovStringRef const srcRootDir)
    {
    OovString relSrcFileName = srcFileName;
    size_t pos = relSrcFileName.find(srcRootDir.getStr());
    if(pos != std::string::npos)
        {
        relSrcFileName.erase(pos, srcRootDir.numBytes());
        FilePathRemovePathSep(relSrcFileName, 0);
        }
    return relSrcFileName;
    }

void NameValueRecord::insertBufToMap(OovString const buf)
    {
    size_t pos = 0;
    mNameValues.clear();
    while(pos != std::string::npos)
        {
        size_t endPos = buf.find('\n', pos);
        std::string line(buf, pos, endPos-pos);
        insertLine(line);
        pos = endPos;
        if(pos != std::string::npos)
            pos++;
        }
    }

/// Use the filename to make an identifier.
static std::string makeOrigCovFn(OovStringRef const fn)
    {
    OovString covFn = fn;
    if(covFn.find("COV_") != std::string::npos)
        {
        covFn.erase(0, 4);
        }
    covFn.replaceStrs("_", "/");
    size_t pos = covFn.rfind('/');
    if(pos != std::string::npos)
        {
        covFn.replace(pos, 1, ".");
        }
    return covFn;
    }

OovString const Project::getLibDirectory()
    {
    OovString path = getBinDirectory();
#ifdef __linux__
    // During development, the libs/.so are in the bin dir.
    if(!isDevelopment())
        {
        size_t pos = path.find("bin");
        if(pos != std::string::npos)
            {
            path.replace(pos, 3, "lib");
            }
        }
#endif
    return path;
    }

OovStringVec StringSplit(char const * const str, char const * const delimiterStr)
{
    OovString tempStr = str;
    OovStringVec tokens;
    size_t start = 0;
    size_t end = 0;
    const size_t delimLen = strlen(delimiterStr);
    while(end != std::string::npos)
        {
        end = tempStr.find(delimiterStr, start);
        size_t len = (end == std::string::npos) ? std::string::npos : end - start;
        OovString splitStr = tempStr.substr(start, len);
        tokens.push_back(splitStr);
        start = (( end > (std::string::npos - delimLen)) ?
                std::string::npos : end + delimLen);
        }
    return tokens;
    }

OovStringVec Tokenizer::getDiagResults()
    {
    OovStringVec diagResults;
    if(mTransUnit)
        {
        int numDiags = clang_getNumDiagnostics(mTransUnit);
        for (int i = 0; i<numDiags && diagResults.size() < 10; i++)
            {
            CXDiagnostic diag = clang_getDiagnostic(mTransUnit, i);
//          CXDiagnosticSeverity sev = clang_getDiagnosticSeverity(diag);
//          if(sev >= CXDiagnostic_Error)
            OovString diagStr = getDisposedString(clang_formatDiagnostic(diag,
                clang_defaultDiagnosticDisplayOptions()));
            if(diagStr.find(mSourceFilename) != std::string::npos)
                {
                diagResults.push_back(diagStr);
                }
            }
        }
    return diagResults;
    }

void CompoundValueRef::parseStringRef(OovStringRef const strIn,
        OovStringVec &vec, char delimiter)
    {
    OovString str = strIn;
    size_t startArgPos = 0;
    while(startArgPos != std::string::npos)
        {
        size_t endColonPos = str.find(delimiter, startArgPos);
        std::string tempStr = str.substr(startArgPos, endColonPos-startArgPos);
        // For compatibility with previous files, allow a string that is
        // after the last colon. Previous versions that had the extra string
        // did not allow null strings.
        if(endColonPos != std::string::npos || tempStr.length() > 0)
            {
            vec.push_back(tempStr);
            }
        startArgPos = endColonPos;
        if(startArgPos != std::string::npos)
            startArgPos++;
        }
    }

bool ModelType::isTypedefType(OovString const &name)
    {
    return(name.find("<<type") != std::string::npos);
    }