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 <vector>
#include <map>
#include <ostream>
#include "simkerneldefs.h"
#include "simutil.h"

namespace omnetpp {

class SIM_API opp_string
{
  private:
    char *buf;

  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()  {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) : std::vector<opp_string>(other) {}
};


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) : std::map<opp_string,opp_string>(other) {}
};

}  // namespace omnetpp


#endif