release: 1.0.1

[lilypond.git] / flower / include / string.hh

diff --git a/flower/include/string.hh b/flower/include/string.hh
index 7682fa0bfbd7b2403db41c87c4ca6e7cb65b6569..fb8dec55e66030da13c5d5b8622494d7989a4f5c 100644 (file)
--- a/flower/include/string.hh
+++ b/flower/include/string.hh
@@ -13,10 +13,17 @@
 
 #include <string.h>
 #include <iostream.h>
-#include <Rational.h>
-
+#include "arithmetic-operator.hh"
+#include "fproto.hh"
 #include "string-handle.hh"
 
+/* Libg++ also has a String class.  Programming errors can lead to
+  confusion about which String is in use.  Uncomment the following if you have 
+  unexplained crashes after mucking with String
+  */
+
+//  #define String FlowerString
+
 /** 
  
   Intuitive string class. provides 
@@ -55,52 +62,52 @@ class String
 protected:
   String_handle strh_; 
 
-  bool null_terminated();
+  bool null_terminated ();
     
 public:
 
   /** init to empty string. This is needed because other
     constructors are provided.*/
-  String() {  }                  
-  String (Rational);
+  String  ();
 
   /// String s = "abc";
   String (char const* source); 
   String (Byte const* byte_C, int length_i); 
     
-  /// "ccccc"
-  String (char c, int n = 1);
+  ///  return "new"-ed copy of contents
+  Byte* copy_byte_p () const;
+  char* copy_ch_p() const;
 
-  String (int i , char const *fmt=0);
-  String ( double f , char const* fmt =0);
-  /// 'true' or 'false'
-  String (bool);
+  char const* ch_C () const;
+  Byte const* byte_C () const;
+  char* ch_l ();
+  Byte* byte_l ();
 
-  ///  return a "new"-ed copy of contents
-  Byte* copy_byte_p() const; //  return a "new"-ed copy of contents
-
-  char const* ch_C() const;
-  Byte const* byte_C() const;
-  char* ch_l();
-  Byte* byte_l();
-
-  /// deprecated; use ch_C()
-  operator char const*() const { return ch_C(); }
-    
-  String &operator =( String const & source);
+  String &operator =(String const & source);
 
   /// concatenate s
   void operator += (char const* s) { strh_ += s; }
   void operator += (String s);
 
-  operator bool () 
+  bool empty_b  () const;
+#if 0
+  /** is the string empty?
+
+    Ugh-ugh-thank-you-cygnus.  W32 barfs on this
+   */
+  operator bool  () const;
   {
-    return length_i (); 
+    return length_i  (); 
   }
+#endif
   void append (String);
   void prepend (String);
 
-  char operator []( int n) const { return strh_[n]; }
+  /**
+    Return a char.  UNSAFE because it may change strlen () result
+   */
+  char &operator [](int n);
+  char operator [](int n) const;
 
   /// return n leftmost chars
   String left_str (int n) const;
@@ -109,17 +116,16 @@ public:
   String right_str (int n) const;
 
   /// return uppercase of *this
-  String upper_str() const;
+  String upper_str () const;
 
   /// return lowercase of *this
-  String lower_str() const;
+  String lower_str () const;
 
   /// return the "esrever" of *this
-  String reversed_str() const;
-
+  String reversed_str () const;
 
   /// return a piece starting at index_i (first char = index_i 0), length n
-  String mid_str (int index_i, int n) const;
+  String cut_str (int index_i, int n) const;
 
   /// cut out a middle piece, return remainder
   String nomid_str (int index_i, int n) const;
@@ -130,39 +136,77 @@ public:
   /// index of rightmost c 
   int index_last_i (char c) const;
 
-  /// index of rightmost element of string 
+  /// index of rightmost element of string  (???)
   int index_last_i (char const* string) const;
 
+  /// index of leftmost #c#
   int index_i (char c) const;
+
+  /// index of leftmost occurance of STRING
   int index_i (String) const;
+
+
   int index_any_i (String) const;
 
-  void to_upper();
-  void to_lower();
+  void to_upper ();
+  void to_lower ();
+
   /// provide Stream output
   void print_on (ostream& os) const;
 
   /// the length of the string
-  int length_i() const;
-
-  // ***** depreciated
-  int len() const {
-    return length_i();
-  }
+  int length_i () const;
 
   /// convert to an integer
-  int value_i() const;
+  int value_i () const;
 
   /// convert to a double
-  double value_f() const;
+  double value_f () const;
 };
 
-#include "compare.hh"
+/*
+ better to clutter global namespace, than suffer *ugh, ugh, ugh*
+ implicit conversions.
+
+ it might be cool to have no type-checking at all in a language,
+ but once there is, having this silently circumvented is a nightmare.
 
+ whenever implicit conversions seem necessary (e.g. operator << ()),
+ use Scalar as the generic type iso String.
+ */
+
+/// for completeness (=handy)
+inline String to_str (String s) { return s; }
+/// "cccc"
+String to_str (char c, int n = 1);
+String to_str (int i, char const* format = 0);
+String to_str (double f , char const* format = 0);
+String to_str (bool b);
+String to_str (char const* format, ... );
+
+/*
+  technically incorrect, but lets keep it here: this is a
+  catch all place for this stuff.
+  */
+  
+#include "international.hh"
+
+
+#include "compare.hh"
 INSTANTIATE_COMPARE(String const &, String::compare_i);
 
+#ifdef STRING_UTILS_INLINED
+#ifndef INLINE
+#define INLINE inline
+#endif
+#include "string.icc"
+/* we should be resetting INLINE. oh well. */
+#endif
+
+
 // because char const* also has an operator ==, this is for safety:
-inline bool operator==(String s1, char const* s2){
+inline bool operator==(String s1, char const* s2)
+{
   return s1 == String (s2);
 }
 inline bool operator==(char const* s1, String s2)
@@ -176,19 +220,15 @@ inline bool operator!=(char const* s1,String s2) {
   return String (s2) !=s1;
 }
 
-
-inline String
-operator  + (String s1, String  s2)
-{
-  s1 += s2;
-  return s1;
-}
+IMPLEMENT_ARITHMETIC_OPERATOR (String, +);
 
 inline ostream &
-operator << ( ostream& os, String d)
+operator << (ostream& os, String d)
 {
   d.print_on (os);
   return os;
 }
 
+
+
 #endif