flower/include/string.hh

   1 /*
   2
   3   FILE   : string.hh -- declare String
   4
   5   Rehacked by HWN 3/nov/95
   6   removed String & 's
   7   introduced Class String_handle
   8  */
   9
  10 #ifndef STRING_HH
  11 #define STRING_HH
  12
  13
  14 // too darn slow with gcc3
  15 #ifdef STREAM_SUPPORT
  16 #if ( __GNUC__ > 2 )
  17 #include <iostream>
  18 #else
  19 class ostream;
  20 #endif
  21 #endif
  22
  23 #include "arithmetic-operator.hh"
  24 #include "string-handle.hh"
  25
  26 /**
  27
  28   Intuitive string class. provides
  29 \begin{itemize}
  30 \item
  31   ref counting through #String_handle#
  32 \item
  33   conversion from bool, int, double, char* , char.
  34 \item
  35   to be moved to String_convert:
  36   conversion to int, upcase, downcase
  37
  38 \item
  39   printable.
  40
  41 \item
  42   indexing (index_i, index_any_i, last_index_i)
  43
  44 \item
  45   cutting (left_string, right_string, mid_string)
  46
  47 \item
  48   concat (+=, +)
  49
  50 \item
  51   signed comparison (<, >, ==, etc)
  52
  53 \item
  54   No operator[] is provided, since this would be enormously  slow. If needed,
  55   convert to char const* .
  56 \end{itemize}
  57
  58 */
  59 class String
  60 {
  61 protected:
  62   String_handle strh_;
  63
  64   bool null_terminated ();
  65
  66 public:
  67
  68   /** init to empty string. This is needed because other
  69     constructors are provided.*/
  70   String ();
  71
  72   /// String s = "abc";
  73   String (char const* source);
  74   String (Byte const* byte, int length_i);
  75
  76   ///  return "new"-ed copy of contents
  77   Byte* get_copy_byte () const;
  78   char* get_copy_str0 () const;
  79
  80   char const* to_str0 () const;
  81   Byte const* to_bytes () const;
  82   char* get_str0 ();
  83   Byte* get_bytes ();
  84
  85   String &operator = (String const & source);
  86
  87   /// concatenate s
  88   void operator += (char const* s) { strh_ += s; }
  89   void operator += (String s);
  90
  91   bool is_empty () const;
  92
  93   void append (String);
  94   void prepend (String);
  95
  96   /**
  97     Return a char.  UNSAFE because it may change strlen () result
  98    */
  99   char &operator [] (int n);
 100   char operator [] (int n) const;
 101
 102   /// return n leftmost chars
 103   String left_string (int n) const;
 104
 105   /// return n rightmost chars
 106   String right_string (int n) const;
 107
 108   /// return uppercase of *this
 109   String upper_string () const;
 110
 111   /// return lowercase of *this
 112   String lower_string () const;
 113
 114   /// return the "esrever" of *this
 115   String reversed_string () const;
 116
 117   /// return a piece starting at index (first char = index_i 0), length n
 118   String cut_string (int index_i, int n) const;
 119
 120   /// cut out a middle piece, return remainder
 121   String nomid_string (int index_i, int n) const;
 122
 123   /// signed comparison,  analogous to memcmp;
 124   static int compare (String const & s1,const  String& s2);
 125
 126   /// index of rightmost c
 127   int index_last (char c) const;
 128
 129   /// index of rightmost element of string (???)
 130   int index_last (char const* string) const;
 131
 132   int index (char c) const;
 133
 134   /// index of leftmost occurance of STRING
 135   int index (String) const;
 136
 137
 138   int index_any (String) const;
 139
 140   void to_upper ();
 141   void to_lower ();
 142
 143 #ifdef STREAM_SUPPORT
 144   /// provide Stream output
 145   void print_on (ostream& os) const;
 146 #endif
 147
 148   /// the length of the string
 149   int length () const;
 150
 151   /// convert to an integer
 152   int to_int () const;
 153
 154   /// convert to a double
 155   double to_double () const;
 156 };
 157
 158 /*
 159  better to clutter global namespace, than suffer *ugh, ugh, ugh*
 160  implicit conversions.
 161
 162  it might be cool to have no type-checking at all in a language,
 163  but once there is, having this silently circumvented is a nightmare.
 164
 165  whenever implicit conversions seem necessary (e.g. operator << ()),
 166  use Scalar as the generic type iso String.
 167  */
 168
 169 /// for completeness (=handy)
 170 inline String to_string (String s) { return s; }
 171 /// "cccc"
 172 String to_string (char c, int n = 1);
 173 String to_string (int i, char const* format = 0);
 174 String to_string (double f, char const* format = 0);
 175 String to_string (long  b);
 176 String to_string (bool b);
 177 String to_string (char const* format, ... );
 178
 179 /*
 180   technically incorrect, but lets keep it here: this is a
 181   catch all place for this stuff.
 182   */
 183
 184 #include "international.hh"
 185
 186
 187 #include "compare.hh"
 188 INSTANTIATE_COMPARE (String const &, String::compare);
 189
 190 #ifdef STRING_UTILS_INLINED
 191 #ifndef INLINE
 192 #define INLINE inline
 193 #endif
 194 #include "string.icc"
 195 /* we should be resetting INLINE. oh well. */
 196 #endif
 197
 198
 199 // because char const* also has an operator ==, this is for safety:
 200 inline bool operator== (String s1, char const* s2)
 201 {
 202   return s1 == String (s2);
 203 }
 204 inline bool operator== (char const* s1, String s2)
 205 {
 206   return String (s1)==s2;
 207 }
 208 inline bool operator!= (String s1, char const* s2 ) {
 209   return s1!=String (s2);
 210 }
 211 inline bool operator!= (char const* s1,String s2) {
 212   return String (s2) !=s1;
 213 }
 214
 215 IMPLEMENT_ARITHMETIC_OPERATOR (String, +);
 216 #ifdef STREAM_SUPPORT
 217 ostream &operator << (ostream& os, String d);
 218 #endif
 219
 220 #endif