opp_string.h

//==========================================================================
//   OPP_STRING.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_OPP_STRING_H
#define __OMNETPP_OPP_STRING_H
 
#include <cstring>
#include <vector>
#include <map>
#include <ostream>
#include "simkerneldefs.h"
 
namespace omnetpp {
 
class SIM_API opp_string
{
  private:
    char *buf;
 
    static char *opp_strdup(const char *s) {
        if (!s || !s[0]) return nullptr;
        char *p = new char[strlen(s)+1];
        strcpy(p,s);
        return p;
    }
 
    static 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;
    }
 
  public:
    opp_string()  {buf = nullptr;}
 
    opp_string(const char *s)  {buf = opp_strdup(s);}
 
    opp_string(const char *s, int n)  {buf = new char[n+1]; strncpy(buf, s?s:"", n); buf[n] = '\0';}
 
    opp_string(const std::string& s)  {buf = opp_strdup(s.c_str());}
 
    opp_string(const opp_string& s)  {buf = opp_strdup(s.buf);}
 
    opp_string(opp_string&& s)  {buf = s.buf; s.buf = nullptr;}
 
    ~opp_string()  {delete [] buf;}
 
    const char *c_str() const  {return buf ? buf : "";}
 
    std::string str() const  {return buf ? buf : "";}
 
    bool empty() const  {return !buf || !buf[0];}
 
    char *buffer()  {return buf;}
 
    int size() const {return buf ? strlen(buf) : 0;}
 
    char *reserve(unsigned size)  {delete[] buf;buf=new char[size];return buf;}
 
    const char *operator=(const char *s)  {delete[] buf;buf=opp_strdup(s);return buf;}
 
    opp_string& operator=(const opp_string& s)  {operator=(s.buf); return *this;}
 
    opp_string& operator=(const std::string& s)  {operator=(s.c_str()); return *this;}
 
    bool operator<(const opp_string& s) const  {return opp_strcmp(buf,s.buf) < 0;}
 
    bool operator==(const opp_string& s) const  {return opp_strcmp(buf,s.buf) == 0;}
 
    bool operator!=(const opp_string& s) const  {return opp_strcmp(buf,s.buf) != 0;}
 
    opp_string& operator+=(const char *s) {return operator=(std::string(buf).append(s));}
 
    opp_string& operator+=(const opp_string& s) {operator+=(s.buf); return *this;}
 
    opp_string& operator+=(const std::string& s) {operator+=(s.c_str()); return *this;}
 
    opp_string operator+(const char *s) {return opp_string((std::string(buf)+s).c_str());}
 
    opp_string operator+(const opp_string& s) {return operator+(s.c_str());}
 
    opp_string operator+(const std::string& s) {return operator+(s.c_str());}
 
};
 
inline std::ostream& operator<<(std::ostream& out, const opp_string& s)
{
    out << s.c_str(); return out;
}
 
 
class SIM_API opp_string_vector : public std::vector<opp_string>
{
  public:
    opp_string_vector() {}
    opp_string_vector(const opp_string_vector& other)  = default;
};
 
 
class SIM_API opp_string_map : public std::map<opp_string,opp_string>
{
  public:
    opp_string_map() {}
    opp_string_map(const opp_string_map& other)  = default;
};
 
}  // namespace omnetpp
 
 
#endif