cownedobject.h

//==========================================================================
//  COWNEDOBJECT.H - part of
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//  Author: Andras Varga
//
//==========================================================================

/*--------------------------------------------------------------*
  Copyright (C) 1992-2008 Andras Varga
  Copyright (C) 2006-2008 OpenSim Ltd.

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

#ifndef __COWNEDOBJECT_H
#define __COWNEDOBJECT_H

#include <typeinfo>
#include <iostream>
#include "simkerneldefs.h"
#include "simutil.h"
#include "cnamedobject.h"
#include "cexception.h"

NAMESPACE_BEGIN


class cOwnedObject;
class cStaticFlag;
class cSimulation;
class cDefaultList;
class cMessage;
class cPacket;


class SIM_API cOwnedObject : public cNamedObject
{
    friend class cObject;
    friend class cDefaultList;
    friend class cSimulation;
    friend class cMessage;  // because of refcounting business
    friend class cPacket;   // because of refcounting business

  private:
    cObject *ownerp;   // owner pointer
    unsigned int pos;  // used only when owner is a cDefaultList

  private:
    // list in which objects are accumulated if there is 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;

  private:
    void copy(const cOwnedObject& obj);

  public:
    // internal
    virtual void removeFromOwnershipTree();

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

  public:
    cOwnedObject();

    explicit cOwnedObject(const char *name, bool namepooling=true);

    cOwnedObject(const cOwnedObject& obj);

    virtual ~cOwnedObject();

    cOwnedObject& operator=(const cOwnedObject& o);

    // Note: dup() is still the original cObject one, which throws an error
    // to indicate that dup() has to be redefined in each subclass.

    virtual void parsimPack(cCommBuffer *buffer);

    virtual void parsimUnpack(cCommBuffer *buffer);

    virtual cObject *getOwner() const {return ownerp;}

    virtual bool isOwnedObject() const {return true;}

    virtual bool isSoftOwner() const {return false;}

    static cDefaultList *getDefaultOwner();

    static long getTotalObjectCount() {return total_objs;}

    static long getLiveObjectCount() {return live_objs;}

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


class SIM_API cNoncopyableOwnedObject : public cOwnedObject, noncopyable
{
  public:
    explicit cNoncopyableOwnedObject(const char *name=NULL, bool namepooling=true) :
        cOwnedObject(name, namepooling) {}

    virtual cNoncopyableOwnedObject *dup() const;

    virtual void parsimPack(cCommBuffer *buffer);

    virtual void parsimUnpack(cCommBuffer *buffer);
};


//
// Internal class: provides a flag that shows if control is in the main() function.
//
class SIM_API cStaticFlag
{
  private:
    static bool staticflag;  // set to true while in main()
    static bool exitingflag; // set on getting a TERM or INT signal (Windows)
  public:
    cStaticFlag()  {staticflag = true;}
    ~cStaticFlag() {staticflag = false;}
    static void set(bool b) {staticflag = b;}
    static void setExiting() {exitingflag = true;}
    static bool isExiting() {return exitingflag;}
    static bool isSet() {return staticflag;}
};

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

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

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


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

template<class T>
const T check_and_cast(const cObject *p)
{
    return check_and_cast<T>(const_cast<cObject *>(p));
}

NAMESPACE_END


#endif