#ifndef __STRINGS_H

#define __STRINGS_H


#include <iostream.h>


class Strings {  
public:

  enum Directions {left, right, leftAndRight};

  Strings ();
  Strings (char);
  Strings (const char*);
  Strings (const Strings&);
  virtual ~Strings();

  virtual int            beginsWith (const char*) const;
  virtual int            contains (const char) const;
  virtual int            contains (const char*) const;
  virtual int            contains (const Strings&) const;
  virtual unsigned int   count (const char) const;
  virtual int            endsWith (const char*) const;
  virtual int            empty() const;
  virtual int            isAlphabetic() const;
  virtual int            isAlphanumeric() const;
  virtual int            isLowercase() const;
  virtual int            isNumeric() const;
  virtual int            isUppercase() const;
  virtual unsigned int   length() const;
  virtual Strings        lowercaseOf() const;
  virtual int            matches (const char*) const;
  virtual int            matches (const Strings&) const;
  virtual int            soundsLike (const char*) const;
  virtual int            soundsLike (const Strings&) const;
  virtual double         toDouble() const;
  virtual int            toInt() const;
  virtual long           toLong() const;
  virtual Strings        sliceOf (const char delimitor) const;
  virtual Strings        token() const;
  virtual Strings        token (const char delimitor) const;
  virtual Strings        uppercaseOf() const;

  virtual void append (char);
  virtual void append (const char*);
  virtual void append (const Strings&); 
  virtual void append (const int);
  virtual void clear();
  virtual void erase();
  virtual void lowercase();
  virtual void prepend (char);
  virtual void prepend (const char*);
  virtual void prepend (const Strings&);
  virtual void prepend (const int);
  virtual void remove (const char);
  virtual void replace (const char, const char);
  virtual void replace (const char, const char*);
  virtual void replace (const char, const Strings&);
  virtual void reverse();
  virtual void slice (unsigned int, const Directions = left);
  virtual void slice (Strings&, const char delimitor, int removeDelimitor = 0);
  virtual void sliceLeft (Strings&, unsigned int);
  virtual void sliceToken (const unsigned int = 1);
  virtual void sliceToken (const char delimitor, int removeDelimitor = 0);
  virtual void sliceToken (Strings& token);
  virtual void sliceToken (Strings& token, const char delimitor, int removeDelimitor = 0);
  virtual void swap (Strings&);
  virtual void trim (const Directions = leftAndRight);
  virtual void trim (const char, const Directions = leftAndRight);
  virtual void uppercase(); 

  operator const char*() const;
  friend ostream& operator << (ostream&, const Strings&);
  const Strings& operator = (char);
  const Strings& operator = (const char*);
  const Strings& operator = (const Strings&);
  friend Strings operator + (const Strings&, const Strings&);
  friend Strings operator + (const Strings&, const char*);
  friend Strings operator + (const char*, const Strings&);
  friend Strings operator + (const Strings&, const char);
  friend Strings operator + (const char, const Strings&);
  friend Strings operator + (const Strings&, const int);
  friend Strings operator + (const int, const Strings&);
  const Strings& operator += (char);
  const Strings& operator += (const char*);
  const Strings& operator += (const Strings&);
  const Strings& operator += (const int);
  int operator == (const Strings&) const;
  int operator == (const char*) const;
  int operator != (const Strings&) const;
  int operator != (const char*) const;
  int operator <  (const Strings&) const;
  int operator <  (const char*) const; 
  int operator >  (const Strings&) const;
  int operator >  (const char*) const;  
  int operator <= (const Strings&) const;
  int operator <= (const char*) const;  
  int operator >= (const Strings&) const; 
  int operator >= (const char*) const;
  const char& operator [] (const unsigned int) const;

protected:
  
  int     checkMatch (char*, char*) const;
  Strings soundexCodeOf (const char*) const;
  int     soundexNumericOf (const char) const;
  void    sliceLeft (unsigned int);
  void    sliceRight (unsigned int);
  void    trimLeft();
  void    trimRight();
  void    trimLeft (const char);
  void    trimRight (const char);

  char*   theString;
};


#endif



// Copyright (c) 1995-1997 D J Supel and ISX Corporation



// ABSTRACT:

// 

//   The String class provides basic string operations. 

//

// METHODS:

//   

// beginsWith (const char*): Returns true if the prefix of the String 

// exactly matches the client specified character string.

//

//   Example: beginsWith ("hello")       on "hello world"    returns 1;

//   Example: beginsWith ("hello")       on "  hello world"  returns 0;

//   Example: beginsWith ("hello world") on "hello world!!!" returns 1;

//

// isAlphabetic() returns true if all characters in the string are

// alphabetic characters or space characters. empty strings return 

// false.

//

// isAlphanumeric() returns true if all characters in the string are

// alphabetic, numeric, or space characters. empty strings return false.

//

// isLowercase() returns true if all characters in the string are

// lowercase characters or space characters. empty strings return 

// false.

//

// isUppercase() returns true if all characters in the string are

// uppercase characters or space characters. empty strings return 

// false.

//

// isNumeric() returns true if all characters in the string are numbers.

// if any spaces exist, false is returned. punctuation in strings 

// currently fail (eg. "24,888.34"). empty strings return false.

//

// matches (const char* pattern) and matches (const Strings& pattern)

// provide UNIX shell-like pattern matching for ?, [], and *.

//

//   Example: matches ("?b?") on "abc" returns 1.

//   Example: matches ("[abc]*") on "apple" returns 1.

//   Example: matches ("[abc]*") on "cat" returns 1.

//   Example: matches ("[abc]*") on "dog" returns 0.

//

// soundsLike (const char*) and soundsLike (const Strings&) returns

// true if the strings compare equally by 'sound', not 'spelling'.

// The method is based on the "soundex" algorithm so best results

// occur in word comparisions as opposed to sentence/phrases. The

// algorithm is 'English' based.

//

//   Example: soundsLike ("Beatles") on "beedles" returns 1.

//   Example: soundsLike ("Botany Bay") on "Botneebay" returns 1.

//   Example: soundsLike ("Rugby") on "rugbug" returns 0.

//

// sliceOf (const char) : Returns the sequence of characters up to

//   the delimitor. If the delimitor is not found, the original string 

//   is returned.

//

// token() : Returns the first non-space sequence of characters.

//

//   Example: token() on "  hello world!"  returns "hello"

//   Example: token() on "hello"           returns "hello"

//   Example: token() on "  hello   "      returns "hello"

//

// token (const char) : Returns the sequence of characters up to 

// the delimitor. If the delimitor is not found, the original string, 

// less any preceeding blank spaces, is returned.

//

//   Example: token (",") on "  hello world, how"  returns "hello world"

//   Example: token (",") on "hello world"         returns "hello world"

//   Example: token (",") on "   hello world,,, "  returns "hello world"

//

// remove (char): remove ALL occurences of the specified character.

//

//   Example: remove (',') on "12,000"     is set to "12000"

//   Example: remove (',') on "12,000,000" is set to "12000000" 

//

// replace (char old, char new): replace ALL occurences of the old

// character with the new character.

//

//   Example: replace (',', '_') on "12,000"     is set to "12_000"

//   Example: replace (',', '_') on "12,000,000" is set to "12_000_000" 

//

// slice (unsigned int, const Directions): cuts off the number of characters

// specified. The client can specify which side of the string the characters 

// are 'sliced' off.

//

//   Example: slice ((unsigned int)4) on "hello world" returns "o world"

//   Example: slice ((unsigned int)2, Strings::right) on "happy" returns "hap"

//

// sliceToken (unsigned int) : Removes the number of 'tokens' specified and  

// sets the string to the begining of the next token.

//

//   Example: sliceToken()  on "   hello world!"  is set to "world!"

//   Example: sliceToken()  on "   $ world!"      is set to "world!"

//   Example: sliceToken()  on "good-day world!"  is set to "world!"

//   Example: sliceToken(2) on "good day world!"  is set to "world!"

//

// sliceToken (const char, int) : Removes the sequence of characters up 

// to the delimitor, including delimitor if int value is true. If the 

// delimitor is not found, the string is altered by removal of any 

// preceeding blank spaces only.

//

//   Example: sliceToken(",") on    "  hello world, how"   is set to ", how"

//   Example: sliceToken(",", 1) on " hello world, how"    is set to "how"

//   Example: sliceToken(",", 1) on " hello world,,, how"  is set to ",,how"

//

// sliceToken (Strings&) and sliceToken (Strings&, const char, int): Perform

// the same operations as the similar sliceToken methods above except the

// sliced off token is returned to the user. This sliced off token will

// have no white-space to its left or right.

//

// trim(): Removes ALL occurences of white-space. The client can specify 

// from which direction trimming takes place.

//

//   Example: trim()                 on " xyz "  is set to "xyz"

//   Example: trim (Strings::left)   on " xyz "  is set to "xyz "

//   Example: trim (Strings::right)  on " xyz "  is set to " xyz"

//

// trim (const char, const Directions): Removes ALL occurences of the

// specified character. The client can specify from which direction 

// trimming of this character takes place.

//

// EXCEPTIONS:

//

//   None.

//

// EXAMPLES:

//

//   See METHODS.

// 

// LIMITATIONS:

//

//   None.

//

// NOTES:

//  

//   None.

//