Collection.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_COLLECTION_H
#define _EYEDB_COLLECTION_H

#define USE_VALUE_CACHE

namespace eyedb {

  class ValueCache;
  class CollectionPeer;
  class CardinalityDescription;
  class IndexImpl;

  class Collection : public Instance {

    // ----------------------------------------------------------------------
    // Collection Interface
    // ----------------------------------------------------------------------
  public:

    typedef eyedblib::uint32 ItemId;

    int getCount() const;

    Bool isEmpty() const;

    const char *getName() const {return name;}

    void setName(const char *s);

    Status getStatus() const;

    static const Size defaultSize;

    virtual Status insert(const Value &v, Bool noDup = False);

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

    Status empty();


    virtual Status isIn(const Value &value, Bool &found,
                        Collection::ItemId *where = 0) const;

    Status getElements(OidArray &oid_array) const;

    Status getElements(ObjectPtrVector &obj_vect,
                       const RecMode *recmode = RecMode::NoRecurs) const;

    Status getElements(ObjectArray &obj_array,
                       const RecMode *recmode = RecMode::NoRecurs) const;

    Status getElements(ValueArray &value_array, Bool index = False) const;


    Status realize(const RecMode *recmod = RecMode::NoRecurs);

    Status remove(const RecMode *recmode = RecMode::NoRecurs);

    Status trace(FILE *fd = stdout, unsigned int flags = 0,
                 const RecMode *recmode = RecMode::FullRecurs) const;

    void setImplementation(const IndexImpl *idximpl);

    Status getImplementation(IndexImpl *&idximpl, Bool remote = False) const;

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

    Status getImplStats(IndexStats *&stats);

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

    Status simulate(const IndexImpl &idximpl, IndexStats *&stats);

    virtual Status setDatabase(Database *mdb);

    virtual void garbage();

    void setCardinalityConstraint(Object *card);

    CardinalityDescription *getCardinalityConstraint() const;

    Status checkCardinality() const;

    Status realizeCardinality();

    int getBottom() const;

    int getTop() const;

    virtual Collection *asCollection() {return this;}

    virtual const Collection *asCollection() const {return this;}

    Status getDefaultDataspace(const Dataspace *&dataspace) const;

    Status setDefaultDataspace(const Dataspace *dataspace);

    Status moveElements(const Dataspace *dataspace);

    Status getLocations(ObjectLocationArray &);

    Bool isLiteral() const {return is_literal;}
    Bool isPureLiteral() const {return is_pure_literal;}
    Bool isLiteralObject() const;

    Status setLiteralObject(bool force);

    virtual ~Collection();

    enum State {
      coherent = 1,
      added,
      removed,
      modified
    };

    // ----------------------------------------------------------------------
    // Collection Protected Part
    // ----------------------------------------------------------------------
  protected:
    eyedblib::int32 type;
    char *name;
    Bool ordered;
    Bool allow_dup;
    Bool string_coll;
    int bottom, top;
    Bool implModified;

    Class *coll_class;
    Bool isref;
    eyedblib::int16 dim;
    eyedblib::int16 item_size;
    Oid cl_oid;

    Bool locked;
    IndexImpl *idximpl;
    Oid inv_oid;
    eyedblib::int16 inv_item;

    Bool is_literal;
    Bool is_pure_literal;
    Oid literal_oid;
    Size idx_data_size;
    Data idx_data;

    CardinalityDescription *card;
    int card_bottom, card_bottom_excl, card_top, card_top_excl;
    Oid card_oid;

    Oid idx1_oid, idx2_oid;
    eyedbsm::Idx *idx1, *idx2; // back end only
    int p_items_cnt;
    int v_items_cnt;
    ValueCache *cache;
    Bool is_complete;
    void create_cache();

    struct ReadCache {
      ObjectArray *obj_arr;
      OidArray *oid_arr;
      ValueArray *val_arr;
    } read_cache;

    Status status;
    Data make_data(Data, Size, Bool swap = False) const;
    void decode(Data) const;

    Collection(const char *, Class * = NULL, Bool = True,
               const IndexImpl * = 0);
    Collection(const char *, Class *, int, const IndexImpl * = 0);

    Status check(const Oid&, const Class *, Error) const;
    Status check(const Oid&, Error) const;
    Status check(const Object*, Error) const;
    Status check(Data, Size, Error) const;
    Status check(const Value &, Error) const;

    Status trace_realize(FILE*, int, unsigned int, const RecMode *) const;
    Status trace_contents_realize(FILE*, int, unsigned int, const RecMode *) const;
    Status getIdxOid(Oid &idx1oid, Oid &idx2oid) const;
    void completeImplStats(IndexStats *stats) const;

    void isStringColl();

    Collection(const char *, Class *,
               const Oid&, const Oid&, int, int,
               int, const IndexImpl *,
               Object *, Bool, Bool, Data, Size);
    void make(const char *, Class *, Bool, const IndexImpl *);
    void make(const char *, Class *, int, const IndexImpl *);
    Status getOidElementsRealize();
    Status getObjElementsRealize(const RecMode * = RecMode::NoRecurs);
    Status getValElementsRealize(Bool index = False);

    // ----------------------------------------------------------------------
    // Collection Private Part
    // ----------------------------------------------------------------------
  private:
    Collection::State read_cache_state_oid, read_cache_state_object,
      read_cache_state_value;
    Bool read_cache_state_index;
    Bool inverse_valid;
    virtual Status cache_compile(Offset &, Size&, unsigned char **, const RecMode *);
    void _init(const IndexImpl *);
    Status init_idr();
    virtual const char *getClassName() const = 0;
    friend class CollectionPeer;

    Status codeIndexImpl(Data &, Offset &, Size &);
    Status setValue(Data);
    Status getValue(Data*) const;
    void cardCode(Data &, Offset &offset, Size &alloc_size);
    Status failedCardinality() const;
    Status create();
    Status update();
    Status updateLiteral();
    Status loadLiteral();

    enum {
      CollObject = 0,
      CollPureLiteral = 1,
      CollLiteral = 2
    };
    char codeLiteral() const;
    Status literalMake(Collection *o);
    std::string getStringType() const;
    Offset inv_oid_offset;

    // ----------------------------------------------------------------------
    // Collection Restricted Access (conceptually private)
    // ----------------------------------------------------------------------
  public:
    Collection(const Collection &);
    Collection& operator=(const Collection &);
    static Object *cardDecode(Database *, Data, Offset &);
    Status realizeInverse(const Oid&, int);
    void setInverse(const Oid&, int);
    void invalidateInverse() {inverse_valid = False;}
    void validateInverse() {inverse_valid = True;}
    void unvalidReadCache();
    void emptyReadCache();
    void setLiteral(Bool _is_literal);
    void setPureLiteral(Bool _is_pure_literal);
    Oid getLiteralOid() const {return literal_oid;}
    void setLiteralOid(Oid _literal_oid) {literal_oid = _literal_oid;}
    Oid& getOidC() {
      return is_literal ? literal_oid : oid;
    }
    const Oid& getOidC() const {
      return is_literal ? literal_oid : oid;
    }

    static void decodeLiteral(char c, Bool &is_literal, Bool &is_pure_literal);
    Bool isPartiallyStored() const;
    virtual Status setMasterObject(Object *_master_object);
    virtual Status releaseMasterObject();

    void makeValue(Value &);

    Status create_realize(const RecMode *);
    Status update_realize(const RecMode *);
    Status realizePerform(const Oid& cloid,
                          const Oid& objoid,
                          AttrIdxContext &idx_ctx,
                          const RecMode *);
    Status loadPerform(const Oid&,
                       LockMode lockmode,
                       AttrIdxContext &idx_ctx,
                       const RecMode* = RecMode::NoRecurs);
    Status removePerform(const Oid& cloid,
                         const Oid& objoid,
                         AttrIdxContext &idx_ctx,
                         const RecMode *);
    Status loadDeferred(LockMode lockmode = DefaultLock,
                        const RecMode * = RecMode::NoRecurs);
    Status postRealizePerform(const Oid& cloid,
                              const Oid& objoid,
                              AttrIdxContext &idx_ctx,
                              Bool&,
                              const RecMode *rcm);
    virtual Status insert_p(const Oid &item_oid, Bool noDup = False) = 0;
    virtual Status insert_p(const Object *o, Bool noDup = False) = 0;
    virtual Status insert_p(Data val, Bool noDup = False,
                            Size size = defaultSize) = 0;
    virtual Status suppress_p(const Oid &item_oid, Bool checkFirst = False);
    virtual Status suppress_p(const Object *item_o, Bool checkFirst = False);
    virtual Status suppress_p(Data data, Bool checkFirst = False,
                              Size size = defaultSize);
    virtual Status isIn_p(const Oid &item_oid, Bool &found,
                          Collection::ItemId *where = 0) const;
    virtual Status isIn_p(const Object *item_o, Bool &found,
                          Collection::ItemId *where = 0) const;
    Status isIn_p(Data data, Bool &found, Size size = defaultSize,
                  Collection::ItemId *where = 0) const;

  };

  class CollectionPtr : public InstancePtr {

  public:
    CollectionPtr(Collection *o = 0) : InstancePtr(o) { }

    Collection *getCollection() {return dynamic_cast<Collection *>(o);}
    const Collection *getCollection() const {return dynamic_cast<Collection *>(o);}

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

  typedef std::vector<CollectionPtr> CollectionPtrVector;

}

#endif

---