GenericContainer.hh

Go to the documentation of this file.

/*--------------------------------------------------------------------------*\
 |                                                                          |
 |  Copyright (C) 2013                                                      |
 |                                                                          |
 |         , __                 , __                                        |
 |        /|/  \               /|/  \                                       |
 |         | __/ _   ,_         | __/ _   ,_                                |
 |         |   \|/  /  |  |   | |   \|/  /  |  |   |                        |
 |         |(__/|__/   |_/ \_/|/|(__/|__/   |_/ \_/|/                       |
 |                           /|                   /|                        |
 |                           \|                   \|                        |
 |                                                                          |
 |      Enrico Bertolazzi                                                   |
 |      Dipartimento di Ingegneria Industriale                              |
 |      Università degli Studi di Trento                                    |
 |      email: enrico.bertolazzi@unitn.it                                   |
 |                                                                          |
\*--------------------------------------------------------------------------*/
 
//
// file: GenericContainer.hh
//
 
#pragma once
 
#ifndef GENERIC_CONTAINER_HH
#define GENERIC_CONTAINER_HH
 
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wpadded"
#pragma clang diagnostic ignored "-Wc++98-compat"
#pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
#pragma clang diagnostic ignored "-Wpoison-system-directories"
#endif
 
#include <iostream>
#include <string>
#include <string_view>
#include <complex>
#include <map>
#include <deque>
#include <vector>
#include <sstream>
#include <iomanip>
#include <stdexcept>
 
#include "GenericContainerConfig.hh"
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
#ifndef GC_DO_ERROR
  #define GC_DO_ERROR(MSG) {                          \
    ostringstream ost;                                \
    ost << "in GenericContainer: " << MSG << '\n';    \
    GenericContainer::exception( ost.str().data() ); \
  }
#endif
 
#ifndef GC_ASSERT
  #define GC_ASSERT(COND,MSG) if ( !(COND) ) GC_DO_ERROR(MSG)
#endif
 
#ifndef GC_WARNING
  #define GC_WARNING(COND,MSG)                                   \
    if ( !(COND) ) {                                             \
      cout << "On line: " << __LINE__                            \
           << " file: " << __FILE__                              \
           << " in GenericContainer\nWARNING: " << MSG << '\n';  \
    }
#endif
 
#ifdef __GNUC__
  #define GC_NO_RETURN __attribute__ ((noreturn))
#else
  #define GC_NO_RETURN
#endif
 
#endif

namespace GC_namespace {
 
  using std::cin;
  using std::cout;
  using std::endl;
  using std::string;
  using std::string_view;
  using std::complex;
  using std::vector;
  using std::map;
  using std::deque;
  using std::istringstream;
  using std::ostringstream;
  using std::runtime_error;
  using std::exception;
 
  extern unsigned stream_number_precision;

  using ostream_type = std::basic_ostream<char>;

  using istream_type = std::basic_istream<char>;
 
  #ifndef DOXYGEN_SHOULD_SKIP_THIS
 
  #if defined(GENERIC_CONTAINER_ON_WINDOWS) && defined(GENERIC_CONTAINER_USE_WINDOWS_TYPES)
  #else
  using std::uint8_t;
  using std::int32_t;
  using std::int64_t;
  using std::uint32_t;
  using std::uint64_t;
  #endif
 
  class GenericContainer;
 
  typedef void* pointer_type;
 
  using string           = string;
  using bool_type        = bool;
  using int_type         = int32_t;
  using long_type        = int64_t;
  using uint_type        = uint32_t;
  using ulong_type       = uint64_t;
  using real_type        = double;
  using complex_type     = complex<real_type>;
  using string_type      = string;
  using vec_pointer_type = vector<pointer_type>;
  using vec_bool_type    = vector<bool_type>;
  using vec_int_type     = vector<int_type>;
  using vec_long_type    = vector<long_type>;
  using vec_real_type    = vector<real_type>;
  using vec_complex_type = vector<complex_type>;
  using vec_string_type  = vector<string_type>;
  using vector_type      = vector<GenericContainer>;
  using map_type         = map<string_type,GenericContainer>;
  using vec_uint_type    = vector<uint_type>;
  using vec_ulong_type   = vector<ulong_type>;
 
  #endif
 
  // ---------------------------------------------------------------------------
  template <typename TYPE>
  class mat_type : public vector<TYPE> {
    unsigned m_num_rows{0};  
    unsigned m_num_cols{0};  
    typedef typename vector<TYPE>::size_type size_type;
  public:

    mat_type() = default;

    mat_type( unsigned nr, unsigned nc )
    : m_num_rows(nr)
    , m_num_cols(nc)
    { vector<TYPE>::resize(size_type(nr*nc)); }    

    void
    resize( unsigned const nr, unsigned const nc ) {
      m_num_rows = nr;
      m_num_cols = nc;
      vector<TYPE>::resize(size_type(nr*nc));
    }
 
    template <typename T1, typename T2>
    void
    resize( T1 const nr, T2 const nc ) {
      static_assert(std::is_integral_v<T1>, "resize() accepts only integral types!");
      static_assert(std::is_integral_v<T1>, "resize() accepts only integral types!");
      resize( static_cast<unsigned>(nr), static_cast<unsigned>(nc) );
    }

    void get_column( unsigned nc, vector<TYPE> & C ) const;
 
    template <typename T>
    void
    get_column( T const nc, vector<TYPE> & C ) const {
      static_assert(std::is_integral_v<T>, "get_column() accepts only integral types as first argument!");
      get_column( static_cast<unsigned>(nc), C );
    }

    void
    getColumn( unsigned nc, vector<TYPE> & C ) const
    { this->get_column( nc, C ); }

    void get_row( unsigned nr, vector<TYPE> & R ) const;
 
    template <typename T>
    void
    get_row( T const nr, vector<TYPE> & R ) const {
      static_assert(std::is_integral_v<T>, "get_row() accepts only integral types as first argument!");
      get_row( static_cast<unsigned>(nr), R );
    }

    void
    getRow( unsigned nr, vector<TYPE> & R ) const
    { this->get_row( nr, R ); }

    void get_column( unsigned nc, TYPE * C ) const;
 
    template <typename T>
    void
    get_column( T const nc, TYPE * C ) const {
      static_assert(std::is_integral_v<T>, "get_column() accepts only integral types as first argument!");
      get_column( static_cast<unsigned>(nc), C );
    }

    void
    getColumn( unsigned nc, TYPE * C ) const
    { get_column( nc, C ); }

    void get_row( unsigned nr, TYPE * R ) const;
 
    template <typename T>
    void
    get_row( T const nr, TYPE * R ) const {
      static_assert(std::is_integral_v<T>, "get_row() accepts only integral types as first argument!");
      get_row( static_cast<unsigned>(nr), R );
    }

    void
    getRow( unsigned nr, TYPE * R ) const
    { this->get_row( nr, R ); }

    [[nodiscard]] unsigned num_rows() const { return m_num_rows; }

    [[nodiscard]] unsigned numRows() const { return m_num_rows; }

    [[nodiscard]] unsigned num_cols() const { return m_num_cols; }

    [[nodiscard]] unsigned numCols() const { return m_num_cols; }

    TYPE const & operator () ( unsigned i, unsigned j ) const;

    TYPE & operator () ( unsigned i, unsigned j );

    void info( ostream_type & stream ) const;

    string_type
    info() const {
      ostringstream ostr;
      this->info(ostr);
      return ostr.str();
    }

    TYPE * data() { return &vector<TYPE>::front(); }

    TYPE const * data() const { return &vector<TYPE>::front(); }
  };
 
  // ---------------------------------------------------------------------------
  #ifndef GENERIC_CONTAINER_ON_WINDOWS
  extern template class mat_type<int_type>;
  extern template class mat_type<long_type>;
  extern template class mat_type<real_type>;
  extern template class mat_type<complex_type>;
  #endif
 
  using mat_int_type     = mat_type<int_type>;
  using mat_long_type    = mat_type<long_type>;
  using mat_real_type    = mat_type<real_type>;
  using mat_complex_type = mat_type<complex_type>;
 
  string to_string( complex_type const & v );

  template <typename TYPE>
  ostream_type & operator << ( ostream_type & s, vector<TYPE> const & v );

  template <typename TYPE>
  ostream_type & operator << ( ostream_type & s, mat_type<TYPE> const & mat );
 
  // ---------------------------------------------------------------------------

  using TypeAllowed = enum class GC_type : int_type {
    NOTYPE,      
    POINTER,     
    BOOL,        
    INTEGER,     
    LONG,        
    REAL,        
    COMPLEX,     
    STRING,      
 
    // Vector types
    VEC_POINTER, 
    VEC_BOOL,    
    VEC_INTEGER, 
    VEC_LONG,    
    VEC_REAL,    
    VEC_COMPLEX, 
    VEC_STRING,  
 
    // Matrix types
    MAT_INTEGER, 
    MAT_LONG,    
    MAT_REAL,    
    MAT_COMPLEX, 
 
    // Complex types
    VECTOR,      
    MAP          
  };

  string_view to_string(GC_type s);

  class GenericContainer {
  public:
    // Import type aliases from namespace `GC_namespace`
    using pointer_type     = GC_namespace::pointer_type;       
    using bool_type        = GC_namespace::bool_type;          
    using int_type         = GC_namespace::int_type;           
    using uint_type        = GC_namespace::uint_type;          
    using long_type        = GC_namespace::long_type;          
    using ulong_type       = GC_namespace::ulong_type;         
    using real_type        = GC_namespace::real_type;          
    using complex_type     = GC_namespace::complex_type;       
    using string_type      = GC_namespace::string_type;        
    using vec_pointer_type = GC_namespace::vec_pointer_type;   
    using vec_bool_type    = GC_namespace::vec_bool_type;      
    using vec_int_type     = GC_namespace::vec_int_type;       
    using vec_uint_type    = GC_namespace::vec_uint_type;      
    using vec_long_type    = GC_namespace::vec_long_type;      
    using vec_ulong_type   = GC_namespace::vec_ulong_type;     
    using vec_real_type    = GC_namespace::vec_real_type;      
    using vec_complex_type = GC_namespace::vec_complex_type;   
    using vec_string_type  = GC_namespace::vec_string_type;    
    using vector_type      = GC_namespace::vector_type;        
    using map_type         = GC_namespace::map_type;           
    using mat_int_type     = GC_namespace::mat_int_type;       
    using mat_long_type    = GC_namespace::mat_long_type;      
    using mat_real_type    = GC_namespace::mat_real_type;      
    using mat_complex_type = GC_namespace::mat_complex_type;   
 
  private:

    using DataStorage = union {
      pointer_type     p;    
      bool_type        b;    
      int_type         i;    
      long_type        l;    
      real_type        r;    
      complex_type     * c;  
      string_type      * s;  
 
      vec_pointer_type * v_p;   
      vec_bool_type    * v_b;   
      vec_int_type     * v_i;   
      vec_long_type    * v_l;   
      vec_real_type    * v_r;   
      vec_complex_type * v_c;   
      vec_string_type  * v_s;   
 
      mat_int_type     * m_i;   
      mat_long_type    * m_l;   
      mat_real_type    * m_r;   
      mat_complex_type * m_c;   
 
      vector_type      * v;     
      map_type         * m;     
    };
 
    DataStorage m_data;                       
    TypeAllowed m_data_type{GC_type::NOTYPE}; 

    void allocate_string();

    void allocate_complex();

    void allocate_vec_pointer(unsigned sz);

    void allocate_vec_bool(unsigned sz);

    void allocate_vec_int(unsigned sz);

    void allocate_vec_long(unsigned sz);

    void allocate_vec_real(unsigned sz);

    void allocate_vec_complex(unsigned sz);

    void allocate_mat_int(unsigned nr, unsigned nc);

    void allocate_mat_long(unsigned nr, unsigned nc);

    void allocate_mat_real(unsigned nr, unsigned nc);

    void allocate_mat_complex(unsigned nr, unsigned nc);

    void allocate_vec_string(unsigned sz);

    void allocate_vector(unsigned sz);

    void allocate_map();

    void ck( string_view, TypeAllowed) const;

    [[nodiscard]] int ck(TypeAllowed) const;

    void ck_or_set(string_view, TypeAllowed);

    #ifdef GENERIC_CONTAINER_ON_WINDOWS
    bool simple_data() const;
    #else
    [[nodiscard]] bool simple_data() const { return m_data_type <= GC_type::STRING; }
    #endif

    #ifdef GENERIC_CONTAINER_ON_WINDOWS
    bool simple_vec_data() const;
    #else
    [[nodiscard]] bool simple_vec_data() const { return m_data_type < GC_type::VEC_STRING; }
    #endif
 
  public:

    GenericContainer() : m_data_type(GC_type::NOTYPE) {}

    ~GenericContainer() { clear(); }

    void clear();

    void erase( string_view name ) const;

    bool empty() const { return this->m_data_type != GC_type::NOTYPE; }


    pointer_type & set_pointer( pointer_type value );

    GenericContainer & free_pointer();

    void get_keys( vec_string_type & keys ) const;

    string get_keys() const;

    bool_type & set_bool( bool_type value );

    int_type & set_int( int_type value );

    long_type & set_long( long_type value );

    real_type & set_real( real_type value );

    complex_type & set_complex( complex_type const & value );

    complex_type & set_complex( real_type re, real_type im );

    string_type & set_string( string_view value );
 
 
 
 


    vec_pointer_type & set_vec_pointer( unsigned sz = 0 );
 
    template <typename T>
    vec_pointer_type &
    set_vec_pointer( T sz ) {
      static_assert(std::is_integral_v<T>, "set_vec_pointers() accepts only integral types!");
      return set_vec_pointer(static_cast<unsigned>(sz));
    }

    vec_pointer_type & set_vec_pointer( vec_pointer_type const & v );

    vec_bool_type & set_vec_bool( unsigned sz = 0 );
 
    template <typename T>
    vec_bool_type &
    set_vec_bool( T sz ) {
      static_assert(std::is_integral_v<T>, "set_vec_bool() accepts only integral types!");
      return set_vec_bool(static_cast<unsigned>(sz));
    }

    vec_bool_type & set_vec_bool( vec_bool_type const & v );

    vec_int_type & set_vec_int( unsigned sz = 0 );
 
    template <typename T>
    vec_int_type &
    set_vec_int( T sz ) {
      static_assert(std::is_integral_v<T>, "set_vec_ints() accepts only integral types!");
      return set_vec_int(static_cast<unsigned>(sz));
    }

    vec_int_type & set_vec_int( vec_int_type const & v );

    vec_long_type & set_vec_long( unsigned sz = 0 );
 
    template <typename T>
    vec_long_type &
    set_vec_long( T sz ) {
      static_assert(std::is_integral_v<T>, "set_vec_long() accepts only integral types!");
      return set_vec_long(static_cast<unsigned>(sz));
    }

    vec_long_type & set_vec_long( vec_long_type const & v );

    vec_real_type & set_vec_real( unsigned sz = 0 );
 
    template <typename T>
    vec_real_type &
    set_vec_real( T sz ) {
      static_assert(std::is_integral_v<T>, "set_vec_real() accepts only integral types!");
      return set_vec_real(static_cast<unsigned>(sz));
    }

    vec_real_type & set_vec_real( vec_real_type const & v );

    vec_complex_type & set_vec_complex( unsigned sz = 0 );
 
    template <typename T>
    vec_complex_type &
    set_vec_complex( T sz ) {
      static_assert(std::is_integral_v<T>, "set_vec_complex() accepts only integral types!");
      return set_vec_complex(static_cast<unsigned>(sz));
    }

    vec_complex_type & set_vec_complex( vec_complex_type const & v );

    vec_string_type & set_vec_string( unsigned sz = 0 );
 
    template <typename T>
    vec_string_type &
    set_vec_string( T sz ) {
      static_assert(std::is_integral_v<T>, "set_vec_string() accepts only integral types!");
      return set_vec_string(static_cast<unsigned>(sz));
    }

    vec_string_type & set_vec_string( vec_string_type const & v );

    mat_int_type & set_mat_int( unsigned nr = 0, unsigned nc = 0 );

    mat_int_type & set_mat_int( mat_int_type const & m );

    mat_long_type & set_mat_long( unsigned nr = 0, unsigned nc = 0 );

    mat_long_type & set_mat_long( mat_long_type const & m );

    mat_real_type & set_mat_real( unsigned nr = 0, unsigned nc = 0 );

    mat_real_type & set_mat_real( mat_real_type const & m );

    mat_complex_type & set_mat_complex( unsigned nr = 0, unsigned nc = 0 );

    mat_complex_type & set_mat_complex( mat_complex_type const & m );

    void push_bool( bool b ) const;

    void push_int( int_type i );

    void push_long( long_type l );

    void push_real( real_type r );

    void push_complex( complex_type & c );

    void push_complex( real_type re, real_type im );

    void push_string( string_view s );

 
 
 
 
 


    vector_type & set_vector( unsigned sz = 0 );

    map_type & set_map();

 
 
 
 
 


    TypeAllowed get_type() const { return m_data_type; }

    string_view get_type_name() const { return to_string(get_type()); }

    GenericContainer const & info( ostream_type & stream ) const;

    string_type
    info() const {
      ostringstream sstr;
      this->info(sstr);
      return sstr.str();
    }

    unsigned get_num_elements() const;

    unsigned num_rows() const;
    unsigned get_numRows() const { return this->num_rows(); }

    unsigned num_cols() const;
    unsigned get_numCols() const { return this->num_cols(); }

    real_type get_number( string_view const where = "" ) const;

    complex_type get_complex_number( string_view const where = "" ) const;

    void get_complex_number( real_type & re, real_type & im ) const;

    void * get_pvoid( string_view const where = "" ) const;

    void ** get_ppvoid( string_view const where = "" ) const;

    int_type const * get_int_pointer() const;

    int_type * get_int_pointer();

    long_type const * get_long_pointer() const;

    long_type * get_long_pointer();

    real_type const * get_real_pointer() const;

    real_type * get_real_pointer();

    complex_type const * get_complex_pointer() const;

    complex_type * get_complex_pointer();

    template <typename T>
    void
    get_value( T & v, string_view const where = "" ) const;

    #ifdef GENERIC_CONTAINER_ON_WINDOWS
    template <typename T>
    T& get_pointer()
    { ck("get_pointer",GC_type::POINTER); return *reinterpret_cast<T*>(get_ppvoid()); }

    template <typename T>
    T get_pointer() const
    { ck("get_pointer",GC_type::POINTER); return reinterpret_cast<T>(get_pvoid()); }
    #else
    template <typename T>
    T& get_pointer()
    { ck("get_pointer", GC_type::POINTER); return *static_cast<T*>(m_data.p); }

    template <typename T>
    T get_pointer() const
    { ck("get_pointer",GC_type::POINTER); return reinterpret_cast<T>(m_data.p); }
    #endif

    bool_type get_map_bool( string_view const key, string_view const where = "" ) const;

    bool_type get_map_bool( std::initializer_list<string> args ) const;

    bool_type get_map_bool( vec_string_type const & keys, string_view const where = "" ) const;

    int_type get_map_int( string_view const key, string_view const where = "" ) const;

    int_type get_map_int( std::initializer_list<string> args ) const;

    int_type get_map_int( vec_string_type const & keys, string_view const where = "" ) const;

    real_type get_map_number( string_view const key, string_view const where = "" ) const;

    real_type get_map_number( std::initializer_list<string> args ) const;

    real_type get_map_number( vec_string_type const & keys, string_view const where = "" ) const;

    string const & get_map_string( string_view const key, string_view const where = "" ) const;

    string const & get_map_string( std::initializer_list<string> args ) const;

    string const & get_map_string( vec_string_type const & keys, string_view const where = "" ) const;

    vec_real_type const & get_map_vec_real( string_view const key, string_view const where = "" ) const;

    vec_real_type const & get_map_vec_real( std::initializer_list<string> args ) const;

    vec_real_type const & get_map_vec_real( vec_string_type const & keys, string_view const where = "" ) const;

    vec_complex_type const & get_map_vec_complex( string_view const key, string_view const where = "" ) const;

    vec_complex_type const & get_map_vec_complex( std::initializer_list<string> args ) const;

    vec_complex_type const & get_map_vec_complex( vec_string_type const & keys, string_view const where = "" ) const;

    vec_string_type const & get_map_vec_string( string_view const key, string_view const where = "" ) const;

    vec_string_type const & get_map_vec_string( std::initializer_list<string> args ) const;

    vec_string_type const & get_map_vec_string( vec_string_type const & keys, string_view const where = "" ) const;

    bool_type & get_bool( string_view const where = "" );

    bool_type const & get_bool( string_view const where = "" ) const;

    int_type & get_int( string_view const where = "" );

    int_type const & get_int( string_view const where = "" ) const;

    long_type & get_long( string_view const where = "" );

    long_type const & get_long( string_view const where = "" ) const;

    int_type get_as_int( string_view const where = "" ) const;

    uint_type get_as_uint( string_view const where = "" ) const;

    long_type get_as_long( string_view const where = "" ) const;

    ulong_type get_as_ulong( string_view const where = "" ) const;

    real_type & get_real( string_view const where = "" );

    real_type const & get_real( string_view const where = "" ) const;

    complex_type & get_complex( string_view const where = "" );

    complex_type const & get_complex( string_view const where = "" ) const;

    string_type & get_string( string_view const where = "" );

    string_type const & get_string( string_view const where = "" ) const;

 
 
 
 
 
 
 

 

    vector_type & get_vector( string_view const where = "" );

    vector_type const & get_vector( string_view const where = "" ) const;

    vec_pointer_type & get_vec_pointer( string_view const where = "" );

    vec_pointer_type const & get_vec_pointer( string_view const where = "" ) const;

    vec_bool_type & get_vec_bool( string_view const where = "" );

    vec_bool_type const & get_vec_bool( string_view const where = "" ) const;

    vec_int_type & get_vec_int( string_view = "" );

    vec_int_type const & get_vec_int( string_view = "" ) const;

    vec_long_type & get_vec_long( string_view = "" );

    vec_long_type const & get_vec_long( string_view = "" ) const;

    vec_real_type & get_vec_real( string_view = "" );

    vec_real_type const & get_vec_real( string_view = "" ) const;

    vec_complex_type & get_vec_complex( string_view = "" );

    vec_complex_type const & get_vec_complex( string_view = "" ) const;

    mat_int_type & get_mat_int( string_view = "" );

    mat_int_type const & get_mat_int( string_view = "" ) const;

    mat_long_type & get_mat_long( string_view = "" );

    mat_long_type const & get_mat_long( string_view = "" ) const;

    mat_real_type & get_mat_real( string_view = "" );

    mat_real_type const & get_mat_real( string_view = "" ) const;

    mat_complex_type & get_mat_complex( string_view = "" );

    mat_complex_type const & get_mat_complex( string_view = "" ) const;

    vec_string_type & get_vec_string( string_view = "" );

    vec_string_type const & get_vec_string( string_view = "" ) const;

 
 
 
 
 
 


    void copyto_vec_int( vec_int_type & v, string_view = "" ) const;

    void copyto_vec_uint( vec_uint_type & v, string_view = "" ) const;

    void copyto_vec_long( vec_long_type & v, string_view = "" ) const;

    void copyto_vec_ulong( vec_ulong_type & v, string_view = "" ) const;

    void copyto_vec_real( vec_real_type & v, string_view = "" ) const;

    void copyto_vec_complex( vec_complex_type & v, string_view = "" ) const;

    void copyto_vec_string( vec_string_type & v, string_view = "" ) const;

 
 
 


    void copyto_mat_int( mat_int_type & m, string_view = "" ) const;

    void copyto_mat_long( mat_long_type & m, string_view = "" ) const;

    void copyto_mat_real( mat_real_type & m, string_view = "" ) const;

    void copyto_mat_complex( mat_complex_type & m, string_view = "" ) const;

 
 
 
 
 

 

    real_type get_number_at( unsigned i, string_view = "" ) const;

    complex_type get_complex_number_at( unsigned i, string_view = "" ) const;

    void get_complex_number_at( unsigned i, real_type & re, real_type & im, string_view = "" ) const;

    template <typename T>
    T& get_pointer_at( unsigned i )
    { return (*this)[i].get_pointer<T>(); }

    template <typename T>
    T get_pointer_at( unsigned i ) const
    { return (*this)[i].get_pointer<T>(); }

    bool_type get_bool_at( unsigned i );
 
    template <typename T>
    bool_type
    get_bool_at( T i ) {
      static_assert(std::is_integral_v<T>, "get_bool_at() accepts only integral types!");
      return get_bool_at(static_cast<unsigned>(i));
    }

    bool_type get_bool_at( unsigned i, string_view const where ) const;

    int_type & get_int_at( unsigned i );
 
    template <typename T>
    int_type &
    get_int_at( T i ) {
      static_assert(std::is_integral_v<T>, "get_int_at() accepts only integral types!");
      return get_int_at(static_cast<unsigned>(i));
    }

    int_type const & get_int_at( unsigned i, string_view const where ) const;

    long_type & get_long_at( unsigned i );
 
    template <typename T>
    long_type &
    get_long_at( T i ) {
      static_assert(std::is_integral_v<T>, "get_long_at() accepts only integral types!");
      return get_long_at(static_cast<unsigned>(i));
    }

    long_type const & get_long_at( unsigned i, string_view const where ) const;

    real_type & get_real_at( unsigned i );
 
    template <typename T>
    real_type & get_real_at( T i ) {
      static_assert(std::is_integral_v<T>, "get_real_at() accepts only integral types!");
      return get_real_at(static_cast<unsigned>(i));
    }

    real_type const & get_real_at( unsigned i, string_view const where ) const;

    complex_type & get_complex_at( unsigned i );
 
    template <typename T>
    complex_type & get_complex_at( T i ) {
      static_assert(std::is_integral_v<T>, "get_complex_at() accepts only integral types!");
      return get_complex_at(static_cast<unsigned>(i));
    }

    complex_type const & get_complex_at( unsigned i, string_view const where ) const;

    int_type & get_int_at( unsigned i, unsigned j );

    int_type const & get_int_at( unsigned i, unsigned j, string_view const where ) const;

    long_type & get_long_at( unsigned i, unsigned j );

    long_type const & get_long_at( unsigned i, unsigned j, string_view const where ) const;

    real_type & get_real_at( unsigned i, unsigned j );

    real_type const & get_real_at( unsigned i, unsigned j, string_view const where ) const;

    complex_type & get_complex_at( unsigned i, unsigned j );

    complex_type const & get_complex_at( unsigned i, unsigned j, string_view const where ) const;

    string_type & get_string_at( unsigned i );
 
    template <typename T>
    string_type &
    get_string_at( T i ) {
      static_assert(std::is_integral_v<T>, "get_string_at() accepts only integral types!");
      return get_string_at(static_cast<unsigned>(i));
    }

    string_type const & get_string_at( unsigned i, string_view const where ) const;

    GenericContainer & get_gc_at( unsigned i );
 
    template <typename T>
    GenericContainer & get_gc_at( T i ) {
      static_assert(std::is_integral_v<T>, "get_gc_at() accepts only integral types!");
      return get_gc_at(static_cast<unsigned>(i));
    }

    GenericContainer const & get_gc_at( unsigned i, string_view const where ) const;

 
 
 
 
 
 
 


    map_type & get_map( string_view = "" );

    map_type const & get_map( string_view = "" ) const;

 
 


    GenericContainer & operator [] ( unsigned i );

    GenericContainer const & operator [] ( unsigned i ) const;

    GenericContainer & operator [] ( string_view s );

    GenericContainer const & operator [] ( string_view s ) const;

    GenericContainer & operator () ( unsigned i, string_view = "" );

    GenericContainer const & operator () ( unsigned i, string_view = "" ) const;

    GenericContainer & operator () ( string_view s, string_view = "" );

    GenericContainer const & operator () ( string_view s, string_view = "" ) const;

    GenericContainer & operator () ( vec_string_type const & vs, string_view = "" );

    GenericContainer const & operator () ( vec_string_type const & vs, string_view = "" ) const;

 
 
 
 
 
 
 
 


    void set( bool const & a ) { this->set_bool(a); }

    void set( uint_type const & a ) { this->set_int(int_type(a)); }

    void set( int_type const & a ) { this->set_int(a); }

    void set( ulong_type const & a ) { this->set_long(long_type(a)); }

    void set( long_type const & a ) { this->set_long(a); }

    void set( float const & a ) { this->set_real(real_type(a)); }

    void set( double const & a ) { this->set_real(real_type(a)); }

    void set( complex<float> const & a )
    { this->set_complex(real_type(a.real()),real_type(a.imag())); }

    void set( complex<double> const & a )
    { this->set_complex(real_type(a.real()),real_type(a.imag())); }

    void set( char const * a ) { this->set_string(a); }

    void set( string_view a ) { this->set_string(a); }

    void set( pointer_type a ) { this->set_pointer(a); }

 
 
 
 


    GenericContainer & operator = ( bool const & a )
    { this->set_bool(a); return * this; }

    GenericContainer & operator = ( uint_type const & a )
    { this->set_int(int_type(a)); return * this; }

    GenericContainer & operator = ( int_type const & a )
    { this->set_int(a); return * this; }

    GenericContainer & operator = ( ulong_type const & a )
    { this->set_long(long_type(a)); return * this; }

    GenericContainer & operator = ( long_type const & a )
    { this->set_long(a); return * this; }

    GenericContainer & operator = ( float const & a )
    { this->set_real(real_type(a)); return * this; }

    GenericContainer & operator = ( double const & a )
    { this->set_real(real_type(a)); return * this; }

    GenericContainer & operator = ( complex<float> const & a )
    { this->set_complex(real_type(a.real()),real_type(a.imag())); return * this; }

    GenericContainer & operator = ( complex<double> const & a )
    { this->set_complex(real_type(a.real()),real_type(a.imag())); return * this; }

    GenericContainer & operator = ( vec_bool_type const & a );

    GenericContainer & operator = ( vec_int_type const & a );

    GenericContainer & operator = ( vec_long_type const & a );

    GenericContainer & operator = ( vec_real_type const & a );

    GenericContainer & operator = ( vec_complex_type const & a );

    GenericContainer & operator = ( vec_string_type const & a );

    GenericContainer & operator = ( mat_int_type const & a );

    GenericContainer & operator = ( mat_long_type const & a );

    GenericContainer & operator = ( mat_real_type const & a );

    GenericContainer & operator = ( mat_complex_type const & a );

    GenericContainer & operator = ( const char * a )
    { this->set_string(a); return * this; }

    GenericContainer & operator = ( string const & a )
    { this->set_string(a); return * this; }

    GenericContainer & operator = ( string_view a )
    { this->set_string(a); return * this; }

    GenericContainer & operator = ( pointer_type a )
    { this->set_pointer(a); return * this; }

    GenericContainer const & operator = ( GenericContainer const & a )
    { this->clear(); this->from_gc( a ); return * this; }

    void load( GenericContainer const & a ) { this->from_gc(a); }

    GenericContainer const & promote_to_int();

    GenericContainer const & promote_to_long();

    GenericContainer const & promote_to_real();

    GenericContainer const & promote_to_complex();

    GenericContainer const & promote_to_vec_int();

    GenericContainer const & promote_to_vec_long();

    GenericContainer const & promote_to_vec_real();

    GenericContainer const & promote_to_vec_complex();

    GenericContainer const & promote_to_mat_int();

    GenericContainer const & promote_to_mat_long();

    GenericContainer const & promote_to_mat_real();

    GenericContainer const & promote_to_mat_complex();

    GenericContainer const & promote_to_vector();



    GenericContainer( bool const & a )
    : m_data_type(GC_type::NOTYPE) { this->operator=(a); }

    GenericContainer( uint_type const & a )
    : m_data_type(GC_type::NOTYPE) { *this = a; }

    GenericContainer( int_type const & a )
    : m_data_type(GC_type::NOTYPE) { this->operator=(a); }

    GenericContainer( ulong_type const & a )
    : m_data_type(GC_type::NOTYPE) { *this = a; }

    GenericContainer( long_type const & a )
    : m_data_type(GC_type::NOTYPE) { this->operator=(a); }

    GenericContainer( float const & a )
    : m_data_type(GC_type::NOTYPE) { this->operator=(a); }

    GenericContainer( double const & a )
    : m_data_type(GC_type::NOTYPE) { this->operator=(a); }

    GenericContainer( complex<float> const & a )
    : m_data_type(GC_type::NOTYPE) { this->operator=(a); }

    GenericContainer( complex<double> const & a )
    : m_data_type(GC_type::NOTYPE) { this->operator=(a); }

    GenericContainer( char const * a )
    : m_data_type(GC_type::NOTYPE) { this->operator=(a); }

    GenericContainer( string const & a )
    : m_data_type(GC_type::NOTYPE) { this->operator=(a); }

    GenericContainer( string_view a )
    : m_data_type(GC_type::NOTYPE) { this->operator=(a); }

    GenericContainer( pointer_type a )
    : m_data_type(GC_type::NOTYPE) { this->set_pointer(a); }

    GenericContainer( GenericContainer const & gc )
    : m_data_type(GC_type::NOTYPE) { this->from_gc(gc); }



    bool exists( string_view s ) const;

    bool exists( vec_string_type const & vs ) const;

    string must_exists( vec_string_type const & vs, string_view const where ) const;

    bool get_if_exists( string_view field, bool & value ) const;

    bool get_if_exists( vec_string_type const & fields, bool & value ) const;

    bool get_if_exists( string_view field, int_type & value ) const;

    bool get_if_exists( string_view field, uint_type & value ) const;

    bool get_if_exists( string_view field, long_type & value ) const;

    bool get_if_exists( string_view field, ulong_type & value ) const;

    bool get_if_exists( string_view field, real_type & value ) const;

    bool get_if_exists( string_view field, complex_type & value ) const;

    bool get_if_exists( string_view field, string_type & value ) const;

    template <typename T>
    bool
    get_if_exists( vec_string_type const & fields, T & value ) const {
      for ( string_view field : fields ) {
        if ( get_if_exists( field, value ) ) return true;
      }
      return false;
    }

    template <typename T>
    bool
    get_if_exists( char const field[], T & value ) const {
      string_type field_str(field);
      return get_if_exists( field_str, value );
    }



    void
    print_content_types(
      ostream_type & stream,
      string_view    prefix = "",
      string_view    indent = "    "
    ) const;

    string
    compare_content( GenericContainer const & gc, string_view from = "" ) const;

    void
    dump(
      ostream_type & stream,
      string_view    prefix = "",
      string_view    indent = "    "
    ) const;

    void
    print(
      ostream_type & stream,
      string_view    prefix = "",
      string_view    indent = "    "
    ) const {
      this->dump( stream, prefix, indent );
    }

    string_type
    print(
      string_view prefix = "",
      string_view indent = "    "
    ) const {
      ostringstream ostr;
      ostr.precision(stream_number_precision);
      this->print(ostr,prefix,indent);
      return ostr.str();
    }

    void to_gc( GenericContainer & gc ) const;

    void from_gc( GenericContainer const & gc );

    void merge( GenericContainer const & gc, string_view const where );

    bool from_file( string_view file_name );

    void to_yaml( ostream_type & stream, string_view prefix = "" ) const;
    
    string
    to_yaml( string_view prefix = "" ) const
    { ostringstream ss; this->to_yaml( ss, prefix ); return ss.str(); }

    bool from_yaml( istream_type & stream );

    bool from_yaml( string const & data ) { istringstream ss(data); return this->from_yaml( ss ); }

    static
    GenericContainer gc_from_yaml( string const & yaml ) {
      GenericContainer gc;
      gc.from_yaml(yaml);
      return gc;
    }

    void to_json( ostream_type & stream, string_view prefix = "" ) const;
 
    string
    to_json( string_view prefix = "" ) const
    { ostringstream ss; this->to_json( ss, prefix ); return ss.str();}

    bool from_json( istream_type & stream );
    bool from_json2( istream_type & stream );
 
    bool from_json( string const & data ) { istringstream ss(data); return this->from_json( ss ); }

    static
    GenericContainer gc_from_json( string const & json ) {
      GenericContainer gc;
      gc.from_json(json);
      return gc;
    }

    bool to_toml( ostream_type & stream ) const;
 
    string
    to_toml() const
    { ostringstream ss; this->to_toml( ss ); return ss.str();}

    bool from_toml( istream_type & stream );
    
    bool from_toml( string const & data ) { istringstream ss(data); return this->from_toml( ss ); }

    static
    GenericContainer gc_from_toml( string const & toml ) {
      GenericContainer gc;
      gc.from_toml(toml);
      return gc;
    }

    void collapse();

    GenericContainer const &
    write_formatted_data( ostream_type & stream, char const delimiter = '\t' ) const;

    GenericContainer const &
    writeFormattedData( ostream_type & stream, char const delimiter = '\t' ) const {
      return this->write_formatted_data( stream, delimiter );
    }

    GenericContainer &
    read_formatted_data(
      istream_type & stream,
      char const commentChars[] = "#%",
      char const delimiters[]   = " \t"
    );

    GenericContainer &
    readFormattedData(
      istream_type & stream,
      char const commentChars[] = "#%",
      char const delimiters[]   = " \t"
    ) {
      return read_formatted_data( stream, commentChars, delimiters );
    }

    GenericContainer &
    read_formatted_data(
      char const fname[],
      char const commentChars[] = "#%",
      char const delimiters[]   = " \t"
    );

    GenericContainer &
    readFormattedData(
      char const fname[],
      char const commentChars[] = "#%",
      char const delimiters[]   = " \t"
    ) {
      return read_formatted_data( fname, commentChars, delimiters );
    }

    GenericContainer &
    read_formatted_data2(
      istream_type   & stream,
      char const       commentChars[] = "#%",
      char const       delimiters[]   = " \t",
      GenericContainer ptr_pars[]     = nullptr
    );

    GenericContainer &
    readFormattedData2(
      istream_type   & stream,
      char const       commentChars[] = "#%",
      char const       delimiters[]   = " \t",
      GenericContainer ptr_pars[]     = nullptr
    ) {
      return read_formatted_data2( stream, commentChars, delimiters, ptr_pars );
    }

    GenericContainer &
    read_formatted_data2(
      char const       fname[],
      char const       commentChars[] = "#%",
      char const       delimiters[]   = " \t",
      GenericContainer ptr_pars[]     = nullptr
    );

    GenericContainer &
    readFormattedData2(
      char const       fname[],
      char const       commentChars[] = "#%",
      char const       delimiters[]   = " \t",
      GenericContainer ptr_pars[]     = nullptr
    ) {
      return read_formatted_data2( fname, commentChars, delimiters, ptr_pars );
    }



    int32_t mem_size() const;

    int32_t serialize( int32_t buffer_dim, uint8_t * buffer ) const;

    int32_t serialize( vector<uint8_t> & buffer ) const;

    std::vector<uint8_t>
    serialize() const {
      std::vector<uint8_t> buffer( static_cast<std::size_t>(mem_size()) ); // allocate required space
      serialize(static_cast<int32_t>(buffer.size()), buffer.data());
      return buffer;
    }

    int32_t de_serialize( int32_t buffer_dim, uint8_t const * buffer );

    int32_t de_serialize( vector<uint8_t> const & buffer );


    static
    void
    exception( string_view const where ) GC_NO_RETURN;
 
  };
 
  // -------------------------------------------------------
  // support functions
  void
  write_table(
    vec_string_type const & headers,
    vector_type     const & data,
    ostream_type          & stream,
    char delimiter = '\t'
  );

  inline
  void
  writeTable(
    vec_string_type const & headers,
    vector_type     const & data,
    ostream_type          & stream,
    char delimiter = '\t'
  ) {
    write_table( headers, data, stream, delimiter );
  }

  void
  write_table(
    vec_string_type const & headers,
    mat_real_type   const & data,
    ostream_type          & stream,
    char delimiter = '\t'
  );

  inline
  void
  writeTable(
    vec_string_type const & headers,
    mat_real_type   const & data,
    ostream_type          & stream,
    char delimiter = '\t'
  ) {
    write_table( headers, data, stream, delimiter );
  }

  void
  write_table_formatted(
    vec_string_type const & headers,
    vector_type     const & data,
    ostream_type          & stream
  );

  inline
  void
  writeTableFormatted(
    vec_string_type const & headers,
    vector_type     const & data,
    ostream_type          & stream
  ) {
    write_table_formatted( headers, data, stream );
  }

  void
  write_table_formatted(
    vec_string_type const & headers,
    mat_real_type   const & data,
    ostream_type          & stream
  );

  inline
  void
  writeTableFormatted(
    vec_string_type const & headers,
    mat_real_type   const & data,
    ostream_type          & stream
  ) {
    write_table_formatted( headers, data, stream );
  }

  void string_escape( ostream_type & stream, string const & s );
 
}
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
  // do not define alias GC if use X11
  #ifndef XlibSpecificationRelease
  namespace GC = GC_namespace;
  #endif
 
  // for backward compatibility
  namespace GenericContainerNamespace = GC_namespace;
 
#endif
 
#ifdef __clang__
#pragma clang diagnostic pop
#endif
 
#endif
 
//
// eof: GenericContainer.hh
//