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