Changeset 394 for trunk/src/core/RpLibrary.cc

Timestamp:

Apr 2, 2006, 11:44:53 PM (19 years ago)

Author:

dkearney

Message:

improved tcl bindings, additions to xml parser including entity reference translations
so we dont get errors when user tries to put values like "<" and ">"

File:

• trunk/src/core/RpLibrary.cc (modified) (21 diffs)

trunk/src/core/RpLibrary.cc

@@ -13 +13 @@
 
 #include "RpLibrary.h"
+#include "RpEntityRef.h"
+
+static RpEntityRef ERTranslator;
 
 /**********************************************************************/
@@ -163 +166 @@
 {
     // XML_Char const* name = _get_attribute(node,"id");
-    std::string name = _get_attribute(node,"id");
+    std::string id = _get_attribute(node,"id");
     std::stringstream retVal;
     XML_Char const* type = NULL;
@@ -177 +180 @@
 
     if (parent) {
-        if (name.empty()) {
+        if (id.empty()) {
             siblings = scew_element_list(parent, type, &count);
             if (count > 0) {
@@ -188 +191 @@
                 if (index < tmpCount) {
                     if (index > 0) {
-                        retVal << type << --index;
+                        // retVal << type << --index;
+                        retVal << type << index;
                     }
                     else {
@@ -204 +208 @@
         else {
             // node has attribute id
-            retVal << type << "(" << name << ")";
+            retVal << type << "(" << id << ")";
 
         }
@@ -540 +544 @@
         child = NULL;
 
-        while ( (child = ele->children("",child)) != NULL ) {
+        while ( ele && (child = ele->children("",child)) != NULL ) {
             childList.push_back(child->nodeComp());
         }
@@ -636 +640 @@
         }
 
-        thisSpath = path + "." + *thisIter;
+        if (!path.empty()) {
+            thisSpath = path + "." + *thisIter;
+        }
+        else {
+            thisSpath = *thisIter;
+        }
 
         if (otherIter == otherv.end()) {
@@ -649 +658 @@
         else {
 
-            otherSpath = path + "." + *otherIter;
+            if (!path.empty()) {
+                otherSpath = path + "." + *otherIter;
+            }
+            else {
+                otherSpath = *otherIter;
+            }
 
             thisVal = this->value(thisSpath);
@@ -673 +687 @@
     while ( otherIter != otherv.end() ) {
 
-        otherSpath = path + "." + *otherIter;
+        if (!path.empty()) {
+            otherSpath = path + "." + *otherIter;
+        }
+        else {
+            otherSpath = *otherIter;
+        }
 
         otherVal = otherLib->value(otherSpath);
@@ -691 +710 @@
 /**********************************************************************/
 // METHOD: value(path)
-/// find the differences between two xml trees.
+/// Return a 2 element list containing the regular and normalized values.
 /**
  */
@@ -734 +753 @@
         /*
         else if (ele->nodeType() == "number") {
-            retArr[0] = "";
+            raw = "";
             retArr[1] = "";
             if ( (tele = ele->element("current")) != NULL) {
-                retArr[0] = tele->get();
-                retArr[1] = retArr[0];
+                raw = tele->get();
             }
             else if ( (tele = ele->element("default")) != NULL) {
-                retArr[0] = tele->get();
-                retArr[1] = retArr[0];
-            }
+                raw = tele->get();
+            }
+            val = raw
+            if ( "" != raw) {
+                // normalize the units
+                units = ele->get("units");
+                if ( "" != units) {
+
+                }
         }
         */
@@ -822 +846 @@
 {
     RpLibrary* value = NULL;
+    RpLibrary* child = NULL;
 
     if (!this->root) {
         // library doesn't exist, do nothing;
+        // need a good way to raise error, and this is not it.
         return *this;
     }
@@ -839 +865 @@
     }
 
-    return (this->put(toPath,value));
+    while ( (child = value->children("",child)) ) {
+        this->put(toPath, child);
+    }
+
+    return (*this);
 
 }
@@ -852 +882 @@
  */
 
+/*
 RpLibrary*
 RpLibrary::children (   std::string path, 
@@ -951 +982 @@
     return retLib;
 }
+*/
+
+RpLibrary*
+RpLibrary::children (   std::string path, 
+                        RpLibrary* rpChildNode, 
+                        std::string type,
+                        int* childCount)
+{
+    // this is static for efficency reasons
+    static std::string old_path = "";
+    // this was static so user never has to delete the retLib.
+    // should be replaced by a smart pointer
+    static RpLibrary* retLib = NULL; 
+    int myChildCount = 0;
+    scew_element* parentNode = NULL;
+    scew_element* childNode = NULL;
+    std::string childName = "";
+
+    if (!this->root) {
+        // library doesn't exist, do nothing;
+        return NULL;
+    }
+
+
+    // check to see if the last call to this function
+    // was searching for children of the same path.
+    if ( (path.compare(old_path) == 0) && (rpChildNode != NULL) ) {
+        parentNode = NULL;
+    }
+    else if (path.empty()) {
+        // searching for children in a new path.
+        // an empty path uses the current RpLibrary as parent
+        parentNode = this->root;
+    }
+    else {
+        // searching for children in a new, non-empty, path.
+        parentNode = _find(path,NO_CREATE_PATH);
+        if (parentNode == NULL) {
+            // node not found
+            // add error code here
+            return NULL;
+        }
+    }
+
+    old_path = path;
+
+    if (rpChildNode) {
+        childNode = rpChildNode->root;
+    }
+
+    if (parentNode) {
+        myChildCount = scew_element_count(parentNode);
+        if (childCount) {
+            *childCount = myChildCount;
+        }
+    }
+
+    // clean up old memory
+    delete retLib;
+
+    if ( (childNode = scew_element_next(parentNode,childNode)) ) {
+
+        if (!type.empty()) {
+            childName = scew_element_name(childNode);
+            // we are searching for a specific child name
+            // keep looking till we find a name that matches the type.
+            // if the current name does not match out search type, 
+            // grab the next child and check to see if its null
+            // if its not null, get its name and test for type again
+            while (  (type != childName)
+                  && (childNode = scew_element_next(parentNode,childNode)) ) {
+
+                childName = scew_element_name(childNode);
+            }
+            if (type == childName) {
+                // found a child with a name that matches type
+                retLib = new RpLibrary( childNode,this->tree );
+            }
+            else {
+                // no children with names that match 'type' were found
+                retLib = NULL;
+            }
+        }
+        else {
+            retLib = new RpLibrary( childNode,this->tree );
+        }
+    }
+    else {
+        // somthing happened within scew, get error code and display
+        // its probable there are no more child elements left to report
+        retLib = NULL;
+    }
+
+    return retLib;
+}
 
 /**********************************************************************/
@@ -1012 +1138 @@
 
 std::string
-RpLibrary::get (std::string path)
-{
-    return (this->getString(path));
+RpLibrary::get (std::string path, int translateFlag)
+{
+    return (this->getString(path, translateFlag));
 }
 
@@ -1024 +1150 @@
 
 std::string
-RpLibrary::getString (std::string path)
+RpLibrary::getString (std::string path, int translateFlag)
 {
     scew_element* retNode = NULL;
     XML_Char const* retCStr = NULL;
+    char* translatedContents = NULL;
+    std::string retStr = "";
+    int len = 0;
 
     if (!this->root) {
@@ -1047 +1176 @@
     }
 
-    return std::string(retCStr);
+    if (translateFlag == TRANSLATE) {
+        // translatedContents = new char[strlen(retCStr)+1];
+        len = strlen(retCStr);
+        translatedContents = (char*) calloc((len+1),sizeof(char));
+        if (translatedContents) {
+            strncpy(translatedContents, retCStr, len);
+            _translateOut(translatedContents);
+            retStr = std::string(translatedContents);
+            // delete[] translatedContents;
+            free(translatedContents);
+        }
+        else {
+            // error allocating space
+            return std::string("");
+        }
+    }
+    else {
+        retStr = std::string(retCStr);
+    }
+
+    return retStr;
 }
 
@@ -1084 +1233 @@
 
 RpLibrary&
-RpLibrary::put ( std::string path, std::string value, std::string id, int append )
+RpLibrary::put (    std::string path, 
+                    std::string value, 
+                    std::string id, 
+                    int append,
+                    int translateFlag)
 {
     scew_element* retNode = NULL;
     std::string tmpVal = "";
     const char* contents = NULL;
+    std::string translatedContents = "";
 
     if (!this->root) {
@@ -1106 +1260 @@
         }
 
-        scew_element_set_contents(retNode,value.c_str());
+        if (translateFlag == TRANSLATE) {
+            _translateIn(value,translatedContents);
+            scew_element_set_contents(retNode,translatedContents.c_str());
+        }
+        else {
+            scew_element_set_contents(retNode,value.c_str());
+        }
     }
 
@@ -1451 +1611 @@
 }
 
+/**********************************************************************/
+// METHOD: translateIn()
+/// Translate entity and character reference text coming in from the user
+/**
+ */
+
+int
+RpLibrary::_translateIn(std::string& outStr,std::string& translatedStr)
+{
+    ERTranslator.appendEscaped(outStr, translatedStr);
+    return 0;
+}
+
+
+/**********************************************************************/
+// METHOD: translateOut()
+/// Translate entity and character reference text going out to the user
+/**
+ */
+
+int
+RpLibrary::_translateOut(char* inStr) 
+{
+    int newLen = 0;
+    ERTranslator.TranslateEntityRefs(inStr, &newLen);
+    return 0;
+}