AndroMeta/include/AndroMeta/MVar.h

Go to the documentation of this file.

/*
 * Copyright 2009-2012 AndroMeta LLC. All rights reserved.
 *
 * AndroMeta LLC retains all intellectual property and proprietary 
 * rights to this software and related documentation and any modifications 
 * thereto.  Any use, reproduction, disclosure, or distribution of this 
 * software and related documentation without an express license agreement 
 * from AndroMeta LLC is strictly prohibited.
 * 
 */

#ifndef ANDROMETA_M_VAR_H
#define ANDROMETA_M_VAR_H

#include <ostream>

#include <AndroMeta/MStr.h>
#include <AndroMeta/MVector.h>
#include <AndroMeta/MList.h>
#include <AndroMeta/MMap.h>
#include <AndroMeta/MRational.h>
#include <AndroMeta/MReal.h>
#include <AndroMeta/MNode.h>

namespace Meta{
  
  class MVar;
  class MObjectBase;
  class MObject;
  
  typedef MVector<MVar> mvec;
  typedef MList<MVar> mlist;
  typedef MMap<mstr, MVar> mmap;
  
  extern const class MVar undef;
  
  class MVar{
  public:
    typedef uint16_t Type;
    
    static const Type NumericMask =        0x0010;
    static const Type DefinedNumericMask = 0x0020;
    
    static const Type Undefined =          0x0010;
    static const Type Constant =           0x0031;
    static const Type Integer =            0x0032;
    static const Type Rational =           0x0033;
    static const Type Float =              0x0034;
    static const Type Real =               0x0036;
    
    static const Type StringMask =         0x0040;
    static const Type String =             0x0040;
    static const Type Symbol =             0x0041;
    static const Type Function =           0x0042;
    
    static const Type ObjectMask =         0x0080;
    static const Type ObjectPointer =      0x0081;
    static const Type LocalObject =        0x0082;
    static const Type SharedObject =       0x0083;
    
    static const Type RawPointer =         0x0100;
    
    static const Type CodeDataMask =       0x0200;
    
    MVar();
    
    MVar(bool x);
    
    MVar(uint8_t x);
    
    MVar(int8_t x);
    
    MVar(uint16_t x);
    
    MVar(int16_t x);
    
    MVar(uint32_t x);
    
    MVar(int32_t x);
    
    MVar(uint64_t x);
    
    MVar(int64_t x);
    
#if defined (__i386__) || defined (__APPLE__)    
    
    MVar(long int x);
    
    MVar(unsigned long int x);
    
#endif
    
    MVar(double x);
    
    MVar(float x);
    
    MVar(const MVar& v);
    
    MVar(const mstr& str, Type t=String);
    
    MVar(const std::string& str, Type t=String);
    
    MVar(const char* str, Type t=String);
    
    MVar(mstr* str, Type t=String);
    
    MVar(MObjectBase* o, Type t=ObjectPointer);
    
    MVar(void* p);
    
    MVar(const MObjectBase& o);
    
    MVar(const mnode& n);
    
    MVar(const mvec& v);
    
    MVar(const mlist& l);
    
    MVar(const mrat& x);
    
    MVar(const mreal& x);
    
    ~MVar();
    
    bool isTrue() const{
      return type_ == Constant && data_.i == 1;
    }
    
    bool isFalse() const{
      return type_ == Constant && data_.i == 0;
    }
    
    mstr& asStr();
    
    const mstr& asStr() const;
    
    mstr& str(){
      return asStr();
    }
    
    const mstr& str() const{
      return asStr();
    }
    
    const char* cstr() const{
      return asStr().c_str();
    }
    
    void convertNode(const mnode& n, bool indexKeys=false);
    
    mstr toStr(bool concise=true,
               bool quote=false,
               bool mml=true) const;
    
    const char* asCStr() const{
      return asStr().c_str();
    }
    
    std::string toStdStr() const{
      return toStr().str();
    }
    
    const int64_t& asLong() const;
    
    int64_t& asLong();
    
    int64_t toLong() const;
    
    double& asDouble();
    
    const double& asDouble() const;
    
    double toDouble() const;
    
    const mrat& asRat() const;
    
    mrat& asRat();
    
    mrat toRat() const;
    
    const mreal& asReal() const;
    
    mreal& asReal();
    
    mreal toReal() const;
    
    size_t asSize() const;
    
    MObjectBase* asObj() const;
    
    MObjectBase* obj() const;
    
#ifndef ANDROMETA_NO_OBJECT
    
    MObject* oc() const;
    
#endif
    
    void* asPtr() const;
    
    void* ptr() const{
      return asPtr();
    }
    
    const mvec& vec() const;
    
    mvec& vec();
    
    operator const mvec&() const{
      return vec();
    }
    
    operator mvec&(){
      return vec();
    }
    
    const mlist& list() const;
    
    mlist& list();
    
    operator const mlist&() const{
      return list();
    }
    
    operator mlist&(){
      return list();
    }
    
    const mmap& map() const;
    
    mmap& map();
    
    mvec toVec() const;
    
    mlist toList() const;
    
    operator const mmap&() const{
      return map();
    }
    
    operator mmap&(){
      return map();
    }
    
    operator double() const{
      return toDouble();
    }
    
    operator uint8_t() const{
      return toLong();
    }
    
    operator int8_t() const{
      return toLong();
    }
    
    operator uint16_t() const{
      return toLong();
    }
    
    operator int16_t() const{
      return toLong();
    }
    
    operator uint32_t() const{
      return (uint32_t)toLong();
    }
    
    operator int32_t() const{
      return (int32_t)toLong();
    }
    
    operator uint64_t() const{
      return toLong();
    }
    
    operator int64_t() const{
      return toLong();
    }
    
#if defined (__i386__) || defined (__APPLE__)      
    
    operator unsigned long int() const{
      return (unsigned long int)toLong();
    }
    
    operator long int() const{
      return (long int)toLong();
    }
    
#endif
    
    operator const char*() const{
      return asStr().c_str();
    }
    
    operator mstr&(){
      return str();
    }
    
    operator const mstr&() const{
      return asStr();
    }
    
    operator float() const{
      return toDouble();
    }
    
    operator bool() const{
      return toBool();
    }
    
    MVar& operator=(const MVar& v);
    
    MVar& operator=(const MStr& s);
    
    MVar& operator=(const std::string& s){
      return *this = MStr(s);
    }
    
    MVar& operator=(const char* s){
      return *this = MStr(s);
    }
    
    template<typename T>
    MVar& operator=(const T& t){
      return *this = MVar(t);
    }
    
    MVar& operator+=(const MVar& v){
      if(type_ == Float){
        if(v.type_ == Float){
          data_.f += v.data_.f;
          return *this;
        }
        else if(v.type_ & DefinedNumericMask){
          data_.f += v.toDouble();
          return *this;
        }
      }
      
      return addA(v);
    }
    
    MVar& addA(const MVar& v);
    
    MVar operator+(const MVar& v) const{
      MVar ret(*this);
      return ret += v;
    }
    
    template<typename T>
    MVar operator+(T& x) const{
      MVar ret(*this);
      return ret += MVar(x);
    }
    
    MVar operator+(uint32_t x) const{
      MVar ret(*this);
      return ret += MVar(x);
    }
    
    MVar operator+(int32_t x) const{
      MVar ret(*this);
      return ret += MVar(x);
    }
    
    MVar operator+(uint64_t x) const{
      MVar ret(*this);
      return ret += MVar(x);
    }
    
    MVar operator+(int64_t x) const{
      MVar ret(*this);
      return ret += MVar(x);
    }
    
#if defined (__i386__) || defined (__APPLE__)
    
    MVar operator+(unsigned long int x) const{
      MVar ret(*this);
      return ret += MVar(x);
    }
    
    MVar operator+(long int x) const{
      MVar ret(*this);
      return ret += MVar(x);
    }
    
#endif
    
    MVar operator+(double x) const{
      MVar ret(*this);
      return ret += MVar(x);
    }
    
    MVar operator++(int){
      MVar ret(*this);
      *this += 1;
      return ret;
    }
    
    MVar& operator++(){
      return *this += 1;
    }
    
    MVar& operator-=(const MVar& v){
      if(type_ == Float){
        if(v.type_ == Float){
          data_.f -= v.data_.f;
          return *this;
        }
        else if(v.type_ & DefinedNumericMask){
          data_.f -= v.toDouble();
          return *this;
        }
      }
      
      return subA(v);
    }
    
    MVar& subA(const MVar& v);
    
    MVar operator-(const MVar& v) const{
      MVar ret(*this);
      return ret -= v;
    }
    
    template<typename T>
    MVar operator-(T& x) const{
      MVar ret(*this);
      return ret -= MVar(x);
    }
    
    MVar operator-(uint32_t x) const{
      MVar ret(*this);
      return ret -= MVar(x);
    }
    
    MVar operator-(int32_t x) const{
      MVar ret(*this);
      return ret -= MVar(x);
    }
    
    MVar operator-(uint64_t x) const{
      MVar ret(*this);
      return ret -= MVar(x);
    }
    
    MVar operator-(int64_t x) const{
      MVar ret(*this);
      return ret -= MVar(x);
    }
    
#if defined (__i386__) || defined (__APPLE__)
    
    MVar operator-(unsigned long int x) const{
      MVar ret(*this);
      return ret -= MVar(x);
    }
    
    MVar operator-(long int x) const{
      MVar ret(*this);
      return ret -= MVar(x);
    }
    
#endif
    
    MVar operator-(double x) const{
      MVar ret(*this);
      return ret -= MVar(x);
    }
    
    MVar operator--(int){
      MVar ret(*this);
      *this -= 1;
      return ret;
    }
    
    MVar& operator--(){
      return *this -= 1;
    }
    
    MVar operator-() const{
      if(type_ == Float){
        return -data_.f;
      }
      
      return neg();
    }
    
    MVar neg() const;
    
    MVar& operator*=(const MVar& v){
      if(type_ == Float){
        if(v.type_ == Float){
          data_.f *= v.data_.f;
          return *this;
        }
        else if(v.type_ & DefinedNumericMask){
          data_.f *= v.toDouble();
          return *this;
        }
      }
      
      return mulA(v);
    }
    
    MVar& mulA(const MVar& v);
    
    MVar operator*(const MVar& v) const{
      MVar ret(*this);
      return ret *= v;
    }
    
    template<typename T>
    MVar operator*(T& x) const{
      MVar ret(*this);
      return ret *= MVar(x);
    }
    
    MVar operator*(uint32_t x) const{
      MVar ret(*this);
      return ret *= MVar(x);
    }
    
    MVar operator*(int32_t x) const{
      MVar ret(*this);
      return ret *= MVar(x);
    }
    
    MVar operator*(uint64_t x) const{
      MVar ret(*this);
      return ret *= MVar(x);
    }
    
    MVar operator*(int64_t x) const{
      MVar ret(*this);
      return ret *= MVar(x);
    }
    
#if defined (__i386__) || defined (__APPLE__)
    
    MVar operator*(unsigned long int x) const{
      MVar ret(*this);
      return ret *= MVar(x);
    }
    
    MVar operator*(long int x) const{
      MVar ret(*this);
      return ret *= MVar(x);
    }
    
#endif
    
    MVar operator*(double x) const{
      MVar ret(*this);
      return ret *= MVar(x);
    }
    
    MVar& operator/=(const MVar& v){
      if(type_ == Float){
        if(v.type_ == Float){
          data_.f /= v.data_.f;
          return *this;
        }
        else if(v.type_ & DefinedNumericMask){
          data_.f /= v.toDouble();
          return *this;
        }
      }
      
      return divA(v);
    }
    
    MVar& divA(const MVar& v);
    
    MVar operator/(const MVar& v) const{
      MVar ret(*this);
      return ret /= v;
    }
    
    template<typename T>
    MVar operator/(T& x) const{
      MVar ret(*this);
      return ret /= MVar(x);
    }
    
    MVar operator/(uint32_t x) const{
      MVar ret(*this);
      return ret /= MVar(x);
    }
    
    MVar operator/(int32_t x) const{
      MVar ret(*this);
      return ret /= MVar(x);
    }
    
    MVar operator/(uint64_t x) const{
      MVar ret(*this);
      return ret /= MVar(x);
    }
    
    MVar operator/(int64_t x) const{
      MVar ret(*this);
      return ret /= MVar(x);
    }
    
    MVar operator/(double x) const{
      MVar ret(*this);
      return ret /= MVar(x);
    }
    
#if defined (__i386__) || defined (__APPLE__)     
    
    MVar operator/(unsigned long int x) const{
      MVar ret(*this);
      return ret /= MVar(x);
    }
    
    MVar operator/(long int x) const{
      MVar ret(*this);
      return ret /= MVar(x);
    }
    
#endif
    
    bool operator<(const MVar& v) const{
      if(type_ == Float){
        if(v.type_ == Float){
          return data_.f < v.data_.f;
        }
        else if(v.type_ & DefinedNumericMask){
          return data_.f < v.toDouble();
        }
        
        return false;
      }
      
      return lt(v);
    }
    
    bool lt(const MVar& v) const;
    
    template<typename T>
    bool operator<(const T& t) const{
      return *this < MVar(t);
    }
    
    bool operator>(const MVar& v) const{
      if(type_ == Float){
        if(v.type_ == Float){
          return data_.f > v.data_.f;
        }
        else if(v.type_ & DefinedNumericMask){
          return data_.f > v.toDouble();
        }
        
        return false;
      }
      
      return gt(v);
    }
    
    bool gt(const MVar& v) const;
    
    template<typename T>
    bool operator>(const T& t) const{
      return *this > MVar(t);
    }
    
    bool operator<=(const MVar& v) const{
      if(type_ == Float){
        if(v.type_ == Float){
          return data_.f <= v.data_.f;
        }
        else if(v.type_ & DefinedNumericMask){
          return data_.f <= v.toDouble();
        }
        
        return false;
      }
      
      return le(v);
    }
    
    bool le(const MVar& v) const;
    
    template<typename T>
    bool operator<=(const T& t) const{
      return *this <= MVar(t);
    }
    
    bool operator>=(const MVar& v) const{
      if(type_ == Float){
        if(v.type_ == Float){
          return data_.f >= v.data_.f;
        }
        else if(v.type_ & DefinedNumericMask){
          return data_.f >= v.toDouble();
        }
        
        return false;
      }
      
      return ge(v);
    }
    
    bool ge(const MVar& v) const;
    
    template<typename T>
    bool operator>=(const T& t) const{
      return *this >= MVar(t);
    }
    
    bool operator==(const MVar& v) const{
      if(type_ == Float){
        if(v.type_ == Float){
          return data_.f == v.data_.f;
        }
        else if(v.type_ & DefinedNumericMask){
          return data_.f == v.toDouble();
        }
        
        return false;
      }
      
      return eq(v);
    }
    
    bool eq(const MVar& v) const;
    
    bool operator==(const MStr& s) const;
    
    template<typename T>
    bool operator==(const T& t) const{
      return *this == MVar(t);
    }
    
    bool operator==(const std::string& s) const{
      return *this == MStr(s);
    }
    
    bool operator==(const char* s) const{
      return *this == MStr(s);
    }
    
    bool operator!=(const MVar& v) const{
      return !(*this == v);
    }
    
    bool operator!=(const MStr& s) const;
    
    template<typename T>
    bool operator!=(const T& t) const{
      return *this != MVar(t);
    }
    
    bool operator!=(const std::string& s) const{
      return *this != MStr(s);
    }
    
    bool operator!=(const char* s) const{
      return *this != MStr(s);
    }
        
    const MVar& operator[](const MVar& key) const;
    
    MVar& operator[](const MVar& key);
    
    template<typename T>
    const MVar& operator[](const T& key) const{
      return (*this)[MVar(key)];
    }
    
    template<typename T>
    MVar& operator[](const T& key){
      return (*this)[MVar(key)];
    }
    
    bool operator!() const{
      return !toBool();
    }
    
    MVar& operator%=(const MVar& v);
    
    MVar operator%(const MVar& v) const{
      MVar ret(*this);
      return ret %= v;
    }
    
    template<typename T>
    MVar operator%(const T& t) const{
      MVar ret(*this);
      return ret %= MVar(t);
    }
    
    MVar operator%(uint32_t x) const{
      MVar ret(*this);
      return ret %= MVar(x);
    }
    
    MVar operator%(int32_t x) const{
      MVar ret(*this);
      return ret %= MVar(x);
    }
    
    MVar operator%(uint64_t x) const{
      MVar ret(*this);
      return ret %= MVar(x);
    }
    
    MVar operator%(int64_t x) const{
      MVar ret(*this);
      return ret %= MVar(x);
    }
    
#if defined (__i386__) || defined (__APPLE__)
    
    MVar operator%(unsigned long int x) const{
      MVar ret(*this);
      return ret %= MVar(x);
    }
    
    MVar operator%(long int x) const{
      MVar ret(*this);
      return ret %= MVar(x);
    }
    
#endif
    
    MVar operator%(double x) const{
      MVar ret(*this);
      return ret %= MVar(x);
    }
    
    MVar& operator<<(const MVar& v){
      push_back(v);
      return *this;
    }
    
    template<typename T>
    MVar& operator<<(const T& x){
      push_back(MVar(x));
      return *this;
    }
    
    typedef void (MVar::*BoolType_)() const;
    
    void boolStub_() const{}
    
    operator BoolType_() const {
      return toBool() ? &MVar::boolStub_ : 0;
    }
    
    bool isDefined() const;
    
    bool isNumeric() const{
      return type_ & NumericMask;
    }
    
    int isRational() const;
    
    bool isReal() const;
    
    Type type() const{
      return type_;
    }
    
    MVar& get(const MVar& key, bool errorOnExists=false);
    
    MVar& operator()(const MVar& key){
      return get(key);
    }
    
    mvec keys(bool all=true, bool indexed=false) const;
    
    size_t size() const;
    
    size_t mapSize() const;
    
    bool isMapEmpty() const;
    
    bool isSeqEmpty() const;
    
    bool isEmpty() const;
    
    size_t span() const;
    
    bool toBool() const;
    
    void setBinary(const char* buf,
                   size_t pos,
                   size_t count,
                   Type t=String);

    size_t getBinary(char* buf, size_t pos, size_t count) const;
    
    size_t getBinary(char* buf, size_t pos) const;
    
    size_t binarySize() const;
    
    bool hasKey(const MVar& key) const;
    
    bool keyValue(const MVar& key, const MVar& value) const;

    void setType(Type t);

    MVar& setHead(const MVar& v, Type t=String);
    
    void clearHead();
    
    MVar head() const;
    
    MVar& back();
    
    const MVar& back() const;
    
    void pushBack(const MVar& v);
    
    void push_back(const MVar& v){
      pushBack(v);
    }
    
    void push(const MVar& v){
      pushBack(v);
    }
    
    void pushFront(const MVar& v);
    
    void push_front(const MVar& v){
      pushFront(v);
    }
    
    MVar popBack();
    
    void pop_back();
    
    MVar popFront();
    
    void pop_front();
    
    void pop(){
      pop_back();
    }
    
    void insert(int64_t pos, const MVar& value);
    
    MVar& add(const MVar& value){
      pushBack(value);
      return *this;
    }
    
    MVar& add(const MVar& key, const MVar& value){
      get(key) = value;
      return *this;
    }
    
    const MVar& uget(const MVar& key, const MVar& def=undef) const;
    
    int64_t index(const MVar& value, int64_t start=0, int64_t end=-1) const;
    
    void erase(const MVar& key);
    
    void clearSeq();
    
    void clearMap();
    
    void clear(){
      clearSeq();
      clearMap();
    }
    
    void merge(const MVar& v);
    
    void outerMerge(const MVar& v);
    
    static MVar fromStr(const mstr& str, bool literal=true, bool exact=false);
    
    static MStr itp(const MStr& str, const mvec& vars);
    
    bool hasVector() const;
    
    bool hasList() const;
    
    void indexMap(bool flag);
    
    int64_t keyIndex(const mstr& key);
    
    bool isString() const{
      return type_ == String;
    }
    
    bool isStringPtr() const;
    
    mvec split(const mstr& delimiter, int maxTokens=-1) const;
    
    mstr join(const mstr& delimiter) const;
    
    MVar& unite();
    
    MVar& unite(const MVar& v, bool outer=false);
    
    MVar& intersect(const MVar& v, bool outer=false);
    
    MVar& complement(const MVar& v);
    
    bool subsumesData(const MVar& v) const;
    
    MVar clone() const;
    
    MVar& unlink();
    
    bool isCodeData() const{
      return type_ & CodeDataMask;
    }
    
    void setCodeData(bool flag);
    
    enum ToNodeType{
      ToNodeTop,
      ToNodeOne,
      ToNodeAll,
      ToNodeNone
    };
    
    mnode toNode(ToNodeType type=ToNodeTop) const;
        
    bool isSymbolic() const;
    
    bool isFunction() const;
    
    bool isFunction(const mstr& f) const;
    
    bool isFunction(const mstr& f, size_t args) const;
    
    bool isFunction(const mstr& f, size_t argsMin, size_t argsMax) const;
    
    bool isSymbol() const;
    
    bool isSymbol(const mstr& name) const;
    
    void convertConstant();
    
    static double inf();
    
    static double negInf();
    
    static double nan();
    
    static double min();
    
    static double max();
    
    static double epsilon();
    
  private:
    void span_(size_t& s) const;
    
    Type type_;
    uint8_t flags_;
    
    union{
      double f;
      int64_t i;
      mstr* s;
      MRational* r;
      MReal* x;
      void* p;
      MObjectBase* o;
    }data_;
    
    union{
      mvec* v;
      mlist* l;
    }vl_;
    
    mmap* map_;
  };
  
  std::ostream& operator<<(std::ostream& ostr, const MVar& v);
  
  std::istream& operator>>(std::istream& is, MVar& v);
  
  template<typename T>
  inline bool operator<(const T& v1, const MVar& v2){
    return MVar(v1) < v2;
  }
  
  template<typename T>
  inline bool operator>(const T& v1, const MVar& v2){
    return MVar(v1) > v2;
  }
  
  template<typename T>
  inline bool operator<=(const T& v1, const MVar& v2){
    return MVar(v1) <= v2;
  }
  
  template<typename T>
  inline bool operator>=(const T& v1, const MVar& v2){
    return MVar(v1) >= v2;
  }
  
  template<typename T>
  inline bool operator==(const T& v1, const MVar& v2){
    return MVar(v1) == v2;
  }
  
  template<typename T>
  inline bool operator!=(const T& v1, const MVar& v2){
    return MVar(v1) != v2;
  }
  
  template<typename T>
  inline MVar operator+(const T& v1, const MVar& v2){
    MVar ret(v1);
    return ret += v2;
  }
  
  template<typename T>
  inline MVar operator-(const T& v1, const MVar& v2){
    MVar ret(v1);
    return ret -= v2;
  }
  
  template<typename T>
  inline MVar operator*(const T& v1, const MVar& v2){
    MVar ret(v1);
    return ret *= v2;
  }
  
  template<typename T>
  inline MVar operator/(const T& v1, const MVar& v2){
    MVar ret(v1);
    return ret /= v2;
  }
  
  template<typename T>
  inline MVar operator%(const T& v1, const MVar& v2){
    MVar ret(v1);
    return ret %= v2;
  }
  
  typedef MVar mvar;
  
  typedef MVar mdist;
  
} // end namespace Meta

#endif // ANDROMETA_M_VAR_H