Update README.md

[deliverable/titan.core.git] / xsdconvert / Mstring.cc

///////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2000-2014 Ericsson Telecom AB
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// which accompanies this distribution, and is available at
// http://www.eclipse.org/legal/epl-v10.html
///////////////////////////////////////////////////////////////////////////////
#include "../common/dbgnew.hh"
// dbgnew must come before Mstring.hh which includes common/memory.hh
#include "Mstring.hh"

#include <string.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h> // only for abort

const Mstring empty_string;

Mstring::Mstring()
: text(memptystr())
{}

Mstring::Mstring(const Mstring & other)
: text(mcopystr(other.text))
{}

Mstring::Mstring(const char * s)
: text(mcopystr(s))
{}

Mstring::Mstring(size_t len, const char *s)
: text((expstring_t)Malloc(len+1))
{
  memcpy(text, s, len);
  text[len] = 0;
}

Mstring::Mstring(char c)
: text(memptystr())
{
  text = mputc(text, c);
}

Mstring::~Mstring()
{
  Free(text);
}

bool Mstring::empty() const
{
  return mstrlen(text) == 0;
}

size_t Mstring::size() const
{
  return mstrlen(text);
}

void Mstring::clear()
{
  Free(text);
  text = memptystr();
}

const char * Mstring::c_str() const
{
  return text;
}

void Mstring::eraseChar(size_t pos)
{
  Mstring temp;
  for (size_t i = 0; i != size(); ++i)
    if (i != pos) temp += text[i];
  Free(text);
  text = mcopystr(temp.text);
}

void Mstring::insertChar(size_t pos, char c)
{
  Mstring temp;
  for (size_t i = 0; i != size(); ++i)
    if (i == pos) {
      temp += c;
      temp += text[i];
    }
    else temp += text[i];
  Free(text);
  text = mcopystr(temp.text);
}

bool Mstring::isFound(const Mstring & s)
{
  return strstr(text, s.text);
}

bool Mstring::isFound(const char * s)
{
  return strstr(text, s);
}

bool Mstring::isFound(char c)
{
  return strchr(text, c);
}

void Mstring::setCapitalized()
{
  text[0] = toupper(text[0]);
}

void Mstring::setUncapitalized()
{
  text[0] = tolower(text[0]);
}

Mstring Mstring::getPrefix(const char delimiter) const
{
  Mstring result;
  char * pos = strchr(text, delimiter);
  if (pos != NULL) for (int i = 0; text + i != pos; ++i) result += text[i];
  return result;
}

Mstring Mstring::getValueWithoutPrefix(const char delimiter) const
{
  char * pos = strrchr(text, delimiter);
  if (pos != NULL) return Mstring(pos+1);
  else return *this;
}

void Mstring::removeWSfromBegin()
{
  size_t i = 0;
  size_t s = mstrlen(text);
  for ( ; i < s; ++i)
    if (!isspace((const unsigned char)text[i])) break;
  memmove(text, text+i, s-i);
  text = mtruncstr(text, s-i);
}

void Mstring::removeWSfromEnd()
{
  int i = mstrlen(text);
  for ( ; i > 0; --i)
    if (!isspace((const unsigned char)text[i-1])) break;
  text = mtruncstr(text, i);
}

char & Mstring::operator [](size_t pos)
{
  size_t s = mstrlen(text);
  if (pos < s)
    return text[pos];
  else {
    fputs("String index overflow\n", stderr);
    abort();
  }
}

const char & Mstring::operator [](size_t pos) const
{
  size_t s = mstrlen(text);
  if (pos < s)
    return text[pos];
  else {
    fputs("String index overflow\n", stderr);
    abort();
  }
}

Mstring & Mstring::operator =(const Mstring & other)
{
  if (&other != this) {
    Free(text);
    text = mcopystr(other.text);
  }
  return *this;
}

Mstring & Mstring::operator =(const char * s)
{
  Free(text);
  text = mcopystr(s);
  return *this;
}

Mstring & Mstring::operator =(char c)
{
  Free(text);
  text = memptystr();
  text = mputc(text, c);
  return *this;
}

Mstring & Mstring::operator +=(const Mstring & other)
{
  text = mputstr(text, other.text);
  return *this;
}

Mstring & Mstring::operator +=(const char * s)
{
  text = mputstr(text, s);
  return *this;
}

Mstring & Mstring::operator +=(char c)
{
  text = mputc(text, c);
  return *this;
}

const Mstring operator +(const Mstring & lhs, const Mstring & rhs)
{
  return Mstring(lhs) += rhs;
}

const Mstring operator +(const char * lhs, const Mstring & rhs)
{
  return Mstring(lhs) += rhs;
}

const Mstring operator +(char lhs, const Mstring & rhs)
{
  return Mstring(lhs) += rhs;
}

const Mstring operator +(const Mstring & lhs, const char * rhs)
{
  return Mstring(lhs) += rhs;
}

const Mstring operator +(const Mstring & lhs, char rhs)
{
  return Mstring(lhs) += rhs;
}

bool operator ==(const Mstring & lhs, const Mstring & rhs)
{
  if (strcmp(lhs.text, rhs.text) == 0) // they are equal
    return true;
  else
    return false;
}

bool operator ==(const char * lhs, const Mstring & rhs)
{
  if (strcmp(lhs, rhs.text) == 0) // they are equal
    return true;
  else
    return false;
}

bool operator ==(const Mstring & lhs, const char * rhs)
{
  if (strcmp(lhs.text, rhs) == 0) // they are equal
    return true;
  else
    return false;
}

bool operator !=(const Mstring & lhs, const Mstring & rhs)
{
  if (strcmp(lhs.text, rhs.text) != 0) // they are NOT equal
    return true;
  else
    return false;
}

bool operator !=(const char * lhs, const Mstring & rhs)
{
  if (strcmp(lhs, rhs.text) != 0) // they are NOT equal
    return true;
  else
    return false;
}

bool operator !=(const Mstring & lhs, const char * rhs)
{
  if (strcmp(lhs.text, rhs) != 0) // they are NOT equal
    return true;
  else
    return false;
}

bool operator <(const Mstring & lhs, const Mstring & rhs)
{
  if (strcmp(lhs.text, rhs.text) < 0)
    return true;
  else
    return false;
}

bool operator <(const char * lhs, const Mstring & rhs)
{
  if (strcmp(lhs, rhs.text) < 0)
    return true;
  else
    return false;
}

bool operator <(const Mstring & lhs, const char * rhs)
{
  if (strcmp(lhs.text, rhs) < 0)
    return true;
  else
    return false;
}

bool operator >(const Mstring & lhs, const Mstring & rhs)
{
  if (strcmp(lhs.text, rhs.text) > 0)
    return true;
  else
    return false;
}

bool operator >(const char * lhs, const Mstring & rhs)
{
  if (strcmp(lhs, rhs.text) > 0)
    return true;
  else
    return false;
}

bool operator >(const Mstring & lhs, const char * rhs)
{
  if (strcmp(lhs.text, rhs) > 0)
    return true;
  else
    return false;
}

bool operator <=(const Mstring & lhs, const Mstring & rhs)
{
  if (strcmp(lhs.text, rhs.text) <= 0)
    return true;
  else
    return false;
}

bool operator <=(const char * lhs, const Mstring & rhs)
{
  if (strcmp(lhs, rhs.text) <= 0)
    return true;
  else
    return false;
}

bool operator <=(const Mstring & lhs, const char * rhs)
{
  if (strcmp(lhs.text, rhs) <= 0)
    return true;
  else
    return false;
}

bool operator >=(const Mstring & lhs, const Mstring & rhs)
{
  if (strcmp(lhs.text, rhs.text) >= 0)
    return true;
  else
    return false;
}

bool operator >=(const char * lhs, const Mstring & rhs)
{
  if (strcmp(lhs, rhs.text) >= 0)
    return true;
  else
    return false;
}

bool operator >=(const Mstring & lhs, const char * rhs)
{
  if (strcmp(lhs.text, rhs) >= 0)
    return true;
  else
    return false;
}