cobject.h

//==========================================================================
//  COBJECT.H - part of
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//  Declaration of the following classes:
//    cObject      : general base class
//
//==========================================================================

/*--------------------------------------------------------------*
  Copyright (C) 1992-2005 Andras Varga

  This file is distributed WITHOUT ANY WARRANTY. See the file
  `license' for details on this and other legal matters.
*--------------------------------------------------------------*/

#ifndef __COBJECT_H
#define __COBJECT_H

#include <typeinfo>
#include <iostream>
#include "cenvir.h"
#include "defs.h"
#include "util.h"
#include "cpolymorphic.h"
#include "cexception.h"
#include "cvisitor.h"


#define MAX_INTERNAL_NAME 11  /* should be 4n+3 */


//=== classes declared here
class cObject;
class cStaticFlag;

//=== classes mentioned
class cCommBuffer;
class cArray;
class cDefaultList;


typedef int (*CompareFunc)(cObject *a, cObject *b);


class SIM_API cObject : public cPolymorphic
{
  private:
    friend class cDefaultList;
    friend class cSimulation;

    union
    {
        char *p;
        char chars[MAX_INTERNAL_NAME+1];
        // last char: !=0 if p is used; =0 if chars[] is used (then also serves as EOS for 10-long strings)
    } nameunion;

    cObject *ownerp;       // owner pointer
    int pos;               // used if owner is a cDefaultList

    // list in which objects are accumulated if there's no simple module in context
    // (see also setDefaultOwner() and cSimulation::setContextModule())
    static cDefaultList *defaultowner;

    // global variables for statistics
    static long total_objs;
    static long live_objs;

  protected:
    static char fullpathbuf[MAX_OBJECTFULLPATH]; // buffer for fullPath()

  private:
    // internal
    virtual void ownedObjectDeleted(cObject *obj);

    // internal
    virtual void yieldOwnership(cObject *obj, cObject *to);

  public:
    // internal
    virtual void removeFromOwnershipTree();

    // internal
    static void setDefaultOwner(cDefaultList *list);

    // called internally by cSimpleModule::snapshot(), and in turn it calls writeContents()
    virtual void writeTo(std::ostream& os);

  protected:

    virtual void take(cObject *obj);

    virtual void drop(cObject *obj);

    void dropAndDelete(cObject *obj);


    void copyNotSupported() const;

  public:

    cObject(const cObject& obj);

    cObject();

    explicit cObject(const char *name);

    virtual ~cObject();

    virtual cObject *dup() const    {return new cObject(*this);}

    cObject& operator=(const cObject& o);


    virtual void setName(const char *s);

    const char *name() const  {return nameunion.chars[MAX_INTERNAL_NAME] ? nameunion.p : nameunion.chars;}

    bool isName(const char *s) const {return !opp_strcmp(name(),s);}

    virtual const char *fullName() const  {return name();}

    virtual std::string fullPath() const;

    virtual const char *fullPath(char *buffer, int buffersize) const;


    cObject *owner() const {return ownerp;}

    virtual bool isSoftOwner()  {return false;}

    static cDefaultList *defaultOwner();


    virtual void writeContents(std::ostream& os);


    virtual void netPack(cCommBuffer *buffer);

    virtual void netUnpack(cCommBuffer *buffer);


    virtual void forEachChild(cVisitor *v);

    cObject *findObject(const char *name, bool deep=true);

    static int cmpbyname(cObject *one, cObject *other);

    static long totalObjectCount() {return total_objs;}

    static long liveObjectCount() {return live_objs;}

    static void resetMessageCounters()  {total_objs=live_objs=0L;}
};


//
// Internal helper class for cObject.
//
class cStaticFlag
{
  private:
    static bool staticflag;  // set to true while in main()
  public:
    cStaticFlag()  {staticflag = true;}
    ~cStaticFlag() {staticflag = false;}
    static bool isSet() {return staticflag;}
};

std::ostream& operator<< (std::ostream& os, const cObject *p);
std::ostream& operator<< (std::ostream& os, const cObject& o);

inline std::ostream& operator<< (std::ostream& os, cObject *p) {
    return os << (const cObject *)p;
}

inline std::ostream& operator<< (std::ostream& os, cObject& o) {
    return os << (const cObject&)o;
}


// Note: this function cannot be put into utils.h (circular dependencies)
template<class T>
T check_and_cast(cPolymorphic *p)
{
    if (!p)
        throw new cRuntimeError("check_and_cast(): cannot cast NULL pointer to type '%s'",opp_typename(typeid(T)));
    T ret = dynamic_cast<T>(p);
    if (!ret)
        throw new cRuntimeError("check_and_cast(): cannot cast (%s *)%s to type '%s'",p->className(),p->fullPath().c_str(),opp_typename(typeid(T)));
    return ret;
}

#endif

---