lhaData.h

Go to the documentation of this file.

// This file is part of MARTY.
// 
// MARTY 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.
// 
// MARTY 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 MARTY. If not, see <https://www.gnu.org/licenses/>.

#ifndef LHADATA_H_INCLUDED
#define LHADATA_H_INCLUDED

#include "lhaBlocks.h"
#include "std_vector_implementation.h"
#include <vector>
#include <optional>
#include <string>
#include <string_view>

namespace mty::lha {

BlockType blockType(std::string_view name);
std::ostream &operator<<(
        std::ostream &out,
        BlockType     type
        );

using FloatType = long double;

struct LHAElement {

    size_t    id;
    size_t    id_sup;
    FloatType value;
};

struct Comparator {

    static bool compare(
            std::vector<size_t> const &pos1,
            std::vector<size_t> const &pos2
            )
    {
        if (pos1.size() != pos2.size())
            return pos1.size() < pos2.size();
        auto iter1 = pos1.begin();
        auto iter2 = pos2.begin();
        while (iter1 != pos1.end()) {
            if (*iter1 < *iter2)
                return true;
            else if (*iter2 < *iter1)
                return false;
            ++iter1;
            ++iter2;
        }
        return false;
    }

    static bool compare(
            LHAElement const &A,
            LHAElement const &B
            )
    {
        if (A.id != B.id)
            return A.id < B.id;
        return A.id_sup < B.id_sup;
    }
};

class LHABlock {

public:

    IMPLEMENTS_STD_VECTOR(LHAElement, elements)

    
    LHABlock() = default;
    ~LHABlock() = default;

    LHABlock(std::string const &);

    std::string const &getName() const { 
        return name; 
    }
    void setName(std::string const &t_name) {
        name = t_name;
    }

    bool isName(std::string_view t_name) const;

    std::optional<LHAElement> getElement(size_t id) const;

    std::optional<LHAElement> getElement(
            size_t id,
            size_t id_sup = -1
            ) const;

    std::vector<LHAElement> getMultipleElements(size_t id) const;

    void sortElements();

    void addElement(
            size_t    id,
            size_t    id_sup,
            FloatType value
            );
    void addElement(
            size_t    id,
            FloatType value
            );

    void addElement(LHAElement const &t_element);

    void addElement(LHAElement &&t_element);

private:


    std::string name;
    std::vector<LHAElement> elements;
};

class LHAFileData {

public:

    static constexpr size_t npos = -1;

    IMPLEMENTS_STD_VECTOR(LHABlock, blocks)

    
    LHAFileData() = default;
    ~LHAFileData() = default;

    size_t findBlock(std::string_view nameBlock) const;
    void addBlock(std::string_view nameBlock);

    template<class ...Args>
        void addElement(
                std::string_view nameBlock,
                Args           &&...args
                )
        {
            for (auto &b : blocks)
                if (b.getName() == nameBlock) {
                    b.addElement(std::forward<Args>(args)...);
                    return;
                }
        }

    std::vector<FloatType> getValues(
            std::string_view nameBlock
            ) const;

    std::optional<FloatType> getValue(
            std::string_view nameBlock,
            size_t           id
            ) const;

    std::optional<FloatType> getValue(
            std::string_view nameBlock,
            size_t           i,
            size_t           j
            ) const;

private:

    std::vector<LHABlock> blocks;
};

std::ostream &operator<<(
        std::ostream     &out,
        LHAElement const &element
        );

std::ostream &operator<<(
        std::ostream   &out,
        LHABlock const &block
        );

std::ostream &operator<<(
        std::ostream      &out,
        LHAFileData const &data
        );


std::string tolower(std::string const &str);

} // End of namespace mty::lha

#endif