mystring.h

/**************************************************************************
 * Copyright (c) 2002-2011 T. M. Murali                                   *
 *                                                                        *
 * This file is part of Biorithm.                                         *
 *                                                                        *
 * Biorithm 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 3 of the License, or      *
 * (at your option) any later version.                                    *
 *                                                                        *
 * Biorithm 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 Biorithm.  If not, see <http://www.gnu.org/licenses/>.      *
 *                                                                        *
 **************************************************************************/

// Purpose: to define a string that has the readline() function like
// LEDA's string (it has read_line().

#ifndef _MYSTRING_H
#define _MYSTRING_H

// for isspace.
#include <ctype.h>
#include <iostream>
#include <string>

#include "constants.h"

// Test for GCC >= 4.3. from http://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html. See definition of GCC_VERSION macro in libutil/constants.h
#if GCC_VERSION >= 40300
// see http://gcc.gnu.org/gcc-4.3/changes.html
#include <tr1/unordered_set>
#else
#include <ext/hash_set>
using namespace __gnu_cxx;
// rename hash* to unordered*, so that I can consistently use unordered* in my code.
// template < class T >
// typedef hash_set< T > unordered_set;
//typedef hash_map unordered_map;
#define unordered_set hash_set;
#define unordered_map hash_map;
#endif

using namespace std;

struct eqstr
{
  bool operator()(const string& s1, const string& s2) const
  {
    return(s1 == s2);
  }
};

struct ltstr
{
  bool operator()(const string& s1, const string& s2) const
  {
    return(s1 < s2);
  }
};

class MyString : public string
{
public:
  MyString()
      : string()
    {}
  MyString(const char *s)
      : string(s)
    {}
  MyString(const string& s)
      : string(s)
    {}
  MyString(const MyString &s)
      : string(s)
    {}
  
  virtual ~MyString()
    {}
  

  MyString& operator=(const MyString& str)
    {
      if (&str != this)
        string::operator=(str);
      return *this;
    }
  MyString& operator=(const string& str)
    {
      if (&str != this)
        string::operator=(str);
      return *this;
    }

  
  void read(istream& s, char delim)
    {
      char buf[1024];
      char* q = buf+1023;
      bool go = true;

      string::operator=(""); // clear string

      while (s && go)
        {
          char* p;
          for(p = buf; p < q && s.get(*p); p++)
            {
              if (*p == delim || (delim == 0) && isspace(*p)) 
                {
                  if (delim != '\n') s.putback(*p);
                  go = false;
                  break;
                }
            } 
          *p = '\0';
          operator+=(buf);
        } 
    }

  void read(char delim = ' ')
    {
      read(cin,delim);
    }

  void read_line(istream& I)
    {
      read(I,'\n');
    }

  void read_line()
    {
      read_line(cin);
    }

  void read_file(istream& I)
    {
      read(I,(char)EOF);
    }

  void read_file()
    {
      read_file(cin);
    }

  // comparison operators
  friend bool operator==(const MyString &x, const MyString &y)
    {
      // don't call operator== because that causes inf. loop!
      return (0 == x.compare(y));
    }
};

// have to specialise template in the same namespace as its definition.
#ifdef __GNUC__
#if __GNUC__ < 3
  namespace Sgi { using ::hash_map; }; // inherit globals
#else
#if __GNUC_MINOR__ == 0
  namespace Sgi = std;               // GCC 3.0
#else
namespace Sgi = ::__gnu_cxx;       // GCC 3.1 and later
#endif
#endif
#else      // ...  there are other compilers, right?
namespace Sgi = std;
#endif

#if (GCC_VERSION < 40300)
// i need to specialise some hash templates.
namespace __gnu_cxx
// namespace Sgi
 {
// hash functions.
template <> struct
hash< string >
{
  // DON'T use string::data()! that function sometimes returns a longer string.
  size_t operator()(const string& s) const { return __stl_hash_string(s.c_str()); }
};

template <> struct
hash< MyString >
{
  size_t operator()(const MyString& s) const { return __stl_hash_string(s.data()); }
};
 }
#endif // GCC_VERSION


#endif // _MYSTRING_H