utils.h

/*
 * EyeDB Version 2.8.4 Copyright (c) 1995-2006 SYSRA
 *
 * File 'utils.h'
 *
 * Package Name 'utils'
 *
 * Generated by eyedbodl at Fri Jan 18 22:51:44 2008
 *
 * ---------------------------------------------------
 * -------------- DO NOT EDIT THIS CODE --------------
 * ---------------------------------------------------
 *
 */

#include <eyedb/eyedb.h>

#ifndef _eyedb_utils_
#define _eyedb_utils_

namespace eyedb {

class Image;
class CURL;
class WConfig;
class Date;
class Time;
class TimeStamp;
class TimeInterval;
class OString;


class utils {

 public:
  utils(int &argc, char *argv[]) {
    eyedb::init(argc, argv);
    init();
  }

  ~utils() {
    release();
    eyedb::release();
  }

  static void init();
  static void release();
  static eyedb::Status updateSchema(eyedb::Database *db);
  static eyedb::Status updateSchema(eyedb::Schema *m);
};

class utilsDatabase : public eyedb::Database {

 public:
  utilsDatabase(const char *dbname, const char *_dbmdb_str = 0) : eyedb::Database(dbname, _dbmdb_str) {}
  utilsDatabase(eyedb::Connection *conn, const char *dbname, const char *_dbmdb_str, eyedb::Database::OpenFlag, const char *user = 0, const char *passwd = 0);
  utilsDatabase(eyedb::Connection *conn, const char *dbname, eyedb::Database::OpenFlag, const char *user = 0, const char *passwd = 0);
  utilsDatabase(const char *dbname, int _dbid, const char *_dbmdb_str = 0) : eyedb::Database(dbname, _dbid, _dbmdb_str) {}
  utilsDatabase(int _dbid, const char *_dbmdb_str = 0) : eyedb::Database(_dbid, _dbmdb_str) {}
  eyedb::Status open(eyedb::Connection *, eyedb::Database::OpenFlag, const char *user = 0, const char *passwd = 0);
  eyedb::Status open(eyedb::Connection *, eyedb::Database::OpenFlag, const eyedb::OpenHints *hints, const char *user = 0, const char *passwd = 0);
  static void setConsApp(eyedb::Database *);
  static eyedb::Status checkSchema(eyedb::Schema *);
  static eyedb::Bool getDynamicGetErrorPolicy();
  static eyedb::Bool getDynamicSetErrorPolicy();
  static void setDynamicGetErrorPolicy(eyedb::Bool policy);
  static void setDynamicSetErrorPolicy(eyedb::Bool policy);
};

class ImageType {

public:
  enum Type {
    GIF_IMG_TYPE = 1,
    JPEG_IMG_TYPE = 2,
    PM_IMG_TYPE = 3,
    PBM_IMG_TYPE = 4,
    X11BITMAP_IMG_TYPE = 5,
    BMP_IMG_TYPE = 6,
    TIFF_IMG_TYPE = 7
  };
};

class Month {

public:
  enum Type {
    January = 1,
    February = 2,
    March = 3,
    April = 4,
    May = 5,
    June = 6,
    July = 7,
    August = 8,
    September = 9,
    October = 10,
    November = 11,
    December = 12
  };
};

class Weekday {

public:
  enum Type {
    Sunday = 0,
    Monday = 1,
    Tuesday = 2,
    Wednesday = 3,
    Thursday = 4,
    Friday = 5,
    Saturday = 6
  };
};

class Image : public eyedb::Struct {

 public:
  Image(eyedb::Database * = 0, const eyedb::Dataspace * = 0);
  Image(const Image& x);

  virtual eyedb::Object *clone() const {return new Image(*this);};

  Image& operator=(const Image& x);

  virtual Image *asImage() {return this;}
  virtual const Image *asImage() const {return this;}

  eyedb::Status setName(const std::string &);
  eyedb::Status setName(unsigned int a0, char );
  std::string getName(eyedb::Bool *isnull = 0, eyedb::Status * = 0) const;
  char getName(unsigned int a0, eyedb::Bool *isnull = 0, eyedb::Status * = 0)  const;

  eyedb::Status setType(ImageType::Type , eyedb::Bool _check_value = eyedb::True);
  ImageType::Type getType(eyedb::Bool *isnull = 0, eyedb::Status * = 0)  const;

  eyedb::Status setData(const unsigned char *, unsigned int len);
  eyedb::Status setData(unsigned int a0, unsigned char );
  eyedb::Status setDataCount(unsigned int a0);
  const unsigned char *getData(unsigned int *len, eyedb::Bool *isnull = 0, eyedb::Status * = 0) const;
  unsigned char getData(unsigned int a0, eyedb::Bool *isnull = 0, eyedb::Status * = 0)  const;
  unsigned int getDataCount(eyedb::Status * = 0) const;

  eyedb::Status setW(eyedblib::int32 );
  eyedblib::int32 getW(eyedb::Bool *isnull = 0, eyedb::Status * = 0)  const;

  eyedb::Status setH(eyedblib::int32 );
  eyedblib::int32 getH(eyedb::Bool *isnull = 0, eyedb::Status * = 0)  const;
  virtual ~Image() {garbageRealize();}

 protected:
  Image(eyedb::Database *_db, const eyedb::Dataspace *_dataspace, int) : eyedb::Struct(_db, _dataspace) {}
  Image(const eyedb::Struct *x, eyedb::Bool share, int) : eyedb::Struct(x, share) {}
  Image(const Image *x, eyedb::Bool share, int) : eyedb::Struct(x, share) {}

 private:
  void initialize(eyedb::Database *_db);

 public: /* restricted */
  Image(const eyedb::Struct *, eyedb::Bool = eyedb::False);
  Image(const Image *, eyedb::Bool = eyedb::False);
  Image(const eyedb::Class *, eyedb::Data);
};

class CURL : public eyedb::Struct {

 public:
  CURL(eyedb::Database * = 0, const eyedb::Dataspace * = 0);
  CURL(const CURL& x);

  virtual eyedb::Object *clone() const {return new CURL(*this);};

  CURL& operator=(const CURL& x);

  virtual CURL *asCURL() {return this;}
  virtual const CURL *asCURL() const {return this;}

  eyedb::Status setProto(const std::string &);
  eyedb::Status setProto(unsigned int a0, char );
  std::string getProto(eyedb::Bool *isnull = 0, eyedb::Status * = 0) const;
  char getProto(unsigned int a0, eyedb::Bool *isnull = 0, eyedb::Status * = 0)  const;

  eyedb::Status setUrl(const std::string &);
  eyedb::Status setUrl(unsigned int a0, char );
  std::string getUrl(eyedb::Bool *isnull = 0, eyedb::Status * = 0) const;
  char getUrl(unsigned int a0, eyedb::Bool *isnull = 0, eyedb::Status * = 0)  const;
  virtual ~CURL() {garbageRealize();}
  // CURL User Part

  CURL(const char *proto, const char *url);
  

 protected:
  CURL(eyedb::Database *_db, const eyedb::Dataspace *_dataspace, int) : eyedb::Struct(_db, _dataspace) {}
  CURL(const eyedb::Struct *x, eyedb::Bool share, int) : eyedb::Struct(x, share) {}
  CURL(const CURL *x, eyedb::Bool share, int) : eyedb::Struct(x, share) {}

 private:
  void initialize(eyedb::Database *_db);

 public: /* restricted */
  CURL(const eyedb::Struct *, eyedb::Bool = eyedb::False);
  CURL(const CURL *, eyedb::Bool = eyedb::False);
  CURL(const eyedb::Class *, eyedb::Data);
};

class WConfig : public eyedb::Struct {

 public:
  WConfig(eyedb::Database * = 0, const eyedb::Dataspace * = 0);
  WConfig(const WConfig& x);

  virtual eyedb::Object *clone() const {return new WConfig(*this);};

  WConfig& operator=(const WConfig& x);

  virtual WConfig *asWConfig() {return this;}
  virtual const WConfig *asWConfig() const {return this;}

  eyedb::Status setName(const std::string &);
  eyedb::Status setName(unsigned int a0, char );
  std::string getName(eyedb::Bool *isnull = 0, eyedb::Status * = 0) const;
  char getName(unsigned int a0, eyedb::Bool *isnull = 0, eyedb::Status * = 0)  const;

  eyedb::Status setUser(const std::string &);
  eyedb::Status setUser(unsigned int a0, char );
  std::string getUser(eyedb::Bool *isnull = 0, eyedb::Status * = 0) const;
  char getUser(unsigned int a0, eyedb::Bool *isnull = 0, eyedb::Status * = 0)  const;

  eyedb::Status setConf(const std::string &);
  eyedb::Status setConf(unsigned int a0, char );
  std::string getConf(eyedb::Bool *isnull = 0, eyedb::Status * = 0) const;
  char getConf(unsigned int a0, eyedb::Bool *isnull = 0, eyedb::Status * = 0)  const;
  virtual ~WConfig() {garbageRealize();}

 protected:
  WConfig(eyedb::Database *_db, const eyedb::Dataspace *_dataspace, int) : eyedb::Struct(_db, _dataspace) {}
  WConfig(const eyedb::Struct *x, eyedb::Bool share, int) : eyedb::Struct(x, share) {}
  WConfig(const WConfig *x, eyedb::Bool share, int) : eyedb::Struct(x, share) {}

 private:
  void initialize(eyedb::Database *_db);

 public: /* restricted */
  WConfig(const eyedb::Struct *, eyedb::Bool = eyedb::False);
  WConfig(const WConfig *, eyedb::Bool = eyedb::False);
  WConfig(const eyedb::Class *, eyedb::Data);
};

class Date : public eyedb::Struct {

 public:
  Date(eyedb::Database * = 0, const eyedb::Dataspace * = 0);
  Date(const Date& x);

  virtual eyedb::Object *clone() const {return new Date(*this);};

  Date& operator=(const Date& x);

  virtual Date *asDate() {return this;}
  virtual const Date *asDate() const {return this;}

  eyedb::Status setJulian(eyedblib::int32 );
  eyedblib::int32 getJulian(eyedb::Bool *isnull = 0, eyedb::Status * = 0)  const;
  virtual ~Date() {garbageRealize();}
  // Date User Part

  private:
    char string_date[16];

    virtual void userCopy(const Object &);
    virtual void userInitialize();
    void setClientData();

  public:
    static Date * date(Database * db);
    static Date * date(Database * db, const Date & d);
    static Date * date(Database * db, eyedblib::int32 julian_day);
    static Date * date(Database * db, eyedblib::int32 year, Month::Type m, eyedblib::int16 day);
    static Date * date(Database * db, const char * d);
    static eyedblib::int32 julian(const char * d);
    eyedblib::int32 year() const;
    eyedblib::int16 month() const;
    eyedblib::int16 day() const;
    eyedblib::int16 day_of_year() const;
    Month::Type month_of_year() const;
    Weekday::Type day_of_week() const;
    const char * toString() const;
    Bool is_leap_year() const;
    Bool is_equal(const Date & d) const;
    Bool is_greater(const Date & d) const;
    Bool is_greater_or_equal(const Date & d) const;
    Bool is_less(const Date & d) const;
    Bool is_less_or_equal(const Date & d) const;
    Bool is_between(const Date & d1, const Date & d2) const;
    Date & next(Weekday::Type day);
    Date & previous(Weekday::Type day);
    Date & add_days(eyedblib::int32 days);
    Date & substract_days(eyedblib::int32 days);
    eyedblib::int32 substract_date(const Date & d) const;
    Status set_julian(eyedblib::int32 julian_day);
    

 protected:
  Date(eyedb::Database *_db, const eyedb::Dataspace *_dataspace, int) : eyedb::Struct(_db, _dataspace) {}
  Date(const eyedb::Struct *x, eyedb::Bool share, int) : eyedb::Struct(x, share) {}
  Date(const Date *x, eyedb::Bool share, int) : eyedb::Struct(x, share) {}

 private:
  void initialize(eyedb::Database *_db);

 public: /* restricted */
  Date(const eyedb::Struct *, eyedb::Bool = eyedb::False);
  Date(const Date *, eyedb::Bool = eyedb::False);
  Date(const eyedb::Class *, eyedb::Data);
};

class Time : public eyedb::Struct {

 public:
  Time(eyedb::Database * = 0, const eyedb::Dataspace * = 0);
  Time(const Time& x);

  virtual eyedb::Object *clone() const {return new Time(*this);};

  Time& operator=(const Time& x);

  virtual Time *asTime() {return this;}
  virtual const Time *asTime() const {return this;}

  eyedb::Status setUsecs(eyedblib::int64 );
  eyedblib::int64 getUsecs(eyedb::Bool *isnull = 0, eyedb::Status * = 0)  const;

  eyedb::Status setTz(eyedblib::int16 );
  eyedblib::int16 getTz(eyedb::Bool *isnull = 0, eyedb::Status * = 0)  const;
  virtual ~Time() {garbageRealize();}
  // Time User Part

  private:
    char string_time[48];

    virtual void userCopy(const Object &);
    virtual void userInitialize();
    void setClientData();
  public:

  Status set_usecs(eyedblib::int64 usecs, eyedblib::int16 tz);
  static void get_local_time_zone(eyedblib::int16 * tz_hour, eyedblib::int16 * tz_min);
  static Time * gmt_time(Database * db);
  static Time * local_time(Database * db);
  static Time * time(Database * db, const Time & t);
  static Time * time(Database * db, eyedblib::int64 usec);
  static Time * time(Database * db, eyedblib::int64 usec, eyedblib::int16 tz);
  static Time * time(Database * db, eyedblib::int16 hours, eyedblib::int16 min, eyedblib::int16 sec, eyedblib::int16 msec);
  static Time * time(Database * db, eyedblib::int16 hours, eyedblib::int16 min, eyedblib::int16 sec, eyedblib::int16 msec, eyedblib::int16 usec);
  static Time * time(Database * db, eyedblib::int16 hours, eyedblib::int16 min, eyedblib::int16 sec, eyedblib::int16 msec, eyedblib::int16 tz_hour, eyedblib::int16 tz_minute);
  static Time * time(Database * db, eyedblib::int16 hours, eyedblib::int16 min, eyedblib::int16 sec, eyedblib::int16 msec, eyedblib::int16 usec, eyedblib::int16 tz_hour, eyedblib::int16 tz_minute);
  static Time * time(Database * db, const char * t);
  static eyedblib::int64 usec_time(const char * t);
  eyedblib::int16 hour() const;
  eyedblib::int16 minute() const;
  eyedblib::int16 second() const;
  eyedblib::int16 millisecond() const;
  eyedblib::int16 tz_hour() const;
  eyedblib::int16 tz_minute() const;
  const char * toString() const;
  Bool is_equal(const Time & t) const;
  Bool is_greater(const Time & t) const;
  Bool is_greater_or_equal(const Time & t) const;
  Bool is_less(const Time & t) const;
  Bool is_less_or_equal(const Time & t) const;
  Bool is_between(const Time & t1, const Time &t2) const;
  Time & add_interval(const TimeInterval & i);
  Time & substract_interval(const TimeInterval & i);
  TimeInterval * substract_time(const Time & t);
  eyedblib::int16 gmt_hour() const;
  eyedblib::int16 gmt_minute() const;
  eyedblib::int16 microsecond() const;
  

 protected:
  Time(eyedb::Database *_db, const eyedb::Dataspace *_dataspace, int) : eyedb::Struct(_db, _dataspace) {}
  Time(const eyedb::Struct *x, eyedb::Bool share, int) : eyedb::Struct(x, share) {}
  Time(const Time *x, eyedb::Bool share, int) : eyedb::Struct(x, share) {}

 private:
  void initialize(eyedb::Database *_db);

 public: /* restricted */
  Time(const eyedb::Struct *, eyedb::Bool = eyedb::False);
  Time(const Time *, eyedb::Bool = eyedb::False);
  Time(const eyedb::Class *, eyedb::Data);
};

class TimeStamp : public eyedb::Struct {

 public:
  TimeStamp(eyedb::Database * = 0, const eyedb::Dataspace * = 0);
  TimeStamp(const TimeStamp& x);

  virtual eyedb::Object *clone() const {return new TimeStamp(*this);};

  TimeStamp& operator=(const TimeStamp& x);

  virtual TimeStamp *asTimeStamp() {return this;}
  virtual const TimeStamp *asTimeStamp() const {return this;}

  eyedb::Status setUsecs(eyedblib::int64 );
  eyedblib::int64 getUsecs(eyedb::Bool *isnull = 0, eyedb::Status * = 0)  const;

  eyedb::Status setTz(eyedblib::int16 );
  eyedblib::int16 getTz(eyedb::Bool *isnull = 0, eyedb::Status * = 0)  const;
  virtual ~TimeStamp() {garbageRealize();}
  // TimeStamp User Part

 private:
  Time ts_time;
  Date ts_date;
  char string_time_stamp[64];

  virtual void userCopy(const Object &);
  virtual void userInitialize();
  void setClientData();
 public:
  static TimeStamp * gmt_time_stamp(Database * db);
  static TimeStamp * local_time_stamp(Database * db);
  static TimeStamp * time_stamp(Database * db, const TimeStamp &);
  static TimeStamp * time_stamp(Database * db, eyedblib::int64 usec);
  static TimeStamp * time_stamp(Database * db, eyedblib::int64 usec, eyedblib::int16 tz);
  static TimeStamp * time_stamp(Database * db, eyedblib::int32 julian_day, eyedblib::int64 usec);
  static TimeStamp * time_stamp(Database * db, eyedblib::int32 julian_day, eyedblib::int64 usec, eyedblib::int16 tz);
  static TimeStamp * time_stamp(Database * db, const Date & d, const Time & t);
  static TimeStamp * time_stamp(Database * db, const Date & d);
  static TimeStamp * time_stamp(Database * db, const Date & d, eyedblib::int16 tz_hour, eyedblib::int16 tz_min);
  static TimeStamp * time_stamp(Database * db, const char * t);
  static eyedblib::int64 usec_time_stamp(const char * ts);
  const Date & date() const;
  const Time & time() const;
  eyedblib::int32 year() const;
  eyedblib::int16 month() const;
  eyedblib::int16 day() const;
  eyedblib::int16 hour() const;
  eyedblib::int16 minute() const;
  eyedblib::int16 second() const;
  eyedblib::int16 millisecond() const;
  eyedblib::int16 tz_hour() const;
  eyedblib::int16 tz_minute() const;
  const char * toString() const;
  TimeStamp & plus(const TimeInterval & i);
  TimeStamp & minus(const TimeInterval & i);
  Bool is_equal(const TimeStamp & ts) const;
  Bool is_greater(const TimeStamp & ts) const;
  Bool is_greater_or_equal(const TimeStamp & ts) const;
  Bool is_less(const TimeStamp & ts) const;
  Bool is_less_or_equal(const TimeStamp & ts) const;
  Bool is_between(const TimeStamp & ts1, const TimeStamp & ts2) const;
  eyedblib::int16 gmt_hour() const;
  eyedblib::int16 gmt_minute() const;
  eyedblib::int16 microsecond() const;
  Status set_usecs(eyedblib::int64 usec, eyedblib::int16 tz);
  TimeInterval * substract(const TimeStamp & ts);
  

 protected:
  TimeStamp(eyedb::Database *_db, const eyedb::Dataspace *_dataspace, int) : eyedb::Struct(_db, _dataspace) {}
  TimeStamp(const eyedb::Struct *x, eyedb::Bool share, int) : eyedb::Struct(x, share) {}
  TimeStamp(const TimeStamp *x, eyedb::Bool share, int) : eyedb::Struct(x, share) {}

 private:
  void initialize(eyedb::Database *_db);

 public: /* restricted */
  TimeStamp(const eyedb::Struct *, eyedb::Bool = eyedb::False);
  TimeStamp(const TimeStamp *, eyedb::Bool = eyedb::False);
  TimeStamp(const eyedb::Class *, eyedb::Data);
};

class TimeInterval : public eyedb::Struct {

 public:
  TimeInterval(eyedb::Database * = 0, const eyedb::Dataspace * = 0);
  TimeInterval(const TimeInterval& x);

  virtual eyedb::Object *clone() const {return new TimeInterval(*this);};

  TimeInterval& operator=(const TimeInterval& x);

  virtual TimeInterval *asTimeInterval() {return this;}
  virtual const TimeInterval *asTimeInterval() const {return this;}

  eyedb::Status setUsecs(eyedblib::int64 );
  eyedblib::int64 getUsecs(eyedb::Bool *isnull = 0, eyedb::Status * = 0)  const;
  virtual ~TimeInterval() {garbageRealize();}
  // TimeInterval User Part

  private:
    char string_time_interval[32];

    virtual void userCopy(const Object &);
    virtual void userInitialize();
    void setClientData();
  public:

  static TimeInterval * time_interval(Database *, eyedblib::int64 usecs);
  static TimeInterval * time_interval(Database *, eyedblib::int32 day, eyedblib::int16 hours, eyedblib::int16 min, eyedblib::int16 sec, eyedblib::int16 msec, eyedblib::int16 usec);
  eyedblib::int32 day() const;
  eyedblib::int16 hour() const;
  eyedblib::int16 minute() const;
  eyedblib::int16 second() const;
  eyedblib::int16 millisecond() const;
  eyedblib::int16 microsecond() const;
  Bool is_zero() const;
  const char * toString() const;
  TimeInterval & plus(const TimeInterval & i);
  TimeInterval & minus(const TimeInterval & i);
  TimeInterval & product(eyedblib::int64 val);
  TimeInterval & quotient(eyedblib::int64 val);
  Bool is_equal(const TimeInterval & i) const;
  Bool is_greater(const TimeInterval & i) const;
  Bool is_greater_or_equal(const TimeInterval & i) const;
  Bool is_less(const TimeInterval & i) const;
  Bool is_less_or_equal(const TimeInterval & i) const;
  Status set_usecs(eyedblib::int64 usecs);
  

 protected:
  TimeInterval(eyedb::Database *_db, const eyedb::Dataspace *_dataspace, int) : eyedb::Struct(_db, _dataspace) {}
  TimeInterval(const eyedb::Struct *x, eyedb::Bool share, int) : eyedb::Struct(x, share) {}
  TimeInterval(const TimeInterval *x, eyedb::Bool share, int) : eyedb::Struct(x, share) {}

 private:
  void initialize(eyedb::Database *_db);

 public: /* restricted */
  TimeInterval(const eyedb::Struct *, eyedb::Bool = eyedb::False);
  TimeInterval(const TimeInterval *, eyedb::Bool = eyedb::False);
  TimeInterval(const eyedb::Class *, eyedb::Data);
};

class OString : public eyedb::Struct {

 public:
  OString(eyedb::Database * = 0, const eyedb::Dataspace * = 0);
  OString(const OString& x);

  virtual eyedb::Object *clone() const {return new OString(*this);};

  OString& operator=(const OString& x);

  virtual OString *asOString() {return this;}
  virtual const OString *asOString() const {return this;}

  eyedb::Status setS(const std::string &);
  eyedb::Status setS(unsigned int a0, char );
  std::string getS(eyedb::Bool *isnull = 0, eyedb::Status * = 0) const;
  char getS(unsigned int a0, eyedb::Bool *isnull = 0, eyedb::Status * = 0)  const;
  virtual ~OString() {garbageRealize();}
  // OString User Part

    static OString * ostring(Database * db);
    static OString * ostring(Database * db, const char * s);
    static OString * ostring(Database * db, const char * s, int len);
    static OString * ostring(Database * db, const char * s, int offset, int len);
    static OString * ostring(Database * db, const OString & s);
    static OString * ostring(Database * db, char s);
    static OString * ostring(Database * db, int s);
    static OString * ostring(Database * db, double s);
    static OString * concat(Database * db, const char * s1, const char * s2);
    static char * substr(const char *, int offset, int len);
    static char * toLower(const char *);
    static char * toUpper(const char *);
    static char * rtrim(const char *);
    static char * ltrim(const char *);

    Status setChar(char c, int offset);
    char getChar(int offset) const;

    OString & append(const char * s);
    OString & append(const char * s, int len);
    OString & append(const char * s, int offset, int len);
    OString & prepend(const char * s);
    OString & prepend(const char * s, int len);
    OString & prepend(const char * s, int offset, int len);
    OString & insert(int offset, const char *);
    OString & insert(int offset, const char *, int len);
    OString & insert(int offset, const char *, int offset2, int len);

    int first(const char *) const;
    int last(const char *) const;
    int find(const char *, int offset) const;
    OString * substr(int offset, int len) const;
    OString * substr(const char * regexp, int offset) const;

    OString & erase(int offset, int len);
    OString & replace(int offset, int len, const char *);
    OString & replace(int offset, int len, const char *, int len2);
    OString & replace(int offset, int len, const char *, int offset2, int len2);
    OString & replace(const char * s1, const char * s2);
    OString & assign(const char *);
    OString & assign(const char *, int len);
    OString & assign(const char *, int offset, int len);
    Status reset();

    OString & toLower();
    OString & toUpper();

    OString & rtrim();
    OString & ltrim();

    int compare(const char *) const;
    int compare(const char *, int to) const;
    int compare(const char *, int from, int to) const;
    Bool is_null() const;
    Bool match(const char * regexp) const;

    int length() const;
    char ** split(const char * separator, int & nb_pieces) const;
    char ** regexp_split(const char * regexp_separator, int & nb_pieces) const;
    

 protected:
  OString(eyedb::Database *_db, const eyedb::Dataspace *_dataspace, int) : eyedb::Struct(_db, _dataspace) {}
  OString(const eyedb::Struct *x, eyedb::Bool share, int) : eyedb::Struct(x, share) {}
  OString(const OString *x, eyedb::Bool share, int) : eyedb::Struct(x, share) {}

 private:
  void initialize(eyedb::Database *_db);

 public: /* restricted */
  OString(const eyedb::Struct *, eyedb::Bool = eyedb::False);
  OString(const OString *, eyedb::Bool = eyedb::False);
  OString(const eyedb::Class *, eyedb::Data);
};


extern eyedb::Object *utilsMakeObject(eyedb::Object *, eyedb::Bool=eyedb::True);
extern eyedb::Bool utils_set_oid_check(eyedb::Bool);
extern eyedb::Bool utils_get_oid_check();

extern eyedb::EnumClass *ImageType_Class;
extern eyedb::EnumClass *Month_Class;
extern eyedb::EnumClass *Weekday_Class;
extern eyedb::StructClass *Image_Class;
extern eyedb::StructClass *CURL_Class;
extern eyedb::StructClass *WConfig_Class;
extern eyedb::StructClass *Date_Class;
extern eyedb::StructClass *Time_Class;
extern eyedb::StructClass *TimeStamp_Class;
extern eyedb::StructClass *TimeInterval_Class;
extern eyedb::StructClass *OString_Class;


}

#endif

---