alg_line.h

Go to the documentation of this file.

 
#ifndef _EXPORT_ALG_LINE_H_
#define _EXPORT_ALG_LINE_H_
 
#include "export/alg_opt.h"
#include "export/functions.h"
#include "log_global.h"
#include "utils.h"
#include <algorithm>
#include <cassert>
#include <exception>
#include <iomanip>
#include <iostream>
#include <regex>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <string>
#include <vector>
 
class Alg_Line {
  public:
    struct Return_Type {
        std::string name; 
        std::string type; 
    };
 
    struct Param_Type {
        std::string key;   
        std::string value; 
        std::string type;  
    };
 
  public:
    // Default constructor.
    Alg_Line() = default;
 
    Alg_Line(const std::string& str, ALG_Opt opt = ALG_Opt::NONE);
 
    const std::string& func() const noexcept;
 
    const std::vector<Return_Type>& returns() const noexcept;
 
    const Return_Type& returns(std::vector<Return_Type>::size_type index) const;
 
    const std::vector<Param_Type>& params() const noexcept;
 
    const Param_Type& params(std::vector<Param_Type>::size_type index) const;
 
    const Param_Type& params(const std::string& key) const;
 
    const std::string& operator[](const std::string key) const;
 
    const std::string& rawStr() const;
 
    bool hasKey(const std::string& key) const noexcept;
 
    bool hasUnknownKey(const std::vector<std::string>& keys) const noexcept;
 
    bool hasUnknownKey(const std::vector<std::string>& keys, std::string& unknown_key) const noexcept;
 
    bool hasRepeatedKey() const noexcept;
 
    bool isValidKey(const std::string& key, const std::vector<std::string>& keys) const noexcept;
 
    bool setKey(std::vector<Param_Type>::size_type index, const std::string& key);
 
    bool needsEnd() const noexcept;
 
    bool isEnd() const noexcept;
 
    bool isFunctionDeclaration() const noexcept;
 
    std::ostream& print(std::ostream& out = std::cout, std::string prefix = "") const;
 
  private:
    std::string::size_type _findChars(const std::string& s, std::string cs) const noexcept;
 
    std::string::size_type _findChar(const std::string& s, char c) const noexcept;
 
    void _removeComment(std::string& s) const noexcept;
 
    void _processReturns(const std::vector<std::string>& v);
 
    void _processFuncParams(const std::vector<std::string>& v);
 
    std::string _decodeEscape(const std::string& s) const;
 
  private:
    std::string _func;                 
    std::vector<Return_Type> _returns; 
    std::vector<Param_Type> _params;   
    std::string _raw_str;              
    ALG_Opt _opt;                      
};
 
inline const std::string& Alg_Line::func() const noexcept { return _func; }
 
inline const std::vector<Alg_Line::Return_Type>& Alg_Line::returns() const noexcept { return _returns; }
 
inline const Alg_Line::Return_Type& Alg_Line::returns(std::vector<Return_Type>::size_type index) const {
    assert(index < _returns.size() && "Alg_Line check returns index size within bound.");
    return _returns[index];
}
 
inline const std::vector<Alg_Line::Param_Type>& Alg_Line::params() const noexcept { return _params; }
 
inline const Alg_Line::Param_Type& Alg_Line::params(std::vector<Param_Type>::size_type index) const {
    assert((index < _params.size() && "Alg_Line check params index size within bound."));
    return _params[index];
}
 
inline const Alg_Line::Param_Type& Alg_Line::params(const std::string& key) const {
    for (auto&& elem : _params) {
        if (elem.key == key) return elem;
    }
    throw std::runtime_error("No key '" + key + "'!");
}
 
inline const std::string& Alg_Line::operator[](const std::string key) const { return params(key).value; }
 
inline const std::string& Alg_Line::rawStr() const { return _raw_str; }
 
inline bool Alg_Line::hasKey(const std::string& key) const noexcept {
    for (auto&& elem : _params) {
        if (elem.key == key) return true;
    }
    return false;
}
 
inline bool Alg_Line::hasUnknownKey(const std::vector<std::string>& keys) const noexcept {
    for (auto&& elem : _params) {
        if (!contains(keys, elem.key)) return true;
    }
    return false;
}
 
inline bool Alg_Line::hasUnknownKey(const std::vector<std::string>& keys, std::string& unkown_key) const noexcept {
    for (auto&& elem : _params) {
        if (!contains(keys, elem.key)) {
            unkown_key = elem.key;
            return true;
        }
    }
    unkown_key.clear(); // return an empty string
    return false;
}
 
inline bool Alg_Line::hasRepeatedKey() const noexcept {
    std::vector<std::string> keys(_params.size());
    for (decltype(_params.size()) i = 0; i != _params.size(); ++i) { keys[i] = _params[i].key; }
    std::sort(keys.begin(), keys.end());
    return std::adjacent_find(keys.begin(), keys.end()) != keys.end();
}
 
inline bool Alg_Line::isValidKey(const std::string& key, const std::vector<std::string>& keys) const noexcept {
    if (!hasKey(key)) return false;
    std::vector<bool> exists(keys.size(), false);
    for (auto&& elem : _params) {
        auto&& the_key = elem.key;
        for (decltype(keys.size()) i = 0; i != keys.size(); ++i) {
            if (keys[i] == the_key) exists[i] = true;
        }
    }
    for (auto&& ck : exists) {
        if (!ck) return false;
    }
    return true;
}
 
inline bool Alg_Line::setKey(std::vector<Param_Type>::size_type index, const std::string& key) {
    assert(index < _params.size() && "Alg_Line check params index size within bound when setting key.");
    if (_params[index].key == "") {
        _params[index].key = key;
        return true;
    } else {
        return false;
    }
}
 
inline bool Alg_Line::needsEnd() const noexcept { return isFuncNeedsEnd(_func); }
 
inline bool Alg_Line::isEnd() const noexcept { return isFuncIsEnd(_func); }
 
inline bool Alg_Line::isFunctionDeclaration() const noexcept { return _opt == ALG_Opt::FUNCTION_DECLARATION; }
 
inline std::ostream& Alg_Line::print(std::ostream& out, std::string prefix) const {
    out << prefix << "$ " << _raw_str << '\n';
    if (_func.empty()) return out;
    out << prefix << "* FUNCTION: " << _func << '\n';
    if (_func != "COMMENT" && !_params.empty()) {
        out << prefix << "* PARAMS:\n";
        for (auto&& p : _params) out << prefix << "   > {" << p.key << "}={" << p.value << "}::{" << p.type << "}\n";
    }
    if (!isFuncNoEnd(_func)) {
        out << prefix << "* RETURN:\n";
        for (auto&& r : _returns) out << prefix << "   > {" << r.name << "}::{" << r.type << "}\n";
    }
    out << std::flush;
    return out;
}
 
inline std::string::size_type Alg_Line::_findChar(const std::string& s, char c) const noexcept {
    return _findChars(s, std::string(1, c));
}
 
inline std::string Alg_Line::_decodeEscape(const std::string& s) const {
    return std::regex_replace(s, std::regex(R"(\\:\\:)"), "::");
}
 
static inline std::ostream& operator<<(std::ostream& out, const Alg_Line& line) { return line.print(out); }
 
#endif