2 * Copyright 2001-2009 Internet2
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
18 * @file xmltooling/unicode.h
20 * Helper classes and types for manipulating Unicode
23 #ifndef __xmltooling_unicode_h__
24 #define __xmltooling_unicode_h__
26 #include <xmltooling/base.h>
29 # include <xmltooling/char_traits.h>
34 #include <xercesc/util/XMLString.hpp>
36 namespace xmltooling {
40 * An STL string type that supports 16-bit Unicode.
42 typedef std::basic_string<XMLCh> xstring;
45 * An STL string type that supports 16-bit Unicode.
47 typedef std::basic_string< XMLCh,char_traits<XMLCh> > xstring;
51 * Transcodes a 16-bit Unicode string into UTF-8.
53 * @param src the 16-bit string to transcode
54 * @param use_malloc true iff the result should be allocated with malloc, false to use new
55 * @return a UTF-8 string allocated by the Xerces memory manager
57 extern XMLTOOL_API char* toUTF8(const XMLCh* src, bool use_malloc=false);
60 * Transcodes a UTF-8 string into 16-bit Unicode.
62 * @param src the UTF-8 string to transcode
63 * @param use_malloc true iff the result should be allocated with malloc, false to use new
64 * @return a 16-bit Unicode string allocated by the Xerces memory manager
66 extern XMLTOOL_API XMLCh* fromUTF8(const char* src, bool use_malloc=false);
69 * Writes a Unicode string to an ASCII stream by transcoding to UTF8.
71 * @param ostr stream to write to
72 * @param s string to write
73 * @return reference to output stream
75 extern XMLTOOL_API std::ostream& operator<<(std::ostream& ostr, const XMLCh* s);
78 * Writes a Unicode string to an ASCII stream by transcoding to UTF8.
80 * @param ostr stream to write to
81 * @param s string to write
82 * @return reference to output stream
84 extern XMLTOOL_API std::ostream& operator<<(std::ostream& ostr, const xstring& s);
87 * A minimal auto_ptr-like class that can copy or transcode a buffer into
88 * the local code page and free the result automatically.
90 * Needed because a standard auto_ptr would use delete on the resulting
93 class XMLTOOL_API auto_ptr_char
95 MAKE_NONCOPYABLE(auto_ptr_char);
98 * Default constructor.
100 auto_ptr_char() : m_buf(NULL) {
104 * Constructor transcodes a 16-bit Unicode string into the local code page (NOT UTF-8) and wraps the result.
105 * @param src the 16-bit string to transcode and wrap
106 * @param trim trims leading/trailing whitespace from the result (defaults to true)
108 auto_ptr_char(const XMLCh* src, bool trim=true) : m_buf(xercesc::XMLString::transcode(src)) {
109 if (trim && m_buf) xercesc::XMLString::trim(m_buf);
113 * Constructor copies a local code page (NOT UTF-8) string and wraps the result.
114 * @param src the local string to copy and wrap
115 * @param trim trims leading/trailing whitespace from the result (defaults to true)
117 auto_ptr_char(const char* src, bool trim=true) : m_buf(xercesc::XMLString::replicate(src)) {
118 if (trim && m_buf) xercesc::XMLString::trim(m_buf);
122 * Destructor frees the wrapped buffer using the Xerces memory manager.
125 xercesc::XMLString::release(&m_buf);
129 * Returns the wrapped buffer.
130 * @return a null-terminated local code page string
132 const char* get() const {
137 * Returns the wrapped buffer and transfers ownership of it to the caller.
138 * @return a null-terminated local code page string
141 char* temp=m_buf; m_buf=NULL; return temp;
149 * A minimal auto_ptr-like class that can copy or transcode a buffer into
150 * 16-bit Unicode and free the result automatically.
152 * Needed because a standard auto_ptr would use delete on the resulting
155 class XMLTOOL_API auto_ptr_XMLCh
157 MAKE_NONCOPYABLE(auto_ptr_XMLCh);
160 * Default constructor.
162 auto_ptr_XMLCh() : m_buf(NULL) {
166 * Constructor transcodes a local code page (NOT UTF-8) string into 16-bit Unicode and wraps the result.
167 * @param src the local string to transcode and wrap
168 * @param trim trims leading/trailing whitespace from the result (defaults to true)
170 auto_ptr_XMLCh(const char* src, bool trim=true) : m_buf(xercesc::XMLString::transcode(src)) {
171 if (trim && m_buf) xercesc::XMLString::trim(m_buf);
175 * Constructor copies a 16-bit Unicode string and wraps the result.
176 * @param src the Unicode string to copy and wrap
177 * @param trim trims leading/trailing whitespace from the result (defaults to true)
179 auto_ptr_XMLCh(const XMLCh* src, bool trim=true) : m_buf(xercesc::XMLString::replicate(src)) {
180 if (trim && m_buf) xercesc::XMLString::trim(m_buf);
184 * Destructor frees the wrapped buffer using the Xerces memory manager.
187 xercesc::XMLString::release(&m_buf);
191 * Returns the wrapped buffer.
192 * @return a null-terminated Unicode string
194 const XMLCh* get() const {
199 * Returns the wrapped buffer and transfers ownership of it to the caller.
200 * @return a null-terminated Unicode string
203 XMLCh* temp=m_buf; m_buf=NULL; return temp;
211 * An auto_ptr that uses array delete on its contents.
213 * @param T type of pointer to wrap
215 template <typename T> class auto_arrayptr
219 auto_arrayptr(const auto_arrayptr<T>&);
220 auto_arrayptr<T>& operator=(const auto_arrayptr<T>&);
225 * @param ptr pointer to wrap
227 auto_arrayptr(T* ptr) : m_ptr(ptr) {
231 * Destructor, uses array delete operation on wrapped pointer.
238 * Returns the wrapped pointer.
239 * @return the wrapped pointer
241 const T* get() const {
246 * Returns the wrapped pointer and transfers ownership of it to the caller.
247 * @return the wrapped pointer
250 T* temp=m_ptr; m_ptr=NULL; return temp;
255 #endif /* __xmltooling_unicode_h__ */