cownedobject.h

//==========================================================================
//  COWNEDOBJECT.H - part of
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//==========================================================================
 
/*--------------------------------------------------------------*
  Copyright (C) 1992-2017 Andras Varga
  Copyright (C) 2006-2017 OpenSim Ltd.
 
  This file is distributed WITHOUT ANY WARRANTY. See the file
  `license' for details on this and other legal matters.
*--------------------------------------------------------------*/
 
#ifndef __OMNETPP_COWNEDOBJECT_H
#define __OMNETPP_COWNEDOBJECT_H
 
#include <utility>
#include <typeinfo>
#include <iostream>
#include "simkerneldefs.h"
#include "cnamedobject.h"
#include "cexception.h"
 
namespace omnetpp {
 
class cOwnedObject;
class cNoncopyableOwnedObject;
class cStaticFlag;
class cSimulation;
class cSoftOwner;
class cMessage;
class cPacket;
 
namespace internal { class Void; }
 
class SIM_API cOwnedObject : public cNamedObject
{
    friend class cObject;
    friend class cNoncopyableOwnedObject;
    friend class cSoftOwner;
    friend class cSimulation;
    friend class cMessage;  // because of refcounting business
    friend class cPacket;   // because of refcounting business
 
  private:
    cObject *owner;    // owner pointer
    unsigned int pos;  // used only when owner is a cSoftOwner
 
    // list in which objects are accumulated if there is no simple module in context
    // (see also setOwningContext() and cSimulation::setContextModule())
    static cSoftOwner *owningContext;
 
    // global variables for statistics
    static long totalObjectCount;
    static long liveObjectCount;
 
  private:
    cOwnedObject(const char *name, bool namepooling, internal::Void *dummy);
    void copy(const cOwnedObject& obj);
 
  public:
    // internal
    virtual void removeFromOwnershipTree();
 
    // internal
    static void setOwningContext(cSoftOwner *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) const override;
 
    virtual void parsimUnpack(cCommBuffer *buffer) override;
 
    virtual cObject *getOwner() const override {return owner;}
 
    virtual bool isOwnedObject() const override {return true;}
 
    static cSoftOwner *getOwningContext();
 
    static long getTotalObjectCount() {return totalObjectCount;}
 
    static long getLiveObjectCount() {return liveObjectCount;}
 
    static void resetObjectCounters()  {totalObjectCount=liveObjectCount=0L;}
};
 
 
class SIM_API cNoncopyableOwnedObject : public cOwnedObject, noncopyable
{
    friend class cSoftOwner;
  private:
    cNoncopyableOwnedObject(const char *name, bool namepooling, internal::Void *dummy) : cOwnedObject(name, namepooling, dummy) {}
    virtual void parsimPack(cCommBuffer *) const override {throw cRuntimeError(this, E_CANTPACK);}
    virtual void parsimUnpack(cCommBuffer *) override {throw cRuntimeError(this, E_CANTPACK);}
 
  public:
    explicit cNoncopyableOwnedObject(const char *name=nullptr, bool namepooling=true) :
        cOwnedObject(name, namepooling) {}
 
    virtual cNoncopyableOwnedObject *dup() const override;
};
 
 
//
// Internal class: provides a flag that shows if control is in the main() function.
//
class SIM_API cStaticFlag
{
  public:
    cStaticFlag();
    ~cStaticFlag();
    static bool insideMain();
    static bool isExiting();
    static void setExiting();
};
 
}  // namespace omnetpp
 
 
#endif