flower/string.hh

   1 /*
   2
   3   FILE   : string.hh -- implement String inline helpclasses,
   4    and declare stringclass.
   5
   6
   7   Rehacked by HWN 3/nov/95
   8   removed String & 's
   9   introduced Class String_handle
  10  */
  11
  12 #ifndef STRING_HH
  13 #define STRING_HH
  14
  15
  16 #include <string.h>
  17 #include <iostream.h>
  18
  19 //#include "globals.hh"
  20 #include "stringutil.hh"
  21
  22 // whugh
  23 #ifdef CENTRAL_OBJECT
  24 #include "sortable.hh"
  25 #define String__mpp  String : public Sortable
  26 #else
  27 #define String__mpp  String
  28 #endif
  29
  30 /// the smart string class.
  31 class String__mpp
  32 {
  33 protected:
  34     String_handle data; // should derive String from String_handle?
  35
  36 public:
  37
  38 #ifdef CENTRAL_OBJECT // everything derived from Sortable object
  39     virtual int operator ==( const Sortable& test ) const;
  40     virtual int operator &&( const Object& test ) const;
  41     virtual int operator >( const Sortable& test ) const;
  42 #endif
  43
  44     /// init to ""
  45     String() {  }
  46     /** needed because other constructors are provided.*/
  47
  48     /// String s = "abc";
  49     String( const char* source );
  50
  51     /// "ccccc"
  52     String( char c, int n = 1 );
  53
  54     /// String s( 10 );
  55     String( int i );
  56
  57     /// 'true' or 'false'
  58     String(bool );
  59
  60     /// String s( 3.14, 6, '#' );
  61     String ( double f , const char *fmt =0);
  62     String(  int i,  int n,  char c = ' ' );
  63
  64     ///  return a "new"-ed copy of contents
  65     char *copy_array() const; //  return a "new"-ed copy of contents
  66
  67     /// return the data. Don't use for writing the data.
  68     virtual operator const char *() const; // virtual???
  69
  70     String operator =( const String & source ) { data = source.data; return *this; }
  71
  72     /// concatenate s
  73     void operator += (const char *s) { data += s; }
  74     void operator += (String s);
  75
  76     char operator []( int n ) const { return data[n]; }
  77
  78     /// return n leftmost chars
  79     String left( int n ) const;
  80
  81     /// return n rightmost chars
  82     String right( int n ) const;
  83
  84     /// convert this to upcase
  85     String upper();
  86
  87     /// convert this to downcase
  88     String lower(); // & ??
  89
  90     /// return the "esrever" of *this
  91     String reversed() const;
  92
  93
  94     /// return a piece starting at pos (first char = pos 1), length n
  95     String mid(int pos,  int n ) const;
  96
  97     /// cut out a middle piece, return remainder
  98     String nomid(int pos, int n ) const;
  99
 100     /// signed comparison,  analogous to strcmp;
 101     int  compare( const char* s ) const;
 102
 103     /// index of rightmost c
 104     int lastPos( char c) const;
 105     /// index of rightmost element of string
 106     int lastPos( const char* string ) const;
 107
 108     /// index of leftmost c
 109     int pos(char c ) const;
 110     /**
 111     RETURN:
 112     0 if not found, else index + 1
 113     */
 114     int pos(const char* string ) const;
 115     int posAny(const char* string ) const;
 116
 117
 118     /// provide Stream output
 119     void printOn(ostream& os) const;
 120
 121     /// convert to an integer
 122     long value() const;
 123
 124     /// convert to a double
 125     double fvalue() const;
 126
 127     /// the length of the string
 128     int len() const;
 129 };
 130 /**
 131
 132   Intuitive string class. provides
 133
 134   ref counting thru #String_handle#
 135
 136   conversion from bool, int, double, char *, char.
 137
 138   conversion to int, upcase, downcase
 139
 140
 141   printable.
 142
 143   indexing (pos, posAny, lastPos)
 144
 145   cutting (left, right, mid)
 146
 147   concat (+=, +)
 148
 149   signed comparison (<, >, ==, etc)
 150
 151   No operator[] is provided, since this would be enormously  slow. If needed,
 152   convert to const char *.
 153 */
 154
 155
 156 // because const char* also has an operator ==, this is for safety:
 157 inline bool operator==(String s1, String s2){    return !(s1.compare(s2));}
 158 inline bool operator==(String s1, const char *s2){ return !(s1.compare(s2));}
 159 inline bool operator==(const char *s1, String s2){ return !(s2.compare(s1));}
 160 inline bool operator!=(String s1, const char *s2  ) {    return s1.compare(s2);}
 161 inline bool operator!=(const char *s1,String s2) {    return s2.compare(s1);}
 162 inline bool operator!=(String s1, String s2  ) {    return s1.compare(s2);}
 163
 164 inline String
 165 operator  + (String s1, String  s2)
 166 {
 167     s1 += s2;
 168     return s1;
 169 }
 170
 171 inline ostream &
 172 operator << ( ostream& os, String d )
 173 {
 174     d.printOn(os);
 175     return os;
 176 }
 177
 178
 179 String quoteString(String message, String quote);
 180
 181 #endif