---

String.h

Go to the documentation of this file.

/*
    File:       String.h

    Function:   Classes for manipulating strings

    Author:     Andrew Willmott

    Copyright:  (c) 1996-2000, Andrew Willmott
*/

#ifndef __String__
#define __String__

#include "cl/PtrArray.h"
#include <string.h>
#include <iostream.h>
#include <fstream.h>


// --- StrConst Class ---------------------------------------------------------

class String;

class StrConst
{
public:
    StrConst() : theString(0) {};

    StrConst(const Char *s) : theString(s) {};

                operator const Char *() const
                { return(theString); };
                
    Bool        operator == (StrConst s) const
                { return(strcmp(theString, s.theString) == 0); };
    Bool        operator != (StrConst s) const
                { return(strcmp(theString, s.theString) != 0); };

    Bool        operator == (const Char *sc) const
                { return(strcmp(theString, sc) == 0); };
    Bool        operator != (const Char *sc) const
                { return(strcmp(theString, sc) != 0); };

    Bool        IsNull() const
                { return(theString == 0); }
    Int         FindChar(Char c) const;
    Int         FindCharLast(Char c) const;
    String      SubString(Int start, Int length);
    String      Prefix(Int length);
    String      Suffix(Int length);

    Int         Length() const
                { return(strlen(theString)); };
    const Char  *CString() const
                { return theString; };

protected:  
    const Char  *theString; 
};

inline Bool operator == (const Char *cs, StrConst s) 
{ return(s == cs); };
inline Bool operator != (const Char *cs, StrConst s)
{ return(s != cs); };

inline ostream &operator << (ostream &s, StrConst sb)
{
    s << (const Char *) sb;
    return(s); 
}

// --- String class -----------------------------------------------------------


class String : public Array<Char>
{
public:
                String() : Array<Char>(1) { item[0] = 0; };
                String(const String &sb) : Array<Char>(sb) {};
                String(StrConst s);
                ~String() {};
                
                operator StrConst() const
                { return(StrConst(item)); };
                operator const Char *() const
                { return(item); };

    Char        *CString() const
                { return(item); };
                
    String      &Append(StrConst s);
    String      &Insert(StrConst s, Int place);
    String      &Delete(Int start, Int length);
    
    String      &operator = (StrConst s);
    String      &operator = (const Char *s);

    Bool        operator == (const Char *s) const
                { return(strcmp(item, s) == 0); };
    Bool        operator != (const Char *s) const
                { return(strcmp(item, s) != 0); };
        
    Bool        operator == (StrConst s) const
                { return(strcmp(item, s) == 0); };
    Bool        operator != (StrConst s) const
                { return(strcmp(item, s) != 0); };
                
    Bool        operator == (const String &s) const
                { return(strcmp(item, s.CString()) == 0); };
    Bool        operator != (const String &s) const
                { return(strcmp(item, s.CString()) != 0); };
                
    String      &operator += (StrConst s)
                { return(Append(s)); };

    istream     &ReadString(istream &s);    
    istream     &ReadWord(istream &s);      
    istream     &ReadLine(istream &s);

    String      &Printf(const Char *format, ...);
    Int         Length() const
                { return(NumItems() - 1); };

    // isn't this wonderful? C++ won't downcast to StrConst in all situations
    // we'd like, so need to replicate the calls here.
    String      SubString(Int start, Int length) const
                { return(StrConst(item).SubString(start, length)); };
    String      Prefix(Int length) const
                { return(StrConst(item).Prefix(length)); };
    String      Suffix(Int length) const
                { return(StrConst(item).Suffix(length)); };
    Int         FindChar(Char c) const
                { return(StrConst(item).FindChar(c)); };
    Int         FindCharLast(Char c) const
                { return(StrConst(item).FindCharLast(c)); };

    Void        Free()
                { Clear(); };
    
    friend      StrConst;
};

inline Bool operator == (const Char *cs, const String &s) 
{ return(s == cs); };
inline Bool operator != (const Char *cs, const String &s)
{ return(s != cs); };

inline Bool operator == (StrConst cs, const String &s)
{ return(s == cs); };
inline Bool operator != (StrConst cs, const String &s)
{ return(s != cs); };

inline ostream &operator << (ostream &s, const String &sb)
{
    s << sb.CString();
    return(s); 
}
istream &operator >> (istream &s, String &str);


// --- TempString class --------------------------------------

//  A TempString is a String that will not be used further by the code that
//  produced it, so is free for further use.
//  Purpose: For speeding up concatenation sequences. These operators ensure 
//  that only one String is used for all the concatenations in a sequence like
//  a + b + c.

class TempString : public String
{

public:
    TempString() : String() {};
};

inline ostream &operator << (ostream &s, TempString &sb)
{ s << (String &) sb; return(s); }
inline TempString operator + (StrConst a, StrConst b)
{ TempString t; t.Append(a).Append(b); return(t); }
inline TempString &operator + (TempString &a, StrConst b)
{ return((TempString &) a.Append(b)); }
inline TempString &operator + (StrConst a, TempString &b)
{ return((TempString &) b.Insert(a, 0));}


// --- Utility routines -----------------------------------------

typedef PtrArray<const Char> StrConstArray;
// XXX need to change to actual StrConst based to make
// == "asd" comparisons work: workaround == StrConst("asd").

Bool        IsEndOfLine(istream &s);
Void        ChompWhiteSpace(istream &s);
// reads from s until next non-whitespace character.
TempString  SubstituteEnvVars(StrConst str);
// replace environment variables in s (e.g., $HOME) with their
// environment-defined values.
Void Split(StrConst line, StrConstArray &a, StrConst sep = " \t");
// WARNING: 'a' is only valid until the next time Split is called.


#endif

---