Variable.hpp

Go to the documentation of this file.

// ANNA - Anna is Not Nothingness Anymore                                                         //
//                                                                                                //
// (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
//                                                                                                //
// See project site at http://redmine.teslayout.com/projects/anna-suite                           //
// See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //


#ifndef anna_core_util_Variable_hpp
#define anna_core_util_Variable_hpp

#include <anna/core/util/defines.hpp>
#include <anna/core/RuntimeException.hpp>
#include <anna/core/define.autoenum.hpp>
#include <anna/core/util/String.hpp>
#include <anna/core/DataBlock.hpp>

namespace anna {

class Variable {
public:
  struct Type {
    enum _v {
      None = -1,
      Unused0,
      String, 
      Integer, 
      Unused1,
      Integer64, 
      Boolean = 5, 
      Block = 6, 
      Float, 
      Double, 
      Custom 
    };
    anna_declare_enum(Type)
  };

  // Constructores
  Variable(const char* name, std::string& value) :
    a_name(name),
    a_isNull(false),
    a_type(Type::String),
    a_isOwner(false) {
    a_value.a_string = &value;
  }


  Variable(const char* name, int& value) :
    a_name(name),
    a_isNull(false),
    a_type(Type::Integer),
    a_isOwner(false) {
    value = 0;
    a_value.a_integer = &value;
  }

  Variable(const char* name, S64& value) :
    a_name(name),
    a_isNull(false),
    a_type(Type::Integer64),
    a_isOwner(false) {
    value = 0;
    a_value.a_longInteger = &value;
  }

  Variable(const char* name, bool& value) :
    a_name(name),
    a_isNull(false),
    a_type(Type::Boolean),
    a_isOwner(false) {
    value = false;
    a_value.a_boolean = &value;
  }

  Variable(const char* name, DataBlock& value) :
    a_name(name),
    a_isNull(false),
    a_type(Type::Block),
    a_isOwner(false) {
    a_value.a_dataBlock = &value;
  }

  Variable(const char* name, float& value) :
    a_name(name),
    a_isNull(false),
    a_type(Type::Float),
    a_isOwner(false) {
    value = 0;
    a_value.a_float = &value;
  }

  Variable(const char* name, double& value) :
    a_name(name),
    a_isNull(false),
    a_type(Type::Double),
    a_isOwner(false) {
    value = 0;
    a_value.a_double = &value;
  }

  Variable(const char* name, void* value) :
    a_name(name),
    a_isNull(false),
    a_type(Type::Custom),
    a_isOwner(false) {
    a_value.a_custom = value;
  }

  Variable(const char* name, const Type::_v type);

  virtual ~Variable();

  // Accesores
  Type::_v getType() const { return a_type; }

  const char* getName() const { return a_name.c_str(); }

  bool isNull() const { return a_isNull; }

  const char* getStringValue() const noexcept(false);

  int getIntegerValue() const noexcept(false);

  S64 getInteger64Value() const noexcept(false);

  bool getBooleanValue() const noexcept(false) ;

  const DataBlock& getDataBlockValue() const noexcept(false) ;

  float getFloatValue() const noexcept(false);

  double getDoubleValue() const noexcept(false);

  void* getCustom() noexcept(false) {
    verifyMatchType(Type::Custom, ANNA_FILE_LOCATION);
    return a_value.a_custom;
  }

  const void* getCustom() const noexcept(false) {
    verifyMatchType(Type::Custom, ANNA_FILE_LOCATION);
    return a_value.a_custom;
  }

  void setCustom(void* value) noexcept(false) {
    verifyMatchType(Type::Custom, ANNA_FILE_LOCATION);
    a_isNull = (value == NULL);
    a_value.a_custom = value;
  }

  int getInteger() const { return *a_value.a_integer; }

  S64 getInteger64() const { return *a_value.a_longInteger; }

  bool getBoolean() const { return *a_value.a_boolean; }

  const DataBlock& getDataBlock() const { return *a_value.a_dataBlock; }

  float getFloat() const { return *a_value.a_float; }

  double getDouble() const { return *a_value.a_double; }

  // Modificadores
  void setValue(const char* value) noexcept(false);

  void setCharPointer(const char* value) noexcept(false);

  void setValue(const int value) noexcept(false);

  void setValue(const S64 value) noexcept(false) ;

  void setValue(const bool value) noexcept(false);

  void setValue(const DataBlock& value) noexcept(false) ;

  void setValue(const float value) noexcept(false) ;

  void setValue(const double value) noexcept(false) ;

  void setNull(const bool isNull = true) { a_isNull = isNull; }

  void setInteger(const int value) { *a_value.a_integer = value; a_isNull = false; }

  void setLong(const S64 value) { *a_value.a_longInteger = value; a_isNull = false; }

  void setBoolean(const bool value) { *a_value.a_boolean = value; a_isNull = false; }

  void setDataBlock(const DataBlock& value) { *a_value.a_dataBlock = value; a_isNull = false; }

  void setFloat(const float value) { *a_value.a_float = value; a_isNull = false; }

  void setDouble(const double value) { *a_value.a_double = value; a_isNull = false; }

  bool isEqual(const Variable& right) const { return a_name == right.a_name; }

  virtual String asString() const ;

protected:
  void* getReference() const ;

  void* buffer() const ;

  bool* getNullIndicator() { return &a_isNull; }

private:
  std::string a_name;
  bool a_isNull;
  const Type::_v a_type;
  const bool a_isOwner;

  union {
    std::string* a_string;
    int* a_integer;
    S64* a_longInteger;
    bool* a_boolean;
    DataBlock* a_dataBlock;
    float* a_float;
    double* a_double;
    void* a_custom;
  } a_value;
  struct {
    int integer;
    S64 longInteger;
    bool boolean;
    float theFloat;
    double theDouble;
  } a_aux;

  Variable(const Variable&);
  Variable& operator = (const Variable&);
  void verifyIsNotNull(const char* file, const int lineno) const noexcept(false);
  void verifyMatchSomeType(const Type::_v firstType, const Type::_v secondType, const char* file, const int lineno) const noexcept(false);
  void verifyMatchType(const Type::_v, const char* file, const int lineno) const noexcept(false);

};

}

#endif