← Back to branch summary

~alinuxninja/nginx-edge/trunk

« back to all changes in this revision

Viewing changes to debian/modules/ngx_pagespeed/psol/include/third_party/icu/source/common/unicode/ucnv_cb.h

  • Committer: Vivian
  • Date: 2015-12-04 18:20:11 UTC
  • Revision ID: git-v1:a36f2bc32e884f7473b3a47040e5411306144d7d
* Do not extract psol.tar.gz

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/modules/ngx_pagespeed/psol/include/third_party/icu/source/common/unicode/ucnv_cb.h
1
 
/*
2
 
**********************************************************************
3
 
*   Copyright (C) 2000-2004, International Business Machines
4
 
*   Corporation and others.  All Rights Reserved.
5
 
**********************************************************************
6
 
 *  ucnv_cb.h:
7
 
 *  External APIs for the ICU's codeset conversion library
8
 
 *  Helena Shih
9
 
 * 
10
 
 * Modification History:
11
 
 *
12
 
 *   Date        Name        Description
13
 
 */
14
 
 
15
 
/**
16
 
 * \file 
17
 
 * \brief C UConverter functions to aid the writers of callbacks
18
 
 *
19
 
 * <h2> Callback API for UConverter </h2>
20
 
 * 
21
 
 * These functions are provided here for the convenience of the callback
22
 
 * writer. If you are just looking for callback functions to use, please
23
 
 * see ucnv_err.h.  DO NOT call these functions directly when you are 
24
 
 * working with converters, unless your code has been called as a callback
25
 
 * via ucnv_setFromUCallback or ucnv_setToUCallback !!
26
 
 * 
27
 
 * A note about error codes and overflow.  Unlike other ICU functions,
28
 
 * these functions do not expect the error status to be U_ZERO_ERROR.
29
 
 * Callbacks must be much more careful about their error codes.
30
 
 * The error codes used here are in/out parameters, which should be passed
31
 
 * back in the callback's error parameter.
32
 
 * 
33
 
 * For example, if you call ucnv_cbfromUWriteBytes to write data out 
34
 
 * to the output codepage, it may return U_BUFFER_OVERFLOW_ERROR if 
35
 
 * the data did not fit in the target. But this isn't a failing error, 
36
 
 * in fact, ucnv_cbfromUWriteBytes may be called AGAIN with the error
37
 
 * status still U_BUFFER_OVERFLOW_ERROR to attempt to write further bytes,
38
 
 * which will also go into the internal overflow buffers.
39
 
 * 
40
 
 * Concerning offsets, the 'offset' parameters here are relative to the start
41
 
 * of SOURCE.  For example, Suppose the string "ABCD" was being converted 
42
 
 * from Unicode into a codepage which doesn't have a mapping for 'B'.
43
 
 * 'A' will be written out correctly, but
44
 
 * The FromU Callback will be called on an unassigned character for 'B'.
45
 
 * At this point, this is the state of the world:
46
 
 *    Target:    A [..]     [points after A]
47
 
 *    Source:  A B [C] D    [points to C - B has been consumed]
48
 
 *             0 1  2  3 
49
 
 *    codePoint = "B"       [the unassigned codepoint] 
50
 
 * 
51
 
 * Now, suppose a callback wants to write the substitution character '?' to
52
 
 * the target. It calls ucnv_cbFromUWriteBytes() to write the ?. 
53
 
 * It should pass ZERO as the offset, because the offset as far as the 
54
 
 * callback is concerned is relative to the SOURCE pointer [which points 
55
 
 * before 'C'.]  If the callback goes into the args and consumes 'C' also,
56
 
 * it would call FromUWriteBytes with an offset of 1 (and advance the source
57
 
 * pointer).
58
 
 *
59
 
 */
60
 
 
61
 
#ifndef UCNV_CB_H
62
 
#define UCNV_CB_H
63
 
 
64
 
#include "unicode/utypes.h"
65
 
 
66
 
#if !UCONFIG_NO_CONVERSION
67
 
 
68
 
#include "unicode/ucnv.h"
69
 
#include "unicode/ucnv_err.h"
70
 
 
71
 
/**
72
 
 * ONLY used by FromU callback functions.
73
 
 * Writes out the specified byte output bytes to the target byte buffer or to converter internal buffers.
74
 
 *
75
 
 * @param args callback fromUnicode arguments
76
 
 * @param source source bytes to write
77
 
 * @param length length of bytes to write
78
 
 * @param offsetIndex the relative offset index from callback.
79
 
 * @param err error status. If <TT>U_BUFFER_OVERFLOW</TT> is returned, then U_BUFFER_OVERFLOW <STRONG>must</STRONG> 
80
 
 * be returned to the user, because it means that not all data could be written into the target buffer, and some is 
81
 
 * in the converter error buffer.
82
 
 * @see ucnv_cbFromUWriteSub
83
 
 * @stable ICU 2.0
84
 
 */
85
 
U_STABLE void U_EXPORT2
86
 
ucnv_cbFromUWriteBytes (UConverterFromUnicodeArgs *args,
87
 
                        const char* source,
88
 
                        int32_t length,
89
 
                        int32_t offsetIndex,
90
 
                        UErrorCode * err);
91
 
 
92
 
/**
93
 
 * ONLY used by FromU callback functions.  
94
 
 * This function will write out the correct substitution character sequence 
95
 
 * to the target.
96
 
 *
97
 
 * @param args callback fromUnicode arguments
98
 
 * @param offsetIndex the relative offset index from the current source pointer to be used
99
 
 * @param err error status. If <TT>U_BUFFER_OVERFLOW</TT> is returned, then U_BUFFER_OVERFLOW <STRONG>must</STRONG> 
100
 
 * be returned to the user, because it means that not all data could be written into the target buffer, and some is 
101
 
 * in the converter error buffer.
102
 
 * @see ucnv_cbFromUWriteBytes
103
 
 * @stable ICU 2.0
104
 
 */
105
 
U_STABLE void U_EXPORT2 
106
 
ucnv_cbFromUWriteSub (UConverterFromUnicodeArgs *args,
107
 
                      int32_t offsetIndex,
108
 
                      UErrorCode * err);
109
 
 
110
 
/**
111
 
 * ONLY used by fromU callback functions.  
112
 
 * This function will write out the error character(s) to the target UChar buffer.
113
 
 *
114
 
 * @param args callback fromUnicode arguments
115
 
 * @param source pointer to pointer to first UChar to write [on exit: 1 after last UChar processed]
116
 
 * @param sourceLimit pointer after last UChar to write
117
 
 * @param offsetIndex the relative offset index from callback which will be set
118
 
 * @param err error status <TT>U_BUFFER_OVERFLOW</TT>
119
 
 * @see ucnv_cbToUWriteSub
120
 
 * @stable ICU 2.0
121
 
 */
122
 
U_STABLE void U_EXPORT2 ucnv_cbFromUWriteUChars(UConverterFromUnicodeArgs *args,
123
 
                             const UChar** source,
124
 
                             const UChar*  sourceLimit,
125
 
                             int32_t offsetIndex,
126
 
                             UErrorCode * err);
127
 
 
128
 
/**
129
 
 * ONLY used by ToU callback functions.
130
 
 *  This function will write out the specified characters to the target 
131
 
 * UChar buffer.
132
 
 *
133
 
 * @param args callback toUnicode arguments
134
 
 * @param source source string to write
135
 
 * @param length the length of source string
136
 
 * @param offsetIndex the relative offset index which will be written.
137
 
 * @param err error status <TT>U_BUFFER_OVERFLOW</TT>
138
 
 * @see ucnv_cbToUWriteSub
139
 
 * @stable ICU 2.0
140
 
 */
141
 
U_STABLE void U_EXPORT2 ucnv_cbToUWriteUChars (UConverterToUnicodeArgs *args,
142
 
                                             const UChar* source,
143
 
                                             int32_t length,
144
 
                                             int32_t offsetIndex,
145
 
                                             UErrorCode * err);
146
 
 
147
 
/**
148
 
 * ONLY used by ToU  callback functions.  
149
 
 * This function will write out the Unicode substitution character (U+FFFD).
150
 
 *
151
 
 * @param args callback fromUnicode arguments
152
 
 * @param offsetIndex the relative offset index from callback.
153
 
 * @param err error status <TT>U_BUFFER_OVERFLOW</TT>
154
 
 * @see ucnv_cbToUWriteUChars
155
 
 * @stable ICU 2.0
156
 
 */
157
 
U_STABLE void U_EXPORT2 ucnv_cbToUWriteSub (UConverterToUnicodeArgs *args,
158
 
                       int32_t offsetIndex,
159
 
                       UErrorCode * err);
160
 
#endif
161
 
 
162
 
#endif