Value.h

/* 
   EyeDB Object Database Management System
   Copyright (C) 1994-2008 SYSRA
   
   EyeDB is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.
   
   EyeDB is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.
   
   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA 
*/

/*
   Author: Eric Viara <viara@sysra.com>
*/


#ifndef _EYEDB_VALUE_H
#define _EYEDB_VALUE_H

namespace eyedb {

  class ValueArray;
  class ObjectArray;

  class Value {

    // ----------------------------------------------------------------------
    // Value Interface
    // ----------------------------------------------------------------------

  public:

    enum Type {
      tNil = 0,
      tNull,
      tBool,
      tByte,
      tChar,
      tShort,
      tInt,
      tLong,
      tDouble,
      tIdent,
      tString,
      tData,
      tOid,
      tObject,
      tObjectPtr,
      tPobj,
      tList,
      tSet,
      tArray,
      tBag,
      tStruct
    } type;

    struct Attr {
      char *name;
      Value *value;

      Attr() {
        name = 0;
        value = 0;
      }

      Attr(const char *_name, Value *_value) {
        name = strdup(_name);
        value = _value;
      }

      ~Attr() {
        free(name);
      }
    };

    struct Struct {
      int attr_cnt;
      Value::Attr **attrs;

      Struct() {attr_cnt = 0; attrs = 0;}

      Struct(int _attr_cnt) {
        attr_cnt = _attr_cnt;
        attrs = new Attr*[attr_cnt];
      }

      void print(FILE *fd) const;
      int operator==(const Struct &);
      std::string toString() const;

      ~Struct() {
        for (int ii = 0; ii < attr_cnt; ii++)
          delete attrs[ii];

        if (attr_cnt)
          delete [] attrs;
      }

    private:
      Struct(const Struct &);
      Struct& operator=(const Struct &);
    };

    struct V_Data {
      Data data;
      Size size;
    };

    union {
      Bool b;
      unsigned char by;
      char c;
      short s;
      eyedblib::int32 i;
      eyedblib::int64 l;
      double d;
      char *str;
      V_Data data;
      Oid *oid;
      Object *o;
      ObjectPtr *o_ptr;
      unsigned int idx;
      LinkedList *list;
      Value::Struct *stru;
    };

    Value() {
      bufstr = NULL;
      auto_obj_garb = false;
      set();
    }

    Value(Bool b1, Bool b2) {
      bufstr = NULL;
      auto_obj_garb = false;
      set(b1, b2);
    }

    Value(Bool _b) {
      bufstr = NULL;
      auto_obj_garb = false;
      set(_b);
    }

    Value(unsigned char _by) {
      bufstr = NULL;
      auto_obj_garb = false;
      set(_by);
    }

    Value(char _c) {
      bufstr = NULL;
      auto_obj_garb = false;
      set(_c);
    }

    Value(short _s) {
      bufstr = NULL;
      auto_obj_garb = false;
      set(_s);
    }

    Value(double _d) {
      bufstr = NULL;
      auto_obj_garb = false;
      set(_d);
    }

    Value(eyedblib::int32 _i) {
      bufstr = NULL;
      auto_obj_garb = false;
      set(_i);
    }

    Value(eyedblib::int64 _l) {
      bufstr = NULL;
      auto_obj_garb = false;
      set(_l);
    }

    Value(const char *_str) {
      bufstr = NULL;
      auto_obj_garb = false;
      set(_str);
    }

    Value(const char *_str, Bool isident) {
      bufstr = NULL;
      auto_obj_garb = false;
      set(_str, isident);
    }

    Value(Data _data, Size _size) {
      bufstr = NULL;
      auto_obj_garb = false;
      set(_data, _size);
    }

    Value(const Oid &_oid) {
      bufstr = NULL;
      auto_obj_garb = false;
      set(_oid);
    }

    Value(const Object *_o) {
      bufstr = NULL;
      auto_obj_garb = false;
      o = 0;
      set(_o);
    }

    Value(const Object *_o, unsigned int _idx) {
      bufstr = NULL;
      auto_obj_garb = false;
      o = 0;
      set(_o, _idx);
    }

    Value(Object *_o, bool _auto_obj_garb = false) {
      bufstr = NULL;
      auto_obj_garb = _auto_obj_garb;
      o = 0;
      set(_o);
    }

    Value(const ObjectPtr &_o_ptr) {
      bufstr = NULL;
      auto_obj_garb = false;
      set(_o_ptr);
    }

    Value(LinkedList *_list, Value::Type _type) {
      bufstr = NULL;
      auto_obj_garb = false;
      set(_list, _type);
    }

    Value(Value::Struct *_stru) {
      bufstr = NULL;
      auto_obj_garb = false;
      set(_stru);
    }

    void set() {
      type = tNil;
      unvalid();
    }

    void set(Bool b1, Bool b2) {
      type = tNull;
      unvalid();
    }

    void set(Bool _b) {
      type = tBool;
      b = _b;
      unvalid();
    }

    void set (unsigned char _by) {
      type = tByte;
      by = _by;
      unvalid();
    }

    void set(char _c) {
      type = tChar;
      c = _c;
      unvalid();
    }

    void set(short _s) {
      type = tShort;
      s = _s;
      unvalid();
    }

    void set(double _d) {
      type = tDouble;
      d = _d;
      unvalid();
    }

    void set(eyedblib::int32 _i) {
      type = tInt;
      i = _i;
      unvalid();
    }

    void set(eyedblib::int64 _l) {
      type = tLong;
      l = _l;
      unvalid();
    }

    void set(const char *_str) {
      type = tString;
      str = _str ? strdup(_str) : NULL;
      unvalid();
    }

    void set(const char *_str, Bool isident) {
      type = (isident ? tIdent : tString);
      str = _str ? strdup(_str) : NULL;
      unvalid();
    }

    void set(Data _data, Size _size) {
      type = tData;
      data.data = _data;
      data.size = _size;
      unvalid();
    }

    void set(const Oid &_oid) {
      type = tOid;
      oid = new Oid(_oid);
      unvalid();
    }

    void set(const Object *_o) {
      type = tObject;
      o = (Object *)_o;
      unvalid();
    }

    void set(const Object *_o, unsigned int _idx) {
      type = tPobj;
      idx = _idx;
      unvalid();
    }

    void set(const ObjectPtr &_o_ptr) {
      type = tObjectPtr;
      o_ptr = new ObjectPtr(_o_ptr);
      unvalid();
    }

    void set(Object *_o);

    void set(LinkedList *_list, Value::Type _type) {
      if (_type != tList && _type != tSet && _type != tArray && _type != tBag)
        {
          (void)Exception::make("setting collection value: type must be "
                                "tList, tSet, tArray or tBag");
          return;
        }

      type = _type;
      list = _list;
      unvalid();
    }

    void set(Value::Struct *_stru) {
      type = tStruct;
      stru = _stru;
      unvalid();
    }

    // flatten methods

    Status toArray(Database *db, ObjectPtrVector &obj_vect,
                   const RecMode *recmode = RecMode::NoRecurs);

    Status toArray(Database *db, ObjectArray &obj_array,
                   const RecMode *recmode = RecMode::NoRecurs);

    Status toArray(ValueArray &valarr);

    Status toArray(OidArray &oidarr);

    Value(const Value &val);

    int operator ==(const Value &val) const;

    int operator <(const Value &val) const;

    int operator !=(const Value &val) const;

    Value &operator =(const Value &val);

    void trace(FILE *fd = stdout) const {
      print(fd);
    }

    void print(FILE *fd = stdout) const;

    Data getData(Size *psize = 0) const;

    const char *getString() const;

    const char *getStringType() const;

    Value::Type getType() const {return type;}

    static const char *getStringType(Value::Type type);

    static const char *getAttributeName(const Class *cl, Bool isIndirect);

    void init() {
      bufstr = NULL;
      type = tNil;
    }

    void decode(Data idr, Offset &offset);

    void code(Data &idr, Offset &offset, Size &alloc_size) const;

    void setAutoObjGarbage(bool _auto_obj_garb) {auto_obj_garb = _auto_obj_garb;}

    bool isAutoObjGarbage() const {return auto_obj_garb;}

    void setMustRelease(bool must_release);

    ~Value();

  private:
    Status toValueArray(LinkedList &);
    Status toOidObjectArray(Database *db, LinkedList &,
                            Bool isObj, const RecMode *rcm);
    void garbage();
    char *bufstr;
    bool auto_obj_garb;
    void unvalid() {
      free(bufstr);
      bufstr = NULL;
    }
  };

  std::ostream& operator<<(std::ostream&, const Value &);
  std::ostream& operator<<(std::ostream&, const Value *);

  class ValueList;

  class ValueArray {

    // ----------------------------------------------------------------------
    // ValueArray Interface
    // ----------------------------------------------------------------------

  public:
    ValueArray(bool _auto_obj_garb = false) {
      values = NULL;
      value_cnt = 0;
      auto_obj_garb = _auto_obj_garb;
    }

    ValueArray(Value *_values, unsigned int _value_cnt, Bool copy = True) {
      values = NULL;
      value_cnt = 0;
      auto_obj_garb = false;
      set(_values, _value_cnt, copy);
    }

    ValueArray(bool _auto_obj_garb, Value *_values, unsigned int _value_cnt,
               Bool copy = True) {
      values = NULL;
      value_cnt = 0;
      auto_obj_garb = _auto_obj_garb;
      set(_values, _value_cnt, copy);
    }

    ValueArray(const ValueArray &valarr);

    ValueArray(const Collection *coll);

    ValueArray(const ValueList &list);

    ValueArray &operator=(const ValueArray &valarr);

    unsigned int getCount() const {return value_cnt;}

    void set(Value *_values, unsigned int _value_cnt, Bool copy = True);

    Status setValueAt(unsigned int ind, const Value &value);

    Value *getValues() {return values;}

    const Value & operator[](unsigned int ind) const {
      return values[ind];
    }

    ValueList *toList() const;

    void setAutoObjGarbage(bool auto_obj_garb);

    bool isAutoObjGarbage() const {return auto_obj_garb;}

    void setMustRelease(bool must_release);

    ~ValueArray();

  private:
    Value *values;
    unsigned int value_cnt;
    bool auto_obj_garb;
  };

  class ValueListCursor;

  class ValueList {

  public:
    ValueList();

    ValueList(const ValueArray &value_array);

    int getCount() const;

    void insertValue(const Value &value);

    void insertValueLast(const Value &value);

    void insertValueFirst(const Value &value);

    Bool suppressValue(const Value &value);

    Bool suppressPairValues(const Value &value1, const Value &value2);

    Bool exists(const Value &value) const;

    void empty();

    ValueArray *toArray() const;

    ~ValueList();

  private:
    LinkedList *list;
    friend class ValueListCursor;
  };

  class ValueListCursor {

  public:
    ValueListCursor(const ValueList &valuelist);

    ValueListCursor(const ValueList *valuelist);

    Bool getNext(Value &value);

    ~ValueListCursor();

  private:
    LinkedListCursor *c;
  };

}

#endif

---