diff options
Diffstat (limited to 'sdo-cpp/branches/sdo-cpp-pre2.1/runtime/core/src/commonj/sdo/PropertyImpl.cpp')
| -rw-r--r-- | sdo-cpp/branches/sdo-cpp-pre2.1/runtime/core/src/commonj/sdo/PropertyImpl.cpp | 594 |
1 files changed, 594 insertions, 0 deletions
diff --git a/sdo-cpp/branches/sdo-cpp-pre2.1/runtime/core/src/commonj/sdo/PropertyImpl.cpp b/sdo-cpp/branches/sdo-cpp-pre2.1/runtime/core/src/commonj/sdo/PropertyImpl.cpp new file mode 100644 index 0000000000..38997e421e --- /dev/null +++ b/sdo-cpp/branches/sdo-cpp-pre2.1/runtime/core/src/commonj/sdo/PropertyImpl.cpp @@ -0,0 +1,594 @@ +/* + * 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/export.h" + +#include <iostream> +using namespace std; + + +#include "commonj/sdo/Sequence.h" +#include "commonj/sdo/DataObject.h" +#include "commonj/sdo/TypeList.h" + +#include "commonj/sdo/Type.h" +#include "commonj/sdo/TypeImpl.h" +#include "commonj/sdo/Property.h" +#include "commonj/sdo/PropertyImpl.h" +#include "commonj/sdo/DataFactoryImpl.h" +#include "commonj/sdo/SDORuntimeException.h" + +namespace commonj{ + namespace sdo{ + + + Substitution::Substitution() : name(), type(0) + { + } + + // Standard Constructor + Substitution::Substitution(DataFactoryPtr mdg, + const SDOString& inname, + const Type& intype) : name(inname) + { + DataFactory* f = (DataFactory*)mdg; + + type = ((DataFactoryImpl*)f)->findType(intype.getURI(),intype.getName()); + } + + // Copy constructor + Substitution::Substitution(const Substitution& s) : name(s.name), type(s.type) + { + } + + Substitution::~Substitution() + { + } + + + /////////////////////////////////////////////////////////////////////////// + // construction by DAS + /////////////////////////////////////////////////////////////////////////// + + PropertyImpl::PropertyImpl(const Type& cont, + const char* inname, + const TypeImpl& intype, + bool many , + bool ro , + bool contain) : + containertype(cont), + type(intype), + defvalue(0), + defvaluelength(0), + opposite(0), + stringdef(0), + bisMany(many), + bisArray(false), + bisReadOnly(ro), + bisContainer(contain), + bDefaulted(false), + bisReference(false) + { + if (inname != 0) + { + name = inname; + } + else + { + name.erase(); + } + if (contain == false && intype.isDataObjectType()) + { + bisReference = true; + } + } + + PropertyImpl::PropertyImpl(const Type& cont, + const SDOString& inname, + const TypeImpl& intype, + bool many, + bool ro, + bool contain) : + containertype(cont), + name(inname), + type(intype), + bisMany(many), + bisArray(false), + bisReadOnly(ro), + bisContainer(contain), + bDefaulted(false), + opposite(0), + stringdef(0), + defvalue(0), + defvaluelength(0), + bisReference(false) + { + if (contain == false && intype.isDataObjectType()) + { + bisReference = true; + } + } + + PropertyImpl::PropertyImpl(const PropertyImpl& p) : + type((*(p.getTypeImpl()))), + containertype(p.getContainingType()), + name(p.name), + bisMany(p.bisMany), + bisArray(false), + bisReadOnly(p.bisReadOnly), + bisContainer(p.bisContainer), + bDefaulted(false), + opposite(0), + defvalue(0), + defvaluelength(0), + stringdef(0), + bisReference(false) + { + if (bisContainer == false && type.isDataObjectType()) + { + bisReference = true; + } + } + + PropertyImpl::~PropertyImpl() + { + // If the default value is an array type then we must use delete[] + // otherwise delete + if (defvalue != 0) + { + if (bisArray) + { + delete[] defvalue; + } + else + { + delete defvalue; + } + } + if (stringdef != 0) + { + delete[] stringdef; + } + } + + /////////////////////////////////////////////////////////////////////////// + // Setting of attributes by DAS + /////////////////////////////////////////////////////////////////////////// + + void PropertyImpl::setMany(bool many) + { + bisMany = many; + } + + void PropertyImpl::setReadOnly(bool readonly) + { + bisReadOnly = readonly; + } + + void PropertyImpl::setContainment(bool contains) + { + if (contains == true && type.isDataType()) + { + return; + } + bisContainer = contains; + if (bisContainer == false && type.isDataObjectType()) + { + bisReference = true; + } + else + { + bisReference = false; + } + } + + + /////////////////////////////////////////////////////////////////////////// + // Setting of defaults by DAS + /////////////////////////////////////////////////////////////////////////// + + void PropertyImpl::setDefault(bool b ) + { + setDefaultBoolean(b); + } + + void PropertyImpl::setDefault(char c ) + { + setDefaultByte(c); + } + + void PropertyImpl::setDefault(wchar_t c ) + { + setDefaultCharacter(c); + } + void PropertyImpl::setDefault(char* c ) + { + setDefaultCString(c); + } + void PropertyImpl::setDefault(const SDOString& c) + { + setDefaultCString(c); + } + void PropertyImpl::setDefault(short s ) + { + setDefaultShort(s); + } +#if __WORDSIZE !=64 + void PropertyImpl::setDefault(long i ) + { + setDefaultInteger(i); + } +#endif + void PropertyImpl::setDefault(int64_t i ) + { + setDefaultLong(i); + } + void PropertyImpl::setDefault(float f ) + { + setDefaultFloat(f); + } + void PropertyImpl::setDefault(long double d ) + { + setDefaultDouble(d); + } + void PropertyImpl::setDefault(const SDODate d ) + { + setDefaultDate(d); + } + void PropertyImpl::setDefault(const char* c , unsigned int len) + { + setDefaultBytes(c, len); + } + void PropertyImpl::setDefault(const SDOString& c , unsigned int len) + { + setDefaultBytes(c, len); + } + + void PropertyImpl::setDefault(const wchar_t* c, unsigned int len ) + { + setDefaultString(c, len); + } + + /////////////////////////////////////////////////////////////////////////// + // Substitution groups. + /////////////////////////////////////////////////////////////////////////// + const Type* PropertyImpl::getSubstitutionType(const char* inname) const + { + for (unsigned int i=0;i<substitutions.size();i++) + { + if (!strcmp(inname, substitutions[i].name.c_str())) + { + return substitutions[i].type; + } + } + return 0; + } + + const char * PropertyImpl::getSubstitutionName(unsigned int index) const + { + if (index < getSubstitutionCount()) + { + return (substitutions[index].name.c_str()); + } + SDO_THROW_EXCEPTION("getSubstitutionName", SDOIndexOutOfRangeException, + "index out of range"); + } + + unsigned int PropertyImpl::getSubstitutionCount(void) const + { + return substitutions.size(); + } + + const Type* PropertyImpl::getSubstitutionType(unsigned int index) const + { + if (index < getSubstitutionCount()) + { + return (substitutions[index].type); + } + return 0; + } + + void PropertyImpl::setSubstitution(DataFactoryPtr mdg, const char* alias, + const Type& substype) + { + substitutions.push_back(Substitution(mdg,alias,substype)); + } + + + /////////////////////////////////////////////////////////////////////////// + // Returns the name of the property. + /////////////////////////////////////////////////////////////////////////// + const char* PropertyImpl::getName() const + { + return name.c_str(); + } + +// const SDOString& PropertyImpl::getName() const +// { +// return name; +// } + + void PropertyImpl::setAlias(const char* alias) + { + char* tmp = new char[strlen(alias)+1]; + strcpy(tmp,alias); + aliases.push_back(tmp); + } + + void PropertyImpl::setAlias(const SDOString& alias) + { + aliases.push_back(alias); + } + + const char* PropertyImpl::getAlias(unsigned int index) const + { + if (index < aliases.size()) + { + return aliases[index].c_str(); + } + return name.c_str(); + } + + unsigned int PropertyImpl::getAliasCount() const + { + return aliases.size(); + } + + + /////////////////////////////////////////////////////////////////////////// + // Returns the type of the property. + /////////////////////////////////////////////////////////////////////////// + const Type& PropertyImpl::getType() const + { + return (Type&)type; + } + + const Type::Types PropertyImpl::getTypeEnum() const + { + return type.getTypeEnum(); + } + + /////////////////////////////////////////////////////////////////////////// + // Returns the type of the property. + /////////////////////////////////////////////////////////////////////////// + const TypeImpl* PropertyImpl::getTypeImpl() const + { + return &type; + } + + /////////////////////////////////////////////////////////////////////////// + // Returns whether the property is many-valued. + /////////////////////////////////////////////////////////////////////////// + bool PropertyImpl::isMany() const + { + if(getTypeImpl()->isFromList())return true; + return bisMany; + } + + /////////////////////////////////////////////////////////////////////////// + // Returns whether the property is containment. + /////////////////////////////////////////////////////////////////////////// + bool PropertyImpl::isContainment() const + { + return bisContainer; + } + + /////////////////////////////////////////////////////////////////////////// + // Returns whether the property is containment. + /////////////////////////////////////////////////////////////////////////// + bool PropertyImpl::isReference() const + { + return bisReference; + } + + /////////////////////////////////////////////////////////////////////////// + // Returns the containing type of this property. + /////////////////////////////////////////////////////////////////////////// + const Type& PropertyImpl::getContainingType() const + { + return containertype; + } + + /////////////////////////////////////////////////////////////////////////// + // Returns the opposite. + /////////////////////////////////////////////////////////////////////////// + const Property* PropertyImpl::getOpposite() const + { + return opposite; + } + + void PropertyImpl::setOpposite(const Property* opp) + { + opposite = opp; + } + /////////////////////////////////////////////////////////////////////////// + // Returns the default value this property will have in a + // data object where the property hasn't been set. + /////////////////////////////////////////////////////////////////////////// + + // check whether the property has a default first + bool PropertyImpl::isDefaulted() const + { + return bDefaulted; + } + + const char* PropertyImpl::getCStringDefault() const + { + PropertyImpl* p = (PropertyImpl*)this; + return getTypeImpl()->convertToCString(defvalue, &(p->stringdef), defvaluelength); + } + bool PropertyImpl::getBooleanDefault() const + { + return getTypeImpl()->convertToBoolean(defvalue,defvaluelength); + } + char PropertyImpl::getByteDefault() const + { + return getTypeImpl()->convertToByte(defvalue,defvaluelength); + } + wchar_t PropertyImpl::getCharacterDefault() const + { + return getTypeImpl()->convertToCharacter(defvalue,defvaluelength); + } + short PropertyImpl::getShortDefault() const + { + return getTypeImpl()->convertToShort(defvalue,defvaluelength); + } + long PropertyImpl::getIntegerDefault() const + { + return getTypeImpl()->convertToInteger(defvalue,defvaluelength); + } + int64_t PropertyImpl::getLongDefault() const + { + return getTypeImpl()->convertToLong(defvalue,defvaluelength); + } + float PropertyImpl::getFloatDefault() const + { + return getTypeImpl()->convertToFloat(defvalue,defvaluelength); + } + long double PropertyImpl::getDoubleDefault() const + { + return getTypeImpl()->convertToDouble(defvalue,defvaluelength); + } + const SDODate PropertyImpl::getDateDefault() const + { + return getTypeImpl()->convertToDate(defvalue,defvaluelength); + } + unsigned int PropertyImpl::getStringDefault(wchar_t* val, unsigned int max) const + { + if (val == 0 || max == 0) return defvaluelength; + return getTypeImpl()->convertToString(defvalue, val, defvaluelength, max); + + } + unsigned int PropertyImpl::getBytesDefault(char* val, unsigned int max) const + { + if (val == 0 || max == 0) return defvaluelength; + return getTypeImpl()->convertToBytes(defvalue, val, defvaluelength, max); + } + + unsigned int PropertyImpl::getBytesDefault(SDOString& val, unsigned int max) const + { + if (max == 0) return defvaluelength; + return getTypeImpl()->convertToBytes(defvalue, val, defvaluelength, max); + } + + unsigned int PropertyImpl::getDefaultLength() const + { + return defvaluelength; + } + + /////////////////////////////////////////////////////////////////////////// + // sets the default value by type + /////////////////////////////////////////////////////////////////////////// + + void PropertyImpl::setDefaultCString(const char* s) + { + bDefaulted=true; + bisArray = true; + defvaluelength = getTypeImpl()->convert(&defvalue,s); + } + void PropertyImpl::setDefaultCString(const SDOString& s) + { + bDefaulted=true; + bisArray = true; + defvaluelength = getTypeImpl()->convert(&defvalue, s); + } + void PropertyImpl::setDefaultString( const wchar_t* c , unsigned int len ) + { + bDefaulted=true; + bisArray = true; + defvaluelength = getTypeImpl()->convert(&defvalue,c, len); + } + void PropertyImpl::setDefaultBytes( const char* c , unsigned int len ) + { + bDefaulted=true; + bisArray = true; + defvaluelength = getTypeImpl()->convert(&defvalue,c, len); + } + void PropertyImpl::setDefaultBytes(const SDOString& c , unsigned int len) + { + bDefaulted=true; + bisArray = true; + defvaluelength = getTypeImpl()->convert(&defvalue,c, len); + } + void PropertyImpl::setDefaultBoolean( const bool b ) + { + bDefaulted=true; + defvaluelength = getTypeImpl()->convert(&defvalue,b); + } + void PropertyImpl::setDefaultByte( const char c ) + { + bDefaulted=true; + defvaluelength = getTypeImpl()->convert(&defvalue,c); + } + void PropertyImpl::setDefaultCharacter( const wchar_t c) + { + bDefaulted=true; + defvaluelength = getTypeImpl()->convert(&defvalue,c); + } + void PropertyImpl::setDefaultShort( const short s ) + { + bDefaulted=true; + defvaluelength = getTypeImpl()->convert(&defvalue,s); + } + void PropertyImpl::setDefaultInteger( const long i ) + { + bDefaulted=true; +#if __WORDSIZE ==64 + defvaluelength = getTypeImpl()->convert(&defvalue,(int64_t)i); +#else + defvaluelength = getTypeImpl()->convert(&defvalue,i); +#endif + } + void PropertyImpl::setDefaultLong(const int64_t l) + { + bDefaulted=true; + defvaluelength = getTypeImpl()->convert(&defvalue,l); + } + void PropertyImpl::setDefaultFloat( const float f ) + { + bDefaulted=true; + defvaluelength = getTypeImpl()->convert(&defvalue,f); + } + void PropertyImpl::setDefaultDouble( const long double d ) + { + bDefaulted=true; + defvaluelength = getTypeImpl()->convert(&defvalue,d); + } + void PropertyImpl::setDefaultDate( const SDODate d ) + { + bDefaulted=true; + defvaluelength = getTypeImpl()->convertDate(&defvalue,d); + } + + /////////////////////////////////////////////////////////////////////////// + // Returns true if values for this Property cannot be modified using the SDO APIs. + // When true, DataObject.set(Property property, Object value) throws an exception. + // Values may change due to other factors, such as services operating on DataObjects. + /////////////////////////////////////////////////////////////////////////// + bool PropertyImpl::isReadOnly() const + { + return bisReadOnly; + } + +}; +}; + + |