Argument.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_ARGUMENT_H
#define _EYEDB_ARGUMENT_H

namespace eyedb {

  class ArgArray;
  class ArgType;

  class Argument : public gbxObject {

    // ----------------------------------------------------------------------
    // Argument Interface
    // ----------------------------------------------------------------------
  public:
    enum GarbagePolicy {
      NoGarbage = 1,
      AutoGarbage,
      AutoFullGarbage
    };

    //
    // Constructors
    //

    // basic types : without copy and without garbage
    Argument();

    Argument(eyedblib::int16 i);

    Argument(eyedblib::int32 i);

    Argument(eyedblib::int64 i);

    Argument(const char *s);

    Argument(char c);

    Argument(unsigned char by);

    Argument(double d);

    Argument(const Oid &oid, Database *db = NULL);

    Argument(const Object *o);

    Argument(const unsigned char *raw, int size);

    Argument(void *x);

    Argument(const ArgArray *array);

    // basic types : without copy and with garbage according to garbage policy
    Argument(char *s, Argument::GarbagePolicy policy);

    Argument(Object *o, Argument::GarbagePolicy policy);

    Argument(unsigned char *raw, int size, Argument::GarbagePolicy policy);

    Argument(ArgArray *array, Argument::GarbagePolicy policy);

    // const array types : without copy and without garbage
    Argument(const int *i, int cnt);

    Argument(const char *c, int cnt);

    Argument(char **s, int cnt);

    Argument(const double *d, int cnt);

    Argument(const Oid *oid, int cnt, Database *db = 0);

    Argument(const Object **o, int cnt);

    // array types : without copy and with garbage according to garbage policy
    Argument(int *i, int cnt, Argument::GarbagePolicy policy);

    Argument(char *c, int cnt, Argument::GarbagePolicy policy);

    Argument(char **s, int cnt, Argument::GarbagePolicy policy);

    Argument(double *d, int cnt, Argument::GarbagePolicy policy);

    Argument(Oid *oid, int cnt, Argument::GarbagePolicy policy,
             Database *db = NULL);

    Argument(Object **o, int cnt, Argument::GarbagePolicy policy);

    // copy constructor
    Argument(const Argument & arg);

    // assignation operator
    Argument &operator=(const Argument &arg);

    //
    // Set methods
    //

    // basic types
    void set(eyedblib::int16 i);

    void set(eyedblib::int32 i);

    void set(eyedblib::int64 i);

    void set(const char *s);

    void set(char c);

    void set(unsigned char by);

    void set(double d);

    void set(const Oid &oid, Database *db = 0);

    void set(const Object *o);

    void set(const unsigned char *raw, int size);

    void set(void *x);

    void set(const ArgArray *array);

    void set(const Argument &arg);

    // basic types : without copy and with garbage according to garbage policy
    void set(char *s, Argument::GarbagePolicy policy);

    void set(Object *o, Argument::GarbagePolicy policy);

    void set(unsigned char *raw, int size, Argument::GarbagePolicy policy);

    void set(ArgArray *array, Argument::GarbagePolicy policy);

    // array types : without copy and with garbage according to garbage policy
    void set(const eyedblib::int16 *i, int cnt);

    void set(const eyedblib::int32 *i, int cnt);

    void set(const eyedblib::int64 *i, int cnt);

    void set(const char *c, int cnt);

    void set(char **s, int cnt);

    void set(const double *d, int cnt);

    void set(const Oid *oid, int cnt, Database *db = 0);

    void set(const Object **o, int cnt);

    // array types : without copy and with garbage according to garbage policy
    void set(eyedblib::int16 *i, int cnt, Argument::GarbagePolicy policy);

    void set(eyedblib::int32 *i, int cnt, Argument::GarbagePolicy policy);

    void set(eyedblib::int64 *i, int cnt, Argument::GarbagePolicy policy);

    void set(char *c, int cnt, Argument::GarbagePolicy policy);

    void set(char **s, int cnt, Argument::GarbagePolicy policy);

    void set(double *d, int cnt, Argument::GarbagePolicy policy);

    void set(Oid *oid, int cnt, Argument::GarbagePolicy policy,
             Database *db = NULL);

    void set(Object **o, int cnt, Argument::GarbagePolicy policy);

    //
    // Accessor methods
    // 

    // basic types
    const eyedblib::int16 *getInteger16() const {
      return type->getType() == INT16_TYPE ? &u.i16 : NULL;
    }

    const eyedblib::int32 *getInteger32() const {
      return type->getType() == INT32_TYPE ? &u.i32 : NULL;
    }

    const eyedblib::int64 *getInteger64() const {
      return type->getType() == INT64_TYPE ? &u.i64 : NULL;
    }

    eyedblib::int64 getInteger() const;

    const char *getChar() const {
      return type->getType() == CHAR_TYPE ? &u.c : NULL;
    }

    const unsigned char *getByte() const {
      return type->getType() == BYTE_TYPE ? &u.by : NULL;
    }

    const double *getFloat() const  {
      return type->getType() == FLOAT_TYPE ? &u.d : NULL;
    }

    const Oid *getOid() const {
      return type->getType() == OID_TYPE ? u.oid : NULL;
    }

    const char *getString() const {
      return type->getType() == STRING_TYPE ? u.s : NULL;
    }

    const Object *getObject() const;

    const unsigned char *getRaw(int &size) const {
      if (type->getType() == RAW_TYPE) {
        size = u.raw.size;
        return u.raw.data;
      }
      return NULL;
    }

    const unsigned char *getBytes(int &size) const {
      return getRaw(size);
    }

    const void *getX() const {
      return type->getType() == ANY_TYPE ? u.x : NULL;
    }

    char *getString() {
      return type->getType() == STRING_TYPE ? u.s : NULL;
    }

    Object *getObject();

    void *getX() {
      return type->getType() == ANY_TYPE ? u.x : NULL;
    }

    const Argument getArgument() {
      return *this;
    }

    // array types
    const eyedblib::int16 *getIntegers16(int &cnt) const;

    const eyedblib::int32 *getIntegers32(int &cnt) const;

    const eyedblib::int64 *getIntegers64(int &cnt) const;

    const char *getChars(int &cnt) const;

    const double *getFloats(int &cnt) const;

    const Oid *getOids(int &cnt) const;

    char **getStrings(int &cnt) const;

    Object **getObjects(int &cnt) const;

    static char *alloc(unsigned int sz, char *x);

    static unsigned char *alloc(unsigned int sz, unsigned char *x);

    static eyedblib::int16 *alloc(unsigned int sz, eyedblib::int16 *x);

    static eyedblib::int32 *alloc(unsigned int sz, eyedblib::int32 *x);

    static eyedblib::int64 *alloc(unsigned int sz, eyedblib::int64 *x);

    static double *alloc(unsigned int sz, double *x);

    static Oid *alloc(unsigned int sz, Oid *x);

    static char **alloc(unsigned int sz, char **x);

    static Object **alloc(unsigned int sz, Object **x);

    static char *dup(const char *s);

    static unsigned char *dup(const unsigned char *x, int sz);

    static eyedblib::int16 *dup(const eyedblib::int16 *x, int cnt);

    static eyedblib::int32 *dup(const eyedblib::int32 *x, int cnt);

    static eyedblib::int64 *dup(const eyedblib::int64 *x, int cnt);

    static double *dup(const double *x, int cnt);

    static Oid *dup(const Oid *x, int cnt);

    static char **dup(char **x, int cnt);

    static Object **dup(Object **x, int cnt);

    static void free(char *x);

    static void free(unsigned char *x);

    static void free(eyedblib::int16 *x);

    static void free(eyedblib::int32 *x);

    static void free(eyedblib::int64 *x);

    static void free(double *x);

    static void free(Oid *x);

    static void free(char **x, int cnt);

    static void free(Object *x);

    static void free(Object **x, int cnt);

    // miscellaneous
    const ArgType *getType() const {return type;}

    ArgType *getType() {return type;}

    const char *toString() const;

    ~Argument();

    static const char *
    getArgTypeStr(const ArgType *argType, Bool printref = True);

    // ----------------------------------------------------------------------
    // Argument Private Part
    // ----------------------------------------------------------------------
  private:
    char *str;
    void garbage();
    void init(ArgType_Type);
    GarbagePolicy policy;

    // ----------------------------------------------------------------------
    // Argument Conceptually private
    // ----------------------------------------------------------------------
  public:
    ArgType *type;
    Database *db;

    unsigned char *code(unsigned int &) const;

    union {
      eyedblib::int16 i16;
      eyedblib::int32 i32;
      eyedblib::int64 i64;
      char *s;
      char c;
      unsigned char by;
      double d;
      Oid *oid;
      Object *o;
      void *x;
      ArgArray *array;
      struct {
        int size;
        unsigned char *data;
      } raw;
      struct {
        int cnt;
        eyedblib::int16 *i;
      } arr_i16;
      struct {
        int cnt;
        eyedblib::int32 *i;
      } arr_i32;
      struct {
        int cnt;
        eyedblib::int64 *i;
      } arr_i64;
      struct {
        int cnt;
        char **s;
      } arr_s;
      struct {
        int cnt;
        char *c;
      } arr_c;
      struct {
        int cnt;
        double *d;
      } arr_d;
      struct {
        int cnt;
        Oid *oid;
      } arr_oid;
      struct {
        int cnt;
        Object **o;
      } arr_o;
    } u;
  };

  class ArgArray : public gbxObject {

    // ----------------------------------------------------------------------
    // ArgArray Interface
    // ----------------------------------------------------------------------
  public:
    ArgArray();

    ArgArray(const Argument **args, int cnt);

    ArgArray(Argument **args, int cnt, Argument::GarbagePolicy policy);

    ArgArray(int cnt, Argument::GarbagePolicy policy);

    void set(Argument **args, int cnt, Argument::GarbagePolicy policy);

    Argument **getArgs() {return args;}

    int getCount() const {return cnt;}
                     
    ArgArray(const ArgArray &arg);

    ArgArray &operator=(const ArgArray &arg);

    ArgArray(unsigned char *c, unsigned int n);

    const Argument *operator[](int n) const {
      return ((n >= 0 && n < cnt) ? args[n] : (Argument *)0);
    }

    Argument *operator[](int n) {
      return ((n >= 0 && n < cnt) ? args[n] : (Argument *)0);
    }

    ArgType_Type getType() const;

    unsigned char *code(unsigned int &) const;

    const char *toString() const;

    ~ArgArray();

    // ----------------------------------------------------------------------
    // ArgArray Private Part
    // ----------------------------------------------------------------------
  private:
    Argument::GarbagePolicy policy;
    void garbage();
    char *str;
    int cnt;
    Argument **args;
  };

  class ArgumentPtr : public gbxObjectPtr {

  public:
    ArgumentPtr(Argument *o = 0) : gbxObjectPtr(o) { }

    Argument *getArgument() {return dynamic_cast<Argument *>(o);}
    const Argument *getArgument() const {return dynamic_cast<Argument *>(o);}

    Argument *operator->() {return dynamic_cast<Argument *>(o);}
    const Argument *operator->() const {return dynamic_cast<Argument *>(o);}
  };

  typedef std::vector<ArgumentPtr> ArgumentPtrVector;

}

#endif

---