---

     

---

CHMstring.h

#ifndef _CHM_STRING_H_
#define _CHM_STRING_H_
//---------------------------------------------------------------------------
// Copyright (C) 1997-2007 iNTERFACEWARE Inc.  All Rights Reserved
//
// Module: CHMstring
//
// Description:String class derived from work by Lynn Prentice
//       and Ian Farquharson.
//
// Author: Greg Norman
// Revision: $Revision: 1.17 $
//
// Last Edit Date: $Date: 2010-02-24 17:41:00 $
// Source: $Source: /home/cvs/cvsroot/CHM/CHMstring.h,v $
//---------------------------------------------------------------------------
// This is super efficient string class used by HL7 Chameleon
#include <CHM/CHMminimumInclude.h>

#define COPYONWRITE

#ifdef __MSC__
   const size_t NPOS = npos;
#endif

//=============================================================================

class CHMstringRef;

class CHMstring 
{
public:
   // Constructors
   CHMstring(void);
   
   CHMstring(const CHMstring& s);   
   
   CHMstring(const CHMstring& s, const size_t& orig, const size_t& n = npos);   
   
   CHMstring(const CHMchar* cp);   
   
   CHMstring(const CHMchar* cp, const size_t& orig, const size_t& n = npos );   
   
   CHMstring(CHMchar c);

   CHMstring(size_t n, CHMchar c);
   
   ~CHMstring(void); 

#ifdef CHM_UNICODE_ON
   CHMstring& operator=(const char* pValue);
#endif  // CHM_UNICODE_ON
   
   CHMstring& operator =(const CHMstring& s);
   
   CHMstring& operator+=(const CHMchar* cp);
   
   CHMstring& operator+=(const CHMstring &s);   
    
   const CHMchar operator[](const size_t& pos) const;
   
   CHMchar& operator[](const size_t& pos);
  
   enum StripType 
   { 
      Leading,  
      Trailing, 
      Both      
   };
   
   CHMstring& append(const CHMchar* cp,
                     const size_t& orig = 0,
                     const size_t& n = npos);
   
   CHMstring& append(size_t SizeOfBuffer, 
                     const CHMchar* Buffer);
   
   CHMstring& append(const CHMstring& s,
                     const size_t& orig = 0,
                     const size_t& n = npos);
   
   void assign(size_t n, CHMchar Filler);
   
   const CHMchar* c_str(void) const;
     
   void clear(void);
      
   int compare(const CHMchar* Compare) const;
   
   int compare(const CHMstring& s) const;
      
   const size_t find(const CHMstring& s, const size_t& pos=0) const;
  
   CHMchar* get_buffer(void); 
     
   CHMstring & insert(size_t pos,
                      const CHMchar* cp,
                      const size_t& orig = 0,
                      const size_t& n = npos );
                      
   CHMstring & insert(size_t pos,
                      const CHMstring &s,
                      const size_t& orig = 0,
                      const size_t& n = npos );

   const CHMboolean is_null(void) const;    
      
   CHMstring& prepend(const CHMchar* cp,
            const size_t& orig = 0,
            const size_t& n = npos );
   
   CHMstring& prepend(const CHMstring &s,
                      const size_t& orig = 0,
                      const size_t& n = npos);
    
   CHMstring& remove(const size_t& pos, const size_t& n=npos);
   
   CHMstring& replace(const size_t& pos,
                      const size_t& n1,
                      const CHMstring& s,
                      const size_t& orig = 0,
                      const size_t& n2 = npos );   
      
   const size_t rfind(const CHMstring& s, const size_t& pos) const;
   
   const size_t rfind(const CHMstring& s) const;
  
   const size_t& size(void) const;
   
   CHMstring strip(const StripType& s = Trailing, const CHMchar& c = ' ') const;
   
   void stripAll(const CHMchar& c = ' ');
   
   void subChar(const CHMchar pTarget,
                const CHMchar pReplacement);

   CHMstring substr(const size_t& pos, const size_t& n=npos) const;

protected:
   const CHMboolean valid_element(const size_t& pos ) const;
   const CHMboolean valid_index(const size_t& pos ) const;

private:
   // provided for display purposes only...
   const CHMchar* Current;
   CHMstringRef* pReference;

private:
   const size_t find_index(const CHMchar*,
                           const size_t& start) const;
   const size_t rfind_index(const CHMchar*,
                           const size_t& start) const;
};

// this constructor is trivial and called frequently ...
inline CHMstring::CHMstring(void)
 : pReference(NULL), Current(NULL) {}

inline const size_t CHMstring::rfind(const CHMstring& s) const
{
   return rfind(s, size());
};

// Check to make sure a string index refers to a valid element
inline const CHMboolean CHMstring::valid_element(const size_t& n) const
{
   return n < size();
};

// Check to make sure a string index is in range
inline const CHMboolean CHMstring::valid_index(const size_t& n) const
{
   return n <= size();
};

CHMstring operator+(const CHMchar* cp, const CHMstring& s);
CHMstring operator+(const CHMstring& s, const CHMchar* cp);

inline CHMstring operator+(const CHMstring& s1, const CHMstring& s2) 
{
   return s1 + s2.c_str();
};

CHMstring operator+(const CHMchar& s1, const CHMstring& s2);
CHMstring operator+(const CHMstring& s1, const CHMchar& s2);

// comparisons...
inline int operator == (const CHMstring& s1, const CHMstring& s2) 
{
   return s1.compare(s2) == 0;
};

inline int operator == (const CHMstring& s1, const CHMchar* s2) 
{
   return s1.compare(s2) == 0;
};

inline int operator == (const CHMchar* cp, const CHMstring& s) 
{
   return CHMstring(cp).compare(s) == 0;
};

inline int operator != (const CHMstring& s1, const CHMstring& s2) 
{
   return !(s1==s2);
};

inline int operator != (const CHMstring& s, const CHMchar* cp) 
{
   return !(s==cp);
};

inline int operator != (const CHMchar* cp, const CHMstring& s) 
{
   return !(cp==s);
};

inline int operator < (const CHMstring& s1, const CHMstring& s2) 
{
   return s1.compare(s2) < 0;
};

inline int operator < (const CHMstring& s1, const CHMchar* s2 ) 
{
   return s1.compare(s2) < 0;
};

inline int operator < (const CHMchar* cp, const CHMstring& s) 
{
   return CHMstring(cp).compare(s) < 0;
};

inline int operator <= (const CHMstring& s1, const CHMstring& s2) 
{
   return s1.compare(s2) <= 0;
};

inline int operator <= (const CHMstring& s, const CHMchar* cp) 
{
   return s.compare(cp) <= 0;
};

inline int operator <= (const CHMchar* cp, const CHMstring& s) 
{
   return CHMstring(cp).compare(s) <= 0;
};

inline int operator > (const CHMstring& s1, const CHMstring& s2) 
{
   return s1.compare(s2) > 0;
};

inline int operator > (const CHMstring& s, const CHMchar* cp) 
{
   return s.compare(cp) > 0;
};

inline int operator > (const CHMchar* cp, const CHMstring& s) 
{
   return CHMstring(cp).compare(s) > 0;
};

inline int operator >= (const CHMstring& s1, const CHMstring& s2) 
{
   return s1.compare(s2) >= 0;
};

inline int operator >= (const CHMstring& s, const CHMchar* cp) 
{
   return s.compare(cp) >= 0;
};

inline int operator >= (const CHMchar* cp, const CHMstring& s) 
{
   return CHMstring(cp).compare(s) >= 0;
};

inline const CHMchar CHMstring::operator[](const size_t& pos) const 
{
#ifdef _DEBUG
   if (pos >= size())
   {
      throw "BOUNDSERROR";
   }
#endif
   return c_str()[pos];
};

inline CHMstring& CHMstring::append(const CHMstring& s,
                        const size_t& orig,
                        const size_t& n) 
{
   return append(s.c_str(), orig, n);
};

inline CHMstring& CHMstring::prepend(const CHMstring &s,
                         const size_t& orig,
                         const size_t& n) 
{
   return prepend(s.c_str(), orig, n);
};

inline CHMstring& CHMstring::insert(size_t pos,
                        const CHMstring &s,
                        const size_t& orig,
                        const size_t& n) 
{
   return insert(pos, s.c_str(), orig, n);
};

inline const CHMchar* CHMstring::c_str(void) const 
{
   if (Current == NULL)
   {
      return CHM_TEXT("");
   }
   return Current;
};

inline const CHMboolean CHMstring::is_null() const
{
   if (NULL == pReference) 
           return true;
   return size() == 0;
}

#endif

---