---

d_Ref_Any.h

Go to the documentation of this file.

#ifndef d_Ref_Any_h
#define d_Ref_Any_h 1

//------------------------------------------------------------------------------
#include "oPlatform.h"
#include "cTypes.h"
#include "cODMGLiteral.h"
#include "oObjectId.h"

//------------------------------------------------------------------------------
class _ODLL d_Object;

template< class T >
class _ODLL d_Ref; 

/**
 * Expresses relationships to objects.
 *
 * This class represents a generic reference to a persistent object. Use d_Ref
 * class for reference of knew type.
 * 
 * It can be used as attribute of a class for 1 to 1 relationship between
 * objects of the same or different class.
 * 
 * If it's used as template-argument of a class container in a class attribute
 * can express 1 to N relationships.
 *
 * LOCATION:
 * d_Ref_Any.h
 *
 * USAGE:
 * d_Ref_Any    <property-name>;
 * 
 * Where:
 * <PROPERTY-NAME>:     NAME OF PROPERTY
 *
 * EXAMPLES:
 * class Invoice : public d_Object
 * {
 *    * Relationship 1-1 to customer or supplier
 *   d_Ref_Any                  customer_or_supplier;
 * 
 *    * Relationship 1-N to product
 *   d_Set< d_Ref_Any > products;
 * };
 * 
 *  * Reference to Invoice object
 * d_Ref_Any<Invoice>   myInvoice;              
 *
 * SEE ALSO:
 * d_Ref, d_Object
 *
 * ODMG:
 * Compliant 
 */
class _ODLL d_Ref_Any 
{
  public:
    /**
     * Default constructor.
     *
     * Creates a null reference.
     *
     * ODMG    :  Compliant
     */
    d_Ref_Any ();

    /**
     * Creates a reference to <iObject> object.
     *
     * ODMG    :  Compliant 
     */
    d_Ref_Any (d_Object* iObject);

    /**
     * Copy constructor.
     *
     * Copy the reference of <iSource>.
     *
     * ODMG    :  Compliant 
     */
    d_Ref_Any (const d_Ref_Any& iSource);

    /**
     * Destructor.
     *
     * ODMG    :  Compliant 
     */
    ~d_Ref_Any();


    /**
     * Get a copy of the object <iSource>.
     *
     * ODMG    :  Compliant 
     */
    d_Ref_Any& operator =( const d_Ref_Any& iSource );

    /**
     * Get a reference for the object <iSource>.
     *
     * ODMG    :  Compliant 
     */
    d_Ref_Any& operator =( d_Object* iSource );

    /**
     * Check if two ref are equals (check the oid)
     *
     * ODMG    :  Extension
     */
    d_Boolean operator ==( const d_Ref_Any& iSource ) const;


    /**
     * Deletes permanently the object referred from memory and storage.
     *
     * ODMG    :  Compliant 
     */
    void delete_object ();

    // Internal.
    void free_object ();

    /**
     * Returns true is the reference has a null value otherwise false.
     * 
     * SEE ALSO:  is_null()
     * ODMG    :  Compliant 
     */
    d_Boolean operator ! () const;

    /**
     * Returns true is the reference has a null value otherwise false.
     * 
     * SEE ALSO:  operator !()
     * ODMG    :  Compliant 
     */
    d_Boolean is_null () const;

    /**
     * Clears the reference setting to null.
     *
     * ODMG    :  Compliant 
     */
    void clear ();


    // Internal.
    d_Ref_Any (const oObjectId& iSource);

    // Internal.
    bool check_for_oid();

    /**
     * Returns true is the reference is valid otherwise false.
     *
     * ODMG    :  Extension
     */
    bool is_valid () const;

    // Internal
    void setValid( bool iValid );

    /**
     * Returns true if the object referenced is already loaded in memory
     * otherwise false.
     * 
     * SEE ALSO:  d_Ref::operator -> (), d_Ref::ptr ()
     * ODMG    :  Extension
     */
    bool is_loaded () const;

    // Internal.
    void refresh();

    // Internal.
    const char* dump ();

    // Internal.
    void setOid (oUInt1 iDatabase, oUInt2 iClass, oUInt4 iRecord);

    // Internal.
    oObjectId& getOid ();

    // Internal.
    d_Object* getObject () const;

    // Internal.
    void clear_object();

    // Internal.
    void unload ();
  protected:

    // Internal.
    d_Object* ptr_check (bool& oLoad);

    // Internal.
    void ptr_load ();

    //--------------------------------------------------------------------------
    // ATTRIBUTES:
    //--------------------------------------------------------------------------
    // Internal
    bool valid;
    
    // Internal.
    oObjectId oid;

    // Internal.
    d_Object* object;
};

//------------------------------------------------------------------------------
inline d_Boolean d_Ref_Any::operator ! () const
{
  return !valid;
}
//------------------------------------------------------------------------------
inline d_Boolean d_Ref_Any::operator == (const d_Ref_Any& iSource) const
{
  if( !valid && !iSource.is_valid() )
    return true;

  if( valid && iSource.is_valid() )
    if( oid == iSource.oid )
      return true;
    else
      return false;

  return false;
}
//------------------------------------------------------------------------------
inline d_Boolean d_Ref_Any::is_null () const
{
  return !valid;
}
//------------------------------------------------------------------------------
inline bool d_Ref_Any::is_valid () const
{
  return valid;
}
//------------------------------------------------------------------------------
inline void d_Ref_Any::setValid( bool iValid )
{
  valid = iValid;
}
//------------------------------------------------------------------------------
inline bool d_Ref_Any::is_loaded () const
{
  return object ? true : false;
}
//------------------------------------------------------------------------------
inline oObjectId& d_Ref_Any::getOid ()
{
  return oid;
}
//------------------------------------------------------------------------------
inline d_Object* d_Ref_Any::getObject () const
{
  return object;
}
//------------------------------------------------------------------------------
inline void d_Ref_Any::clear_object()
{
  object = 0;
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

#endif

---