cobject.h

//==========================================================================
//  COBJECT.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_COBJECT_H
#define __OMNETPP_COBJECT_H
 
#include <string>
#include <iostream>
#include "simkerneldefs.h"
#include "cvisitor.h"
 
// Note: we include regmacros.h here in order to prevent the compiler from
// misunderstanding Register_Class() in other source files as a function declaration
#include "regmacros.h"
 
namespace omnetpp {
 
class cCommBuffer;
class cClassDescriptor;
class cOwnedObject;
class cSoftOwner;
 
 
class SIM_API cObject
{
    friend class cOwnedObject;
    friend class cSoftOwner;
 
#ifdef SIMFRONTEND_SUPPORT
    // internal: used by the UI to optimize refreshes
    virtual bool hasChangedSince(int64_t refreshSerial);
    static int64_t getChangeCounter() {return changeCounter;}
#endif
 
  protected:
#ifdef SIMFRONTEND_SUPPORT
    // internal
    static int64_t changeCounter;
#endif
 
    // internal
    virtual void ownedObjectDeleted(cOwnedObject *obj);
 
    // internal
    virtual void yieldOwnership(cOwnedObject *obj, cObject *to);
 
  public:
    // internal
    void takeAllObjectsFrom(cSoftOwner *list);
 
  public:
    cObject() {}
 
    cObject(const cObject& other) = default;
 
    virtual ~cObject();
 
    virtual const char *getClassName() const;
 
    virtual const char *getName() const  {return "";}
 
    bool isName(const char *s) const;
 
    virtual const char *getFullName() const  {return getName();}
 
    virtual std::string getFullPath() const;
 
    virtual std::string getClassAndFullName() const;
 
    virtual std::string getClassAndFullPath() const;
 
    const cObject *getThisPtr() const  {return this;}  //Note: nonvirtual
 
    virtual std::string str() const;
 
    virtual std::ostream& printOn(std::ostream& os) const;
 
    virtual cObject *dup() const;
 
  protected:
 
    virtual void take(cOwnedObject *obj);
 
    virtual void drop(cOwnedObject *obj);
 
    void dropAndDelete(cOwnedObject *obj);
 
  public:
    virtual void parsimPack(cCommBuffer *buffer) const;
 
    virtual void parsimUnpack(cCommBuffer *buffer);
 
    virtual cObject *getOwner() const {return nullptr;}
 
    virtual bool isOwnedObject() const {return false;}
 
    virtual bool isSoftOwner() const {return false;}
 
    virtual void forEachChild(cVisitor *v);
 
    cObject *findObject(const char *name, bool deep=true);
 
    virtual cClassDescriptor *getDescriptor() const;
 
    void copyNotSupported() const;
};
 
// operator<<
 
template<typename T>
typename std::enable_if<std::is_base_of<cObject, T>::value, std::ostream&>::type
operator<<(std::ostream& os, const T *p) {
    if (p)
        return p->printOn(os);
    else
        return os << "<nullptr>";
}
 
template<typename T>
typename std::enable_if<std::is_base_of<cObject, T>::value, std::ostream&>::type
operator<<(std::ostream& os, const T& o) {
    return o.printOn(os);
}
 
// as_cObject
 
template <typename T>
typename std::enable_if<std::is_polymorphic<T>::value, cObject*>::type
as_cObject(T *p) { return dynamic_cast<cObject*>(p); }
 
template <typename T>
typename std::enable_if<!std::is_polymorphic<T>::value, cObject*>::type
as_cObject(T *p) { return nullptr; }
 
template <typename T>
typename std::enable_if<std::is_polymorphic<T>::value, const cObject*>::type
as_cObject(const T *p) { return dynamic_cast<const cObject*>(p); }
 
template <typename T>
typename std::enable_if<!std::is_polymorphic<T>::value, const cObject*>::type
as_cObject(const T *p) { return nullptr; }
 
class noncopyable
{
  protected:
    noncopyable() {}
    ~noncopyable() {}
  private:
    // private, and in addition deleted
    noncopyable(const noncopyable& x) = delete;
    const noncopyable& operator=(const noncopyable&) = delete;
};
 
}  // namespace omnetpp
 
 
#endif