String.hpp

Go to the documentation of this file.

/*******************************************************************************
* Copyright (C) 2004 Vintela, Inc. All rights reserved.
* Copyright (C) 2005 Novell, Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
*  - Redistributions of source code must retain the above copyright notice,
*    this list of conditions and the following disclaimer.
*
*  - Redistributions in binary form must reproduce the above copyright notice,
*    this list of conditions and the following disclaimer in the documentation
*    and/or other materials provided with the distribution.
*
*  - Neither the name of Vintela, Inc., Novell, Inc., nor the names of its
*    contributors may be used to endorse or promote products derived from this
*    software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL Vintela, Inc., Novell, Inc., OR THE 
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*******************************************************************************/


#ifndef BLOCXX_STRING_HPP_INCLUDE_GUARD_
#define BLOCXX_STRING_HPP_INCLUDE_GUARD_
#include "blocxx/BLOCXX_config.h"
#include "blocxx/Types.hpp"
#include "blocxx/COWIntrusiveReference.hpp"
#include "blocxx/CommonFwd.hpp"
#include "blocxx/Exception.hpp"
#include <iosfwd>

namespace BLOCXX_NAMESPACE
{

BLOCXX_DECLARE_APIEXCEPTION(StringConversion, BLOCXX_COMMON_API);

class BLOCXX_COMMON_API String
{
public:
   class ByteBuf;
   String();
   explicit String(Int32 val);
   explicit String(UInt32 val);
// do this check so we fill in the gaps and have int, long & long long constructors if necessary
#if defined(BLOCXX_INT32_IS_INT) && defined(BLOCXX_INT64_IS_LONG_LONG)

   explicit String(long val);
   explicit String(unsigned long val);
#endif

   explicit String(Int64 val);
   explicit String(UInt64 val);
   explicit String(Real32 val);
   explicit String(Real64 val);
   String(const char* str);

   enum ETakeOwnershipFlag
   {
      E_TAKE_OWNERSHIP
   };
   explicit String(ETakeOwnershipFlag, char* allocatedMemory, size_t len);
   explicit String(const char* str, size_t len);
   String(const String& arg);
   explicit String(char c);
   ~String();
   void swap(String& x);
   char* allocateCString() const;
   size_t length() const;
   size_t UTF8Length() const;
   bool empty() const { return length() == 0; }
   int format(const char* fmt, ...);
   enum EReturnDelimitersFlag
   {
      E_DISCARD_DELIMITERS,
      E_RETURN_DELIMITERS
   };
   enum EEmptyTokenReturnFlag
   {
      E_SKIP_EMPTY_TOKENS,
      E_RETURN_EMPTY_TOKENS
   };
   StringArray tokenize(const char* delims = " \n\r\t\v",
      EReturnDelimitersFlag returnDelimitersAsTokens = E_DISCARD_DELIMITERS,
      EEmptyTokenReturnFlag returnEmptyTokens = E_SKIP_EMPTY_TOKENS ) const;
   const char* c_str() const;
   char charAt(size_t ndx) const;
   int compareTo(const String& arg) const;
   int compareTo(const char* arg) const;
   int compareToIgnoreCase(const String& arg) const;
   int compareToIgnoreCase(const char* arg) const;
   String& concat(const char* arg);

   String& concat(const String& arg)
   {
      return concat(arg.c_str());
   }

   String& concat(char arg);
   enum EIgnoreCaseFlag
   {
      E_CASE_SENSITIVE,
      E_CASE_INSENSITIVE
   };
   bool endsWith(const char* arg, EIgnoreCaseFlag ignoreCase = E_CASE_SENSITIVE) const;

   bool endsWith(const String& arg, EIgnoreCaseFlag ignoreCase = E_CASE_SENSITIVE) const
   {
      return endsWith(arg.c_str(), ignoreCase);
   }

   bool endsWith(char arg) const;

   bool equals(const String& arg) const;
   bool equals(const char* arg) const;
   bool equalsIgnoreCase(const String& arg) const;
   bool equalsIgnoreCase(const char* arg) const;
   UInt32 hashCode() const;
   size_t indexOf(char ch, size_t fromIndex=0) const;
   size_t indexOf(const char* arg, size_t fromIndex=0) const;
   size_t indexOf(const String& arg, size_t fromIndex=0) const
   {
      return indexOf(arg.c_str(), fromIndex);
   }

   size_t lastIndexOf(char ch, size_t fromIndex=npos) const;
   size_t lastIndexOf(const char* arg, size_t fromIndex=npos) const;
   size_t lastIndexOf(const String& arg, size_t fromIndex=npos) const
   {
      return lastIndexOf(arg.c_str(), fromIndex);
   }

   bool startsWith(const char* arg, EIgnoreCaseFlag ignoreCase = E_CASE_SENSITIVE) const;
   bool startsWith(const String& arg, EIgnoreCaseFlag ignoreCase = E_CASE_SENSITIVE) const
   {
      return startsWith(arg.c_str(), ignoreCase);
   }
   bool startsWith(char arg) const;

   String substring(size_t beginIndex,
      size_t length=npos) const;
   bool isSpaces() const;
   String& toLowerCase();
   String& toUpperCase();
   String& ltrim();
   String& rtrim();
   String& trim();
   String& erase();
   
   String& erase( size_t idx, size_t len = npos );
   String& operator= (const String & arg);
   const char& operator[] (size_t ndx) const;
   char& operator[] (size_t ndx);
   String& operator+= (const String& arg) { return concat(arg); }
   String& operator+= (const char* arg) { return concat(arg); }
   String& operator+= (char arg) { return concat(arg); }
   void readObject(std::istream& istrm);
   void writeObject(std::ostream& ostrm) const;
   String toString() const;
   Real32 toReal32() const;
   Real64 toReal64() const;
   bool toBool() const;
   UInt8 toUInt8(int base=10) const;
   Int8 toInt8(int base=10) const;
   UInt16 toUInt16(int base=10) const;
   Int16 toInt16(int base=10) const;
   UInt32 toUInt32(int base=10) const;
   Int32 toInt32(int base=10) const;
   UInt64 toUInt64(int base=10) const;
   Int64 toInt64(int base=10) const;
   unsigned int toUnsignedInt(int base=10) const;
   int toInt(int base=10) const;
   static unsigned long long int strtoull(const char* nptr, char** endptr,
      int base);
   static long long int strtoll(const char* nptr, char** endptr, int base);
   static const char* strchr(const char* theStr, int c);
   static String getLine(std::istream& istr);

#if defined(BLOCXX_AIX)
   static const size_t npos;
#else
   static const size_t npos = ~0;
#endif // BLOCXX_AIX

#ifdef BLOCXX_WIN32
#pragma warning (push)
#pragma warning (disable: 4251)
#endif

   typedef COWIntrusiveReference<ByteBuf> buf_t;
private:
   buf_t m_buf;

#ifdef BLOCXX_WIN32
#pragma warning (pop)
#endif

};
BLOCXX_EXPORT_TEMPLATE(BLOCXX_COMMON_API, Array, String);
BLOCXX_EXPORT_TEMPLATE(BLOCXX_COMMON_API, Enumeration, String);

BLOCXX_COMMON_API std::ostream& operator<< (std::ostream& ostr, const String& arg);
BLOCXX_COMMON_API String operator + (const String& s1, const String& s2);
BLOCXX_COMMON_API String operator + (const char* p, const String& s);
BLOCXX_COMMON_API String operator + (const String& s, const char* p);
BLOCXX_COMMON_API String operator + (char c, const String& s);
BLOCXX_COMMON_API String operator + (const String& s, char c);
inline bool
operator == (const String& s1, const String& s2)
{
   return (s1.compareTo(s2) == 0);
}
inline bool
operator == (const String& s, const char* p)
{
   return (s.compareTo(p) == 0);
}
inline bool
operator == (const char* p, const String& s)
{
   return (s.compareTo(p) == 0);
}
inline bool
operator != (const String& s1, const String& s2)
{
   return (s1.compareTo(s2) != 0);
}
inline bool
operator != (const String& s, const char* p)
{
   return (s.compareTo(p) != 0);
}
inline bool
operator != (const char* p, const String& s)
{
   return (s.compareTo(p) != 0);
}
inline bool
operator < (const String& s1, const String& s2)
{
   return (s1.compareTo(s2) < 0);
}
inline bool
operator < (const String& s, const char* p)
{
   return (s.compareTo(p) < 0);
}
inline bool
operator < (const char* p, const String& s)
{
   return (String(p).compareTo(s) < 0);
}
inline bool
operator <= (const String& s1, const String& s2)
{
   return (s1.compareTo(s2) <= 0);
}
inline bool
operator <= (const String& s, const char* p)
{
   return (s.compareTo(p) <= 0);
}
inline bool
operator <= (const char* p, const String& s)
{
   return (String(p).compareTo(s) <= 0);
}
inline bool
operator > (const String& s1, const String& s2)
{
   return (s1.compareTo(s2) > 0);
}
inline bool
operator > (const String& s, const char* p)
{
   return (s.compareTo(p) > 0);
}
inline bool
operator > (const char* p, const String& s)
{
   return (String(p).compareTo(s) > 0);
}
inline bool
operator >= (const String& s1, const String& s2)
{
   return (s1.compareTo(s2) >= 0);
}
inline bool
operator >= (const String& s, const char* p)
{
   return (s.compareTo(p) >= 0);
}
inline bool
operator >= (const char* p, const String& s)
{
   return (String(p).compareTo(s) >= 0);
}

} // end namespace BLOCXX_NAMESPACE

#endif

---