cwatch.h

//==========================================================================
//  CWATCH.H - part of
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//
//  Declaration of the following classes:
//    cWatchBase etc: make primitive types, structs etc inspectable
//
//==========================================================================

/*--------------------------------------------------------------*
  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 __CWATCH_H
#define __CWATCH_H

#include <iostream>
#include <sstream>
#include "cownedobject.h"

NAMESPACE_BEGIN


class SIM_API cWatchBase : public cNoncopyableOwnedObject
{
  public:
    cWatchBase(const char *name)  : cNoncopyableOwnedObject(name) {}

    virtual bool supportsAssignment() const = 0;

    virtual void assign(const char *s) {}
};


template<typename T>
class cGenericReadonlyWatch : public cWatchBase
{
  private:
    const T& r;
  public:
    cGenericReadonlyWatch(const char *name, const T& x) : cWatchBase(name), r(x) {}
    virtual const char *getClassName() const {return opp_typename(typeid(T));}
    virtual bool supportsAssignment() const {return false;}
    virtual std::string info() const
    {
        std::stringstream out;
        out << r;
        return out.str();
    }
};


template<typename T>
class cGenericAssignableWatch : public cWatchBase
{
  private:
    T& r;
  public:
    cGenericAssignableWatch(const char *name, T& x) : cWatchBase(name), r(x) {}
    virtual const char *getClassName() const {return opp_typename(typeid(T));}
    virtual bool supportsAssignment() const {return true;}
    virtual std::string info() const
    {
        std::stringstream out;
        out << r;
        return out.str();
    }
    virtual void assign(const char *s)
    {
        std::stringstream in(s);
        in >> r;
    }
};

class SIM_API cWatch_bool : public cWatchBase
{
  private:
    bool& r;
  public:
    cWatch_bool(const char *name, bool& x) : cWatchBase(name), r(x) {}
    virtual const char *getClassName() const {return "bool";}
    virtual bool supportsAssignment() const {return true;}
    virtual std::string info() const
    {
        return r ? "true" : "false";
    }
    virtual void assign(const char *s)
    {
        r = *s!='0' && *s!='n' && *s!='N' && *s!='f' && *s!='F';
    }
};

class SIM_API cWatch_char : public cWatchBase
{
  private:
    char& r;
  public:
    cWatch_char(const char *name, char& x) : cWatchBase(name), r(x) {}
    virtual const char *getClassName() const {return "char";}
    virtual bool supportsAssignment() const {return true;}
    virtual std::string info() const
    {
        std::stringstream out;
        out << "'" << ((unsigned char)r<32 ? ' ' : r) << "' (" << int(r) << ")";
        return out.str();
    }
    virtual void assign(const char *s)
    {
        if (s[0]=='\'')
            r = s[1];
        else
            r = atoi(s);
    }
};

class SIM_API cWatch_uchar : public cWatchBase
{
  private:
    unsigned char& r;
  public:
    cWatch_uchar(const char *name, unsigned char& x) : cWatchBase(name), r(x) {}
    virtual const char *getClassName() const {return "unsigned char";}
    virtual bool supportsAssignment() const {return true;}
    virtual std::string info() const
    {
        std::stringstream out;
        out << "'" << (char)(r<' ' ? ' ' : r) << "' (" << int(r) << ")";
        return out.str();
    }
    virtual void assign(const char *s)
    {
        if (s[0]=='\'')
            r = s[1];
        else
            r = atoi(s);
    }
};

class SIM_API cWatch_stdstring : public cWatchBase
{
  private:
    std::string& r;
  public:
    cWatch_stdstring(const char *name, std::string& x) : cWatchBase(name), r(x) {}
    virtual const char *getClassName() const {return "std::string";}
    virtual bool supportsAssignment() const {return true;}
    virtual std::string info() const;
    virtual void assign(const char *s);
};

class SIM_API cWatch_cObject : public cWatchBase
{
  private:
    cObject& r;
  public:
    cWatch_cObject(const char *name, cObject& ref) : cWatchBase(name), r(ref) {}
    virtual const char *getClassName() const {return r.getClassName();}
    virtual std::string info() const {return r.info();}
    virtual bool supportsAssignment() const {return false;}
    virtual cClassDescriptor *getDescriptor() {return r.getDescriptor();}
};

class SIM_API cWatch_cObjectPtr : public cWatchBase
{
  private:
    cObject *&rp;
  public:
    cWatch_cObjectPtr(const char *name, cObject *&ptr) : cWatchBase(name), rp(ptr) {}
    virtual const char *getClassName() const {return rp? rp->getClassName() : "n/a";}
    virtual std::string info() const {return rp ? rp->info() : "<null>";}
    virtual bool supportsAssignment() const {return false;}
    virtual cClassDescriptor *getDescriptor() {return rp ? rp->getDescriptor() : NULL;}
};


inline cWatchBase *createWatch(const char *varname, short& d) {
    return new cGenericAssignableWatch<short>(varname, d);
}

inline cWatchBase *createWatch(const char *varname, unsigned short& d) {
    return new cGenericAssignableWatch<unsigned short>(varname, d);
}

inline cWatchBase *createWatch(const char *varname, int& d) {
    return new cGenericAssignableWatch<int>(varname, d);
}

inline cWatchBase *createWatch(const char *varname, unsigned int& d) {
    return new cGenericAssignableWatch<unsigned int>(varname, d);
}

inline cWatchBase *createWatch(const char *varname, long& d) {
    return new cGenericAssignableWatch<long>(varname, d);
}

inline cWatchBase *createWatch(const char *varname, unsigned long& d) {
    return new cGenericAssignableWatch<unsigned long>(varname, d);
}

inline cWatchBase *createWatch(const char *varname, float& d) {
    return new cGenericAssignableWatch<float>(varname, d);
}

inline cWatchBase *createWatch(const char *varname, double& d) {
    return new cGenericAssignableWatch<double>(varname, d);
}

inline cWatchBase *createWatch(const char *varname, bool& d) {
    return new cWatch_bool(varname, d);
}

inline cWatchBase *createWatch(const char *varname, char& d) {
    return new cWatch_char(varname, d);
}

inline cWatchBase *createWatch(const char *varname, unsigned char& d) {
    return new cWatch_uchar(varname, d);
}

inline cWatchBase *createWatch(const char *varname, signed char& d) {
    return new cWatch_char(varname, *(char *)&d);
}

inline cWatchBase *createWatch(const char *varname, std::string& v) {
    return new cWatch_stdstring(varname, v);
}

// this is the fallback, if none of the above match
template<typename T>
inline cWatchBase *createWatch(const char *varname, T& d) {
    return new cGenericReadonlyWatch<T>(varname, d);
}

// to be used if T also has op>> defined
template<typename T>
inline cWatchBase *createWatch_genericAssignable(const char *varname, T& d) {
    return new cGenericAssignableWatch<T>(varname, d);
}

// for objects
inline cWatchBase *createWatch_cObject(const char *varname, cObject& obj) {
    return new cWatch_cObject(varname, obj);
}

// for pointers to objects.
// NOTE: this is a bit tricky. C++ thinks that (cObject*&) and
// (SomeDerivedType*&) are unrelated, so we have to force the cast
// in the WATCH_PTR() macro. But to stay type-safe, we include a 3rd arg
// of type cObject*: the compiler has to be able to cast that
// implicitly from SomeDerivedType* -- this way we do not accept pointers
// that are REALLY unrelated.
inline cWatchBase *createWatch_cObjectPtr(const char *varname, cObject *&refp, cObject *p) {
    ASSERT(refp==p);
    return new cWatch_cObjectPtr(varname, refp);
}



#define WATCH(variable)    createWatch(#variable,(variable))

#define WATCH_RW(variable) createWatch_genericAssignable(#variable,(variable))

#define WATCH_OBJ(variable) createWatch_cObject(#variable,(variable))

#define WATCH_PTR(variable) createWatch_cObjectPtr(#variable,(cObject*&)(variable),(variable))


NAMESPACE_END


#endif