String.hpp

Go to the documentation of this file.

/*******************************************************************************
* Copyright (C) 2005, Vintela, Inc. All rights reserved.
* Copyright (C) 2006, 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., 
*       nor Novell, Inc., 
*       nor the names of its contributors or employees 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 THE COPYRIGHT OWNER OR 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>
#include <string>
 
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);
   explicit String(const Char16Array& ra) BLOCXX_DEPRECATED;
   explicit String(Bool parm) BLOCXX_DEPRECATED;
   explicit String(const Char16& parm) BLOCXX_DEPRECATED;
   explicit String(const std::string& 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 size() const { return length(); }
   size_t UTF8Length() const;
   bool empty() const { return length() == 0; }
   int format(const char* fmt, ...);
   enum EReturnDelimitersFlag
   {
      E_DISCARD_TOKENS, // deprecated in 3.1.0
      E_RETURN_TOKENS, // deprecated in 3.1.0
      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;
   BLOCXX_DEPRECATED const char* getBytes() const  {  return c_str(); }
   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::streambuf & istrm);
   void writeObject(std::streambuf & ostrm) const;
   String toString() const;
   Char16 toChar16() const BLOCXX_DEPRECATED;
   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 = size_t(~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