1 /******************************************************************************
2 *
3 * Copyright 2016, Fuzhou Rockchip Electronics Co.Ltd. All rights reserved.
4 * No part of this work may be reproduced, modified, distributed, transmitted,
5 * transcribed, or translated into any language or computer format, in any form
6 * or by any means without written permission of:
7 * Fuzhou Rockchip Electronics Co.Ltd .
8 *
9 *
10 *****************************************************************************/
11 /**
12 * @file xmltags.cpp
13 *
14 *****************************************************************************/
15
16 #include "calibtags.h"
17 #include "xmltags.h"
18 #include <string>
19 #include <iostream>
20
21 /******************************************************************************
22 * class XmlTag
23 *****************************************************************************/
24
25 /******************************************************************************
26 * XmlTag::XmlTag
27 *****************************************************************************/
XmlTag(const XMLElement * e)28 XmlTag::XmlTag( const XMLElement* e )
29 : m_Element( e )
30 {
31 }
32
33
34
35 /******************************************************************************
36 * XmlTag::XmlTag
37 *****************************************************************************/
Size()38 int XmlTag::Size()
39 {
40 const XMLAttribute* pattr = m_Element->FindAttribute(CALIB_ATTRIBUTE_SIZE);
41 const char* c_string = pattr->Value();
42
43 int col;
44 int row;
45
46 int res = sscanf(c_string, CALIB_ATTRIBUTE_SIZE_FORMAT, &row, &col);
47 if (res != CALIB_ATTRIBUTE_SIZE_NO_ELEMENTS)
48 {
49 return (0);
50 }
51
52 return ((col * row));
53 }
54
SizeRow()55 int XmlTag::SizeRow()
56 {
57 const XMLAttribute* pattr = m_Element->FindAttribute(CALIB_ATTRIBUTE_SIZE);
58 const char* c_string = pattr->Value();
59
60 int col;
61 int row;
62
63 int res = sscanf(c_string, CALIB_ATTRIBUTE_SIZE_FORMAT, &row, &col);
64 if (res != CALIB_ATTRIBUTE_SIZE_NO_ELEMENTS)
65 {
66 return (0);
67 }
68
69 return (row);
70 }
71
SizeCol()72 int XmlTag::SizeCol()
73 {
74 const XMLAttribute* pattr = m_Element->FindAttribute(CALIB_ATTRIBUTE_SIZE);
75 const char* c_string = pattr->Value();
76
77 int col;
78 int row;
79
80 int res = sscanf(c_string, CALIB_ATTRIBUTE_SIZE_FORMAT, &row, &col);
81 if (res != CALIB_ATTRIBUTE_SIZE_NO_ELEMENTS)
82 {
83 return (0);
84 }
85
86 return (col);
87 }
88
89
90
91 /******************************************************************************
92 * XmlTag::Value
93 *****************************************************************************/
Value()94 const char* XmlTag::Value()
95 {
96 const char* text = m_Element->GetText();
97 char* pstr_start = (char*)text;
98 int len = 0;
99 char* pstr_last = pstr_start;
100
101 #if 0
102 if (pstr_start) {
103 len = strlen(pstr_start);
104 pstr_last = (char*)text + len - 1;
105
106 while ((*pstr_start == '\n' || *pstr_start == '\r' || *pstr_start == 0x20 || *pstr_start == 0x09) && (pstr_start != pstr_last)) {
107 pstr_start++;
108 }
109
110 while ((*pstr_last == '\n' || *pstr_last == '\r' || *pstr_last == 0x20 || *pstr_last == 0x09) && (pstr_start != pstr_last)) {
111 pstr_last--;
112 }
113
114 len = pstr_last - pstr_start;
115 }
116
117 if (len) {
118 *(pstr_last + 1) = '\0';
119 }
120 #else
121 /* above code cannot process the case: there is only one valide charactor,such as "A \n\r" */
122 if (pstr_start) {
123 len = strlen(pstr_start);
124 pstr_last = (char*)text + len - 1;
125
126 while ((*pstr_start == '\n' || *pstr_start == '\r' || *pstr_start == 0x20 || *pstr_start == 0x09) && (pstr_start != pstr_last)) {
127 pstr_start++;
128 }
129
130 while ((*pstr_last == '\n' || *pstr_last == '\r' || *pstr_last == 0x20 || *pstr_last == 0x09) && (pstr_start != pstr_last)) {
131 *pstr_last = '\0';
132 pstr_last--;
133 }
134 }
135 #endif
136
137 return pstr_start ;
138 }
139
140
141 /******************************************************************************
142 * XmlTag::ValueTonUInt
143 *****************************************************************************/
ValueToUInt(bool * ok)144 unsigned int XmlTag::ValueToUInt( bool *ok )
145 {
146 const char* value = Value();
147 unsigned int v = 0;
148
149 //*ok = XMLUtil::ToUnsigned(value, &v);
150 if(sscanf(value, "%x", &v) == 1)
151 *ok = true;
152 else
153 *ok = false;
154
155 return ( v );
156 }
157
158
159
160 /******************************************************************************
161 * XmlTag::Type
162 *****************************************************************************/
Type()163 XmlTag::TagType_e XmlTag::Type()
164 {
165 const XMLAttribute *pattr = m_Element->FindAttribute( CALIB_ATTRIBUTE_TYPE );
166 std::string s_value(pattr->Value());
167
168 if ( s_value == CALIB_ATTRIBUTE_TYPE_CHAR )
169 {
170 return ( TAG_TYPE_CHAR );
171 }
172 else if ( s_value == CALIB_ATTRIBUTE_TYPE_DOUBLE )
173 {
174 return ( TAG_TYPE_DOUBLE );
175 }
176 else if ( s_value == CALIB_ATTRIBUTE_TYPE_STRUCT )
177 {
178 return ( TAG_TYPE_STRUCT );
179 }
180 else if ( s_value == CALIB_ATTRIBUTE_TYPE_CELL )
181 {
182 return ( TAG_TYPE_CELL );
183 }
184 else if ( s_value == CALIB_ATTRIBUTE_TYPE_INT )
185 {
186 return ( TAG_TYPE_INT );
187 }
188 else
189 {
190 return ( TAG_TYPE_INVALID );
191 }
192
193 return ( TAG_TYPE_INVALID );
194 }
195
196
197
198 /******************************************************************************
199 * XmlTag::isType
200 *****************************************************************************/
isType(const XmlTag::TagType_e type)201 bool XmlTag::isType
202 (
203 const XmlTag::TagType_e type
204 )
205 {
206 const XMLAttribute* pattr = m_Element->FindAttribute( CALIB_ATTRIBUTE_TYPE );
207 std::string s_value(pattr->Value());
208
209 if ( s_value == CALIB_ATTRIBUTE_TYPE_CHAR )
210 {
211 return ( (bool)(TAG_TYPE_CHAR == type) );
212 }
213 else if ( s_value == CALIB_ATTRIBUTE_TYPE_DOUBLE )
214 {
215 return ( (bool)(TAG_TYPE_DOUBLE == type) );
216 }
217 else if ( s_value == CALIB_ATTRIBUTE_TYPE_STRUCT )
218 {
219 return ( (bool)(TAG_TYPE_STRUCT == type) );
220 }
221 else if ( s_value == CALIB_ATTRIBUTE_TYPE_CELL )
222 {
223 return ( (bool)(TAG_TYPE_CELL == type) );
224 }
225 else if ( s_value == CALIB_ATTRIBUTE_TYPE_INT )
226 {
227 return ( (bool)(TAG_TYPE_INT == type) );
228 }
229 else
230 {
231 return ( (bool)(TAG_TYPE_INVALID == type) );
232 }
233
234 return ( false );
235 }
236
237
238
239 /******************************************************************************
240 * class XmlCellTag
241 *****************************************************************************/
242
243 /******************************************************************************
244 * XmlCellTag::XmlCellTag
245 *****************************************************************************/
XmlCellTag(const XMLElement * e)246 XmlCellTag::XmlCellTag( const XMLElement *e )
247 : XmlTag( e )
248 {
249 }
250
251
252
253 /******************************************************************************
254 * XmlCellTag::XmlTag
255 *****************************************************************************/
Index()256 int XmlCellTag::Index()
257 {
258 int value = 0;
259
260 const XMLAttribute *pattr = m_Element->FindAttribute( CALIB_ATTRIBUTE_INDEX );
261 if ( !pattr )
262 {
263 pattr->QueryIntValue(&value);
264 }
265
266 return ( value );
267
268 #if 0
269 int res = 0;
270 res = m_Element.QueryIntAttribute(CALIB_ATTRIBUTE_INDEX, &value);
271 if(res == XML_NO_ATTRIBUTE)
272 return err;
273 else
274 return ( value );
275 #endif
276
277 }
278
279
280