b2rtable.H

//------------------------------------------------------------------------
// b2rtable.H --
//
//     written by Mathias Doreille, Thomas Ludwig, Silvio Merazzi
//
// Copyright (c) 2015,2016,2017,2018
//     SMR Engineering & Development SA
//     2502 Bienne, Switzerland
//
// All Rights Reserved.  Proprietary source code.  The contents of
// this file may not be disclosed to third parties, copied or
// duplicated in any form, in whole or in part, without the prior
// written permission of SMR.
//------------------------------------------------------------------------
 
#ifndef _B2RTABLE_H_
#define _B2RTABLE_H_
 
#include <cassert>
#include <complex>
#include <iomanip>
#include <iostream>
#include <map>
#include <string>
 
#include "b2csda.H"
#include "b2exception.H"
 
namespace b2000 {
 
class RData {
public:
    enum { NONE = 0, BOOL = 1, INT = 2, DOUBLE = 3, COMPLEX_DOUBLE = 4, STRING = 5 };
 
    static const char* type_to_string[6];
 
    RData() : type_(NONE) {}
 
    RData(const bool v) : type_(BOOL), b_data(v) {}
 
    RData(const int v) : type_(INT) { i_data.push_back(v); }
 
    RData(const double v) : type_(DOUBLE) { d_data.push_back(v); }
 
    RData(const std::complex<double> v) : type_(COMPLEX_DOUBLE) { cd_data.push_back(v); }
 
    RData(const std::string& v) : type_(STRING), s_data(v) {}
 
    RData(const char* v) : type_(STRING), s_data(v) {}
 
    template <typename InputIterator>
    RData(InputIterator first, InputIterator last) {
        set_impl<InputIterator, typename std::iterator_traits<InputIterator>::value_type>::f(
              *this, first, last);
    }
 
    template <typename T>
    RData(const std::vector<T>& v) {
        set(v.begin(), v.end());
    }
 
    void set() {
        clear();
        type_ = NONE;
    }
 
    void set(const bool v) {
        clear();
        type_ = BOOL;
        b_data = v;
    }
 
    void set(const int v) {
        clear();
        type_ = INT;
        i_data.push_back(v);
    }
 
    void set(const double v) {
        clear();
        type_ = DOUBLE;
        d_data.push_back(v);
    }
 
    void set(const std::complex<double> v) {
        clear();
        type_ = COMPLEX_DOUBLE;
        cd_data.push_back(v);
    }
 
    void set(const std::string& data) {
        clear();
        type_ = STRING;
        s_data = data;
    }
 
    void set(const char* data) {
        clear();
        type_ = STRING;
        s_data = std::string(data);
    }
 
    template <typename T>
    void set(const std::vector<T>& v) {
        set(v.begin(), v.end());
    }
 
    template <typename InputIterator>
    void set(InputIterator first, InputIterator last) {
        set_impl<InputIterator, typename std::iterator_traits<InputIterator>::value_type>::f(
              *this, first, last);
    }
 
    bool get_bool() const { return b_data; }
 
    const std::vector<int>& get_int() const { return i_data; }
 
    const std::vector<double>& get_double() const { return d_data; }
 
    const std::vector<std::complex<double> >& get_complex_double() const { return cd_data; }
 
    template <typename T>
    inline const std::vector<T>& get() const {
        UnimplementedError() << THROW;
        return std::vector<T>();
    }
 
    const std::string& get_string() const { return s_data; }
 
    int type() const { return type_; }
 
    const std::type_info& type_info() const {
        switch (type_) {
            case BOOL:
                return typeid(bool);
            case INT:
                return typeid(int);
            case DOUBLE:
                return typeid(double);
            case COMPLEX_DOUBLE:
                return typeid(std::complex<double>);
            case STRING:
                return typeid(std::string);
            default:
                assert(0);
        }
        return typeid(void);
    }
 
    size_t size() const {
        switch (type_) {
            case NONE:
                return 0;
            case BOOL:
                return 1;
            case INT:
                return i_data.size();
            case DOUBLE:
                return d_data.size();
            case COMPLEX_DOUBLE:
                return cd_data.size();
            case STRING:
                return s_data.size();
            default:
                return 0;
        }
    }
 
    bool empty() const { return size() == 0; }
 
    static size_t get_data_size(const int type, const size_t num_elements) {
        // Special handling for BOOL.
        const size_t rdata_mul[6] = {0, sizeof(bool), 4, 8, 16, 1};
        const size_t rdata_add[6] = {0, 0, 0, 0, 0, 0};
 
        return rdata_mul[type] * num_elements + rdata_add[type];
    }
 
    size_t get_data_size() const { return get_data_size(type(), size()); }
 
    const void* get_data() const {
        switch (type()) {
            case RData::BOOL:
                return (const void*)&b_data;
            case RData::INT:
                return (const void*)&get_int()[0];
            case RData::DOUBLE:
                return (const void*)&get_double()[0];
            case RData::COMPLEX_DOUBLE:
                return (const void*)&get_complex_double()[0];
            case RData::STRING:
                return (const void*)&get_string()[0];
            default:
                assert(false);
                return nullptr;
        }
    }
 
    bool operator==(const bool o) const { return (type_ == RData::BOOL && b_data == o); }
 
    bool operator==(const int& o) const {
        return (type_ == RData::INT && i_data.size() == 1 && i_data.front() == o);
    }
 
    bool operator==(const std::vector<int>& o) const {
        return (type_ == RData::INT && i_data == o);
    }
 
    bool operator==(const double& o) const {
        return (type_ == RData::DOUBLE && d_data.size() == 1 && d_data.front() == o);
    }
 
    bool operator==(const std::vector<double>& o) const {
        return (type_ == RData::DOUBLE && d_data == o);
    }
 
    bool operator==(const std::complex<double>& o) const {
        return (type_ == RData::COMPLEX_DOUBLE && cd_data.size() == 1 && cd_data.front() == o);
    }
 
    bool operator==(const std::vector<std::complex<double> >& o) const {
        return (type_ == RData::COMPLEX_DOUBLE && cd_data == o);
    }
 
    bool operator==(const std::string& o) const { return (type_ == RData::STRING && s_data == o); }
 
    bool operator==(const char* o) const { return (type_ == RData::STRING && s_data == o); }
 
private:
    friend std::ostream& operator<<(std::ostream& o, const RData& v);
 
    void print(std::ostream& o = std::cout) const {
        switch (type_) {
            case NONE:
                o << "None";
                break;
            case BOOL:
                o << (b_data ? "TRUE" : "FALSE");
            case INT:
                o << "[";
                for (size_t i = 0; i != i_data.size(); ++i) {
                    o << (i > 0 ? ", " : "") << i_data[i];
                }
                o << "]";
                break;
            case DOUBLE:
                o << std::setprecision(15) << "[";
                for (size_t i = 0; i != d_data.size(); ++i) {
                    o << (i > 0 ? ", " : "") << d_data[i];
                }
                o << "]";
                break;
            case COMPLEX_DOUBLE:
                o << std::setprecision(15) << "[";
                for (size_t i = 0; i != cd_data.size(); ++i) {
                    o << (i > 0 ? ", " : "") << cd_data[i];
                }
                o << "]";
                break;
            case STRING:
                o << '"' << s_data << '"';
                break;
            default:
                assert(0);
        }
    }
 
    template <typename T, typename V>
    struct set_impl {
        static void f(RData& r, T first, T last) { r.clear(); }
    };
 
    template <typename T>
    struct set_impl<T, int> {
        static void f(RData& r, T first, T last) {
            r.clear();
            r.type_ = RData::INT;
            r.i_data.insert(r.i_data.end(), first, last);
        }
    };
 
    template <typename T>
    struct set_impl<T, double> {
        static void f(RData& r, T first, T last) {
            r.clear();
            r.type_ = RData::DOUBLE;
            r.d_data.insert(r.d_data.end(), first, last);
        }
    };
 
    template <typename T>
    struct set_impl<T, std::complex<double> > {
        static void f(RData& r, T first, T last) {
            r.clear();
            r.type_ = RData::COMPLEX_DOUBLE;
            r.cd_data.insert(r.cd_data.end(), first, last);
        }
    };
 
    template <typename T>
    struct set_impl<T, b2000::csda<double> > {
        static void f(RData& r, T first, T last) {
            r.clear();
            r.type_ = RData::COMPLEX_DOUBLE;
            r.cd_data.insert(r.cd_data.end(), first, last);
        }
    };
 
    template <typename T>
    struct set_impl<T, char> {
        static void f(RData& r, T first, T last) {
            r.clear();
            r.type_ = RData::STRING;
            r.s_data.insert(r.s_data.end(), first, last);
        }
    };
 
    void clear() {
        type_ = RData::NONE;
        b_data = false;
        i_data.clear();
        d_data.clear();
        cd_data.clear();
        s_data.clear();
    }
 
    unsigned int type_;
    bool b_data;
    std::vector<int> i_data;
    std::vector<double> d_data;
    std::vector<std::complex<double> > cd_data;
    std::string s_data;
};
 
inline std::ostream& operator<<(std::ostream& o, const RData& v) {
    v.print(o);
    return o;
}
 
template <>
inline const std::vector<int>& RData::get<int>() const {
    return get_int();
}
 
template <>
inline const std::vector<double>& RData::get<double>() const {
    return get_double();
}
 
template <>
inline const std::vector<std::complex<double> >& RData::get<std::complex<double> >() const {
    return get_complex_double();
}
 
template <>
inline const std::vector<b2000::csda<double> >& RData::get<b2000::csda<double> >() const {
    return reinterpret_cast<const std::vector<b2000::csda<double> >&>(get_complex_double());
}
 
class RTable : public std::map<std::string, RData> {
public:
    std::string errmsg_context;
 
    bool has_key(const std::string& key) const { return find(key) != end(); }
 
    void remove_key(const std::string& key) {
        iterator i = find(key);
        if (i == end()) { return; }
        erase(i);
    }
 
    const RData& operator()(const std::string& key) const {
        const_iterator i = find(key);
        if (i == end()) { key_error(key); }
        return (*i).second;
    }
 
    RData& operator()(const std::string& key) {
        iterator i = find(key);
        if (i == end()) { key_error(key); }
        return (*i).second;
    }
 
    void update(const RTable& o) {
        for (auto const& i : o) { (*this)[i.first] = i.second; }
    }
 
    template <typename T>
    void set(const std::string& key, const T& v, const bool new_key = false) {
        iterator i = find(key);
        if (i == end()) {
            i = insert(std::pair<std::string, RData>(key, RData(v))).first;
        } else {
            if (new_key) { exists_error(key); }
            (*i).second.set(v);
        }
    }
 
    void set(const std::string& key, const bool v, const bool new_key = false) {
        iterator i = find(key);
        if (i == end()) {
            i = insert(std::pair<std::string, RData>(key, RData(v))).first;
        } else {
            if (new_key) { exists_error(key); }
            (*i).second.set(v);
        }
    }
 
    template <typename T>
    void set(const std::string& key, const std::vector<T>& v, const bool new_key = false) {
        iterator i = find(key);
        if (i == end()) {
            i = insert(std::pair<std::string, RData>(key, RData(v))).first;
        } else {
            if (new_key) { exists_error(key); }
            (*i).second.set(v);
        }
    }
 
    template <typename InputIterator>
    void set(
          const std::string& key, InputIterator first, InputIterator last,
          const bool new_key = false) {
        iterator i = find(key);
        if (i == end()) {
            i = insert(std::pair<std::string, RData>(key, RData(first, last))).first;
        } else {
            if (new_key) { exists_error(key); }
            (*i).second.set(first, last);
        }
    }
 
    void set(const std::string& key, const std::string& s, const bool new_key = false) {
        iterator i = find(key);
        if (i == end()) {
            i = insert(std::pair<std::string, RData>(key, RData(s))).first;
        } else {
            if (new_key) { exists_error(key); }
            (*i).second.set(s);
        }
    }
 
    bool get_bool(const std::string& key) const {
        const_iterator i = find(key);
        if (i != end()) {
            if (i->second.type() == RData::BOOL) { return i->second.get_bool(); }
            type_error(key, i->second.type(), RData::BOOL);
        }
        empty_error(key);
        return 0;
    }
 
    bool get_bool(const std::string& key, const bool default_) const {
        const_iterator i = find(key);
        if (i != end()) {
            if (i->second.type() == RData::BOOL) { return i->second.get_bool(); }
            type_error(key, i->second.type(), RData::BOOL);
        }
        return default_;
    }
 
    int get_int(const std::string& key) const {
        const std::vector<int>& vv = get_int_(key);
        if (vv.empty()) { empty_error(key); }
        return vv.front();
    }
 
    int get_int(const std::string& key, const int default_) const {
        const_iterator i = find(key);
        if (i == end()) { return default_; }
        const std::vector<int>& vv = (*i).second.get_int();
        if (vv.empty()) { empty_error(key); }
        return vv.front();
    }
 
    double get_double(const std::string& key) const {
        const_iterator i = find(key);
        if (i == end()) { key_error(key); }
        const RData& r = (*i).second;
        if (r.empty()) { empty_error(key); }
        if (r.type() == RData::COMPLEX_DOUBLE) { return r.get_complex_double().front().real(); }
        return r.get_double().front();
    }
 
    double get_double(const std::string& key, const double default_) const {
        const_iterator i = find(key);
        if (i == end()) { return default_; }
        const RData& r = (*i).second;
        if (r.empty()) { empty_error(key); }
        if (r.type() == RData::COMPLEX_DOUBLE) { return r.get_complex_double().front().real(); }
        return r.get_double().front();
    }
 
    std::complex<double> get_complex_double(const std::string& key) const {
        const_iterator i = find(key);
        if (i == end()) { key_error(key); }
        const RData& r = (*i).second;
        if (r.empty()) { empty_error(key); }
        if (r.type() == RData::DOUBLE) { return std::complex<double>(r.get_double().front()); }
        if (r.type() != RData::COMPLEX_DOUBLE) { type_error(key, r.type(), RData::COMPLEX_DOUBLE); }
        return r.get_complex_double().front();
    }
 
    b2000::csda<double> get_csda_double(const std::string& key) const {
        return get_complex_double(key);
    }
 
    std::complex<double> get_complex_double(
          const std::string& key, const std::complex<double>& default_) const {
        const_iterator i = find(key);
        if (i == end()) { return default_; }
        const RData& r = (*i).second;
        if (r.empty()) { empty_error(key); }
        if (r.type() == RData::DOUBLE) { return std::complex<double>(r.get_double().front()); }
        if (r.type() != RData::COMPLEX_DOUBLE) { type_error(key, r.type(), RData::COMPLEX_DOUBLE); }
        return r.get_complex_double().front();
    }
 
    b2000::csda<double> get_csda_double(
          const std::string& key, const b2000::csda<double>& default_) const {
        return get_complex_double(key, default_);
    }
 
    std::string get_string(const std::string& key) const { return get_string_(key); }
 
    std::string get_string(const std::string& key, const std::string& default_) const {
        const_iterator i = find(key);
        if (i == end()) { return default_; }
        return (*i).second.get_string();
    }
 
    template <typename T>
    inline T get(const std::string& key) const {
        UnimplementedError() << THROW;
        return T();
    }
 
    template <typename T>
    inline T get(const std::string& key, const T& default_) const {
        UnimplementedError() << THROW;
        return T();
    }
 
    void get(const std::string& key, std::vector<int>& v) const {
        const std::vector<int>& vv = get_int_(key);
        v = vv;
    }
 
    void get(const std::string& key, std::vector<double>& v) const {
        const_iterator i = find(key);
        if (i == end()) { key_error(key); }
        const RData& r = (*i).second;
        if (r.type() == RData::COMPLEX_DOUBLE) {
            const std::vector<std::complex<double> >& vc = r.get_complex_double();
            v.clear();
            v.reserve(vc.size());
            for (auto j : vc) { v.push_back(j.real()); }
        } else if (r.type() == RData::DOUBLE) {
            v = r.get_double();
        } else {
            type_error(key, r.type(), RData::DOUBLE);
        }
    }
 
    void get(const std::string& key, std::vector<std::complex<double> >& v) const {
        const_iterator i = find(key);
        if (i == end()) { key_error(key); }
        const RData& r = (*i).second;
        if (r.type() == RData::DOUBLE) {
            const std::vector<double>& vd = r.get_double();
            v.clear();
            v.reserve(vd.size());
            for (auto j : vd) { v.push_back(std::complex<double>(j)); }
        } else if (r.type() == RData::COMPLEX_DOUBLE) {
            v = r.get_complex_double();
        } else {
            type_error(key, r.type(), RData::COMPLEX_DOUBLE);
        }
    }
 
    void get(const std::string& key, std::vector<b2000::csda<double> >& v) const {
        const_iterator i = find(key);
        if (i == end()) { key_error(key); }
        const RData& r = (*i).second;
        if (r.type() == RData::DOUBLE) {
            const std::vector<double>& vd = r.get_double();
            v.clear();
            v.reserve(vd.size());
            for (auto j : vd) { v.push_back(std::complex<double>(j)); }
        } else if (r.type() == RData::COMPLEX_DOUBLE) {
            const std::vector<std::complex<double> >& vc = r.get_complex_double();
            v.clear();
            v.reserve(vc.size());
            for (auto j : vc) { v.push_back(std::complex<double>(j)); }
        } else {
            type_error(key, r.type(), RData::COMPLEX_DOUBLE);
        }
    }
 
    void get(const std::string& key, const size_t size_, int* v) const {
        const std::vector<int>& vv = get_int_(key);
        if (vv.size() < size_) { size_error(key, vv.size(), size_); }
        std::copy(&vv[0], &vv[0] + size_, v);
    }
 
    void get(const std::string& key, const size_t size_, double* v) const {
        const std::vector<double>& vv = get_double_(key);
        if (vv.size() < size_) { size_error(key, vv.size(), size_); }
        std::copy(&vv[0], &vv[0] + size_, v);
    }
 
    void get(const std::string& key, const size_t size_, std::complex<double>* v) const {
        const_iterator i = find(key);
        if (i == end()) { key_error(key); }
        const RData& r = (*i).second;
        if (r.type() == RData::DOUBLE) {
            const std::vector<double>& vd = r.get_double();
            if (vd.size() < size_) { size_error(key, vd.size(), size_); }
            for (size_t j = 0; j != vd.size(); ++j) { v[j] = std::complex<double>(vd[j]); }
        } else if (r.type() == RData::COMPLEX_DOUBLE) {
            const std::vector<std::complex<double> >& vc = r.get_complex_double();
            if (vc.size() < size_) { size_error(key, vc.size(), size_); }
            std::copy(&vc[0], &vc[0] + size_, v);
        } else {
            type_error(key, r.type(), RData::COMPLEX_DOUBLE);
        }
    }
 
    void append_to_array(std::vector<char>& a) const;
 
    const char* update_from_array(const char* abegin, const char* aend);
 
private:
    friend std::ostream& operator<<(std::ostream& o, const RTable& r);
 
    void print(std::ostream& o) const {
        o << "{";
        for (const_iterator i = begin(); i != end(); ++i) {
            o << (i != begin() ? ", " : "") << '"' << (*i).first << "\":" << (*i).second;
        }
        o << "}";
    }
 
    const std::vector<int>& get_int_(const std::string& key) const {
        const_iterator i = find(key);
        if (i == end()) { key_error(key); }
        const RData& r = (*i).second;
        if (r.type() != RData::INT) { type_error(key, r.type(), RData::INT); }
        return r.get_int();
    }
 
    const std::vector<double>& get_double_(const std::string& key) const {
        const_iterator i = find(key);
        if (i == end()) { key_error(key); }
        const RData& r = (*i).second;
        if (r.type() != RData::DOUBLE) { type_error(key, r.type(), RData::DOUBLE); }
        return r.get_double();
    }
 
    std::complex<double> get_complex_double_first_(const std::string& key) const {
        const_iterator i = find(key);
        if (i == end()) { key_error(key); }
        const RData& r = (*i).second;
        if (r.empty()) { empty_error(key); }
        if (r.type() == RData::DOUBLE) { return std::complex<double>(r.get_double().front()); }
        if (r.type() != RData::COMPLEX_DOUBLE) { type_error(key, r.type(), RData::COMPLEX_DOUBLE); }
        return r.get_complex_double().front();
    }
 
    const std::string& get_string_(const std::string& key) const {
        const_iterator i = find(key);
        if (i == end()) { key_error(key); }
        const RData& r = (*i).second;
        if (r.type() != RData::STRING) { type_error(key, r.type(), RData::STRING); }
        return r.get_string();
    }
 
    void key_error(const std::string& key) const;
 
    void exists_error(const std::string& key) const;
 
    void type_error(const std::string& key, const int has, const int need) const;
 
    void empty_error(const std::string& key) const;
 
    void size_error(const std::string& key, const size_t has, const size_t need) const;
};
 
inline std::ostream& operator<<(std::ostream& o, const RTable& r) {
    r.print(o);
    return o;
}
 
template <>
inline std::string RTable::get<std::string>(const std::string& key) const {
    return get_string(key);
}
 
template <>
inline bool RTable::get<bool>(const std::string& key) const {
    return get_bool(key);
}
 
template <>
inline int RTable::get<int>(const std::string& key) const {
    return get_int(key);
}
 
template <>
inline double RTable::get<double>(const std::string& key) const {
    return get_double(key);
}
 
template <>
inline std::complex<double> RTable::get<std::complex<double> >(const std::string& key) const {
    return get_complex_double(key);
}
 
template <>
inline b2000::csda<double> RTable::get<b2000::csda<double> >(const std::string& key) const {
    return get_complex_double(key);
}
 
template <>
inline std::string RTable::get<std::string>(
      const std::string& key, const std::string& default_) const {
    return get_string(key, default_);
}
 
template <>
inline bool RTable::get<bool>(const std::string& key, const bool& default_) const {
    return get_bool(key, default_);
}
 
template <>
inline int RTable::get<int>(const std::string& key, const int& default_) const {
    return get_int(key, default_);
}
 
template <>
inline double RTable::get<double>(const std::string& key, const double& default_) const {
    return get_double(key, default_);
}
 
template <>
inline std::complex<double> RTable::get<std::complex<double> >(
      const std::string& key, const std::complex<double>& default_) const {
    return get_complex_double(key, default_);
}
 
template <>
inline b2000::csda<double> RTable::get<b2000::csda<double> >(
      const std::string& key, const b2000::csda<double>& default_) const {
    return get_complex_double(key, default_);
}
 
}  // namespace b2000
 
#endif /* _B2RTABLE_H_ */