| /* $Id$ |
| * |
| * 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. |
| */ |
| |
| #include "serialization/EtchDefaultValueFactory.h" |
| |
| const EtchString& EtchDefaultValueFactory::ETCH_RUNTIME_EXCEPTION_TYPE_NAME() { |
| static const EtchString name("_Etch_RuntimeException"); |
| return name; |
| } |
| |
| const EtchString& EtchDefaultValueFactory::ETCH_LIST_TYPE_NAME() { |
| static const EtchString name("_Etch_List"); |
| return name; |
| } |
| |
| const EtchString& EtchDefaultValueFactory::ETCH_MAP_TYPE_NAME() { |
| static const EtchString name("_Etch_Map"); |
| return name; |
| } |
| |
| const EtchString& EtchDefaultValueFactory::ETCH_SET_TYPE_NAME() { |
| static const EtchString name("_Etch_Set"); |
| return name; |
| } |
| |
| const EtchString& EtchDefaultValueFactory::ETCH_DATETIME_TYPE_NAME() { |
| static const EtchString name("_Etch_Datetime"); |
| return name; |
| } |
| |
| const EtchString& EtchDefaultValueFactory::ETCH_AUTH_EXCEPTION_TYPE_NAME() { |
| static const EtchString name("_Etch_AuthException"); |
| return name; |
| } |
| |
| const EtchString& EtchDefaultValueFactory::ETCH_EXCEPTION_MESSAGE_NAME() { |
| static const EtchString name("_exception"); |
| return name; |
| } |
| |
| const EtchString& EtchDefaultValueFactory::MSG_FIELD_NAME() { |
| static const EtchString name("msg"); |
| return name; |
| } |
| |
| const EtchString& EtchDefaultValueFactory::MESSAGE_ID_FIELD_NAME() { |
| static const EtchString name("_messageId"); |
| return name; |
| } |
| |
| const EtchString& EtchDefaultValueFactory::IN_REPLY_TO_FIELD_NAME() { |
| static const EtchString name("_inReplyTo"); |
| return name; |
| } |
| |
| const EtchString& EtchDefaultValueFactory::RESULT_FIELD_NAME() { |
| static const EtchString name("result"); |
| return name; |
| } |
| |
| const EtchField& EtchDefaultValueFactory::_mf_msg() { |
| static const EtchField name(EtchDefaultValueFactory::MSG_FIELD_NAME()); |
| return name; |
| } |
| |
| const EtchField& EtchDefaultValueFactory::_mf__messageId() { |
| static const EtchField name(EtchDefaultValueFactory::MESSAGE_ID_FIELD_NAME()); |
| return name; |
| } |
| |
| const EtchField& EtchDefaultValueFactory::_mf__inReplyTo() { |
| static const EtchField name(EtchDefaultValueFactory::IN_REPLY_TO_FIELD_NAME()); |
| return name; |
| } |
| |
| const EtchField& EtchDefaultValueFactory::_mf_result() { |
| static const EtchField name(EtchDefaultValueFactory::RESULT_FIELD_NAME()); |
| return name; |
| } |
| |
| capu::Mutex EtchDefaultValueFactory::Mutex; |
| |
| EtchDefaultValueFactory::EtchDefaultValueFactory(EtchString uri, EtchTypeMap* types, EtchClass2TypeMap* class2type) |
| : mMixins(NULL), mTypes(types), mClass2type(class2type) { |
| EtchString result, key("DefaultValueFactory.level"); |
| EtchURL u(uri); |
| status_t error = u.getTerms().get(key, &result); |
| if (error != ETCH_OK) { |
| //default |
| mLevel = LEVEL_FULL; |
| } else { |
| if (result.c_str() != NULL) |
| mLevel = atoi(result.c_str()); |
| if ((mLevel > LEVEL_FULL) || (mLevel < LEVEL_NONE)) { |
| mLevel = LEVEL_FULL; |
| } |
| } |
| mMixins = new EtchList<EtchValueFactory*> (); |
| mDynamicTypes = new EtchTypeMap(); |
| if (types != NULL) { |
| types->get(EtchDefaultValueFactory::ETCH_AUTH_EXCEPTION_TYPE_NAME(), m_mt__Etch_AuthException); |
| types->get(EtchDefaultValueFactory::ETCH_DATETIME_TYPE_NAME(), m_mt__Etch_Datetime); |
| types->get(EtchDefaultValueFactory::ETCH_LIST_TYPE_NAME(), m_mt__Etch_List); |
| types->get(EtchDefaultValueFactory::ETCH_MAP_TYPE_NAME(), m_mt__Etch_Map); |
| types->get(EtchDefaultValueFactory::ETCH_RUNTIME_EXCEPTION_TYPE_NAME(), m_mt__Etch_RuntimeException); |
| types->get(EtchDefaultValueFactory::ETCH_SET_TYPE_NAME(), m_mt__Etch_Set); |
| types->get(EtchDefaultValueFactory::ETCH_EXCEPTION_MESSAGE_NAME(), m_mt__exception); |
| } |
| |
| } |
| |
| EtchDefaultValueFactory::~EtchDefaultValueFactory() { |
| |
| mDynamicTypes->clear(); |
| delete mMixins; |
| delete mDynamicTypes; |
| } |
| |
| status_t EtchDefaultValueFactory::Init(EtchRuntime* runtime, EtchTypeMap* types, EtchClass2TypeMap* class2type) { |
| status_t result = ETCH_OK; |
| |
| EtchType *type; |
| result |= types->get(ETCH_RUNTIME_EXCEPTION_TYPE_NAME(), type); |
| |
| result |= EtchRuntimeExceptionSerializer::Init(runtime, type, class2type); |
| |
| result |= types->get(ETCH_LIST_TYPE_NAME(), type); |
| result |= EtchListSerializer::Init(runtime, type, class2type); |
| |
| result |= types->get(ETCH_MAP_TYPE_NAME(), type); |
| result |= EtchHashTableSerializer::Init(runtime, type, class2type); |
| |
| result |= types->get(ETCH_SET_TYPE_NAME(), type); |
| result |= EtchSetSerializer::Init(runtime, type, class2type); |
| |
| result |= types->get(ETCH_DATETIME_TYPE_NAME(), type); |
| result |= EtchDateSerializer::Init(runtime, type, class2type); |
| |
| result |= types->get(ETCH_AUTH_EXCEPTION_TYPE_NAME(), type); |
| result |= EtchAuthenticationExceptionSerializer::Init(runtime, type, class2type); |
| |
| { |
| result |= types->get(ETCH_EXCEPTION_MESSAGE_NAME(), type); |
| capu::SmartPointer<EtchValidator> val; |
| EtchValidatorRuntimeException::Get(runtime, val); |
| result |= type->putValidator(_mf_result(), val); |
| EtchValidatorLong::Get(runtime, 0, val); |
| result |= type->putValidator(_mf__messageId(), val); |
| result |= type->putValidator(_mf__inReplyTo(), val); |
| } |
| |
| return result; |
| } |
| |
| const EtchType * EtchDefaultValueFactory::get_mt__Etch_RuntimeException() { |
| return m_mt__Etch_RuntimeException; |
| } |
| |
| const EtchType * EtchDefaultValueFactory::get_mt__Etch_List() { |
| return m_mt__Etch_List; |
| } |
| |
| const EtchType* EtchDefaultValueFactory::get_mt__Etch_Map() { |
| return m_mt__Etch_Map; |
| } |
| |
| const EtchType* EtchDefaultValueFactory::get_mt__Etch_Set() { |
| return m_mt__Etch_Set; |
| } |
| |
| const EtchType* EtchDefaultValueFactory::get_mt__Etch_Datetime() { |
| return m_mt__Etch_Datetime; |
| } |
| |
| const EtchType* EtchDefaultValueFactory::get_mt__Etch_AuthException() { |
| return m_mt__Etch_AuthException; |
| } |
| |
| EtchType* EtchDefaultValueFactory::get_mt__exception() { |
| return m_mt__exception; |
| } |
| |
| status_t EtchDefaultValueFactory::getType(capu::uint32_t id, EtchType *&result) { |
| status_t res = mTypes->get(id, result); |
| if (res == ETCH_OK) |
| return ETCH_OK; |
| |
| if (mMixins == NULL) |
| return ETCH_ERROR; |
| |
| EtchValueFactory *tmp; |
| for (int i = 0; i < mMixins->size(); i++) { |
| if (mMixins->get(i, &tmp) == ETCH_OK) { |
| if (tmp->getType(id, result) == ETCH_OK) |
| return ETCH_OK; |
| } |
| } |
| |
| Mutex.lock(); |
| res = mDynamicTypes->get(id, result); |
| if (res == ETCH_OK) { |
| Mutex.unlock(); |
| return ETCH_OK; |
| } |
| Mutex.unlock(); |
| return ETCH_ERROR; |
| } |
| |
| status_t EtchDefaultValueFactory::getType(EtchString& name, EtchType *&result) { |
| status_t res = mTypes->get(name, result); |
| if (res == ETCH_OK) |
| return ETCH_OK; |
| |
| if (mMixins == NULL) |
| return ETCH_ERROR; |
| |
| EtchValueFactory *tmp; |
| for (int i = 0; i < mMixins->size(); i++) { |
| if (mMixins->get(i, &tmp) == ETCH_OK) { |
| if (tmp->getType(name, result) == ETCH_OK) |
| return ETCH_OK; |
| } |
| } |
| |
| Mutex.lock(); |
| res = mDynamicTypes->get(name, result); |
| if (res == ETCH_OK) { |
| Mutex.unlock(); |
| return ETCH_OK; |
| } |
| Mutex.unlock(); |
| return ETCH_ERROR; |
| } |
| |
| status_t EtchDefaultValueFactory::addType(EtchType* type) { |
| Mutex.lock(); |
| status_t result = mDynamicTypes->add(type); |
| Mutex.unlock(); |
| return result; |
| } |
| |
| status_t EtchDefaultValueFactory::exportCustomValue(capu::SmartPointer<EtchObject> value, EtchStructValue*& result) { |
| if (value.get() == NULL) |
| return ETCH_EINVAL; |
| const EtchObjectType* typeID = value->getObjectType(); |
| EtchType* type = NULL; |
| getCustomStructType(typeID, type); |
| |
| if (type == NULL && typeID == EtchStructValue::TYPE()) { |
| capu::SmartPointer<EtchStructValue> _struct = capu::smartpointer_cast<EtchStructValue > (value); |
| type = _struct->getType(); |
| } |
| |
| if (type == NULL) { |
| if ((typeID == EtchAuthenticationException::TYPE()) || (typeID == EtchRuntimeException::TYPE()) || (typeID == EtchException::TYPE())) |
| type = m_mt__Etch_RuntimeException; |
| else if (typeID->getTypeId() == EOTID_LIST) |
| type = m_mt__Etch_List; |
| else if (typeID->getTypeId() == EOTID_HASHTABLE) |
| type = m_mt__Etch_Map; |
| else if (typeID->getTypeId() == EOTID_SET) |
| type = m_mt__Etch_Set; |
| else { |
| return ETCH_EINVAL; |
| } |
| } |
| |
| EtchImportExportHelper* helper = type->getImportExportHelper(); |
| |
| if (helper == NULL) |
| return ETCH_EINVAL; |
| |
| return helper->exportValue(this, value, result); |
| } |
| |
| status_t EtchDefaultValueFactory::importCustomValue(EtchStructValue* value, capu::SmartPointer<EtchObject> &result) { |
| if (value == NULL) |
| return ETCH_EINVAL; |
| EtchType * type = value->getType(); |
| EtchImportExportHelper* helper; |
| if (type == NULL) |
| return ETCH_EINVAL; |
| |
| helper = type->getImportExportHelper(); |
| if (helper == NULL) |
| return ETCH_EINVAL; |
| |
| return helper->importValue(value, result); |
| } |
| |
| status_t EtchDefaultValueFactory::getCustomStructType(const EtchObjectType *c, EtchType *& type) { |
| status_t result = mClass2type->get(c, &type); |
| if (result == ETCH_OK) |
| return ETCH_OK; |
| |
| EtchValueFactory *tmp; |
| for (int i = 0; i < mMixins->size(); i++) { |
| mMixins->get(i, &tmp); |
| if (tmp->getCustomStructType(c, type) == ETCH_OK) |
| return ETCH_OK; |
| } |
| return ETCH_EINVAL; |
| } |
| |
| status_t EtchDefaultValueFactory::getNativeArrayForComponentType(const EtchObjectType *objectType, capu::SmartPointer<EtchNativeArrayBase> &nativeArray, capu::int32_t length, capu::int32_t dim) { |
| return ETCH_EUNIMPL; |
| } |
| |
| EtchString EtchDefaultValueFactory::getStringEncoding() { |
| return EtchString("utf-8"); |
| } |
| |
| status_t EtchDefaultValueFactory::getMessageId(EtchMessage* msg, capu::int64_t &result) { |
| if (msg == NULL) |
| return ETCH_EINVAL; |
| |
| capu::SmartPointer<EtchObject> l; |
| if (msg->get(_mf__messageId(), &l) != ETCH_OK) |
| return ETCH_ERROR; |
| |
| result = ((EtchLong *) l.get())->get(); |
| return ETCH_OK; |
| } |
| |
| status_t EtchDefaultValueFactory::setMessageId(EtchMessage* msg, capu::int64_t msgid) { |
| if (msg == NULL) |
| return ETCH_EINVAL; |
| capu::SmartPointer<EtchObject> value = new EtchLong(msgid); |
| status_t res = msg->put(_mf__messageId(), value); |
| if (res != ETCH_OK) { |
| return res; |
| } |
| return ETCH_OK; |
| } |
| |
| EtchField EtchDefaultValueFactory::get_mf__messageId() { |
| return _mf__messageId(); |
| } |
| |
| status_t EtchDefaultValueFactory::getInReplyToMessageId(EtchMessage* msg, capu::int64_t &result) { |
| if (msg == NULL) |
| return ETCH_EINVAL; |
| capu::SmartPointer<EtchObject> l; |
| if (msg->get(_mf__inReplyTo(), &l) != ETCH_OK) |
| return ETCH_ERROR; |
| result = ((EtchLong *) l.get())->get(); |
| return ETCH_OK; |
| } |
| |
| status_t EtchDefaultValueFactory::setInReplyToMessageId(EtchMessage* msg, capu::int64_t msgid) { |
| if (msg == NULL) |
| return ETCH_EINVAL; |
| capu::SmartPointer<EtchObject> value = new EtchLong(msgid); |
| status_t res = msg->put(_mf__inReplyTo(), value); |
| if (res != ETCH_OK) { |
| return res; |
| } |
| return ETCH_OK; |
| } |
| |
| EtchField EtchDefaultValueFactory::get_mf__inReplyTo() { |
| return _mf__inReplyTo(); |
| } |
| |
| status_t EtchDefaultValueFactory::lockDynamicTypes() { |
| mDynamicTypes->lock(); |
| return ETCH_OK; |
| } |
| |
| status_t EtchDefaultValueFactory::unlockDynamicTypes() { |
| return ETCH_ENOT_SUPPORTED; |
| } |
| |
| EtchLevel EtchDefaultValueFactory::getLevel() { |
| return mLevel; |
| } |
| |
| EtchLevel EtchDefaultValueFactory::setLevel(EtchLevel level) { |
| EtchLevel oldLevel = this->mLevel; |
| this->mLevel = level; |
| return oldLevel; |
| } |
| |
| void EtchDefaultValueFactory::addMixin(EtchValueFactory* vf) { |
| mMixins->add(vf); |
| } |