diff options
author | dims <dims@13f79535-47bb-0310-9956-ffa450edef68> | 2008-06-17 00:23:01 +0000 |
---|---|---|
committer | dims <dims@13f79535-47bb-0310-9956-ffa450edef68> | 2008-06-17 00:23:01 +0000 |
commit | bdd0a41aed7edf21ec2a65cfa17a86af2ef8c48a (patch) | |
tree | 38a92061c0793434c4be189f1d70c3458b6bc41d /tags/cpp-sdo-1.0.incubating-M3/runtime/core/src/commonj/sdo/TypeImpl.cpp |
Move Tuscany from Incubator to top level.
git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@668359 13f79535-47bb-0310-9956-ffa450edef68
Diffstat (limited to 'tags/cpp-sdo-1.0.incubating-M3/runtime/core/src/commonj/sdo/TypeImpl.cpp')
-rw-r--r-- | tags/cpp-sdo-1.0.incubating-M3/runtime/core/src/commonj/sdo/TypeImpl.cpp | 4066 |
1 files changed, 4066 insertions, 0 deletions
diff --git a/tags/cpp-sdo-1.0.incubating-M3/runtime/core/src/commonj/sdo/TypeImpl.cpp b/tags/cpp-sdo-1.0.incubating-M3/runtime/core/src/commonj/sdo/TypeImpl.cpp new file mode 100644 index 0000000000..34dd46e1b6 --- /dev/null +++ b/tags/cpp-sdo-1.0.incubating-M3/runtime/core/src/commonj/sdo/TypeImpl.cpp @@ -0,0 +1,4066 @@ +/* + * 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/Logger.h" + +#include "commonj/sdo/PropertyImpl.h" +#include "commonj/sdo/TypeImpl.h" + +#include <iostream> +#include <wchar.h> +#include <stdio.h> +#include <stdlib.h> +using namespace std; + +#include <list> +#include <vector> +using namespace std; + +#include "commonj/sdo/SDORuntimeException.h" + +namespace commonj{ +namespace sdo{ + + + + char* TypeImpl::types[num_types] = { + "Other Types", + "BigDecimal", + "BigInteger", + "Boolean" , + "Byte", + "Bytes", + "Character", + "Date" , + "Double" , + "Float" , + "Integer" , + "Long" , + "Short" , + "String" , + "URI" , + "DataObject", + "ChangeSummary", + "Text", + "OpenDataObject" + }; + + + /////////////////////////////////////////////////////////////////////////// + // + /////////////////////////////////////////////////////////////////////////// + + void TypeImpl::addChangeSummary(void) + { + changeSummaryType = true; + } + + bool TypeImpl::isChangeSummaryType() const + { + return changeSummaryType; + } + + + /////////////////////////////////////////////////////////////////////////// + // + /////////////////////////////////////////////////////////////////////////// + + bool TypeImpl::isFromList() const + { + return bFromList; + } + /////////////////////////////////////////////////////////////////////////// + // + /////////////////////////////////////////////////////////////////////////// + + bool TypeImpl::isDataType(void) const + { + return isPrimitive; + } + + /////////////////////////////////////////////////////////////////////////// + // + /////////////////////////////////////////////////////////////////////////// + + TypeImpl::TypeImpl(const TypeImpl& t) + { + isResolving = false; + isResolved = false; + brestriction = t.brestriction; + bFromList = t.bFromList; + } + + TypeImpl::TypeImpl(const Type* base, const char* uri, + const char* inname, + bool isSeq, + bool isOp, + bool isAbs, + bool isData, + bool isRestriction) + { + init(uri,inname,isSeq,isOp, isAbs, isData); + baseType = (TypeImpl*)base; + brestriction = isRestriction; + bFromList = false; + } + + TypeImpl::TypeImpl(const char* uri, const char* inname, + bool isSeq, + bool isOp, + bool isAbs, + bool isData, + bool isFromList) + + { + init(uri,inname,isSeq,isOp,isAbs, isData); + baseType = 0; + brestriction = false; + bFromList= false; + bFromList = isFromList; + } + + void TypeImpl::init(const char* uri, const char* inname, + bool isSeq, + bool isOp, + bool isAbs, + bool isData) + { + isResolving = false; + isResolved = false; + localPropsSize = 0; + changeSummaryType = false; + isSequenced = isSeq; + isOpen = isOp; + isAbstract = isAbs; + isPrimitive = isData; + name = new char[strlen(inname)+1]; + strcpy(name,inname); + + if (uri == 0) + { + typeURI = new char[1]; + typeURI[0] = 0; + typeEnum = DataObjectType; + return; + } + + typeURI = new char[strlen(uri)+1]; + strcpy(typeURI,uri); + + if (!strcmp(uri,Type::SDOTypeNamespaceURI.c_str())) { + for (int i = 0; i < num_types ; i++) { + if (!strcmp(inname,types[i])) { + typeEnum = (Types)i; + if (i <= UriType) isPrimitive = true; + // Note - you could create Text, but it would + // not be recognised as primitive. + return; + } + } + } + + // All other types are data object types - for now + typeEnum = DataObjectType; + } + + + /////////////////////////////////////////////////////////////////////////// + // + /////////////////////////////////////////////////////////////////////////// + TypeImpl::TypeImpl() + { + } + + /////////////////////////////////////////////////////////////////////////// + // + /////////////////////////////////////////////////////////////////////////// + + TypeImpl::~TypeImpl() + { + // Types free their corresponding properties, but not the types + // of those properties + // Need to free only those we allocated + unsigned int count = 0, start = props.size() - localPropsSize; + std::list<PropertyImpl*>::iterator i; + for (i= props.begin(); i != props.end() ; ++i) + { + if (count >= start) { + delete(*i); + } + count++; + } + if (name != 0) + { + delete[] name; + } + + if (typeURI != 0) + { + delete[] typeURI; + } + for (unsigned int j = 0; j < aliases.size();j++) + { + delete[] aliases[j]; + } + } + + /////////////////////////////////////////////////////////////////////////// + // Sets a data type as sequenced. + /////////////////////////////////////////////////////////////////////////// + + void TypeImpl::setSequenced(bool set) + { + isSequenced = set; + } + + /////////////////////////////////////////////////////////////////////////// + // Sets a data type as open. + /////////////////////////////////////////////////////////////////////////// + + void TypeImpl::setOpen(bool set) + { + isOpen = set; + } + + bool TypeImpl::isBaseTypeOf(const Type* type) const + { + return type + && (this == type || isBaseTypeOf(type->getBaseType())); + } + + /////////////////////////////////////////////////////////////////////////// + // Sets a data type as open. + /////////////////////////////////////////////////////////////////////////// + + void TypeImpl::setBaseType(const Type* bt, bool isRestriction) + { + if (isBaseTypeOf(bt)) + { + SDOString stringBuffer = getName(); + stringBuffer += "\tis base type of\t"; + stringBuffer += bt->getName(); + SDO_THROW_EXCEPTION(setBaseType, SDOIllegalArgumentException, stringBuffer.c_str()) + } + + baseType = (TypeImpl*)bt; + brestriction = isRestriction; + + // DataType and Sequenced must be the same as the base Type + isPrimitive = baseType->isPrimitive; + if (isPrimitive) + { + typeEnum = baseType->typeEnum; + } + + // Removing the following and allowing "sequenced" to be inherited from base type + /* + if (isSequenced && !baseType->isSequenced) + { + // Its an error to be sequenced and inherit from a + // non-sequenced type + string msg("Cannot be sequenced and inherit from a non-sequenced base type:"); + msg += getURI(); + msg += " "; + msg += getName(); + SDO_THROW_EXCEPTION("setBaseType", + SDOUnsupportedOperationException, + msg.c_str()); + } + */ + + isSequenced = baseType->isSequenced; + + // if the base is open then this type must be open too. + if (baseType->isOpenType()) + { + isOpen = true; + } + } + + bool TypeImpl::equals(const Type& tother) const + { + if (strcmp(typeURI,tother.getURI())) return false; + // TODO - aliases + if (strcmp(name, tother.getName())) return false; + return true; + } + + + const Type* TypeImpl::getBaseType() const + { + return (Type*)baseType; + } + + /////////////////////////////////////////////////////////////////////////// + // Returns the name of the type. + /////////////////////////////////////////////////////////////////////////// + + const char* TypeImpl::getName() const + { + return name; + } + + void TypeImpl::setAlias(const char* alias) + { + char* tmp = new char[strlen(alias)+1]; + strcpy(tmp,alias); + aliases.push_back(tmp); + } + + + + + const char* TypeImpl::getAlias(unsigned int index) const + { + if (index < aliases.size()) + { + return aliases[index]; + } + return name; + } + + unsigned int TypeImpl::getAliasCount() const + { + return aliases.size(); + } + /////////////////////////////////////////////////////////////////////////// + // Returns the namespace URI of the type. + /////////////////////////////////////////////////////////////////////////// + const char* TypeImpl::getURI() const + { + return typeURI; + } + + void TypeImpl::throwIfNestedChangeSummary() const + { + PROPERTY_LIST::const_iterator i; + for (i = props.begin(); i != props.end(); ++i) + { + + const TypeImpl *t = ((*i)->getTypeImpl()); + if (t != 0) + { + if (t->isDataObjectType()) + { + if (t->isChangeSummaryType()) + { + string msg(" Nested change summary type:"); + msg += t->getURI(); + msg += " "; + msg += t->getName(); + SDO_THROW_EXCEPTION("resolve", + SDOUnsupportedOperationException, + msg.c_str()); + } + t->throwIfNestedChangeSummary(); + } + } + } + } + + void TypeImpl::validateChangeSummary() + { + if (!isChangeSummaryType()) return; + throwIfNestedChangeSummary(); + } + + PROPERTY_LIST TypeImpl::getCompoundProperties() + { + return props; + } + + void TypeImpl::initCompoundProperties() + { + // We have already met this type in the resolution heirarchy + if (isResolving) + { + string msg(" circular type dependency on:"); + msg += getURI(); + msg += " "; + msg += getName(); + + SDO_THROW_EXCEPTION("initCompoundProperties", + SDOUnsupportedOperationException, + msg.c_str()); + } + + if (isResolved) + { + return; + } + + isResolving = true; + + + if (baseType != 0) + { + baseType->initCompoundProperties(); + PROPERTY_LIST pl = baseType->getCompoundProperties(); + localPropsSize = props.size(); + + // spec says the properties which are common are taken from + // the superclass. I imagine this will change , and only the + // ones taken from the subclass will be used. + + if (brestriction) + { + // restrict the properties to only those which + // appear in the parent + std::list<PropertyImpl*>::iterator p1,p; + for (p=pl.begin();p!=pl.end();++p) + { + for (p1=props.begin();p1!=props.end();++p1) + { + if (!strcmp((*p1)->getName(), + (*p)->getName())) + { + props.erase(p1); + localPropsSize = props.size(); + break; + } + } + } + + } + + props.insert(props.begin(),pl.begin(), pl.end()); + + isPrimitive = !(baseType->isDataObjectType()); + } + if (isPrimitive && (props.size() > 0)) + { + string msg("Add property to data type:"); + msg += getURI(); + msg += " "; + msg += getName(); + SDO_THROW_EXCEPTION("initCompoundProperties", + SDOUnsupportedOperationException, + msg.c_str()); + } + isResolved = true; + isResolving = false; + return; + } + + + /////////////////////////////////////////////////////////////////////////// + // Returns the list of the properties of this type. + /////////////////////////////////////////////////////////////////////////// + PropertyList TypeImpl::getProperties() const + { + return props; + } + + const std::list<PropertyImpl*>& TypeImpl::getPropertyListReference() const + { + return props; + } + + unsigned int TypeImpl::getPropertiesSize() const + { + return props.size(); + } + + /////////////////////////////////////////////////////////////////////////// + // Returns the property with the specified name. + /////////////////////////////////////////////////////////////////////////// + const Property& TypeImpl::getProperty(const char* propertyName) const + { + PropertyImpl* pi = getPropertyImpl(propertyName); + if (pi == 0) + { + string msg("Property not found:"); + msg += propertyName; + SDO_THROW_EXCEPTION("getProperty", + SDOPropertyNotFoundException, msg.c_str()); + } + return (Property&)*pi; + } + const Property& TypeImpl::getProperty(const SDOString& propertyName) const + { + PropertyImpl* pi = getPropertyImpl(propertyName); + if (pi == 0) + { + string msg("Property not found:"); + msg += propertyName; + SDO_THROW_EXCEPTION("getProperty", + SDOPropertyNotFoundException, msg.c_str()); + } + return (Property&)*pi; + } + + + /////////////////////////////////////////////////////////////////////////// + // Substitute Support - get the real underlying type + /////////////////////////////////////////////////////////////////////////// + + const Type& TypeImpl::getRealPropertyType(const std::string& propertyName) const + { + const TypeImpl* ti = getRealPropertyTypeImpl(propertyName); + if (ti != 0)return (Type&)*ti; + + string msg("Property not found:"); + msg += propertyName; + SDO_THROW_EXCEPTION("getProperty", + SDOPropertyNotFoundException, msg.c_str()); + + } + + + const TypeImpl* TypeImpl::getRealPropertyTypeImpl(const std::string& propertyName) const + { + + std::list<PropertyImpl*>::const_iterator i; + for (i = props.begin(); i != props.end(); ++i) + { + if (propertyName == (*i)->getName()) + { + return ((*i)->getTypeImpl()); + } + for (unsigned int k=0;k < (*i)->getAliasCount(); k++) + { + if (propertyName == (*i)->getAlias(k)) + { + return ((*i)->getTypeImpl()); + } + } + for (unsigned int j=0;j < (*i)->getSubstitutionCount(); j++) + { + if (propertyName == (*i)->getSubstitutionName(j)) + { + return (TypeImpl*)(*i)->getSubstitutionType(j); + } + } + } + return 0; + } + + /////////////////////////////////////////////////////////////////////////// + // Returns the property with the specified name. + /////////////////////////////////////////////////////////////////////////// + + PropertyImpl* TypeImpl::getPropertyImpl(const SDOString& propertyName) const + { + + // Extension - find the property from an xpath + // you should not be able to have both "." and "[" before a "/" - this is assumed. + + if (propertyName.length() == 0) return 0; + + // strchr returns NULL if target not found + // find_first_of returns string::npos in that case + // find_first_of returns the subscript of the character found eg 0 if it is the first + size_t tokenend = propertyName.find_first_of('/'); + size_t bracket = propertyName.find_first_of('['); + size_t dot = propertyName.find_first_of('.'); + size_t dotOrBracketOrSlash = propertyName.find_first_of(".[/"); + SDOString copy; + // char* copy; + + int len = propertyName.length(); + if (dotOrBracketOrSlash != string::npos) + { + len = dotOrBracketOrSlash; + } + + if (len != 0) + { + copy.assign(propertyName, 0, len); + } + else + { + copy = propertyName; + } + + std::list<PropertyImpl*>::const_iterator i; + for (i = props.begin(); i != props.end(); ++i) + { + if (!strcmp(copy.c_str(),(*i)->getName())) // ie the two strings are the same + { + // delete copy; + if ((tokenend != string::npos) && (propertyName.length() - tokenend) > 1) + { + // There is someting to the right of the "/" + const TypeImpl* ti = (*i)->getTypeImpl(); + if (ti != 0) + { + PropertyImpl* p = ti->getPropertyImpl(SDOString(propertyName, tokenend + 1, string::npos)); + return p; + } + else + { + return (PropertyImpl*)(*i); + } + } + else { + return (PropertyImpl*)(*i); + } + } + + for (unsigned int j = 0; j < (*i)->getSubstitutionCount(); j++) + { + if (!strcmp(copy.c_str(), (*i)->getSubstitutionName(j))) // ie the two strings are the same + { + // delete copy; + if ((tokenend != string::npos) && (propertyName.length() - tokenend) > 1) + { + // There is someting to the right of the "/" + const TypeImpl* ti = (*i)->getTypeImpl(); + if (ti != 0) + { + // PropertyImpl* p = ti->getPropertyImpl((const char *)(tokenend+1)); + PropertyImpl* p = ti->getPropertyImpl(SDOString(propertyName, tokenend + 1, string::npos)); + return p; + } + else + { + return (PropertyImpl*)(*i); + } + } + else { + return (PropertyImpl*)(*i); + } + } + } + for (unsigned int k = 0; k < (*i)->getAliasCount(); k++) + { + if (!strcmp(copy.c_str(), (*i)->getAlias(k))) // ie the two strings are the same + { + // delete copy; + if ((tokenend != string::npos) && (propertyName.length() - tokenend) > 1) + { + const TypeImpl* ti = (*i)->getTypeImpl(); + if (ti != 0) + { + // PropertyImpl* p = ti->getPropertyImpl((const char *)(tokenend+1)); + PropertyImpl* p = ti->getPropertyImpl(SDOString(propertyName, tokenend + 1, string::npos)); + return p; + } + else + { + return (PropertyImpl*)(*i); + } + } + else { + return (PropertyImpl*)(*i); + } + } + } + } + return 0; + } + + /////////////////////////////////////////////////////////////////////////// + // Returns the property with the specified name. + /////////////////////////////////////////////////////////////////////////// + PropertyImpl* TypeImpl::getPropertyImplPure(const char* propertyName) const + { + + + std::list<PropertyImpl*>::const_iterator i; + for (i = props.begin(); i != props.end(); ++i) + { + if (!strcmp(propertyName,(*i)->getName())) + { + return (PropertyImpl*)(*i); + } + for (unsigned int k=0;k < (*i)->getAliasCount(); k++) + { + if (!strcmp(propertyName,(*i)->getAlias(k))) + { + return (PropertyImpl*)(*i); + } + } + } + return 0; + } + + + /////////////////////////////////////////////////////////////////////////// + // Returns the property index with the specified name. + /////////////////////////////////////////////////////////////////////////// + unsigned int TypeImpl::getPropertyIndex(const char* propertyName) const + { + return getPropertyIndex(SDOString(propertyName)); + } + unsigned int TypeImpl::getPropertyIndex(const SDOString& propertyName) const + { + std::list<PropertyImpl*>::const_iterator i; + int j = 0; + for (i = props.begin(); i != props.end(); ++i) + { + if (!strcmp(propertyName.c_str(), (*i)->getName())) + { + return j; + } + j++; + } + string msg("Property not found:"); + msg += propertyName; + SDO_THROW_EXCEPTION("getPropertyIndex", + SDOPropertyNotFoundException, msg.c_str()); + } + + /////////////////////////////////////////////////////////////////////////// + // Returns the property with the specified name. + /////////////////////////////////////////////////////////////////////////// + const Property& TypeImpl::getProperty(unsigned int index) const + { + PropertyImpl* pi = getPropertyImpl(index); + if (pi == 0) + { + string msg("Property not found for index:"); + msg += index; + SDO_THROW_EXCEPTION("getProperty" , + SDOPropertyNotFoundException, msg.c_str()); + } + return (Property&)*pi; + } + + /////////////////////////////////////////////////////////////////////////// + // Returns the property with the specified index. + /////////////////////////////////////////////////////////////////////////// + PropertyImpl* TypeImpl::getPropertyImpl(unsigned int index) const + { + std::list<PropertyImpl*>::const_iterator i; + int count = 0; + for (i = props.begin() ; i != props.end() ; ++i) + { + if (count == index)return (PropertyImpl*)(*i); + count++; + } + return 0; + } + + + /////////////////////////////////////////////////////////////////////////// + // Returns the property with the specified name. + /////////////////////////////////////////////////////////////////////////// + void TypeImpl::addProperty(const char* propname, + const TypeImpl& t, + bool many, bool rdonly, bool cont) + { + // do not add duplicate properties + if (!getPropertyImplPure(propname)) + { + props.push_back(new PropertyImpl(*this, + propname, + t, + many, + rdonly, + cont)); + localPropsSize++; + } + } + + /////////////////////////////////////////////////////////////////////////// + // Indicates if this Type specifies DataObjects.. + /////////////////////////////////////////////////////////////////////////// + bool TypeImpl::isDataObjectType() const + { + return !isPrimitive; + } + + /////////////////////////////////////////////////////////////////////////// + // Indicates if this Type specifies Sequenced DataObjects. + /////////////////////////////////////////////////////////////////////////// + bool TypeImpl::isSequencedType() const + { + return isSequenced; + } + + /////////////////////////////////////////////////////////////////////////// + // Indicates if this Type allows any form of open content. + /////////////////////////////////////////////////////////////////////////// + bool TypeImpl::isOpenType() const + { + /* TODO - handle open types */ + return isOpen; + } + + /////////////////////////////////////////////////////////////////////////// + // Indicates if this type may not be instantiated. + /////////////////////////////////////////////////////////////////////////// + bool TypeImpl::isAbstractType() const + { + return isAbstract; + } + + void TypeImpl::setAbstract(bool set) + { + isAbstract = set; + } + + /////////////////////////////////////////////////////////////////////////// + // TODO - override ==. + /////////////////////////////////////////////////////////////////////////// + bool TypeImpl::equals(const Type& t) + { + return ( strcmp(getName(),t.getName()) == 0 + && strcmp(getURI (),t.getURI ()) == 0 ); + } + + /////////////////////////////////////////////////////////////////////////// + // getTypeEnum. + /////////////////////////////////////////////////////////////////////////// + Type::Types TypeImpl::getTypeEnum(void) const + { + return typeEnum; + } + + + /////////////////////////////////////////////////////////////////////////// + // Conversions. + // convert is used in the process of setting a value. The input is the + // result of a setXXX, so in the first case setBoolean. The typeEnum is the + // type of the value being set and governs the expected final result in + // the value* buffer. + /////////////////////////////////////////////////////////////////////////// + + unsigned int TypeImpl::convert(void** value,const bool b) const + { + switch (typeEnum) + { + case BooleanType: + case ByteType: + case CharacterType: + case IntegerType: + case ShortType: + if (*value != 0)delete (char*)(*value); + *value = new char[sizeof(long)]; + *(long*)*value = (long)b; + return sizeof(long); + + case LongType: + if (*value != 0)delete (char*)(*value); + *value = new char[sizeof(int64_t)]; + *(int64_t*)*value = (int64_t)b; + return sizeof(int64_t); + + case BigDecimalType: + case BigIntegerType: + case StringType: + case UriType: + if (*value != 0)delete (char*)(*value); + // spec change - types + *value = new wchar_t[6]; + if (b) + { + ((wchar_t*)(*value))[0] = (wchar_t)'t'; + ((wchar_t*)(*value))[1] = (wchar_t)'r'; + ((wchar_t*)(*value))[2] = (wchar_t)'u'; + ((wchar_t*)(*value))[3] = (wchar_t)'e'; + ((wchar_t*)(*value))[4] = 0; + return 4; + } + else + { + ((wchar_t*)(*value))[0] = (wchar_t)'f'; + ((wchar_t*)(*value))[1] = (wchar_t)'a'; + ((wchar_t*)(*value))[2] = (wchar_t)'l'; + ((wchar_t*)(*value))[3] = (wchar_t)'s'; + ((wchar_t*)(*value))[4] = (wchar_t)'e'; + ((wchar_t*)(*value))[5] = 0; + return 5; + } + break; + + + case BytesType: + { + if (*value != 0)delete (char*)(*value); + // spec change - types + *value = new char[6]; + if (b) + { + strcpy((char*)*value, "true"); + return 4; + } + else + { + strcpy((char*)*value, "false"); + return 5; + } + break; + + } + + case DoubleType: + case FloatType: + case DateType: + case OtherTypes: + case DataObjectType: + case ChangeSummaryType: + default: + { + string msg("Cannot set Boolean on object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("setBoolean" , + SDOInvalidConversionException, msg.c_str()); + break; + } + } + return 0; + } + + unsigned int TypeImpl::convert(void** value,const char c) const + { +#if __WORDSIZE ==64 + return convert(value,(int64_t)c); +#else + return convert(value,(long)c); +#endif + } + + unsigned int TypeImpl::convert(void** value,const wchar_t c) const + { +#if __WORDSIZE ==64 + return convert(value,(int64_t)c); +#else + return convert(value,(long)c); +#endif + } + + // This is set CString... + unsigned int TypeImpl::convert(void** value,const char* c) const + { + + switch (typeEnum) + { + case BooleanType: + if (*value != 0)delete ((char*)*value); + *value = new char[sizeof(long)]; + if ((c == 0) || strcmp(c,"true")) + { + *(long*)*value = 0; + } + else + { + *(long*)*value = 1; + } + return sizeof(long); + + case ByteType: + case CharacterType: + case IntegerType: + case ShortType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(long)]; + *(long*)*value = atoi(c); + return sizeof(long); + + case DoubleType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(long double)]; + // TODO - atof not suitable here + *(long double*)*value = (long double)atof(c); + return sizeof(long double); + + case FloatType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(float)]; + *(float*)*value = (float)atof(c); + return sizeof(float); + + case LongType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(int64_t)]; +#if defined(WIN32) || defined (_WINDOWS) + *(int64_t*)*value = (int64_t)_atoi64(c); +#else + *(int64_t*)*value = (int64_t)strtoll(c, NULL, 0); +#endif + return sizeof(int64_t); + + case DateType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(time_t)]; + *(time_t*)*value = (time_t)atoi(c); + return sizeof(time_t); + + case BigDecimalType: + case BigIntegerType: + case StringType: + case UriType: + { + if (*value != 0) delete ((wchar_t*)*value); + wchar_t* vw = new wchar_t[strlen(c)+1]; + for (unsigned int i=0;i< strlen(c);i++) + { + vw[i] = (wchar_t)c[i]; + } + vw[strlen(c)] = 0; + *value = (void*)vw; + return strlen(c); + } + break; + case BytesType: + { + if (*value != 0) delete ((char*)*value); + char* vc = new char[strlen(c)+1]; + for (unsigned int i=0;i< strlen(c);i++) + { + vc[i] = (char)c[i]; + } + vc[strlen(c)] = 0; + *value = (void*)vc; + return strlen(c); + } + break; + + case OtherTypes: + case DataObjectType: + case ChangeSummaryType: + default: + { + string msg("Cannot set CString on object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("setString" , + SDOInvalidConversionException, msg.c_str()); + break; + } + } + return 0; + } + + // +++ + + // This is set CString... + // The value supplied in s is converted and written to value. + unsigned int TypeImpl::convert(void** value, const SDOString& c) const + { + switch (typeEnum) + { + case BooleanType: + if (*value != 0) delete ((char*) *value); + *value = new char[sizeof(long)]; + + if (c == "true") + { + *(long*)*value = 0; + } + else + { + *(long*)*value = 1; + } + return sizeof(long); + + case ByteType: + case CharacterType: + case IntegerType: + case ShortType: + if (*value != 0) delete ((char*)*value); + + *value = new char[sizeof(long)]; + *(long*)*value = atoi(c.c_str()); + return sizeof(long); + + case DoubleType: + if (*value != 0) delete ((char*)*value); + + *value = new char[sizeof(long double)]; + // TODO - atof not suitable here + *(long double*)*value = (long double)atof(c.c_str()); + return sizeof(long double); + + case FloatType: + if (*value != 0) delete ((char*)*value); + + *value = new char[sizeof(float)]; + *(float*)*value = (float)atof(c.c_str()); + return sizeof(float); + + case LongType: + if (*value != 0) delete ((char*)*value); + + *value = new char[sizeof(int64_t)]; +#if defined(WIN32) || defined (_WINDOWS) + *(int64_t*)*value = (int64_t)_atoi64(c.c_str()); +#else + *(int64_t*)*value = (int64_t)strtoll(c.c_str(), NULL, 0); +#endif + return sizeof(int64_t); + + case DateType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(time_t)]; + *(time_t*)*value = (time_t)atoi(c.c_str()); + return sizeof(time_t); + + case BigDecimalType: + case BigIntegerType: + case StringType: + case UriType: + { + if (*value != 0) delete ((wchar_t*)*value); + wchar_t* vw = new wchar_t[c.length() + 1]; + for (unsigned int i = 0; i < c.length(); i++) + { + vw[i] = (wchar_t)c[i]; + } + vw[c.length()] = 0; + *value = (void*)vw; + return c.length(); + } + break; + case BytesType: + { + if (*value != 0) delete ((char*)*value); + char* vc = new char[c.length() + 1]; + for (unsigned int i = 0; i < c.length(); i++) + { + vc[i] = (char)c[i]; + } + vc[c.length()] = 0; + *value = (void*)vc; + return c.length(); + } + break; + + case OtherTypes: + case DataObjectType: + case ChangeSummaryType: + default: + { + string msg("Cannot set CString on object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("setString" , + SDOInvalidConversionException, msg.c_str()); + break; + } + } + return 0; + } + + + // --- + + // setString + unsigned int TypeImpl::convert(void** value,const wchar_t* b, unsigned int len) const + { + unsigned int i; + switch (typeEnum) + { + case BigDecimalType: + case BigIntegerType: + case UriType: + case StringType: + { + if (*value != 0) delete ((wchar_t*)*value); + wchar_t* vw = new wchar_t[len+1]; + for (i=0;i<len;i++) + { + vw[i] = b[i]; + } + vw[len] = 0; + *value = (void*)vw; + return len; + } + break; + + case BytesType: + { + if (*value != 0) delete ((char*)*value); + char* vc = new char[len+1]; + for (i=0;i<len;i++) + { + vc[i] = (char)b[i]; + } + vc[len] = 0; + *value = (void*)vc; + return len; + } + break; + + case BooleanType: + if (*value != 0)delete ((char*)*value); + *value = new char[sizeof(long)]; + if (len > 4) + { + *(long*)*value = 0; + } + else + { + if (b[0] == (wchar_t)'t' && + b[1] == (wchar_t)'r' && + b[2] == (wchar_t)'u' && + b[3] == (wchar_t)'e' ) + *(long*)*value = 1; + else *(long*)*value = 0; + } + return sizeof(long); + + case CharacterType: + case ByteType: + if (*value != 0)delete ((char*)*value); + *value = new char[sizeof(long)]; + if (len > 0) + { + *(long*)*value = (long)b[0]; + } + else + { + *(long*)*value = (long)0; + } + return sizeof(long); + + case ShortType: + case IntegerType: + { + if (*value != 0)delete ((char*)*value); + *value = new char[sizeof(long)]; + int val = 0; + for (unsigned int j=0;j<len;j++) + { + val += (1+ (10*j)) * ((char)b[len-1-j] - (char)'0'); + } + *(long*)*value = (long)val; + return sizeof(long); + } + + case LongType: + { + if (*value != 0)delete ((char*)*value); + *value = new char[sizeof(int64_t)]; + int64_t val = 0; + for (unsigned int j=0;j<len;j++) + { + val += (int64_t)(1+ (10*j)) * ((char)b[len-1-j] - (char)'0'); + } + *(int64_t*)*value = (int64_t)val; + return sizeof(long); + } + case DoubleType: + case FloatType: + case DateType: + case OtherTypes: + case DataObjectType: + case ChangeSummaryType: + default: + { + string msg("Cannot set String on object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("setString" , + SDOInvalidConversionException, msg.c_str()); + break; + } + } + return 0; + } + + // setBytes + unsigned int TypeImpl::convert(void** value,const char* b, unsigned int len) const + { + unsigned int i; + switch (typeEnum) + { + case BytesType: + { + if (*value != 0) delete ((char*)*value); + char* vc = new char[len+1]; + for (i=0;i<len;i++) + { + vc[i] = (char)b[i]; + } + vc[len] = 0; + *value = (void*)vc; + return len; + } + + case BigDecimalType: + case BigIntegerType: + case UriType: + case StringType: + { + if (*value != 0) delete ((wchar_t*)*value); + wchar_t* vw = new wchar_t[len+1]; + for (i=0;i<len;i++) + { + vw[i] = b[i]; + } + vw[len] = 0; + *value = (void*)vw; + return len; + } + + case BooleanType: + if (*value != 0)delete ((char*)*value); + *value = new char[sizeof(long)]; + if (len > 4) + { + *(long*)*value = 0; + } + else + { + if (b[0] == (char)'t' && + b[1] == (char)'r' && + b[2] == (char)'u' && + b[3] == (char)'e' ) + *(long*)*value = 1; + else *(long*)*value = 0; + } + return sizeof(long); + + case ByteType: + case CharacterType: + if (*value != 0)delete ((char*)*value); + *value = new char[sizeof(long)]; + if (len > 0) + { + *(long*)*value = (long)b[0]; + } + else + { + *(long*)*value = (long)0; + } + return sizeof(long); + + case IntegerType: + case ShortType: + { + if (*value != 0)delete ((char*)*value); + *value = new char[sizeof(long)]; + int val = 0; + for (unsigned int j=0;j<len;j++) + { + val += (1+ (10*j)) * ((char)b[len-1-j] - (char)'0'); + } + *(long*)*value = (long)val; + return sizeof(long); + } + + case LongType: + { + if (*value != 0)delete ((char*)*value); + *value = new char[sizeof(int64_t)]; + int64_t val = 0; + for (unsigned int j=0;j<len;j++) + { + val += (int64_t)(1+ (10*j)) * ((char)b[len-1-j] - (char)'0'); + } + *(int64_t*)*value = (int64_t)val; + return sizeof(long); + } + + case DoubleType: + case FloatType: + case DateType: + case OtherTypes: + case DataObjectType: + case ChangeSummaryType: + default: + { + string msg("Cannot set Bytes on object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("setBytes" , + SDOInvalidConversionException, msg.c_str()); + return 0; + } + } + return 0; + } + + // +++ + + unsigned int TypeImpl::convert(void** value, const SDOString& b, unsigned int len) const + { + unsigned int i; + switch (typeEnum) + { + case BytesType: + { + if (*value != 0) delete ((char*)*value); + + char* vc = new char[len + 1]; + b.copy(vc, len); + vc[len] = 0; + + *value = (void*)vc; + return len; + } + + case BigDecimalType: + case BigIntegerType: + case UriType: + case StringType: + { + if (*value != 0) delete ((wchar_t*)*value); + + wchar_t* vw = new wchar_t[len+1]; + // Can't use std::string.copy() because we are copying into wchar_t elements. + for (i=0;i<len;i++) + { + vw[i] = b[i]; + } + vw[len] = 0; + *value = (void*)vw; + return len; + } + + case BooleanType: + if (*value != 0)delete ((char*)*value); + *value = new char[sizeof(long)]; + if (len > 4) + { + *(long*)*value = 0; + } + else + { + if (b == "true") + *(long*)*value = 1; + else *(long*)*value = 0; + } + return sizeof(long); + + case ByteType: + case CharacterType: + if (*value != 0)delete ((char*)*value); + *value = new char[sizeof(long)]; + if (len > 0) + { + *(long*)*value = (long)b[0]; + } + else + { + *(long*)*value = (long)0; + } + return sizeof(long); + + case IntegerType: + case ShortType: + { + if (*value != 0)delete ((char*)*value); + *value = new char[sizeof(long)]; + int val = 0; + for (unsigned int j=0;j<len;j++) + { + val += (1+ (10*j)) * ((char)b[len-1-j] - (char)'0'); + } + *(long*)*value = (long)val; + return sizeof(long); + } + + case LongType: + { + if (*value != 0)delete ((char*)*value); + *value = new char[sizeof(int64_t)]; + int64_t val = 0; + for (unsigned int j=0;j<len;j++) + { + val += (int64_t)(1+ (10*j)) * ((char)b[len-1-j] - (char)'0'); + } + *(int64_t*)*value = (int64_t)val; + return sizeof(long); + } + + case DoubleType: + case FloatType: + case DateType: + case OtherTypes: + case DataObjectType: + case ChangeSummaryType: + default: + { + string msg("Cannot set Bytes on object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("setBytes" , + SDOInvalidConversionException, msg.c_str()); + return 0; + } + } + return 0; + } + + // --- + + unsigned int TypeImpl::convert(void** value,const short s) const + { +#if __WORDSIZE ==64 + return convert(value,(int64_t)s); +#else + return convert(value,(long)s); +#endif + } + +/* unsigned int TypeImpl::convert(void** value,const int i) const + { + return convert(value,(long)i); + } +*/ + unsigned int TypeImpl::convertDate(void** value, const SDODate i) const + { + switch (typeEnum) + { + case BooleanType: + { + string msg("Cannot set Date on object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("setDate" , + SDOInvalidConversionException, msg.c_str()); + break; + } + default: +#if __WORDSIZE ==64 + return convert(value, (int64_t)(i.getTime())); +#else + return convert(value, (long)(i.getTime())); +#endif + } + } + +#if __WORDSIZE !=64 + // setInteger + unsigned int TypeImpl::convert(void** value,const long i) const + { +#if ! defined(WIN32) && ! defined (_WINDOWS) + char *tmp = new char[MAX_LONG_SIZE]; + int j = 0; +#endif + switch (typeEnum) + { + case BooleanType: + case ByteType: + case CharacterType: + case IntegerType: + case ShortType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(long)]; + *(long*)*value = (long)i; + return sizeof(long); + + case DoubleType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(long double)]; + *(long double*)*value = (long double)i; + return sizeof(long double); + + case FloatType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(float)]; + *(float*)*value = (float)i; + return sizeof(float); + + case LongType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(int64_t)]; + *(int64_t*)*value = (int64_t)i; + return sizeof(int64_t); + + case DateType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(time_t)]; + *(time_t*)*value = (time_t)i; + return sizeof(time_t); + + case BigDecimalType: + case BigIntegerType: + case StringType: + case UriType: + { + if (*value != 0) delete ((wchar_t*)*value); + *value = new wchar_t[MAX_LONG_SIZE]; + // TODO - whats the equivalent of _ltow on linux? +#if defined(WIN32) || defined (_WINDOWS) + _ltow(i,(wchar_t*)*value,10); + return wcslen((wchar_t*)(*value)); +#else + sprintf(tmp,"%d", i); + for (j=0; j< strlen(tmp); j++) + { + ((wchar_t*)(*value))[j] = (wchar_t)tmp[j]; + } + ((wchar_t*)(*value))[strlen(tmp)] = 0; + delete tmp; + return j; +#endif + + } + + case BytesType: + { + if (*value != 0) delete ((wchar_t*)*value); + *value = new char[MAX_LONG_SIZE]; + // TODO - whats the equivalent of _ltow on linux? + sprintf((char*)*value,"%d", i); + return strlen((char*)(*value)); + + } + + case OtherTypes: + case DataObjectType: + case ChangeSummaryType: + default: + { + string msg("Cannot set Integer on object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("setInteger" , + SDOInvalidConversionException, msg.c_str()); + break; + } + } + } + +#endif + + // setLongLong + + unsigned int TypeImpl::convert(void** value,const int64_t l) const + { +#if ! defined(WIN32) && ! defined (_WINDOWS) + char *tmp = new char[MAX_LONG_SIZE]; + int j = 0; +#endif + switch (typeEnum) + { + case BooleanType: + case ByteType: + case CharacterType: + case IntegerType: + case ShortType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(long)]; + *(long*)*value = (long)l; + return sizeof(long); + + case DoubleType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(long double)]; + *(long double*)*value = (long double)l; + return sizeof(long double); + + case FloatType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(float)]; + *(float*)*value = (float)l; + return sizeof(float); + + case LongType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(int64_t)]; + *(int64_t*)*value = (int64_t)l; + return sizeof(int64_t); + + case DateType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(time_t)]; + *(time_t*)*value = (time_t)l; + return sizeof(time_t); + + case BigDecimalType: + case BigIntegerType: + case StringType: + case UriType: + { + if (*value != 0) delete ((wchar_t*)*value); + *value = new wchar_t[MAX_LONG_SIZE]; + // TODO - whats the equivalent of _ltow on linux? +#if defined(WIN32) || defined (_WINDOWS) + _i64tow(l,(wchar_t*)*value,10); + return wcslen((wchar_t*)(*value)); +#else + sprintf(tmp, "%lld", l); + for (j=0; j< strlen(tmp); j++) + { + ((wchar_t*)(*value))[j] = (wchar_t)tmp[j]; + } + ((wchar_t*)(*value))[strlen(tmp)] = 0; + delete tmp; + return j; +#endif + + } + + case BytesType: + { + if (*value != 0) delete ((char*)*value); + *value = new char[MAX_LONG_SIZE]; +#if defined(WIN32) || defined (_WINDOWS) + _i64toa(l,(char*)*value,10); +#else + sprintf((char*)*value, "%lld", l); +#endif + return strlen((char*)(*value)); + + } + + case OtherTypes: + case DataObjectType: + case ChangeSummaryType: + default: + { + string msg("Cannot set LongLong on object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("setLongLong" , + SDOInvalidConversionException, msg.c_str()); + break; + } + } + } + + // setFloat + unsigned int TypeImpl::convert(void** value,const float f) const + { + switch (typeEnum) + { + case BooleanType: + case ByteType: + case CharacterType: + case IntegerType: + case ShortType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(long)]; + *(long*)*value = (long)f; + return sizeof(long); + + case DoubleType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(long double)]; + *(long double*)*value = (long double)f; + return sizeof(long double); + + case FloatType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(float)]; + *(float*)*value = (float)f; + return sizeof(float); + + case LongType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(int64_t)]; + *(int64_t*)*value = (int64_t)f; + return sizeof(int64_t); + + case DateType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(time_t)]; + *(time_t*)*value = (time_t)f; + return sizeof(time_t); + + case BigDecimalType: + case BigIntegerType: + case StringType: + case UriType: + case BytesType: + case OtherTypes: + case DataObjectType: + case ChangeSummaryType: + default: + { + string msg("Cannot set Float on object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("setFloat" , + SDOInvalidConversionException, msg.c_str()); + break; + } + break; + } + } + + // TODO - storing the double as a long double - perhaps I need + // a new type? +/* unsigned int TypeImpl::convert(void** value,const double d) const + { + switch (typeEnum) + { + case BooleanType: + case ByteType: + case CharacterType: + case IntegerType: + case ShortType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(long)]; + *(long*)*value = (long)d; + return sizeof(long); + + case DoubleType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(long double)]; + *(long double*)*value = (long double)d; + return sizeof(long double); + + case FloatType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(float)]; + *(float*)*value = (float)d; + return sizeof(float); + + case LongType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(int64_t)]; + *(int64_t*)*value = (int64_t)d; + return sizeof(int64_t); + + case DateType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(time_t)]; + *(time_t*)*value = (time_t)d; + return sizeof(time_t); + + case BigDecimalType: + case BigIntegerType: + case StringType: + case UriType: + case BytesType: + case OtherTypes: + case DataObjectType: + case ChangeSummaryType: + default: + { + string msg("Cannot set Double on object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("setDouble" , + SDOInvalidConversionException, msg.c_str()); + break; + } + } + } +*/ + unsigned int TypeImpl::convert(void** value,const long double d) const + { + switch (typeEnum) + { + case BooleanType: + case ByteType: + case CharacterType: + case IntegerType: + case ShortType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(long)]; + *(long*)*value = (long)d; + return sizeof(long); + + case DoubleType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(long double)]; + *(long double*)*value = (long double)d; + return sizeof(long double); + + case FloatType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(float)]; + *(float*)*value = (float)d; + return sizeof(float); + + case LongType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(int64_t)]; + *(int64_t*)*value = (int64_t)d; + return sizeof(int64_t); + + case DateType: + if (*value != 0) delete ((char*)*value); + *value = new char[sizeof(time_t)]; + *(time_t*)*value = (time_t)d; + return sizeof(time_t); + + case BigDecimalType: + case BigIntegerType: + case StringType: + case UriType: + case BytesType: + case OtherTypes: + case DataObjectType: + case ChangeSummaryType: + default: + { + string msg("Cannot set Long Double on object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("setLongDouble" , + SDOInvalidConversionException, msg.c_str()); + break; + } + } + } + + unsigned int TypeImpl::convert(void** value,DataObject* dob) const + { + switch (typeEnum) + { + + case OtherTypes: + case DataObjectType: + *(DataObject**)value = dob; + return sizeof (void*); + + case BooleanType: + case ByteType: + case CharacterType: + case IntegerType: + case ShortType: + case DoubleType: + case FloatType: + case LongType: + case DateType: + case BigDecimalType: + case BigIntegerType: + case StringType: + case BytesType: + case UriType: + default: + { + string msg("Cannot set Data Object on object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("setDataObject" , + SDOInvalidConversionException, msg.c_str()); + break; + } + } + return 0; + } + + unsigned int TypeImpl::convertToString(void* value, wchar_t* outval, unsigned int len, + unsigned int max) const + { +#if ! defined(WIN32) && ! defined (_WINDOWS) + char* tmpstr = new char[MAX_LONG_SIZE]; + int j = 0; +#endif + unsigned int i; + switch (typeEnum) + { + + case BigDecimalType: + case BigIntegerType: + case UriType: + case StringType: + { + if (value == 0) return 0; + wchar_t* tmp = (wchar_t*)value; + for (i=0;(i < len) && (i < max);i++) + { + outval[i] = tmp[i]; + } + return len>max?max:len; + } + case BytesType: + { + if (value == 0) return 0; + char* tmp = (char*)value; + for (i=0;(i < len) && (i < max);i++) + { + outval[i] = (wchar_t)(tmp[i]); + } + return len>max?max:len; + } + + case BooleanType: + { + if (max < 4) return 0; + if (value == 0 || *(long*)value == 0) { + if (max < 5) return 0; + outval[0] = (wchar_t)'f'; + outval[1] = (wchar_t)'a'; + outval[2] = (wchar_t)'l'; + outval[3] = (wchar_t)'s'; + outval[4] = (wchar_t)'e'; + return 5; + } + else + { + outval[0] = (wchar_t)'t'; + outval[1] = (wchar_t)'r'; + outval[2] = (wchar_t)'u'; + outval[3] = (wchar_t)'e'; + return 4; + } + } + + case ByteType: + { + if (value == 0) return 0; + long tmp = *(long*)value; + outval[0] = (wchar_t)(tmp&0xFF); + return 1; + } + + case CharacterType: + { + if (value == 0) return 0; + long tmp = *(long*)value; + outval[0] = (wchar_t)(tmp & 0xFFFF); + return 1; + } + + case ShortType: + case IntegerType: + { + if (value == 0) return 0; + long tmp = *(long*)value; +#if defined(WIN32) || defined (_WINDOWS) + wchar_t* tmpstr = new wchar_t[MAX_LONG_SIZE]; + _ltow(tmp,tmpstr,10); + if (wcslen(tmpstr) > max) return 0; + _ltow(tmp,outval,10); + return wcslen(outval); +#else + sprintf(tmpstr, "%ld", tmp); + if (strlen(tmpstr) > max) return 0; + for (j=0; j< strlen(tmpstr); j++) + { + outval[j] = (wchar_t)tmpstr[j]; + } + delete tmpstr; + return j; +#endif + } + + + case LongType: + { + if (value == 0) return 0; + int64_t tmp = *(int64_t*)value; +#if defined(WIN32) || defined (_WINDOWS) + wchar_t* tmpstr = new wchar_t[MAX_LONG_SIZE]; + _i64tow(tmp,tmpstr,10); + if (wcslen(tmpstr) > max) + { + delete tmpstr; + return 0; + } + _i64tow(tmp,outval,10); + return wcslen(outval); +#else + sprintf(tmpstr, "%lld", tmp); + if (strlen(tmpstr) > max) return 0; + for (j=0; j< strlen(tmpstr); j++) + { + outval[j] = (wchar_t)tmpstr[j]; + } + delete tmpstr; + return j; +#endif + } + + case DateType: + { + + if (value == 0) return 0; + string msg("Conversion to string not implemented from type:"); + msg += getName(); + SDO_THROW_EXCEPTION("getString" , + SDOInvalidConversionException, msg.c_str()); + break; + } + + case DoubleType: + { + if (value == 0) return 0; + if (max < MAX_DOUBLE_SIZE) return 0; + wchar_t* fmt = new wchar_t[5]; + fmt[0] = (wchar_t)'%'; + fmt[1] = (wchar_t)'.'; + fmt[2] = (wchar_t)'3'; + fmt[3] = (wchar_t)'e'; + fmt[4] = (wchar_t)0; +#if defined(WIN32) || defined (_WINDOWS) + swprintf((wchar_t*)outval,fmt,*(long double*)value); +#else +#if defined(NO_SWPRINTF) + { + int k; + char *tmpbuf = new char[50]; + wchar_t *tmpw = (wchar_t*)outval; + sprintf(tmpbuf,"%.3Le",*(long double*)value); + for (k=0;k<strlen(tmpbuf);k++) + { + *(tmpw++) = (wchar_t)(tmpbuf[k]); + } + *tmpw = 0; + delete tmpbuf; + } + +#else + swprintf((wchar_t*)outval, wcslen((wchar_t*)outval), fmt, *(long double*)value); +#endif +#endif + delete fmt; + + return wcslen(outval); + } + case FloatType: + { + if (value == 0) return 0; + if (max < MAX_FLOAT_SIZE) return 0; + wchar_t* fmt = new wchar_t[5]; + fmt[0] = (wchar_t)'%'; + fmt[1] = (wchar_t)'.'; + fmt[2] = (wchar_t)'3'; + fmt[3] = (wchar_t)'e'; + fmt[4] = (wchar_t)0; +#if defined(WIN32) || defined (_WINDOWS) + swprintf(outval,fmt,*(float*)value); +#else +#if defined(NO_SWPRINTF) + { + int k; + char *tmpbuf = new char[50]; + wchar_t *tmpw = (wchar_t*)outval; + sprintf(tmpbuf,"%.3e",*(float*)value); + for (k=0;k<strlen(tmpbuf);k++) + { + *(tmpw++) = (wchar_t)(tmpbuf[k]); + } + *tmpw = 0; + delete tmpbuf; + } +#else + swprintf(outval, wcslen(outval), fmt, *(float*)value); +#endif +#endif + delete fmt; + + return wcslen(outval); + } + + case OtherTypes: + case DataObjectType: + default: + { + string msg("Cannot get String from object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("getString" , + SDOInvalidConversionException, msg.c_str()); + break; + } + } + return 0; + } + +unsigned int TypeImpl::convertToString(const SDOValue& sdoValue, + wchar_t* outval, + unsigned int max) const +{ + switch (typeEnum) + { + case BigDecimalType: + case BigIntegerType: + case UriType: + case StringType: + case BytesType: + case BooleanType: + case ByteType: + case CharacterType: + case ShortType: + case IntegerType: + case LongType: + case DateType: + case DoubleType: + case FloatType: + return sdoValue.getString(outval, max); + + case OtherTypes: + case DataObjectType: + default: + { + string msg("Cannot get String from object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("getString" , + SDOInvalidConversionException, + msg.c_str()); + break; + } + } + return 0; +} + + unsigned int TypeImpl::convertToBytes(void* value, char* outval, unsigned int len, + unsigned int max) const + { + unsigned int i; + switch (typeEnum) + { + case BytesType: + { + if (value == 0) return 0; + char* tmp = (char*)value; + for (i=0;(i < max) && (i < len);i++) + { + outval[i] = tmp[i]; + } + return len>max?max:len; + } + + case BigDecimalType: + case BigIntegerType: + case UriType: + case StringType: + { + if (value == 0) return 0; + wchar_t* tmp = (wchar_t*)value; + for (i=0;(i < max) && (i < len);i++) + { + outval[i] = (char)(tmp[i]); + } + return len>max?max:len; + } + + case BooleanType: + { + if (value == 0 || *(long*)value == 0) { + if (max < 5) return 0; + outval[0] = 'f'; + outval[1] = 'a'; + outval[2] = 'l'; + outval[3] = 's'; + outval[4] = 'e'; + return 5; + } + else { + if (max < 4) return 0; + outval[0] = 't'; + outval[1] = 'r'; + outval[2] = 'u'; + outval[3] = 'e'; + return 4; + } + return 0; + } + + case CharacterType: + case ByteType: + { + if (value == 0) return 0; + long tmp = *(long*)value; + outval[0] = (char)(tmp&0xFF); + return 1; + } + + case ShortType: + case IntegerType: + { + if (value == 0) return 0; + long tmp = *(long*)value; + char* tmpstr = new char[MAX_LONG_SIZE]; + sprintf(tmpstr, "%ld", tmp); + if (strlen(tmpstr) > max) + { + delete tmpstr; + return 0; + } + delete tmpstr; + sprintf(outval, "%ld", tmp); + return strlen(outval); + } + + + case LongType: + { + if (value == 0) return 0; + int64_t tmp = *(int64_t*)value; + char * tmpstr = new char[MAX_LONG_SIZE]; + sprintf(tmpstr, "%lld", tmp); + if (strlen(tmpstr) > max) + { + delete tmpstr; + return 0; + } + delete tmpstr; + sprintf(outval, "%lld", tmp); + return strlen(outval); + } + case DateType: + { + if (value == 0) return 0; + string msg("Conversion to string not implemented from type:"); + msg += getName(); + SDO_THROW_EXCEPTION("getBytes" , + SDOInvalidConversionException, msg.c_str()); + break; + } + + case DoubleType: + if (value == 0) return 0; + if (max < MAX_DOUBLE_SIZE) return 0; + sprintf(outval,"%.3Le",*(long double*)value); + return strlen(outval); + + case FloatType: + if (value == 0) return 0; + if (max < MAX_FLOAT_SIZE) return 0; + sprintf(outval,"%.3e",*(float*)value); + return strlen(outval); + + case OtherTypes: + case DataObjectType: + default: + { + if (max < 9) return 0; + sprintf(outval,"%08x",value); + //string msg("Cannot get Bytes from object of type:"); + //msg += getName(); + //SDO_THROW_EXCEPTION("getBytes" , + // SDOInvalidConversionException, msg.c_str()); + return strlen(outval); + } + } + return 0; + } + + unsigned int TypeImpl::convertToBytes(const SDOValue& sdoValue, char* outptr, unsigned int max) const + { + unsigned int i; + switch (typeEnum) + { + case BytesType: + case BigDecimalType: + case BigIntegerType: + case UriType: + case StringType: + case BooleanType: + case CharacterType: + case ByteType: + case ShortType: + case IntegerType: + case LongType: + case DateType: + case DoubleType: + case FloatType: + return sdoValue.getBytes(outptr, max); + + case DataObjectType: + case OtherTypes: + default: + string msg("Cannot get Bytes from object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("getBytes" , + SDOInvalidConversionException, + msg.c_str()); + } + return 0; + } + + + // +++ + + // value is a pointer to the byte stream that is the value to convert + // outval is the resulting string representation of value + // len is the length of the input byte stream, it is used only when the length cannot be inferred from other information. + // max is the maximum size allowed for the output byte stream. (Not strictly needed when the output is an std::string but we maintain the behaviour from the earlier method. + + // Questions + // 1. Why isn't value const? + // + unsigned int TypeImpl::convertToBytes(const void* value, + SDOString& outval, + unsigned int len, + unsigned int max) const + { + unsigned int i; + outval.erase(); + switch (typeEnum) + { + case BytesType: + { + if (value == 0) return 0; + + const char* tempPtr = (const char*) value; + unsigned int count = (len > max) ? max : len; + outval.assign(tempPtr, count); + + return count; + } + + case BigDecimalType: + case BigIntegerType: + case UriType: + case StringType: + { + if (value == 0) return 0; + + const wchar_t* tempPtr = (const wchar_t*) value; + unsigned int count = (len > max) ? max : len; + + // The following loop copies the low byte from each 2 byte wchar_t + // into one byte of the target array eg H_E_L_P -> HELP + for (i = 0; (i < count); i++) + { + outval += (char)(tempPtr[i]); + } + return count; + } + + case BooleanType: + { + if (value == 0 || *(const long*)value == 0) { + if (max < 5) return 0; + outval = "false"; + return 5; + } + else { + if (max < 4) return 0; + outval = "true"; + return 4; + } + return 0; + } + + case CharacterType: + case ByteType: + { + if (value == 0) return 0; + + const long tmp = *(const long*)value; + outval += (char)(tmp&0xFF); + return 1; + } + + case ShortType: + case IntegerType: + { + if (value == 0) return 0; + + const long tmp = *(const long*) value; + char* tmpstr = new char[MAX_LONG_SIZE + 1]; + sprintf(tmpstr, "%ld", tmp); + if (strlen(tmpstr) > max) + { + delete tmpstr; + return 0; + } + outval = tmpstr; + delete tmpstr; + return outval.length(); + } + + case LongType: + { + if (value == 0) return 0; + + const int64_t tmp = *(const int64_t*)value; + char* tmpstr = new char[MAX_LONG_SIZE + 1]; + sprintf(tmpstr, "%lld", tmp); + if (strlen(tmpstr) > max) + { + delete tmpstr; + return 0; + } + outval = tmpstr; + delete tmpstr; + return outval.length(); + } + case DateType: + { + if (value == 0) return 0; + + string msg("Conversion to string not implemented from type:"); + msg += getName(); + SDO_THROW_EXCEPTION("getBytes" , + SDOInvalidConversionException, msg.c_str()); + break; + } + + case DoubleType: + { + if (value == 0) return 0; + + if (max < MAX_DOUBLE_SIZE) return 0; + + char* tmpstr = new char[MAX_DOUBLE_SIZE + 1]; + sprintf(tmpstr, "%.3Le", *(const long double*)value); + outval = tmpstr; + delete tmpstr; + return outval.length(); + } + + case FloatType: + { + if (value == 0) return 0; + + if (max < MAX_FLOAT_SIZE) return 0; + + char* tmpstr = new char[MAX_FLOAT_SIZE + 1]; + sprintf(tmpstr, "%.3Le", *(const float*)value); + outval = tmpstr; + delete tmpstr; + return outval.length(); + } + + case OtherTypes: + case DataObjectType: + default: + { + if (max < 9) return 0; + + char tmpstr[9]; + sprintf(tmpstr, "%08x", value); + outval = tmpstr; + //string msg("Cannot get Bytes from object of type:"); + //msg += getName(); + //SDO_THROW_EXCEPTION("getBytes" , + // SDOInvalidConversionException, msg.c_str()); + return outval.length(); + } + } + return 0; + } + + // --- + + const char* TypeImpl::convertToCString(void* value, char** asstringbuf, unsigned int len) const + { + unsigned int i; + + switch (typeEnum) + { + case BooleanType: + if (value == 0 || *(long*)value == 0) { + *asstringbuf = new char[6]; + strcpy(*asstringbuf,"false"); + } + else { + *asstringbuf = new char[5]; + strcpy(*asstringbuf,"true"); + } + return *asstringbuf; + + case ByteType: + *asstringbuf = new char[MAX_LONG_SIZE]; + if (value == 0){ + sprintf(*asstringbuf,"%ld",0); + } + else { + sprintf(*asstringbuf,"%ld",*(long*)value); + } + return *asstringbuf; + + case CharacterType: + *asstringbuf = new char[MAX_LONG_SIZE]; + if (value == 0){ + sprintf(*asstringbuf,"%ld",0); + } + else { + sprintf(*asstringbuf,"%ld", *(long*)value); + } + return *asstringbuf; + + case IntegerType: + *asstringbuf = new char[MAX_LONG_SIZE]; + if (value == 0){ + sprintf(*asstringbuf,"%ld",0); + } + else { + sprintf(*asstringbuf,"%ld", *(long*)value); + } + return *asstringbuf; + + case ShortType: + *asstringbuf = new char[MAX_LONG_SIZE]; + if (value == 0){ + sprintf(*asstringbuf,"%ld",0); + } + else { + sprintf(*asstringbuf,"%ld", *(long*)value); + } + return *asstringbuf; + + case DoubleType: + *asstringbuf = new char[MAX_DOUBLE_SIZE]; + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + (*asstringbuf)[0] = 0; + return *asstringbuf; + } + sprintf(*asstringbuf,"%.3Le",*(long double*)value); + return *asstringbuf; + + case FloatType: + *asstringbuf = new char[MAX_FLOAT_SIZE]; + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + (*asstringbuf)[0] = 0; + return *asstringbuf; + } + sprintf(*asstringbuf,"%.3e", *(float*)value); + return *asstringbuf; + + case LongType: + { + *asstringbuf = new char[MAX_LONG_SIZE]; + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + (*asstringbuf)[0] = 0; + return *asstringbuf; + } + int64_t temp = *(int64_t*)value; +#if defined(WIN32) || defined (_WINDOWS) + sprintf(*asstringbuf,"%I64d", temp); +#else + sprintf(*asstringbuf,"%lld", temp); +#endif + return *asstringbuf; + } + case DateType: + *asstringbuf = new char[MAX_LONG_SIZE]; + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + (*asstringbuf)[0] = 0; + return *asstringbuf; + } + sprintf(*asstringbuf,"%ld", *(time_t*)value); + return *asstringbuf; + + case BigDecimalType: + case BigIntegerType: + case StringType: + case UriType: + { + if (value == 0 || len == 0) + { + *asstringbuf = new char[1]; + (*asstringbuf)[0] = 0; + return *asstringbuf; + } + *asstringbuf = new char[len + 1]; + wchar_t* tmp = (wchar_t*)value; + for (i=0;i< len;i++) + { + (*asstringbuf)[i] = tmp[i] & 0xFF; + } + (*asstringbuf)[i] = 0; + return *asstringbuf; + } + + case BytesType: + { + if (value == 0 || len == 0) + { + *asstringbuf = new char[1]; + (*asstringbuf)[0] = 0; + return *asstringbuf; + } + *asstringbuf = new char[len + 1]; + char* tmp = (char*)value; + for (i=0;i< len ;i++) + { + (*asstringbuf)[i] = (char)(tmp[i]); + } + (*asstringbuf)[i] = 0; + return *asstringbuf; + } + + + case OtherTypes: + case DataObjectType: + default: + { + *asstringbuf = new char[9]; + sprintf(*asstringbuf,"%08x",value); + //string msg("Cannot get CString from object of type:"); + //msg += getName(); + //SDO_THROW_EXCEPTION("getCString" , + // SDOInvalidConversionException, msg.c_str()); + return *asstringbuf; + } + } + return 0; + } + + const char* TypeImpl::convertToCString(const SDOValue& sdoValue) const + { + + switch (typeEnum) + { + case BooleanType: + case ByteType: + case CharacterType: + case IntegerType: + case ShortType: + case DoubleType: + case FloatType: + case LongType: + case DateType: + case BigDecimalType: + case BigIntegerType: + case StringType: + case UriType: + case BytesType: + return sdoValue.getCString(); + + case OtherTypes: + case DataObjectType: + default: + { + string msg("Cannot get CString from object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("getCString" , + SDOInvalidConversionException, + msg.c_str()); + } + return 0; + } + } + + + const bool TypeImpl::convertToBoolean(void* value, unsigned int len) const + { + switch (typeEnum) + { + case BooleanType: + case ByteType: + case CharacterType: + case IntegerType: + case ShortType: + if (value == 0) return false; + if (*(long*)value != 0) return true; + return false; + + case DoubleType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return false; + } + if (*(long double*)value != 0.0) return true; + return false; + + case FloatType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return false; + } + if (*(float*)value != 0.0) return true; + return false; + + case LongType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return false; + } + if (*(int64_t*)value != 0)return true; + return false; + + case DateType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return false; + } + if (*(time_t*)value != 0)return true; + return false; + + case BigDecimalType: + case BigIntegerType: + case StringType: + case UriType: + if (value == 0 || len < 4) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return false; + } + if ( ((wchar_t*)value)[0] == (wchar_t)'t' && + ((wchar_t*)value)[1] == (wchar_t)'r' && + ((wchar_t*)value)[2] == (wchar_t)'u' && + ((wchar_t*)value)[3] == (wchar_t)'e' ) + return true; + + return false; + + case BytesType: + if (value == 0 || len < 4) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return false; + } + if (!strncmp((char*)value,"true", 4)) return true; + return false; + + case OtherTypes: + case DataObjectType: + default: + { + string msg("Cannot get Boolean from object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("getBoolean" , + SDOInvalidConversionException, msg.c_str()); + break; + } + } + + } + + const bool TypeImpl::convertToBoolean(const SDOValue& sdoValue) const + { + switch (typeEnum) + { + case BooleanType: + case ByteType: + case CharacterType: + case IntegerType: + case ShortType: + case DoubleType: + case FloatType: + case LongType: + case DateType: + case BigDecimalType: + case BigIntegerType: + case StringType: + case UriType: + case BytesType: + return sdoValue.getBoolean(); + + case OtherTypes: + case DataObjectType: + default: + { + string msg("Cannot get Boolean from object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("getBoolean" , + SDOInvalidConversionException, + msg.c_str()); + break; + } + } + } + + + const char TypeImpl::convertToByte(void* value , unsigned int len) const + { + switch (typeEnum) + { + case BooleanType: + case ByteType: + case CharacterType: + case IntegerType: + case ShortType: + if (value == 0) return 0; + return (char)(*(long*)value); + + case DoubleType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } + return (char)(*(long double*)value); + + case FloatType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } + return (char)(*(float*)value); + + case LongType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } + return (char)(*(int64_t*)value); + + case DateType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } + + return (char)(*(time_t*)value); + + case BigDecimalType: + case BigIntegerType: + case StringType: + case UriType: + { + if (value == 0) return 0; + // Assume the string is a number eg "123" and attempt to convert it. + +#if defined(WIN32) || defined(_WINDOWS) + return (char) _wtoi((wchar_t*) value); +#else + char* tmpstr = new char[len + 1]; + short s = 0; + wchar_t* srcptr = (wchar_t*) value; + + for (int j = 0; j < len; j++) + { + tmpstr[j] = (char) srcptr[j]; + } + tmpstr[len] = 0; + s = (char) atoi(tmpstr); + delete tmpstr; + return (char) s; +#endif + } + + case BytesType: + { + if (value == 0) return 0; + return (char)*(char*)value; + } + + + case OtherTypes: + case DataObjectType: + default: + { + string msg("Cannot get Byte from object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("getByte" , + SDOInvalidConversionException, msg.c_str()); + break; + } + } + } + + const char TypeImpl::convertToByte(const SDOValue& sdoValue) const + { + switch (typeEnum) + { + case BooleanType: + case ByteType: + case CharacterType: + case IntegerType: + case ShortType: + case DoubleType: + case FloatType: + case LongType: + case DateType: + case BigDecimalType: + case BigIntegerType: + case StringType: + case UriType: + case BytesType: + return sdoValue.getByte(); + + case OtherTypes: + case DataObjectType: + default: + { + string msg("Cannot get Byte from object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("getByte", + SDOInvalidConversionException, + msg.c_str()); + break; + } + } + } + + + const wchar_t TypeImpl::convertToCharacter(void* value, unsigned int len) const + { + switch (typeEnum) + { + case BooleanType: + case ByteType: + case CharacterType: + case IntegerType: + case ShortType: + if (value == 0) return 0; + return (wchar_t)(*(long*)value); + + case DoubleType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } + return (wchar_t)(*(long double*)value); + + case FloatType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } + return (wchar_t)(*(float*)value); + + case LongType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } + return (wchar_t)(*(int64_t*)value); + + case DateType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } + return (wchar_t)(*(time_t*)value); + + case BigDecimalType: + case BigIntegerType: + case StringType: + case UriType: + { + if (value == 0) return 0; + return *(wchar_t*)value; + } + + case BytesType: + { + if (value == 0) return 0; + return (wchar_t)*(char*)value; + } + + case OtherTypes: + case DataObjectType: + default: + { + string msg("Cannot get Character from object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("getCharacter" , + SDOInvalidConversionException, msg.c_str()); + break; + } + } + } + + + const wchar_t TypeImpl::convertToCharacter(const SDOValue& sdoValue) const + { + switch (typeEnum) + { + case BooleanType: + case ByteType: + case CharacterType: + case IntegerType: + case ShortType: + case DoubleType: + case FloatType: + case LongType: + case DateType: + case BigDecimalType: + case BigIntegerType: + case StringType: + case UriType: + case BytesType: + return sdoValue.getCharacter(); + + case OtherTypes: + case DataObjectType: + default: + { + string msg("Cannot get Character from object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("getCharacter" , + SDOInvalidConversionException, msg.c_str()); + break; + } + } + } + + + + const short TypeImpl::convertToShort(void* value, unsigned int len) const + { +#if ! defined(WIN32) && !defined (_WINDOWS) + char* tmpstr = new char[len+1]; + short s = 0; +#endif + switch (typeEnum) + { + case BooleanType: + case ByteType: + case CharacterType: + case IntegerType: + case ShortType: + if (value == 0) return 0; + return (short)(*(long*)value); + + case DoubleType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } + return (short)(*(long double*)value); + + case FloatType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } + return (short)(*(float*)value); + + case LongType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } + return (short)(*(int64_t*)value); + + case DateType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } + return (short)(*(time_t*)value); + + case BigDecimalType: + case BigIntegerType: + case StringType: + case UriType: + if (value == 0 || len == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } +#if defined(WIN32) || defined (_WINDOWS) + return (short)_wtoi((wchar_t*)value); +#else + for (int j=0;j< len;j++) + { + tmpstr[j] = (char)((char *)value)[j]; + } + tmpstr[len] = 0; + s = (short) atoi(tmpstr); + delete tmpstr; + return s; +#endif + + + case BytesType: + case OtherTypes: + case DataObjectType: + default: + { + string msg("Cannot get Short from object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("getShort" , + SDOInvalidConversionException, msg.c_str()); + break; + } + } + } + + const short TypeImpl::convertToShort(const SDOValue& sdoValue) const + { + switch (typeEnum) + { + case BooleanType: + case ByteType: + case CharacterType: + case IntegerType: + case ShortType: + case DoubleType: + case FloatType: + case LongType: + case DateType: + case BigDecimalType: + case BigIntegerType: + case StringType: + case UriType: + case BytesType: + return sdoValue.getShort(); + + case OtherTypes: + case DataObjectType: + default: + { + string msg("Cannot get Short from object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("getShort" , + SDOInvalidConversionException, + msg.c_str()); + break; + } + } + } + + +/* const int TypeImpl::convertToInt(void* value, unsigned int len) const + { + switch (typeEnum) + { + case BooleanType: + case ByteType: + case CharacterType: + case IntegerType: + case ShortType: + if (value == 0) return 0; + return (int)(*(long*)value); + + case DoubleType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } + return (int)(*(long double*)value); + + case FloatType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } + return (int)(*(float*)value); + + case LongType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } + return (int)(*(int64_t*)value); + + case DateType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } + return (int)(*(time_t*)value); + + case BigDecimalType: + case BigIntegerType: + case StringType: + case UriType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } +#if defined(WIN32) || defined (_WINDOWS) + return (int)_wtoi((wchar_t*)value); +#else + char* tmp = new char[len+1]; + int j = 0;; + for (j=0;j<len;j++) + { + tmp[j] = (char)(wchar_t*)value[j]; + } + tmp[j] = 0; + j = atoi(tmp); + delete tmp; + return j; +#endif + + case BytesType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } + return (int)atoi((char*)value); + + case OtherTypes: + case DataObjectType: + default: + { + string msg("Cannot get Int from object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("getInt" , + SDOInvalidConversionException, msg.c_str()); + break; + } + } + } + + */ + const long TypeImpl::convertToInteger(void* value, unsigned int len) const + { +#if ! defined(WIN32) && ! defined (_WINDOWS) + char* tmp = new char[len+1]; + int j = 0; + long l = 0; +#endif + switch (typeEnum) + { + case BooleanType: + case ByteType: + case CharacterType: + case IntegerType: + case ShortType: + if (value == 0) return 0; + return (long)(*(long*)value); + + case DoubleType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } + return (long)(*(long double*)value); + + case FloatType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } + return (long)(*(float*)value); + + case LongType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } + return (long)(*(int64_t*)value); + + case DateType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } + return (long)(*(time_t*)value); + + case BigDecimalType: + case BigIntegerType: + case StringType: + case UriType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } +#if defined(WIN32) || defined (_WINDOWS) + return (long)_wtol((wchar_t*)value); +#else + for (j=0;j<len;j++) + { + tmp[j] = (char)((wchar_t*)value)[j]; + } + tmp[j] = 0; + l = atol(tmp); + delete tmp; + return l; +#endif + + case BytesType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } + return (int)atol((char*)value); + + case OtherTypes: + case DataObjectType: + default: + { + string msg("Cannot get Long from object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("getLong" , + SDOInvalidConversionException, msg.c_str()); + break; + } + } + } + + const long TypeImpl::convertToInteger(const SDOValue& sdoValue) const + { + switch (typeEnum) + { + case BooleanType: + case ByteType: + case CharacterType: + case IntegerType: + case ShortType: + case DoubleType: + case FloatType: + case LongType: + case DateType: + case BigDecimalType: + case BigIntegerType: + case StringType: + case UriType: + case BytesType: + return sdoValue.getInteger(); + + case OtherTypes: + case DataObjectType: + default: + { + string msg("Cannot get Long from object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("getLong" , + SDOInvalidConversionException, + msg.c_str()); + break; + } + } + } + + + const int64_t TypeImpl::convertToLong(void* value, unsigned int len) const + { +#if ! defined(WIN32) && ! defined (_WINDOWS) + char* tmp = new char[len+1]; + int j = 0; + int64_t l = 0; +#endif + switch (typeEnum) + { + case BooleanType: + case CharacterType: + case ByteType: + case IntegerType: + case ShortType: + if (value == 0) return 0; + return (int64_t)(*(long*)value); + + case DoubleType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } + return (int64_t)(*(long double*)value); + + case FloatType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } + return (int64_t)(*(float*)value); + + case LongType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } + return (int64_t)(*(int64_t*)value); + + case DateType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } + return (int64_t)(*(time_t*)value); + + case BigDecimalType: + case BigIntegerType: + case StringType: + case UriType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } +#if defined(WIN32) || defined (_WINDOWS) + return (long)_wtol((wchar_t*)value); +#else + for (j=0;j<len;j++) + { + tmp[j] = (char)((wchar_t*)value)[j]; + } + tmp[j] = 0; + l = strtoll(tmp, NULL, 0); + delete tmp; + return l; +#endif + + + case BytesType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } +#if defined(WIN32) || defined (_WINDOWS) + return _atoi64((char*)value); +#else + return strtoll((char*)value, NULL, 0); +#endif + + case OtherTypes: + case DataObjectType: + default: + { + string msg("Cannot get Long Long from object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("getLongLong" , + SDOInvalidConversionException, msg.c_str()); + break; + } + } + } + + const int64_t TypeImpl::convertToLong(const SDOValue& sdoValue) const + { + switch (typeEnum) + { + case BooleanType: + case CharacterType: + case ByteType: + case IntegerType: + case ShortType: + case DoubleType: + case FloatType: + case LongType: + case DateType: + case BigDecimalType: + case BigIntegerType: + case StringType: + case UriType: + case BytesType: + return sdoValue.getLong(); + + case OtherTypes: + case DataObjectType: + default: + { + string msg("Cannot get Long Long from object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("getLongLong" , + SDOInvalidConversionException, msg.c_str()); + break; + } + } + } + + + const float TypeImpl::convertToFloat(void* value, unsigned int len) const + { + switch (typeEnum) + { + case BooleanType: + case ByteType: + case CharacterType: + case IntegerType: + case ShortType: + if (value == 0) return 0; + return (float)(*(long*)value); + + case DoubleType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0.0; + } + return (float)(*(long double*)value); + + case FloatType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0.0; + } + return (float)(*(float*)value); + + case LongType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0.0; + } + return (float)(*(int64_t*)value); + + case DateType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0.0; + } + return (float)(*(time_t*)value); + + case BigDecimalType: + case BigIntegerType: + case StringType: + case UriType: + { + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0.0; + } + char* tmp = new char[len+1]; + for (unsigned int j=0;j<len;j++) + { + tmp[j] = (char)((wchar_t*)value)[j]; + } + tmp[len] = 0; + float f = atof(tmp); + delete tmp; + return f; + } + + case BytesType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0.0; + } + return (float)atof((char*)value); + + case OtherTypes: + case DataObjectType: + default: + { + string msg("Cannot get Float from object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("getFloat" , + SDOInvalidConversionException, msg.c_str()); + break; + } + } + } + + /*const double TypeImpl::convertToDouble(void* value, unsigned int len) const + { + switch (typeEnum) + { + case BooleanType: + case ByteType: + case CharacterType: + case IntegerType: + case ShortType: + if (value == 0) return 0; + return (double)(*(long*)value); + + case DoubleType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0.0; + } + return (double)(*(long double*)value); + + case FloatType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0.0; + } + return (double)(*(float*)value); + + case LongType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0.0; + } + return (double)(*(int64_t*)value); + + case DateType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0.0; + } + return (double)(*(time_t*)value); + + case BigDecimalType: + case BigIntegerType: + case StringType: + case UriType: + { + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0.0; + } + char* tmp = new char[len+1]; + int j = 0; + for (j=0;j<len;j++) + { + tmp[j] = (char)((wchar_t*)value)[j]; + } + tmp[len] = 0; + float f = atof(tmp); + delete tmp; + return (double)f; + } + case BytesType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0.0; + } + return (double)atof((char*)value); + + case OtherTypes: + case DataObjectType: + default: + { + string msg("Cannot get LongDouble from object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("getLongDouble" , + SDOInvalidConversionException, msg.c_str()); + break; + } + } + } +*/ + const long double TypeImpl::convertToDouble(void* value, unsigned int len) const + { + switch (typeEnum) + { + case BooleanType: + case ByteType: + case CharacterType: + case IntegerType: + case ShortType: + if (value == 0) return 0; + return (long double)(*(long*)value); + + case DoubleType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0.0; + } + return (long double)(*(long double*)value); + + case FloatType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0.0; + } + return (long double)(*(float*)value); + + case LongType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0.0; + } + return (long double)(*(int64_t*)value); + + case DateType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0.0; + } + return (long double)(*(time_t*)value); + + case BigDecimalType: + case BigIntegerType: + case StringType: + case UriType: + { + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0.0; + } + char* tmp = new char[len+1]; + for (unsigned int j=0;j<len;j++) + { + tmp[j] = (char)((wchar_t*)value)[j]; + } + tmp[len] = 0; + float f = atof(tmp); + delete tmp; + return (long double)f; + } + + case BytesType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0.0; + } + return (long double)atof((char*)value); + + case OtherTypes: + case DataObjectType: + SDO_THROW_EXCEPTION("getLongDouble" , + SDOInvalidConversionException, "Not implemented on data object"); + break; + + default: + { + string msg("Cannot get LongDouble from object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("getLongDouble" , + SDOInvalidConversionException, msg.c_str()); + break; + } + } + } + + const long double TypeImpl::convertToDouble(const SDOValue& sdoValue) const + { + switch (typeEnum) + { + case BooleanType: + case ByteType: + case CharacterType: + case IntegerType: + case ShortType: + case DoubleType: + case FloatType: + case LongType: + case DateType: + case BigDecimalType: + case BigIntegerType: + case StringType: + case UriType: + case BytesType: + return sdoValue.getDouble(); + + case OtherTypes: + case DataObjectType: + default: + { + string msg("Cannot get double from object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("getDouble" , + SDOInvalidConversionException, msg.c_str()); + break; + } + } + } + + const float TypeImpl::convertToFloat(const SDOValue& sdoValue) const + { + switch (typeEnum) + { + case BooleanType: + case ByteType: + case CharacterType: + case IntegerType: + case ShortType: + case DoubleType: + case FloatType: + case LongType: + case DateType: + case BigDecimalType: + case BigIntegerType: + case StringType: + case UriType: + case BytesType: + return sdoValue.getFloat(); + + case OtherTypes: + case DataObjectType: + default: + { + string msg("Cannot get float from object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("getFloat" , + SDOInvalidConversionException, msg.c_str()); + break; + } + } + } + + + const SDODate TypeImpl::convertToDate(void* value, unsigned int len) const + { + switch (typeEnum) + { + case ByteType: + case CharacterType: + case IntegerType: + case ShortType: + if (value == 0) return 0; + return (time_t)(*(long*)value); + + case DoubleType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } + return (time_t)(*(long double*)value); + + case FloatType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } + return (time_t)(*(float*)value); + + case LongType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } + return (time_t)(*(int64_t*)value); + + case DateType: + if (value == 0) + { + // Conversions might set from a zero value, as they are used + // by the default Setting code as well + return 0; + } + return (time_t)(*(time_t*)value); + + case BigDecimalType: + case BigIntegerType: + case StringType: + case UriType: + case BooleanType: + case BytesType: + case OtherTypes: + case DataObjectType: + default: + { + string msg("Cannot get Date from object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("getDate" , + SDOInvalidConversionException, msg.c_str()); + break; + } + } + } + + const SDODate TypeImpl::convertToDate(const SDOValue& sdoValue) const + { + switch (typeEnum) + { + case ByteType: + case CharacterType: + case IntegerType: + case ShortType: + case DoubleType: + case FloatType: + case LongType: + case DateType: + case BooleanType: + case BytesType: + case StringType: + return sdoValue.getDate(); + + case BigDecimalType: + case BigIntegerType: + case UriType: + case OtherTypes: + case DataObjectType: + default: + { + string msg("Cannot get Date from object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("getDate" , + SDOInvalidConversionException, + msg.c_str()); + break; + } + } + } + + + + DataObject* TypeImpl::convertToDataObject(void* value, unsigned int len) const + { + switch (typeEnum) + { + case OtherTypes: + case DataObjectType: + return (DataObject*)value; + + case BooleanType: + case ByteType: + case CharacterType: + case IntegerType: + case ShortType: + case DoubleType: + case FloatType: + case LongType: + case DateType: + case BigDecimalType: + case BigIntegerType: + case StringType: + case BytesType: + case UriType: + default: + { + string msg("Cannot get Data Object from object of type:"); + msg += getName(); + SDO_THROW_EXCEPTION("getDataObject" , + SDOInvalidConversionException, msg.c_str()); + break; + } + } + } +}; + +}; |