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 <typeinfo>
#include <iostream>
#include "simkerneldefs.h"
#include "simutil.h"
#include "cnamedobject.h"
#include "cexception.h"

namespace omnetpp {


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 *owner;    // 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 totalObjectCount;
    static long liveObjectCount;

  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) const override;

    virtual void parsimUnpack(cCommBuffer *buffer) override;

    virtual cObject *getOwner() const override {return owner;}

    virtual bool isOwnedObject() const override {return true;}

    virtual bool isSoftOwner() const {return false;}

    static cDefaultList *getDefaultOwner();

    static long getTotalObjectCount() {return totalObjectCount;}

    static long getLiveObjectCount() {return liveObjectCount;}

    static void resetObjectCounters()  {totalObjectCount=liveObjectCount=0L;}
};


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

    virtual cNoncopyableOwnedObject *dup() const override;

    virtual void parsimPack(cCommBuffer *buffer) const override;

    virtual void parsimUnpack(cCommBuffer *buffer) override;
};


//
// 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 bool insideMain() {return staticFlag;}
    static bool isExiting() {return exitingFlag;}
    static void setExiting() {exitingFlag = true;}
};

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;
}

}  // namespace omnetpp


#endif