diff options
Diffstat (limited to 'sdo-cpp/branches/sdo-cpp-pre2.1/runtime/core/src/commonj/sdo/SDOUtils.cpp')
-rw-r--r-- | sdo-cpp/branches/sdo-cpp-pre2.1/runtime/core/src/commonj/sdo/SDOUtils.cpp | 442 |
1 files changed, 442 insertions, 0 deletions
diff --git a/sdo-cpp/branches/sdo-cpp-pre2.1/runtime/core/src/commonj/sdo/SDOUtils.cpp b/sdo-cpp/branches/sdo-cpp-pre2.1/runtime/core/src/commonj/sdo/SDOUtils.cpp new file mode 100644 index 0000000000..cb4e0d0b24 --- /dev/null +++ b/sdo-cpp/branches/sdo-cpp-pre2.1/runtime/core/src/commonj/sdo/SDOUtils.cpp @@ -0,0 +1,442 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +/* $Rev$ $Date$ */ + +#include "commonj/sdo/SDOUtils.h" +#include <stdio.h> +using namespace std; + +// +// Utility methods to print a DataObject tree +// + +namespace commonj { + namespace sdo { + + const char *SDOUtils::CDataStartMarker = "XXXCDATA@STARTXXX"; + const char *SDOUtils::XMLCDataStartMarker = "<![CDATA["; + const char *SDOUtils::CDataEndMarker = "XXXCDATA@ENDX"; + const char *SDOUtils::XMLCDataEndMarker = "]]>"; + +////////////////////////////////////////////////////////////////////////// +// Conversions +////////////////////////////////////////////////////////////////////////// + + + std::map<std::string,std::string> SDOUtils::SdoToXsd; + + std::map<std::string,std::string> SDOUtils::XsdToSdo; + + std::map<char,std::string> SDOUtils::HtmlEntities; + + bool SDOUtils::populated = false; + + bool SDOUtils::populate() + { + SDOUtils::XsdToSdo["ID"] = "String"; + SDOUtils::XsdToSdo["NCName"] = "String"; + SDOUtils::XsdToSdo["string"] = "String"; + SDOUtils::XsdToSdo["anyType"] = "DataObject"; + SDOUtils::XsdToSdo["int"] = "Integer"; + SDOUtils::XsdToSdo["integer"] = "Integer"; + SDOUtils::XsdToSdo["negativeInteger"] = "Integer"; + SDOUtils::XsdToSdo["nonNegativeInteger"] = "Integer"; + SDOUtils::XsdToSdo["positiveInteger"] = "Integer"; + SDOUtils::XsdToSdo["nonpositiveInteger"] = "Integer"; + SDOUtils::XsdToSdo["unsignedShort"] = "Integer"; + SDOUtils::XsdToSdo["unsignedInt"] = "Integer"; + SDOUtils::XsdToSdo["unsignedLong"] = "Long"; + SDOUtils::XsdToSdo["double"] = "Double"; + SDOUtils::XsdToSdo["short"] = "Short"; + SDOUtils::XsdToSdo["unsignedByte"] = "Short"; + SDOUtils::XsdToSdo["float"] = "Float"; + SDOUtils::XsdToSdo["boolean"] = "Boolean"; + SDOUtils::XsdToSdo["byte"] = "Byte"; + SDOUtils::XsdToSdo["base64Binary"] = "Bytes"; + SDOUtils::XsdToSdo["hexBinary"] = "Bytes"; + SDOUtils::XsdToSdo["anyURI"] = "URI"; + SDOUtils::XsdToSdo["QName"] = "URI"; + + SDOUtils::SdoToXsd["String"] = "string"; + SDOUtils::SdoToXsd["DataObject"] = "anyType"; + SDOUtils::SdoToXsd["Integer"] = "integer"; + SDOUtils::SdoToXsd["Long"] = "unsignedLong"; + SDOUtils::SdoToXsd["Double"] = "double"; + SDOUtils::SdoToXsd["Short"] = "short"; + SDOUtils::SdoToXsd["Float"] = "float"; + SDOUtils::SdoToXsd["Boolean"] = "boolean"; + SDOUtils::SdoToXsd["Byte"] = "byte"; + SDOUtils::SdoToXsd["Bytes"] = "base64Binary"; + SDOUtils::SdoToXsd["URI"] = "anyURI"; + + SDOUtils::HtmlEntities['&'] = "&"; + SDOUtils::HtmlEntities['<'] = "<"; + SDOUtils::HtmlEntities['>'] = ">"; + SDOUtils::HtmlEntities['\''] = "'"; + SDOUtils::HtmlEntities['"'] = """; + + SDOUtils::populated = true; + return true; + } + + const char* SDOUtils::SDOToXSD(const char* sdoname) + { + if (sdoname == 0) + { + return SDOUtils::SdoToXsd["String"].c_str(); + } + if (!SDOUtils::populated) SDOUtils::populate(); + string& s = SDOUtils::SdoToXsd[sdoname]; + if (s.empty()) + { + return SDOUtils::SdoToXsd["String"].c_str(); + } + return s.c_str(); + } + + + const char* SDOUtils::XSDToSDO(const char* xsdname) + { + if (xsdname == 0) + { + return SDOUtils::XsdToSdo["string"].c_str(); + } + if (!SDOUtils::populated) SDOUtils::populate(); + string& s = SDOUtils::XsdToSdo[xsdname]; + if (s.empty()) + return SDOUtils::XsdToSdo["string"].c_str(); + return s.c_str(); + } + +////////////////////////////////////////////////////////////////////////// +// Print Tabs +////////////////////////////////////////////////////////////////////////// + + void SDOUtils::printTabs(ostream& out, unsigned int incr) + { + for (unsigned int ind=0; ind < incr; ind++) + { + out << " "; + } + } + +////////////////////////////////////////////////////////////////////////// +// Print a DatObject tree +////////////////////////////////////////////////////////////////////////// + + void SDOUtils::printDataObject(ostream& out, DataObjectPtr dataObject) + { + printDataObject(out, dataObject,0); + } + + + void SDOUtils::printDataObject(ostream& out ,DataObjectPtr dataObject, + unsigned int incr) + { + + out << ">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> start of DO" + << endl; + + if (!dataObject)return; + + const Type& dataObjectType = dataObject->getType(); + printTabs(out, incr); + out << "DataObject type: " + << dataObjectType.getURI() + << "#" << dataObjectType.getName() << endl; + + incr++; + + ////////////////////////////////////////////////////////////// + // Iterate over all the properties + ////////////////////////////////////////////////////////////// + PropertyList pl = dataObject->getInstanceProperties(); + for (unsigned int i = 0; i < pl.size(); i++) + { + printTabs(out, incr); + out << "Property: " << pl[i].getName() << endl; + + const Type& propertyType = pl[i].getType(); + + printTabs(out, incr); + + out << "Property Type: " + << propertyType.getURI() + << "#" << propertyType.getName() << endl; + + if (dataObject->isSet(pl[i])) + { + + /////////////////////////////////////////////////////////// + // For a many-valued property get the list of values + /////////////////////////////////////////////////////////// + if (pl[i].isMany()) + { + incr++; + DataObjectList& dol = dataObject->getList(pl[i]); + char cc[20]; + for (unsigned int j = 0; j <dol.size(); j++) + { + printTabs(out, incr); + // seems to be a bug in ostream? Will not print j + // as an integer. + out << "Value "; + sprintf(cc,"%d",j); + out << cc; + out << endl; + incr++; + if (pl[i].isReference()) + { + printTabs(out, incr); + out << "Reference Value: " << dol[j]->objectToXPath() <<endl; + } + else + { + printDataObject(out, dol[j],incr); + } + incr--; + out << endl; + } + incr--; + } // end IsMany + + ////////////////////////////////////////////////////////////////////// + // For a primitive data type print the value + ////////////////////////////////////////////////////////////////////// + else if (propertyType.isDataType()) + { + printTabs(out, incr); + out<< "Property Value: " ; + if (dataObject->isNull(pl[i])) + out << "NULL" << endl; + else + out << dataObject->getCString(pl[i]) <<endl ; + } + + ////////////////////////////////////////////////////////////////////// + // For a dataobject print the do + ////////////////////////////////////////////////////////////////////// + else + { + incr++; + if (pl[i].isReference()) + { + printTabs(out, incr); + out << "Reference Value: " << dataObject->getDataObject(pl[i])->objectToXPath() <<endl; + } + else + { + printDataObject(out, dataObject->getDataObject(pl[i]),incr); + } + incr--; + } + } + else + { + printTabs(out, incr); + out << "Property Value: not set" <<endl ; + } + + } + incr--; + out << "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< end of do" << endl; + } + + + void SDOUtils::printTypes(std::ostream& out, DataFactoryPtr df) + { + TypeList tl = df->getTypes(); + for (unsigned int i = 0; i < tl.size(); i++) + { + out << "Type: " << tl[i].getURI()<< "#" << tl[i].getName() << + " isOpen: " << tl[i].isOpenType() + << " isSequenced: " << tl[i].isSequencedType() << endl; + + const std::list<PropertyImpl*> pl = tl[i].getPropertyListReference(); + + for (std::list<PropertyImpl*>::const_iterator j = pl.begin(); + j != pl.end(); + j++) + { + const Property* current = (Property*) (*j); + + out << "\tProperty: " + << current->getName() + << " type: " + << current->getType().getURI() + << "#" + << current->getType().getName() + << " isMany: " + << current->isMany() + << endl; + } + } + + } + + /* + * A local utility function that replaces one string with and another within a + * host string and adjusts the lenght of the host string accordingly. + */ + SDOString SDOUtils::replace(SDOString hostString, const char *fromString, const char *toString) + { + SDOString returnString(""); + + // find and replace all occurances of fromString with toString. The start, end + // and length variables are used to indicate the start, end and length + // of the text sections to be copied from the host string to the return + // string. toString is appended in between these copied sections because the + // string is broken whenever fromString is found + std::string::size_type start = 0; + std::string::size_type end = hostString.find(fromString, 0); + std::string::size_type length = 0; + + while ( end != std::string::npos ) + { + // copy all the text up to the fromString + length = end - start; + returnString.append(hostString.substr(start, length)); + + // add in the toString + returnString.append(toString); + + // find the next fromString + start = end + strlen(fromString); + end = hostString.find(fromString, start); + } + + // copy any text left at the end of the host string + returnString.append(hostString.substr(start)); + + return returnString; + } + + + /* + * Processes a string, substituting entities (such as &) for special characters + * Does not double-encode, that is, & is not converted to &amp; + */ + SDOString SDOUtils::escapeHtmlEntities(SDOString inputString) + { + if (inputString.size() == 0) + return inputString; + + if (!SDOUtils::populated) SDOUtils::populate(); + + SDOString returnString = SDOString(); + + SDOString::iterator start = inputString.begin(); + SDOString::iterator end = inputString.end(); + SDOString::iterator cur = start; + + while(cur < end) { + //cout << SDOString(cur) <<endl; + if ((*cur) == '&') { + bool skip = false; + /* + * Don't want to double-encode, so skip recognised entities + */ + for (map<char, SDOString>::iterator iter = HtmlEntities.begin(); + iter != HtmlEntities.end(); iter++ ) { + if (SDOString(cur, end).compare(0, (*iter).second.length(), (*iter).second) == 0) { + cur += (*iter).second.length(); + skip = true; + break; + } + } + + if (skip) continue; + } + + /* + * look for characters which need encoding + */ + for (map<char, SDOString>::iterator iter = HtmlEntities.begin(); + iter != HtmlEntities.end(); iter++ ) { + if ((*cur) == (*iter).first) { + returnString += SDOString(start, cur); + // cout << returnString <<endl; + returnString += (*iter).second; + // cout << returnString <<endl; + start = cur + 1; + break; + } + } + + cur++; + } + + returnString += SDOString(start, end); + // cout << returnString <<endl; + return returnString; + } + + + /* + * Processes a string substituting entities (such as &) for special characters + * CDATA sections within the string are left untouched + */ + SDOString SDOUtils::escapeHtmlEntitiesExcludingCData(SDOString inputString) + { + if (inputString.size() == 0) + return inputString; + + if (!SDOUtils::populated) SDOUtils::populate(); + + SDOString returnString = SDOString(); + + SDOString::const_iterator start = inputString.begin(); + SDOString::const_iterator end = inputString.end(); + SDOString::const_iterator cur = start; + + bool inCdataSection = false; + while(cur < end) { + if (!inCdataSection && SDOString(cur, end).compare(0, strlen(XMLCDataStartMarker), XMLCDataStartMarker) == 0) { + inCdataSection = true; + returnString += escapeHtmlEntities(SDOString(start, cur)); + start = cur; + cur += strlen(XMLCDataStartMarker); + continue; + } + + if (inCdataSection && SDOString(cur, end).compare(0, strlen(XMLCDataEndMarker), XMLCDataEndMarker) == 0) { + inCdataSection = false; + cur += strlen(XMLCDataEndMarker); + /* don't escape inside the cdata section */ + returnString += SDOString(start, cur); + start = cur; + continue; + } + + ++cur; + } + + if (inCdataSection) { + returnString += SDOString(start, end); + } else { + returnString += escapeHtmlEntities(SDOString(start, end)); + } + + return returnString; + } + + + }; +}; |