InputTag.cc

/*
 *  MoMEMta: a modular implementation of the Matrix Element Method
 *  Copyright (C) 2016  Universite catholique de Louvain (UCL), Belgium
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */


#include <momemta/InputTag.h>

std::vector<std::string> split(const std::string& s, const std::string& delimiters) {

    std::vector<std::string> result;

    size_t current;
    size_t next = -1;
    do
    {
        next = s.find_first_not_of(delimiters, next + 1);
        if (next == std::string::npos)
            break;
        next -= 1;

        current = next + 1;
        next = s.find_first_of(delimiters, current);
        result.push_back(s.substr(current, next - current));
    }
    while (next != std::string::npos);

    return result;
}

InputTag::InputTag(const std::string& module, const std::string& parameter):
    module(module), parameter(parameter) {
    string_representation = module + "::" + parameter;
}

InputTag::InputTag(const std::string& module, const std::string& parameter, size_t index):
    module(module), parameter(parameter), index(index), indexed(true) {
    string_representation = module + "::" + parameter + "/" + std::to_string(index + 1);
}

bool InputTag::isInputTag(const std::string& tag) {
    if (tag.find("::") == std::string::npos)
        return false;

    if (tag.find("/") != std::string::npos) {
        auto tags = split(tag, "::");
        auto rtags = split(tags[1], "/");
        try {
            int64_t index = std::stoll(rtags[1]) - 1;
            if (index < 0)
                return false;

            return true;
        } catch (const std::invalid_argument& e) {
            return false;
        }
    } else {
        return true;
    }
}

InputTag InputTag::fromString(const std::string& tag) {
    auto tags = split(tag, "::");
    auto rtags = split(tags[1], "/");

    if (rtags.size() == 1)
        return InputTag(tags[0], tags[1]);
    else
        return InputTag(tags[0], rtags[0], std::stoull(rtags[1]) - 1);
}

bool InputTag::operator==(const InputTag& rhs) const {
    return ((module == rhs.module) && (parameter == rhs.parameter));
}

std::string InputTag::toString() const {
    return string_representation;
}

bool InputTag::isIndexed() const {
    return indexed;
}

bool InputTag::empty() const {
    return module.empty() || parameter.empty();
}

void InputTag::update() {
    string_representation = module + "::" + parameter;
    if (indexed)
        string_representation +=  "/" + std::to_string(index + 1);
}