diff options
Diffstat (limited to 'TAO/orbsvcs/orbsvcs/Property/CosPropertyService_i.cpp')
| -rw-r--r-- | TAO/orbsvcs/orbsvcs/Property/CosPropertyService_i.cpp | 1306 |
1 files changed, 300 insertions, 1006 deletions
diff --git a/TAO/orbsvcs/orbsvcs/Property/CosPropertyService_i.cpp b/TAO/orbsvcs/orbsvcs/Property/CosPropertyService_i.cpp index ec8ae6a5581..bb59682f6a1 100644 --- a/TAO/orbsvcs/orbsvcs/Property/CosPropertyService_i.cpp +++ b/TAO/orbsvcs/orbsvcs/Property/CosPropertyService_i.cpp @@ -41,14 +41,14 @@ CosProperty_Hash_Key::CosProperty_Hash_Key (const CosProperty_Hash_Key &src) int CosProperty_Hash_Key::operator == (const CosProperty_Hash_Key &hash_key) const { - return (ACE_OS::strcmp (this->pname_, - hash_key.pname_) == 0); + return ACE_OS::strcmp (this->pname_.in (), + hash_key.pname_.in ()) == 0; } u_long CosProperty_Hash_Key::hash (void) const { - u_long ret = ACE::hash_pjw (this->pname_); + u_long ret = ACE::hash_pjw (this->pname_.in ()); return ret; } @@ -57,15 +57,13 @@ CosProperty_Hash_Key::~CosProperty_Hash_Key (void) { } -//====================================================================== - CosProperty_Hash_Value::CosProperty_Hash_Value (void) { } CosProperty_Hash_Value::CosProperty_Hash_Value (const CORBA::Any &any, const CosPropertyService::PropertyModeType &mode) - : pvalue_ (any), + : pvalue_ (new CORBA::Any (any)), pmode_ (mode) { } @@ -98,17 +96,17 @@ TAO_PropertySetFactory::~TAO_PropertySetFactory (void) // things. CosPropertyService::PropertySet_ptr -TAO_PropertySetFactory::create_propertyset (CORBA::Environment &ACE_TRY_ENV) +TAO_PropertySetFactory::create_propertyset (CORBA::Environment &TAO_IN_ENV) { // New a TAO_PropertySet. - TAO_PropertySet *new_set; - ACE_NEW_RETURN (new_set, TAO_PropertySet, 0); + TAO_PropertySet<POA_CosPropertyService::PropertySet> *new_set; + ACE_NEW_RETURN (new_set, TAO_PropertySet<POA_CosPropertyService::PropertySet>, 0); // Successful, store this in the products sequence and return. size_t cur_len = this->propertyset_products_.length (); this->propertyset_products_.length (cur_len + 1); this->propertyset_products_[cur_len] = new_set; - return new_set->_this (ACE_TRY_ENV); + return new_set->_this (TAO_IN_ENV); } // Allows a client to create a new TAO_PropertySet with specific @@ -117,50 +115,56 @@ TAO_PropertySetFactory::create_propertyset (CORBA::Environment &ACE_TRY_ENV) CosPropertyService::PropertySet_ptr TAO_PropertySetFactory::create_constrained_propertyset (const CosPropertyService::PropertyTypes &allowed_property_types, const CosPropertyService::Properties &allowed_properties, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Environment &TAO_IN_ENV) { - TAO_PropertySet *new_set = 0; - CosPropertyService::PropertySet_ptr propset_ptr = 0; + ACE_DEBUG ((LM_DEBUG, + "create_constrained_propertyset\n")); + TAO_PropertySet<POA_CosPropertyService::PropertySet> *new_set = 0; - ACE_TRY + TAO_TRY { // New a TAO_PropertySet using these constraints. ACE_NEW_RETURN (new_set, - TAO_PropertySet (allowed_property_types, + TAO_PropertySet<POA_CosPropertyService::PropertySet> (allowed_property_types, allowed_properties, - ACE_TRY_ENV), + TAO_TRY_ENV), 0); - ACE_TRY_CHECK; - + TAO_CHECK_ENV; + // Successful, store this in the products sequence. size_t products_len = this->propertyset_products_.length (); this->propertyset_products_.length (products_len + 1); this->propertyset_products_[products_len] = new_set; - // All done. - propset_ptr = new_set->_this (ACE_TRY_ENV); - ACE_TRY_CHECK; + // All done. Return the pointer. + return new_set->_this (TAO_IN_ENV); } - ACE_CATCH (CORBA::UserException, ex) + TAO_CATCH (CORBA::UserException, ex) { + // Should be the Multiple exception raised by the PropertySet + // constructor, which got that from define_properties method. + // Throw ConstraintNotSupported exception for this, because that + // is the only exception that this method can throw. + TAO_TRY_ENV.print_exception ("User exception"); + // Release the memory. delete new_set; // Throw the exception. - ACE_TRY_THROW (CosPropertyService::ConstraintNotSupported()); + TAO_THROW_RETURN (CosPropertyService::ConstraintNotSupported(), + 0); } - ACE_CATCH (CORBA::SystemException, ex) + TAO_CATCH (CORBA::SystemException, ex) { + TAO_TRY_ENV.print_exception ("System Exception"); + // Release memory. delete new_set; // Throw the exception. - ACE_RETHROW; + TAO_RETHROW_RETURN (0); } - ACE_ENDTRY; - ACE_CHECK_RETURN (0); - - return propset_ptr; + TAO_ENDTRY_RETURN (0); } // Allows a client to create a new TAO_PropertySet with specific @@ -168,49 +172,51 @@ TAO_PropertySetFactory::create_constrained_propertyset (const CosPropertyService CosPropertyService::PropertySet_ptr TAO_PropertySetFactory::create_initial_propertyset (const CosPropertyService::Properties &initial_properties, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Environment &TAO_IN_ENV) { - TAO_PropertySet *new_set = 0; - CosPropertyService::PropertySet_ptr propset_ptr = 0; + TAO_PropertySet<POA_CosPropertyService::PropertySet> *new_set = 0; - ACE_TRY + TAO_TRY { // New a TAO_PropertySet. ACE_NEW_RETURN (new_set, - TAO_PropertySet (initial_properties, - ACE_TRY_ENV), + TAO_PropertySet<POA_CosPropertyService::PropertySet> (initial_properties, + TAO_TRY_ENV), 0); - ACE_TRY_CHECK; + TAO_CHECK_ENV; // Successful, store this in the products sequence. size_t products_len = this->propertyset_products_.length (); this->propertyset_products_.length (products_len + 1); this->propertyset_products_[products_len] = new_set; - // All done. - propset_ptr = new_set->_this (ACE_TRY_ENV); - ACE_TRY_CHECK; + // All done. Return the pointer. + return new_set->_this (TAO_IN_ENV); } - ACE_CATCH (CosPropertyService::MultipleExceptions, ex) + TAO_CATCH (CosPropertyService::MultipleExceptions, ex) { + // This is the only user exception the constructor can give, and + // this is the only thing I can throw. + TAO_TRY_ENV.print_exception ("MultipleExceptions"); + // Release memory. delete new_set; // Throw the exception. - ACE_RETHROW; + TAO_RETHROW_RETURN (0); } - ACE_CATCH (CORBA::SystemException, ex) + TAO_CATCH (CORBA::SystemException, ex) { + // Should be some system exceptions. + TAO_TRY_ENV.print_exception ("System Exception"); + // Release the memory. delete new_set; // Throw the exception. - ACE_RETHROW; + TAO_RETHROW_RETURN (0); } - ACE_ENDTRY; - ACE_CHECK_RETURN (0); - - return propset_ptr; + TAO_ENDTRY_RETURN (0); } // Destructor. @@ -234,7 +240,7 @@ TAO_PropertySetDefFactory::TAO_PropertySetDefFactory (void) // delete all these New'ed things. CosPropertyService::PropertySetDef_ptr -TAO_PropertySetDefFactory::create_propertysetdef (CORBA::Environment &ACE_TRY_ENV) +TAO_PropertySetDefFactory::create_propertysetdef (CORBA::Environment &TAO_IN_ENV) { // New a TAO_PropertySetDef. TAO_PropertySetDef *new_set; @@ -244,31 +250,27 @@ TAO_PropertySetDefFactory::create_propertysetdef (CORBA::Environment &ACE_TRY_EN size_t cur_len = this->propertysetdef_products_.length (); this->propertysetdef_products_.length (cur_len + 1); this->propertysetdef_products_[cur_len] = new_set; - - CosPropertyService::PropertySetDef_ptr propsetdef_ptr = - new_set->_this (ACE_TRY_ENV); - ACE_CHECK_RETURN (0); - - return propsetdef_ptr; + return new_set->_this (TAO_IN_ENV); } CosPropertyService::PropertySetDef_ptr TAO_PropertySetDefFactory::create_constrained_propertysetdef (const CosPropertyService::PropertyTypes &allowed_property_types, const CosPropertyService::PropertyDefs &allowed_property_defs, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Environment &TAO_IN_ENV) { + ACE_DEBUG ((LM_DEBUG, "create_constrained_propertysetdef\n")); + TAO_PropertySetDef *new_set = 0; - CosPropertyService::PropertySetDef_ptr propsetdef_ptr = 0; - - ACE_TRY + + TAO_TRY { // New a TAO_PropertySetDef using these constraints. ACE_NEW_RETURN (new_set, TAO_PropertySetDef (allowed_property_types, allowed_property_defs, - ACE_TRY_ENV), + TAO_TRY_ENV), 0); - ACE_TRY_CHECK; + TAO_CHECK_ENV; // Successful, store this in the products sequence. size_t products_len = this->propertysetdef_products_.length (); @@ -276,29 +278,35 @@ TAO_PropertySetDefFactory::create_constrained_propertysetdef (const CosPropertyS this->propertysetdef_products_[products_len] = new_set; // All done. Return the pointer. - propsetdef_ptr = new_set->_this (ACE_TRY_ENV); - ACE_TRY_CHECK; + return new_set->_this (TAO_IN_ENV); } - ACE_CATCH (CORBA::UserException, ex) + TAO_CATCH (CORBA::UserException, ex) { + // Should be the Multiple exception raised by the PropertySetDef + // constructor, which got that from define_properties_with_modes + // method. Throw ConstraintNotSupported exception for this, + // because that is the only exception that this method can + // throw. + TAO_TRY_ENV.print_exception ("User exception"); + // Release the memory. delete new_set; // Throw the exception. - ACE_TRY_THROW (CosPropertyService::ConstraintNotSupported()); + TAO_THROW_RETURN (CosPropertyService::ConstraintNotSupported(), + 0); } - ACE_CATCH (CORBA::SystemException, ex) + TAO_CATCH (CORBA::SystemException, ex) { + TAO_TRY_ENV.print_exception ("System Exception"); + // Release memory. delete new_set; // Throw the exception. - ACE_RETHROW; + TAO_RETHROW_RETURN (0); } - ACE_ENDTRY; - ACE_CHECK_RETURN (0); - - return propsetdef_ptr; + TAO_ENDTRY_RETURN (0); } // Allows the client to create a new TAO_PropertySetDef with specific @@ -306,51 +314,54 @@ TAO_PropertySetDefFactory::create_constrained_propertysetdef (const CosPropertyS CosPropertyService::PropertySetDef_ptr TAO_PropertySetDefFactory::create_initial_propertysetdef (const CosPropertyService::PropertyDefs &initial_property_defs, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Environment &TAO_IN_ENV) { + ACE_DEBUG ((LM_DEBUG, "create_initial_propertysetdef\n")); + TAO_PropertySetDef *new_set = 0; - CosPropertyService::PropertySetDef_ptr propsetdef_ptr = 0; - ACE_TRY + TAO_TRY { // New a TAO_PropertySet using these lengths. ACE_NEW_RETURN (new_set, TAO_PropertySetDef (initial_property_defs, - ACE_TRY_ENV), + TAO_TRY_ENV), 0); - ACE_TRY_CHECK; + TAO_CHECK_ENV; // Successful, store this in the products sequence. size_t products_len = this->propertysetdef_products_.length (); this->propertysetdef_products_.length (products_len + 1); this->propertysetdef_products_[products_len] = new_set; - // All done. - propsetdef_ptr = new_set->_this (ACE_TRY_ENV); - ACE_TRY_CHECK; + // All done. Return the pointer. + return new_set->_this (TAO_IN_ENV); } - ACE_CATCH (CosPropertyService::MultipleExceptions, ex) + TAO_CATCH (CosPropertyService::MultipleExceptions, ex) { + // This is the only user exception the constructor can give, and + // this is the only thing I can throw. + TAO_TRY_ENV.print_exception ("MultipleExceptions"); + // Release memory. delete new_set; // Throw the exception. - ACE_RETHROW; + TAO_RETHROW_RETURN (0); } - ACE_CATCH (CORBA::SystemException, ex) + TAO_CATCH (CORBA::SystemException, ex) { + // Should be some system exceptions. + TAO_TRY_ENV.print_exception ("System Exception"); + // Release the memory. delete new_set; // Throw the exception. - ACE_RETHROW; + TAO_RETHROW_RETURN (0); } - ACE_ENDTRY; - ACE_CHECK_RETURN (0); - - return propsetdef_ptr; + TAO_ENDTRY_RETURN (0); } - // Makes default sized hash_table_. TAO_PropertySetDef::TAO_PropertySetDef (void) @@ -361,42 +372,68 @@ TAO_PropertySetDef::TAO_PropertySetDef (void) TAO_PropertySetDef::TAO_PropertySetDef (const CosPropertyService::PropertyTypes allowed_property_types, const CosPropertyService::PropertyDefs allowed_property_defs, - CORBA::Environment &ACE_TRY_ENV) - : TAO_PropertySet(allowed_property_types, - allowed_property_defs.length (), - ACE_TRY_ENV) + CORBA::Environment &TAO_IN_ENV) + : TAO_PropertySet<POA_CosPropertyService::PropertySetDef> (allowed_property_types, + allowed_property_defs.length (), + TAO_IN_ENV) { + ACE_DEBUG ((LM_DEBUG, + "TAO_PropertySetDef Hash_Table:-current_size %d\ntotal_size %d\n", + this->hash_table_.current_size (), + this->hash_table_.total_size ())); + // Set the length of the allowed property names. this->allowed_property_names_.length (allowed_property_defs.length ()); + ACE_DEBUG ((LM_DEBUG, + "Allowed property types size %d\nAllowed propertydefs' names size%d\n", + this->allowed_property_types_.length (), + this->allowed_property_names_.length ())); + // Copy the allowed properties' names to the sequence. for (size_t ni = 0; ni < allowed_property_defs.length (); ni++) this->allowed_property_names_[ni] = allowed_property_defs[ni].property_name; - + // Define the allowed properties in the hash table. - ACE_TRY + TAO_TRY { this->define_properties_with_modes (allowed_property_defs, - ACE_TRY_ENV); - ACE_TRY_CHECK; + TAO_TRY_ENV); + TAO_CHECK_ENV; } - ACE_CATCHANY + TAO_CATCHANY { - ACE_RETHROW; + TAO_TRY_ENV.print_exception ("TAO_PropertySetDef"); + TAO_RETHROW; } - ACE_ENDTRY; - ACE_CHECK; + TAO_ENDTRY; } // Constructor that the factory uses. TAO_PropertySetDef::TAO_PropertySetDef (const CosPropertyService::PropertyDefs initial_property_defs, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Environment &TAO_IN_ENV) { - this->define_properties_with_modes (initial_property_defs, - ACE_TRY_ENV); - ACE_CHECK; + ACE_DEBUG ((LM_DEBUG, + "TAO_PropertySetDef Hash_Table:-current_size %d\ntotal_size %d\nInitialProps %d\n", + this->hash_table_.current_size (), + this->hash_table_.total_size (), + initial_property_defs.length ())); + + // Define the initial properties in this property set def. + TAO_TRY + { + this->define_properties_with_modes (initial_property_defs, + TAO_TRY_ENV); + TAO_CHECK_ENV; + } + TAO_CATCHANY + { + TAO_TRY_ENV.print_exception ("TAO_PropertySetDef-Constructor"); + TAO_RETHROW; + } + TAO_ENDTRY; } // Destructor. @@ -440,72 +477,82 @@ void TAO_PropertySetDef::define_property_with_mode (const char *property_name, const CORBA::Any &property_value, CosPropertyService::PropertyModeType property_mode, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Environment &TAO_IN_ENV) { + ACE_DEBUG ((LM_DEBUG, + "define_property with mode : property_name %s \n", + property_name)); + // Check the names validity. if (property_name == 0) - ACE_THROW (CosPropertyService::InvalidPropertyName()); + TAO_THROW (CosPropertyService::InvalidPropertyName()); // Is this type allowed? if (is_type_allowed (property_value.type ()) != 1) - ACE_THROW (CosPropertyService::UnsupportedTypeCode()); + TAO_THROW (CosPropertyService::UnsupportedTypeCode()); // Is this property allowed? if (is_property_allowed (property_name) != 1) - ACE_THROW (CosPropertyService::UnsupportedProperty()); - + TAO_THROW (CosPropertyService::UnsupportedProperty()); + // Is this a valid mode. if (property_mode == CosPropertyService::undefined) - ACE_THROW (CosPropertyService::UnsupportedMode()); + TAO_THROW (CosPropertyService::UnsupportedMode()); // Try to bind the Property. CosProperty_Hash_Key hash_key (property_name); CosProperty_Hash_Value hash_value (property_value, property_mode); - COSPROPERTY_HASH_ENTRY *entry_ptr; + CosProperty_Hash_Entry_ptr entry_ptr; + - int ret = this->hash_table_.bind (hash_key, hash_value, entry_ptr); - //CosProperty_Hash_Value old_value; - //CosProperty_Hash_Key old_key; + CosProperty_Hash_Value old_value; + CosProperty_Hash_Key old_key; switch (ret) { case 0: + // Bind successful. + ACE_DEBUG ((LM_DEBUG, + "define_property_with_mode successful\n")); break; case 1: // Property name exists. - + // Is the pointer valid. if (entry_ptr == 0) - ACE_THROW (CORBA::UNKNOWN ()); - + TAO_THROW (CORBA::UNKNOWN (CORBA::COMPLETED_NO)); + // If type is not the same, raise exception. - if (entry_ptr->int_id_.pvalue_.type () != property_value.type ()) - ACE_THROW (CosPropertyService::ConflictingProperty()); + if (entry_ptr->int_id_.pvalue_->type () != property_value.type ()) + TAO_THROW (CosPropertyService::ConflictingProperty()); // If mode is read only, raise exception. if ((entry_ptr->int_id_.pmode_ == CosPropertyService::read_only) || (entry_ptr->int_id_.pmode_ == CosPropertyService::fixed_readonly)) - ACE_THROW (CosPropertyService::ReadOnlyProperty()); + TAO_THROW (CosPropertyService::ReadOnlyProperty()); // If current mode is fixed_normal, but the new mode is not // fixed, reject it. if ((entry_ptr->int_id_.pmode_ == CosPropertyService::fixed_normal) && (property_mode < CosPropertyService::fixed_normal)) - ACE_THROW (CosPropertyService::UnsupportedMode()); - + TAO_THROW (CosPropertyService::UnsupportedMode()); + // Everything is fine. Overwrite the value. if (this->hash_table_.rebind (hash_key, - hash_value) > 0) + hash_value, + old_key, + old_value) > 0) { + ACE_DEBUG ((LM_DEBUG, "Property Defined\n")); break; } default: // Error. ret is -1 or rebind returned other than 1. - ACE_THROW (CORBA::UNKNOWN ()); + TAO_THROW (CORBA::UNKNOWN (CORBA::COMPLETED_NO)); } return; @@ -515,8 +562,10 @@ TAO_PropertySetDef::define_property_with_mode (const char *property_name, // MultipleExceptions sequence and raise that. void TAO_PropertySetDef::define_properties_with_modes (const CosPropertyService::PropertyDefs &property_defs, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Environment &TAO_IN_ENV) { + ACE_DEBUG ((LM_DEBUG, "define_properties_with_modes\n")); + // Get the length. size_t sequence_length = property_defs.length (); @@ -526,17 +575,18 @@ TAO_PropertySetDef::define_properties_with_modes (const CosPropertyService::Prop // Try defining the propdefs one by one. for (size_t i = 0; i < sequence_length; i++) { - ACE_TRY + TAO_TRY { // Define the property. this->define_property_with_mode (property_defs[i].property_name, property_defs[i].property_value, property_defs[i].property_mode, - ACE_TRY_ENV); - ACE_TRY_CHECK; + TAO_TRY_ENV); + TAO_CHECK_ENV; } - ACE_CATCH (CosPropertyService::InvalidPropertyName, ex) + TAO_CATCH (CosPropertyService::InvalidPropertyName, ex) { + TAO_TRY_ENV.print_exception ("InvalidPropertyName"); size_t len = multi_ex.exceptions.length (); multi_ex.exceptions.length (len + 1); multi_ex.exceptions[len].reason = @@ -544,8 +594,9 @@ TAO_PropertySetDef::define_properties_with_modes (const CosPropertyService::Prop multi_ex.exceptions[len].failing_property_name = property_defs[i].property_name; } - ACE_CATCH (CosPropertyService::ConflictingProperty, ex) + TAO_CATCH (CosPropertyService::ConflictingProperty, ex) { + TAO_TRY_ENV.print_exception ("ConflictingProperty"); size_t len = multi_ex.exceptions.length (); multi_ex.exceptions.length (len + 1); multi_ex.exceptions[len].reason = @@ -553,8 +604,9 @@ TAO_PropertySetDef::define_properties_with_modes (const CosPropertyService::Prop multi_ex.exceptions[len].failing_property_name = property_defs[i].property_name; } - ACE_CATCH (CosPropertyService::ReadOnlyProperty, ex) + TAO_CATCH (CosPropertyService::ReadOnlyProperty, ex) { + TAO_TRY_ENV.print_exception ("ReadOnlyProperty"); size_t len = multi_ex.exceptions.length (); multi_ex.exceptions.length (len + 1); multi_ex.exceptions[len].reason = @@ -562,8 +614,9 @@ TAO_PropertySetDef::define_properties_with_modes (const CosPropertyService::Prop multi_ex.exceptions[len].failing_property_name = property_defs[i].property_name; } - ACE_CATCH (CosPropertyService::UnsupportedTypeCode, ex) + TAO_CATCH (CosPropertyService::UnsupportedTypeCode, ex) { + TAO_TRY_ENV.print_exception ("UnsupportedTypeCode"); size_t len = multi_ex.exceptions.length (); multi_ex.exceptions.length (len + 1); multi_ex.exceptions[len].reason = @@ -571,8 +624,9 @@ TAO_PropertySetDef::define_properties_with_modes (const CosPropertyService::Prop multi_ex.exceptions[len].failing_property_name = property_defs[i].property_name; } - ACE_CATCH (CosPropertyService::UnsupportedProperty, ex) + TAO_CATCH (CosPropertyService::UnsupportedProperty, ex) { + TAO_TRY_ENV.print_exception ("UnsupportedProperty"); size_t len = multi_ex.exceptions.length (); multi_ex.exceptions.length (len + 1); multi_ex.exceptions[len].reason = @@ -580,40 +634,43 @@ TAO_PropertySetDef::define_properties_with_modes (const CosPropertyService::Prop multi_ex.exceptions[len].failing_property_name = property_defs[i].property_name; } - ACE_CATCH (CosPropertyService::UnsupportedMode, ex) - { - ACE_TRY_ENV.print_exception ("UnsupportedMode"); + TAO_CATCH (CosPropertyService::UnsupportedMode, ex) + { + TAO_TRY_ENV.print_exception ("UnsupportedMode"); size_t len = multi_ex.exceptions.length (); multi_ex.exceptions.length (len + 1); multi_ex.exceptions[len].reason = CosPropertyService::unsupported_mode; multi_ex.exceptions[len].failing_property_name = property_defs[i].property_name; - } - ACE_CATCH (CORBA::SystemException, sysex) - { - ACE_RETHROW; - } - ACE_ENDTRY; - ACE_CHECK; + } + TAO_CATCH (CORBA::SystemException, sysex) + { + // Print it and throw it again. + TAO_TRY_ENV.print_exception ("SystemException"); + TAO_RETHROW; + } + TAO_ENDTRY; } // Raise the multi exception if needed. if (multi_ex.exceptions.length () > 0) - ACE_THROW (CosPropertyService::MultipleExceptions (multi_ex)); + TAO_THROW (CosPropertyService::MultipleExceptions (multi_ex)); } // Get the mode of a property. Raises InvalidpropertyName, // PropertyNotFound exceptions. CosPropertyService::PropertyModeType TAO_PropertySetDef::get_property_mode (const char *property_name, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Environment &TAO_IN_ENV) { + ACE_DEBUG ((LM_DEBUG, "get_property_mode\n")); + // Check for the name's validity. if (property_name == 0) - ACE_THROW_RETURN (CosPropertyService::InvalidPropertyName(), + TAO_THROW_RETURN (CosPropertyService::InvalidPropertyName(), CosPropertyService::undefined); - + // Find the property in the hash table. CosProperty_Hash_Key hash_key (property_name); CosProperty_Hash_Value hash_value; @@ -627,7 +684,7 @@ TAO_PropertySetDef::get_property_mode (const char *property_name, return hash_value.pmode_; default: // Error or property is not found. - ACE_THROW_RETURN (CosPropertyService::PropertyNotFound(), + TAO_THROW_RETURN (CosPropertyService::PropertyNotFound(), CosPropertyService::undefined); } } @@ -642,7 +699,7 @@ TAO_PropertySetDef::get_property_mode (const char *property_name, CORBA::Boolean TAO_PropertySetDef::get_property_modes (const CosPropertyService::PropertyNames &property_names, CosPropertyService::PropertyModes_out property_modes, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Environment &) { // Allocate memory for the out parameter. ACE_NEW_RETURN (property_modes, @@ -665,19 +722,22 @@ TAO_PropertySetDef::get_property_modes (const CosPropertyService::PropertyNames CosPropertyService::PropertyModeType mode; for (size_t i = 0; i < sequence_length; i++) { - ACE_TRY + TAO_TRY { // Invoke get_property_mode for this name. mode = this->get_property_mode (property_names[i], - ACE_TRY_ENV); - ACE_TRY_CHECK; + TAO_TRY_ENV); + TAO_CHECK_ENV; // Store the mode in the out sequence. property_modes[i].property_name = property_names[i]; property_modes[i].property_mode = mode; } - ACE_CATCHANY + TAO_CATCHANY { + // DEBUG. + TAO_TRY_ENV.print_exception ("Some exception"); + // Return value becomes false. ret = 1; @@ -686,8 +746,7 @@ TAO_PropertySetDef::get_property_modes (const CosPropertyService::PropertyNames property_modes[i].property_name = property_names[i]; property_modes[i].property_mode = CosPropertyService::undefined; } - ACE_ENDTRY; - ACE_CHECK_RETURN (0); + TAO_ENDTRY; } return ret; @@ -701,24 +760,26 @@ TAO_PropertySetDef::get_property_modes (const CosPropertyService::PropertyNames void TAO_PropertySetDef::set_property_mode (const char *property_name, CosPropertyService::PropertyModeType property_mode, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Environment &TAO_IN_ENV) { + ACE_DEBUG ((LM_DEBUG, "set-property_mode")); + // Check the names validity. if (property_name == 0) - ACE_THROW (CosPropertyService::InvalidPropertyName()); + TAO_THROW (CosPropertyService::InvalidPropertyName()); // Trying to set to undefined mode is not allowed. if (property_mode == CosPropertyService::undefined) - ACE_THROW (CosPropertyService::UnsupportedMode()); + TAO_THROW (CosPropertyService::UnsupportedMode()); // Find the property from the Hash Table. CosProperty_Hash_Key hash_key (property_name); CosProperty_Hash_Value hash_value; int ret = this->hash_table_.find (hash_key, hash_value); - - //CosProperty_Hash_Value old_value; - //CosProperty_Hash_Key old_key; + + CosProperty_Hash_Value old_value; + CosProperty_Hash_Key old_key; // Act acc to the ret value. switch (ret) @@ -737,50 +798,63 @@ TAO_PropertySetDef::set_property_mode (const char *property_name, // Set the new mode and update the hash table. hash_value.pmode_ = property_mode; if (this->hash_table_.rebind (hash_key, - hash_value) != 1) + hash_value, + old_key, + old_value) != 1) // Return values 0 and -1 are not possible. - ACE_THROW (CORBA::UNKNOWN ()); + TAO_THROW (CORBA::UNKNOWN (CORBA::COMPLETED_NO)); + else + ACE_DEBUG ((LM_DEBUG, + "Mode set succesful\n")); break; - + case CosPropertyService::read_only: // Read_only to fixed read only alone is possible. if (property_mode != CosPropertyService::fixed_readonly) - ACE_THROW (CosPropertyService::UnsupportedMode()); + TAO_THROW (CosPropertyService::UnsupportedMode()); else { // Change the mode and update hash table. hash_value.pmode_ = property_mode; if (this->hash_table_.rebind (hash_key, - hash_value) != 1) + hash_value, + old_key, + old_value) != 1) // Return values 0 and -1 are not possible. - ACE_THROW (CORBA::UNKNOWN ()); + TAO_THROW (CORBA::UNKNOWN (CORBA::COMPLETED_NO)); + else + ACE_DEBUG ((LM_DEBUG, "Mode set successful\n")); } break; case CosPropertyService::fixed_normal: // Fixed_normal to fixed_readonly alone is possible. if (property_mode != CosPropertyService::fixed_readonly) - ACE_THROW (CosPropertyService::UnsupportedMode()); + TAO_THROW (CosPropertyService::UnsupportedMode()); else { // Change the mode and update the hash table. hash_value.pmode_ = property_mode; if (this->hash_table_.rebind (hash_key, + hash_value, + hash_key, hash_value) != 1) // Return values 0 and -1 are not possible. - ACE_THROW (CORBA::UNKNOWN ()); + TAO_THROW (CORBA::UNKNOWN (CORBA::COMPLETED_NO)); + else + ACE_DEBUG ((LM_DEBUG, "Mode set successful\n")); } break; default: // Fixed_readonly to any mode is not possible. - ACE_THROW (CosPropertyService::UnsupportedMode()); + TAO_THROW (CosPropertyService::UnsupportedMode()); } break; case -1: default: // Error or property not found in the Hash Table. - ACE_THROW (CosPropertyService::PropertyNotFound()); + TAO_THROW (CosPropertyService::PropertyNotFound()); } } @@ -791,8 +865,10 @@ TAO_PropertySetDef::set_property_mode (const char *property_name, void TAO_PropertySetDef::set_property_modes (const CosPropertyService::PropertyModes &property_modes, - CORBA::Environment &ACE_TRY_ENV) + CORBA::Environment &TAO_IN_ENV) { + ACE_DEBUG ((LM_DEBUG, "set_property_modes\n")); + // Get the length of the sequence. size_t sequence_length = property_modes.length (); @@ -802,15 +878,18 @@ TAO_PropertySetDef::set_property_modes (const CosPropertyService::PropertyModes // Set modes one by one. for (size_t i = 0; i < sequence_length; i++) { - ACE_TRY + TAO_TRY { this->set_property_mode (property_modes[i].property_name, property_modes[i].property_mode, - ACE_TRY_ENV); - ACE_TRY_CHECK; + TAO_TRY_ENV); + TAO_CHECK_ENV; } - ACE_CATCH (CosPropertyService::PropertyNotFound, ex) + TAO_CATCH (CosPropertyService::PropertyNotFound, ex) { + // DEBUG. + TAO_TRY_ENV.print_exception ("PropertyNotFound"); + // Put this exception in the multiple exception. size_t len = multi_ex.exceptions.length (); multi_ex.exceptions.length (len + 1); @@ -819,8 +898,11 @@ TAO_PropertySetDef::set_property_modes (const CosPropertyService::PropertyModes multi_ex.exceptions[len].failing_property_name = property_modes[i].property_name; } - ACE_CATCH (CosPropertyService::InvalidPropertyName, ex) + TAO_CATCH (CosPropertyService::InvalidPropertyName, ex) { + // DEBUG. + TAO_TRY_ENV.print_exception ("InvalidPropertyName"); + // Put this exception in the multiple exception. size_t len = multi_ex.exceptions.length (); multi_ex.exceptions.length (len + 1); @@ -829,8 +911,11 @@ TAO_PropertySetDef::set_property_modes (const CosPropertyService::PropertyModes multi_ex.exceptions[len].failing_property_name = property_modes[i].property_name; } - ACE_CATCH (CosPropertyService::UnsupportedMode, ex) + TAO_CATCH (CosPropertyService::UnsupportedMode, ex) { + // DEBUG. + TAO_TRY_ENV.print_exception ("UnsupportedMode"); + // Put this exception in the multiple exception. size_t len = multi_ex.exceptions.length (); multi_ex.exceptions.length (len + 1); @@ -839,22 +924,28 @@ TAO_PropertySetDef::set_property_modes (const CosPropertyService::PropertyModes multi_ex.exceptions[len].failing_property_name = property_modes[i].property_name; } - ACE_CATCH (CORBA::SystemException, systex) + TAO_CATCH (CORBA::SystemException, systex) { - ACE_RETHROW; + // DEBUG. + TAO_TRY_ENV.print_exception ("Unknown"); + + // We cant afford to get this. Throw this. + TAO_RETHROW; } - ACE_ENDTRY; - ACE_CHECK; + TAO_ENDTRY; } // Raise the multi_ex, if needed. if (multi_ex.exceptions.length () > 0) - ACE_THROW (CosPropertyService::MultipleExceptions (multi_ex)); + { + ACE_DEBUG ((LM_DEBUG, "set_property_modes:- Raising multi_ex\n")); + TAO_THROW (CosPropertyService::MultipleExceptions (multi_ex)); + } } // Constructor. Construct the iterator from the PropertySet object. -TAO_PropertyNamesIterator::TAO_PropertyNamesIterator (TAO_PropertySet &property_set) +TAO_PropertyNamesIterator::TAO_PropertyNamesIterator (TAO_PropertySet<POA_CosPropertyService::PropertySet> &property_set) : iterator_ (property_set.hash_table_) { } @@ -883,12 +974,12 @@ CORBA::Boolean TAO_PropertyNamesIterator::next_one (CORBA::String_out property_name, CORBA::Environment &) { - COSPROPERTY_HASH_ENTRY *entry_ptr; + CosProperty_Hash_Entry_ptr entry_ptr; if (this->iterator_.next (entry_ptr) != 0) { property_name = - CORBA::string_dup (entry_ptr->ext_id_.pname_); + CORBA::string_dup (entry_ptr->ext_id_.pname_.in ()); this->iterator_.advance (); return 1; } @@ -906,50 +997,31 @@ TAO_PropertyNamesIterator::next_n (CORBA::ULong how_many, CosPropertyService::PropertyNames, 0); - COSPROPERTY_HASH_ENTRY *entry_ptr = 0; + CosProperty_Hash_Entry_ptr entry_ptr = 0; if (this->iterator_.next (entry_ptr) == 0 || how_many == 0) return 0; size_t size = this->iterator_.map ().current_size (); - - size_t len = 0; - if (how_many <= size) - len = how_many; - else - len = size; - property_names->length (len); + + property_names->length (how_many <= size ? how_many : size); for (size_t ni = 0; ni < property_names->length (); ni++, this->iterator_.advance ()) if (this->iterator_.next (entry_ptr) != 0) property_names [ni] = - CORBA::string_dup (entry_ptr->ext_id_.pname_); + CORBA::string_dup (entry_ptr->ext_id_.pname_.in ()); return 1; } void -TAO_PropertyNamesIterator::destroy (CORBA::Environment &ACE_TRY_ENV) +TAO_PropertyNamesIterator::destroy (CORBA::Environment &) { - // Remove self from POA. Because of reference counting, the POA - // will automatically delete the servant when all pending requests - // on this servant are complete. - - PortableServer::POA_var poa = this->_default_POA (ACE_TRY_ENV); - ACE_CHECK; - - PortableServer::ObjectId_var id = poa->servant_to_id (this, - ACE_TRY_ENV); - ACE_CHECK; - - poa->deactivate_object (id.in (), - ACE_TRY_ENV); - ACE_CHECK; } -TAO_PropertiesIterator::TAO_PropertiesIterator (TAO_PropertySet &property_set) +TAO_PropertiesIterator::TAO_PropertiesIterator (TAO_PropertySet<POA_CosPropertyService::PropertySet> &property_set) : iterator_ (property_set.hash_table_) { } @@ -968,13 +1040,13 @@ CORBA::Boolean TAO_PropertiesIterator::next_one (CosPropertyService::Property_out aproperty, CORBA::Environment &) { - COSPROPERTY_HASH_ENTRY *entry_ptr; - + CosProperty_Hash_Entry_ptr entry_ptr; + if (this->iterator_.next (entry_ptr) != 0) { aproperty = new CosPropertyService::Property; aproperty->property_name = entry_ptr->ext_id_.pname_; - aproperty->property_value = entry_ptr->int_id_.pvalue_; + aproperty->property_value = entry_ptr->int_id_.pvalue_.in (); this->iterator_.advance (); return 1; } @@ -995,817 +1067,35 @@ TAO_PropertiesIterator::next_n (CORBA::ULong how_many, CosPropertyService::Properties, 0); - COSPROPERTY_HASH_ENTRY *entry_ptr = 0; + CosProperty_Hash_Entry_ptr entry_ptr = 0; if (this->iterator_.next (entry_ptr) == 0 || how_many == 0) return 0; size_t size = this->iterator_.map ().current_size (); - size_t len; - if (how_many <= size) - len = how_many; - else - len = size; - nproperties->length (len); + nproperties->length (how_many <= size ? how_many : size); for (size_t ni = 0; ni < nproperties->length (); ni++, this->iterator_.advance ()) - { - if (this->iterator_.next (entry_ptr) != 0) - { - nproperties [ni].property_name = entry_ptr->ext_id_.pname_; - nproperties [ni].property_value = - entry_ptr->int_id_.pvalue_; - } - else - break; - } - - return 1; -} - -void -TAO_PropertiesIterator::destroy (CORBA::Environment &ACE_TRY_ENV) -{ - // Remove self from POA. Because of reference counting, the POA - // will automatically delete the servant when all pending requests - // on this servant are complete. - - PortableServer::POA_var poa = this->_default_POA (ACE_TRY_ENV); - ACE_CHECK; - - PortableServer::ObjectId_var id = poa->servant_to_id (this, - ACE_TRY_ENV); - ACE_CHECK; - - poa->deactivate_object (id.in (), - ACE_TRY_ENV); - ACE_CHECK; -} - -// Makes default sized hash_table_. All the sequences are set the max -// length as 0. - -TAO_PropertySet::TAO_PropertySet (void) -{ -} - -// Init values that the PropertySetFactory will want to specify. Write -// the allowed properties in the Hash Table with *fixed-normal* mode. -// @@ Need to check for duplicate properties and raise exceptions. - - -TAO_PropertySet::TAO_PropertySet (const CosPropertyService::PropertyTypes allowed_property_types, - const CosPropertyService::Properties allowed_properties, - CORBA::Environment &ACE_TRY_ENV) - : allowed_property_types_ (allowed_property_types), - allowed_property_names_ (allowed_properties.length ()) -{ - // Set the length for the sequence, just to make sure. - this->allowed_property_names_.length (allowed_properties.length ()); - - // Keep the allowed property names in the sequence.. - for (size_t ni = 0; - ni < allowed_properties.length (); - ni++) - this->allowed_property_names_[ni] = - allowed_properties[ni].property_name; - - // Define the allowed properties in the hash table. - ACE_TRY - { - this->define_properties (allowed_properties, - ACE_TRY_ENV); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "TAO_PropertySet-Constructor"); - ACE_RETHROW; - } - ACE_ENDTRY; - ACE_CHECK; -} - -// TAO_PropertySetDef's constructor needs this, for initializing the -// allowed properties' sequence withe just the maximum length. - -TAO_PropertySet::TAO_PropertySet (const CosPropertyService::PropertyTypes allowed_property_types, - const CORBA::ULong number_of_allowed_properties, - CORBA::Environment &) - : allowed_property_types_ (allowed_property_types), - allowed_property_names_ (number_of_allowed_properties) -{ -} - -// PropertySetFactory needs this constructor. Store all the initial -// properies with *normal* modes. - - -TAO_PropertySet::TAO_PropertySet (const CosPropertyService::Properties initial_properties, - CORBA::Environment &ACE_TRY_ENV) -{ - // Define all the initial properties in the Property Set. All take - // *normal* modes. - ACE_TRY - { - this->define_properties (initial_properties, - ACE_TRY_ENV); - ACE_TRY_CHECK; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, "TAO_PropertySet-Constructor"); - ACE_RETHROW; - } - ACE_ENDTRY; - ACE_CHECK; -} - -// Destructor. All sequences will be deleted. - -TAO_PropertySet::~TAO_PropertySet (void) -{ -} - -// Function to modify or add a property to the PropertySet: -// Adds the name and the value to the set... Doesn't check for Typecode -// overwriting, duplicate names, void names etc, yet. -// @@ Uses Normal mode as the default mode of properties, We can -// change this behavior based on the Initial set of allowed modes, if -// there is anything like that set by the client. - - -void -TAO_PropertySet::define_property (const char *property_name, - const CORBA::Any &property_value, - CORBA::Environment &ACE_TRY_ENV) -{ - // Check the name's validity. - if (property_name == 0) - ACE_THROW (CosPropertyService::InvalidPropertyName()); - - // Is this type allowed? - if (is_type_allowed (property_value.type ()) != 1) - ACE_THROW (CosPropertyService::UnsupportedTypeCode()); - - // Is this property allowed? - if (is_property_allowed (property_name) != 1) - ACE_THROW (CosPropertyService::UnsupportedProperty()); - - // Try to bind the property. Use normal mode. - CosProperty_Hash_Key hash_key (property_name); - CosProperty_Hash_Value hash_value (property_value, - CosPropertyService::normal); - COSPROPERTY_HASH_ENTRY *entry_ptr; - //CosProperty_Hash_Key old_key; - //CosProperty_Hash_Value old_value; - - int ret = this->hash_table_.bind (hash_key, - hash_value, - entry_ptr); - switch (ret) - { - case 0: - break; - case 1: - // Property already exists. - - // Is the pointer valid? - if (entry_ptr == 0) - ACE_THROW (CORBA::UNKNOWN ()); - - // If type is not the same, raise exception. - if (entry_ptr->int_id_.pvalue_.type () != property_value.type ()) - ACE_THROW (CosPropertyService::ConflictingProperty()); - - // If mode is read only, raise exception. - if ((entry_ptr->int_id_.pmode_ == CosPropertyService::read_only) || - (entry_ptr->int_id_.pmode_ == CosPropertyService::fixed_readonly)) - ACE_THROW (CosPropertyService::ReadOnlyProperty()); - - // Use the mode that is already there. - hash_value.pmode_ = entry_ptr->int_id_.pmode_; - - // Everything is fine. Overwrite the value. - if (this->hash_table_.rebind (hash_key, - hash_value) != 1) - { - ACE_DEBUG ((LM_DEBUG, - "TAO_PropertySet::Define Property failed\n")); - TAO_THROW (CORBA::UNKNOWN ()); - } - break; - default: - // Error. ret is -1. - TAO_THROW (CORBA::UNKNOWN ()); - } - - return; -} - -// Tells whether this type is allowed in this property set or no. - -CORBA::Boolean -TAO_PropertySet::is_type_allowed (CORBA::TypeCode_ptr type) -{ - ACE_DECLARE_NEW_CORBA_ENV; - - // If the sequence is empty, no constraints. - if (this->allowed_property_types_.length () == 0) - return 1; - - // Check in the allowed_property_types sequence. - CORBA::Boolean ret_val = 0; - for (size_t ti = 0; - ti < this->allowed_property_types_.length (); - ti++) - { - ACE_TRY - { - ret_val = ((const CORBA::TypeCode *)this->allowed_property_types_[ti])->equal (type, - ACE_TRY_ENV); - ACE_TRY_CHECK; - - if (ret_val == 1) - return 1; - } - ACE_CATCHANY - { - ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION, - "TAO_PropertySet::is_type_allowed failed"); - return ret_val; - } - ACE_ENDTRY; - ACE_CHECK_RETURN (0); - } - - // Type not found. - return ret_val; -} - -// Tells whether this property is allowed in this property or no. - -CORBA::Boolean -TAO_PropertySet::is_property_allowed (const char* property_name) -{ - // If the sequence is empty, no constraints. - if (this->allowed_property_names_.length() == 0) - return 1; - - // Check in the allowed_property_names. - for (size_t ni = 0; - ni < this->allowed_property_names_.length (); - ni++) - if (ACE_OS::strcmp ((const char *) this->allowed_property_names_[ni], - property_name) == 0) - return 1; - - // Name not found in the sequence. - return 0; -} - -// Defining a sequence of properties -// -// Check for overwriting, duplicate names, void names etc and raise -// appropriate exceptions. - - -void -TAO_PropertySet::define_properties (const CosPropertyService::Properties &nproperties, - CORBA::Environment &ACE_TRY_ENV) -{ - // Get the length. - size_t sequence_length = nproperties.length (); - - // Define multiple exceptions object. - CosPropertyService::MultipleExceptions multi_ex; - - for (size_t pi = 0; pi < sequence_length; pi++) - { - ACE_TRY - { - // Define this property. - this->define_property (nproperties [pi].property_name.in (), - nproperties [pi].property_value, - ACE_TRY_ENV); - ACE_TRY_CHECK; - } - ACE_CATCH (CosPropertyService::InvalidPropertyName, ex) - { - size_t len = multi_ex.exceptions.length (); - multi_ex.exceptions.length (len + 1); - multi_ex.exceptions[len].reason = - CosPropertyService::invalid_property_name; - multi_ex.exceptions[len].failing_property_name = - nproperties[pi].property_name; - } - ACE_CATCH (CosPropertyService::ConflictingProperty, ex) - { - size_t len = multi_ex.exceptions.length (); - multi_ex.exceptions.length (len + 1); - multi_ex.exceptions[len].reason = - CosPropertyService::conflicting_property; - multi_ex.exceptions[len].failing_property_name = - nproperties[pi].property_name; - } - ACE_CATCH (CosPropertyService::ReadOnlyProperty, ex) - { - size_t len = multi_ex.exceptions.length (); - multi_ex.exceptions.length (len + 1); - multi_ex.exceptions[len].reason = - CosPropertyService::read_only_property; - multi_ex.exceptions[len].failing_property_name = - nproperties[pi].property_name; - } - ACE_CATCH (CosPropertyService::UnsupportedTypeCode, ex) - { - size_t len = multi_ex.exceptions.length (); - multi_ex.exceptions.length (len + 1); - multi_ex.exceptions[len].reason = - CosPropertyService::unsupported_type_code; - multi_ex.exceptions[len].failing_property_name = - nproperties[pi].property_name; - } - ACE_CATCH (CosPropertyService::UnsupportedProperty, ex) - { - size_t len = multi_ex.exceptions.length (); - multi_ex.exceptions.length (len + 1); - multi_ex.exceptions[len].reason = - CosPropertyService::unsupported_property; - multi_ex.exceptions[len].failing_property_name = - nproperties[pi].property_name; - } - ACE_CATCH (CORBA::SystemException, sysex) - { - ACE_RETHROW; - } - ACE_ENDTRY; - ACE_CHECK; - } - - // Raise the multi exception if needed. - if (multi_ex.exceptions.length () > 0) - ACE_THROW (CosPropertyService::MultipleExceptions (multi_ex)); -} - -// Returns the current number of properties associated with this -// PropertySet. - - -CORBA::ULong -TAO_PropertySet::get_number_of_properties (CORBA::Environment &) -{ - return this->hash_table_.current_size (); -} - -// Returns all of the property names currently defined in the -// PropertySet. If the PropertySet contains more than <how_many> -// property names, then the remaining property names are put into the -// PropertyNamesIterator. - - -void -TAO_PropertySet::get_all_property_names (CORBA::ULong how_many, - CosPropertyService::PropertyNames_out property_names, - CosPropertyService::PropertyNamesIterator_out rest, - CORBA::Environment &ACE_TRY_ENV) -{ - // Allocating storage is a must. - ACE_NEW (property_names, - CosPropertyService::PropertyNames); - - size_t num_of_properties = - this->get_number_of_properties (ACE_TRY_ENV); - ACE_CHECK; - - if (num_of_properties == 0) - // Nothing to do. - return; - - // Set the length of the property_names appropriately. - CORBA::ULong sequence_length = 0; - - if (how_many > 0) - { - if (how_many >= num_of_properties) - sequence_length = num_of_properties; - else - sequence_length = how_many; - property_names->length (sequence_length); - } - - // Iterate thru names and put them in the property_names. - - COSPROPERTY_HASH_ENTRY *entry_ptr; - COSPROPERTY_HASH_ITERATOR iterator (this->hash_table_); - - for (size_t ni = 0; - ni < sequence_length; - ni++, iterator.advance ()) - if (iterator.next (entry_ptr) != 0) - property_names [ni] = - CORBA::string_dup (entry_ptr->ext_id_.pname_); - - // If there are some more properties, put them in the - // iterator. How?? Make a new PropertySet and use that to create - // propertyNames Iterator. - - if (num_of_properties > how_many) - { - TAO_PropertySet *property_set; - - ACE_NEW (property_set, TAO_PropertySet); - - for (size_t i = how_many; - i < num_of_properties; - i++, iterator.advance ()) - if (iterator.next (entry_ptr) != 0) - if (property_set->hash_table_.bind (entry_ptr->ext_id_, - entry_ptr->int_id_) < 0) - ACE_DEBUG ((LM_DEBUG, - "Error:TAO_PropertySet::get_all_property_names\n")); - - // Make the NamesIterator out of this TAO_PropertySet. - TAO_PropertyNamesIterator *names_iterator; - ACE_NEW (names_iterator, TAO_PropertyNamesIterator (*property_set)); - - // Init the out parameter. - - // Get the Interface ptr. - CosPropertyService::PropertyNamesIterator_ptr iterator_ptr = - names_iterator->_this (ACE_TRY_ENV); - ACE_CHECK; - - // POA stuff todo here, since we have <destroy> method in the - // <NamesIterator> interface. - // Give ownership of this servant to the POA. - names_iterator->_remove_ref (ACE_TRY_ENV); - ACE_CHECK; - - // Init the out parameter. - rest = iterator_ptr; - } -} - -// Returns the value of a property in the PropertySet. - - -CORBA::Any * -TAO_PropertySet::get_property_value (const char *property_name, - CORBA::Environment &ACE_TRY_ENV) -{ - // Check the name's validity. - if (property_name == 0) - ACE_THROW_RETURN (CosPropertyService::InvalidPropertyName(), - 0); - - // Get the value out of the hash table. - - CosProperty_Hash_Key hash_key (property_name); - CosProperty_Hash_Value hash_value; - - if (this->hash_table_.find (hash_key, hash_value) != 0) - ACE_THROW_RETURN (CosPropertyService::PropertyNotFound(), - 0); - - // Return the any value got. - CORBA::Any *any_ptr =0; - ACE_NEW_RETURN (any_ptr, - CORBA::Any (hash_value.pvalue_), - 0); - return any_ptr; -} - -// Returns the values of the properties listed in property_names. When -// the boolean return value is true, the Properties parameter contains -// valid values for all requested property names. If false, then all -// properties with a value of type tk_void may have failed due to -// <PropertyNotFound> or <InvalidPropertyName>. - - -CORBA::Boolean -TAO_PropertySet::get_properties (const CosPropertyService::PropertyNames &property_names, - CosPropertyService::Properties_out nproperties, - CORBA::Environment &ACE_TRY_ENV) -{ - // Allocate memory for the out parameter. - ACE_NEW_RETURN (nproperties, - CosPropertyService::Properties, - 0); - - // Validate the length. - size_t n = property_names.length (); - if (n == 0) - return 0; - - // Set the length for the out parameter. - nproperties->length (n); - - // Get values for all the names. - - CORBA::Any_ptr any_ptr = 0; - CORBA::Boolean ret_val = 1; - - for (size_t i = 0; i < n; i++) - { - ACE_TRY_ENV.clear (); - any_ptr = get_property_value (property_names [i], - ACE_TRY_ENV); - ACE_CHECK_RETURN (0); - - if (any_ptr != 0) - { - // Property is found. - nproperties [i].property_name = property_names [i]; - nproperties [i].property_value = *any_ptr; - } - else - { - // Invalid name. Ret value is False. - ret_val = 0; - - // Assign void type to this name in the out parameter. - nproperties [i].property_name = - property_names [i]; - - // Make an any value with tk_void type. - // @@ Using replace method, <<= operator does not exist yet - // for this. - nproperties [i].property_value.replace (CORBA::_tc_void, - 0, - 0, - ACE_TRY_ENV); - ACE_CHECK_RETURN (0); - } - } - - return ret_val; -} - - -void -TAO_PropertySet::get_all_properties (CORBA::ULong how_many, - CosPropertyService::Properties_out nproperties, - CosPropertyService::PropertiesIterator_out rest, - CORBA::Environment &ACE_TRY_ENV) -{ - // Allocate memory for the out parameter. - ACE_NEW (nproperties, - CosPropertyService::Properties); - - // Validate the length. - size_t num_of_properties = - hash_table_.current_size (); - - if (num_of_properties == 0) - return; - - // Set the length for the nproperties if how_many > 0. - CORBA::ULong sequence_length = 0; - - if (how_many > 0) - { - if (how_many >= num_of_properties) - sequence_length = num_of_properties; - else - sequence_length = how_many; - - nproperties->length (sequence_length); - } - - // Prepare an iterator and iterate through the PropertySet. Retrive - // the values. - - COSPROPERTY_HASH_ITERATOR iterator (this->hash_table_); - COSPROPERTY_HASH_ENTRY *entry_ptr = 0; - - for (CORBA::ULong i = 0; - i < sequence_length; - i++, iterator.advance ()) - if (iterator.next (entry_ptr) != 0) + if (this->iterator_.next (entry_ptr) != 0) { - nproperties[i].property_name = - CORBA::string_dup (entry_ptr->ext_id_.pname_); - nproperties[i].property_value = - entry_ptr->int_id_.pvalue_; + nproperties [ni].property_name = entry_ptr->ext_id_.pname_; + nproperties [ni].property_value = + entry_ptr->int_id_.pvalue_.in (); } - - // If there are more properties, put them in the <PropertiesIterator>. - // Make a new <TAO_PropertySet> and use that to create an Properties - // iterator. put that in a iterator and assign that to the out - // paramerter. - - if (num_of_properties > how_many) - { - TAO_PropertySet *prop_set; - - ACE_NEW (prop_set, TAO_PropertySet); - - for (size_t i = sequence_length; - i < num_of_properties; - i++, iterator.advance ()) - { - if (iterator.next (entry_ptr) != 0 - && prop_set->hash_table_.bind (entry_ptr->ext_id_, - entry_ptr->int_id_) < 0) - ACE_DEBUG ((LM_DEBUG, - "Error:TAO_PropertySet::get_all_properties\n")); - } - - // Make the iterator out of the new TAO_Propset. - TAO_PropertiesIterator *iterator = 0; - ACE_NEW (iterator, - TAO_PropertiesIterator (*prop_set)); - - // Init the out parameter. - - // Get the interface ptr. - CosPropertyService::PropertiesIterator_ptr iterator_ptr = - iterator->_this (ACE_TRY_ENV); - ACE_CHECK; - - // POA stuff todo here, since we have <destroy> method in the - // <NamesIterator> interface. - // Give ownership of this servant to the POA. - iterator->_remove_ref (ACE_TRY_ENV); - ACE_CHECK; - - // Init the out parameter. - rest = iterator_ptr; - } -} - -// Deletes the specified property if it exists from a PropertySet. - - -void -TAO_PropertySet::delete_property (const char *property_name, - CORBA::Environment &ACE_TRY_ENV) -{ - // Check the name's validity. - if (property_name == 0) - ACE_THROW (CosPropertyService::InvalidPropertyName()); - - // Get the entry from the Hash Table. - - CosProperty_Hash_Key hash_key (property_name); - COSPROPERTY_HASH_ENTRY *entry_ptr = 0; - - if (this->hash_table_.find (hash_key, - entry_ptr) == -1) - ACE_THROW (CosPropertyService::PropertyNotFound()); - - // If property is fixed, then raise exception. - if ((entry_ptr->int_id_.pmode_ == CosPropertyService::fixed_normal) - || (entry_ptr->int_id_.pmode_ == CosPropertyService::fixed_readonly)) - ACE_THROW (CosPropertyService::FixedProperty()); - - // Unbind this property. - if (this->hash_table_.unbind (entry_ptr) != 0) - { - ACE_ERROR ((LM_ERROR, - "Unbind failed\n")); - TAO_THROW (CORBA::UNKNOWN ()); - } - - return; -} - -// Deletes the properties defined in the property_names -// parameter. This is a batch operation that returns the -// MultipleExceptions exception if any delete failed. - - -void -TAO_PropertySet::delete_properties (const CosPropertyService::PropertyNames &property_names, - CORBA::Environment &ACE_TRY_ENV) -{ - // Get the length. - size_t sequence_length = property_names.length (); - - // Declare multiple exceptions' object. - CosPropertyService::MultipleExceptions *multi_ex = 0; - ACE_NEW (multi_ex, - CosPropertyService::MultipleExceptions); - - for (size_t pi = 0; pi < sequence_length; pi++) - { - ACE_TRY - { - // Delete this property. - this->delete_property (property_names[pi], - ACE_TRY_ENV); - ACE_TRY_CHECK; - } - ACE_CATCH (CosPropertyService::InvalidPropertyName, ex) - { - // Put this exception in the multiple exception. - size_t len = multi_ex->exceptions.length (); - multi_ex->exceptions.length (len + 1); - multi_ex->exceptions[len].reason = - CosPropertyService::invalid_property_name; - multi_ex->exceptions[len].failing_property_name = - property_names[pi]; - } - ACE_CATCH (CosPropertyService::PropertyNotFound, ex) - { - // Put this exception in the multiple exception. - size_t len = multi_ex->exceptions.length (); - multi_ex->exceptions.length (len + 1); - multi_ex->exceptions[len].reason = - CosPropertyService::property_not_found; - multi_ex->exceptions[len].failing_property_name = - property_names[pi]; - } - ACE_CATCH (CosPropertyService::FixedProperty, ex) - { - // Put this exception in the multiple exception. - size_t len = multi_ex->exceptions.length (); - multi_ex->exceptions.length (len + 1); - multi_ex->exceptions[len].reason = - CosPropertyService::fixed_property; - multi_ex->exceptions[len].failing_property_name = - property_names[pi]; - } - ACE_CATCH (CORBA::SystemException, sysex) - { - // We cant afford to get this. Throw this. - ACE_RETHROW; - } - ACE_ENDTRY; - ACE_CHECK; - } - - // Raise the multiple exceptions if there are any. - if (multi_ex->exceptions.length () > 0) - ACE_THROW (CosPropertyService::MultipleExceptions (*multi_ex)); -} - -// Delete all the properties in the current ProperySet : Delete the -// properties one by one. - - -CORBA::Boolean -TAO_PropertySet::delete_all_properties (CORBA::Environment &ACE_TRY_ENV) -{ - // Get all the property names in a names' sequence. - CosPropertyService::PropertyNames_ptr names_ptr = 0; - CosPropertyService::PropertyNames_out names_out (names_ptr); - CosPropertyService::PropertyNames_var names; - - CosPropertyService::PropertyNamesIterator_ptr iter_ptr = 0; - CosPropertyService::PropertyNamesIterator_out iter_out (iter_ptr); - CosPropertyService::PropertyNamesIterator_var iter; - - CORBA::ULong size = this->get_number_of_properties (ACE_TRY_ENV); - ACE_CHECK_RETURN (0); - - this->get_all_property_names (size, - names_out, - iter_out, - ACE_TRY_ENV); - ACE_CHECK_RETURN (0); - - // Get the out values on to the var varibles. - names = names_out.ptr (); - iter = iter_out.ptr (); - - // Delete all these properties. - this->delete_properties (names.in (), - ACE_TRY_ENV); - ACE_CHECK_RETURN (0); - - // All properties deleted. + else + break; return 1; } -// Returns TRUE if the property is defined in the PropertySet. - - -CORBA::Boolean -TAO_PropertySet::is_property_defined (const char *property_name, - CORBA::Environment &) -{ - CosProperty_Hash_Key hash_key (property_name); - - if (this->hash_table_.find (hash_key) == 0) - return 1; - else - return 0; -} - - void -TAO_PropertySet::operator= (const TAO_PropertySet &) +TAO_PropertiesIterator::destroy (CORBA::Environment &) { - // Empty. } - #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) template class ACE_Hash_Map_Entry<CosProperty_Hash_Key, CosProperty_Hash_Value>; template class ACE_Hash<CosProperty_Hash_Key>; @@ -1817,7 +1107,9 @@ template class ACE_Hash_Map_Iterator_Ex<CosProperty_Hash_Key, CosProperty_Hash_V template class ACE_Hash_Map_Iterator_Base_Ex<CosProperty_Hash_Key, CosProperty_Hash_Value, ACE_Hash<CosProperty_Hash_Key>, ACE_Equal_To<CosProperty_Hash_Key>, ACE_Null_Mutex>; template class ACE_Hash_Map_Reverse_Iterator<CosProperty_Hash_Key, CosProperty_Hash_Value, ACE_Null_Mutex>; template class ACE_Hash_Map_Reverse_Iterator_Ex<CosProperty_Hash_Key, CosProperty_Hash_Value, ACE_Hash<CosProperty_Hash_Key>, ACE_Equal_To<CosProperty_Hash_Key>, ACE_Null_Mutex>; -template class TAO_Unbounded_Sequence<TAO_PropertySet*>; +template class TAO_PropertySet<POA_CosPropertyService::PropertySet>; +template class TAO_PropertySet<POA_CosPropertyService::PropertySetDef>; +template class TAO_Unbounded_Sequence<TAO_PropertySet<POA_CosPropertyService::PropertySet>*>; template class TAO_Unbounded_Sequence<TAO_PropertySetDef*>; #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA) #pragma instantiate ACE_Hash_Map_Entry<CosProperty_Hash_Key, CosProperty_Hash_Value> @@ -1830,6 +1122,8 @@ template class TAO_Unbounded_Sequence<TAO_PropertySetDef*>; #pragma instantiate ACE_Hash_Map_Iterator_Base_Ex<CosProperty_Hash_Key, CosProperty_Hash_Value, ACE_Hash<CosProperty_Hash_Key>, ACE_Equal_To<CosProperty_Hash_Key>, ACE_Null_Mutex> #pragma instantiate ACE_Hash_Map_Reverse_Iterator<CosProperty_Hash_Key, CosProperty_Hash_Value, ACE_Null_Mutex> #pragma instantiate ACE_Hash_Map_Reverse_Iterator_Ex<CosProperty_Hash_Key, CosProperty_Hash_Value, ACE_Hash<CosProperty_Hash_Key>, ACE_Equal_To<CosProperty_Hash_Key>, ACE_Null_Mutex> -#pragma instantiate TAO_Unbounded_Sequence<TAO_PropertySet*> +#pragma instantiate TAO_PropertySet<POA_CosPropertyService::PropertySet> +#pragma instantiate TAO_PropertySet<POA_CosPropertyService::PropertySetDef> +#pragma instantiate TAO_Unbounded_Sequence<TAO_PropertySet<POA_CosPropertyService::PropertySet>*> #pragma instantiate TAO_Unbounded_Sequence<TAO_PropertySetDef*> #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */ |