Add an info log in Terminate()
[platform/framework/native/appfw.git] / inc / FTextUcs2Encoding.h
1 //
2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
3 //
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
7 //
8 //     http://www.apache.org/licenses/LICENSE-2.0
9 //
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.
15 //
16
17 /**
18  * @file                FTextUcs2Encoding.h
19  * @brief               This is the header file for the %Ucs2Encoding class.
20  *
21  * This header file contains the declarations of the %Ucs2Encoding class.
22  * This class is derived from the Encoding class.
23  */
24 #ifndef _FTEXT_UCS2_ENCODING_H_
25 #define _FTEXT_UCS2_ENCODING_H_
26
27 #include <FTextEncoding.h>
28
29
30 namespace Tizen { namespace Text
31 {
32 /**
33  * @class       Ucs2Encoding
34  * @brief       This class is an implementation of the UCS-2 encoding.
35  *
36  * @since       2.0
37  *
38  * @final       This class is not intended for extension.
39  *
40  * The %Ucs2Encoding class is an implementation of the UCS-2 encoding.
41  * Universal Character Set (UCS2) is a two-octet per character encoding type with a fixed width.
42  * UCS2 prepares several characters in advance to output the needed information fast.
43  * When printing out characters, users can avail different types of character sets.
44  *
45  *  For more information on the class features, see <a href="../org.tizen.native.appprogramming/html/guide/text/converting_all_text_data.htm">Converting All Text Data at Once</a>.
46  *
47  * The following example demonstrates how to use the %Ucs2Encoding class.
48  *
49  *  @code
50  *      #include <FBase.h>
51  *      #include <FText.h>
52  *
53  *      using namespace Tizen::Base;
54  *      using namespace Tizen::Text;
55  *
56  *      void
57  *      MyClass::Ucs2EncodingSample(void)
58  *      {
59  *              Ucs2Encoding ucs2;
60  *
61  *              String str(L"(\u03a0) and (\u03a3)"); // sigma and pi
62  *
63  *              int byteCount;
64  *              ucs2.GetByteCount(str, byteCount);
65  *
66  *              // Encodes
67  *              ByteBuffer* pBuffer = ucs2.GetBytesN(str);
68  *
69  *              int charCount;
70  *              ucs2.GetCharCount(*pBuffer, charCount);
71  *
72  *              // Decodes
73  *              String decodedStr;
74  *              ucs2.GetString(*pBuffer, decodedStr);
75  *
76  *              if (str.Equals(decodedStr))
77  *              {
78  *                      //....
79  *              }
80  *
81  *              delete pBuffer;
82  *      }
83  *
84  * @endcode
85  *
86  */
87
88 class _OSP_EXPORT_ Ucs2Encoding
89         : public Encoding
90 {
91 public:
92         /**
93          * This is the default constructor for this class.
94          *
95          * @since       2.0
96          */
97         Ucs2Encoding(void);
98
99         /**
100          * This is the destructor for this class. @n
101          * This destructor overrides Tizen::Text::Encoding::~Encoding().
102          *
103          * @since       2.0
104          */
105         virtual ~Ucs2Encoding(void);
106
107         /**
108          * Gets the total number of bytes that are generated by encoding an instance of Tizen::Base::String.
109          *
110          * @since                               2.0
111          *
112          * @return                      An error code
113          * @param[in]           str                      A string to encode
114          * @param[out]  byteCount                    The total number of bytes required to encode the string
115          * @exception           E_SUCCESS                The method is successful.
116          * @exception           E_INVALID_ARG            A specified input parameter is invalid, or
117          *                                           the specified @c str is an empty string.
118          * @exception           E_INVALID_ENCODING_RANGE The specified string contains code points that are outside the bounds of the character encoding scheme.
119          * @remarks     This method determines the exact number of bytes
120          *              that are produced if the given string is encoded.
121          * @see         GetMaxByteCount()
122          */
123         virtual result GetByteCount(const Tizen::Base::String& str, int& byteCount) const;
124
125         /**
126          * Gets the total number of bytes that are generated by encoding an instance of Tizen::Base::WcharBuffer.
127          *
128          * @since                               2.0
129          *
130          * @return                      An error code
131          * @param[in]           chars                 An instance of Tizen::Base::WcharBuffer to encode
132          * @param[out]  byteCount                 The total number of bytes required to encode the specified range of characters
133          * @exception           E_SUCCESS             The method is successful.
134          * @exception           E_INVALID_ARG         A specified input parameter is invalid, or
135          *                                        the specified @c chars is empty.
136          * @exception           E_INVALID_ENCODING_RANGE The specified string contains code points that are outside the bounds of the character encoding scheme.
137          * @remarks     This method determines the exact number of bytes
138          *              that are produced if the given array of characters is encoded.
139          * @see         GetMaxByteCount()
140          */
141         virtual result GetByteCount(const Tizen::Base::WcharBuffer& chars, int& byteCount) const;
142
143         /**
144          * Gets the total number of bytes that are required to encode a range of characters in the specified Tizen::Base::WcharBuffer instance.
145          *
146          * @since                               2.0
147          *
148          * @return                      An error code
149          * @param[in]           chars                 An instance of Tizen::Base::WcharBuffer to encode
150          * @param[in]           charIndex             The index from where encoding begins in the Tizen::Base::WcharBuffer instance
151          * @param[in]   charCount                   The total number of characters to encode
152          * @param[out]  byteCount                 The total number of bytes required to encode the specified range of characters
153          * @exception           E_SUCCESS                The method is successful.
154          * @exception           E_INVALID_ARG            A specified input parameter is invalid, or
155          *                                         the specified @c chars is empty.
156          * @exception           E_OUT_OF_RANGE               The value of an argument is outside the valid range defined by the method, or
157          *                                                                                   the length of the specified @c charIndex or @c charCount is greater than the length of the specified @c chars.
158          * @exception   E_UNDERFLOW              This operation has caused the memory to underflow, or
159          *                                                                               the sum of the length of the specified @c charIndex and @c charCount is greater than the length of the specified @c chars.
160          * @exception           E_INVALID_ENCODING_RANGE The specified string contains code points that are outside the bounds of the character encoding scheme.
161          * @remarks     This method determines the exact number of bytes
162          *              that are produced if the given array of characters is encoded.
163          * @see                 GetMaxByteCount()
164          */
165         virtual result GetByteCount(const Tizen::Base::WcharBuffer& chars, int charIndex, int charCount, int& byteCount) const;
166
167
168         /**
169          * Encodes an instance of Tizen::Base::WcharBuffer into an instance of Tizen::Base::ByteBuffer.
170          *
171          * @since                       2.0
172          *
173          * @return                      A pointer to the Tizen::Base::ByteBuffer instance where the resultant encoded string is stored, @n
174          *                      else @c null if an exception occurs @n
175          *                                              The buffer limit is the position of the last encoded byte plus one and the starting position is zero.
176          * @param[in]   chars                    An instance of Tizen::Base::WcharBuffer to encode
177          * @exception   E_SUCCESS                The method is successful.
178          * @exception   E_OUT_OF_MEMORY          The memory is insufficient.
179          * @exception   E_INVALID_ARG            The specified @c chars is empty or invalid.
180          * @exception   E_INVALID_ENCODING_RANGE The specified string contains code points that are outside the bounds of the character encoding scheme.
181          * @remarks             The specific error code can be accessed using the GetLastResult() method.
182          * @see                         GetCharsN()
183          */
184         virtual Tizen::Base::ByteBuffer* GetBytesN(const Tizen::Base::WcharBuffer& chars) const;
185
186         /**
187          * Encodes an instance of Tizen::Base::String into an instance of Tizen::Base::ByteBuffer.
188          *
189          * @since                       2.0
190          *
191          * @return                                      A pointer to the Tizen::Base::ByteBuffer instance where the resultant encoded string is stored, @n
192          *                                      else @c null if an exception occurs @n
193          *                                              The buffer limit is the position of the last encoded byte plus one and the starting position is zero.
194          * @param[in]   str                      A string to encode
195          * @exception       E_SUCCESS                The method is successful.
196          * @exception   E_OUT_OF_MEMORY          The memory is insufficient.
197          * @exception   E_INVALID_ARG            The specified @c str is empty or invalid.
198          * @exception   E_INVALID_ENCODING_RANGE The specified string contains code points that are outside the bounds of the character encoding scheme.
199          * @remarks             The specific error code can be accessed using the GetLastResult() method.
200          * @see                         GetString()
201          */
202         virtual Tizen::Base::ByteBuffer* GetBytesN(const Tizen::Base::String& str) const;
203
204         /**
205          * Encodes an instance of Tizen::Base::WcharBuffer into an instance of Tizen::Base::ByteBuffer as per the specified range. @n
206          * The position and limit of the pointer to the %Tizen::Base::ByteBuffer instance is not changed.
207          *
208          * @since                       2.0
209          *
210          * @return              An error code
211          * @param[in]   chars                    An instance of Tizen::Base::WcharBuffer to encode
212          * @param[in]   charIndex                The index from where encoding begins in the Tizen::Base::WcharBuffer instance
213          * @param[in]   charCount                  The total number of characters to encode
214          * @param[out]  bytes                    The Tizen::Base::ByteBuffer instance where the resultant encoded string is stored
215          * @param[in]   byteIndex                  The starting index of the resultant encoding in the Tizen::Base::ByteBuffer instance
216          * @exception   E_SUCCESS                The method is successful.
217          * @exception   E_OUT_OF_MEMORY          The memory is insufficient.
218          * @exception   E_INVALID_ARG            A specified input parameter is invalid, or
219          *                                         the specified @c chars or @c bytes is empty.
220          * @exception   E_OUT_OF_RANGE          The value of an argument is outside the valid range defined by the method, or
221          *                                         the length of the specified @c charIndex or @c charCount is greater than the length of the specified @c chars.
222          * @exception E_UNDERFLOW                    This operation has caused the memory to underflow, or
223          *                                         the sum of the length of the specified @c charIndex and @c charCount is greater than the length of the specified @c chars.
224          * @exception   E_OVERFLOW               This operation has caused the memory to overflow, or
225          *                                         the specified @c bytes does not contain sufficient space to store the encoded characters.
226          * @exception   E_INVALID_ENCODING_RANGE The specified string contains code points that are outside the bounds of the character encoding scheme.
227          * @remarks     This method encodes a range of characters in a Tizen::Base::WcharBuffer into a range of bytes in a Tizen::Base::ByteBuffer.
228          * @see                         GetChars()
229          */
230         virtual result GetBytes(const Tizen::Base::WcharBuffer& chars, int charIndex, int charCount,
231                 Tizen::Base::ByteBuffer& bytes, int byteIndex = 0) const;
232
233         /**
234          * Encodes an instance of Tizen::Base::String into an instance of Tizen::Base::ByteBuffer as per the specified range. @n
235          * The position and limit of the pointer to the %Tizen::Base::ByteBuffer instance is not changed.
236          *
237          * @since                       2.0
238          *
239          * @return              An error code
240          * @param[in]   str                       A string to encode
241          * @param[in]   charIndex                 The index from where encoding begins in the Tizen::Base::WcharBuffer instance
242          * @param[in]   charCount                   The total number of characters to encode
243          * @param[out]  bytes                     The Tizen::Base::ByteBuffer instance where the resultant encoded string is stored
244          * @param[in]   byteIndex                   The starting index of the resultant encoding in the Tizen::Base::ByteBuffer instance
245          * @exception   E_SUCCESS                The method is successful.
246          * @exception   E_OUT_OF_MEMORY          The memory is insufficient.
247          * @exception   E_INVALID_ARG            A specified input parameter is invalid, or
248          *                                       the specified @c str or @c bytes is empty.
249          * @exception   E_OUT_OF_RANGE                   The value of an argument is outside the valid range defined by the method, or
250          *                                         the length of the specified @c charIndex or @c charCount is greater than the length of the specified @c str.
251          * @exception   E_UNDERFLOW              This operation has caused the memory to underflow, or
252          *                                                                                 the sum of the length of the specified @c charIndex and @c charCount is greater than the length of the specified @c str.
253          * @exception   E_OVERFLOW               This operation has caused the memory to overflow, or
254          *                                                                                 the specified @c bytes does not contain sufficient space to store the encoded characters.
255          * @exception   E_INVALID_ENCODING_RANGE The specified string contains code points that are outside the bounds of the character encoding scheme.
256          * @see                         GetString()
257          */
258         virtual result GetBytes(const Tizen::Base::String& str, int charIndex, int charCount,
259                 Tizen::Base::ByteBuffer& bytes, int byteIndex = 0) const;
260
261         /**
262          * Gets the total number of characters that are generated by decoding an instance of Tizen::Base::ByteBuffer.
263          *
264          * @since                       2.0
265          *
266          * @return              An error code
267          * @param[in]   bytes                    An instance of Tizen::Base::ByteBuffer to decode
268          * @param[out]  charCount               The total number of characters that are generated by decoding the specified Tizen::Base::ByteBuffer instance
269          * @exception   E_SUCCESS                The method is successful.
270          * @exception   E_INVALID_ARG            A specified input parameter is invalid, or
271          *                                         the specified @c bytes is empty.
272          * @exception   E_INVALID_ENCODING_RANGE The specified string contains code points that are outside the bounds of the character encoding scheme.
273          * @remarks     This method determines the exact number of characters
274          *              that are produced if the given range of bytes is converted.
275          * @see                         GetMaxCharCount()
276          */
277         virtual result GetCharCount(const Tizen::Base::ByteBuffer& bytes, int& charCount) const;
278
279         /**
280          * Gets the total number of characters that are generated by decoding a range of elements specified in the Tizen::Base::ByteBuffer instance.
281          *
282          * @since                       2.0
283          *
284          * @return              An error code
285          * @param[in]   bytes                    An instance of Tizen::Base::ByteBuffer to decode
286          * @param[in]   byteIndex                The index from where decoding begins
287          * @param[in]   byteCount                The total number of bytes to decode
288          * @param[out]  charCount                The total number of characters that are generated by decoding the specified Tizen::Base::ByteBuffer instance
289          * @exception   E_SUCCESS                The method is successful.
290          * @exception   E_INVALID_ARG            A specified input parameter is invalid, or
291          *                                         the specified @c bytes is empty.
292          * @exception   E_OUT_OF_RANGE          The value of an argument is outside the valid range defined by the method, or
293          *                                                                                 the length of the specified @c byteIndex or @c byteCount is greater than the length of the specified @c bytes.
294          * @exception   E_UNDERFLOW              This operation has caused the memory to underflow, or
295          *                                                                         the sum of the length of the specified @c byteIndex and @c byteCount is greater than the length of the specified @c bytes.
296          * @exception   E_INVALID_ENCODING_RANGE The specified string contains code points that are outside the bounds of the character encoding scheme.
297          * @remarks     This method determines the exact number of characters
298          *              that are produced if the given range of bytes is converted.
299          * @see                         GetMaxCharCount()
300          */
301         virtual result GetCharCount(const Tizen::Base::ByteBuffer& bytes, int byteIndex, int byteCount, int& charCount) const;
302
303         /**
304          *Decodes an instance of Tizen::Base::ByteBuffer into an instance of Tizen::Base::WcharBuffer.
305          *
306          * @since                       2.0
307          *
308          * @return                                   A pointer to the Tizen::Base::WcharBuffer instance where the resultant decoded data is stored, @n
309          *                                   else @c null if an exception occurs @n
310          *                                              The buffer limit is the position of the last decoded byte plus one and the starting position is zero.
311          * @param[in]   bytes                An instance of Tizen::Base::ByteBuffer to decode
312          * @exception   E_SUCCESS                The method is successful.
313          * @exception   E_OUT_OF_MEMORY          The memory is insufficient.
314          * @exception   E_INVALID_ARG            The specified @c bytes is empty or invalid.
315          * @exception   E_INVALID_ENCODING_RANGE The specified string contains code points that are outside the bounds of the character encoding scheme.
316          * @remarks             The specific error code can be accessed using the GetLastResult() method.
317          * @see                         GetBytesN()
318          */
319         virtual Tizen::Base::WcharBuffer* GetCharsN(const Tizen::Base::ByteBuffer& bytes) const;
320
321         /**
322          * Decodes an instance of Tizen::Base::ByteBuffer into an instance of Tizen::Base::WcharBuffer as per the specified range. @n
323          * The position and limit of the pointer to the %Tizen::Base::WcharBuffer instance is not changed.
324          *
325          * @since                       2.0
326          *
327          * @return              An error code
328          * @param[in]   bytes                    An instance of Tizen::Base::ByteBuffer to decode
329          * @param[in]   byteIndex                The index from where decoding begins
330          * @param[in]   byteCount                The total number of bytes to decode
331          * @param[out]  chars                    The Tizen::Base::WcharBuffer instance where the resultant decoded data is stored
332          * @param[in]   charIndex                The index from where encoding begins in the Tizen::Base::WcharBuffer instance
333          * @exception   E_SUCCESS                The method is successful.
334          * @exception   E_OUT_OF_MEMORY          The memory is insufficient.
335          * @exception   E_INVALID_ARG            A specified input parameter is invalid, or
336          *                                        the specified @c bytes or @ chars is empty.
337          * @exception   E_OUT_OF_RANGE           The value of an argument is outside the valid range defined by the method, or
338          *                                                                             the length of the specified @c byteIndex or @c byteCount is greater than the length of the specified @c bytes.
339          * @exception   E_UNDERFLOW                  This operation has caused the memory to underflow, or
340          *                                                                                 the sum of the length of the specified @c byteIndex and @c byteCount is greater than the length of the specified @c bytes.
341          * @exception E_OVERFLOW                     This operation has caused the memory to overflow, or
342          *                                                                                the specified @c chars does not contain sufficient space to store the decoded bytes.
343          * @exception   E_INVALID_ENCODING_RANGE The specified string contains code points that are outside the bounds of the character encoding scheme.
344          * @see                         GetBytes()
345          */
346         virtual result GetChars(const Tizen::Base::ByteBuffer& bytes, int byteIndex, int byteCount,
347                 Tizen::Base::WcharBuffer& chars, int charIndex = 0) const;
348
349         /**
350          * Gets a string containing the decoded representation of the specified Tizen::Base::ByteBuffer instance.
351          *
352          * @since                       2.0
353          *
354          * @return              An error code
355          * @param[in]   bytes                  An instance of Tizen::Base::ByteBuffer to decode
356          * @param[out]  str                    A Tizen::Base::String instance @n
357          *                                     It contains the decoded representation of the specified Tizen::Base::ByteBuffer instance.
358          * @exception   E_SUCCESS                The method is successful.
359          * @exception   E_OUT_OF_MEMORY          The memory is insufficient.
360          * @exception   E_INVALID_ARG            A specified input parameter is invalid, or
361          *                                         the specified @c bytes is empty.
362          * @exception   E_INVALID_ENCODING_RANGE The specified string contains code points that are outside the bounds of the character encoding scheme.
363          * @see                         GetBytesN()
364          */
365         virtual result GetString(const Tizen::Base::ByteBuffer& bytes, Tizen::Base::String& str) const;
366
367         /**
368          * Gets a string containing the decoded representation of the specified Tizen::Base::ByteBuffer instance.
369          *
370          * @since                       2.0
371          *
372          * @return              An error code
373          * @param[in]   bytes                     An instance of Tizen::Base::ByteBuffer to decode
374          * @param[in]   index                     The index from where decoding begins
375          * @param[in]   count                     The total number of bytes to decode
376          * @param[out]  str                       A Tizen::Base::String instance @n
377          *                                       It contains the decoded representation of the specified Tizen::Base::ByteBuffer instance.
378          * @exception   E_SUCCESS                The method is successful.
379          * @exception   E_OUT_OF_MEMORY          The memory is insufficient.
380          * @exception   E_INVALID_ARG            A specified input parameter is invalid, or
381          *                                         the specified @c bytes is empty.
382          * @exception   E_OUT_OF_RANGE           The value of an argument is outside the valid range defined by the method, or
383          *                                                                                 the sum of the length of the specified @c index and @c count is greater than the length of the specified @c bytes.
384          * @exception   E_UNDERFLOW                              This operation has caused the memory to underflow, or
385          *                                                                                 the sum of the length of the specified @c index and @c count is greater than the length of the specified @c bytes.
386          * @exception   E_INVALID_ENCODING_RANGE The specified string contains code points that are outside the bounds of the character encoding scheme.
387          * @see                         GetBytesN()
388          */
389         virtual result GetString(const Tizen::Base::ByteBuffer& bytes, int index, int count, Tizen::Base::String& str) const;
390
391
392         /**
393         * Gets the maximum number of bytes required for encoding a given number of characters.
394         *
395         * @since                        2.0
396         *
397         * @return               The maximum number of bytes required for encoding the given number of characters
398         * @param[in]    charCount The total number of characters to encode
399         * @remarks   This method determines an appropriate buffer size for the byte arrays passed to GetBytes() for encoding.
400         * @see                          GetByteCount()
401         * @see                          GetBytes()
402         */
403         virtual int GetMaxByteCount(int charCount) const;
404
405
406         /**
407         * Gets the maximum number of characters that are generated by decoding the specified number of bytes.
408         *
409         * @since                                2.0
410         *
411         * @return                       The maximum number of characters generated by decoding the specified number of bytes
412         * @param[in]            byteCount The total number of bytes to encode
413         * @remarks     This method determines an appropriate buffer size for the character arrays passed to
414         *                   GetChars() or a decoder for encoding.
415         * @see                                  GetByteCount()
416         * @see                                  GetChars()
417         */
418         virtual int GetMaxCharCount(int byteCount) const;
419
420
421         /**
422          * Gets the encoder for the current encoding.
423          *
424          * @since                               2.0
425          *
426          * @return                      A pointer to the Encoder instance for the current encoding
427          * @remarks     Contrary to GetBytes(), an encoder can convert partial sequences of characters into
428          *              partial sequences of bytes by maintaining the appropriate state between the conversions.
429          *              Currently only Utf8Encoding supports this method. Other classes return @c null.
430          * @see                                 GetBytes()
431          */
432         virtual Encoder* GetEncoderN(void) const;
433
434
435         /**
436          * Gets the decoder for the current encoding.
437          *
438          * @since                               2.0
439          *
440          * @return                      A pointer to the Decoder instance for the current encoding
441          * @remarks     Contrary to GetChars(), a decoder can convert partial sequences of bytes
442          *              into partial sequences of characters by maintaining the appropriate state between the conversions.
443          *              Currently only Utf8Encoding supports this method. Other classes return @c null.
444          *
445          * @see                                 GetChars()
446          */
447         virtual Decoder* GetDecoderN(void) const;
448
449         /**
450         * Gets the encoding type of the current instance.
451         *
452         * @since                        2.0
453         *
454         * @return               An encoding type
455         */
456         virtual Tizen::Base::String GetEncodingType(void) const;
457
458 private:
459         /**
460          * The implementation of this copy constructor is intentionally blank and declared as private to
461          * prohibit copying of objects.
462          */
463         Ucs2Encoding(const Ucs2Encoding& ucs2Encoding);
464
465         /**
466          * The implementation of this copy assignment operator is intentionally blank and declared as private
467          * to prohibit copying of objects.
468          */
469         Ucs2Encoding& operator =(const Ucs2Encoding& ucs2Encoding);
470
471         friend class _Ucs2EncodingImpl;
472         class _Ucs2EncodingImpl* __pUcs2EncodingImpl;
473 };
474
475 } } // Tizen::Text
476 #endif //_FTEXT_UCS2_ENCODING_H_