TAO_Service_Type_Repository Class Reference

This class implements CosTradingRepos::ServiceTypeRepository IDL interface. More...

#include <Service_Type_Repository.h>

Collaboration diagram for TAO_Service_Type_Repository:

[legend]List of all members.

Public Member Functions
	TAO_Service_Type_Repository (ACE_Lock *lock=0)
	~TAO_Service_Type_Repository (void)
virtual CosTradingRepos::ServiceTypeRepository::IncarnationNumber	incarnation (void)
virtual CosTradingRepos::ServiceTypeRepository::IncarnationNumber	add_type (const char *name, const char *if_name, const CosTradingRepos::ServiceTypeRepository::PropStructSeq &props, const CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq &super_types)
virtual void	remove_type (const char *name)
virtual CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq *	list_types (const CosTradingRepos::ServiceTypeRepository::SpecifiedServiceTypes &which_types)
virtual CosTradingRepos::ServiceTypeRepository::TypeStruct *	describe_type (const char *name)
virtual CosTradingRepos::ServiceTypeRepository::TypeStruct *	fully_describe_type (const char *name)
virtual void	mask_type (const char *name)
virtual void	unmask_type (const char *name)
Private Types
typedef ACE_Hash_Map_Manager_Ex< CORBA::String_var, CosTradingRepos::ServiceTypeRepository::PropStruct *, ACE_Hash< CORBA::String_var >, ACE_Equal_To< CORBA::String_var >, ACE_Null_Mutex >	Prop_Map
typedef ACE_Hash_Map_Manager_Ex< CORBA::String_var, Type_Info *, ACE_Hash< CORBA::String_var >, ACE_Equal_To< CORBA::String_var >, ACE_Null_Mutex >	Service_Type_Map
typedef ACE_Hash_Map_Iterator_Ex< CORBA::String_var, Type_Info *, ACE_Hash< CORBA::String_var >, ACE_Equal_To< CORBA::String_var >, ACE_Null_Mutex >	Service_Type_Map_Iterator
Private Member Functions
void	fully_describe_type_i (const CosTradingRepos::ServiceTypeRepository::TypeStruct &type_struct, CosTradingRepos::ServiceTypeRepository::PropStructSeq &props, CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq &super_types)
void	collect_inheritance_hierarchy (const CosTradingRepos::ServiceTypeRepository::TypeStruct &type_struct, TAO_String_Queue &target)
void	validate_properties (Prop_Map &prop_map, const CosTradingRepos::ServiceTypeRepository::PropStructSeq &props)
void	validate_supertypes (Service_Type_Map &super_map, const CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq &super_types)
	Confirm that the each super type exists, and cram them into super_map.
void	validate_inheritance (Prop_Map &prop_map, const CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq &super_types)
void	update_type_map (const char *name, const char *if_name, const CosTradingRepos::ServiceTypeRepository::PropStructSeq &props, const CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq &super_types, Prop_Map &prop_map, Service_Type_Map &super_map)
	TAO_Service_Type_Repository (const TAO_Service_Type_Repository &)
TAO_Service_Type_Repository &	operator= (const TAO_Service_Type_Repository &)
Private Attributes
ACE_Lock *	lock_
	Lock with which to serialize access to the service type map.
Service_Type_Map	type_map_
CosTradingRepos::ServiceTypeRepository::IncarnationNumber	incarnation_
Classes
class	Type_Info
	Storage structure for information pertinent to the type. More...

---

Detailed Description

This class implements CosTradingRepos::ServiceTypeRepository IDL interface.

Definition at line 31 of file Service_Type_Repository.h.

---

Member Typedef Documentation

typedef ACE_Hash_Map_Manager_Ex<CORBA::String_var, CosTradingRepos::ServiceTypeRepository::PropStruct *, ACE_Hash<CORBA::String_var>, ACE_Equal_To<CORBA::String_var>, ACE_Null_Mutex> TAO_Service_Type_Repository::Prop_Map [private]

Definition at line 204 of file Service_Type_Repository.h.

typedef ACE_Hash_Map_Manager_Ex<CORBA::String_var, Type_Info *, ACE_Hash<CORBA::String_var>, ACE_Equal_To<CORBA::String_var>, ACE_Null_Mutex> TAO_Service_Type_Repository::Service_Type_Map [private]

Definition at line 211 of file Service_Type_Repository.h.

typedef ACE_Hash_Map_Iterator_Ex<CORBA::String_var, Type_Info *, ACE_Hash<CORBA::String_var>, ACE_Equal_To<CORBA::String_var>, ACE_Null_Mutex> TAO_Service_Type_Repository::Service_Type_Map_Iterator [private]

Definition at line 218 of file Service_Type_Repository.h.

---

Constructor & Destructor Documentation

TAO_BEGIN_VERSIONED_NAMESPACE_DECL TAO_Service_Type_Repository::TAO_Service_Type_Repository

(

ACE_Lock *

lock = 0

)

Parameterize the Service_Type_Repository with a lock to serialize access to the type repository map. A reader/writer lock is probably best. The Service_Type_Repository assumes control of the lock.

Definition at line 15 of file Service_Type_Repository.cpp.

References ACE_NEW.

  : lock_ (lock)
{
  this->incarnation_.low = 0;
  this->incarnation_.high = 0;

  // If a lock wasn't provided, let's assume the user doesn't want any
  // kind of lock at all.
  if (this->lock_ == 0)
    ACE_NEW (this->lock_,
             ACE_Lock_Adapter<ACE_Null_Mutex>);
}

TAO_Service_Type_Repository::~TAO_Service_Type_Repository

(

void

)

Definition at line 28 of file Service_Type_Repository.cpp.

References ACE_WRITE_GUARD, ACE_Hash_Map_Iterator_Base_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK >::done(), and lock_.

{
  {
    // Make sure not to throw exceptions in destructors...
    ACE_WRITE_GUARD (ACE_Lock, ace_mon, *this->lock_);

    for (Service_Type_Map_Iterator service_map_iterator (this->type_map_);
         service_map_iterator.done () == 0;
         service_map_iterator++)
      {
        Type_Info *type_info = (*service_map_iterator).int_id_;
        delete type_info;
      }
  }

  delete this->lock_;
}

TAO_Service_Type_Repository::TAO_Service_Type_Repository

(

const TAO_Service_Type_Repository &

)

[private]

---

Member Function Documentation

CosTradingRepos::ServiceTypeRepository::IncarnationNumber TAO_Service_Type_Repository::add_type	(	const char *	name,
		const char *	if_name,
		const CosTradingRepos::ServiceTypeRepository::PropStructSeq &	props,
		const CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq &	super_types
	)			[virtual]

BEGIN SPEC The add_type operation enables the creation of new service types in the service type repository. The caller supplies the "name" for the new type, the identifier for the interface associated with instances of this service type, the properties definitions for this service type, and the service type names of the immediate super-types to this service type.

Definition at line 68 of file Service_Type_Repository.cpp.

References ACE_WRITE_GUARD_THROW_EX, CosTradingRepos::ServiceTypeRepository::IncarnationNumber::high, incarnation_, TAO_Trader_Base::is_valid_identifier_name(), CosTradingRepos::ServiceTypeRepository::IncarnationNumber::low, update_type_map(), validate_inheritance(), validate_properties(), and validate_supertypes().

{
  Prop_Map prop_map;
  Service_Type_Map super_map;

  ACE_WRITE_GUARD_THROW_EX (ACE_Lock, ace_mon, *this->lock_, CORBA::INTERNAL ());

  // Make sure Type name is valid.
  if (TAO_Trader_Base::is_valid_identifier_name (name) == 0)
    throw CosTrading::IllegalServiceType (name);

  // Check if the service type already exists.
  CORBA::String_var type_name (name);
  if (this->type_map_.find (type_name) == 0)
    throw CosTradingRepos::ServiceTypeRepository::ServiceTypeExists ();

  // Make sure all property names are valid and appear only once.
  this->validate_properties (prop_map,
                             props);

  // Check that all super_types exist, and none are duplicated.
  this->validate_supertypes (super_map,
                             super_types);

  // NOTE: I don't really know a way to do this without an Interface
  // Repository, since the Interface Repository IDs don't contain
  // information about supertypes.
  //
  // make sure interface name is legal.
  //  this->validate_interface (if_name, super_types);
  //
  // Instead, we do this:
  //
  if (if_name == 0)
    throw CosTradingRepos::ServiceTypeRepository::InterfaceTypeMismatch ();

  // Collect and make sure that properties of all supertypes and this
  // type are compatible.  We can use prop_map and super_types_map for
  // the job.
  this->validate_inheritance (prop_map,
                              super_types);

  // We can now use prop_map to construct a sequence of all properties
  // the this type.
  this->update_type_map (name,
                         if_name,
                         props,
                         super_types,
                         prop_map,
                         super_map);

  CosTradingRepos::ServiceTypeRepository::IncarnationNumber return_value =
    this->incarnation_;

  // Increment incarnation number.
  this->incarnation_.low++;

  // If we wrapped around in lows...
  if (this->incarnation_.low == 0)
    this->incarnation_.high++;

  return return_value;
}

void TAO_Service_Type_Repository::collect_inheritance_hierarchy	(	const CosTradingRepos::ServiceTypeRepository::TypeStruct &	type_struct,
		TAO_String_Queue &	target
	)			[private]

Definition at line 412 of file Service_Type_Repository.cpp.

References ACE_Unbounded_Queue< T >::enqueue_tail(), and CosTradingRepos::ServiceTypeRepository::TypeStruct::super_types.

Referenced by fully_describe_type_i().

{
  // Recurse for each super_type
  for (int i = type_struct.super_types.length () - 1;
       i >= 0;
       i--)
    {
      Service_Type_Map::ENTRY *next_type_entry = 0;
      CORBA::String_var next_type_name (type_struct.super_types[i]);

      if (this->type_map_.find (next_type_name, next_type_entry) != -1)
        {
          CosTradingRepos::ServiceTypeRepository::TypeStruct &next_type_struct =
            next_type_entry->int_id_->type_struct_;

          const char *type_name =
            type_struct.super_types[i];
          target.enqueue_tail (const_cast<char *> (type_name));

          this->collect_inheritance_hierarchy (next_type_struct,
                                               target);
        }
    }
}

CosTradingRepos::ServiceTypeRepository::TypeStruct * TAO_Service_Type_Repository::describe_type

(

const char *

name

)

[virtual]

BEGIN SPEC The describe_type operation permits a client to obtain the details for a particular service type. If "name" is malformed, then the CosTrading::IllegalServiceType exception is raised. If "name" does not exist within the repository, then the CosTrading::UnknownServiceType exception is raised. END SPEC

Definition at line 204 of file Service_Type_Repository.cpp.

References ACE_NEW_RETURN, ACE_READ_GUARD_THROW_EX, CosTradingRepos::ServiceTypeRepository::TypeStruct::if_name, CosTradingRepos::ServiceTypeRepository::TypeStruct::incarnation, TAO_Trader_Base::is_valid_identifier_name(), CosTradingRepos::ServiceTypeRepository::TypeStruct::masked, CosTradingRepos::ServiceTypeRepository::TypeStruct::props, and CosTradingRepos::ServiceTypeRepository::TypeStruct::super_types.

{
  if (TAO_Trader_Base::is_valid_identifier_name (name) == 0)
    {
      throw CosTrading::IllegalServiceType (name);
    }

  ACE_READ_GUARD_THROW_EX
    (ACE_Lock,
     ace_mon,
     *this->lock_,
     CORBA::INTERNAL ());

  // Make sure the type exists.
  CORBA::String_var type_name (name);
  Service_Type_Map::ENTRY *type_entry = 0;
  if (this->type_map_.find (type_name,
                            type_entry) == -1)
    throw CosTrading::UnknownServiceType (name);

  // Return appropriate information about the type.
  CosTradingRepos::ServiceTypeRepository::TypeStruct *descr = 0;
  ACE_NEW_RETURN (descr,
                  CosTradingRepos::ServiceTypeRepository::TypeStruct,
                  0);
  CosTradingRepos::ServiceTypeRepository::TypeStruct &s =
    type_entry->int_id_->type_struct_;

  descr->if_name = s.if_name;
  descr->masked = s.masked;
  descr->incarnation = s.incarnation;
  descr->super_types = s.super_types;
  descr->props = s.props;
  /*
  CORBA::ULong length = s.props.length ();
  CosTradingRepos::ServiceTypeRepository::PropStruct* pstructs =
    s.props.get_buffer (0);
  descr->props.replace (length, length, pstructs, 0);
  */
  return descr;
}

CosTradingRepos::ServiceTypeRepository::TypeStruct * TAO_Service_Type_Repository::fully_describe_type

(

const char *

name

)

[virtual]

BEGIN SPEC The fully_describe_type operation permits a client to obtain the details for a particular service type. The property sequence returned in the TypeStruct includes all properties inherited from the transitive closure of its super types; the sequence of super types in the TypeStruct contains the names of the types in the transitive closure of the super type relation. If "name" is malformed, then the CosTrading::IllegalServiceType exception is raised. If "name" does not exist within the repository, then the CosTrading::UnknownServiceType exception is raised. END SPEC

Definition at line 248 of file Service_Type_Repository.cpp.

References ACE_NEW_RETURN, ACE_READ_GUARD_THROW_EX, fully_describe_type_i(), CosTradingRepos::ServiceTypeRepository::TypeStruct::if_name, CosTradingRepos::ServiceTypeRepository::TypeStruct::incarnation, TAO_Trader_Base::is_valid_identifier_name(), CosTradingRepos::ServiceTypeRepository::TypeStruct::masked, CosTradingRepos::ServiceTypeRepository::TypeStruct::props, and CosTradingRepos::ServiceTypeRepository::TypeStruct::super_types.

{
  if (TAO_Trader_Base::is_valid_identifier_name (name) == 0)
    throw CosTrading::IllegalServiceType (name);

  ACE_READ_GUARD_THROW_EX (ACE_Lock, ace_mon, *this->lock_, CORBA::INTERNAL ());

  // Make sure the type exists.
  CORBA::String_var type_name (name);
  Service_Type_Map::ENTRY *type_entry = 0;
  if (this->type_map_.find (type_name,
                            type_entry) == -1)
    throw CosTrading::UnknownServiceType (name);

  // Return appropriate information about the type.
  CosTradingRepos::ServiceTypeRepository::TypeStruct *descr = 0;
  ACE_NEW_RETURN (descr,
                  CosTradingRepos::ServiceTypeRepository::TypeStruct,
                  0);
  CosTradingRepos::ServiceTypeRepository::TypeStruct &s =
    type_entry->int_id_->type_struct_;

  // Aggregate the Properties of this type and all its supertypes.
  // Compute the transitive closure of all supertypes.
  this->fully_describe_type_i (s,
                               descr->props,
                               descr->super_types);

  // We do the explicit copy, since otherwise we'd have excessive
  // properties copying.
  descr->if_name = s.if_name;
  descr->masked = s.masked;
  descr->incarnation = s.incarnation;

  return descr;
}

void TAO_Service_Type_Repository::fully_describe_type_i	(	const CosTradingRepos::ServiceTypeRepository::TypeStruct &	type_struct,
		CosTradingRepos::ServiceTypeRepository::PropStructSeq &	props,
		CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq &	super_types
	)			[private]

Build a sequence aggregating the property names from all supertypes of the type, and a sequence representing the transitive closure of the super type relation.

Definition at line 337 of file Service_Type_Repository.cpp.

References collect_inheritance_hierarchy(), ACE_Hash_Map_Manager_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK >::find(), CosTradingRepos::ServiceTypeRepository::TypeStruct::props, ACE_Unbounded_Queue< T >::size(), and type_map_.

Referenced by fully_describe_type(), and validate_inheritance().

{
  TAO_String_Queue service_type_queue;
  this->collect_inheritance_hierarchy (type_struct,
                                       service_type_queue);

  // Count the total number of properties.
  CORBA::ULong num_props = 0;
  CORBA::ULong num_types = static_cast<CORBA::ULong> (service_type_queue.size ());

  TAO_String_Queue::ITERATOR iterator (service_type_queue);

  for (;
       iterator.done () == 0;
       iterator.advance ())
    {
      char **next_type_name = 0;
      Service_Type_Map::ENTRY *type_entry = 0;

      iterator.next (next_type_name);
      CORBA::String_var hash_key (const_cast<const char *> (*next_type_name));
      this->type_map_.find (hash_key,
                            type_entry);

      CosTradingRepos::ServiceTypeRepository::TypeStruct &tstruct =
        type_entry->int_id_->type_struct_;
      num_props += tstruct.props.length ();
    }

  num_props += type_struct.props.length ();
  props.length (num_props);
  super_types.length (num_types);

  // Copy in all properties.
  int i = 0;
  CORBA::ULong prop_index = 0;
  CORBA::ULong type_index = 0;

  for (i = type_struct.props.length () - 1;
       i >= 0;
       i--)
    props[prop_index++] = type_struct.props[i];

  for (iterator.first ();
       iterator.done () == 0;
       iterator.advance ())
    {
      char **next_type_name = 0;
      Service_Type_Map::ENTRY *type_entry = 0;

      iterator.next (next_type_name);
      CORBA::String_var hash_key (const_cast<const char *> (*next_type_name));
      this->type_map_.find (hash_key,
                            type_entry);

      // Should never be zero.
      if (type_entry != 0)
        {
          CosTradingRepos::ServiceTypeRepository::TypeStruct& tstruct =
            type_entry->int_id_->type_struct_;

          for (i = tstruct.props.length () - 1;
               i >= 0;
               i--)
            props[prop_index++] = tstruct.props[i];

          super_types[type_index++] = hash_key.in ();
        }
    }
}

CosTradingRepos::ServiceTypeRepository::IncarnationNumber TAO_Service_Type_Repository::incarnation

(

void

)

[virtual]

Definition at line 47 of file Service_Type_Repository.cpp.

References CosTradingRepos::ServiceTypeRepository::IncarnationNumber::high, and CosTradingRepos::ServiceTypeRepository::IncarnationNumber::low.

{
  CosTradingRepos::ServiceTypeRepository::IncarnationNumber inc_num;

  if (this->lock_->acquire_read () == -1)
    {
      inc_num = this->incarnation_;
      this->lock_->release ();
    }
  else
    {
      inc_num.high = 0;
      inc_num.low = 0;
    }

  return inc_num;
}

CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq * TAO_Service_Type_Repository::list_types

(

const CosTradingRepos::ServiceTypeRepository::SpecifiedServiceTypes &

which_types

)

[virtual]

Definition at line 161 of file Service_Type_Repository.cpp.

References ACE_NEW_RETURN, ACE_READ_GUARD_THROW_EX, CosTradingRepos::ServiceTypeRepository::all, ACE_Hash_Map_Manager_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK >::current_size(), ACE_Hash_Map_Iterator_Base_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK >::done(), CosTradingRepos::ServiceTypeRepository::SpecifiedServiceTypes::incarnation, CORBA::string_dup(), and type_map_.

{
  ACE_READ_GUARD_THROW_EX (ACE_Lock, ace_mon, *this->lock_, CORBA::INTERNAL ());

  CORBA::ULong i = 0;
  CORBA::ULong length = static_cast<CORBA::ULong> (this->type_map_.current_size ());
  CosTrading::ServiceTypeName *types =
    CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq::allocbuf (length);

  if (types == 0)
    return 0;

  int all = which_types._d () == CosTradingRepos::ServiceTypeRepository::all;

  CosTradingRepos::ServiceTypeRepository::IncarnationNumber num =
    which_types.incarnation ();

  for (Service_Type_Map_Iterator itr (this->type_map_);
       itr.done () == 0;
       itr++)
    {
      Type_Info* type_info = (*itr).int_id_;
      const char* type_name = (*itr).ext_id_.in ();

      if (all
          || num < type_info->type_struct_.incarnation)
        types[i++] = CORBA::string_dup (type_name);
    }

  CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq *tmp = 0;

  ACE_NEW_RETURN (tmp,
                  CosTradingRepos::ServiceTypeRepository::
                  ServiceTypeNameSeq (length,
                                      i,
                                      types,
                                      1),
                  0);
  return tmp;
}

void TAO_Service_Type_Repository::mask_type

(

const char *

name

)

[virtual]

BEGIN SPEC The mask_type operation permits the deprecation of a particular type (i.e., after being masked, exporters will no longer be able to advertise offers of that particular type). The type continues to exist in the service repository due to other service types being derived from it. If "name" is malformed, then the CosTrading::IllegalServiceType exception is raised. If "name" does not exist within the repository, then the CosTrading::UnknownServiceType exception is raised. If the type is currently in the masked state, then the AlreadyMasked exception is raised. END SPEC

Definition at line 287 of file Service_Type_Repository.cpp.

References ACE_WRITE_GUARD_THROW_EX, and TAO_Trader_Base::is_valid_identifier_name().

{
  if (TAO_Trader_Base::is_valid_identifier_name (name) == 0)
    throw CosTrading::IllegalServiceType (name);

  ACE_WRITE_GUARD_THROW_EX (ACE_Lock, ace_mon, *this->lock_, CORBA::INTERNAL ());

  // Make sure the type exists.
  CORBA::String_var type_name (name);
  Service_Type_Map::ENTRY *type_entry = 0;
  if (this->type_map_.find (type_name,
                            type_entry) != -1)
    throw CosTrading::UnknownServiceType (name);

  // Make sure the type is unmasked.
  CORBA::Boolean &mask =
    type_entry->int_id_->type_struct_.masked;

  if (mask == 1)
    throw CosTradingRepos::ServiceTypeRepository::AlreadyMasked (name);
  else
    mask = 1;
}

TAO_Service_Type_Repository& TAO_Service_Type_Repository::operator=

(

const TAO_Service_Type_Repository &

)

[private]

void TAO_Service_Type_Repository::remove_type

(

const char *

name

)

[virtual]

BEGIN SPEC The remove_type operation removes the named type from the service type repository. If "name" is malformed, then the CosTrading::IllegalServiceType exception is raised. If "name" does not exist within the repository, then the CosTrading::UnknownServiceType exception is raised. If "name" has a service type which has been derived from it, then the HasSubTypes exception is raised. END SPEC

Definition at line 136 of file Service_Type_Repository.cpp.

References ACE_WRITE_GUARD_THROW_EX, TAO_Service_Type_Repository::Type_Info::has_subtypes_, TAO_Trader_Base::is_valid_identifier_name(), type_map_, and ACE_Hash_Map_Manager_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK >::unbind().

{
  if (TAO_Trader_Base::is_valid_identifier_name (name) == 0)
    throw CosTrading::IllegalServiceType (name);

  ACE_WRITE_GUARD_THROW_EX (ACE_Lock, ace_mon, *this->lock_, CORBA::INTERNAL ());

  // Check if the type exists.
  Service_Type_Map::ENTRY* type_entry = 0; ;
  if (this->type_map_.find (name,
                            type_entry) == -1)
    throw CosTrading::UnknownServiceType (name);

  // Check if it has any subtypes.
  Type_Info *type_info = type_entry->int_id_;
  if (type_info->has_subtypes_)
    throw CosTradingRepos::ServiceTypeRepository::HasSubTypes (name, "");

  // Remove the type from the map.
  this->type_map_.unbind (type_entry);
  delete type_info;
}

void TAO_Service_Type_Repository::unmask_type

(

const char *

name

)

[virtual]

BEGIN SPEC The unmask_type undeprecates a type (i.e., after being unmasked, exporters will be able to resume advertisement of offers of that particular type). If "name" is malformed, then the CosTrading::IllegalServiceType exception is raised. If "name" does not exist within the repository, then the CosTrading::UnknownServiceType exception is raised. If the type is not currently in the masked state, then the NotMasked exception is raised. END SPEC

Definition at line 312 of file Service_Type_Repository.cpp.

References ACE_WRITE_GUARD_THROW_EX, and TAO_Trader_Base::is_valid_identifier_name().

{
  if (TAO_Trader_Base::is_valid_identifier_name (name) == 0)
    throw CosTrading::IllegalServiceType (name);

  ACE_WRITE_GUARD_THROW_EX (ACE_Lock, ace_mon, *this->lock_, CORBA::INTERNAL ());

  // Make sure the type exists.
  CORBA::String_var type_name (name);
  Service_Type_Map::ENTRY *type_entry = 0;
  if (this->type_map_.find (type_name,
                            type_entry) != -1)
    throw CosTrading::UnknownServiceType (name);

  // Make sure the type is masked.
  CORBA::Boolean &mask = type_entry->int_id_->type_struct_.masked;

  if (mask == 0)
    throw CosTradingRepos::ServiceTypeRepository::NotMasked (name);
  else
    mask = 0;
}

void TAO_Service_Type_Repository::update_type_map	(	const char *	name,
		const char *	if_name,
		const CosTradingRepos::ServiceTypeRepository::PropStructSeq &	props,
		const CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq &	super_types,
		Prop_Map &	prop_map,
		Service_Type_Map &	super_map
	)			[private]

Update the type map with the information contained in the TypeStruct, prop_map, and super_map.

Definition at line 571 of file Service_Type_Repository.cpp.

References ACE_NEW, ACE_Hash_Map_Manager_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK >::bind(), TAO_Service_Type_Repository::Type_Info::has_subtypes_, CosTradingRepos::ServiceTypeRepository::TypeStruct::if_name, CosTradingRepos::ServiceTypeRepository::TypeStruct::incarnation, incarnation_, CosTradingRepos::ServiceTypeRepository::TypeStruct::masked, CosTradingRepos::ServiceTypeRepository::TypeStruct::props, CosTradingRepos::ServiceTypeRepository::TypeStruct::super_types, type_map_, and TAO_Service_Type_Repository::Type_Info::type_struct_.

Referenced by add_type().

{
  // Update entries for all supertypes to include this type as a
  // subtype.  we can use the super_types_map we have constructed.

  for (Service_Type_Map_Iterator super_map_iterator (super_map);
       super_map_iterator.done () == 0;
       super_map_iterator++)
    {
      Type_Info *super_type_info =
        (*super_map_iterator).int_id_;
      super_type_info->has_subtypes_ = 0;
    }

  // All parameters are valid, create an entry for this service type
  // in the this->type_map_.
  Type_Info *type = 0;
  ACE_NEW (type,
           Type_Info);

  type->type_struct_.props = props;
  type->type_struct_.if_name = if_name;
  type->type_struct_.super_types = super_types;
  type->type_struct_.incarnation = this->incarnation_;
  type->type_struct_.masked = 0;
  type->has_subtypes_ = 0;

  // Move the prop struct sequences and super type names from the in
  // params to the internal storage.
  /*
  CORBA::ULong pslength = props.length ();
  CosTradingRepos::ServiceTypeRepository::PropStructSeq* pstructs =
    const_cast<CosTradingRepos::ServiceTypeRepository::PropStructSeq*> (&props);
  CosTradingRepos::ServiceTypeRepository::PropStruct* psbuf =
    pstructs->get_buffer (1);
  type->type_struct_.props.replace (pslength,
                                    pslength,
                                    psbuf,
                                    1);
  */
  CORBA::String_var type_name (name);
  this->type_map_.bind (type_name, type);
}

void TAO_Service_Type_Repository::validate_inheritance	(	Prop_Map &	prop_map,
		const CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq &	super_types
	)			[private]

Ensure that properties of a super_type aren't having their types or retstrictions redefined.

Definition at line 498 of file Service_Type_Repository.cpp.

References ACE_Hash_Map_Manager_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK >::bind(), ACE_Hash_Map_Manager_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK >::find(), fully_describe_type_i(), and type_map_.

Referenced by add_type().

{
  CORBA::ULong num_super_types = super_types.length ();

  for (CORBA::ULong i = 0;
       i < num_super_types;
       i++)
    {
      Service_Type_Map::ENTRY *super_type_entry = 0;
      CORBA::String_var super_type (super_types[i]);
      CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq place_holder;
      CosTradingRepos::ServiceTypeRepository::PropStructSeq super_props;

      this->type_map_.find (super_type, super_type_entry);

      // Super_type_entry should never be zero.
      if (super_type_entry != 0)
        this->fully_describe_type_i (super_type_entry->int_id_->type_struct_,
                                     super_props,
                                     place_holder);
      else
        continue;

      CORBA::ULong num_props = super_props.length ();

      for (CORBA::ULong j = 0;
           j < num_props;
           j++)
        {
          Prop_Map::ENTRY *existing_prop = 0;
          CORBA::String_var prop_name (super_props[j].name);

          if (prop_map.bind (prop_name,
                             &super_props[j],
                             existing_prop) == 1)
            {
              // If already there, check that it is compatible with
              // properties of other types. Value Types have to be the
              // same.
              const CosTradingRepos::ServiceTypeRepository::PropStruct &property_in_map =
                *existing_prop->int_id_;

              CORBA::TypeCode_ptr prop_type = property_in_map.value_type.in ();
              int compare = 0;
              try
                {
                  compare =
                    super_props[j].value_type->equal (prop_type);
                }
              catch (const CORBA::Exception&)
                {
                throw CosTradingRepos::ServiceTypeRepository::ValueTypeRedefinition(
                  super_props[j].name,
                  super_props[j],
                  property_in_map.name,
                  property_in_map);
                }

              if (compare == 0
                  || super_props[j].mode > property_in_map.mode)
                throw CosTradingRepos::ServiceTypeRepository::ValueTypeRedefinition(
                  super_props[j].name,
                  super_props[j],
                  property_in_map.name,
                  property_in_map);
            }
        }
    }
}

void TAO_Service_Type_Repository::validate_properties	(	Prop_Map &	prop_map,
		const CosTradingRepos::ServiceTypeRepository::PropStructSeq &	props
	)			[private]

Confirm that the properties in props have valid names, and aren't duplicated. Cram those properties into the prop_map.

Definition at line 440 of file Service_Type_Repository.cpp.

References ACE_Hash_Map_Manager_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK >::bind(), and TAO_Trader_Base::is_valid_property_name().

Referenced by add_type().

{
  for (CORBA::ULong i = 0;
       i < props.length ();
       i++)
    {
      const char *n = props[i].name;
      if (TAO_Trader_Base::is_valid_property_name (n) == 0)
        throw CosTrading::IllegalPropertyName (n);
      else
        {
          CORBA::String_var prop_name (n);
          CosTradingRepos::ServiceTypeRepository::PropStruct *prop_val =
            const_cast<CosTradingRepos::ServiceTypeRepository::PropStruct *> (&props[i]);

          if (prop_map.bind (prop_name,
                             prop_val) == 1)
            throw CosTrading::DuplicatePropertyName (n);
        }
    }
}

void TAO_Service_Type_Repository::validate_supertypes	(	Service_Type_Map &	super_map,
		const CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq &	super_types
	)			[private]

Confirm that the each super type exists, and cram them into super_map.

Definition at line 465 of file Service_Type_Repository.cpp.

References ACE_Hash_Map_Manager_Ex< EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK >::bind(), and TAO_Trader_Base::is_valid_identifier_name().

Referenced by add_type().

{
  for (CORBA::ULong i = 0;
       i < super_types.length ();
       i++)
    {
      const char *type =
        super_types[i];

      if (TAO_Trader_Base::is_valid_identifier_name (type) == 0)
        throw CosTrading::IllegalServiceType (type);
      else
        {
          CORBA::String_var hash_type (type);
          Service_Type_Map::ENTRY *type_entry = 0;

          if (this->type_map_.find (hash_type,
                                    type_entry) == -1)
            throw CosTrading::UnknownServiceType (type);
          else
            {
              if (super_map.bind (hash_type,
                                  type_entry->int_id_) == 1)
                throw CosTradingRepos::ServiceTypeRepository::DuplicateServiceTypeName (
                  type);
            }
        }
    }
}

---

Member Data Documentation

CosTradingRepos::ServiceTypeRepository::IncarnationNumber TAO_Service_Type_Repository::incarnation_ [private]

Incarnation number to be used for the next modification to the repository.

Definition at line 270 of file Service_Type_Repository.h.

Referenced by add_type(), and update_type_map().

ACE_Lock* TAO_Service_Type_Repository::lock_ [private]

Lock with which to serialize access to the service type map.

Definition at line 259 of file Service_Type_Repository.h.

Referenced by ~TAO_Service_Type_Repository().

Service_Type_Map TAO_Service_Type_Repository::type_map_ [private]

Stores information for each service type in the repository. This is a mapping from service type name to a Type_Info struct which serves as a storage for various information for the given type.

Definition at line 266 of file Service_Type_Repository.h.

Referenced by fully_describe_type_i(), list_types(), remove_type(), update_type_map(), and validate_inheritance().

---

The documentation for this class was generated from the following files:

• Service_Type_Repository.h
• Service_Type_Repository.cpp

---