scilab/modules/xml/src/cpp/insertion.hxx

   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