Agregat.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_AGREGAT_H
#define _EYEDB_AGREGAT_H

namespace eyedb {

  class Agregat : public Instance {

    // ----------------------------------------------------------------------
    // Agregat Interface
    // ----------------------------------------------------------------------
  public:
    Agregat(Database *db = 0, const Dataspace *dataspace = 0);

    Agregat(const Agregat &o);

    Agregat(const Agregat *o, Bool share = False);

    Agregat& operator=(const Agregat &o);

    Status setValue(Data data);

    Status getValue(Data* data) const;

    Status setItemSize(const Attribute* agreg, Size size);

    Status getItemSize(const Attribute* agreg, Size* psize) const;

    Status setItemValue(const Attribute* agreg, Data data, int nb=1, int from=0);

    Status setItemOid(const Attribute* agreg, const Oid * poid, int nb=1, int from=0);

    Status getItemOid(const Attribute *agreg, Oid *poid, int nb = 1, int from = 0) const;

    virtual Status realize(const RecMode* recmode = RecMode::NoRecurs);

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

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

    virtual Agregat *asAgregat() {return this;}

    virtual const Agregat *asAgregat() const {return this;}

    virtual ~Agregat();

    // ----------------------------------------------------------------------
    // Agregat Protected Part
    // ----------------------------------------------------------------------
  protected:
    Status checkAgreg(const Attribute*) const;
    Status create();
    Status update();
    virtual void garbage();
#ifdef GBX_NEW_CYCLE
    virtual void decrRefCountPropag();
#endif
    void initialize(Database *);

    // ----------------------------------------------------------------------
    // Agregat Private Part
    // ----------------------------------------------------------------------
  private:
    void copy(const Agregat *, Bool);

    Status trace_realize(FILE*, int, unsigned int, const RecMode *) const;
    Status create_realize(Bool);
    Status update_realize(Bool);

    // ----------------------------------------------------------------------
    // Agregat Restricted Access (conceptually private)
    // ----------------------------------------------------------------------
  public:
    virtual void manageCycle(gbxCycleContext &);

    Status realizePerform(const Oid& cloid,
                          const Oid& objoid,
                          AttrIdxContext &idx_ctx,
                          const RecMode *);
    Status loadPerform(const Oid& cloid,
                       LockMode,
                       AttrIdxContext &idx_ctx,
                       const RecMode* = RecMode::NoRecurs);
    Status removePerform(const Oid& cloid,
                         const Oid& objoid,
                         AttrIdxContext &idx_ctx,
                         const RecMode *);
  };

  class AgregatPtr : public InstancePtr {

  public:
    AgregatPtr(Agregat *o = 0) : InstancePtr(o) { }

    Agregat *getAgregat() {return dynamic_cast<Agregat *>(o);}
    const Agregat *getAgregat() const {return dynamic_cast<Agregat *>(o);}

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

  typedef std::vector<AgregatPtr> AgregatPtrVector;

}

#endif

---