~vbursian/research-assistant/intervers

////////////////////////////////////////////////////////////////////////////////
/*! @file String.cpp   Class sString and related.
- Part of RANet - Research Assistant Net Library.
- Copyright(C) 1994-2017, Viktor E. Bursian, St.Petersburg, Russia.
                          VBursian@gmail.com
*///////////////////////////////////////////////////////////////////////////////
#include "Strings.h"
#include "Excepts.h"
#include "Symbols.h"
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <sstream>
namespace RA {
//------------------------------------------------------------------------------

literal  sString::EmptyLiteral("");
literal  sString::DefaultDelimiters(",;()[]=<>");
const sString   sString::PlusInfinity = sString("+")+sString(Symbol::Infinity);
const sString   sString::MinusInfinity = sString("-")+sString(Symbol::Infinity);

//------------------------------------------------------------------------------

sString  sString::FromReal (real                number
                           ,unsigned short int  digits_after_dot)
{
  //!@todo{UI++} Повсеместно подменять + и - на Symbol::Plus и Symbol::Minus, но
  //!            это надо делать и при вводе тоже (в обратную сторону).
  //!            Тогда, однако, нужна будет FromDouble (без подмены) для sBursiPan.
  if( number == -real_inf ){
    return MinusInfinity;
  }else if( number == real_inf ){
    return PlusInfinity;
  }else if( number == number ){
    std::ostringstream          S;
    S.setf(std::ios::fixed,std::ios::floatfield);   // floatfield set to fixed
    S.precision(digits_after_dot);
    S << ((long double)number);
    return sString(S.str().c_str());
  }else{
    return sString(Symbol::NaN);
  }
}


sString  sString::FromInteger (integer  number)
{
  std::ostringstream          S;
  S << number;
  return sString(S.str().c_str());
}


rsString  sString::operator >> (integer &  number)
{
  //!@bug из "sFolderNode" вводит 0 и опустошает строку
  //!     (после починки убрать патч из Storable.cpp)

  std::istringstream          S(std::string(literal(*this)));
  S >> number;
  int                         P = S.tellg();
  operator =(Tail(P));
  return *this;
}


rsString  sString::operator >> (real &  R)
{
  int                         P;
  if( Pos(PlusInfinity) == 0 ){
    R = real_inf;
    P = PlusInfinity.Length();
  }else if( Pos(MinusInfinity) == 0 ){
    R = - real_inf;
    P = MinusInfinity.Length();
  }else if( Pos(Symbol::NaN) == 0 ){
    R = real_nan;
    P = sString(Symbol::NaN).Length();
  }else{
    std::istringstream          S(std::string(literal(*this)));
    S.setf(std::ios::fixed,std::ios::floatfield);   // floatfield set to fixed
    long double       D(R);
    S >> D;
    R = D;
    P = S.tellg();
  }
  operator =(Tail(P));
  return *this;
}

//------------------------------------------------------------------------------

sString::~sString ()
{
  if( Body ){
    delete [] Body;  Body=NULL;
  }
}


sString::sString ()
    :Body(NULL)
    ,CurrentLength(0)
    //,CurrentSpace(0)
{
}


sString::sString (rcsString  source_string)
    :Body(NULL)
    ,CurrentLength(0)
    //,CurrentSpace(0)
{
  int                         length;
  if( ! source_string.Empty() ){
    length= source_string.Length();
    Body= new char [length+1];
    (void)memcpy((pointer)Body ,(pointer)source_string.Body ,length+1);
    CurrentLength= length;
    //CurrentSpace= length+1;
  }
}


sString::sString (literal Source)
    :Body(NULL)
    ,CurrentLength(0)
    //,CurrentSpace(0)
{
  int                         length;
  if( Source && *Source ){
    length= strlen(Source);
    Body= new char [length+1];
    (void)memcpy((pointer)Body ,(pointer)Source ,length+1);
    CurrentLength= length;
    //CurrentSpace= length+1;
  }
}


sString::sString (char C)
    :Body(NULL)
    ,CurrentLength(0)
    //,CurrentSpace(0)
{
  Body= new char [2];
  Body[0]=C;
  Body[1]='\0';
  CurrentLength=1;
  //CurrentSpace= 2;
}


bool  sString::Empty () const
{
  return Body ? (CurrentLength == 0) : true ;
}


size_t  sString::Length () const
{
  return Body ? CurrentLength : 0 ;
}


//char  sString::operator [] (size_t I) const
char  sString::operator [] (int  I) const
{
  if( Empty() ){
    throw xProgramError("sString::operator[] is called for empty string"
                       ,__FILE__,__LINE__);
  }
  if( I < 0 ){
    throw xProgramError("sString::operator[]: negative index"
                       ,__FILE__,__LINE__);
  }else if( (unsigned int)I >= CurrentLength ){
    throw xProgramError("sString::operator[]: index goes out of range"
                       ,__FILE__,__LINE__);
  }
  return Body[I];
}


//sString::operator literal () const
//{
//  return Body ? Body : EmptyLiteral ;
//}


sString::operator ptr_to_const_char () const
{
  return Body ? Body : EmptyLiteral ;
}


sString  sString::Substr (size_t from ,size_t length) const
{
  sString                     Result;
  if( Empty() ){
    return Result;
  }
  if( from >= CurrentLength ){
    return Result;
  }
  if( from+length > Length() ){
    length= Length()- from;
  }
  if( length > 0 ){
    Result.Body= new char [length+1];
    (void)memcpy(Result.Body,(Body+from),length);
    Result.Body[length]='\0';
    Result.CurrentLength= length;
    //Result.CurrentSpace= CurrentLength+1;
  }
  return Result;
}


sString  sString::Tail (size_t from) const
{
  if( Empty() ){
    return sString();
  }
  if( from >= CurrentLength ){
    return sString();
  }
  return Substr(from,Length()- from);
}


size_t  sString::Pos (rcsString S) const
{
  if( Empty() ){
    return CurrentLength;
  }else if( S.Empty() ){
    return CurrentLength;
  }else{
    char *                      P;
    P=strstr(Body,S.Body);  //! @todo{sString} won't go through null-chars
    return ( P ? P-Body : CurrentLength );
  }
}


size_t  sString::Pos (literal S) const
{
  if( Empty() ){
    return CurrentLength;
  }else if( !S ){
    return CurrentLength;
  }else if( !(*S) ){
    return CurrentLength;
  }else{
    char *                      P;
    P=strstr(Body,S);  //! @todo{sString} won't go through null-chars
    return ( P ? P-Body : CurrentLength );
  }
}


rsString  sString::operator = (rcsString S)
{
  int                         length =0;
  int                         space =0;
  char *                      NewBody = NULL;

  if( !S.Empty() ){
    length= S.Length();
    space=length+1;
    NewBody= new char [space];
    (void)memcpy(NewBody,S.Body,space);
  }
  if( Body )
    delete [] Body;
  Body=NewBody;
  CurrentLength=length;
  //CurrentSpace=space;
  return *this;
}


sString  sString::operator + (rcsString S) const
{
  return operator+(literal(S));
}


sString  sString::operator + (literal S) const
{
  sString                     Result;
  int                         LoS =0;
  if( S ){
    LoS=strlen(S);
  }
  if( Length()+LoS > 0 ){
    Result.Body= new char [Length() + LoS + 1];
    if( !Empty() ){
      (void)memcpy(Result.Body,Body,Length()+1);
    }
    if( S ){
      (void)memcpy(Result.Body+Length() ,(pointer)S ,LoS+1);
    }
    Result.CurrentLength= Length()+LoS;
    //Result.CurrentSpace= Result.CurrentLength+1;
  }
  return Result;
}


rsString  sString::operator += (rcsString Tail)
{
  return operator+=(literal(Tail));//! @todo{sString} bomb! что за нах!
}


rsString  sString::operator += (literal Tail)
{
  if( Tail && *Tail ){
    int                         length = strlen(Tail);
    char *                      NewBody = NULL;

    NewBody= new char [Length() + length +1];
    if( !Empty() )
      (void)memcpy(NewBody,Body,Length());
    (void)memcpy(NewBody+Length(),(pointer)Tail,length+1);
    if( Body )
      delete [] Body;
    Body=NewBody;
    CurrentLength+=length;
    //CurrentSpace=CurrentLength+1;
  }
  return *this ;
}


rsString  sString::operator += (const char C)
{
  char *                      NewBody = NULL;
  NewBody= new char [Length() + 2];
  if( !Empty() )
    (void)memcpy(NewBody,Body,Length());
  NewBody[Length()]=C;
  if( Body )
    delete [] Body;
  Body=NewBody;
  CurrentLength+=1;
  Body[Length()]='\0';
  //CurrentSpace=CurrentLength+1;
  return *this ;
}


//rsString  sString::operator << (const int I)
//{
//  char                        Buffer [30];
//  sprintf(Buffer,"%i",I);
//  (*this)+=Buffer;
//  return *this;
//}


//rsString  sString::operator << (const unsigned int I)
//{
//  char                        Buffer [30];
//  sprintf(Buffer,"%u",I);
//  (*this)+=Buffer;
//  return *this;
//}


//rsString  sString::operator << (const long int I)
//{
//  char                        Buffer [30];
//  sprintf(Buffer,"%li",I);
//  (*this)+=Buffer;
//  return *this;
//}


//rsString  sString::operator << (const unsigned long int I)
//{
//  char                        Buffer [30];
//  sprintf(Buffer,"%lu",I);
//  (*this)+=Buffer;
//  return *this;
//}


rsString  sString::operator << (real  R)
{
  char                        Buffer [90];
  /*!< @todo{sString} for X11 it was: ...,"%Lg",(long double)R */
  sprintf(Buffer,"%lg",(double)R);
  (*this)+=Buffer;
  return *this;
}


//rsString  sString::operator << (const double D)
//{
//  char                        Buffer [90];
//  sprintf(Buffer,"%lg",D);
//  (*this)+=Buffer;
//  return *this;
//}


bool  sString::operator == (rcsString S)  const
{
  if( Empty() && S.Empty() ){
    return true;
  }else if( !Empty() && !S.Empty() ){
    if( CurrentLength == S.Length() ){
      return memcmp(Body,S.Body,CurrentLength)==0;
    }else{
      return false;
    }
  }else{
    return false;
  }
}


bool  sString::operator == (literal L) const
{
  if( Empty() ){
    return !(L && *L);
  }else{
    if( CurrentLength != strlen(L) ){
      return false;
    }else{
      return memcmp(Body,L,CurrentLength)==0;
    }
  }
}


bool  sString::operator < (rcsString S) const
{
  if( Empty() ){
    return !S.Empty();
  }else if( S.Empty() ){
    return false;
  }else{
      unsigned int    lmin = std::min(CurrentLength,S.Length());
      int             result = memcmp(Body,S.Body,lmin);
    if( result ){
      return bool(result < 0);
    }else{
      return CurrentLength < S.Length();
    }
  }
}


sString  sString::UpperCase () const
{
  sString                     Result (*this);
  if( !Result.Empty() ){
    for (size_t i=0; i<CurrentLength; ++i)
      Result.Body[i]=toupper(Body[i]);
    //! @todo{sString} see locale::toupper
    //locale loc;
    //for (size_t i=0; i<CurrentLength; ++i)
    //  Result.Body[i]=toupper(Body[i],loc);
  }
  return Result;
}


sString  sString::Trim () const
{
  /*! @todo{sString} Trim*/
  sString                     Result (*this);
  if( !Result.Empty() ){
    throw xNotImplemented(__PRETTY_FUNCTION__);
  }
  return Result;
}


sString  sString::TrimSyntactic (literal /*Delimiters*/) const
{
  sString                     Result (*this);
  if( !Result.Empty() ){
    throw xNotImplemented(__PRETTY_FUNCTION__);
  }
  return Result;
}


sString  sString::Translate (char O ,char N) const
{
  sString                     Result (*this);
  for( size_t i=0 ; i < CurrentLength ; ++i )
    if( Body[i] == O )
      Result.Body[i]=N;
  return Result;
}


void  sString::EatLeadingSpaces ()
{
  if( ! Empty() ){
    //! @todo{sString} implement
  }
}


int  sString::WipeOut (literal  substring
                      ,bool     only_first)
{
  int                         occurences = 0;
  size_t                      L = strlen(substring);
  if( L ){
    size_t                      P;
    while( (P = Pos(substring)) < CurrentLength ){
      operator =( Substr(0,P) + Tail(P+L) );
      occurences++;
      if( only_first )
        break;
    }
  }
  return occurences;
}


int  sString::Replace (literal  substring
                      ,literal  replacement
                      ,bool     only_first)
{
  int                         occurences = 0;
  size_t                      L = strlen(substring);
  if( L ){
    size_t                      P;
    while( (P = Pos(substring)) < CurrentLength ){
      operator =( Substr(0,P) + replacement + Tail(P+L) );
      occurences++;
      if( only_first )
        break;
    }
  }
  return occurences;
}


//void  sString::InputTextLine (std::istream &  S)
//{
//  const int                   BufferSize = 1000;
//  char                        Buffer [BufferSize];
//  int                         L = 0;
//  tStreamPos                  S_InitialPosition = S.GetPosition();
//  tStreamPos                  S_Size = S.GetSize();
//  if( Body ){
//    delete [] Body;  Body=NULL;
//  }
//  CurrentLength=0;
//  //CurrentSpace=0;
//  while( S_InitialPosition+L < S_Size ){
//    S.ReadInto(Buffer+L,1);
//    if( Buffer[L] == '\r' ){
//    }else if( Buffer[L] == '\n' ){
//      Buffer[L]='\000';
//      operator+=(Buffer);
//      return;
//    }else{
//      L++;
//      if( L == BufferSize ){
//        throw xNotImplemented("Input of truly long lines");
//      }
//    }
//  }
//  if( L > 0 ){
//    Buffer[L]='\000';
//    operator+=(Buffer);
//  }
//}


void  sString::SetValue (literal Source)
{
  if( Body ){
    delete [] Body;  Body=NULL;
  }
  CurrentLength=0;
  //CurrentSpace=0;
  if( Source && *Source ){
    int                       L = strlen(Source);
    Body= new char [L+1];
    (void)memcpy(Body,(pointer)Source,L+1);
    CurrentLength=L;
    //CurrentSpace=L+1;
  }
}


void  sString::Read (std::istream &  a_stream)
{
  uint32_t                    L;
  if( Body ){
    delete [] Body;  Body=NULL;
  }
  CurrentLength=0;
  //CurrentSpace=0;
  a_stream.read( (char *)(&L), sizeof(L) );
  if( L ){
    Body= new char [L+1];
    a_stream.read(Body,L);
    *(byte*)(Body+L)=0;
    CurrentLength=L;
    //CurrentSpace=L+1;
  }
}


void  sString::Write (std::ostream &  a_stream) const
{
  uint32_t               L;
  if( Length() > std::numeric_limits<uint32_t>::max() ){
    L = std::numeric_limits<uint32_t>::max();
  }else{
    L = Length();
  }
  a_stream.write( (char *)(&L), sizeof(L) );
  if( L )
    a_stream.write(Body,L);
}

//------------------------------------------------------------------------------
} //namespace RA