Split the examples of polyline properties + add a new image
[scilab.git] / scilab / modules / xml / src / cpp / insertion.hpp
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2012 - Scilab Enterprises - Calixte DENIZET
4  *
5  * This file must be used under the terms of the CeCILL.
6  * This source file is licensed as described in the file COPYING, which
7  * you should have received as part of this distribution.  The terms
8  * are also available at
9  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
10  *
11  */
12
13 #ifndef __INSERTION_HPP__
14 #define __INSERTION_HPP__
15
16 #include "XMLRhsValue.hxx"
17
18 extern "C"
19 {
20 #include <stdio.h>
21 #include "gw_xml.h"
22 #include "Scierror.h"
23 #include "api_scilab.h"
24 #include "xml_mlist.h"
25 #include "localization.h"
26 }
27
28 using namespace org_modules_xml;
29
30 /*--------------------------------------------------------------------------*/
31 #define __XML_CHECK_TYPE__(TYPEIN,REQUIREDTYPE,FIELD) if (typeid(TYPEIN) != typeid(REQUIREDTYPE)) \
32     {                                                                   \
33         Scierror(999, gettext("%s: Wrong type to set %s field.\n"), fname, FIELD); \
34         return false;                                                   \
35     }
36 /*--------------------------------------------------------------------------*/
37
38 /**
39  * Sets the properties of a XMLDocument
40  * A value will have the type T
41  * @param fname function name
42  * @param doc the XMLDocument
43  * @param field te field name
44  * @param value the new value
45  */
46 template <class T>
47 bool setProperty(char * fname, org_modules_xml::XMLDocument & doc, const char * field, T & value)
48 {
49     if (!strcmp("root", field))
50     {
51         if (typeid(T &) != typeid(XMLElement &) && typeid(T &) != typeid(std::string &))
52         {
53             Scierror(999, gettext("%s: Wrong type to set %s field.\n"), fname, "root");
54             return false;
55         }
56         if (typeid(T &) == typeid(XMLElement &))
57         {
58             doc.setRoot((XMLElement &)value);
59         }
60         else
61         {
62             std::string error;
63             doc.setRoot((std::string &)value, &error);
64             if (!error.empty())
65             {
66                 Scierror(999, gettext("%s: Not valid xml for root.\n"), fname);
67                 return false;
68             }
69         }
70     }
71     else if (!strcmp("url", field))
72     {
73         __XML_CHECK_TYPE__(T &, std::string &, "url");
74         doc.setDocumentURL((std::string &)value);
75     }
76     else
77     {
78         Scierror(999, gettext("%s: Unknown field: %s\n"), fname, field);
79         return false;
80     }
81
82     return true;
83 }
84 /*--------------------------------------------------------------------------*/
85
86 /**
87  * Sets the properties of a XMLElement
88  * A value will have the type T
89  * @param fname function name
90  * @param elem the XMLElement
91  * @param field te field name
92  * @param value the new value
93  */
94 template <class T>
95 bool setProperty(char * fname, XMLElement & elem, const char * field, T & value)
96 {
97     if (!strcmp("name", field))
98     {
99         __XML_CHECK_TYPE__(T &, std::string &, "name");
100         elem.setNodeName((std::string &)value);
101     }
102     else if (!strcmp("namespace", field))
103     {
104         __XML_CHECK_TYPE__(T &, XMLNs &, "namespace");
105         elem.setNodeNameSpace((XMLNs &)value);
106     }
107     else if (!strcmp("content", field))
108     {
109         __XML_CHECK_TYPE__(T &, std::string &, "content");
110         elem.setNodeContent((std::string &)value);
111     }
112     else if (!strcmp("type", field))
113     {
114         Scierror(999, gettext("%s: Field %s is not modifiable: %s\n"), fname, "type");
115         return false;
116     }
117     else if (!strcmp("parent", field))
118     {
119         Scierror(999, gettext("%s: Field %s is not modifiable: %s\n"), fname, "parent");
120         return false;
121     }
122     else if (!strcmp("attributes", field))
123     {
124         __XML_CHECK_TYPE__(T &, XMLAttr &, "attributes");
125         elem.setAttributes((XMLAttr &)value);
126     }
127     else if (!strcmp("children", field))
128     {
129         if (typeid(T &) != typeid(XMLElement &) && typeid(T &) != typeid(XMLNodeList &) && typeid(T &) != typeid(std::string &))
130         {
131             Scierror(999, gettext("%s: Wrong type to set %s field.\n"), fname, "children");
132             return false;
133         }
134         if (typeid(T &) == typeid(XMLElement &))
135         {
136             elem.setChildren((XMLElement &)value);
137         }
138         else if (typeid(T &) == typeid(XMLNodeList &))
139         {
140             elem.setChildren((XMLNodeList &)value);
141         }
142         else
143         {
144             elem.setChildren((std::string &)value);
145         }
146     }
147     else
148     {
149         Scierror(999, gettext("%s: Unknown field: %s\n"), fname, field);
150         return false;
151     }
152
153     return true;
154 }
155 /*--------------------------------------------------------------------------*/
156
157 /**
158  * Function to handle insertion in different XMLObjects
159  * @param fname the function name
160  * @param fname_len the function name length
161  */
162 template<class T, class U>
163 int sci_insertion(char * fname, void* pvApiCtx)
164 {
165     T * a;
166     U * b;
167     int lhsid;
168     SciErr err;
169     int * fieldaddr = 0;
170     int * rhsaddr = 0;
171     int * lhsaddr = 0;
172     char * field = 0;
173     bool success;
174
175     CheckLhs(1, 1);
176     CheckRhs(3, 3);
177
178     err = getVarAddressFromPosition(pvApiCtx, 1, &fieldaddr);
179     if (err.iErr)
180     {
181         printError(&err, 0);
182         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
183         return 0;
184     }
185
186     if (!isStringType(pvApiCtx, fieldaddr))
187     {
188         Scierror(999, gettext("%s: Wrong type for input argument #%i: A string expected.\n"), fname, 1);
189         return 0;
190     }
191
192     err = getVarAddressFromPosition(pvApiCtx, 2, &rhsaddr);
193     if (err.iErr)
194     {
195         printError(&err, 0);
196         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
197         return 0;
198     }
199
200     err = getVarAddressFromPosition(pvApiCtx, 3, &lhsaddr);
201     if (err.iErr)
202     {
203         printError(&err, 0);
204         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 3);
205         return 0;
206     }
207
208     if (getAllocatedSingleString(pvApiCtx, fieldaddr, &field) != 0)
209     {
210         Scierror(999, _("%s: No more memory.\n"), fname);
211         return 0;
212     }
213     lhsid = getXMLObjectId(lhsaddr, pvApiCtx);
214
215     a = XMLObject::getFromId<T>(lhsid);
216     if (!a)
217     {
218         freeAllocatedSingleString(field);
219         Scierror(999, gettext("%s: XML object does not exist.\n"), fname);
220         return 0;
221     }
222
223     success = XMLRhsValue::get(fname, rhsaddr, &b, pvApiCtx);
224     if (!success)
225     {
226         freeAllocatedSingleString(field);
227         Scierror(999, gettext("%s: Error in getting rhs argument.\n"), fname);
228         return 0;
229     }
230
231     success = setProperty<U>(fname, *a, const_cast<char *>(field), *b);
232     freeAllocatedSingleString(field);
233
234     if (typeid(U) == typeid(std::string))
235     {
236         delete b;
237     }
238
239     if (a->createOnStack(Rhs + 1, pvApiCtx))
240     {
241         LhsVar(1) = Rhs + 1;
242     }
243     else
244     {
245         LhsVar(1) = 0;
246     }
247
248     PutLhsVar();
249
250     return 0;
251 }
252
253 #endif