PatternValidator.h

/* Copyright 2019 Kristofer Björnson
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef COM_DAFER45_TBTK_PROPERTY_EXTRACTOR_PATTERN_VALIDATOR
#define COM_DAFER45_TBTK_PROPERTY_EXTRACTOR_PATTERN_VALIDATOR

#include "TBTK/Index.h"

#include <string>

namespace TBTK{
namespace PropertyExtractor{

class PatternValidator{
public:
    PatternValidator();

    //TBTKFeature PropertyExtractor.PatternValidator.checkNumRequiredComponentIndices.1 2019-11-01
    //TBTKFeature PropertyExtractor.PatternValidator.checkNumRequiredComponentIndices.2 2019-11-01
    //TBTKFeature PropertyExtractor.PatternValidator.checkNumRequiredComponentIndices.3 2019-11-01
    void setNumRequiredComponentIndices(int numRequiredComponentIndices);

    //TBTKFeature PropertyExtractor.PatternValidator.checkAllowedSubindexFlags.1 2019-11-01
    //TBTKFeature PropertyExtractor.PatternValidator.checkAllowedSubindexFlags.2 2019-11-01
    //TBTKFeature PropertyExtractor.PatternValidator.checkAllowedSubindexFlags.3 2019-11-01
    //TBTKFeature PropertyExtractor.PatternValidator.checkAllowedSubindexFlags.4 2019-11-01
    //TBTKFeature PropertyExtractor.PatternValidator.checkAllowedSubindexFlags.5 2019-11-01
    void setAllowedSubindexFlags(
        const std::vector<Subindex> &allowedSubindexFlags
    );

    void setCallingFunctionName(const std::string &callingFunctionsName);

    //TBTKFeature PropertyExtractor.PatternValidator.checkNumRequiredComponentIndices.1 2019-11-01
    //TBTKFeature PropertyExtractor.PatternValidator.checkNumRequiredComponentIndices.2 2019-11-01
    //TBTKFeature PropertyExtractor.PatternValidator.checkNumRequiredComponentIndices.3 2019-11-01
    //TBTKFeature PropertyExtractor.PatternValidator.checkAllowedSubindexFlags.1 2019-11-01
    //TBTKFeature PropertyExtractor.PatternValidator.checkAllowedSubindexFlags.2 2019-11-01
    //TBTKFeature PropertyExtractor.PatternValidator.checkAllowedSubindexFlags.3 2019-11-01
    //TBTKFeature PropertyExtractor.PatternValidator.checkAllowedSubindexFlags.4 2019-11-01
    //TBTKFeature PropertyExtractor.PatternValidator.checkAllowedSubindexFlags.5 2019-11-01
    void validate(const std::vector<Index> &patterns) const;
private:
    int numRequiredComponentIndices;

    std::vector<Subindex> allowedSubindexFlags;

    std::string callingFunctionName;

    void validateNumRequiredComponentIndices(
        const std::vector<Index> &patterns
    ) const;

    void validateAllowedSubindexFlags(
        const std::vector<Index> &patterns
    ) const;
};

inline PatternValidator::PatternValidator(){
    numRequiredComponentIndices = -1;
}

inline void PatternValidator::setNumRequiredComponentIndices(
    int numRequiredComponentIndices
){
    this->numRequiredComponentIndices = numRequiredComponentIndices;
}

inline void PatternValidator::setAllowedSubindexFlags(
    const std::vector<Subindex> &allowedSubindexFlags
){
    this->allowedSubindexFlags = allowedSubindexFlags;
}

inline void PatternValidator::setCallingFunctionName(
    const std::string &callingFunctionName
){
    this->callingFunctionName = callingFunctionName;
}

inline void PatternValidator::validate(
    const std::vector<Index> &patterns
) const{
    if(numRequiredComponentIndices != -1)
        validateNumRequiredComponentIndices(patterns);
    validateAllowedSubindexFlags(patterns);
}

inline void PatternValidator::validateNumRequiredComponentIndices(
    const std::vector<Index> &patterns
) const{
    for(unsigned int n = 0; n < patterns.size(); n++){
        TBTKAssert(
            patterns[n].split().size()
                == (unsigned int)numRequiredComponentIndices,
            callingFunctionName,
            "Unexpected number of pattern component Indices. The"
            << " pattern was expected to have '"
            << numRequiredComponentIndices << "', but the pattern"
            << " '" << patterns[n].toString() << "' has '"
            << patterns[n].split().size() << "' components.",
            ""
        );
    }
}

inline void PatternValidator::validateAllowedSubindexFlags(
    const std::vector<Index> &patterns
) const{
    for(unsigned int n = 0; n < patterns.size(); n++){
        std::vector<Index> components = patterns[n].split();
        for(unsigned int m = 0; m < components.size(); m++){
            for(unsigned int c = 0; c < components[m].getSize(); c++){
                int subindex = components[m][c];
                if(subindex < 0){
                    bool isValid = false;
                    for(
                        unsigned int k = 0;
                        k < allowedSubindexFlags.size();
                        k++
                    ){
                        if(
                            subindex
                            == allowedSubindexFlags[k]
                        ){
                            isValid = true;
                            break;
                        }
                    }

                    if(!isValid){
                        TBTKExit(
                            callingFunctionName,
                            "Invalid subindex at"
                            << " position '" << c
                            << "' in component"
                            << " Index '" << m
                            << "' of the pattern '"
                            << patterns[n].toString()
                            << "'.",
                            ""
                        );
                    }
                }
            }
        }
    }
}

};  //End of namespace PropertyExtractor
};  //End of namespace TBTK

#endif