示例#1
0
文件: mapa.cpp 项目: lenis96/proyecto
void mapa::eliminarConcepto(concepto c){
    QMutableListIterator <concepto> i (listaConceptos);
    QMutableListIterator <QPair <concepto,concepto> > j(listaParejas);
    j.toFront();
    while(j.hasNext()){
        if(j.peekNext().first.getNumConcepto()==c.getNumConcepto() || j.peekNext().second.getNumConcepto()==c.getNumConcepto()){
            j.next();
            j.remove();
        }
        else{
            j.next();
        }
    }
    i.toFront();
    while(i.hasNext()){
        if(i.peekNext().getNumConcepto()==c.getNumConcepto()){
            i.next();
            i.remove();
            qDebug()<<"va a borrar";
        }
        else{
            i.next();
        }
    }
}
示例#2
0
//---------------------------------------------------------------------------
//  optimize
//
//! Optimize the search specification for fast searches without making any
//! semantic changes.  Detect conflicts in certain specifications (e.g.
//! minimum length greater than maximum length), and detect constraints
//! implicit in certain specifications (e.g. Type I Sevens must have a length
//! of exactly 7 letters).
//
//! @param lexicon the lexicon for which this search is to be used
//---------------------------------------------------------------------------
void
SearchSpec::optimize(const QString& lexicon)
{
    QList<SearchCondition> newConditions;
    QList<SearchCondition> wildcardConditions;

    const int MAX_ANAGRAMS = 65535;
    QString mustInclude;
    QString mustExclude;
    int minLength = 0;
    int maxLength = MAX_WORD_LEN + 1;
    int minAnagrams = 0;
    int maxAnagrams = MAX_ANAGRAMS;
    int minNumVowels = 0;
    int maxNumVowels = MAX_WORD_LEN + 1;
    int minNumUniqueLetters = 0;
    int maxNumUniqueLetters = MAX_WORD_LEN + 1;
    int minPointValue = 0;
    int maxPointValue = 10 * MAX_WORD_LEN + 1;
    QMap<QString, bool> inLexicons;
    inLexicons[lexicon] = true;

    QMutableListIterator<SearchCondition> it (conditions);
    while (it.hasNext()) {

        SearchCondition& condition = it.next();
        int minValue = condition.minValue;
        int maxValue = condition.maxValue;
        QString stringValue = condition.stringValue;
        bool negated = condition.negated;
        switch (condition.type) {

            case SearchCondition::PatternMatch:
            case SearchCondition::AnagramMatch:
            case SearchCondition::SubanagramMatch: {

                condition.stringValue = stringValue =
                    Auxil::getCanonicalSearchString(stringValue);
                if (stringValue.contains("*")) {
                    newConditions.append(condition);
                    break;
                }

                bool wildcard = (stringValue.contains("[") ||
                                 stringValue.contains("?"));

                if (!negated) {
                    int length = stringValue.length();
                    if (stringValue.contains("[")) {
                        int subtract = 0;
                        bool inCharClass = false;
                        for (int i = 0; i < length; ++i) {
                            QChar c = stringValue.at(i);
                            if (c == '[')
                                inCharClass = true;
                            else if (c == ']') {
                                inCharClass = false;
                                ++subtract;
                            }
                            else if (inCharClass)
                                ++subtract;
                        }
                        length -= subtract;
                    }

                    if ((condition.type == SearchCondition::PatternMatch) ||
                        (condition.type == SearchCondition::AnagramMatch))
                    {
                        if ((length < minLength) || (length > maxLength)) {
                            conditions.clear();
                            return;
                        }
                        minLength = maxLength = length;
                    }
                    else {
                        if (length < minLength) {
                            conditions.clear();
                            return;
                        }
                        else if (length < maxLength)
                            maxLength = length;
                    }
                }

                if (wildcard)
                    wildcardConditions.append(condition);
                else
                    newConditions.append(condition);
            }
            break;

            case SearchCondition::Length:
            if (minValue > minLength)
                minLength = minValue;
            if (maxValue < maxLength)
                maxLength = maxValue;
            if ((minLength > MAX_WORD_LEN) || (maxLength <= 0) ||
                (minLength > maxLength))
            {
                conditions.clear();
                return;
            }
            break;

            case SearchCondition::IncludeLetters:
            condition.stringValue = stringValue =
                Auxil::getCanonicalSearchString(stringValue);
            if (negated) {
                if (!mustInclude.isEmpty()) {
                    for (int i = 0; i < int(stringValue.length()); ++i) {
                        if (mustInclude.contains(stringValue.at(i))) {
                            conditions.clear();
                            return;
                        }
                    }
                }
                mustExclude += stringValue;
                newConditions.append(condition);
            }
            else {
                if (!mustExclude.isEmpty()) {
                    for (int i = 0; i < int(stringValue.length()); ++i) {
                        if (mustExclude.contains(stringValue.at(i))) {
                            conditions.clear();
                            return;
                        }
                    }
                }
                mustInclude += stringValue;
                newConditions.append(condition);
            }
            break;

            case SearchCondition::BelongToGroup: {
                SearchSet ss = Auxil::stringToSearchSet(stringValue);
                if (ss == UnknownSearchSet)
                    break;

                else if (!negated) {
                    SearchCondition addCondition;
                    switch (ss) {
                        case SetHighFives:
                        addCondition.type = SearchCondition::Length;
                        addCondition.minValue = 5;
                        addCondition.maxValue = 5;
                        break;

                        case SetTypeOneSevens:
                        case SetTypeTwoSevens:
                        case SetTypeThreeSevens:
                        addCondition.type = SearchCondition::Length;
                        addCondition.minValue = 7;
                        addCondition.maxValue = 7;
                        break;

                        case SetTypeOneEights:
                        case SetEightsFromSevenLetterStems:
                        addCondition.type = SearchCondition::Length;
                        addCondition.minValue = 8;
                        addCondition.maxValue = 8;
                        break;

                        default: break;
                    }

                    if (addCondition.type !=
                        SearchCondition::UnknownSearchType)
                    {
                        newConditions.append(addCondition);
                    }
                }
            }
            newConditions.append(condition);
            break;

            case SearchCondition::InLexicon:
            if (inLexicons.contains(stringValue) &&
                inLexicons[stringValue] == negated)
            {
                conditions.clear();
                return;
            }
            inLexicons[stringValue] = negated;
            newConditions.append(condition);
            break;

            case SearchCondition::NumAnagrams:
            if (minValue > minAnagrams)
                minAnagrams = minValue;
            if (maxValue < maxAnagrams)
                maxAnagrams = maxValue;
            if ((minAnagrams > MAX_ANAGRAMS) || (maxAnagrams <= 0) ||
                (minAnagrams > maxAnagrams))
            {
                conditions.clear();
                return;
            }
            break;

            case SearchCondition::NumVowels:
            if (minValue > minNumVowels)
                minNumVowels = minValue;
            if (maxValue < maxNumVowels)
                maxNumVowels = maxValue;
            if ((minNumVowels > MAX_WORD_LEN) || (maxNumVowels < 0) ||
                (minNumVowels > maxNumVowels))
            {
                conditions.clear();
                return;
            }
            break;

            case SearchCondition::NumUniqueLetters:
            if (minValue > minNumUniqueLetters)
                minNumUniqueLetters = minValue;
            if (maxValue < maxNumUniqueLetters)
                maxNumUniqueLetters = maxValue;
            if ((minNumUniqueLetters > MAX_WORD_LEN) ||
                (maxNumUniqueLetters <= 0) ||
                (minNumUniqueLetters > maxNumUniqueLetters))
            {
                conditions.clear();
                return;
            }
            break;

            case SearchCondition::PointValue:
            if (minValue > minPointValue)
                minPointValue = minValue;
            if (maxValue < maxPointValue)
                maxPointValue = maxValue;
            if ((minPointValue > 10 * MAX_WORD_LEN) || (maxPointValue <= 0) ||
                (minPointValue > maxPointValue))
            {
                conditions.clear();
                return;
            }
            break;

            default:
            newConditions.append(condition);
            break;
        }
    }

    // Sanity checks for impossible conditions
    if ((minNumVowels > maxLength) || (minNumUniqueLetters > maxLength) ||
        (minPointValue > (10 * maxLength)) || (maxPointValue < minLength))
    {
        conditions.clear();
        return;
    }

    SearchCondition condition;

    // Add Number of Anagrams conditions
    if ((minAnagrams > 0) || (maxAnagrams < MAX_ANAGRAMS)) {
        condition.type = SearchCondition::NumAnagrams;
        condition.minValue = minAnagrams;
        condition.maxValue = maxAnagrams;
        newConditions.push_front(condition);
    }

    // Add Point Value conditions
    if ((minPointValue > 0) || (maxPointValue < (10 * MAX_WORD_LEN + 1))) {
        condition.type = SearchCondition::PointValue;
        condition.minValue = minPointValue;
        condition.maxValue = maxPointValue;
        newConditions.push_front(condition);
    }

    // Add Number of Unique Letters conditions
    if ((minNumUniqueLetters > 0) ||
        (maxNumUniqueLetters < (MAX_WORD_LEN + 1)))
    {
        condition.type = SearchCondition::NumUniqueLetters;
        condition.minValue = minNumUniqueLetters;
        condition.maxValue = maxNumUniqueLetters;
        newConditions.push_front(condition);
    }

    // Add Number of Vowels conditions
    if ((minNumVowels > 0) || (maxNumVowels < (MAX_WORD_LEN + 1))) {
        condition.type = SearchCondition::NumVowels;
        condition.minValue = minNumVowels;
        condition.maxValue = maxNumVowels;
        newConditions.push_front(condition);
    }

    // Add Length conditions
    if ((minLength > 0) || (maxLength < (MAX_WORD_LEN + 1))) {
        condition.type = SearchCondition::Length;
        condition.minValue = minLength;
        condition.maxValue = maxLength;
        newConditions.push_front(condition);
    }

    conditions = wildcardConditions + newConditions;
}