mystring.h

Go to the documentation of this file.

/* Copyright (C) 2001-2008 Stefan Buehler <sbuehler@ltu.se>
 
   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by the
   Free Software Foundation; either version 2, or (at your option) any
   later version.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
   USA. */
 
#ifndef mystring_h
#define mystring_h
 
#include <cassert>
#include <climits>
#include <string>
#include "matpack.h"
#include "array.h"
 
// String stream library. This is included with the ARTS source code
// for now, because it is missing in gcc <= 2.95.2
#ifdef HAVE_SSTREAM
#include <sstream>
#else
#include "sstream.h"
#endif
 
template<class charT>
class my_basic_string : public basic_string<charT>
{
public:
  // Constructors:
  my_basic_string();
  explicit my_basic_string(Index n, char c=' ');
  my_basic_string(const basic_string<charT>& A,
                  Index pos=0,
                  Index numpos=my_basic_string<charT>::npos);
  my_basic_string(const char A[]);
 
  // Assignment operators:
  my_basic_string& operator=(const my_basic_string<charT>& A);
  //  my_basic_string& operator=(const char A[]);
 
  // Insert string before all occurrences of the substring.
  void insert_substr(const my_basic_string<charT>& searchstr,
                     const my_basic_string<charT>& insstr);
 
  // Split string
  void split (Array< my_basic_string<charT> > &aos,
              const my_basic_string<charT> &delim) const;
  
  // Number of elements:
  Index nelem() const;
 
  // Find functions:
//   Index find(char c);
//   Index find(const my_basic_string<charT>&  c);
 
  // Index operators:
  char operator[](Index n) const;
  char& operator[](Index n);
 
  static const Index npos = static_cast<Index>(basic_string<charT>::npos);
 
  typedef Index size_type;
};
 
 
// Member functions for my_basic_string:
 
 
// Constructors:
 
template<class charT>
inline my_basic_string<charT>::my_basic_string() : basic_string<charT>()  
{ /* Nothing to do here. */ }
 
template<class charT>
inline my_basic_string<charT>::my_basic_string(Index n, char c) :
  basic_string<charT>(n,c) 
{ /* Nothing to do here. */ }
 
// template<class charT>
// inline my_basic_string<charT>::my_basic_string(const my_basic_string& A) : basic_string<charT>(A) 
// { /* Nothing to do here. */ };
 
template<class charT>
inline my_basic_string<charT>::my_basic_string(const basic_string<charT>& A,
                                               Index pos,
                                               Index numpos)
{ 
  // Range checks:
  assert(0<=pos);               // Start index must be 0 or greater 0.
 
//   cout << "A = " << A << "\n";
//   cout << "pos = " << pos << "\n";
//   cout << "size = " << A.size() << "\n";
 
  assert(static_cast<typename basic_string<charT>::size_type>(pos)<A.size());      
  // At most the last element of the original string.
 
  assert( numpos==my_basic_string<charT>::npos ||
          ( (numpos >= 0) &&
            (static_cast<typename basic_string<charT>::size_type>(numpos)<=(A.size()-pos))
            )
          );  // Number of characters to copy must be at the most the
              // number left. -1 means all remaining characters. 
 
  // The assertions look complicated, because we have to cast pos and
  // npos to the unsigned size type of basic string to avoid warning
  // messages from the compiler. Both casts are save, because previous
  // assertions check that pos and npos are positive. (The allowed
  // case npos -1 (=my_basic_string<charT>::npos) is also handled
  // correctly.)
 
  basic_string<charT>::operator=(basic_string<charT>(A,pos,numpos));
 
}
 
template<class charT>
inline my_basic_string<charT>::my_basic_string(const char A[]) : basic_string<charT>(A) 
{ /* Nothing to do here. */ }
 
 
template<class charT>
inline my_basic_string<charT>& my_basic_string<charT>::operator=(const my_basic_string<charT>& A)
{
  basic_string<charT>::operator=(A);
  return *this;
}
 
template<class charT>
inline void my_basic_string<charT>::insert_substr(const my_basic_string<charT>& searchstr,
                                                  const my_basic_string<charT>& insstr)
{ 
  size_t searchstr_size = searchstr.size();
  size_t insstr_size = insstr.size();
  size_t start_pos = 0;
 
  while (start_pos != string::npos)
    {
      start_pos = this->find (searchstr, start_pos);
      if (start_pos && start_pos != string::npos)
        {
          this->insert (start_pos, insstr);
          start_pos += searchstr_size + insstr_size;
        }
    }
}
 
template<class charT>
inline void my_basic_string<charT>::split (Array< my_basic_string<charT> > &aos,
                                           const my_basic_string<charT> &delim) const
{
  size_t pos, oldpos;
  pos = oldpos = 0;
  aos.resize(0);
  
  while (oldpos < (size_t)this->nelem() &&
         (pos = this->find(delim, oldpos)) != (size_t)my_basic_string<charT>::npos)
  {
    if (pos) aos.push_back(this->substr(oldpos, pos-oldpos));
    oldpos = pos+delim.nelem();
  }
  
  if (oldpos < (size_t)this->nelem()) aos.push_back(this->substr(oldpos));
}
 
template<class charT>
inline Index my_basic_string<charT>::nelem() const
{ 
  size_t s = this->size();
  assert(s<LONG_MAX);
  return static_cast<long>(s);
}
 
template<class charT>
inline char my_basic_string<charT>::operator[](Index n) const
{
  assert(0<=n);
  assert(n<nelem());
  return basic_string<charT>::operator[](n);
}
 
template<class charT>
inline char& my_basic_string<charT>::operator[](Index n)
{
  assert(0<=n);
  assert(n<nelem());
  return basic_string<charT>::operator[](n);
}
 
// Non-member functions:
 
// /** Output operator. */
// inline ostream& operator<<(ostream& os, const my_basic_string& v)
// {
//   my_basic_string<base>::const_iterator         i = v.begin();
//   const my_basic_string<base>::const_iterator end = v.end();
 
//   if ( i!=end )
//     {
//       os << *i;
//       ++i;
//     }
 
//   for ( ; i!=end; ++i )
//     {
//       os << "\n" << setw(3) << *i;
//     }
 
 
//   // Just use the operator of string.
//   operator<<(os,v);
//   return os;
// }
 
 
typedef my_basic_string<char> String;
 
// Declare the existance of class Array:
/*template<class base>
class Array;*/
 
typedef Array<String> ArrayOfString;
 
//
// We don't use this function, we use string.find() instead.
//
// //! Find first occurance.
// /*!
//   This returns the index of the first occurance of w in 
//   string x.  
// 
//   A return value of -1 indicates that no matching element was found.
// 
//   \return   The index of the thing we looked for.
//   \param  x The string to search.
//   \param w  The character to look for.
// 
//   \author Stefan Buehler
//   \date   2002-12-06
// */
// template <class base>
// Index find_first( const my_basic_string<base>& x,
//                   const base& w )
// {
//   for ( Index i=0; i<x.nelem(); ++i )
//     if ( w == x[i] )
//       return i;
// 
//   return -1;
// }
 
 
#endif  // mystring_h