simutil.h

//==========================================================================
//  SIMUTIL.H - part of
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//
//  Utility functions
//
//==========================================================================

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

#include <string.h>  // for strlen, etc.
#include <stdarg.h>  // for va_list
#include <stdio.h>   // for sprintf
#include <stdlib.h>  // for gcvt
#include <typeinfo>  // for type_info
#include <string>    // for std::string
#include "simkerneldefs.h"
#include "platdep/platmisc.h" // for gcvt, etc
#include "errmsg.h"

NAMESPACE_BEGIN

// forward declarations
class cComponent;

// logically belongs to csimulation.h but must be here because of declaration order
enum {CTX_NONE, CTX_BUILD, CTX_INITIALIZE, CTX_EVENT, CTX_FINISH, CTX_CLEANUP};


#ifdef USE_DOUBLE_SIMTIME


SIM_API double strToSimtime(const char *str);

SIM_API double strToSimtime0(const char *&str);

SIM_API char *simtimeToStr(double t, char *dest=NULL);

SIM_API char *simtimeToStrShort(double t, char *buf=NULL);
#endif //USE_DOUBLE_SIMTIME


inline int opp_strlen(const char *);

inline char *opp_strdup(const char *);

inline char *opp_strcpy(char *,const char *);

inline int opp_strcmp(const char *, const char *);

SIM_API char *opp_strprettytrunc(char *dest, const char *src, unsigned maxlen);



SIM_API void opp_error(OppErrorCode errcode,...);

SIM_API void opp_error(const char *msg,...);

SIM_API void opp_warning(OppErrorCode errcode,...);

SIM_API void opp_warning(const char *msg,...);

SIM_API void opp_terminate(OppErrorCode errcode,...);

SIM_API void opp_terminate(const char *msg,...);

// INTERNAL: returns the name of a C++ type, correcting the quirks of various compilers.
SIM_API const char *opp_typename(const std::type_info& t);


#define Enter_Method cMethodCallContextSwitcher __ctx(this); __ctx.methodCall

#define Enter_Method_Silent cMethodCallContextSwitcher __ctx(this); __ctx.methodCallSilent

class SIM_API cContextSwitcher
{
  protected:
    cComponent *callerContext;
  public:
    cContextSwitcher(const cComponent *newContext);

    ~cContextSwitcher();
};

class SIM_API cMethodCallContextSwitcher : public cContextSwitcher
{
  public:
    cMethodCallContextSwitcher(const cComponent *newContext);

    ~cMethodCallContextSwitcher();

    void methodCall(const char *methodFmt,...);
    void methodCallSilent(const char *methodFm,...);
    void methodCallSilent();
};

class SIM_API cContextTypeSwitcher
{
  private:
    int savedcontexttype;

  public:
    cContextTypeSwitcher(int contexttype);

    ~cContextTypeSwitcher();
};

//==========================================================================
//=== Implementation of utility functions:

#ifndef _STRINGUTIL_H_   // avoid clash with similar defs in common/stringutil.h

inline char *opp_strcpy(char *s1,const char *s2)
{
    return strcpy(s1, s2 ? s2 : "");
}

inline int opp_strlen(const char *s)
{
    return s ? strlen(s) : 0;
}

inline char *opp_strdup(const char *s)
{
    if (!s || !s[0]) return NULL;
    char *p = new char[strlen(s)+1];
    strcpy(p,s);
    return p;
}

inline char *opp_strdup(const char *s, int len)
{
    if (!s || !s[0]) return NULL;
    char *p = new char[len+1];
    strncpy(p,s,len);
    p[len] = 0;
    return p;
}

inline int opp_strcmp(const char *s1, const char *s2)
{
    if (s1)
        return s2 ? strcmp(s1,s2) : (*s1 ? 1 : 0);
    else
        return (s2 && *s2) ? -1 : 0;
}

#endif //_STRINGUTIL_H_

// internally used: appends [num] to the given string
inline void opp_appendindex(char *s, unsigned int i)
{
   while (*s) s++;
   *s++ = '[';
   if (i<10)
       {*s++ = '0'+i; *s++=']'; *s=0; return;}
   if (i<100)
       {*s++ = '0'+i/10; *s++='0'+i%10; *s++=']'; *s=0; return;}
   sprintf(s,"%d]",i);
}

inline long double_to_long(double d)
{
    // gcc feature: if double d=0xc0000000, (long)d yields 0x80000000 !
    // This only happens with long: unsigned long is OK.
    // This causes trouble if we in fact want to cast this long to unsigned long, see NED_expr_2.test.
    // Workaround follows. Note: even the ul variable is needed: when inlining it, gcc will do the wrong cast!
    long l = (long)d;
    unsigned long ul = (unsigned long)d;
    return d<0 ? l : ul;
}

// internal
inline std::string double_to_str(double t)
{
#if __cplusplus >= 201103L
   return std::to_string(t);
#else
   char buf[32];
   return gcvt(t,16,buf);
#endif
}


NAMESPACE_END


#endif