UString.h

Go to the documentation of this file.

//---------------------------------------------------------------------------------------
// Copyright (c) 2001-2012 by PDFTron Systems Inc. All Rights Reserved.
// Consult legal.txt regarding legal and license information.
//---------------------------------------------------------------------------------------

#ifndef   H_CPPPDFTRON_UNISTRING
#define   H_CPPPDFTRON_UNISTRING

#include <Common/BasicTypes.h>
#include <Common/Exception.h>
#include <C/Common/TRN_Types.h>
#include <C/Common/TRN_UString.h>
#include <Common/Common.h>
#include <ostream>

namespace pdftron { 

class UString
{
public:

         UString();

         UString(const UString& str);

         explicit UString(Unicode value);

         UString(const Unicode* value);

         UString(const Unicode* value, int length);

        enum TextEncoding {
                e_ascii_enc = 0,   
                e_pdfdoc_enc,      
                e_winansii_enc,    
                e_pdftext_enc,     
                e_utf16be_enc,     
                e_utf8,            
                e_no_enc           
        };

         UString(const char* buf, int buf_sz = -1, TextEncoding enc = e_utf8);

        UString(const std::string & str, TextEncoding enc = e_utf8);

        UString( const std::wstring& value );

        ~UString();

         UString& operator=(const UString& str);
         UString& operator=(const char* ascii_str);

         UString& Assign(const UString& uni);
         UString& Assign(const Unicode* uni, int buf_sz = -1);
         UString& Assign2(const char* buf, int buf_sz = -1, TextEncoding enc = e_utf8);

         UString& operator+=(const UString& str);

         UString Concat(const UString &str) const;

        friend UString operator+( const UString& str1, const UString& str2) { return str1.Concat(str2);}

         int GetLength() const;

         bool Empty() const;

         const Unicode* GetBuffer() const;

         int Compare(const UString& str, int max_length = -1) const;

        /* 
         * Copies a substring of at most some number of characters from a string 
         * beginning from a specified position.
         *
         * @param off An index locating the element at the position from which 
         * the copy of the string is made, with a default value of 0.
         * 
         * @param count The number of characters that are to be copied if they 
         * are present. -1 means copy the entire string.
         *
         * @return A substring object that is a copy of elements of the string operand 
         * beginning at the position specified by the first argument.
         */
         UString SubStr(int off = 0, int count = -1) const;

         Unicode GetAt(int idx) const;

         void PushBack(Unicode ch);

         void Resize(int count, Unicode ch = ' ');

        void ToUpper();

        void ToLower();

         void Reserve(int count);

         const Unicode* CStr() const;
        
         bool IsInAscii() const;

         int ConvertToAscii(char* in_out_buf, int buf_sz, bool null_term) const;

         int ConvertToUtf8(char* in_out_buf, int buf_sz, bool null_term) const; 

        int ConvertToUtf32( UInt32* out_buf, int buf_sz, bool null_term ) const;

        std::wstring ConvertToNativeWString() const;

         std::string ConvertToAscii() const; 

        std::string ConvertToUtf8() const;

        std::basic_string<UInt32> ConvertToUtf32() const;

         int ConvertToPDFText(char* in_out_buf, int buf_sz, bool force_unicode = false) const;

         friend bool operator == (const UString& rStr1, const UString& rStr2) { return rStr1.GetLength() == rStr2.GetLength() && rStr1.Compare( rStr2 ) == 0; }
         friend bool operator == (const UString& rStr1, const Unicode* pStr2) { return rStr1.Compare( pStr2 ) == 0; }
         friend bool operator == (const Unicode* pStr1, const UString& rStr2) { return UString( pStr1 ).Compare( rStr2 ) == 0; }
         friend bool operator != (const UString& rStr1, const UString& rStr2) { return !(operator == ( rStr1, rStr2 )); }
         friend bool operator != (const UString& rStr1, const Unicode* pStr2) { return !(operator == ( rStr1, pStr2 )); }
         friend bool operator != (const Unicode* pStr1, const UString& rStr2) { return !(operator == ( pStr1, rStr2 )); }
         friend bool operator <  (const UString& rStr1, const UString& rStr2) { return rStr1.Compare( rStr2 ) < 0; }
         friend bool operator >  (const UString& rStr1, const UString& rStr2) { return rStr1.Compare( rStr2 ) > 0; }
         friend bool operator <= (const UString& rStr1, const UString& rStr2) { return rStr1.Compare( rStr2 ) <= 0; }
         friend bool operator >= (const UString& rStr1, const UString& rStr2) { return rStr1.Compare( rStr2 ) >= 0; }
        
// private:
        UString(TRN_UString impl);
        TRN_UString mp_impl;  

};


inline std::ostream& operator<<(std::ostream& stream, const UString& str) {
        return stream << str.ConvertToAscii();
}


#include <Impl/UString.inl>


};      // namespace pdftron

#endif // H_CPPPDFTRON_UNISTRING

---

© 2002-2012 PDFTron Systems Inc.