/*
-
FILE : string.hh -- declare String
-
+
Rehacked by HWN 3/nov/95
removed String & 's
introduced Class String_handle
- */
+*/
#ifndef STRING_HH
#define STRING_HH
+// too darn slow with gcc3
+#ifdef STREAM_SUPPORT
+#if (__GNUC__ > 2)
+#include <iostream>
+#else
+class ostream;
+#endif
+#endif
-#include <string.h>
-#include <iostream.h>
-#include <Rational.h>
-
+#include "arithmetic-operator.hh"
#include "string-handle.hh"
-/**
-
- Intuitive string class. provides
+/**
+
+Intuitive string class. provides
\begin{itemize}
\item
- ref counting through #String_handle#
+ref counting through #String_handle#
\item
- conversion from bool, int, double, char* , char.
+conversion from bool, int, double, char* , char.
\item
- to be moved to String_convert:
- conversion to int, upcase, downcase
+to be moved to String_convert:
+conversion to int, upcase, downcase
\item
- printable.
+printable.
\item
- indexing (index_i, index_any_i, last_index_i)
+indexing (index_i, index_any_i, last_index_i)
\item
- cutting (left_str, right_str, mid_str)
+cutting (left_string, right_string, mid_string)
\item
- concat (+=, +)
+concat (+=, +)
\item
- signed comparison (<, >, ==, etc)
+signed comparison (<, >, ==, etc)
\item
- No operator[] is provided, since this would be enormously slow. If needed,
- convert to char const* .
+No operator[] is provided, since this would be enormously slow. If needed,
+convert to char const* .
\end{itemize}
-
*/
class String
{
protected:
- String_handle strh_;
+ String_handle strh_;
+
+ bool null_terminated ();
- bool null_terminated();
-
public:
- /** init to empty string. This is needed because other
+ /** 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, int length_i);
- /// String s = "abc";
- String( char const* source );
- String( Byte const* byte_c_l, int length_i );
-
- /// "ccccc"
- String( char c, int n = 1 );
+ /// return "new"-ed copy of contents
+ Byte *get_copy_byte () const;
+ char *get_copy_str0 () const;
- String( int i , char const *fmt=0);
- String ( double f , char const* fmt =0);
- /// 'true' or 'false'
- String(bool );
+ char const *to_str0 () const;
+ Byte const *to_bytes () const;
+ char *get_str0 ();
+ Byte *get_bytes ();
- /// return a "new"-ed copy of contents
- Byte* copy_byte_p() const; // return a "new"-ed copy of contents
+ String &operator = (String const &source);
- char const* ch_c_l() const;
- Byte const* byte_c_l() const;
- char* ch_l();
- Byte* byte_l();
+ /// concatenate s
+ void operator += (char const *s) { strh_ += s; }
+ void operator += (String s);
- /// deprecated; use ch_c_l()
- operator char const* () const { return ch_c_l(); }
-
- String &operator =( String const & source );
+ bool is_empty () const;
- /// concatenate s
- void operator += (char const* s) { strh_ += s; }
- void operator += (String s);
+ void append (String);
+ void prepend (String);
- void append(String);
- void prepend(String);
+ /**
+ Return a char. UNSAFE because it may change strlen () result
+ */
+ char &operator [] (int n);
+ char operator [] (int n) const;
- char operator []( int n ) const { return strh_[n]; }
+ /// return n leftmost chars
+ String left_string (int n) const;
- /// return n leftmost chars
- String left_str( int n ) const;
+ /// return n rightmost chars
+ String right_string (int n) const;
- /// return n rightmost chars
- String right_str( int n ) const;
+ /// return the "esrever" of *this
+ void reverse ();
- /// return uppercase of *this
- String upper_str() const;
+ /// return a piece starting at index (first char = index_i 0), length n
+ String cut_string (int index_i, int n) const;
- /// return lowercase of *this
- String lower_str() const;
+ /// cut out a middle piece, return remainder
+ String nomid_string (int index_i, int n) const;
- /// return the "esrever" of *this
- String reversed_str() const;
+ /// signed comparison, analogous to memcmp;
+ static int compare (String const &s1, const String &s2);
+ /// index of rightmost c
+ int index_last (char c) const;
- /// return a piece starting at index_i (first char = index_i 0), length n
- String mid_str(int index_i, int n ) const;
+ /// index of rightmost element of string (???)
+ int index_last (char const *string) const;
- /// cut out a middle piece, return remainder
- String nomid_str(int index_i, int n ) const;
+ int index (char c) const;
- /// signed comparison, analogous to memcmp;
- static int compare_i(String const & s1,const String& s2);
-
- /// index of rightmost c
- int index_last_i( char c) const;
+ /// index of leftmost occurance of STRING
+ int index (String) const;
- /// index of rightmost element of string
- int index_last_i( char const* string ) const;
+ int index_any (String) const;
- int index_i(char c ) const;
- 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;
+#ifdef STREAM_SUPPORT
+ /// provide Stream output
+ void print_on (ostream &os) const;
+#endif
- /// the length of the string
- int length_i() const;
+ /// the length of the string
+ int length () const;
- // ***** depreciated
- int len() const {
- return length_i();
- }
+ /// convert to an integer
+ int to_int () const;
- /// convert to an integer
- int value_i() const;
+ /// convert to a double
+ double to_double () const;
- /// convert to a double
- double value_f() const;
+ void substitute_char (char text, String sub);
};
+/*
+ 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_string (String s) { return s; }
+/// "cccc"
+String to_string (char c, int n = 1);
+String to_string (int i, char const *format = 0);
+String to_string (double f, char const *format = 0);
+String to_string (long b);
+String to_string (bool b);
+String to_string (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);
-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){
- return s1 == String(s2);
-}
-inline bool operator==(char const* s1, String s2)
+inline bool operator == (String s1, char const *s2)
{
- return String(s1)==s2;
+ return s1 == String (s2);
}
-inline bool operator!=(String s1, char const* s2 ) {
- return s1!=String(s2);
-}
-inline bool operator!=(char const* s1,String s2) {
- return String(s2) !=s1;
+inline bool operator == (char const *s1, String s2)
+{
+ return String (s1) == s2;
}
-
-
-inline String
-operator + (String s1, String s2)
+inline bool operator != (String s1, char const *s2)
{
- s1 += s2;
- return s1;
+ return s1 != String (s2);
}
-
-inline ostream &
-operator << ( ostream& os, String d )
+inline bool operator != (char const *s1, String s2)
{
- d.print_on(os);
- return os;
+ return String (s2) != s1;
}
-
-// String quoteString(String message, String quote);
+IMPLEMENT_ARITHMETIC_OPERATOR (String, +);
+#ifdef STREAM_SUPPORT
+ostream &operator << (ostream &os, String d);
+#endif
#endif
projects / lilypond.git / blobdiff