src/ecl_fixnum.cpp

   1
   2 namespace Ecl
   3 {
   4
   5 class Fixnum {
   6
   7 private:
   8     cl_fixnum the_fixnum;
   9
  10     Fixnum();
  11 public:
  12
  13     Fixnum(int i) : the_fixnum( MAKE_FIXNUM(i) )
  14     {
  15     }
  16
  17     Fixnum(long l) : the_fixnum( MAKE_FIXNUM(i) )
  18     {
  19     }
  20
  21     Fixnum(const cl_object& obj) :
  22     {
  23         the_fixnum = other.the_finxum;
  24     }
  25
  26     inline operator int() const
  27     {
  28 #ifdef NDEBUG
  29         return fix(the_fixnum);
  30 #else
  31         return fixint(the_fixnum);
  32 #endif
  33     }
  34
  35     inline operator long() const
  36     {
  37 #ifdef NDEBUG
  38         return fix(the_fixnum);
  39 #else
  40         return fixint(the_fixnum);
  41 #endif
  42     }
  43
  44
  45 };
  46
  47 class SingleFloat
  48 {
  49 private:
  50     cl_object my_float;
  51
  52     SingleFloat();
  53
  54 public:
  55     SingleFloat(float f) : my_float(ecl_make_singlefloat(f))
  56     {
  57     }
  58
  59     SingleFloat(const SingleFloat& other)
  60     {
  61         my_float = other.my_float;
  62     }
  63
  64     inline operator float() const {
  65         ecl_to_float(my_float);
  66     }
  67
  68     inline operator cl_object() const {
  69         return my_float;
  70     }
  71 };
  72
  73
  74 class String
  75 {
  76 private:
  77     cl_string the_string;
  78 public:
  79     String(std::string s) : my_string(s)
  80     {
  81         the_string = make_simple_string(s.c_str());
  82     }
  83
  84     String(const String& other)
  85     {
  86         my_string = other.my_string();
  87         the_string = make_simple_string(s.c_str());
  88     }
  89
  90     inline operator std::string() const
  91     {
  92         return std::string(the_string->self);
  93     }
  94
  95     inline operator cl_string()
  96     {
  97         return the_string;
  98     }
  99 };
 100
 101
 102 // to do -- maybe a template class specialised on differen types
 103 class Vector()
 104 {
 105 private:
 106     cl_object  my_array;
 107
 108 public:
 109
 110     Vector(std::size_t size, cl_eltype type)
 111     {
 112         my_array = si_make_vector(ecl_elttype_to_symbol(type), MAKE_FIXNUM(dim), Cnil, MAKE_FIXNUM(0), Cnil, MAKE_FIXNUM(0));
 113     }
 114
 115     inline std::size_t size() const
 116     {
 117         return my_array->dim;
 118     }
 119
 120     inline cl_eltype elements() const
 121     {
 122         return array_elttype(my_array);
 123     }
 124
 125     inline cl_object operator[](cl_index index) const
 126     {
 127         return aref1(my_array, index);
 128     }
 129
 130     // gratituous abuse of operator overloadin
 131     inline cl_object operator()(cl_index index, cl_object value)
 132     {
 133         return aset1(my_array, index, value);
 134     }
 135
 136     inline  operator cl_object() const
 137     {
 138         return my_array;
 139     }
 140 }
 141
 142 }