service_type_exporter.cpp

这是广泛使用的通信开源项目,对于大容量,高并发的通讯要求完全能够胜任,他广泛可用于网络游戏医学图像网关的高qos要求.更详细的内容可阅读相应的材料

// Service_Type_Exporter.cpp,v 1.28 2002/10/25 00:40:19 bala Exp

#include "Service_Type_Exporter.h"

ACE_RCSID(Trading, Service_Type_Exporter, "Service_Type_Exporter.cpp,v 1.28 2002/10/25 00:40:19 bala Exp")

TAO_Service_Type_Exporter::
TAO_Service_Type_Exporter (CosTrading::Lookup_ptr lookup_if,
                           CORBA::Boolean verbose
                           ACE_ENV_ARG_DECL)
    ACE_THROW_SPEC ((CORBA::SystemException))
  : verbose_ (verbose),
    lookup_ (lookup_if)
{
  // Obtain the Service Type Repository.
  CosTrading::TypeRepository_var obj = lookup_if->type_repos (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  // Narrow the Service Type Repository.
  this->repos_ = CosTradingRepos::ServiceTypeRepository::_narrow (obj.in ()
                                                                  ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  // Build the service type descriptions.
  this->create_types ();
}

void
TAO_Service_Type_Exporter::remove_all_types (ACE_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException,
                   CosTrading::IllegalServiceType,
                   CosTrading::UnknownServiceType,
                   CosTradingRepos::ServiceTypeRepository::HasSubTypes))
{
  ACE_DEBUG ((LM_DEBUG, "*** TAO_Service_Type_Exporter::removing all"
              " types from the Repository.\n"));

  for (int i = NUM_TYPES - 1; i >= 0; i--)
    {
      ACE_TRY
        {
          this->repos_->remove_type (TT_Info::INTERFACE_NAMES[i] ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
      ACE_CATCH (CosTrading::UnknownServiceType, excp)
        {
          if (this->verbose_)
            {
              if (excp.type.in () != 0)
                ACE_DEBUG ((LM_DEBUG, "Service type not yet registered: %s\n", excp.type.in ()));
            }

        }
      ACE_CATCHANY
        {
          ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
                               "TAO_Service_Type_Exporter::remove_all_types");
        }
      ACE_ENDTRY;
      ACE_CHECK;
    }
}

void
TAO_Service_Type_Exporter::add_all_types (ACE_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException,
                   CosTrading::IllegalServiceType,
                   CosTradingRepos::ServiceTypeRepository::ServiceTypeExists,
                   CosTradingRepos::ServiceTypeRepository::InterfaceTypeMismatch,
                   CosTrading::IllegalPropertyName,
                   CosTrading::DuplicatePropertyName,
                   CosTradingRepos::ServiceTypeRepository::ValueTypeRedefinition,
                   CosTrading::UnknownServiceType,
                   CosTradingRepos::ServiceTypeRepository::DuplicateServiceTypeName))

{
  ACE_DEBUG ((LM_DEBUG, "*** TAO_Service_Type_Exporter::"
              "adding all types to the Repository.\n"));
  this->add_all_types_to (this->repos_.ptr () ACE_ENV_ARG_PARAMETER);
  // ACE_CHECK;
}

void
TAO_Service_Type_Exporter::add_all_types_to_all (ACE_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException,
                   CosTrading::IllegalServiceType,
                   CosTradingRepos::ServiceTypeRepository::ServiceTypeExists,
                   CosTradingRepos::ServiceTypeRepository::InterfaceTypeMismatch,
                   CosTrading::IllegalPropertyName,
                   CosTrading::DuplicatePropertyName,
                   CosTradingRepos::ServiceTypeRepository::ValueTypeRedefinition,
                   CosTrading::UnknownServiceType,
                   CosTradingRepos::ServiceTypeRepository::DuplicateServiceTypeName))
{
  ACE_DEBUG ((LM_DEBUG, "*** TAO_Service_Type_Exporter::"
              "add all types to all repositories.\n"));

  ACE_DEBUG ((LM_DEBUG, "Obtaining link interface.\n"));
  CosTrading::Link_var link_if = this->lookup_->link_if (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  ACE_DEBUG ((LM_DEBUG, "Obtaining references to traders directly"
              " linked to the root trader.\n"));
  CosTrading::LinkNameSeq_var link_name_seq = link_if->list_links (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  ACE_DEBUG ((LM_DEBUG, "Exporting service types with each of the linked"
              " traders.\n"));
  for (CORBA::ULong i = link_name_seq->length () - 1; i > 0; i--)
    {
      CosTradingRepos::ServiceTypeRepository_ptr str = 0;
      ACE_TRY
        {
          ACE_DEBUG ((LM_DEBUG, "Getting link information for %s\n",
                      ACE_static_cast (const char*, link_name_seq[i])));
          CosTrading::Link::LinkInfo_var link_info =
            link_if->describe_link (link_name_seq[i] ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;

          ACE_DEBUG ((LM_DEBUG, "Adding service types to %s\n",
                      ACE_static_cast (const char*, link_name_seq[i])));

          CosTrading::TypeRepository_var remote_repos =
            link_info->target->type_repos (ACE_ENV_SINGLE_ARG_PARAMETER);
          ACE_TRY_CHECK;

          str =
            CosTradingRepos::ServiceTypeRepository::_narrow (remote_repos.in ()
                                                             ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;

        }
      ACE_CATCHANY
        {
          // @@ Seth, Ignore all these exceptions?
        }
      ACE_ENDTRY;
      ACE_CHECK;

      // @@ Seth, But this one?
      this->add_all_types_to (str ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
}

void
TAO_Service_Type_Exporter::
add_all_types_to (CosTradingRepos::ServiceTypeRepository_ptr repos
                  ACE_ENV_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException,
                   CosTrading::IllegalServiceType,
                   CosTradingRepos::ServiceTypeRepository::ServiceTypeExists,
                   CosTradingRepos::ServiceTypeRepository::InterfaceTypeMismatch,
                   CosTrading::IllegalPropertyName,
                   CosTrading::DuplicatePropertyName,
                   CosTradingRepos::ServiceTypeRepository::ValueTypeRedefinition,
                   CosTrading::UnknownServiceType,
                   CosTradingRepos::ServiceTypeRepository::DuplicateServiceTypeName))
{
  for (int i = 0; i < NUM_TYPES; i++)
    {
      ACE_TRY
        {
          repos->add_type (TT_Info::INTERFACE_NAMES[i],
                           this->type_structs_[i].if_name,
                           this->type_structs_[i].props,
                           this->type_structs_[i].super_types
                           ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
      ACE_CATCH (CosTradingRepos::ServiceTypeRepository::ServiceTypeExists, ste)
        {
          ACE_PRINT_EXCEPTION (ste, "TAO_Service_Type_Exporter::add_all_types");

          if (ste.name.in () != 0)
            ACE_DEBUG ((LM_DEBUG, "Invalid name: %s\n", ste.name.in ()));
        }
      ACE_CATCH (CosTrading::IllegalPropertyName, excp)
        {
          ACE_PRINT_EXCEPTION (excp, "TAO_Service_Type_Exporter::add_all_types");

          if (excp.name.in () != 0)
            ACE_DEBUG ((LM_DEBUG, "Invalid name: %s\n", excp.name.in ()));
        }
      ACE_CATCH (CosTradingRepos::ServiceTypeRepository::ValueTypeRedefinition, vtr)
        {
          ACE_PRINT_EXCEPTION (vtr, "TAO_Service_Type_Exporter::add_all_types");

          if (vtr.type_1.in () != 0)
            ACE_DEBUG ((LM_DEBUG, "Type One: %s\n", vtr.type_2.in ()));
          if (vtr.type_2.in () != 0)
            ACE_DEBUG ((LM_DEBUG, "Type Two: %s\n", vtr.type_2.in ()));
        }
      ACE_CATCHANY
        {
          ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
                               "TAO_Service_Type_Exporter::add_all_types");
          ACE_RE_THROW;
        }
      ACE_ENDTRY;
      ACE_CHECK;
    }
}

void
TAO_Service_Type_Exporter::list_all_types (ACE_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  ACE_TRY
    {
      CosTradingRepos::ServiceTypeRepository::SpecifiedServiceTypes sst;
      ACE_DEBUG ((LM_DEBUG, "*** TAO_Service_Type_Exporter::"
                  "listing all types in the Repository.\n"));

      sst.all_ (1);
      CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq_var type_names =
        this->repos_->list_types (sst ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;

      CORBA::ULong l = type_names->length ();
      for (CORBA::ULong i = 0; i != l; ++i)
        {
          CORBA::ULong index = l - 1 - i;
          if (this->verbose_)
            {
              ACE_DEBUG ((LM_DEBUG, "type name: %s\n",
                          ACE_static_cast (const char *,
                                           type_names[index])));
            }
        }
    }
  ACE_CATCHANY
    {
      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
                           "TAO_Service_Type_Exporter::list_all_types");
      ACE_RE_THROW;
    }
  ACE_ENDTRY;
  // ACE_CHECK;
}

void
TAO_Service_Type_Exporter::describe_all_types (ACE_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((CORBA::SystemException,
                   CosTrading::IllegalServiceType,
                   CosTrading::UnknownServiceType))
{
  ACE_TRY
    {
      ACE_DEBUG ((LM_DEBUG, "*** TAO_Service_Type_Exporter::"
                  "describing all types in the Repository.\n"));

      for (int i = 0; i < NUM_TYPES; i++)
        {
          CosTradingRepos::ServiceTypeRepository::TypeStruct_var type_struct =
            this->repos_->describe_type (TT_Info::INTERFACE_NAMES[i]
                                         ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;

          if (this->verbose_)