/Users/mourrain/Devel/mmx/basix/include/basix/string.hpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : string.hpp
* DESCRIPTION: Strings with possible zero-characters
* COPYRIGHT  : (C) 2004  Joris van der Hoeven
*******************************************************************************
* This software falls under the GNU general public license and comes WITHOUT
* ANY WARRANTY WHATSOEVER. See the file $TEXMACS_PATH/LICENSE for more details.
* If you don't have this file, write to the Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
******************************************************************************/

#ifndef __STRING_HPP
#define __STRING_HPP
#include <basix/type_props.hpp>

namespace mmx {

/******************************************************************************
* The string class
******************************************************************************/

class string;
class string_rep REP_STRUCT {
private:
  char* a;  // the string
  nat   n;  // length of string
  nat   l;  // allocated number of bytes

public:
  inline string_rep (nat n2): a ((char*) mmx_malloc (n2)), n(n2), l(n2) {}
  inline ~string_rep () { mmx_free ((void*) a, l); }
  void resize (nat n);
  void extend (nat n);

  friend class string;
  friend inline nat N (const string& s);
  friend inline bool busy (const string& s);
  friend inline char* S (string& s);
  friend inline const char* S (const string& s);
  friend inline char read (const string& s, nat i);
  friend string copy (const string& s);
  friend string operator * (const string& s, const string& t);
  friend int as_int (const string& s);
  friend double as_double (const string& s);
  friend inline char* inside (const string& s, nat pos);
};

class string {
INDIRECT_PROTO (string, string_rep)
public:
  inline string (nat n=0): rep (new string_rep (n)) {}
  string (char c);
  string (const char *s);
  string (const char *s, nat n);

  friend inline nat N (const string& s) { return s.rep->n; }
  friend inline bool busy (const string& s) { return s.rep->n != 0; }
  friend inline char* S (string& s) { s.secure (); return s.rep->a; }
  friend inline const char* S (const string& s) { return s.rep->a; }
  friend inline char read (const string& s, nat i) { return s.rep->a[i]; }
  inline char operator [] (nat i) const { return rep->a[i]; }
  inline char& operator [] (nat i) { secure (); return rep->a[i]; }
  string operator () (nat start, nat end) const;
  string& operator << (char c);
  string& operator << (const string& t);
  string& operator >> (char& c);
  bool operator == (const char* s) const;
  bool operator != (const char* s) const;
  bool operator == (const string& s) const;
  bool operator != (const string& s) const;
  friend nat hash (const string& s);
  friend string copy (const string& s);
  friend string operator * (const string& s, const string& t);
  friend string as_string (void* ptr);
  friend string as_string (short int i);
  friend string as_string (short unsigned int i);
  friend string as_string (int i);
  friend string as_string (unsigned int i);
  friend string as_string (long int i);
  friend string as_string (long unsigned int i);
  friend string as_string (long long int i);
  friend string as_string (long long unsigned int i);
  friend string as_string (float x);
  friend string as_string (double x);
  friend string as_string_hexa (int i);
  friend int as_int (const string& s);
  friend double as_double (const string& s);
  friend string unescape (const string& s);
  friend char* inside (const string& s, nat pos);

  friend class string_rep;
};
INDIRECT_IMPL (string, string_rep)

TRUE_TO_EXACT_IDENTITY_SUGAR(,string)
template<> inline string duplicate (const string& s) { return copy (s); }

inline char* inside (const string& s, nat pos) {
  return s.rep->a + pos; }
inline void mem_copy (char* d, char* s, nat n) {
  for (nat i=0; i<n; i++) d[i]= s[i]; }

/******************************************************************************
* Conversion routines
******************************************************************************/

string as_string (int i);
string as_string (unsigned int i);
string as_string (void* ptr);
inline string as_string (short int i) {
  return as_string ((int) i); }
inline string as_string (short unsigned int i) {
  return as_string ((unsigned int) i); }
inline string as_string (signed char i) {
  return as_string ((int) i); }
inline string as_string (unsigned char i) {
  return as_string ((unsigned int) i); }
string as_string (long int i);
string as_string (long unsigned int i);
string as_string (long long int i);
string as_string (long long unsigned int i);
string as_string (float x);
string as_string (double x);
string as_string (long double x);

inline string as_string_hexa (int i) {
  static char buf[16];  
  sprintf (buf, "%x", i);
  return buf; }
int as_int (const string& s);
double as_double (const string& s);

/******************************************************************************
* Further routines for exact numeric input and output
******************************************************************************/

template<typename C> void
numeric_to_string (const C& x, string& s) {
  if (x == 0) s << '0';
  else if (x <= 0) { // NOTE x < 0 would be nicer, but yields warnings
    s << '-';
    numeric_to_string (-x, s);
  }
  else {
    if (x >= 10) numeric_to_string (x/10, s);
    s << (char) (((char) '0') + ((char) ((int) (x%10))));
  }
}

template<typename C> void
string_to_numeric (const string& s, C& val) {
  int i=0, n=N(s);
  val=0;
  if (n==0) return;
  if (s[0]=='-') i++;
  while (i<n) {
    if (s[i]<'0') break;
    if (s[i]>'9') break;
    val *= 10;
    val += (int) (s[i]-'0');
    i++;
  }
  if (s[0]=='-') val=-val;
}

STMPL void numeric_to_string (const float& x, string& s);
STMPL void numeric_to_string (const double& x, string& s);
STMPL void numeric_to_string (const long double& x, string& s);
STMPL void string_to_numeric (const string& s, float& val);
STMPL void string_to_numeric (const string& s, double& val);
STMPL void string_to_numeric (const string& s, long double& val);

template<typename C> string
numeric_as_string (const C& x) {
  string s;
  numeric_to_string<C> (x, s);
  return s;
}

template<typename C> C
string_as_numeric (const string& s) {
  C val;
  string_to_numeric<C> (s, val);
  return val;
}

/******************************************************************************
* Further routines on strings
******************************************************************************/

bool operator <  (const string& s, const string& t);
bool operator <= (const string& s, const string& t);
bool operator >  (const string& s, const string& t);
bool operator >= (const string& s, const string& t);
char* as_charp (const string& s);
void free_charp (char* s);
string escape (const string& s);
string unescape (const string& s);
string quote (const string& s);
string unquote (const string& s);
string locase (const string& s);
string upcase (const string& s);
string locase_first (const string& s);
string upcase_first (const string& s);
bool starts (const string& s, const string& what);
bool ends (const string& s, const string& what);
string replace (const string& s, const string& what, const string& by);
int search_forwards (const string& s, const string& what, const int& pos);
int search_backwards (const string& s, const string& what, const int& pos);
string reverse (const string& s);
vector<string> tokenize (const string& s, const string& sep, bool keep=false);
string recompose (const vector<string>& v, const string& sep, bool last=true);

} // namespace mmx
#endif // __STRING_HPP