/Users/barrand/private/dev/softinex/old/inexlib-1.2/inlib/inlib/value

Go to the documentation of this file.

// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file inlib.license for terms.

#ifndef inlib_value
#define inlib_value

#include <string>

#include "array"
#include "typedefs"
#include "tos" //for tos

#ifdef INLIB_MEM
#include "mem"
#endif

namespace inlib {

class value {
  static const std::string& s_class() {
    static const std::string s_v("inlib::value");
    return s_v;
  }
public:
  enum e_type {
    NONE = 0,
    // integers :
    //UNSIGNED_CHAR = 10,
    //CHAR = 11,
    UNSIGNED_SHORT = 12,
    SHORT = 13,
    UNSIGNED_INT = 14,
    INT = 15,
    UNSIGNED_INT64 = 16,
    INT64 = 17,
    // reals :
    FLOAT = 30,
    DOUBLE = 31,
    // else :
    BOOL = 50,
    STRING = 51,
    // pointers :
    VOID_STAR = 100,
    DOUBLE_STAR = 101,
    FLOAT_STAR = 102,
    INT_STAR = 103,

    // multidimensional vectors (1000+base type) :
    //ARRAY_UNSIGNED_CHAR = 1010,
    //ARRAY_CHAR = 1011,
    ARRAY_UNSIGNED_SHORT = 1012,
    ARRAY_SHORT = 1013,
    ARRAY_UNSIGNED_INT = 1014,
    ARRAY_INT = 1015,
    ARRAY_UNSIGNED_INT64 = 1016,
    ARRAY_INT64 = 1017,
    ARRAY_FLOAT = 1030,
    ARRAY_DOUBLE = 1031,
    ARRAY_BOOL = 1050,
    ARRAY_STRING = 1051
  };
public:
  value():m_label(0){
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
    m_type = NONE;
    u.m_unsigned_int64 = 0;
  }

  value(bool a_value):m_label(0) {
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
    m_type = BOOL;
    u.m_bool = a_value;
  }
//  value(char a_value):m_label(0) {
//#ifdef INLIB_MEM
//    mem::increment(s_class().c_str());
//#endif
//    m_type = CHAR;
//    u.m_char = a_value;
//  }
  value(short a_value):m_label(0) {
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
    m_type = SHORT;
    u.m_short = a_value;
  }
  value(int a_value):m_label(0) {
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
    m_type = INT;
    u.m_int = a_value;
  }
  value(int64 a_value):m_label(0) {
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
    m_type = INT64;
    u.m_int64 = a_value;
  }
  value(uint64 a_value):m_label(0) {
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
    m_type = UNSIGNED_INT64;
    u.m_unsigned_int64 = a_value;
  }
  value(float a_value):m_label(0) {
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
    m_type = FLOAT;
    u.m_float = a_value;
  }
  value(double a_value):m_label(0) {
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
    m_type = DOUBLE;
    u.m_double = a_value;
  }

//  value(unsigned char a_value):m_label(0) {
//#ifdef INLIB_MEM
//    mem::increment(s_class().c_str());
//#endif
//    m_type = UNSIGNED_CHAR;
//    u.m_unsigned_char = a_value;
//  }
  value(unsigned short a_value):m_label(0) {
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
    m_type = UNSIGNED_SHORT;
    u.m_unsigned_short = a_value;
  }
  value(unsigned int a_value):m_label(0) {
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
    m_type = UNSIGNED_INT;
    u.m_unsigned_int = a_value;
  }
  value(void* a_value):m_label(0) {
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
    m_type = VOID_STAR;
    u.m_void_star = a_value;
  }
  value(double* a_value):m_label(0) {
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
    m_type = DOUBLE_STAR;
    u.m_double_star = a_value;
  }
  value(float* a_value):m_label(0) {
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
    m_type = FLOAT_STAR;
    u.m_float_star = a_value;
  }
  value(int* a_value):m_label(0) {
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
    m_type = INT_STAR;
    u.m_int_star = a_value;
  }

  value(const char* a_value):m_label(0) {
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
    m_type = STRING;
    u.m_string = new std::string(a_value?a_value:"");
  }
  value(const std::string& a_value):m_label(0) {
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
    m_type = STRING;
    u.m_string = new std::string(a_value);
  }
/*
  Value(const std::vector<double>& aValue):fLabel(0),fDimension(0){
    //Debug::increment("Lib::Value");
    fType = ARRAY_DOUBLE;
    std::vector<unsigned int> is(1);
    is[0] = aValue.size();
    u.f_array_double = new inlib::array<double>(is);
    u.f_array_double->fill(aValue);
  }

#define SLASH_VALUE_CSTOR(a_what,a_f_what,a_type) \
  Value(const std::vector<unsigned int>& aOrders,\
               const std::vector<a_what>& aValues)\
  :fLabel(0),fDimension(0){\
    fType = a_type;\
    u.a_f_what = new inlib::array<a_what>(aOrders);\
    u.a_f_what->fill(aValues);\
  }

  SLASH_VALUE_CSTOR(unsigned char,f_array_unsigned_char,Slash::Core::IValue::ARRAY_UNSIGNED_CHAR)
  SLASH_VALUE_CSTOR(char,f_array_char,Slash::Core::IValue::ARRAY_CHAR)
  SLASH_VALUE_CSTOR(unsigned short,f_array_unsigned_short,Slash::Core::IValue::ARRAY_UNSIGNED_SHORT)
  SLASH_VALUE_CSTOR(short,f_array_short,Slash::Core::IValue::ARRAY_SHORT)
  SLASH_VALUE_CSTOR(unsigned int,f_array_unsigned_int,Slash::Core::IValue::ARRAY_UNSIGNED_INT)
  SLASH_VALUE_CSTOR(int,f_array_int,Slash::Core::IValue::ARRAY_INT)
  SLASH_VALUE_CSTOR(Slash::uint64,f_array_unsigned_int64,Slash::Core::IValue::ARRAY_UNSIGNED_INT64)
  SLASH_VALUE_CSTOR(Slash::int64,f_array_int64,Slash::Core::IValue::ARRAY_INT64)
  SLASH_VALUE_CSTOR(float,f_array_float,Slash::Core::IValue::ARRAY_FLOAT)
  SLASH_VALUE_CSTOR(double,f_array_double,Slash::Core::IValue::ARRAY_DOUBLE)
  SLASH_VALUE_CSTOR(bool,f_array_bool,Slash::Core::IValue::ARRAY_BOOL)
  SLASH_VALUE_CSTOR(std::string,f_array_string,Slash::Core::IValue::ARRAY_STRING)

#undef SLASH_VALUE_CSTOR

*/

  virtual ~value() {
    delete m_label;
    reset();
#ifdef INLIB_MEM
    mem::decrement(s_class().c_str());
#endif
  }
public:
  value(const value& a_from):m_label(0){
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif

    if(a_from.m_label) m_label = new std::string(*a_from.m_label);
    m_type = a_from.m_type;

    if(a_from.m_type==STRING) {
      u.m_string = new std::string(*a_from.u.m_string);

    //} else if(a_from.m_type==ARRAY_UNSIGNED_CHAR) {
    //  u.m_array_unsigned_char = 
    //    new array<unsigned char>(*a_from.u.m_array_unsigned_char);

    //} else if(a_from.m_type==ARRAY_CHAR) {
    //  u.m_array_char = new array<char>(*a_from.u.m_array_char);

    } else if(a_from.m_type==ARRAY_UNSIGNED_SHORT) {
      u.m_array_unsigned_short = 
        new array<unsigned short>(*a_from.u.m_array_unsigned_short);

    } else if(a_from.m_type==ARRAY_SHORT) {
      u.m_array_short = new array<short>(*a_from.u.m_array_short);

    } else if(a_from.m_type==ARRAY_UNSIGNED_INT) {
      u.m_array_unsigned_int = 
        new array<unsigned int>(*a_from.u.m_array_unsigned_int);

    } else if(a_from.m_type==ARRAY_INT) {
      u.m_array_int = new array<int>(*a_from.u.m_array_int);

    } else if(a_from.m_type==ARRAY_UNSIGNED_INT64) {
      u.m_array_unsigned_int64 = 
        new array<uint64>(*a_from.u.m_array_unsigned_int64);

    } else if(a_from.m_type==ARRAY_INT64) {
      u.m_array_int64 = new array<int64>(*a_from.u.m_array_int64);

    } else if(a_from.m_type==ARRAY_FLOAT) {
      u.m_array_float = new array<float>(*a_from.u.m_array_float);

    } else if(a_from.m_type==ARRAY_DOUBLE) {
      u.m_array_double = new array<double>(*a_from.u.m_array_double);

    } else if(a_from.m_type==ARRAY_BOOL) {
      u.m_array_bool = new array<bool>(*a_from.u.m_array_bool);

    } else if(a_from.m_type==ARRAY_STRING) {
      u.m_array_string = new array<std::string>(*a_from.u.m_array_string);

    } else {
      u = a_from.u;
    }
  }

  value& operator=(const value& a_from) {
    delete m_label;
    m_label = 0;
    if(a_from.m_label) m_label = new std::string(*a_from.m_label);
    reset();

    m_type = a_from.m_type;

    if(a_from.m_type==STRING) {
      u.m_string = new std::string(*a_from.u.m_string);

    //} else if(a_from.m_type==ARRAY_UNSIGNED_CHAR) {
    //  u.m_array_unsigned_char =
    //    new array<unsigned char>(*a_from.u.m_array_unsigned_char);

    //} else if(a_from.m_type==ARRAY_CHAR) {
    //  u.m_array_char = new array<char>(*a_from.u.m_array_char);

    } else if(a_from.m_type==ARRAY_UNSIGNED_SHORT) {
      u.m_array_unsigned_short = 
        new array<unsigned short>(*a_from.u.m_array_unsigned_short);

    } else if(a_from.m_type==ARRAY_SHORT) {
      u.m_array_short = new array<short>(*a_from.u.m_array_short);

    } else if(a_from.m_type==ARRAY_UNSIGNED_INT) {
      u.m_array_unsigned_int = 
        new array<unsigned int>(*a_from.u.m_array_unsigned_int);

    } else if(a_from.m_type==ARRAY_INT) {
      u.m_array_int = new array<int>(*a_from.u.m_array_int);

    } else if(a_from.m_type==ARRAY_UNSIGNED_INT64) {
      u.m_array_unsigned_int64 = 
        new array<uint64>(*a_from.u.m_array_unsigned_int64);

    } else if(a_from.m_type==ARRAY_INT64) {
      u.m_array_int64 = new array<int64>(*a_from.u.m_array_int64);

    } else if(a_from.m_type==ARRAY_FLOAT) {
      u.m_array_float = new array<float>(*a_from.u.m_array_float);

    } else if(a_from.m_type==ARRAY_DOUBLE) {
      u.m_array_double = new array<double>(*a_from.u.m_array_double);

    } else if(a_from.m_type==ARRAY_BOOL) {
      u.m_array_bool = new array<bool>(*a_from.u.m_array_bool);

    } else if(a_from.m_type==ARRAY_STRING) {
      u.m_array_string = new array<std::string>(*a_from.u.m_array_string);
  
    } else {
      u = a_from.u;
    }

    return *this;
  }
public:
  void set_label(const std::string& a_s) {
    delete m_label;
    m_label = new std::string(a_s);
  }
  std::string label() const {return m_label?(*m_label):"";}

  e_type type() const {return m_type;}
  void set_type(e_type a_type) {
    reset();
    m_type = a_type;
    switch(a_type) {
    case NONE:      u.m_unsigned_int64 = 0;break;
    //case UNSIGNED_CHAR:    u.m_unsigned_char = 0;break;
    //case CHAR:      u.m_char = 0;break;
    case UNSIGNED_SHORT:   u.m_unsigned_short = 0;break;
    case SHORT:     u.m_short = 0;break;
    case UNSIGNED_INT:     u.m_unsigned_int = 0;break;
    case INT:       u.m_int = 0;break;
    case UNSIGNED_INT64:   u.m_unsigned_int64 =0;break;
    case INT64:     u.m_int64 = 0;break;
    case FLOAT:     u.m_float = 0;break;
    case DOUBLE:    u.m_double = 0;break;
    case BOOL:      u.m_bool = false;break;
    case VOID_STAR:        u.m_void_star = 0;break;
    case DOUBLE_STAR:      u.m_double_star = 0;break;
    case FLOAT_STAR:       u.m_float_star = 0;break;
    case INT_STAR:         u.m_int_star = 0;break;
    case STRING:       u.m_string = new std::string("");break;
    //case ARRAY_UNSIGNED_CHAR:
    //  u.m_array_unsigned_char = new inlib::array<unsigned char>();break;
    //case ARRAY_CHAR:u.m_array_char = new inlib::array<char>();break;
  
    case ARRAY_UNSIGNED_SHORT:
      u.m_array_unsigned_short = new inlib::array<unsigned short>();break;
    case ARRAY_SHORT:u.m_array_short = new inlib::array<short>();break;
  
    case ARRAY_UNSIGNED_INT:
      u.m_array_unsigned_int = new inlib::array<unsigned int>();break;
    case ARRAY_INT:u.m_array_int = new inlib::array<int>();break;
    case ARRAY_UNSIGNED_INT64:
      u.m_array_unsigned_int64 = new inlib::array<uint64>();break;
    case ARRAY_INT64:u.m_array_int64 = new inlib::array<int64>();break;
  
    case ARRAY_FLOAT:u.m_array_float = new inlib::array<float>();break;
    case ARRAY_DOUBLE:u.m_array_double = new inlib::array<double>();break;
    case ARRAY_BOOL:u.m_array_bool = new inlib::array<bool>();break;
    case ARRAY_STRING:u.m_array_string = new inlib::array<std::string>();break;
    }
  }

  void set(void* a_value) {
    reset();
    m_type = VOID_STAR;
    u.m_void_star = a_value;
  }

  unsigned char get_unsigned_char() const {return u.m_unsigned_char;}
  char get_char() const {return u.m_char;}
  unsigned int get_unsigned_int() const {return u.m_unsigned_int;}
  int get_int() const {return u.m_int;}

  int64 get_int64() const {return u.m_int64;}
  uint64 get_unsigned_int64() const {return u.m_unsigned_int64;}

  unsigned short get_unsigned_short() const{return u.m_unsigned_short;}
  short get_short() const {return u.m_short;}
  float get_float() const {return u.m_float;}
  double get_double() const {return u.m_double;}
  void* get_void_star() const {return u.m_void_star;}
  double* get_double_star() const {return u.m_double_star;}
  float* get_float_star() const {return u.m_float_star;}
  int* get_int_star() const {return u.m_int_star;}
  bool get_bool() const {return u.m_bool;}
  std::string get_string() const {return *u.m_string;}

public:
  bool s_type(std::string& a_s) const {return s_type(m_type,a_s);}
  static bool s_type(inlib::value::e_type a_type,std::string& a_s){
    switch(a_type) {
    case NONE:a_s = "NONE";return true;
    case INT:a_s = "INT";return true;
    case INT64:a_s = "INT64";return true;
    case DOUBLE:a_s = "DOUBLE";return true;
    case STRING:a_s = "STRING";return true;
    case VOID_STAR:a_s = "VOID_STAR";return true;
    case DOUBLE_STAR:a_s = "DOUBLE_STAR";return true;
    case FLOAT_STAR:a_s = "FLOAT_STAR";return true;
    case INT_STAR:a_s = "INT_STAR";return true;
    case BOOL:a_s = "BOOL";return true;
    case SHORT:a_s = "SHORT";return true;
    case FLOAT:a_s = "FLOAT";return true;
    //case CHAR:a_s = "CHAR";return true;
    //case UNSIGNED_CHAR:a_s = "UNSIGNED_CHAR";return true;
    case UNSIGNED_SHORT:a_s = "UNSIGNED_SHORT";return true;
    case UNSIGNED_INT:a_s = "UNSIGNED_INT";return true;
    case UNSIGNED_INT64:a_s = "UNSIGNED_INT64";return true;
    //case ARRAY_UNSIGNED_CHAR:a_s = "ARRAY_UNSIGNED_CHAR";return true;
    //case ARRAY_CHAR:a_s = "ARRAY_CHAR";return true;
    case ARRAY_UNSIGNED_SHORT:a_s = "ARRAY_UNSIGNED_SHORT";return true;
    case ARRAY_SHORT:a_s = "ARRAY_SHORT";return true;
    case ARRAY_UNSIGNED_INT:a_s = "ARRAY_UNSIGNED_INT";return true;
    case ARRAY_INT:a_s = "ARRAY_INT";return true;
    case ARRAY_UNSIGNED_INT64:a_s = "ARRAY_UNSIGNED_INT64";return true;
    case ARRAY_INT64:a_s = "ARRAY_INT64";return true;
    case ARRAY_FLOAT:a_s = "ARRAY_FLOAT";return true;
    case ARRAY_DOUBLE:a_s = "ARRAY_DOUBLE";return true;
    case ARRAY_BOOL:a_s = "ARRAY_BOOL";return true;
    case ARRAY_STRING:a_s = "ARRAY_STRING";return true;
    default:a_s.clear();return false;
    }

  }
  bool tos(std::string& a_s) const {return tos(*this,a_s);}

  static bool tos(const value& a_v,std::string& a_s){
    switch(a_v.m_type) {
    case NONE:
      inlib::sprintf(a_s,5,"(nil)");
      return true;
    case INT:
      inlib::sprintf(a_s,16,"%d",a_v.u.m_int);
      return true;
    case DOUBLE:
      inlib::sprintf(a_s,16,"%g",a_v.u.m_double);
      return true;
    case VOID_STAR:
      inlib::sprintf(a_s,16,"0x%lx",(unsigned long)a_v.u.m_void_star);
      return true;
    case UNSIGNED_SHORT:
      inlib::sprintf(a_s,16,"%u",a_v.u.m_unsigned_short);
      return true;
    case UNSIGNED_INT:
      inlib::sprintf(a_s,16,"%u",a_v.u.m_unsigned_int);
      return true;
    case BOOL:
      inlib::sprintf(a_s,5,"%s",a_v.u.m_bool?"true":"false");
      return true;
    case SHORT:
      inlib::sprintf(a_s,16,"%d",a_v.u.m_short);
      return true;
    case INT64:
      inlib::sprintf(a_s,16,inlib::int64_format(),a_v.u.m_int64);
      return true;
    case UNSIGNED_INT64:
      inlib::sprintf(a_s,16,inlib::int64_format(),a_v.u.m_unsigned_int64);
      return true;
    case FLOAT:
      inlib::sprintf(a_s,16,"%g",a_v.u.m_float);
      return true;
    //case UNSIGNED_CHAR:
    //  inlib::sprintf(a_s,16,"%c",a_v.u.m_unsigned_char);
    //  return true;
    //case CHAR:
    //  inlib::sprintf(a_s,16,"%c",a_v.u.m_char);
    //  return true;
    case DOUBLE_STAR:
      inlib::sprintf(a_s,16,"0x%lx",(unsigned long)a_v.u.m_double_star);
      return true;
    case FLOAT_STAR:
      inlib::sprintf(a_s,16,"0x%lx",(unsigned long)a_v.u.m_float_star);
      return true;
    case INT_STAR:
      inlib::sprintf(a_s,16,"0x%lx",(unsigned long)a_v.u.m_int_star);
      return true;
    case STRING:
      a_s = *a_v.u.m_string;
      return true;

    //case ARRAY_UNSIGNED_CHAR:
    //  a_s = inlib::tos<unsigned char>(a_v.u.m_array_unsigned_char->vector());
    //  return true;
    //case ARRAY_CHAR:
    //  a_s = inlib::tos<char>(a_v.u.m_array_char->vector());
    //  return true;
  
    case ARRAY_UNSIGNED_SHORT:
      a_s = inlib::tos<unsigned short>(a_v.u.m_array_unsigned_short->vector());
      return true;
    case ARRAY_SHORT:
      a_s = inlib::tos<short>(a_v.u.m_array_short->vector());
      return true;
  
    case ARRAY_UNSIGNED_INT:
      a_s = inlib::tos<unsigned int>(a_v.u.m_array_unsigned_int->vector());
      return true;
    case ARRAY_INT:
      a_s = inlib::tos<int>(a_v.u.m_array_int->vector());
      return true;
  
    case ARRAY_UNSIGNED_INT64:
      a_s = inlib::tos<uint64>(a_v.u.m_array_unsigned_int64->vector());
      return true;
    case ARRAY_INT64:
      a_s = inlib::tos<int64>(a_v.u.m_array_int64->vector());
      return true;
  
    case ARRAY_FLOAT:
      a_s = inlib::tos<float>(a_v.u.m_array_float->vector());
      return true;
    case ARRAY_DOUBLE:
      a_s = inlib::tos<double>(a_v.u.m_array_double->vector());
      return true;
    case ARRAY_BOOL:
      a_s = inlib::tos<bool>(a_v.u.m_array_bool->vector());
      return true;
    case ARRAY_STRING:
      a_s = inlib::tos<std::string>(a_v.u.m_array_string->vector());
      return true;
    default:
      a_s.clear();  
      return false;
    }
  }
/*
*/
protected:
  void reset() {
    if(m_type==STRING) {
      delete u.m_string;
      u.m_string = 0;
  
    //} else if(m_type==ARRAY_UNSIGNED_CHAR) {
    //  delete u.m_array_unsigned_char;u.m_array_unsigned_char = 0;

    //} else if(m_type==ARRAY_CHAR) {
    //  delete u.m_array_char;u.m_array_char = 0;

    } else if(m_type==ARRAY_UNSIGNED_SHORT) {
      delete u.m_array_unsigned_short;u.m_array_unsigned_short = 0;

    } else if(m_type==ARRAY_SHORT) {
      delete u.m_array_short;u.m_array_short = 0;

    } else if(m_type==ARRAY_UNSIGNED_INT) {
      delete u.m_array_unsigned_int;u.m_array_unsigned_int = 0;

    } else if(m_type==ARRAY_INT) {
      delete u.m_array_int;u.m_array_int = 0;

    } else if(m_type==ARRAY_UNSIGNED_INT64) {
      delete u.m_array_unsigned_int64;u.m_array_unsigned_int64 = 0;

    } else if(m_type==ARRAY_INT64) {
      delete u.m_array_int64;u.m_array_int64 = 0;

    } else if(m_type==ARRAY_FLOAT) {
      delete u.m_array_float;u.m_array_float = 0;

    } else if(m_type==ARRAY_DOUBLE) {
      delete u.m_array_double;u.m_array_double = 0;

    } else if(m_type==ARRAY_BOOL) {
      delete u.m_array_bool;u.m_array_bool = 0;

    } else if(m_type==ARRAY_STRING) {
      delete u.m_array_string;u.m_array_string = 0;

    } else {
      u.m_unsigned_int64 = 0;
    }
  }
protected:
  std::string* m_label;
  //unsigned int m_dim;
protected:
  e_type m_type;
  union {
    bool m_bool;
    char m_char;
    int m_int;
    short m_short;
    int64 m_int64;
    float m_float;
    double m_double;
    unsigned char m_unsigned_char;
    unsigned short m_unsigned_short;
    unsigned int m_unsigned_int;
    uint64 m_unsigned_int64;
    void* m_void_star;
    double* m_double_star;
    float* m_float_star;
    int* m_int_star;
    std::string* m_string;

    inlib::array<unsigned char>* m_array_unsigned_char;
    inlib::array<char>* m_array_char;
    inlib::array<unsigned short>* m_array_unsigned_short;
    inlib::array<short>* m_array_short;
    inlib::array<uint64>* m_array_unsigned_int64;
    inlib::array<int64>* m_array_int64;
    inlib::array<unsigned int>* m_array_unsigned_int;
    inlib::array<int>* m_array_int;
    inlib::array<float>* m_array_float;
    inlib::array<double>* m_array_double;
    inlib::array<bool>* m_array_bool;
    inlib::array<std::string>* m_array_string;
  } u;
};

}

#endif