////////////////////////////////////////////////////////////////
//
//	capstring.h
//
//	This modification of the "apstring" interface is for
//	an assignment in CS117 at Carleton College.
//	Jeff Ondich.  jondich@carleton.edu
//	
////////////////////////////////////////////////////////////////

#ifndef _APSTRING_H
#define _APSTRING_H

#include <iostream>
// uncomment line below if bool not built-in type
// #include "bool.h"

// *******************************************************************
//  APCS string class
//
//  string class consistent with a subset of the standard C++ string class
//  as defined in the draft ANSI standard
// *******************************************************************

extern const int npos;  // used to indicate not a position in the string

class capstring
{
  public:

  /////////////////////////////////////////
  // The members to be added for the
  // CS117 assignment.
  /////////////////////////////////////////

  void				makeupper( );
  int				rfind( char ch ) const;
  int				rfind( const capstring& s ) const;
  void				reverse( );
  void				operator -= ( char ch );

  /////////////////////////////////////////
  // End of the CS117 members.
  /////////////////////////////////////////


  // constructors/destructor

    capstring( );                         // construct empty string ""
    capstring( const char * s );          // construct from string literal
    capstring( const capstring & str );      // copy constructor
    ~capstring( );                        // destructor

  // assignment

    const capstring & operator = ( const capstring & str ); // assign str
    const capstring & operator = ( const char * s );       // assign s
    const capstring & operator = ( char ch );              // assign ch

  // accessors

    int    length( )                  const;    // number of chars
    int    find( const capstring & str ) const;  // index of first occurrence of str
    int    find( char ch )            const;    // index of first occurrence of ch
    capstring substr( int pos, int len ) const;    // substring of len chars 
                                                // starting at pos
    const char * c_str( )             const;    // explicit conversion to char *

  // indexing

    char   operator[ ]( int k )       const;    // range-checked indexing
    char & operator[ ]( int k );                // range-checked indexing

  // modifiers

    const capstring & operator += ( const capstring & str );// append str
    const capstring & operator += ( char ch );            // append char
 
        
  private:
      int myLength;                     // length of string (# of characters)
      int myCapacity;                   // capacity of string
      char * myCstring;                 // storage for characters         
};

// The following free (non-member) functions operate on strings
//
// I/O functions

ostream & operator << ( ostream & os, const capstring & str );
istream & operator >> ( istream & is, capstring & str ); 
istream & getline( istream & is, capstring & str );  
          
// comparison operators:

bool operator == ( const capstring & lhs, const capstring & rhs );  
bool operator != ( const capstring & lhs, const capstring & rhs );  
bool operator <  ( const capstring & lhs, const capstring & rhs );  
bool operator <= ( const capstring & lhs, const capstring & rhs );  
bool operator >  ( const capstring & lhs, const capstring & rhs );  
bool operator >= ( const capstring & lhs, const capstring & rhs );  

// concatenation operator +

capstring operator + ( const capstring & lhs, const capstring & rhs );
capstring operator + ( char ch, const capstring & str );
capstring operator + ( const capstring & str, char ch );

// *******************************************************************
// Specifications for string functions
//
// Any violation of a function's precondition will result in an error
// message followed by a call to abort.
//
// constructors / destructor
//
// apstring( )
//    postcondition: string is empty
//
// apstring( const char * s )
//    description:   constructs a string object from a literal string
//                   such as "abcd"
//    precondition:  s is '\0'-terminated string as used in C
//    postcondition: copy of s has been constructed
//
// apstring( const apstring & str )
//    description:   copy constructor
//    postcondition: copy of str has been constructed
//
// ~apstring( );
//    description:   destructor
//    postcondition: string is destroyed
//
// assignment
//
// apstring & operator = ( const apstring & rhs )
//    postcondition: normal assignment via copying has been performed
//
// apstring & operator = ( const char * s )
//    description:   assignment from literal string such as "abcd"
//    precondition:  s is '\0'-terminated string as used in C
//    postcondition: assignment via copying of s has been performed
//
// apstring & operator = ( char ch )
//    description:   assignment from character as though single char string
//    postcondition: assignment of one-character string has been performed
//
// accessors
//
// int length( ) const;
//    postcondition: returns # of chars in string
//
// int find( const apstring & str)  const;
//    description:   find the first occurrence of the string str within this
//                   string and return the index of the first character.  If
//                   str does not occur in this string, then return npos.
//    precondition:  this string represents c0, c1, ..., c(n-1)
//                   str represents s0, s1, ...,s(m-1)
//    postcondition: if s0 == ck0, s1 == ck1, ..., s(m-1) == ck(m-1) and
//                   there is no j < k0 such that s0 = cj, ...., sm == c(j+m-1),
//                   then returns k0;
//                   otherwise returns npos
//
// int find( char ch ) const;
//    description:   finds the first occurrence of the character ch within this
//                   string and returns the index.  If ch does not occur in this
//                   string, then returns npos.
//    precondition:  this string represents c0, c1, ..., c(n-1)
//    postcondition: if ch == ck, and there is no j < k such that ch == cj
//                   then returns k;
//                   otherwise returns npos
//
// apstring substr( int pos, int len ) const;
//    description:   extract and return the substring of length len starting
//                   at index pos
//    precondition:  this string represents c0, c1, ..., c(n-1)
//                         0 <= pos <= pos + len - 1 < n.
//    postcondition: returns the string that represents
//                   c(pos), c(pos+1), ..., c(pos+len-1)
//
// const char * c_str( ) const;
//    description:   convert string into a '\0'-terminated string as
//                   used in C for use with functions
//                   that have '\0'-terminated string parameters.
//    postcondition: returns the equivalent '\0'-terminated string
//
// indexing
//
// char operator [ ]( int k ) const;
//    precondition:  0 <= k < length()
//    postcondition: returns copy of the kth character
//
// char & operator [ ]( int k ) 
//    precondition:  0 <= k < length()
//    postcondition: returns reference to the kth character
//
// modifiers
//
// const apstring & operator += ( const apstring & str )
//    postcondition: concatenates a copy of str onto this string
//
// const apstring & operator += ( char ch )
//    postcondition: concatenates a copy of ch onto this string
//
//
// non-member functions
//
// ostream & operator << ( ostream & os, const apstring & str) 
//    postcondition: str is written to output stream os
//
// istream & operator >> ( istream & is, apstring & str )
//    precondition:  input stream is open for reading
//    postcondition: the next string from input stream is has been read
//                   and stored in str
//
// istream & getline( istream & is, apstring & str )
//    description:   reads a line from input stream is into the string str
//    precondition:  input stream is open for reading
//    postcondition: chars from input stream is up to '\n' have been read
//                   and stored in str; the '\n' has been read but not stored
//
// apstring operator + ( const apstring & lhs, const apstring & rhs )
//    postcondition: returns concatenation of lhs with rhs
//
// apstring operator + ( char ch, const apstring & str )
//    postcondition: returns concatenation of ch with str
//
// apstring operator + ( const apstring & str, char ch )
//    postcondition: returns concatenation of str with ch
//
//***************************************************************
#endif