C++ yvector::clear方法代码示例

void CTrieHolder::GetOccurrences (const TerminalString& Text, yvector< COccurrence >& Occurrences) const
{
    int r = 0;
    Occurrences.clear();
    for (size_t i=0; i<Text.size(); i++) {
        r = NextState(r, i, Text[i], Occurrences);
    };
};

static void BuildRuleInfo(const yset<CWorkRule>& rules, yvector<CGLRRuleInfo>& res)
{
    res.clear();
    for (yset<CWorkRule>::const_iterator it = rules.begin(); it != rules.end(); ++it) {
        res.push_back();
        res.back().Init(&*it);
    }
    std::sort(res.begin(), res.end());
}

void TMixedDescriptorPool::CollectFiles(yvector<const TFileDescriptor*>& files) {
    files.clear();
    const yset<Stroka>& fileNames = Database.RequestedFiles();
    for (yset<Stroka>::const_iterator it = fileNames.begin(); it != fileNames.end(); ++it) {
        const TFileDescriptor* fd = FindFileByName(*it);
        if (fd)
            files.push_back(fd);
    }
}

static inline void CustomSplit(const TStringBuf& str, char sep, yvector<TStringBuf>& result)
{
    result.clear();

    typedef TContainerConsumer< yvector<TStringBuf> > TConsumer;
    TConsumer consumer(&result);
    TSkipEmptyTokens<TConsumer> filter(&consumer);
    SplitString(str.data(), str.data() + str.size(), TCharDelimiter<const char>(sep), filter);
}

void CMultiWordCreator::GetFoundWordsInPeriod(const SArtPointer& artP, yvector<SWordHomonymNum>& foundWords,
                                              const CWordsPair& wp) const
{
    foundWords.clear();

    //сначала пытаемся найти среди KwType, которые уже искались на всем предложении, те, которые
    //входят в наш отрезок

    if (artP.HasKWType()) {
        ymap<TKeyWordType, yvector<SWordHomonymNum> >::const_iterator it = m_KW2Words.find(artP.GetKWType());
        if (it != m_KW2Words.end()) {
            const yvector<SWordHomonymNum>& whs = it->second;
            for (size_t i = 0; i < whs.size(); i++) {
                CWord& w = m_Words.GetWord(whs[i]);
                if (wp.Includes(w.GetSourcePair()))
                    foundWords.push_back(whs[i]);
            }
        }
    }

    if (!foundWords.empty())
        return;

    //пытаемся найти среди StrType, которые уже искались на всем предложении, те, которые
    //входят в наш отрезок
    if (artP.HasStrType()) {
        ymap<Wtroka, yvector<SWordHomonymNum> >::const_iterator it = m_Title2Words.find(artP.GetStrType());
        if (it != m_Title2Words.end()) {
            const yvector<SWordHomonymNum>& whs = it->second;
            for (size_t i = 0; i < whs.size(); ++i) {
                CWord& w = m_Words.GetWord(whs[i]);
                if (wp.Includes(w.GetSourcePair()))
                    foundWords.push_back(whs[i]);
            }
        }
    }

    if (!foundWords.empty())
        return;

    //теперь проходим по запомненным отрезкам, для которых хранятся все найденные MultiWords
    ymap<CWordsPair, yvector<SWordHomonymNum> >::const_iterator it = m_FoundWordsByPeriod.find(wp);
    if (it != m_FoundWordsByPeriod.end()) {
        const yvector<SWordHomonymNum>& whs = it->second;
        for (size_t i = 0; i < whs.size(); i++) {
            const CHomonym& h = m_Words[whs[i]];
            if (h.HasArticle(artP, KW_DICT))
                foundWords.push_back(whs[i]);
        }
    }
}

// обычно функция возвращает clause->ToString(),
// если в клаузе есть открывающая кавычка, а нет закрывающей, тогда  функция добавляет к результату
// все слова до закрывающей кавычки
Wtroka CQuotesFinder::FindRightQuoteIfHas(const CWordsPair& PeriodToPrint, int SentNo,
                                          const CWordsPair& GroupToExclude, yvector<SFactAddress>& FioInQuotes)
{
    FioInQuotes.clear();
    CSentenceRusProcessor* pSentPrc = GetSentPrc(SentNo);
    yset<int> QuoteWords;
    Wtroka ClauseStr;
    static const Wtroka COMMA = Wtroka::FromAscii(",");
    for (int i = PeriodToPrint.FirstWord(); i <=  PeriodToPrint.LastWord(); i++) {
        const CWord& w = pSentPrc->m_Words.GetOriginalWord(i);
        if (!GroupToExclude.Contains(i) &&
            !(GroupToExclude.Contains(i - 1) && w.GetText() == COMMA) &&
            !(GroupToExclude.Contains(i + 1) && w.GetText() == COMMA)) {
            ClauseStr += w.GetOriginalText() + ' ';
            QuoteWords.insert(i);
        }
    }

    size_t index = ClauseStr.find('"');
    if (index != Wtroka::npos && ClauseStr.rfind('"') == index) {
        yset<int> AddQuoteWords;
        Wtroka Add;
        // если только одна кавычка, то пойдем искать вторую кавычку
        int i;
        for (i = PeriodToPrint.LastWord()+1; i < (int)pSentPrc->getWordsCount(); i++) {
            const CWord& w = pSentPrc->m_Words.GetOriginalWord(i);
            if (!GroupToExclude.Contains(i)) {
                Add += w.GetOriginalText() + ' ';
                AddQuoteWords.insert(i);
            }
            if (w.HasCloseQuote())
                break;
        }
        if (i != (int)pSentPrc->getWordsCount()) {
            ClauseStr += ' ';
            ClauseStr += Add;
            QuoteWords.insert(AddQuoteWords.begin(), AddQuoteWords.end());
        }

    }

    AddFios(SentNo, QuoteWords, FioInQuotes);

    return ClauseStr;
};

//check an agreement between aux. verbs and predicates of analitical form.
bool CAnalyticFormBuilder::IsAnalyticalVerbForm(int iVerbWrd, int iSWrd, int& VerbHomNo,
                                                yvector<int>& AnalyticHom, bool& b_AddAuxVerbHom)
{
    b_AddAuxVerbHom = false;
    AnalyticHom.clear();

    const CWord& _Be = m_Words.GetWord(m_ClauseWords.at(iVerbWrd));
    const CWord& _Predik = m_Words.GetWord(m_ClauseWords.at(iSWrd));

    //с предикативными значениями "много" и "мало" анал. форм не строить : DIALING
    //с предикативными значениями "много" и "мало" анал. форм строится, но клонируется омоним для вспомогательного глагола
    //if ( ( m_Words[iSWrd].FindLemma("МНОГО") || m_Words[iSWrd].FindLemma("МАЛО") ) && ... )
    if (_Predik.HasPOS(gNumeral) && _Predik.HasPOS(gPraedic))
            b_AddAuxVerbHom = true;

    //14.07.04: отсутствие синтаксиса порождает заплатку:
    //если у потенциального предиката есть омоним Noun, то добавить омоним AuxVerb для вспомогательного глагола,
    //в противном случае, просто изменить часть речи на AuxVerb.
    if (_Predik.HasMorphNoun())
        b_AddAuxVerbHom = true;

    //masks used later (to avoid constructing them repeatedly in loop)
    const TGramBitSet Verb_Infinitive(gVerb, gInfinitive),
                      Infinitive_Imperfect(gInfinitive, gImperfect),
                      Person3_Singular(gPerson3, gSingular),
                      Infinitive_Gerund(gInfinitive, gGerund);

    for (CWord::SHomIt it = _Be.IterHomonyms(); it.Ok(); ++it) {
        VerbHomNo = it.GetID();
        const CHomonym& VerbHom = _Be.GetRusHomonym(VerbHomNo);

        if (VerbHom.Lemma == kByt || (VerbHom.Lemma == kStat && VerbHom.HasAnyOfPOS(Verb_Infinitive))) {
            for (CWord::SHomIt it_predik = _Predik.IterHomonyms(); it_predik.Ok(); ++it_predik) {
                int j = it_predik.GetID();

                const CHomonym& ShortFormHom = _Predik.GetRusHomonym(j);
                if (ShortFormHom.Grammems.HasAll(Infinitive_Imperfect) && (VerbHom.IsFutureTense() || VerbHom.Lemma == kStat))
                    AnalyticHom.push_back(j);

                else if ((ShortFormHom.HasGrammem(gPraedic)) &&
                         (VerbHom.HasGrammem(gNeuter) || (VerbHom.IsFutureTense() && VerbHom.Grammems.HasAll(Person3_Singular))))
                    AnalyticHom.push_back(j);

                else if (ShortFormHom.HasGrammem(gComparative) && ShortFormHom.IsFullAdjective())
                    AnalyticHom.push_back(j);

                else if (ShortFormHom.IsShortAdjectiveOrParticiple()) {
                    // "была", "стал", "был", "было" ...
                    if ((VerbHom.HasGrammem(gSingular) && VerbHom.IsPastTense() &&
                         ShortFormHom.HasGrammem(gSingular) &&
                         (VerbHom.Grammems.All() & ShortFormHom.Grammems.All()).HasAny(NSpike::AllGenders))
                        || (VerbHom.HasGrammem(gPlural) && ShortFormHom.HasGrammem(gPlural))
                        || (!VerbHom.IsPastTense() && VerbHom.HasGrammem(gSingular) && ShortFormHom.HasGrammem(gSingular))
                        || VerbHom.Grammems.HasAny(Infinitive_Gerund))

                        AnalyticHom.push_back(j);
                }
            }
            return AnalyticHom.size() > 0;
        }
    }
    return false;
}