String.h

Go to the documentation of this file.

/*
Copyright 2007-2025. Algoryx Simulation AB.
 
All AGX source code, intellectual property, documentation, sample code,
tutorials, scene files and technical white papers, are copyrighted, proprietary
and confidential material of Algoryx Simulation AB. You may not download, read,
store, distribute, publish, copy or otherwise disseminate, use or expose this
material unless having a written signed agreement with Algoryx Simulation AB, or having been
advised so by Algoryx Simulation AB for a time limited evaluation, or having purchased a
valid commercial license from Algoryx Simulation AB.
 
Algoryx Simulation AB disclaims all responsibilities for loss or damage caused
from using this software, unless otherwise stated in written agreements with
Algoryx Simulation AB.
*/
 
 
#ifndef AGX_STRING_H
#define AGX_STRING_H
 
 
#include <agx/Integer.h>
#include <agx/Real.h>
#include <agx/Vector.h>
 
#include <string>
 
 
namespace agx
{
  template<typename T = std::string> class AgXString;
 
#ifndef SWIG
  typedef Vector<AgXString<std::string> > StringVector;
#else
  typedef Vector<String> StringVector;
#endif
 
  template<typename T>
  class AgXString : public T
  {
    public:
      typedef std::string::size_type      size_type;
      typedef std::string::iterator       iterator;
      typedef std::string::const_iterator const_iterator;
 
    public:
      AgXString();
 
      AgXString( const AgXString& str );
 
      AgXString( const std::string& str );
 
      AgXString( const char* str );
 
      AgXString( size_type length, char ch );
 
      AgXString( const char* str, size_type length );
 
      AgXString( const char* str, size_type index, size_type length );
 
      AgXString( const_iterator begin, const_iterator end );
 
      AgXString operator + ( const AgXString& other ) const;
 
      AgXString operator + ( const char* other ) const;
 
      AgXString operator + ( const char elem ) const;
 
      AgXString copy() const;
 
      AgXString substr( size_type index ) const;
 
      AgXString substr( size_type index, size_type length ) const;
 
      static AgXString format( const char* format, ... );
      static AgXString formatVA( const char* format, va_list ap);
 
      bool operator== (const AgXString& other) const;
 
      bool operator== (const std::string& other) const;
 
      bool operator== (const char* other) const;
 
      bool operator!= (const std::string& other) const;
 
      bool operator!= (const char* other) const;
 
      /* Pystring extensions */
      // Copyright (c) 2008, Sony Pictures Imageworks
      // 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 the organization Sony Pictures Imageworks 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 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.
 
#define MAX_32BIT_INT 2147483647
 
      AgXString capitalize() const;
 
      AgXString center(int width) const;
 
      int count(const AgXString& substr, int start = 0, int end = MAX_32BIT_INT) const;
 
      bool endswith(const AgXString& suffix, int start = 0, int end = MAX_32BIT_INT) const;
      bool endswithCI(const AgXString& suffix, int start = 0, int end = MAX_32BIT_INT) const;
 
      AgXString expandtabs(int tabsize = 8) const;
 
      bool contains(const AgXString& sub, size_t start = 0) const;
 
      int index(const AgXString& sub, int start = 0, int end = MAX_32BIT_INT) const;
 
      bool isalnum() const;
 
      bool isalpha() const;
 
      bool isdigit() const;
 
      bool islower() const;
 
      bool isspace() const;
 
      bool istitle() const;
 
      bool isupper() const;
 
      AgXString ljust(int width) const;
 
      AgXString lower() const;
 
      AgXString lstrip(const AgXString& chars = "") const;
 
      AgXString stripLeadingString(const AgXString& toBeRemoved) const;
 
      void partition(const AgXString& sep, StringVector& result ) const;
 
      AgXString replace(const AgXString& oldstr, const AgXString& newstr, int count = -1) const;
 
      size_t find(const AgXString& sub, int start = 0, int end = MAX_32BIT_INT ) const;
 
      size_t rfind(const AgXString& sub, int start = 0, int end = MAX_32BIT_INT ) const;
 
      AgXString rjust(int width) const;
 
      void rpartition(const AgXString& sep, StringVector& result ) const;
 
      AgXString rstrip(const AgXString& chars = "") const;
 
      void split(StringVector& result, const AgXString& sep = "", int maxsplit = -1) const;
 
      void rsplit(StringVector& result, const AgXString& sep = "", int maxsplit = -1) const;
 
      void splitlines(StringVector& result, bool keepends = false ) const;
 
      bool startswith(const AgXString& prefix, int start = 0, int end = MAX_32BIT_INT ) const;
      bool startswithCI(const AgXString& prefix, int start = 0, int end = MAX_32BIT_INT ) const;
 
      AgXString strip(const AgXString& chars = "") const;
 
      AgXString swapcase() const;
 
      AgXString title() const;
 
      AgXString translate(const AgXString& table, const AgXString& deletechars = "") const;
 
      AgXString upper() const;
 
      AgXString zfill(int width) const;
 
      AgXString slice(int start = 0, int end = MAX_32BIT_INT) const;
  };
 
#ifndef SWIG
  typedef AgXString<std::string> String;
#endif
 
  AGXCORE_EXPORT const agx::String& getEmptyString();
 
  // Utility function to print bit patterns
  // NOTE: Ignores endianess, handles data as a block of bytes
  template <typename T>
  agx::String printBin(const T& val);
 
  template <typename T>
  agx::String printHex(const T& val);
 
  agx::String AGXCORE_EXPORT printBin(const void* data, UInt numBytes);
  agx::String AGXCORE_EXPORT printHex(const void* data, UInt numBytes);
 
 
  // Specializations for basic types, handles endianess
  agx::String AGXCORE_EXPORT printBin(UInt32 val);
  agx::String AGXCORE_EXPORT printBin(UInt64 val);
  agx::String AGXCORE_EXPORT printBin(Real32 val);
  agx::String AGXCORE_EXPORT printBin(Real64 val);
 
  agx::String AGXCORE_EXPORT printHex(UInt32 val);
  agx::String AGXCORE_EXPORT printHex(UInt64 val);
  agx::String AGXCORE_EXPORT printHex(Real32 val);
  agx::String AGXCORE_EXPORT printHex(Real64 val);
 
} // namespace agx
 
 
#include <pystring/pystring.h>
 
namespace agx
{
 
  template<typename T>
  inline AgXString<T> AgXString<T>::format(const char* format, ...)
  {
    va_list ap;
    va_start(ap, format);
    AgXString<T> result = AgXString<T>::formatVA(format, ap);
    va_end(ap);
    return result;
  }
 
  template<typename T>
  inline AgXString<T> AgXString<T>::formatVA(const char* format, va_list ap)
  {
    char* buf = 0;
 
#ifdef _MSC_VER
    int len = _vscprintf( format, ap ) + 1;
    buf = (char*) malloc( len * sizeof(char) );
    if (buf)
      vsprintf_s( buf, len, format, ap );
#else
    int ret = vasprintf(&buf, format, ap);
    agxVerifyN(ret >= 0, "Could not allocate memory for formatted string: \'%s\'", format);
#endif
 
    agxAssert(buf);
    if (buf) {
      AgXString<T> result(buf);
      free(buf);
 
      return result;
    }
    else
      return AgXString<T>(); // Fall back.
  }
 
  // Implementation
 
  template <typename T>
  inline AgXString<T>::AgXString() : T()
  {
 
  }
 
  template <typename T>
  inline AgXString<T>::AgXString( const AgXString<T>& str )
    : T( str )
 
  {
  }
 
  template <typename T>
  inline AgXString<T>::AgXString( const std::string& str )
    : T( str )
  {
  }
 
  template <typename T>
  inline AgXString<T>::AgXString( const char* str )
    : T( str )
  {
  }
 
  template <typename T>
  inline AgXString<T>::AgXString( size_type length, char ch )
    : T( length, ch )
  {
  }
 
  template <typename T>
  inline AgXString<T>::AgXString( const char* str, size_type length )
    : T( str, length )
 
  {
  }
 
  template <typename T>
  inline AgXString<T>::AgXString( const char* str, size_type index, size_type length )
    : T( str, index, length )
 
  {
  }
 
  template <typename T>
  inline AgXString<T>::AgXString( const_iterator begin, const_iterator end )
    : T( begin, end )
  {
  }
 
  template <typename T>
  inline AgXString<T> AgXString<T>::operator + ( const AgXString<T>& other ) const
  {
    AgXString ret = *this;
    ret += other;
    return ret;
  }
 
  template <typename T>
  inline AgXString<T> AgXString<T>::operator + ( const char* other ) const
  {
    AgXString ret = *this;
    ret += other;
    return ret;
  }
 
  template <typename T>
  inline AgXString<T>  AgXString<T>::operator + ( const char elem ) const
  {
    AgXString ret = *this;
    ret += elem;
    return ret;
  }
 
  template <typename T>
  inline AgXString<T> AgXString<T>::copy() const
  {
    return AgXString( *this );
  }
 
  template <typename T>
  inline AgXString<T> AgXString<T>::substr( size_type index ) const
  {
    return AgXString( this->c_str(), index, this->size() );
  }
 
  template <typename T>
  inline AgXString<T> AgXString<T>::substr( size_type index, size_type length ) const
  {
    return AgXString( this->c_str(), index, length );
  }
 
  template <typename T>
  AGX_FORCE_INLINE bool AgXString<T>::operator== (const AgXString<T>& other) const
  {
    return static_cast<const std::string&>(*this) == static_cast<const std::string&>(other);
  }
 
  template <typename T>
  AGX_FORCE_INLINE bool AgXString<T>::operator== (const std::string& other) const
  {
    return *(std::string*)this == other;
  }
 
  template <typename T>
  AGX_FORCE_INLINE bool AgXString<T>::operator== (const char* other) const
  {
    return *(std::string*)this == other;
  }
 
  template <typename T>
  AGX_FORCE_INLINE bool AgXString<T>::operator!= (const std::string& other) const
  {
    return *(std::string*)this != other;
  }
 
  template <typename T>
  AGX_FORCE_INLINE bool AgXString<T>::operator!= (const char* other) const
  {
    return *(std::string*)this != other;
  }
 
 
 
  template<typename T>
  AgXString<T> operator + ( const char* str1, const AgXString<T>& str2 )
  {
    return AgXString<T>( str1 ) + str2;
  }
 
  template<typename T>
  AgXString<T> operator + ( const char elem, const AgXString<T>& str )
  {
    return AgXString<T>( 1, elem ) + str;
  }
 
  template<typename T>
  inline bool AgXString<T>::contains(const AgXString<T>& sub, size_t start) const
  {
    return this->find(sub, int(start)) != AgXString<T>::npos;
  }
 
 
  template<typename T>
  AgXString<T> AgXString<T>::capitalize() const
  {
    return pystring::capitalize(*this);
  }
 
  template<typename T>
  AgXString<T> AgXString<T>::center(int width) const
  {
    return pystring::center(*this, width);
  }
 
  template<typename T>
  int AgXString<T>::count(const AgXString<T>& substr, int start, int end) const
  {
    return pystring::count(*this, substr, start, end);
  }
 
  template<typename T>
  bool AgXString<T>::endswith(const AgXString<T>& suffix, int start, int end) const
  {
    return pystring::endswith(*this, suffix, start, end);
  }
 
  template<typename T>
  bool AgXString<T>::endswithCI(const AgXString<T>& suffix, int start, int end) const
  {
    return pystring::endswithCI(*this, suffix, start, end);
  }
 
  template<typename T>
  AgXString<T> AgXString<T>::expandtabs(int tabsize) const
  {
    return pystring::expandtabs(*this, tabsize);
  }
 
  /*
  int AgXString<T>::find(const AgXString<T>& sub, int start, int end) const
  {
    return pystring::find(*this, sub, start, end);
  }
  */
 
  template<typename T>
  int AgXString<T>::index(const AgXString<T>& sub, int start, int end) const
  {
    return pystring::index(*this, sub, start, end);
  }
 
  template<typename T>
  bool AgXString<T>::isalnum() const
  {
    return pystring::isalnum(*this);
  }
 
  template<typename T>
  bool AgXString<T>::isalpha() const
  {
    return pystring::isalpha(*this);
  }
 
  template<typename T>
  bool AgXString<T>::isdigit() const
  {
    return pystring::isdigit(*this);
  }
 
  template<typename T>
  bool AgXString<T>::islower() const
  {
    return pystring::islower(*this);
  }
 
  template<typename T>
  bool AgXString<T>::isspace() const
  {
    return pystring::isspace(*this);
  }
 
  template<typename T>
  bool AgXString<T>::istitle() const
  {
    return pystring::istitle(*this);
  }
 
  template<typename T>
  bool AgXString<T>::isupper() const
  {
    return pystring::isupper(*this);
  }
 
 
  template<typename T>
  AgXString<T> AgXString<T>::ljust(int width) const
  {
    return pystring::ljust(*this, width);
  }
 
  template<typename T>
  AgXString<T> AgXString<T>::lower() const
  {
    return pystring::lower(*this);
  }
 
 
  template<typename T>
  AgXString<T> AgXString<T>::stripLeadingString(const AgXString<T>& toBeRemoved) const
  {
    std::size_t start = this->find(toBeRemoved); // Find the string to be removed
    if (start == 0 ) {// Did we find it, and its from the start of the string?
      if (T::length() > toBeRemoved.size()) {
        return this->substr(toBeRemoved.size(), T::length() ); // Remove it.
      } else
        return "";
    }
    return *this;
  }
 
 
  template<typename T>
  AgXString<T> AgXString<T>::lstrip(const AgXString<T>& chars) const
  {
    return pystring::lstrip(*this, chars);
  }
 
  template<typename T>
  void AgXString<T>::partition(const AgXString<T>& sep, StringVector& result ) const
  {
    return pystring::partition(*this, sep, result);
  }
 
  template<typename T>
  AgXString<T> AgXString<T>::replace(const AgXString<T>& oldstr, const AgXString<T>& newstr, int count) const
  {
    return pystring::replace(*this, oldstr, newstr, count);
  }
 
  template<typename T>
  size_t AgXString<T>::find(const AgXString<T>& sub, int start, int end) const
  {
    int index = pystring::find(*this, sub, start, end);
    return index < 0 ? AgXString<T>::npos : (size_t)index;
  }
 
  template<typename T>
  size_t AgXString<T>::rfind(const AgXString<T>& sub, int start, int end) const
  {
    int index = pystring::rfind(*this, sub, start, end);
    return index < 0 ? AgXString<T>::npos : (size_t)index;
  }
 
 
  template<typename T>
  AgXString<T> AgXString<T>::rjust(int width) const
  {
    return pystring::rjust(*this, width);
  }
 
  template<typename T>
  void AgXString<T>::rpartition(const AgXString<T>& sep, StringVector& result ) const
  {
    return pystring::rpartition(*this, sep, result);
  }
 
  template<typename T>
  AgXString<T> AgXString<T>::rstrip(const AgXString<T>& chars) const
  {
    return pystring::rstrip(*this, chars);
  }
 
  template<typename T>
  void AgXString<T>::split(StringVector& result, const AgXString<T>& sep, int maxsplit) const
  {
    return pystring::split(*this, result, sep, maxsplit);
  }
 
  template<typename T>
  void AgXString<T>::rsplit(StringVector& result, const AgXString<T>& sep, int maxsplit) const
  {
    return pystring::rsplit(*this, result, sep, maxsplit);
  }
 
  template<typename T>
  void AgXString<T>::splitlines(StringVector& result, bool keepends) const
  {
    return pystring::splitlines(*this, result, keepends);
  }
 
  template<typename T>
  bool AgXString<T>::startswith(const AgXString<T>& prefix, int start, int end) const
  {
    return pystring::startswith(*this, prefix, start, end);
  }
 
  template<typename T>
  bool AgXString<T>::startswithCI(const AgXString<T>& prefix, int start, int end) const
  {
    return pystring::startswithCI(*this, prefix, start, end);
  }
 
  template<typename T>
  AgXString<T> AgXString<T>::strip(const AgXString<T>& chars) const
  {
    if (this->size() == 0)
      return *this;
 
    return pystring::strip(*this, chars);
  }
 
  template<typename T>
  AgXString<T> AgXString<T>::swapcase() const
  {
    return pystring::swapcase(*this);
  }
 
  template<typename T>
  AgXString<T> AgXString<T>::title() const
  {
    return pystring::title(*this);
  }
 
  template<typename T>
  AgXString<T> AgXString<T>::translate(const AgXString<T>& table, const AgXString<T>& deletechars) const
  {
    return pystring::translate(*this, table, deletechars);
  }
 
  template<typename T>
  AgXString<T> AgXString<T>::upper() const
  {
    return pystring::upper(*this);
  }
 
  template<typename T>
  AgXString<T> AgXString<T>::zfill(int width) const
  {
    return pystring::zfill(*this, width);
  }
 
  template<typename T>
  AgXString<T> AgXString<T>::slice(int start, int end) const
  {
    return pystring::slice(*this, start, end);
  }
 
 
  template <typename T>
  agx::String printBin(const T& val)
  {
    return printBin(&val, sizeof(T));
  }
 
  template <typename T>
  agx::String printHex(const T& val)
  {
    return printHex(&val, sizeof(T));
  }
 
}
 
namespace std
{
  AGX_FORCE_INLINE void swap(agx::String& lhs, agx::String& rhs)
  {
    std::swap(static_cast<std::string&>(lhs), static_cast<std::string&>(rhs));
  }
}
 
 
#endif /* _AGX_STRING_H_ */