CollArray.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_COLL_ARRAY_H
#define _EYEDB_COLL_ARRAY_H

namespace eyedb {

  class CollArray : public Collection {

    // ----------------------------------------------------------------------
    // CollArray Interface
    // ----------------------------------------------------------------------
  public:
    CollArray(Database *db, const char *n, Class *mc = NULL,
              Bool isref = True,
              const CollImpl *collimpl = 0);

    CollArray(Database *db, const char *n, Class *mc, int dim,
              const CollImpl *collimpl = 0);

    CollArray(const CollArray &o);

    CollArray& operator=(const CollArray &o);

    virtual Object *clone() const {return new CollArray(*this);}
  
    Status insert(const Value &value, Bool noDup = False);

    Status suppress(const Value &value, Bool checkFirst = False);

    Status insertAt(Collection::ItemId id, const Value &value);

    Status append(const Value &value);

    Status suppressAt(Collection::ItemId id);

    Status retrieveAt(Collection::ItemId id, Value &value) const;

    Status retrieveAt(Collection::ItemId id, Oid &item_oid) const;

    Status retrieveAt(Collection::ItemId id, ObjectPtr &o,
                      const RecMode *recmode = RecMode::NoRecurs) const;

    Status retrieveAt(Collection::ItemId id, Object *&o,
                      const RecMode *recmode = RecMode::NoRecurs) const;

    virtual CollArray *asCollArray() {return this;}

    virtual const CollArray *asCollArray() const {return this;}

    Status getImplStats(std::string &, std::string &, Bool dspImpl = True,
                        Bool full = False, const char *indent = "");
    Status getImplStats(IndexStats *&, IndexStats *&);

    Status simulate(const CollImpl &, std::string &, std::string &,
                    Bool dspImpl = True, Bool full = False,
                    const char *indent = "");
    Status simulate(const CollImpl &, IndexStats *&, IndexStats *&);

    virtual void garbage();

    // ----------------------------------------------------------------------
    // CollArray Private Part
    // ----------------------------------------------------------------------
  private:
    ValueCache *read_arr_cache;

    void init();
    const char *getClassName() const;
    CollArray(const char *, Class *,
              const Oid&, const Oid&, int,
              int, int, const CollImpl *, Object *,
              Bool, Bool, Data, Size);
    friend class CollectionPeer;

    // ----------------------------------------------------------------------
    // CollArray Restricted Access (conceptually private)
    // ----------------------------------------------------------------------
  public:
    CollArray(const char *, Class * = NULL, Bool = True,
              const CollImpl * = 0);
    CollArray(const char *, Class *, int,
              const CollImpl * = 0);

    Status insert_p(const Oid &item_oid, Bool noDup = False);
    Status insert_p(const Object *item_o, Bool noDup = False);
    Status insert_p(Data val, Bool noDup = False, Size size = defaultSize);
    Status suppress_p(const Oid &item_oid, Bool checkFirst = False);
    Status suppress_p(const Object *item_o, Bool checkFirst = False);
    Status suppress_p(Data data, Bool checkFirst = False, Size size = defaultSize);
    Status insertAt_p(Collection::ItemId id, const Oid &item_oid);
    Status insertAt_p(Collection::ItemId id, const Object *item_o);
    Status insertAt_p(Collection::ItemId id, Data val, Size size = defaultSize);
    Status append_p(const Oid &item_oid, Bool noDup = False);
    Status append_p(const Object *item_o, Bool noDup = False);
    Status append_p(Data data, Bool noDup = False, Size size = defaultSize);
    Status retrieveAt_p(Collection::ItemId id, Data data, Size size = defaultSize) const;

  };

  class CollArrayPtr : public CollectionPtr {

  public:
    CollArrayPtr(CollArray *o = 0) : CollectionPtr(o) { }

    CollArray *getCollArray() {return dynamic_cast<CollArray *>(o);}
    const CollArray *getCollArray() const {return dynamic_cast<CollArray *>(o);}

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

  typedef std::vector<CollArrayPtr> CollArrayPtrVector;

}

#endif

---