void asn1DOMTest_CancellationNoteType (OSCTXT* pctxt, 
   CancellationNoteType* pvalue, xmlNodePtr pXmlNode, OSBOOL setChild)
{
   xmlAttrPtr pXmlAttr = pXmlNode->properties;

   /* Populate attributes */
   for ( ; 0 != pXmlAttr; pXmlAttr = pXmlAttr->next) {
      if (pXmlAttr->type == XML_ATTRIBUTE_NODE) {
         if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("languageLocaleID"))) {
            pvalue->m.languageLocaleIDPresent = 1;
            if (0 != pXmlAttr->children) {
               pvalue->languageLocaleID = pXmlAttr->children->content;
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("languageID"))) {
            pvalue->m.languageIDPresent = 1;
            if (0 != pXmlAttr->children) {
               pvalue->languageID = pXmlAttr->children->content;
            }
         }
      }
   }
   /* Populate elements */
   if (0 != pXmlNode->children) {
      pvalue->base = pXmlNode->children->content;
   }
}
Exemple #2
0
int DOMTest_Config_item (OSCTXT* pctxt, Config_item* pvalue, 
   xmlNodePtr pXmlNode, OSBOOL setChild)
{
   xmlAttrPtr pXmlAttr = pXmlNode->properties;

   /* Populate attributes */
   for ( ; 0 != pXmlAttr; pXmlAttr = pXmlAttr->next) {
      if (pXmlAttr->type == XML_ATTRIBUTE_NODE) {
         if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("name"))) {
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               pvalue->name = ((xmlNodePtr)pXmlAttr)->children->content;
            }
            else {
               pvalue->name = (const OSUTF8CHAR*)"";
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("type"))) {
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               Config_item_type_ToEnum (pctxt, ((xmlNodePtr)pXmlAttr)->children->content, &pvalue->type);
            }
         }
      }
   }
   /* Populate elements */
   if (setChild)
      pXmlNode = pXmlNode->children;

   for ( ; 0 != pXmlNode; pXmlNode = pXmlNode->next) {
      if (pXmlNode->type == XML_ELEMENT_NODE) {
      }
   }

   return 0;
}
Exemple #3
0
EXTRTMETHOD OSBOOL rtxQNamesEqual 
(const OSXMLFullQName* pqname1, const OSXMLFullQName* pqname2)
{
   if (pqname1 == pqname2) return TRUE;
   else return (OSBOOL)
      (rtxUTF8StrEqual (pqname1->nsURI, pqname2->nsURI) &&
       rtxUTF8StrEqual (pqname1->localName, pqname2->localName));
}
Exemple #4
0
int DOMTest_Ns7_Light (OSCTXT* pctxt, Ns7_Light* pvalue, 
   xmlNodePtr pXmlNode, OSBOOL setChild)
{
   xmlAttrPtr pXmlAttr = pXmlNode->properties;

   /* Populate attributes */
   for ( ; 0 != pXmlAttr; pXmlAttr = pXmlAttr->next) {
      if (pXmlAttr->type == XML_ATTRIBUTE_NODE) {
         if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("diffuse-color"))) {
            pvalue->m.diffuse_colorPresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               pvalue->diffuse_color = ((xmlNodePtr)pXmlAttr)->children->content;
            }
            else {
               pvalue->diffuse_color = (const OSUTF8CHAR*)"";
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("direction"))) {
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               pvalue->direction = ((xmlNodePtr)pXmlAttr)->children->content;
            }
            else {
               pvalue->direction = (const OSUTF8CHAR*)"";
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("enabled"))) {
            pvalue->m.enabledPresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               Ns7_Light_enabled_ToEnum (pctxt, ((xmlNodePtr)pXmlAttr)->children->content, &pvalue->enabled);
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("specular"))) {
            pvalue->m.specularPresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               Ns7_Light_specular_ToEnum (pctxt, ((xmlNodePtr)pXmlAttr)->children->content, &pvalue->specular);
            }
         }
      }
   }
   /* Populate elements */
   if (setChild)
      pXmlNode = pXmlNode->children;

   for ( ; 0 != pXmlNode; pXmlNode = pXmlNode->next) {
      if (pXmlNode->type == XML_ELEMENT_NODE) {
      }
   }

   return 0;
}
Exemple #5
0
int DOMTest_Config_item_map_entry (OSCTXT* pctxt, 
   Config_item_map_entry* pvalue, xmlNodePtr pXmlNode, OSBOOL setChild)
{
   xmlAttrPtr pXmlAttr = pXmlNode->properties;

   /* Populate attributes */
   for ( ; 0 != pXmlAttr; pXmlAttr = pXmlAttr->next) {
      if (pXmlAttr->type == XML_ATTRIBUTE_NODE) {
         if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("name"))) {
            pvalue->m.namePresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               pvalue->name = ((xmlNodePtr)pXmlAttr)->children->content;
            }
            else {
               pvalue->name = (const OSUTF8CHAR*)"";
            }
         }
      }
   }
   /* Populate elements */
   if (setChild)
      pXmlNode = pXmlNode->children;

   for ( ; 0 != pXmlNode; pXmlNode = pXmlNode->next) {
      if (pXmlNode->type == XML_ELEMENT_NODE) {
         if (rtxUTF8StrEqual (pXmlNode->name, OSUTF8("config-item")) ||
         rtxUTF8StrEqual (pXmlNode->name, OSUTF8("config-item-set")) ||
         rtxUTF8StrEqual (pXmlNode->name, OSUTF8("config-item-map-named")) ||
         rtxUTF8StrEqual (pXmlNode->name, OSUTF8("config-item-map-indexed"))) {
            { Config_item_map_entry_element* pdata2;
            pdata2 = rtxMemAllocType (pctxt, Config_item_map_entry_element);

            if (pdata2 == NULL)
               return LOG_RTERR (pctxt, RTERR_NOMEM);

            asn1Init_Config_item_map_entry_element (pdata2);
            DOMTest_Config_item_map_entry_element (pctxt, pdata2, pXmlNode, FALSE);
            if (0 != pdata2)
               rtxDListAppend (pctxt, &pvalue->choice_list, (void*)pdata2);
            }
         }
      }
   }

   return 0;
}
Exemple #6
0
int DOMTest_Ns7_Extrude (OSCTXT* pctxt, Ns7_Extrude* pvalue, 
   xmlNodePtr pXmlNode, OSBOOL setChild)
{
   xmlAttrPtr pXmlAttr = pXmlNode->properties;

   /* Populate attributes */
   for ( ; 0 != pXmlAttr; pXmlAttr = pXmlAttr->next) {
      if (pXmlAttr->type == XML_ATTRIBUTE_NODE) {
         if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("transform"))) {
            pvalue->m.transformPresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               pvalue->transform = ((xmlNodePtr)pXmlAttr)->children->content;
            }
            else {
               pvalue->transform = (const OSUTF8CHAR*)"";
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("class-names"))) {
            pvalue->m.class_namesPresent = 1;
            DOMTest_Ns3_Class_names (pctxt, (Ns3_Class_names*)&pvalue->class_names, pXmlAttr, FALSE);
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("id"))) {
            pvalue->m.idPresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               pvalue->id = ((xmlNodePtr)pXmlAttr)->children->content;
            }
            else {
               pvalue->id = (const OSUTF8CHAR*)"";
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("layer"))) {
            pvalue->m.layerPresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               pvalue->layer = ((xmlNodePtr)pXmlAttr)->children->content;
            }
            else {
               pvalue->layer = (const OSUTF8CHAR*)"";
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("style-name"))) {
            pvalue->m.style_namePresent = 1;
            pvalue->style_name = rtxMemAllocType (pctxt, Ns3_Style_name);

            if (pvalue->style_name == NULL)
               return LOG_RTERR (pctxt, RTERR_NOMEM);

            asn1Init_Ns3_Style_name ((Ns3_Style_name*)pvalue->style_name);
            DOMTest_Ns3_Style_name (pctxt, (Ns3_Style_name*)pvalue->style_name, pXmlAttr, FALSE);
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("z-index"))) {
            pvalue->m.z_indexPresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               pvalue->z_index = atoi ((const char*)((xmlNodePtr)pXmlAttr)->children->content);
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("class-names"))) {
            pvalue->m.class_names_1Present = 1;
            DOMTest_Ns3_Class_names (pctxt, (Ns3_Class_names*)&pvalue->class_names_1, pXmlAttr, FALSE);
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("style-name"))) {
            pvalue->m.style_name_1Present = 1;
            pvalue->style_name_1 = rtxMemAllocType (pctxt, Ns3_Style_name);

            if (pvalue->style_name_1 == NULL)
               return LOG_RTERR (pctxt, RTERR_NOMEM);

            asn1Init_Ns3_Style_name ((Ns3_Style_name*)pvalue->style_name_1);
            DOMTest_Ns3_Style_name (pctxt, (Ns3_Style_name*)pvalue->style_name_1, pXmlAttr, FALSE);
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("d"))) {
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               pvalue->d = ((xmlNodePtr)pXmlAttr)->children->content;
            }
            else {
               pvalue->d = (const OSUTF8CHAR*)"";
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("viewBox"))) {
            DOMTest_ViewBox (pctxt, (ViewBox*)&pvalue->viewBox, pXmlAttr, FALSE);
         }
      }
   }
   /* Populate elements */
   if (setChild)
      pXmlNode = pXmlNode->children;

   for ( ; 0 != pXmlNode; pXmlNode = pXmlNode->next) {
      if (pXmlNode->type == XML_ELEMENT_NODE) {
      }
   }

   return 0;
}
Exemple #7
0
int DOMTest_Ns7_Scene (OSCTXT* pctxt, Ns7_Scene* pvalue, 
   xmlNodePtr pXmlNode, OSBOOL setChild)
{
   xmlAttrPtr pXmlAttr = pXmlNode->properties;

   /* Populate attributes */
   for ( ; 0 != pXmlAttr; pXmlAttr = pXmlAttr->next) {
      if (pXmlAttr->type == XML_ATTRIBUTE_NODE) {
         if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("ambient-color"))) {
            pvalue->m.ambient_colorPresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               pvalue->ambient_color = ((xmlNodePtr)pXmlAttr)->children->content;
            }
            else {
               pvalue->ambient_color = (const OSUTF8CHAR*)"";
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("distance"))) {
            pvalue->m.distancePresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               pvalue->distance = ((xmlNodePtr)pXmlAttr)->children->content;
            }
            else {
               pvalue->distance = (const OSUTF8CHAR*)"";
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("focal-length"))) {
            pvalue->m.focal_lengthPresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               pvalue->focal_length = ((xmlNodePtr)pXmlAttr)->children->content;
            }
            else {
               pvalue->focal_length = (const OSUTF8CHAR*)"";
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("lighting-mode"))) {
            pvalue->m.lighting_modePresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               Ns7_Lighting_mode_ToEnum (pctxt, ((xmlNodePtr)pXmlAttr)->children->content, &pvalue->lighting_mode);
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("projection"))) {
            pvalue->m.projectionPresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               Ns7_Projection_ToEnum (pctxt, ((xmlNodePtr)pXmlAttr)->children->content, &pvalue->projection);
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("shade-mode"))) {
            pvalue->m.shade_modePresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               Ns7_Shade_mode_ToEnum (pctxt, ((xmlNodePtr)pXmlAttr)->children->content, &pvalue->shade_mode);
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("shadow-slant"))) {
            pvalue->m.shadow_slantPresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               pvalue->shadow_slant = atoi ((const char*)((xmlNodePtr)pXmlAttr)->children->content);
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("transform"))) {
            pvalue->m.transformPresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               pvalue->transform = ((xmlNodePtr)pXmlAttr)->children->content;
            }
            else {
               pvalue->transform = (const OSUTF8CHAR*)"";
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("vpn"))) {
            pvalue->m.vpnPresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               pvalue->vpn = ((xmlNodePtr)pXmlAttr)->children->content;
            }
            else {
               pvalue->vpn = (const OSUTF8CHAR*)"";
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("vrp"))) {
            pvalue->m.vrpPresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               pvalue->vrp = ((xmlNodePtr)pXmlAttr)->children->content;
            }
            else {
               pvalue->vrp = (const OSUTF8CHAR*)"";
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("vup"))) {
            pvalue->m.vupPresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               pvalue->vup = ((xmlNodePtr)pXmlAttr)->children->content;
            }
            else {
               pvalue->vup = (const OSUTF8CHAR*)"";
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("class-names"))) {
            pvalue->m.class_namesPresent = 1;
            DOMTest_Ns3_Class_names (pctxt, (Ns3_Class_names*)&pvalue->class_names, pXmlAttr, FALSE);
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("id"))) {
            pvalue->m.idPresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               pvalue->id = ((xmlNodePtr)pXmlAttr)->children->content;
            }
            else {
               pvalue->id = (const OSUTF8CHAR*)"";
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("layer"))) {
            pvalue->m.layerPresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               pvalue->layer = ((xmlNodePtr)pXmlAttr)->children->content;
            }
            else {
               pvalue->layer = (const OSUTF8CHAR*)"";
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("style-name"))) {
            pvalue->m.style_namePresent = 1;
            pvalue->style_name = rtxMemAllocType (pctxt, Ns3_Style_name);

            if (pvalue->style_name == NULL)
               return LOG_RTERR (pctxt, RTERR_NOMEM);

            asn1Init_Ns3_Style_name ((Ns3_Style_name*)pvalue->style_name);
            DOMTest_Ns3_Style_name (pctxt, (Ns3_Style_name*)pvalue->style_name, pXmlAttr, FALSE);
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("z-index"))) {
            pvalue->m.z_indexPresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               pvalue->z_index = atoi ((const char*)((xmlNodePtr)pXmlAttr)->children->content);
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("class-names"))) {
            pvalue->m.class_names_1Present = 1;
            DOMTest_Ns3_Class_names (pctxt, (Ns3_Class_names*)&pvalue->class_names_1, pXmlAttr, FALSE);
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("style-name"))) {
            pvalue->m.style_name_1Present = 1;
            pvalue->style_name_1 = rtxMemAllocType (pctxt, Ns3_Style_name);

            if (pvalue->style_name_1 == NULL)
               return LOG_RTERR (pctxt, RTERR_NOMEM);

            asn1Init_Ns3_Style_name ((Ns3_Style_name*)pvalue->style_name_1);
            DOMTest_Ns3_Style_name (pctxt, (Ns3_Style_name*)pvalue->style_name_1, pXmlAttr, FALSE);
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("height"))) {
            pvalue->m.heightPresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               pvalue->height = ((xmlNodePtr)pXmlAttr)->children->content;
            }
            else {
               pvalue->height = (const OSUTF8CHAR*)"";
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("width"))) {
            pvalue->m.widthPresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               pvalue->width = ((xmlNodePtr)pXmlAttr)->children->content;
            }
            else {
               pvalue->width = (const OSUTF8CHAR*)"";
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("x"))) {
            pvalue->m.xPresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               pvalue->x = ((xmlNodePtr)pXmlAttr)->children->content;
            }
            else {
               pvalue->x = (const OSUTF8CHAR*)"";
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("y"))) {
            pvalue->m.yPresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               pvalue->y = ((xmlNodePtr)pXmlAttr)->children->content;
            }
            else {
               pvalue->y = (const OSUTF8CHAR*)"";
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("end-cell-address"))) {
            pvalue->m.end_cell_addressPresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               pvalue->end_cell_address = ((xmlNodePtr)pXmlAttr)->children->content;
            }
            else {
               pvalue->end_cell_address = (const OSUTF8CHAR*)"";
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("end-x"))) {
            pvalue->m.end_xPresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               pvalue->end_x = ((xmlNodePtr)pXmlAttr)->children->content;
            }
            else {
               pvalue->end_x = (const OSUTF8CHAR*)"";
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("end-y"))) {
            pvalue->m.end_yPresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               pvalue->end_y = ((xmlNodePtr)pXmlAttr)->children->content;
            }
            else {
               pvalue->end_y = (const OSUTF8CHAR*)"";
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("table-background"))) {
            pvalue->m.table_backgroundPresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               Table_background_ToEnum (pctxt, ((xmlNodePtr)pXmlAttr)->children->content, &pvalue->table_background);
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("anchor-page-number"))) {
            pvalue->m.anchor_page_numberPresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               pvalue->anchor_page_number = atoi ((const char*)((xmlNodePtr)pXmlAttr)->children->content);
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("anchor-type"))) {
            pvalue->m.anchor_typePresent = 1;
            if (0 != ((xmlNodePtr)pXmlAttr)->children) {
               Odf_Anchor_type_ToEnum (pctxt, ((xmlNodePtr)pXmlAttr)->children->content, &pvalue->anchor_type);
            }
         }
      }
   }
   /* Populate elements */
   if (setChild)
      pXmlNode = pXmlNode->children;

   for ( ; 0 != pXmlNode; pXmlNode = pXmlNode->next) {
      if (pXmlNode->type == XML_ELEMENT_NODE) {
         if (rtxUTF8StrEqual (pXmlNode->name, OSUTF8("light"))) {
            { Ns7_Light* pdata2;
            pdata2 = rtxMemAllocType (pctxt, Ns7_Light);

            if (pdata2 == NULL)
               return LOG_RTERR (pctxt, RTERR_NOMEM);

            asn1Init_Ns7_Light (pdata2);
            DOMTest_Ns7_Light (pctxt, pdata2, pXmlNode, FALSE);
            if (0 != pdata2)
               rtxDListAppend (pctxt, &pvalue->light_list, (void*)pdata2);
            }
         }
         else if (rtxUTF8StrEqual (pXmlNode->name, OSUTF8("scene")) ||
         rtxUTF8StrEqual (pXmlNode->name, OSUTF8("extrude")) ||
         rtxUTF8StrEqual (pXmlNode->name, OSUTF8("sphere")) ||
         rtxUTF8StrEqual (pXmlNode->name, OSUTF8("rotate")) ||
         rtxUTF8StrEqual (pXmlNode->name, OSUTF8("cube"))) {
            { Ns7_Scene_element* pdata2;
            pdata2 = rtxMemAllocType (pctxt, Ns7_Scene_element);

            if (pdata2 == NULL)
               return LOG_RTERR (pctxt, RTERR_NOMEM);

            asn1Init_Ns7_Scene_element (pdata2);
            DOMTest_Ns7_Scene_element (pctxt, pdata2, pXmlNode, FALSE);
            if (0 != pdata2)
               rtxDListAppend (pctxt, &pvalue->choice_list, (void*)pdata2);
            }
         }
      }
   }

   return 0;
}
Exemple #8
0
int DOMTest_Ns7_Scene_element (OSCTXT* pctxt, Ns7_Scene_element* pvalue, 
   xmlNodePtr pXmlNode, OSBOOL setChild)
{
   if (setChild)
      pXmlNode = pXmlNode->children;

   for ( ; 0 != pXmlNode; pXmlNode = pXmlNode->next) {
      if (pXmlNode->type == XML_ELEMENT_NODE) {
         if (rtxUTF8StrEqual (pXmlNode->name, OSUTF8("scene"))) {
            pvalue->t = 1;
            pvalue->u.scene = rtxMemAllocType (pctxt, Ns7_Scene);

            if (pvalue->u.scene == NULL)
               return LOG_RTERR (pctxt, RTERR_NOMEM);

            asn1Init_Ns7_Scene ((Ns7_Scene*)pvalue->u.scene);
            DOMTest_Ns7_Scene (pctxt, (Ns7_Scene*)pvalue->u.scene, pXmlNode, TRUE);
            break;
         }
         else if (rtxUTF8StrEqual (pXmlNode->name, OSUTF8("extrude"))) {
            pvalue->t = 2;
            pvalue->u.extrude = rtxMemAllocType (pctxt, Ns7_Extrude);

            if (pvalue->u.extrude == NULL)
               return LOG_RTERR (pctxt, RTERR_NOMEM);

            asn1Init_Ns7_Extrude (pvalue->u.extrude);
            DOMTest_Ns7_Extrude (pctxt, pvalue->u.extrude, pXmlNode, TRUE);
            break;
         }
         else if (rtxUTF8StrEqual (pXmlNode->name, OSUTF8("sphere"))) {
            pvalue->t = 3;
            pvalue->u.sphere = rtxMemAllocType (pctxt, Ns7_Sphere);

            if (pvalue->u.sphere == NULL)
               return LOG_RTERR (pctxt, RTERR_NOMEM);

            asn1Init_Ns7_Sphere (pvalue->u.sphere);
            DOMTest_Ns7_Sphere (pctxt, pvalue->u.sphere, pXmlNode, TRUE);
            break;
         }
         else if (rtxUTF8StrEqual (pXmlNode->name, OSUTF8("rotate"))) {
            pvalue->t = 4;
            pvalue->u.rotate = rtxMemAllocType (pctxt, Ns7_Rotate);

            if (pvalue->u.rotate == NULL)
               return LOG_RTERR (pctxt, RTERR_NOMEM);

            asn1Init_Ns7_Rotate (pvalue->u.rotate);
            DOMTest_Ns7_Rotate (pctxt, pvalue->u.rotate, pXmlNode, TRUE);
            break;
         }
         else if (rtxUTF8StrEqual (pXmlNode->name, OSUTF8("cube"))) {
            pvalue->t = 5;
            pvalue->u.cube = rtxMemAllocType (pctxt, Ns7_Cube);

            if (pvalue->u.cube == NULL)
               return LOG_RTERR (pctxt, RTERR_NOMEM);

            asn1Init_Ns7_Cube (pvalue->u.cube);
            DOMTest_Ns7_Cube (pctxt, pvalue->u.cube, pXmlNode, TRUE);
            break;
         }
         else {
            LOG_RTERR1 (pctxt, RTERR_INVOPT,
               rtxErrAddStrParm (pctxt, (const char*)pXmlNode->name));
         }
      }
   }

   return 0;
}
Exemple #9
0
int DOMTest_Config_item_map_entry_element (OSCTXT* pctxt, 
   Config_item_map_entry_element* pvalue, xmlNodePtr pXmlNode, OSBOOL setChild)
{
   if (setChild)
      pXmlNode = pXmlNode->children;

   for ( ; 0 != pXmlNode; pXmlNode = pXmlNode->next) {
      if (pXmlNode->type == XML_ELEMENT_NODE) {
         if (rtxUTF8StrEqual (pXmlNode->name, OSUTF8("config-item"))) {
            pvalue->t = 1;
            pvalue->u.config_item = rtxMemAllocType (pctxt, Config_item);

            if (pvalue->u.config_item == NULL)
               return LOG_RTERR (pctxt, RTERR_NOMEM);

            asn1Init_Config_item (pvalue->u.config_item);
            DOMTest_Config_item (pctxt, pvalue->u.config_item, pXmlNode, TRUE);
            break;
         }
         else if (rtxUTF8StrEqual (pXmlNode->name, OSUTF8("config-item-set"))) {
            pvalue->t = 2;
            pvalue->u.config_item_set
                = rtxMemAllocType (pctxt, Config_item_set);

            if (pvalue->u.config_item_set == NULL)
               return LOG_RTERR (pctxt, RTERR_NOMEM);

            asn1Init_Config_item_set ((Config_item_set*)pvalue->u.config_item_set);
            DOMTest_Config_item_set (pctxt, (Config_item_set*)pvalue->u.config_item_set, pXmlNode, TRUE);
            break;
         }
         else if (rtxUTF8StrEqual (pXmlNode->name, OSUTF8("config-item-map-named"))) {
            pvalue->t = 3;
            pvalue->u.config_item_map_named
                = rtxMemAllocType (pctxt, Config_item_map_named);

            if (pvalue->u.config_item_map_named == NULL)
               return LOG_RTERR (pctxt, RTERR_NOMEM);

            asn1Init_Config_item_map_named ((Config_item_map_named*)pvalue->u.config_item_map_named);
            DOMTest_Config_item_map_named (pctxt, (Config_item_map_named*)pvalue->u.config_item_map_named, pXmlNode, TRUE);
            break;
         }
         else if (rtxUTF8StrEqual (pXmlNode->name, OSUTF8("config-item-map-indexed"))) {
            pvalue->t = 4;
            pvalue->u.config_item_map_indexed
                = rtxMemAllocType (pctxt, Config_item_map_indexed);

            if (pvalue->u.config_item_map_indexed == NULL)
               return LOG_RTERR (pctxt, RTERR_NOMEM);

            asn1Init_Config_item_map_indexed (pvalue->u.config_item_map_indexed);
            DOMTest_Config_item_map_indexed (pctxt, pvalue->u.config_item_map_indexed, pXmlNode, TRUE);
            break;
         }
         else {
            LOG_RTERR1 (pctxt, RTERR_INVOPT,
               rtxErrAddStrParm (pctxt, (const char*)pXmlNode->name));
         }
      }
   }

   return 0;
}
void asn1DOMTest_OrderCancellationType (OSCTXT* pctxt, 
   OrderCancellationType* pvalue, xmlNodePtr pXmlNode, OSBOOL setChild)
{
   /* Populate elements */
   if (setChild)
      pXmlNode = pXmlNode->children;

   for ( ; 0 != pXmlNode; pXmlNode = pXmlNode->next) {
      if (pXmlNode->type == XML_ELEMENT_NODE) {
         if (rtxUTF8StrEqual (pXmlNode->name, OSUTF8("ID"))) {
            asn1DOMTest_UBL_UnspecializedDatatypes_1_0_IdentifierType (pctxt, &pvalue->iD, pXmlNode, TRUE);
         }
         else if (rtxUTF8StrEqual (pXmlNode->name, OSUTF8("CopyIndicator"))) {
            pvalue->m.copyIndicatorPresent = 1;
            asn1DOMTest_CopyIndicator (pctxt, &pvalue->copyIndicator, pXmlNode, TRUE);
         }
         else if (rtxUTF8StrEqual (pXmlNode->name, OSUTF8("GUID"))) {
            pvalue->m.gUIDPresent = 1;
            asn1DOMTest_UBL_UnspecializedDatatypes_1_0_IdentifierType (pctxt, &pvalue->gUID, pXmlNode, TRUE);
         }
         else if (rtxUTF8StrEqual (pXmlNode->name, OSUTF8("IssueDateTime"))) {
            asn1DOMTest_IssueDateTime (pctxt, &pvalue->issueDateTime, pXmlNode, TRUE);
         }
         else if (rtxUTF8StrEqual (pXmlNode->name, OSUTF8("DocumentStatusCode"))) {
            pvalue->m.documentStatusCodePresent = 1;
            asn1DOMTest_DocumentStatusCodeType (pctxt, &pvalue->documentStatusCode, pXmlNode, TRUE);
         }
         else if (rtxUTF8StrEqual (pXmlNode->name, OSUTF8("Note"))) {
            pvalue->m.notePresent = 1;
            asn1DOMTest_Note (pctxt, &pvalue->note, pXmlNode, TRUE);
         }
         else if (rtxUTF8StrEqual (pXmlNode->name, OSUTF8("CancellationNote"))) {
            asn1DOMTest_CancellationNote (pctxt, &pvalue->cancellationNote, pXmlNode, TRUE);
         }
         else if (rtxUTF8StrEqual (pXmlNode->name, OSUTF8("ResponseRequiredIndicator"))) {
            pvalue->m.responseRequiredIndicatorPresent = 1;
            asn1DOMTest_ResponseRequiredIndicator (pctxt, &pvalue->responseRequiredIndicator, pXmlNode, TRUE);
         }
         else if (rtxUTF8StrEqual (pXmlNode->name, OSUTF8("AcceptedIndicator"))) {
            pvalue->m.acceptedIndicatorPresent = 1;
            asn1DOMTest_AcceptedIndicator (pctxt, &pvalue->acceptedIndicator, pXmlNode, TRUE);
         }
         else if (rtxUTF8StrEqual (pXmlNode->name, OSUTF8("OrderReference"))) {
            asn1DOMTest_OrderCancellationType_orderReference_list (pctxt, &pvalue->orderReference_list, pXmlNode, TRUE);
         }
         else if (rtxUTF8StrEqual (pXmlNode->name, OSUTF8("BuyerParty"))) {
            asn1DOMTest_BuyerParty (pctxt, &pvalue->buyerParty, pXmlNode, TRUE);
         }
         else if (rtxUTF8StrEqual (pXmlNode->name, OSUTF8("SellerParty"))) {
            asn1DOMTest_SellerParty (pctxt, &pvalue->sellerParty, pXmlNode, TRUE);
         }
      }
   }
}
void asn1DOMTest_OperatorCodeType (OSCTXT* pctxt, OperatorCodeType* pvalue, 
   xmlNodePtr pXmlNode, OSBOOL setChild)
{
   xmlAttrPtr pXmlAttr = pXmlNode->properties;

   /* Populate attributes */
   for ( ; 0 != pXmlAttr; pXmlAttr = pXmlAttr->next) {
      if (pXmlAttr->type == XML_ATTRIBUTE_NODE) {
         if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("codeListAgencyID"))) {
            pvalue->m.codeListAgencyIDPresent = 1;
            if (0 != pXmlAttr->children) {
               pvalue->codeListAgencyID = pXmlAttr->children->content;
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("codeListAgencyName"))) {
            pvalue->m.codeListAgencyNamePresent = 1;
            if (0 != pXmlAttr->children) {
               pvalue->codeListAgencyName = pXmlAttr->children->content;
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("codeListID"))) {
            pvalue->m.codeListIDPresent = 1;
            if (0 != pXmlAttr->children) {
               pvalue->codeListID = pXmlAttr->children->content;
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("codeListName"))) {
            pvalue->m.codeListNamePresent = 1;
            if (0 != pXmlAttr->children) {
               pvalue->codeListName = pXmlAttr->children->content;
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("codeListSchemeURI"))) {
            pvalue->m.codeListSchemeURIPresent = 1;
            if (0 != pXmlAttr->children) {
               pvalue->codeListSchemeURI = pXmlAttr->children->content;
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("codeListURI"))) {
            pvalue->m.codeListURIPresent = 1;
            if (0 != pXmlAttr->children) {
               pvalue->codeListURI = pXmlAttr->children->content;
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("codeListVersionID"))) {
            pvalue->m.codeListVersionIDPresent = 1;
            if (0 != pXmlAttr->children) {
               pvalue->codeListVersionID = pXmlAttr->children->content;
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("languageID"))) {
            pvalue->m.languageIDPresent = 1;
            if (0 != pXmlAttr->children) {
               pvalue->languageID = pXmlAttr->children->content;
            }
         }
         else if (rtxUTF8StrEqual (pXmlAttr->name, OSUTF8("name"))) {
            pvalue->m.namePresent = 1;
            if (0 != pXmlAttr->children) {
               pvalue->name = pXmlAttr->children->content;
            }
         }
      }
   }
   /* Populate elements */
   if (0 != pXmlNode->children) {
      OperatorCodeContentType_ToEnum (pXmlNode->children->content, &pvalue->base);
   }
}