diff options
Diffstat (limited to 'sdo-cpp/tags/cpp-sdo-1.0.incubating-M3/runtime/core/src/commonj/sdo/SequenceImpl.cpp')
-rw-r--r-- | sdo-cpp/tags/cpp-sdo-1.0.incubating-M3/runtime/core/src/commonj/sdo/SequenceImpl.cpp | 1328 |
1 files changed, 1328 insertions, 0 deletions
diff --git a/sdo-cpp/tags/cpp-sdo-1.0.incubating-M3/runtime/core/src/commonj/sdo/SequenceImpl.cpp b/sdo-cpp/tags/cpp-sdo-1.0.incubating-M3/runtime/core/src/commonj/sdo/SequenceImpl.cpp new file mode 100644 index 0000000000..71bcc6e07f --- /dev/null +++ b/sdo-cpp/tags/cpp-sdo-1.0.incubating-M3/runtime/core/src/commonj/sdo/SequenceImpl.cpp @@ -0,0 +1,1328 @@ +/* + * 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/disable_warn.h" +#include "commonj/sdo/Property.h" +#include "commonj/sdo/Type.h" +#include "commonj/sdo/TypeList.h" + +#include "commonj/sdo/SequenceImpl.h" + +#include "commonj/sdo/DataObject.h" +#include "commonj/sdo/DataObjectImpl.h" +#include "commonj/sdo/SDORuntimeException.h" +using namespace std; + + +#define CHECK_RANGE\ + if (index >= the_list.size()){\ + std::string msg("Index out of range:");\ + msg += index;\ + SDO_THROW_EXCEPTION("Sequence API", SDOIndexOutOfRangeException,\ + msg.c_str());\ + }\ + unsigned int j = 0;\ + for (i = the_list.begin(); (j < index) && (i != the_list.end()); ++i)\ + {\ + j++;\ + } + + +namespace commonj +{ + namespace sdo + { + + SequenceImpl::SequenceImpl() + { + SDO_THROW_EXCEPTION("Sequence constructor", + SDORuntimeException, + "SequenceImpl::construction without a data object"); + } + + SequenceImpl::SequenceImpl(DataObject* indo) + { + the_do = (DataObjectImpl*) indo; + } + + SequenceImpl::SequenceImpl(SequenceImpl* inseq) + { + // take a copy of the_list + the_list = inseq->the_list; + } + + unsigned int SequenceImpl::size() + { + return the_list.size(); + } + + // Convert an index into the sequence into an iterator (pointer) to the + // list element identified by the index. If the index is invalid then + // throw an exception. + void SequenceImpl::checkRange(unsigned int index, SEQUENCE_ITEM_LIST::iterator& i) + { + if (index >= the_list.size()) + { + std::string msg("Index out of range:"); + msg += index; + SDO_THROW_EXCEPTION("Sequence API", + SDOIndexOutOfRangeException, + msg.c_str()); + } + unsigned int j = 0; + for (i = the_list.begin(); (j < index) && (i != the_list.end()); ++i) + { + j++; + } + return; + } + + // Return the data object associated with this sequence + const DataObjectPtr SequenceImpl::getDataObject() + { + return the_do; + } + + const Property& SequenceImpl::getProperty(unsigned int index) + { + SEQUENCE_ITEM_LIST::iterator i; + + if (isText(index)) + { + std::string msg("Cannot get property of a text item"); + msg += index; + SDO_THROW_EXCEPTION("getProperty", + SDOUnsupportedOperationException, + msg.c_str()); + } + + checkRange(index, i); + + if (i != the_list.end()) + { + return *((*i).getProp()); + } + std::string msg("Index out of range:"); + msg += index; + SDO_THROW_EXCEPTION("getProperty", + SDOIndexOutOfRangeException, + msg.c_str()); + } + + Type::Types SequenceImpl::getTypeEnum(unsigned int index) + { + SEQUENCE_ITEM_LIST::iterator i; + + checkRange(index, i); + + if (i != the_list.end()) + { + if ((*i).getProp() == 0) + { + // text type + return Type::TextType; + } + return (*i).getProp()->getTypeEnum(); + } + std::string msg("Index out of range:"); + msg += index; + SDO_THROW_EXCEPTION("getTypeEnum", + SDOIndexOutOfRangeException, + msg.c_str()); + } + + unsigned int SequenceImpl::getListIndex(unsigned int index) + { + SEQUENCE_ITEM_LIST::iterator i; + + checkRange(index, i); + + if (i != the_list.end()) { + if ((*i).getProp() == 0) + { + std::string msg("Get list index on text property"); + SDO_THROW_EXCEPTION("getListIndex", + SDOUnsupportedOperationException, + msg.c_str()); + } + if ((*i).getProp()->isMany()) + { + return (*i).getIndex(); + } + else + { + std::string msg("Get list index on text single valued property"); + SDO_THROW_EXCEPTION("getListIndex", + SDOUnsupportedOperationException, + msg.c_str()); + } + } + std::string msg("Index out of range:"); + msg += index; + SDO_THROW_EXCEPTION("getListIndex", + SDOIndexOutOfRangeException, + msg.c_str()); + } + + unsigned int SequenceImpl::getIndex(const char* propName, unsigned int pindex) + { + SEQUENCE_ITEM_LIST::iterator i; + unsigned int j = 0; + for (i = the_list.begin(), j = 0; i != the_list.end(); ++i, ++j) + { + const Property* p = (*i).getProp(); + if (p == 0) + { + continue; // avoid text + } + + if (!strcmp(p->getName(), propName)) + { + if (p->isMany()) + { + if (pindex == (*i).getIndex()) + { + return j; + } + } + else + { + return j; + } + } + } + SDO_THROW_EXCEPTION("getIndex", + SDOIndexOutOfRangeException, + "SequenceImpl::getIndex - property Setting not in sequence"); + } + + unsigned int SequenceImpl::getIndex(const Property& p, unsigned int pindex) + { + return getIndex(p.getName(), pindex); + } + + // specific getters for prims and data objects + + // It isn't obvious from the code here, however, this method also + // retrieves free text elements (see the spec) ie text items that can be + // added to the sequence even though they are not associated with a property. + const char* SequenceImpl::getCStringValue(unsigned int index) + { + const SDOValue& result = getSDOValue(index); + + if (result.isSet()) + { + return result.getCString(); + } + else + { + return 0; + } + } + + unsigned int SequenceImpl::getLength(unsigned int index) + { + SEQUENCE_ITEM_LIST::iterator i; + CHECK_RANGE; + const Property* p = (*i).getProp(); + switch (p->getTypeEnum()) + { + case Type::StringType: + return getStringValue(index,0,0); + case Type::BytesType: + return getBytesValue(index,0,0); + default: + return 0; + } + } + + RefCountingPointer<DataObject> SequenceImpl::getDataObjectValue(unsigned int index) + { + SEQUENCE_ITEM_LIST::iterator i; + CHECK_RANGE; + const Property* p = (*i).getProp(); + if (p == 0) { + return 0; + } + if (p->isMany()) + { + DataObjectList& dol = the_do->getList(*p); + DataObject* list_do = dol[(*i).getIndex()]; + if (list_do != 0) + { + return list_do; + } + return 0; + } + return the_do->getDataObject(*((*i).getProp())); + } + + /////////////////////////////////////////////////////////////////////////// + // generic getter for those types which support it + /////////////////////////////////////////////////////////////////////////// + + void SequenceImpl::setCStringValue( unsigned int index, const char* s ) + { + SEQUENCE_ITEM_LIST::iterator i; + CHECK_RANGE; + if ((*i).getProp() == 0) { + (*i).setText(s); + return; + } + the_do->setCString(*((*i).getProp()),s); + + } + void SequenceImpl::setBooleanValue( unsigned int index, bool b ) + { + SEQUENCE_ITEM_LIST::iterator i; + CHECK_RANGE; + if ((*i).getProp() == 0) { + return; + } + the_do->setBoolean(*((*i).getProp()),b); + } + + void SequenceImpl::setByteValue( unsigned int index, char c ) + { + SEQUENCE_ITEM_LIST::iterator i; + CHECK_RANGE; + if ((*i).getProp() == 0) { + return; + } + the_do->setByte(*((*i).getProp()),c); + } + + void SequenceImpl::setCharacterValue( unsigned int index, wchar_t c ) + { + SEQUENCE_ITEM_LIST::iterator i; + CHECK_RANGE; + if ((*i).getProp() == 0) { + return; + } + the_do->setCharacter(*((*i).getProp()),c); + } + void SequenceImpl::setStringValue( unsigned int index, const wchar_t* s , unsigned int len) + { + SEQUENCE_ITEM_LIST::iterator i; + CHECK_RANGE; + if ((*i).getProp() == 0) { + return; + } + the_do->setString(*((*i).getProp()),s, len); + } + void SequenceImpl::setBytesValue( unsigned int index, const char* s , unsigned int len) + { + SEQUENCE_ITEM_LIST::iterator i; + CHECK_RANGE; + if ((*i).getProp() == 0) { + return; + } + the_do->setBytes(*((*i).getProp()),s, len); + } + void SequenceImpl::setShortValue( unsigned int index, short s ) + { + SEQUENCE_ITEM_LIST::iterator i; + CHECK_RANGE; + if ((*i).getProp() == 0) { + return; + } + the_do->setShort(*((*i).getProp()),s); + } + + void SequenceImpl::setIntegerValue( unsigned int index, long l) + { + SEQUENCE_ITEM_LIST::iterator i; + CHECK_RANGE; + if ((*i).getProp() == 0) { + return; + } + the_do->setInteger(*((*i).getProp()),l); + } + + + void SequenceImpl::setLongValue( unsigned int index, int64_t l ) + { + SEQUENCE_ITEM_LIST::iterator i; + CHECK_RANGE; + if ((*i).getProp() == 0) { + return; + } + the_do->setLong(*((*i).getProp()),l); + } + + void SequenceImpl::setFloatValue( unsigned int index, float f ) + { + SEQUENCE_ITEM_LIST::iterator i; + CHECK_RANGE; + if ((*i).getProp() == 0) { + return; + } + the_do->setFloat(*((*i).getProp()),f); + } + + + void SequenceImpl::setDoubleValue(unsigned int index, long double d ) + { + SEQUENCE_ITEM_LIST::iterator i; + CHECK_RANGE; + if ((*i).getProp() == 0) { + return; + } + the_do->setDouble(*((*i).getProp()),d); + } + + void SequenceImpl::setDateValue(unsigned int index, const SDODate t ) + { + SEQUENCE_ITEM_LIST::iterator i; + CHECK_RANGE; + if ((*i).getProp() == 0) { + return; + } + the_do->setDate(*((*i).getProp()),t); + } + + void SequenceImpl::setDataObjectValue(unsigned int index, DataObjectPtr d ) + { + SEQUENCE_ITEM_LIST::iterator i; + CHECK_RANGE; + if ((*i).getProp() == 0) { + return; + } + the_do->setDataObject(*((*i).getProp()),d); + } + + +bool SequenceImpl::addDataObject(const char* propertyName, RefCountingPointer<DataObject> v) +{ + const PropertyImpl* p = the_do->getPropertyImpl(propertyName); + if (p == 0) + { + if (the_do->getType().isOpenType()) + { + p = the_do->defineDataObject(propertyName, v->getType()); + } + if (p == 0) + { + std::string msg("Cannot find property:"); + msg += propertyName; + SDO_THROW_EXCEPTION("getProperty", SDOPropertyNotFoundException, + msg.c_str()); + } + } + return addDataObject((const Property&)*p,v); +} +bool SequenceImpl::addDataObject(unsigned int propertyIndex, RefCountingPointer<DataObject> v) +{ + return addDataObject(the_do->getProperty(propertyIndex), v); +} +bool SequenceImpl::addDataObject(const Property& p, RefCountingPointer<DataObject> v) +{ + // If this is a many valued property. + if (p.isMany()) + { + // Append the incoming data object value to the end of the list of + // values. The sequence is updated as part of the append operation. + DataObjectList& dol = the_do->getList(p); + dol.append((RefCountingPointer<DataObject>) v); + /* the_list.push_back(seq_item(&p,dol.size()-1));*/ + return true; + } + + SEQUENCE_ITEM_LIST::iterator i; + + // Scan the sequence to check that this property has not been set already. + for (i= the_list.begin(); i != the_list.end(); ++i) + { + const Property* pp = (*i).getProp(); + if (pp == 0) + { + continue; // This item is a free text entry. + } + if (!strcmp(pp->getName(), p.getName())) + { + SDO_THROW_EXCEPTION("add", + SDOUnsupportedOperationException, + "Sequence::add of property which already exists in sequence"); + } + } + + the_do->setDataObject(p, v, true); + // the_list.push_back(seq_item(&p, 0)); + return true; +} + + +bool SequenceImpl::addDataObject(unsigned int index, const char* propertyName, RefCountingPointer<DataObject> v) +{ + const PropertyImpl* p = the_do->getPropertyImpl(propertyName); + if (p == 0) + { + if (the_do->getType().isOpenType()) + { + p = the_do->defineDataObject(propertyName, v->getType()); + } + if (p == 0) + { + std::string msg("Cannot find property:"); + msg += propertyName; + SDO_THROW_EXCEPTION("getProperty", SDOPropertyNotFoundException, + msg.c_str()); + } + } + return addDataObject(index,(const Property&)*p,v); +} +bool SequenceImpl::addDataObject(unsigned int index, unsigned int propertyIndex, RefCountingPointer<DataObject> v) +{ + return addDataObject(index,the_do->getProperty(propertyIndex), v); +} +bool SequenceImpl::addDataObject(unsigned int index, const Property& p, RefCountingPointer<DataObject> v) +{ + SEQUENCE_ITEM_LIST::iterator i; + SEQUENCE_ITEM_LIST::iterator i2 = the_list.end(); + unsigned int j = 0; + + if (index >= the_list.size()) + { + return addDataObject(p, v); + } + if (p.isMany()) + { + DataObjectList& dol = the_do->getList(p); + dol.append((RefCountingPointer<DataObject>)v); + + checkRange(index, i); + + /*the_list.insert(i,seq_item(&p,dol.size()-1));*/ + return true; + } + + for (i = the_list.begin(); i != the_list.end(); ++i) + { + const Property* pp = (*i).getProp(); + if (pp == 0) + { + continue; // This item is a free text entry. + } + if (!strcmp(pp->getName(), p.getName())) + { + SDO_THROW_EXCEPTION("Insert", + SDOUnsupportedOperationException, + "Sequence::insert of property which already exists in sequence"); + } + if (j == index) + { + i2 = i; + } + j++; + } + // setDataObject can update the sequence but does not do so by an append + // so tell it to mind its own business and we will update the sequence here. + the_do->setDataObject(p, v, false); + the_list.insert(i2, seq_item(&p, 0)); + return true; +} + + void SequenceImpl::push(const Property& p, unsigned int index) + { + the_list.push_back(seq_item(&p,index)); + } + + void SequenceImpl::remove(unsigned int index) + { + if (index >= the_list.size()) { + std::string msg("Index out of range:"); + msg += index; + SDO_THROW_EXCEPTION("Sequence remove", SDOIndexOutOfRangeException, + msg.c_str()); + } + SEQUENCE_ITEM_LIST::iterator i; + + checkRange(index, i); + + the_list.erase(i); + return; + } + + void SequenceImpl::removeAll(const Property& p) + { + int j = 0; + const Property* prop; + SEQUENCE_ITEM_LIST::iterator i = the_list.begin(); + + while (i != the_list.end()) + { + prop = (*i).getProp(); + if (prop != 0) + { + if (!strcmp(prop->getName(), p.getName())) + { + i = the_list.erase(i); + } + else + { + ++i; + } + } + else + { + ++i; + } + + } + + return; + } + + void SequenceImpl::move(unsigned int toIndex, unsigned int fromIndex) + { + if (fromIndex >= the_list.size()) { + std::string msg("Index out of range:"); + msg += fromIndex; + SDO_THROW_EXCEPTION("Sequence Move", SDOIndexOutOfRangeException, + msg.c_str()); + } + + if (toIndex == fromIndex) return; + + SEQUENCE_ITEM_LIST::iterator i1, + i2 = the_list.end(), + i3 = the_list.end(); + unsigned int j = 0; + for (i3 = the_list.begin(); + j < toIndex && j < fromIndex && + i3 != the_list.end() ; ++i3); + { + if (j == toIndex) i1 = i3; + if (j == fromIndex) i2 = i3; + j++; + } + + if (toIndex < fromIndex) + { + the_list.insert( i1, *i2); + the_list.erase(i2); + } + else + { + if (toIndex + 1 == the_list.size()) + { + the_list.push_back(*i2); + } + else + { + the_list.insert(++i1,*i2); + } + the_list.erase(i2); + } + return; + } + + bool SequenceImpl::addText(const char* text) + { + the_list.push_back(seq_item(text)); + return true; + } + + bool SequenceImpl::isText(unsigned int index) + { + if (index >= the_list.size()) { + return false; + } + SEQUENCE_ITEM_LIST::iterator i; + + checkRange(index, i); + + if ((*i).getProp() == 0) + { + return true; + } + + return false; + } + + bool SequenceImpl::addText(unsigned int index, const char* text) + { + if (index >= the_list.size()) { + return addText(text); + } + + SEQUENCE_ITEM_LIST::iterator i; + + checkRange(index, i); + + the_list.insert(i,seq_item(text)); + return true; + } + + bool SequenceImpl::setText(unsigned int index, const char* text) + { + if (index >= the_list.size()) { + return false; + } + + if (!isText(index)) + { + return false; + } + + SEQUENCE_ITEM_LIST::iterator i; + + checkRange(index, i); + + (*i).setText(text); + return true; + } + +const SDOValue& SequenceImpl::getSDOValue(unsigned int index) +{ + SEQUENCE_ITEM_LIST::iterator i; + + checkRange(index, i); + + const Property* p = (*i).getProp(); + if (p == 0) + { + // There is no property. Either this is a free text element or we have a + // problem. + const SDOValue* freeText = (*i).getFreeText(); + if (freeText != 0) + { + return *freeText; + } + else + { + return SDOValue::unsetSDOValue; + } + } + PropertyImpl* pProp = 0; // Not used. Just a place for getSDOValue to + // write the return value that we don't need. + if (p->isMany()) + { + DataObjectList& dol = the_do->getList(*p); + DataObject* list_do = dol[(*i).getIndex()]; + if (list_do != 0) + { + return ((DataObjectImpl*) list_do)->getSDOValue(&pProp); + } + return SDOValue::unsetSDOValue; + } + return the_do->getSDOValue(*((*i).getProp()), &pProp); +} + +bool SequenceImpl::getBooleanValue(unsigned int index) +{ + const SDOValue& result = getSDOValue(index); + + if (result.isSet()) + { + return result.getBoolean(); + } + else + { + return (bool) 0; + } +} + +char SequenceImpl::getByteValue(unsigned int index) +{ + const SDOValue& result = getSDOValue(index); + + if (result.isSet()) + { + return result.getByte(); + } + else + { + return (char) 0; + } +} + +wchar_t SequenceImpl::getCharacterValue(unsigned int index) +{ + const SDOValue& result = getSDOValue(index); + + if (result.isSet()) + { + return result.getCharacter(); + } + else + { + return (wchar_t) 0; + } +} + +short SequenceImpl::getShortValue(unsigned int index) +{ + const SDOValue& result = getSDOValue(index); + + if (result.isSet()) + { + return result.getShort(); + } + else + { + return (short) 0; + } +} + +long SequenceImpl::getIntegerValue(unsigned int index) +{ + const SDOValue& result = getSDOValue(index); + + if (result.isSet()) + { + return result.getInteger(); + } + else + { + return (long) 0; + } +} + +int64_t SequenceImpl::getLongValue(unsigned int index) +{ + const SDOValue& result = getSDOValue(index); + + if (result.isSet()) + { + return result.getLong(); + } + else + { + return (int64_t) 0; + } +} + +float SequenceImpl::getFloatValue(unsigned int index) +{ + const SDOValue& result = getSDOValue(index); + + if (result.isSet()) + { + return result.getFloat(); + } + else + { + return (float) 0; + } +} + +long double SequenceImpl::getDoubleValue(unsigned int index) +{ + const SDOValue& result = getSDOValue(index); + + if (result.isSet()) + { + return result.getDouble(); + } + else + { + return (long double) 0; + } +} + +const SDODate SequenceImpl::getDateValue(unsigned int index) +{ + const SDOValue& result = getSDOValue(index); + + if (result.isSet()) + { + return result.getDate(); + } + else + { + return (SDODate) 0; + } +} + +bool SequenceImpl::addCString(const char* propertyName, const char* v) +{ + return addSDOValue(propertyName, SDOValue(SDOString(v))); +} +bool SequenceImpl::addCString(const Property& p, const char* v) +{ + return addSDOValue(p, SDOValue(SDOString(v))); +} +bool SequenceImpl::addCString(unsigned int propertyIndex, const char* v) +{ + return addCString(the_do->getProperty(propertyIndex), v); +} + +bool SequenceImpl::addByte(const char* propertyName, char v) +{ + return addSDOValue(propertyName, SDOValue(v)); +} +bool SequenceImpl::addByte(const Property& p, char v) +{ + return addSDOValue(p, SDOValue(v)); +} +bool SequenceImpl::addByte(unsigned int propertyIndex, char v) +{ + return addByte(the_do->getProperty(propertyIndex), v); +} + +bool SequenceImpl::addCharacter(const char* propertyName, wchar_t v) +{ + return addSDOValue(propertyName, SDOValue(v)); +} +bool SequenceImpl::addCharacter(const Property& p, wchar_t v) +{ + return addSDOValue(p, SDOValue(v)); +} +bool SequenceImpl::addCharacter(unsigned int propertyIndex, wchar_t v) +{ + return addCharacter(the_do->getProperty(propertyIndex), v); +} + +bool SequenceImpl::addShort(const char* propertyName, short v) +{ + return addSDOValue(propertyName, SDOValue(v)); +} +bool SequenceImpl::addShort(const Property& p, short v) +{ + return addSDOValue(p, SDOValue(v)); +} +bool SequenceImpl::addShort(unsigned int propertyIndex, short v) +{ + return addShort(the_do->getProperty(propertyIndex), v); +} + +bool SequenceImpl::addFloat(const char* propertyName, float v) +{ + return addSDOValue(propertyName, SDOValue(v)); +} +bool SequenceImpl::addFloat(const Property& p, float v) +{ + return addSDOValue(p, SDOValue(v)); +} +bool SequenceImpl::addFloat(unsigned int propertyIndex, float v) +{ + return addFloat(the_do->getProperty(propertyIndex), v); +} + +bool SequenceImpl::addDouble(const char* propertyName, long double v) +{ + return addSDOValue(propertyName, SDOValue(v)); +} +bool SequenceImpl::addDouble(const Property& p, long double v) +{ + return addSDOValue(p, SDOValue(v)); +} +bool SequenceImpl::addDouble(unsigned int propertyIndex, long double v) +{ + return addDouble(the_do->getProperty(propertyIndex), v); +} + +bool SequenceImpl::addDate(const char* propertyName, const SDODate v) +{ + return addSDOValue(propertyName, SDOValue(v)); +} +bool SequenceImpl::addDate(const Property& p, const SDODate v) +{ + return addSDOValue(p, SDOValue(v)); +} +bool SequenceImpl::addDate(unsigned int propertyIndex, const SDODate v) +{ + return addDate(the_do->getProperty(propertyIndex), v); +} + +bool SequenceImpl::addLong(const char* propertyName, int64_t v) +{ + return addSDOValue(propertyName, SDOValue(v)); +} +bool SequenceImpl::addLong(const Property& p, int64_t v) +{ + return addSDOValue(p, SDOValue(v)); +} +bool SequenceImpl::addLong(unsigned int propertyIndex, int64_t v) +{ + return addLong(the_do->getProperty(propertyIndex), v); +} + +bool SequenceImpl::addInteger(const char* propertyName, long v) +{ + return addSDOValue(propertyName, SDOValue(v)); +} +bool SequenceImpl::addInteger(const Property& p, long v) +{ + return addSDOValue(p, SDOValue(v)); +} +bool SequenceImpl::addInteger(unsigned int propertyIndex, long v) +{ + return addInteger(the_do->getProperty(propertyIndex), v); +} + +bool SequenceImpl::addBoolean(const char* propertyName, bool v) +{ + return addSDOValue(propertyName, SDOValue(v)); +} +bool SequenceImpl::addBoolean(const Property& p, bool v) +{ + return addSDOValue(p, SDOValue(v)); +} + +bool SequenceImpl::addBoolean(unsigned int propertyIndex, bool v) +{ + return addBoolean(the_do->getProperty(propertyIndex), v); +} + +// The return value is not spec compliant (which calls for void) it is a +// yes/no as to whether the call succeeded. +bool SequenceImpl::addSDOValue(const char* propertyName, const SDOValue& sval) +{ + const PropertyImpl* p = the_do->getPropertyImpl(propertyName); + if (p == 0) + { + if (the_do->getType().isOpenType()) + { + p = the_do->defineSDOValue(propertyName, sval); + } + if (p == 0) + { + std::string msg("Cannot find property:"); + msg += propertyName; + SDO_THROW_EXCEPTION("SequenceImpl::addSDOValue", + SDOPropertyNotFoundException, + msg.c_str()); + } + } + return addSDOValue((const Property&) *p, sval); +} +bool SequenceImpl::addSDOValue(const Property& p, const SDOValue& sval) +{ + if (p.isMany()) + { + DataObjectList& dol = the_do->getList(p); + dol.append(sval); + /* the_list.push_back(seq_item(&p,dol.size()-1));*/ + return true; + } +// std::cout << "Incoming property: " << p.getName() << std::endl << std::endl; + SEQUENCE_ITEM_LIST::iterator i; + for (i = the_list.begin(); i != the_list.end(); ++i) + { + const Property* pp = (*i).getProp(); + if (pp == 0) continue; +// std::cout << pp->getName() << std::endl; + if (!strcmp(pp->getName(), p.getName())) + { + SDO_THROW_EXCEPTION("add", + SDOUnsupportedOperationException, + "Sequence::add of property which already exists in sequence"); + } + } +// std::cout << std::endl; + the_do->setSDOValue(p, sval, sval.convertTypeEnumToString(), true); + // the_list.push_back(seq_item(&p, 0)); + return true; +} +bool SequenceImpl::addSDOValue(unsigned int propertyIndex, const SDOValue& sval) +{ + return addSDOValue(the_do->getProperty(propertyIndex), sval); +} + +bool SequenceImpl::addString(const char* propertyName, const wchar_t* v, unsigned int len) +{ + return addSDOValue(propertyName, SDOValue(v, len)); +} +bool SequenceImpl::addString(unsigned int propertyIndex, const wchar_t* v, unsigned int len) +{ + return addString(the_do->getProperty(propertyIndex), v, len); +} +bool SequenceImpl::addString(const Property& p, const wchar_t* v, unsigned int len) +{ + return addSDOValue(p, SDOValue(v, len)); +} + +bool SequenceImpl::addBytes(const char* propertyName, const char* v, unsigned int len) +{ + return addSDOValue(propertyName, SDOValue(v, len)); +} +bool SequenceImpl::addBytes(unsigned int propertyIndex, const char* v, unsigned int len) +{ + return addBytes(the_do->getProperty(propertyIndex), v, len); +} +bool SequenceImpl::addBytes(const Property& p, const char* v, unsigned int len) +{ + return addSDOValue(p, SDOValue(v, len)); +} + + bool SequenceImpl::addByte(unsigned int index, const char* propertyName, char v) + { + return addSDOValue(index, propertyName, SDOValue(v)); + } + bool SequenceImpl::addByte(unsigned int index, unsigned int propertyIndex, char v) + { + return addByte(index, the_do->getProperty(propertyIndex), v); + } + bool SequenceImpl::addByte(unsigned int index, const Property& p, char v) + { + return addSDOValue(index, p, SDOValue(v)); + } + + bool SequenceImpl::addCharacter(unsigned int index, const char* propertyName, wchar_t v) + { + return addSDOValue(index, propertyName, SDOValue(v)); + } + bool SequenceImpl::addCharacter(unsigned int index, unsigned int propertyIndex, wchar_t v) + { + return addCharacter(index, the_do->getProperty(propertyIndex), v); + } + bool SequenceImpl::addCharacter(unsigned int index, const Property& p, wchar_t v) + { + return addSDOValue(index, p, SDOValue(v)); + } + + bool SequenceImpl::addShort(unsigned int index, const char* propertyName, short v) + { + return addSDOValue(index, propertyName, SDOValue(v)); + } + bool SequenceImpl::addShort(unsigned int index, unsigned int propertyIndex, short v) + { + return addShort(index, the_do->getProperty(propertyIndex), v); + } + bool SequenceImpl::addShort(unsigned int index, const Property& p, short v) + { + return addSDOValue(index, p, SDOValue(v)); + } + + bool SequenceImpl::addLong(unsigned int index, const char* propertyName, int64_t v) + { + return addSDOValue(index, propertyName, SDOValue(v)); + } + bool SequenceImpl::addLong(unsigned int index, unsigned int propertyIndex, int64_t v) + { + return addLong(index, the_do->getProperty(propertyIndex), v); + } + bool SequenceImpl::addLong(unsigned int index, const Property& p, int64_t v) + { + return addSDOValue(index, p, SDOValue(v)); + } + + bool SequenceImpl::addFloat(unsigned int index, const char* propertyName, float v) + { + return addSDOValue(index, propertyName, SDOValue(v)); + } + bool SequenceImpl::addFloat(unsigned int index, unsigned int propertyIndex, float v) + { + return addFloat(index, the_do->getProperty(propertyIndex), v); + } + bool SequenceImpl::addFloat(unsigned int index, const Property& p, float v) + { + return addSDOValue(index, p, SDOValue(v)); + } + + bool SequenceImpl::addDouble(unsigned int index, const char* propertyName, long double v) + { + return addSDOValue(index, propertyName, SDOValue(v)); + } + bool SequenceImpl::addDouble(unsigned int index, unsigned int propertyIndex, long double v) + { + return addDouble(index, the_do->getProperty(propertyIndex), v); + } + bool SequenceImpl::addDouble(unsigned int index, const Property& p, long double v) + { + return addSDOValue(index, p, SDOValue(v)); + } + + bool SequenceImpl::addDate(unsigned int index, const char* propertyName, const SDODate v) + { + return addSDOValue(index, propertyName, SDOValue(v)); + } + bool SequenceImpl::addDate(unsigned int index, unsigned int propertyIndex, const SDODate v) + { + return addDate(index, the_do->getProperty(propertyIndex), v); + } + bool SequenceImpl::addDate(unsigned int index, const Property& p, const SDODate v) + { + return addSDOValue(index, p, SDOValue(v)); + } + + bool SequenceImpl::addInteger(unsigned int index, const char* propertyName, long v) + { + return addSDOValue(index, propertyName, SDOValue(v)); + } + bool SequenceImpl::addInteger(unsigned int index, unsigned int propertyIndex, long v) + { + return addInteger(index, the_do->getProperty(propertyIndex), v); + } + bool SequenceImpl::addInteger(unsigned int index, const Property& p, long v) + { + return addSDOValue(index, p, SDOValue(v)); + } + + bool SequenceImpl::addCString(unsigned int index, const char* propertyName, const char* v) + { + return addSDOValue(index, propertyName, SDOValue(SDOString(v))); + } + bool SequenceImpl::addCString(unsigned int index, unsigned int propertyIndex, const char* v) + { + return addCString(index, the_do->getProperty(propertyIndex), v); + } + bool SequenceImpl::addCString(unsigned int index, const Property& p, const char* v) + { + return addSDOValue(index, p, SDOValue(SDOString(v))); + } + + bool SequenceImpl::addBoolean(unsigned int index, const char* propertyName, bool v) + { + return addSDOValue(index, propertyName, SDOValue(v)); + } + bool SequenceImpl::addBoolean(unsigned int index, unsigned int propertyIndex, bool v) + { + return addBoolean(index, the_do->getProperty(propertyIndex), v); + } + bool SequenceImpl::addBoolean(unsigned int index, const Property& p, bool v) + { + return addSDOValue(index, p, SDOValue(v)); + } + + bool SequenceImpl::addSDOValue(unsigned int index, const char* propertyName, const SDOValue& sval) + { + const PropertyImpl* p = the_do->getPropertyImpl(propertyName); + if (p == 0) + { + if (the_do->getType().isOpenType()) + { + p = the_do->defineSDOValue(propertyName, sval); + } + if (p == 0) + { + std::string msg("Cannot find property:"); + msg += propertyName; + SDO_THROW_EXCEPTION("getProperty", + SDOPropertyNotFoundException, + msg.c_str()); + } + } + return addSDOValue(index, (const Property&) *p, sval); + } + bool SequenceImpl::addSDOValue(unsigned int index, unsigned int propertyIndex, const SDOValue& sval) + { + return addSDOValue(index,the_do->getProperty(propertyIndex), sval); + } + bool SequenceImpl::addSDOValue(unsigned int index, const Property& p, const SDOValue& sval) + { + SEQUENCE_ITEM_LIST::iterator i; + SEQUENCE_ITEM_LIST::iterator i2 = the_list.end(); + unsigned int j = 0; + if (index >= the_list.size()) { + return addSDOValue(p, sval); + } + if (p.isMany()) + { + DataObjectList& dol = the_do->getList(p); + dol.append(sval); + + checkRange(index, i); + + /*the_list.insert(i,seq_item(&p,dol.size()-1));*/ + return true; + } + + for (i = the_list.begin(); i != the_list.end(); ++i) + { + const Property* pp = (*i).getProp(); + if (pp == 0) continue; + if (!strcmp(pp->getName(), p.getName())) + { + SDO_THROW_EXCEPTION("Insert", + SDOUnsupportedOperationException, + "Sequence::insert of property which already exists in sequence"); + } + if (j == index) { + i2 = i; + } + j++; + } + + // setSDOValue can update the sequence but does not do so by an append so + // tell it to mind its own business and we will update the sequence here. + the_do->setSDOValue(p, sval, sval.convertTypeEnumToString(), false); + the_list.insert(i2, seq_item(&p, 0)); + return true; + } + +bool SequenceImpl::addString(unsigned int index, + const char* propertyName, + const wchar_t* v, + unsigned int len) +{ + return addSDOValue(index, propertyName, SDOValue(v, len)); +} + +bool SequenceImpl::addString(unsigned int index, unsigned int propertyIndex, const wchar_t* v, unsigned int len) +{ + return addString(index,the_do->getProperty(propertyIndex), v, len); +} +bool SequenceImpl::addString(unsigned int index, const Property& p, const wchar_t* v, unsigned int len) +{ + return addSDOValue(index, p, SDOValue(v, len)); +} + +bool SequenceImpl::addBytes(unsigned int index, + const char* propertyName, + const char* v, + unsigned int len) +{ + return addSDOValue(index, propertyName, SDOValue(v, len)); +} + +bool SequenceImpl::addBytes(unsigned int index, unsigned int propertyIndex, const char* v, unsigned int len) +{ + return addBytes(index,the_do->getProperty(propertyIndex), v, len); +} +bool SequenceImpl::addBytes(unsigned int index, const Property& p, const char* v, unsigned int len) +{ + return addSDOValue(index, p, SDOValue(v, len)); +} + +unsigned int SequenceImpl::getBytesValue(unsigned int index, char* ptr, unsigned int max) +{ + + const SDOValue& result = getSDOValue(index); + + if (result.isSet()) + { + return result.getBytes(ptr, max); + } + else + { + return 0; + } +} +unsigned int SequenceImpl::getStringValue(unsigned int index, wchar_t* ptr, unsigned int max) +{ + + const SDOValue& result = getSDOValue(index); + + if (result.isSet()) + { + return result.getString(ptr, max); + } + else + { + return 0; + } +} + +}; +}; |