// -*- C++ -*-
//
// $Id$

// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
// TAO and the TAO IDL Compiler have been developed by:
//       Center for Distributed Object Computing
//       Washington University
//       St. Louis, MO
//       USA
//       http://www.cs.wustl.edu/~schmidt/doc-center.html
// and
//       Distributed Object Computing Laboratory
//       University of California at Irvine
//       Irvine, CA
//       USA
//       http://doc.ece.uci.edu/
// and
//       Institute for Software Integrated Systems
//       Vanderbilt University
//       Nashville, TN
//       USA
//       http://www.isis.vanderbilt.edu/
//
// Information about TAO is available at:
//     http://www.cs.wustl.edu/~schmidt/TAO.html


// TAO_IDL - Generated from 
// be/be_codegen.cpp:611

#ifndef _TAO_IDL_COSTRADINGREPOSS_CPP_
#define _TAO_IDL_COSTRADINGREPOSS_CPP_


#include "CosTradingReposS.h"
#include "tao/PortableServer/Object_Adapter.h"
#include "tao/PortableServer/Operation_Table.h"
#include "tao/TAO_Server_Request.h"
#include "tao/ORB_Core.h"
#include "tao/Profile.h"
#include "tao/Stub.h"
#include "tao/IFR_Client_Adapter.h"
#include "tao/Object_T.h"
#include "tao/Typecode.h"
#include "tao/DynamicC.h"
#include "tao/CDR.h"
#include "tao/Basic_Arguments.h"
#include "tao/Fixed_Size_Argument_T.h"
#include "tao/Object_Argument_T.h"
#include "tao/Special_Basic_Arguments.h"
#include "tao/UB_String_Arguments.h"
#include "tao/Var_Size_Argument_T.h"
#include "tao/PortableInterceptor.h"
#if TAO_HAS_INTERCEPTORS == 1
#include "tao/PortableServer/PICurrent_Guard.h"
#include "tao/PortableServer/ServerRequestInfo.h"
#include "tao/PortableServer/ServerInterceptorAdapter.h"
#include "tao/RequestInfo_Util.h"
#endif  /* TAO_HAS_INTERCEPTORS == 1 */

#include "ace/Dynamic_Service.h"
#include "ace/Malloc_Allocator.h"
#include "ace/config-all.h"

#if defined (__BORLANDC__)
#pragma option -w-rvl -w-rch -w-ccc -w-aus
#endif /* __BORLANDC__ */

#if !defined (__ACE_INLINE__)
#include "CosTradingReposS.inl"
#endif /* !defined __ACE_INLINE__ */

// TAO_IDL - Generated from
// be/be_visitor_arg_traits.cpp:64

// Arg traits specializations.
namespace TAO
{

#if !defined (_COSTRADING_LOOKUP__ARG_TRAITS_SS_)
#define _COSTRADING_LOOKUP__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Trading_Export Arg_Traits<CosTrading::Lookup>
    : public
        Object_Arg_Traits_T<
            CosTrading::Lookup_ptr,
            CosTrading::Lookup_var,
            CosTrading::Lookup_out,
            TAO::Objref_Traits<CosTrading::Lookup>
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:710

#if !defined (_COSTRADING_LOOKUP_SPECIFIEDPROPS__ARG_TRAITS_SS_)
#define _COSTRADING_LOOKUP_SPECIFIEDPROPS__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Trading_Export Arg_Traits<CosTrading::Lookup::SpecifiedProps>
    : public
        Var_Size_Arg_Traits_T<
            CosTrading::Lookup::SpecifiedProps,
            CosTrading::Lookup::SpecifiedProps_var,
            CosTrading::Lookup::SpecifiedProps_out
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:379

#if !defined (_COSTRADING_PROPERTYNAMESEQ__ARG_TRAITS_SS_)
#define _COSTRADING_PROPERTYNAMESEQ__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Trading_Export Arg_Traits<CosTrading::PropertyNameSeq>
    : public
        Var_Size_Arg_Traits_T<
            CosTrading::PropertyNameSeq,
            CosTrading::PropertyNameSeq_var,
            CosTrading::PropertyNameSeq_out
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:379

#if !defined (_COSTRADING_ADMIN_OCTETSEQ__ARG_TRAITS_SS_)
#define _COSTRADING_ADMIN_OCTETSEQ__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Trading_Export Arg_Traits<CosTrading::Admin::OctetSeq>
    : public
        Var_Size_Arg_Traits_T<
            CosTrading::Admin::OctetSeq,
            CosTrading::Admin::OctetSeq_var,
            CosTrading::Admin::OctetSeq_out
          >
  {
  };

#endif /* end #if !defined */

#if !defined (_COSTRADING_OFFERITERATOR__ARG_TRAITS_SS_)
#define _COSTRADING_OFFERITERATOR__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Trading_Export Arg_Traits<CosTrading::OfferIterator>
    : public
        Object_Arg_Traits_T<
            CosTrading::OfferIterator_ptr,
            CosTrading::OfferIterator_var,
            CosTrading::OfferIterator_out,
            TAO::Objref_Traits<CosTrading::OfferIterator>
          >
  {
  };

#endif /* end #if !defined */

#if !defined (_COSTRADING_OFFERIDITERATOR__ARG_TRAITS_SS_)
#define _COSTRADING_OFFERIDITERATOR__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Trading_Export Arg_Traits<CosTrading::OfferIdIterator>
    : public
        Object_Arg_Traits_T<
            CosTrading::OfferIdIterator_ptr,
            CosTrading::OfferIdIterator_var,
            CosTrading::OfferIdIterator_out,
            TAO::Objref_Traits<CosTrading::OfferIdIterator>
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:379

#if !defined (_COSTRADING_PROPERTYSEQ__ARG_TRAITS_SS_)
#define _COSTRADING_PROPERTYSEQ__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Trading_Export Arg_Traits<CosTrading::PropertySeq>
    : public
        Var_Size_Arg_Traits_T<
            CosTrading::PropertySeq,
            CosTrading::PropertySeq_var,
            CosTrading::PropertySeq_out
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:379

#if !defined (_COSTRADING_OFFERSEQ__ARG_TRAITS_SS_)
#define _COSTRADING_OFFERSEQ__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Trading_Export Arg_Traits<CosTrading::OfferSeq>
    : public
        Var_Size_Arg_Traits_T<
            CosTrading::OfferSeq,
            CosTrading::OfferSeq_var,
            CosTrading::OfferSeq_out
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:379

#if !defined (_COSTRADING_OFFERIDSEQ__ARG_TRAITS_SS_)
#define _COSTRADING_OFFERIDSEQ__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Trading_Export Arg_Traits<CosTrading::OfferIdSeq>
    : public
        Var_Size_Arg_Traits_T<
            CosTrading::OfferIdSeq,
            CosTrading::OfferIdSeq_var,
            CosTrading::OfferIdSeq_out
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:537

#if !defined (_COSTRADING_FOLLOWOPTION__ARG_TRAITS_SS_)
#define _COSTRADING_FOLLOWOPTION__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Trading_Export Arg_Traits<CosTrading::FollowOption>
    : public
        Basic_Arg_Traits_T<
            CosTrading::FollowOption
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:379

#if !defined (_COSTRADING_LINKNAMESEQ__ARG_TRAITS_SS_)
#define _COSTRADING_LINKNAMESEQ__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Trading_Export Arg_Traits<CosTrading::LinkNameSeq>
    : public
        Var_Size_Arg_Traits_T<
            CosTrading::LinkNameSeq,
            CosTrading::LinkNameSeq_var,
            CosTrading::LinkNameSeq_out
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:379

#if !defined (_COSTRADING_POLICYNAMESEQ__ARG_TRAITS_SS_)
#define _COSTRADING_POLICYNAMESEQ__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Trading_Export Arg_Traits<CosTrading::PolicyNameSeq>
    : public
        Var_Size_Arg_Traits_T<
            CosTrading::PolicyNameSeq,
            CosTrading::PolicyNameSeq_var,
            CosTrading::PolicyNameSeq_out
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:379

#if !defined (_COSTRADING_POLICYSEQ__ARG_TRAITS_SS_)
#define _COSTRADING_POLICYSEQ__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Trading_Export Arg_Traits<CosTrading::PolicySeq>
    : public
        Var_Size_Arg_Traits_T<
            CosTrading::PolicySeq,
            CosTrading::PolicySeq_var,
            CosTrading::PolicySeq_out
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:379

#if !defined (_COSTRADINGREPOS_SERVICETYPEREPOSITORY_SERVICETYPENAMESEQ__ARG_TRAITS_SS_)
#define _COSTRADINGREPOS_SERVICETYPEREPOSITORY_SERVICETYPENAMESEQ__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Trading_Export Arg_Traits<CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq>
    : public
        Var_Size_Arg_Traits_T<
            CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq,
            CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq_var,
            CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq_out
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:379

#if !defined (_COSTRADINGREPOS_SERVICETYPEREPOSITORY_PROPSTRUCTSEQ__ARG_TRAITS_SS_)
#define _COSTRADINGREPOS_SERVICETYPEREPOSITORY_PROPSTRUCTSEQ__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Trading_Export Arg_Traits<CosTradingRepos::ServiceTypeRepository::PropStructSeq>
    : public
        Var_Size_Arg_Traits_T<
            CosTradingRepos::ServiceTypeRepository::PropStructSeq,
            CosTradingRepos::ServiceTypeRepository::PropStructSeq_var,
            CosTradingRepos::ServiceTypeRepository::PropStructSeq_out
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:618

#if !defined (_COSTRADINGREPOS_SERVICETYPEREPOSITORY_INCARNATIONNUMBER__ARG_TRAITS_SS_)
#define _COSTRADINGREPOS_SERVICETYPEREPOSITORY_INCARNATIONNUMBER__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Trading_Export Arg_Traits<CosTradingRepos::ServiceTypeRepository::IncarnationNumber>
    : public
        Fixed_Size_Arg_Traits_T<
            CosTradingRepos::ServiceTypeRepository::IncarnationNumber
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:618

#if !defined (_COSTRADINGREPOS_SERVICETYPEREPOSITORY_TYPESTRUCT__ARG_TRAITS_SS_)
#define _COSTRADINGREPOS_SERVICETYPEREPOSITORY_TYPESTRUCT__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Trading_Export Arg_Traits<CosTradingRepos::ServiceTypeRepository::TypeStruct>
    : public
        Var_Size_Arg_Traits_T<
            CosTradingRepos::ServiceTypeRepository::TypeStruct,
            CosTradingRepos::ServiceTypeRepository::TypeStruct_var,
            CosTradingRepos::ServiceTypeRepository::TypeStruct_out
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:710

#if !defined (_COSTRADINGREPOS_SERVICETYPEREPOSITORY_SPECIFIEDSERVICETYPES__ARG_TRAITS_SS_)
#define _COSTRADINGREPOS_SERVICETYPEREPOSITORY_SPECIFIEDSERVICETYPES__ARG_TRAITS_SS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Trading_Export Arg_Traits<CosTradingRepos::ServiceTypeRepository::SpecifiedServiceTypes>
    : public
        Fixed_Size_Arg_Traits_T<
            CosTradingRepos::ServiceTypeRepository::SpecifiedServiceTypes
          >
  {
  };

#endif /* end #if !defined */
}


// TAO_IDL - Generated from
// be/be_interface.cpp:1539

class TAO_CosTradingRepos_ServiceTypeRepository_Perfect_Hash_OpTable
  : public TAO_Perfect_Hash_OpTable
{
private:
  unsigned int hash (const char *str, unsigned int len);

public:
  const TAO_operation_db_entry * lookup (const char *str, unsigned int len);
};

/* C++ code produced by gperf version 2.8 (ACE version) */
/* Command-line: /work/a/ports/devel/ace+tao/work/ACE_wrappers/bin/gperf -m -M -J -c -C -D -E -T -f 0 -F 0,0,0 -a -o -t -p -K opname_ -L C++ -Z TAO_CosTradingRepos_ServiceTypeRepository_Perfect_Hash_OpTable -N lookup  */
unsigned int
TAO_CosTradingRepos_ServiceTypeRepository_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
{
  static const unsigned char asso_values[] =
    {
#if defined (ACE_MVS)
     24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
     24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
     24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
     24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
     24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
     24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
     24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
     24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
     24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
     24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
     24, 24, 24, 24, 24, 24, 24, 24, 24,  0,
     24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
     24, 24, 24, 24, 24, 24, 24, 24, 24,  0,
     24, 24,  5,  0,  0, 24, 24, 24, 24, 24,
     24, 24, 24, 24, 24, 24, 24,  5,  0,  5,
     24, 24, 24,  5, 24, 24, 24, 24, 24, 24,
     24, 24,  0, 10,  0, 24, 24, 24, 24, 24,
     24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
     24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
     24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
     24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
     24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
     24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
     24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
     24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
     24, 24, 24, 24, 24, 24,
#else
     24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
     24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
     24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
     24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
     24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
     24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
     24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
     24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
     24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
     24, 24, 24, 24, 24,  0, 24,  0, 24, 24,
      5,  0,  0, 24, 24, 24, 24, 24,  5,  0,
      5, 24, 24, 24,  5,  0, 10,  0, 24, 24,
     24, 24, 24, 24, 24, 24, 24, 24,
#endif /* ACE_MVS */
    };
  return len + asso_values[(int) str[len - 1]] + asso_values[(int) str[0]];
}

const class TAO_operation_db_entry *
TAO_CosTradingRepos_ServiceTypeRepository_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
{
  enum
    {
      TOTAL_KEYWORDS = 12,
      MIN_WORD_LENGTH = 5,
      MAX_WORD_LENGTH = 19,
      MIN_HASH_VALUE = 5,
      MAX_HASH_VALUE = 23,
      HASH_VALUE_RANGE = 19,
      DUPLICATES = 0,
      WORDLIST_SIZE = 17
    };

  static const class TAO_operation_db_entry  wordlist[] =
    {
      {"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},{"",0,0,0},
      {"_is_a", &POA_CosTradingRepos::ServiceTypeRepository::_is_a_skel, 0, 0},
      {"",0,0,0},{"",0,0,0},
      {"add_type", &POA_CosTradingRepos::ServiceTypeRepository::add_type_skel, &POA_CosTradingRepos::_TAO_ServiceTypeRepository_ThruPOA_Proxy_Impl::add_type, 0},
      {"mask_type", &POA_CosTradingRepos::ServiceTypeRepository::mask_type_skel, &POA_CosTradingRepos::_TAO_ServiceTypeRepository_ThruPOA_Proxy_Impl::mask_type, 0},
      {"_interface", &POA_CosTradingRepos::ServiceTypeRepository::_interface_skel, 0, 0},
      {"unmask_type", &POA_CosTradingRepos::ServiceTypeRepository::unmask_type_skel, &POA_CosTradingRepos::_TAO_ServiceTypeRepository_ThruPOA_Proxy_Impl::unmask_type, 0},
      {"",0,0,0},{"",0,0,0},{"",0,0,0},
      {"list_types", &POA_CosTradingRepos::ServiceTypeRepository::list_types_skel, &POA_CosTradingRepos::_TAO_ServiceTypeRepository_ThruPOA_Proxy_Impl::list_types, 0},
      {"remove_type", &POA_CosTradingRepos::ServiceTypeRepository::remove_type_skel, &POA_CosTradingRepos::_TAO_ServiceTypeRepository_ThruPOA_Proxy_Impl::remove_type, 0},
      {"",0,0,0},
      {"describe_type", &POA_CosTradingRepos::ServiceTypeRepository::describe_type_skel, &POA_CosTradingRepos::_TAO_ServiceTypeRepository_ThruPOA_Proxy_Impl::describe_type, 0},
      {"fully_describe_type", &POA_CosTradingRepos::ServiceTypeRepository::fully_describe_type_skel, &POA_CosTradingRepos::_TAO_ServiceTypeRepository_ThruPOA_Proxy_Impl::fully_describe_type, 0},
      {"_component", &POA_CosTradingRepos::ServiceTypeRepository::_component_skel, 0, 0},
      {"_get_incarnation", &POA_CosTradingRepos::ServiceTypeRepository::_get_incarnation_skel, &POA_CosTradingRepos::_TAO_ServiceTypeRepository_ThruPOA_Proxy_Impl::_get_incarnation, 0},
      {"",0,0,0},
      {"_non_existent", &POA_CosTradingRepos::ServiceTypeRepository::_non_existent_skel, 0, 0},
    };

  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
    {
      unsigned int key = hash (str, len);

      if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)
        {
          const char *s = wordlist[key].opname_;

          if (*str == *s && !strncmp (str + 1, s + 1, len - 1))
            return &wordlist[key];
        }
    }
  return 0;
}

static TAO_CosTradingRepos_ServiceTypeRepository_Perfect_Hash_OpTable tao_CosTradingRepos_ServiceTypeRepository_optable;

// TAO_IDL - Generated from
// be/be_visitor_interface/interceptors_ss.cpp:53

#if (TAO_HAS_INTERCEPTORS == 1)

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_incarnation_get : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_incarnation_get (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosTradingRepos::ServiceTypeRepository *tao_impl
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  void result (::CosTradingRepos::ServiceTypeRepository::IncarnationNumber result);

private:
  TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_incarnation_get (
      const TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_incarnation_get &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_incarnation_get &
    );
  
private:
  POA_CosTradingRepos::ServiceTypeRepository *_tao_impl;
  
  ::CosTradingRepos::ServiceTypeRepository::IncarnationNumber _result;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_incarnation_get::TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_incarnation_get (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosTradingRepos::ServiceTypeRepository *tao_impl
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_incarnation_get::arguments (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return parameter_list;
}

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_incarnation_get::exceptions (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return exception_list;
}

CORBA::Any * 
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_incarnation_get::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 0;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  CORBA::Any_var safe_result_any = result_any;
  
  (*result_any) <<= this->_result;
  
  return safe_result_any._retn ();
}

char *
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_incarnation_get::target_most_derived_interface (
    ACE_ENV_SINGLE_ARG_DECL_NOT_USED
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return
    CORBA::string_dup (this->_tao_impl->_interface_repository_id ());
}

CORBA::Boolean
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_incarnation_get::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

void 
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_incarnation_get::result (::CosTradingRepos::ServiceTypeRepository::IncarnationNumber result)
{
  // Update the result.
   this->_result = result;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_add_type : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_add_type (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosTradingRepos::ServiceTypeRepository *tao_impl,
      const char * name,
      const char * if_name,
      const ::CosTradingRepos::ServiceTypeRepository::PropStructSeq & props,
      const ::CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq & super_types
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  void result (::CosTradingRepos::ServiceTypeRepository::IncarnationNumber result);

private:
  TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_add_type (
      const TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_add_type &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_add_type &
    );
  
private:
  POA_CosTradingRepos::ServiceTypeRepository *_tao_impl;
  
  const char * name_;
  const char * if_name_;
  const ::CosTradingRepos::ServiceTypeRepository::PropStructSeq & props_;
  const ::CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq & super_types_;
  ::CosTradingRepos::ServiceTypeRepository::IncarnationNumber _result;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_add_type::TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_add_type (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosTradingRepos::ServiceTypeRepository *tao_impl,
    const char * name,
    const char * if_name,
    const ::CosTradingRepos::ServiceTypeRepository::PropStructSeq & props,
    const ::CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq & super_types
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    name_ (name),
    if_name_ (if_name),
    props_ (props),
    super_types_ (super_types)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_add_type::arguments (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
  parameter_list->length (4);
  CORBA::ULong len = 0;
  
  (*parameter_list)[len].argument <<= name_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<= if_name_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<=  this->props_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  (*parameter_list)[len].argument <<=  this->super_types_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_add_type::exceptions (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  Dynamic::ExceptionList_var safe_exception_list = exception_list;
    
  static CORBA::TypeCode_ptr _tao_CosTradingRepos_ServiceTypeRepository_add_type_exceptiondata[] = 
  {
    CosTrading::_tc_IllegalServiceType,
    CosTradingRepos::ServiceTypeRepository::_tc_ServiceTypeExists,
    CosTradingRepos::ServiceTypeRepository::_tc_InterfaceTypeMismatch,
    CosTrading::_tc_IllegalPropertyName,
    CosTrading::_tc_DuplicatePropertyName,
    CosTradingRepos::ServiceTypeRepository::_tc_ValueTypeRedefinition,
    CosTrading::_tc_UnknownServiceType,
    CosTradingRepos::ServiceTypeRepository::_tc_DuplicateServiceTypeName
  };
  
  exception_list->length (8);
  for (CORBA::ULong i = 0; i < 8; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_CosTradingRepos_ServiceTypeRepository_add_type_exceptiondata[i];
      TAO_Pseudo_Object_Manager<CORBA::TypeCode> tcp_object (&tcp, 1);
      (*exception_list)[i] = tcp_object;
    }

  return safe_exception_list._retn ();
}

CORBA::Any * 
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_add_type::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 0;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  CORBA::Any_var safe_result_any = result_any;
  
  (*result_any) <<= this->_result;
  
  return safe_result_any._retn ();
}

char *
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_add_type::target_most_derived_interface (
    ACE_ENV_SINGLE_ARG_DECL_NOT_USED
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return
    CORBA::string_dup (this->_tao_impl->_interface_repository_id ());
}

CORBA::Boolean
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_add_type::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

void 
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_add_type::result (::CosTradingRepos::ServiceTypeRepository::IncarnationNumber result)
{
  // Update the result.
   this->_result = result;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_remove_type : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_remove_type (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosTradingRepos::ServiceTypeRepository *tao_impl,
      const char * name
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
private:
  TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_remove_type (
      const TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_remove_type &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_remove_type &
    );
  
private:
  POA_CosTradingRepos::ServiceTypeRepository *_tao_impl;
  
  const char * name_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_remove_type::TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_remove_type (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosTradingRepos::ServiceTypeRepository *tao_impl,
    const char * name
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    name_ (name)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_remove_type::arguments (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
  parameter_list->length (1);
  CORBA::ULong len = 0;
  
  (*parameter_list)[len].argument <<= name_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_remove_type::exceptions (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  Dynamic::ExceptionList_var safe_exception_list = exception_list;
    
  static CORBA::TypeCode_ptr _tao_CosTradingRepos_ServiceTypeRepository_remove_type_exceptiondata[] = 
  {
    CosTrading::_tc_IllegalServiceType,
    CosTrading::_tc_UnknownServiceType,
    CosTradingRepos::ServiceTypeRepository::_tc_HasSubTypes
  };
  
  exception_list->length (3);
  for (CORBA::ULong i = 0; i < 3; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_CosTradingRepos_ServiceTypeRepository_remove_type_exceptiondata[i];
      TAO_Pseudo_Object_Manager<CORBA::TypeCode> tcp_object (&tcp, 1);
      (*exception_list)[i] = tcp_object;
    }

  return safe_exception_list._retn ();
}

CORBA::Any * 
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_remove_type::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 1;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

char *
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_remove_type::target_most_derived_interface (
    ACE_ENV_SINGLE_ARG_DECL_NOT_USED
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return
    CORBA::string_dup (this->_tao_impl->_interface_repository_id ());
}

CORBA::Boolean
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_remove_type::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_list_types : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_list_types (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosTradingRepos::ServiceTypeRepository *tao_impl,
      const ::CosTradingRepos::ServiceTypeRepository::SpecifiedServiceTypes & which_types
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  void result (::CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq * result);

private:
  TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_list_types (
      const TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_list_types &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_list_types &
    );
  
private:
  POA_CosTradingRepos::ServiceTypeRepository *_tao_impl;
  
  const ::CosTradingRepos::ServiceTypeRepository::SpecifiedServiceTypes & which_types_;
  ::CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq * _result;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_list_types::TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_list_types (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosTradingRepos::ServiceTypeRepository *tao_impl,
    const ::CosTradingRepos::ServiceTypeRepository::SpecifiedServiceTypes & which_types
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    which_types_ (which_types)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_list_types::arguments (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
  parameter_list->length (1);
  CORBA::ULong len = 0;
  
  (*parameter_list)[len].argument <<=  this->which_types_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_list_types::exceptions (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return exception_list;
}

CORBA::Any * 
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_list_types::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 0;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  CORBA::Any_var safe_result_any = result_any;
  
  (*result_any) <<= *this->_result;
  
  return safe_result_any._retn ();
}

char *
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_list_types::target_most_derived_interface (
    ACE_ENV_SINGLE_ARG_DECL_NOT_USED
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return
    CORBA::string_dup (this->_tao_impl->_interface_repository_id ());
}

CORBA::Boolean
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_list_types::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

void 
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_list_types::result (::CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq * result)
{
  // Update the result.
   this->_result = result;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_describe_type : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_describe_type (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosTradingRepos::ServiceTypeRepository *tao_impl,
      const char * name
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  void result (::CosTradingRepos::ServiceTypeRepository::TypeStruct * result);

private:
  TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_describe_type (
      const TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_describe_type &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_describe_type &
    );
  
private:
  POA_CosTradingRepos::ServiceTypeRepository *_tao_impl;
  
  const char * name_;
  ::CosTradingRepos::ServiceTypeRepository::TypeStruct * _result;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_describe_type::TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_describe_type (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosTradingRepos::ServiceTypeRepository *tao_impl,
    const char * name
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    name_ (name)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_describe_type::arguments (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
  parameter_list->length (1);
  CORBA::ULong len = 0;
  
  (*parameter_list)[len].argument <<= name_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_describe_type::exceptions (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  Dynamic::ExceptionList_var safe_exception_list = exception_list;
    
  static CORBA::TypeCode_ptr _tao_CosTradingRepos_ServiceTypeRepository_describe_type_exceptiondata[] = 
  {
    CosTrading::_tc_IllegalServiceType,
    CosTrading::_tc_UnknownServiceType
  };
  
  exception_list->length (2);
  for (CORBA::ULong i = 0; i < 2; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_CosTradingRepos_ServiceTypeRepository_describe_type_exceptiondata[i];
      TAO_Pseudo_Object_Manager<CORBA::TypeCode> tcp_object (&tcp, 1);
      (*exception_list)[i] = tcp_object;
    }

  return safe_exception_list._retn ();
}

CORBA::Any * 
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_describe_type::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 0;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  CORBA::Any_var safe_result_any = result_any;
  
  (*result_any) <<= *this->_result;
  
  return safe_result_any._retn ();
}

char *
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_describe_type::target_most_derived_interface (
    ACE_ENV_SINGLE_ARG_DECL_NOT_USED
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return
    CORBA::string_dup (this->_tao_impl->_interface_repository_id ());
}

CORBA::Boolean
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_describe_type::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

void 
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_describe_type::result (::CosTradingRepos::ServiceTypeRepository::TypeStruct * result)
{
  // Update the result.
   this->_result = result;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_fully_describe_type : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_fully_describe_type (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosTradingRepos::ServiceTypeRepository *tao_impl,
      const char * name
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  void result (::CosTradingRepos::ServiceTypeRepository::TypeStruct * result);

private:
  TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_fully_describe_type (
      const TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_fully_describe_type &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_fully_describe_type &
    );
  
private:
  POA_CosTradingRepos::ServiceTypeRepository *_tao_impl;
  
  const char * name_;
  ::CosTradingRepos::ServiceTypeRepository::TypeStruct * _result;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_fully_describe_type::TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_fully_describe_type (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosTradingRepos::ServiceTypeRepository *tao_impl,
    const char * name
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    name_ (name)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_fully_describe_type::arguments (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
  parameter_list->length (1);
  CORBA::ULong len = 0;
  
  (*parameter_list)[len].argument <<= name_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_fully_describe_type::exceptions (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  Dynamic::ExceptionList_var safe_exception_list = exception_list;
    
  static CORBA::TypeCode_ptr _tao_CosTradingRepos_ServiceTypeRepository_fully_describe_type_exceptiondata[] = 
  {
    CosTrading::_tc_IllegalServiceType,
    CosTrading::_tc_UnknownServiceType
  };
  
  exception_list->length (2);
  for (CORBA::ULong i = 0; i < 2; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_CosTradingRepos_ServiceTypeRepository_fully_describe_type_exceptiondata[i];
      TAO_Pseudo_Object_Manager<CORBA::TypeCode> tcp_object (&tcp, 1);
      (*exception_list)[i] = tcp_object;
    }

  return safe_exception_list._retn ();
}

CORBA::Any * 
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_fully_describe_type::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 0;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  CORBA::Any_var safe_result_any = result_any;
  
  (*result_any) <<= *this->_result;
  
  return safe_result_any._retn ();
}

char *
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_fully_describe_type::target_most_derived_interface (
    ACE_ENV_SINGLE_ARG_DECL_NOT_USED
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return
    CORBA::string_dup (this->_tao_impl->_interface_repository_id ());
}

CORBA::Boolean
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_fully_describe_type::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

void 
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_fully_describe_type::result (::CosTradingRepos::ServiceTypeRepository::TypeStruct * result)
{
  // Update the result.
   this->_result = result;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_mask_type : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_mask_type (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosTradingRepos::ServiceTypeRepository *tao_impl,
      const char * name
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
private:
  TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_mask_type (
      const TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_mask_type &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_mask_type &
    );
  
private:
  POA_CosTradingRepos::ServiceTypeRepository *_tao_impl;
  
  const char * name_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_mask_type::TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_mask_type (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosTradingRepos::ServiceTypeRepository *tao_impl,
    const char * name
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    name_ (name)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_mask_type::arguments (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
  parameter_list->length (1);
  CORBA::ULong len = 0;
  
  (*parameter_list)[len].argument <<= name_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_mask_type::exceptions (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  Dynamic::ExceptionList_var safe_exception_list = exception_list;
    
  static CORBA::TypeCode_ptr _tao_CosTradingRepos_ServiceTypeRepository_mask_type_exceptiondata[] = 
  {
    CosTrading::_tc_IllegalServiceType,
    CosTrading::_tc_UnknownServiceType,
    CosTradingRepos::ServiceTypeRepository::_tc_AlreadyMasked
  };
  
  exception_list->length (3);
  for (CORBA::ULong i = 0; i < 3; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_CosTradingRepos_ServiceTypeRepository_mask_type_exceptiondata[i];
      TAO_Pseudo_Object_Manager<CORBA::TypeCode> tcp_object (&tcp, 1);
      (*exception_list)[i] = tcp_object;
    }

  return safe_exception_list._retn ();
}

CORBA::Any * 
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_mask_type::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 1;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

char *
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_mask_type::target_most_derived_interface (
    ACE_ENV_SINGLE_ARG_DECL_NOT_USED
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return
    CORBA::string_dup (this->_tao_impl->_interface_repository_id ());
}

CORBA::Boolean
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_mask_type::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:74

class TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_unmask_type : public TAO_ServerRequestInfo
{
public:
  TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_unmask_type (
      TAO_ServerRequest &_tao_server_request,
      TAO_Object_Adapter::Servant_Upcall *tao_servant_upcall,
      POA_CosTradingRepos::ServiceTypeRepository *tao_impl,
      const char * name
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    );
  
  virtual Dynamic::ParameterList * arguments (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual Dynamic::ExceptionList * exceptions (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Any * result (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual char * target_most_derived_interface (
      ACE_ENV_SINGLE_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
  virtual CORBA::Boolean target_is_a (
      const char * id
      ACE_ENV_ARG_DECL_WITH_DEFAULTS
    )
    ACE_THROW_SPEC ((CORBA::SystemException));
  
private:
  TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_unmask_type (
      const TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_unmask_type &
    );
  
  void operator= (
      const TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_unmask_type &
    );
  
private:
  POA_CosTradingRepos::ServiceTypeRepository *_tao_impl;
  
  const char * name_;
};

// TAO_IDL - Generated from
// be/be_visitor_operation/interceptors_ss.cpp:438

TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_unmask_type::TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_unmask_type (
    TAO_ServerRequest &_tao_server_request,
    TAO_Object_Adapter::Servant_Upcall *_tao_servant_upcall,
    POA_CosTradingRepos::ServiceTypeRepository *tao_impl,
    const char * name
    ACE_ENV_ARG_DECL_NOT_USED
  )
  : TAO_ServerRequestInfo (_tao_server_request, _tao_servant_upcall),
    _tao_impl (tao_impl),
    name_ (name)
{}

Dynamic::ParameterList *
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_unmask_type::arguments (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the argument list on demand.
  Dynamic::ParameterList *parameter_list =
    TAO_RequestInfo_Util::make_parameter_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  Dynamic::ParameterList_var safe_parameter_list = parameter_list;
  parameter_list->length (1);
  CORBA::ULong len = 0;
  
  (*parameter_list)[len].argument <<= name_;
  (*parameter_list)[len].mode = CORBA::PARAM_IN;
  len++;
  
  return safe_parameter_list._retn ();
}

Dynamic::ExceptionList *
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_unmask_type::exceptions (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the exception list on demand.
  Dynamic::ExceptionList *exception_list =
    TAO_RequestInfo_Util::make_exception_list (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  Dynamic::ExceptionList_var safe_exception_list = exception_list;
    
  static CORBA::TypeCode_ptr _tao_CosTradingRepos_ServiceTypeRepository_unmask_type_exceptiondata[] = 
  {
    CosTrading::_tc_IllegalServiceType,
    CosTrading::_tc_UnknownServiceType,
    CosTradingRepos::ServiceTypeRepository::_tc_NotMasked
  };
  
  exception_list->length (3);
  for (CORBA::ULong i = 0; i < 3; ++i)
    {
      CORBA::TypeCode_ptr tcp = _tao_CosTradingRepos_ServiceTypeRepository_unmask_type_exceptiondata[i];
      TAO_Pseudo_Object_Manager<CORBA::TypeCode> tcp_object (&tcp, 1);
      (*exception_list)[i] = tcp_object;
    }

  return safe_exception_list._retn ();
}

CORBA::Any * 
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_unmask_type::result (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  // Generate the result on demand.
  CORBA::Boolean tk_void_any = 1;
  CORBA::Any *result_any =
    TAO_RequestInfo_Util::make_any (tk_void_any ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  return result_any;
}

char *
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_unmask_type::target_most_derived_interface (
    ACE_ENV_SINGLE_ARG_DECL_NOT_USED
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return
    CORBA::string_dup (this->_tao_impl->_interface_repository_id ());
}

CORBA::Boolean
TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_unmask_type::target_is_a (
    const char * id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  return this->_tao_impl->_is_a (id ACE_ENV_ARG_PARAMETER);
}

#endif /* TAO_HAS_INTERCEPTORS */

///////////////////////////////////////////////////////////////////////
//            Strategized Proxy Broker Implementation
//

// TAO_IDL - Generated from
// be/be_visitor_interface/strategized_proxy_broker_ss.cpp:40

// Factory function Implementation.
POA_CosTradingRepos::_TAO_ServiceTypeRepository_Strategized_Proxy_Broker *
POA_CosTradingRepos::_TAO_ServiceTypeRepository_Strategized_Proxy_Broker::the_TAO_ServiceTypeRepository_Strategized_Proxy_Broker (void)
{
  static POA_CosTradingRepos::_TAO_ServiceTypeRepository_Strategized_Proxy_Broker
  strategized_proxy_broker;
  
  return &strategized_proxy_broker;
}

POA_CosTradingRepos::_TAO_ServiceTypeRepository_Strategized_Proxy_Broker::_TAO_ServiceTypeRepository_Strategized_Proxy_Broker (void)
{
}

POA_CosTradingRepos::_TAO_ServiceTypeRepository_Strategized_Proxy_Broker::~_TAO_ServiceTypeRepository_Strategized_Proxy_Broker (void)
{
}

TAO::Collocation_Strategy
POA_CosTradingRepos::_TAO_ServiceTypeRepository_Strategized_Proxy_Broker::get_strategy (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::SystemException))
{
  TAO::Collocation_Strategy strategy =
    TAO_ORB_Core::collocation_strategy (obj ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (TAO::TAO_CS_REMOTE_STRATEGY);
  
  return strategy;
}

void
POA_CosTradingRepos::_TAO_ServiceTypeRepository_Strategized_Proxy_Broker::dispatch (
    CORBA::Object_ptr obj,
    CORBA::Object_out forward_obj,
    TAO::Argument ** args,
    int num_args,
    const char * op,
    size_t op_len,
    TAO::Collocation_Strategy strategy
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((CORBA::Exception))
{
  TAO_Object_Adapter::Servant_Upcall servant_upcall (
      obj->_stubobj ()->servant_orb_var ()->orb_core ()
    );
  
  TAO_Collocated_Skeleton collocated_skel;
  TAO_Abstract_ServantBase *servant = 0;
  
  if (strategy == TAO::TAO_CS_THRU_POA_STRATEGY)
    {
      servant_upcall.prepare_for_upcall (
          obj->_stubobj ()->object_key (),
          op,
          forward_obj
          ACE_ENV_ARG_PARAMETER
        );
      ACE_CHECK;
      
      servant_upcall.pre_invoke_collocated_request (
          ACE_ENV_SINGLE_ARG_PARAMETER
        );
      ACE_CHECK;
      
      servant = servant_upcall.servant ();
    }
  else
    {
      servant = obj->_servant ();
    }
  
  int status = servant->_find (op,
                               collocated_skel,
                               strategy,
                               op_len);
  
  if (status == -1)
    {
      ACE_THROW (CORBA::BAD_OPERATION ());
    }
  
  ACE_TRY
    {
      collocated_skel (servant,
                       args,
                       num_args
                       ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
#if (TAO_HAS_MINIMUM_CORBA == 0)
  ACE_CATCH (PortableServer::ForwardRequest, forward_request)
    {
      forward_obj =
        CORBA::Object::_duplicate (forward_request.forward_reference.in ());
      return;
    }
#else
  ACE_CATCHANY
    {
      ACE_UNUSED_ARG (forward_obj);
      ACE_RE_THROW;
    }
#endif /* TAO_HAS_MINIMUM_CORBA */
  ACE_ENDTRY;
  ACE_CHECK;
}

//
//        End Strategized Proxy Broker Implementation
///////////////////////////////////////////////////////////////////////

// TAO_IDL - Generated from
// be/be_visitor_interface/interface_ss.cpp:648

TAO::Collocation_Proxy_Broker *
CosTradingRepos__TAO_ServiceTypeRepository_Proxy_Broker_Factory_function (CORBA::Object_ptr)
{
  return
    ::POA_CosTradingRepos::_TAO_ServiceTypeRepository_Strategized_Proxy_Broker::the_TAO_ServiceTypeRepository_Strategized_Proxy_Broker ();
}

int
CosTradingRepos__TAO_ServiceTypeRepository_Proxy_Broker_Factory_Initializer (size_t)
{
  CosTradingRepos__TAO_ServiceTypeRepository_Proxy_Broker_Factory_function_pointer = 
    CosTradingRepos__TAO_ServiceTypeRepository_Proxy_Broker_Factory_function;
  
  return 0;
}

static int
CosTradingRepos__TAO_ServiceTypeRepository_Proxy_Broker_Stub_Factory_Initializer_Scarecrow =
  CosTradingRepos__TAO_ServiceTypeRepository_Proxy_Broker_Factory_Initializer (
      reinterpret_cast<
          size_t> (
          CosTradingRepos__TAO_ServiceTypeRepository_Proxy_Broker_Factory_Initializer
        )
    );


///////////////////////////////////////////////////////////////////////
//                 ThruPOA Proxy  Implementation
//

// TAO_IDL - Generated from
// be/be_visitor_interface/thru_poa_proxy_impl_ss.cpp:37

POA_CosTradingRepos::_TAO_ServiceTypeRepository_ThruPOA_Proxy_Impl::_TAO_ServiceTypeRepository_ThruPOA_Proxy_Impl (void)
{}

// ThruPOA Implementation of the IDL interface methods

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosTradingRepos::_TAO_ServiceTypeRepository_ThruPOA_Proxy_Impl::_get_incarnation (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  ((TAO::Arg_Traits< ::CosTradingRepos::ServiceTypeRepository::IncarnationNumber>::ret_val *) args[0])->arg () =
    reinterpret_cast<
        POA_CosTradingRepos::ServiceTypeRepository_ptr> (
        servant->_downcast (
            "IDL:omg.org/CosTradingRepos/ServiceTypeRepository:1.0"
          )
      )->incarnation (
          ACE_ENV_SINGLE_ARG_PARAMETER
        );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosTradingRepos::_TAO_ServiceTypeRepository_ThruPOA_Proxy_Impl::add_type (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    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
  ))
{
  ((TAO::Arg_Traits< ::CosTradingRepos::ServiceTypeRepository::IncarnationNumber>::ret_val *) args[0])->arg () =
    reinterpret_cast<
        POA_CosTradingRepos::ServiceTypeRepository_ptr> (
        servant->_downcast (
            "IDL:omg.org/CosTradingRepos/ServiceTypeRepository:1.0"
          )
      )->add_type (
          ((TAO::Arg_Traits< ::CosTrading::ServiceTypeName>::in_arg_val *) args[1])->arg (),
          ((TAO::Arg_Traits< ::CosTradingRepos::ServiceTypeRepository::Identifier>::in_arg_val *) args[2])->arg (),
          ((TAO::Arg_Traits< ::CosTradingRepos::ServiceTypeRepository::PropStructSeq>::in_arg_val *) args[3])->arg (),
          ((TAO::Arg_Traits< ::CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq>::in_arg_val *) args[4])->arg ()
          ACE_ENV_ARG_PARAMETER
        );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosTradingRepos::_TAO_ServiceTypeRepository_ThruPOA_Proxy_Impl::remove_type (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::CosTrading::IllegalServiceType,
    ::CosTrading::UnknownServiceType,
    ::CosTradingRepos::ServiceTypeRepository::HasSubTypes
  ))
{
  reinterpret_cast<
      POA_CosTradingRepos::ServiceTypeRepository_ptr> (
      servant->_downcast (
          "IDL:omg.org/CosTradingRepos/ServiceTypeRepository:1.0"
        )
    )->remove_type (
        ((TAO::Arg_Traits< ::CosTrading::ServiceTypeName>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosTradingRepos::_TAO_ServiceTypeRepository_ThruPOA_Proxy_Impl::list_types (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  ((TAO::Arg_Traits< ::CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq>::ret_val *) args[0])->arg () =
    reinterpret_cast<
        POA_CosTradingRepos::ServiceTypeRepository_ptr> (
        servant->_downcast (
            "IDL:omg.org/CosTradingRepos/ServiceTypeRepository:1.0"
          )
      )->list_types (
          ((TAO::Arg_Traits< ::CosTradingRepos::ServiceTypeRepository::SpecifiedServiceTypes>::in_arg_val *) args[1])->arg ()
          ACE_ENV_ARG_PARAMETER
        );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosTradingRepos::_TAO_ServiceTypeRepository_ThruPOA_Proxy_Impl::describe_type (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::CosTrading::IllegalServiceType,
    ::CosTrading::UnknownServiceType
  ))
{
  ((TAO::Arg_Traits< ::CosTradingRepos::ServiceTypeRepository::TypeStruct>::ret_val *) args[0])->arg () =
    reinterpret_cast<
        POA_CosTradingRepos::ServiceTypeRepository_ptr> (
        servant->_downcast (
            "IDL:omg.org/CosTradingRepos/ServiceTypeRepository:1.0"
          )
      )->describe_type (
          ((TAO::Arg_Traits< ::CosTrading::ServiceTypeName>::in_arg_val *) args[1])->arg ()
          ACE_ENV_ARG_PARAMETER
        );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosTradingRepos::_TAO_ServiceTypeRepository_ThruPOA_Proxy_Impl::fully_describe_type (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::CosTrading::IllegalServiceType,
    ::CosTrading::UnknownServiceType
  ))
{
  ((TAO::Arg_Traits< ::CosTradingRepos::ServiceTypeRepository::TypeStruct>::ret_val *) args[0])->arg () =
    reinterpret_cast<
        POA_CosTradingRepos::ServiceTypeRepository_ptr> (
        servant->_downcast (
            "IDL:omg.org/CosTradingRepos/ServiceTypeRepository:1.0"
          )
      )->fully_describe_type (
          ((TAO::Arg_Traits< ::CosTrading::ServiceTypeName>::in_arg_val *) args[1])->arg ()
          ACE_ENV_ARG_PARAMETER
        );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosTradingRepos::_TAO_ServiceTypeRepository_ThruPOA_Proxy_Impl::mask_type (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::CosTrading::IllegalServiceType,
    ::CosTrading::UnknownServiceType,
    ::CosTradingRepos::ServiceTypeRepository::AlreadyMasked
  ))
{
  reinterpret_cast<
      POA_CosTradingRepos::ServiceTypeRepository_ptr> (
      servant->_downcast (
          "IDL:omg.org/CosTradingRepos/ServiceTypeRepository:1.0"
        )
    )->mask_type (
        ((TAO::Arg_Traits< ::CosTrading::ServiceTypeName>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/thru_poa_proxy_impl_ss.cpp:52

void
POA_CosTradingRepos::_TAO_ServiceTypeRepository_ThruPOA_Proxy_Impl::unmask_type (
    TAO_Abstract_ServantBase *servant,
    TAO::Argument ** args,
    int 
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::CosTrading::IllegalServiceType,
    ::CosTrading::UnknownServiceType,
    ::CosTradingRepos::ServiceTypeRepository::NotMasked
  ))
{
  reinterpret_cast<
      POA_CosTradingRepos::ServiceTypeRepository_ptr> (
      servant->_downcast (
          "IDL:omg.org/CosTradingRepos/ServiceTypeRepository:1.0"
        )
    )->unmask_type (
        ((TAO::Arg_Traits< ::CosTrading::ServiceTypeName>::in_arg_val *) args[1])->arg ()
        ACE_ENV_ARG_PARAMETER
      );
  ACE_CHECK;
}

//
//           End ThruPOA Proxy Implementation
///////////////////////////////////////////////////////////////////////

// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_ss.cpp:97

POA_CosTradingRepos::ServiceTypeRepository::ServiceTypeRepository (void)
{
  this->optable_ = &tao_CosTradingRepos_ServiceTypeRepository_optable;
}

POA_CosTradingRepos::ServiceTypeRepository::ServiceTypeRepository (const ServiceTypeRepository& rhs)
  : TAO_Abstract_ServantBase (rhs),
    TAO_ServantBase (rhs)
{
}

POA_CosTradingRepos::ServiceTypeRepository::~ServiceTypeRepository (void)
{
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/operation_ss.cpp:98

void POA_CosTradingRepos::ServiceTypeRepository::_get_incarnation_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
  POA_CosTradingRepos::ServiceTypeRepository *_tao_impl =
    static_cast<
        POA_CosTradingRepos::ServiceTypeRepository *> (
        _tao_servant
      );
  ::CosTradingRepos::ServiceTypeRepository::IncarnationNumber _tao_retval;
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    static_cast<
        TAO_Object_Adapter::Servant_Upcall *> (
        _tao_servant_upcall
      );
    
  TAO_ServerRequestInterceptor_Adapter _tao_vfr (
      _tao_server_request.orb_core ()->server_request_interceptors (),
      _tao_server_request.interceptor_count ()
    );
  
  TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_incarnation_get _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            _tao_retval = 
              _tao_impl->incarnation (
                  ACE_ENV_SINGLE_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          ::CosTradingRepos::ServiceTypeRepository::IncarnationNumber _tao_retval_info = _tao_retval;
          _tao_ri.result (_tao_retval_info);
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
#if (TAO_HAS_INTERCEPTORS == 1)
  if (!_tao_vfr.location_forwarded ())
    {
#endif /* TAO_HAS_INTERCEPTORS */
      TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
      
      if (!(
          (_tao_out << _tao_retval)
          ))
        {
          TAO_OutputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
          ACE_CHECK;
        }
#if (TAO_HAS_INTERCEPTORS == 1)
    }
#endif /* TAO_HAS_INTERCEPTORS */
  
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/operation_ss.cpp:98

void POA_CosTradingRepos::ServiceTypeRepository::add_type_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
    TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
POA_CosTradingRepos::ServiceTypeRepository *_tao_impl =
    static_cast<
        POA_CosTradingRepos::ServiceTypeRepository *> (
        _tao_servant
      );
  ::CosTradingRepos::ServiceTypeRepository::IncarnationNumber _tao_retval;
  ::CORBA::String_var name;
  ::CORBA::String_var if_name;
  ::CosTradingRepos::ServiceTypeRepository::PropStructSeq props;
  ::CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq super_types;
  
  if (!(
      (_tao_in >> name.out ()) &&
      (_tao_in >> if_name.out ()) &&
      (_tao_in >> props) &&
      (_tao_in >> super_types)
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    static_cast<
        TAO_Object_Adapter::Servant_Upcall *> (
        _tao_servant_upcall
      );
    
  TAO_ServerRequestInterceptor_Adapter _tao_vfr (
      _tao_server_request.orb_core ()->server_request_interceptors (),
      _tao_server_request.interceptor_count ()
    );
  
  TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_add_type _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      name.in (),
      
      if_name.in (),
      
      props,
      
      super_types
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            _tao_retval = 
              _tao_impl->add_type (
                  name.in (),
                  
                  if_name.in (),
                  
                  props,
                  
                  super_types
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          ::CosTradingRepos::ServiceTypeRepository::IncarnationNumber _tao_retval_info = _tao_retval;
          _tao_ri.result (_tao_retval_info);
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
#if (TAO_HAS_INTERCEPTORS == 1)
  if (!_tao_vfr.location_forwarded ())
    {
#endif /* TAO_HAS_INTERCEPTORS */
      TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
      
      if (!(
          (_tao_out << _tao_retval)
          ))
        {
          TAO_OutputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
          ACE_CHECK;
        }
#if (TAO_HAS_INTERCEPTORS == 1)
    }
#endif /* TAO_HAS_INTERCEPTORS */
  
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/operation_ss.cpp:98

void POA_CosTradingRepos::ServiceTypeRepository::remove_type_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
    TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
POA_CosTradingRepos::ServiceTypeRepository *_tao_impl =
    static_cast<
        POA_CosTradingRepos::ServiceTypeRepository *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CORBA::String_var name;
  
  if (!(
      (_tao_in >> name.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    static_cast<
        TAO_Object_Adapter::Servant_Upcall *> (
        _tao_servant_upcall
      );
    
  TAO_ServerRequestInterceptor_Adapter _tao_vfr (
      _tao_server_request.orb_core ()->server_request_interceptors (),
      _tao_server_request.interceptor_count ()
    );
  
  TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_remove_type _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      name.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            
              _tao_impl->remove_type (
                  name.in ()
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/operation_ss.cpp:98

void POA_CosTradingRepos::ServiceTypeRepository::list_types_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
    TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
POA_CosTradingRepos::ServiceTypeRepository *_tao_impl =
    static_cast<
        POA_CosTradingRepos::ServiceTypeRepository *> (
        _tao_servant
      );
  ::CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq_var _tao_retval;
  ::CosTradingRepos::ServiceTypeRepository::SpecifiedServiceTypes which_types;
  
  if (!(
      (_tao_in >> which_types)
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    static_cast<
        TAO_Object_Adapter::Servant_Upcall *> (
        _tao_servant_upcall
      );
    
  TAO_ServerRequestInterceptor_Adapter _tao_vfr (
      _tao_server_request.orb_core ()->server_request_interceptors (),
      _tao_server_request.interceptor_count ()
    );
  
  TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_list_types _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      which_types
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            _tao_retval = 
              _tao_impl->list_types (
                  which_types
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          ::CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq * _tao_retval_info = _tao_retval._retn ();
          _tao_ri.result (_tao_retval_info);
          _tao_retval = _tao_retval_info;
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
#if (TAO_HAS_INTERCEPTORS == 1)
  if (!_tao_vfr.location_forwarded ())
    {
#endif /* TAO_HAS_INTERCEPTORS */
      TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
      
      if (!(
          (_tao_out << _tao_retval.in ())
          ))
        {
          TAO_OutputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
          ACE_CHECK;
        }
#if (TAO_HAS_INTERCEPTORS == 1)
    }
#endif /* TAO_HAS_INTERCEPTORS */
  
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/operation_ss.cpp:98

void POA_CosTradingRepos::ServiceTypeRepository::describe_type_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
    TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
POA_CosTradingRepos::ServiceTypeRepository *_tao_impl =
    static_cast<
        POA_CosTradingRepos::ServiceTypeRepository *> (
        _tao_servant
      );
  ::CosTradingRepos::ServiceTypeRepository::TypeStruct_var _tao_retval;
  ::CORBA::String_var name;
  
  if (!(
      (_tao_in >> name.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    static_cast<
        TAO_Object_Adapter::Servant_Upcall *> (
        _tao_servant_upcall
      );
    
  TAO_ServerRequestInterceptor_Adapter _tao_vfr (
      _tao_server_request.orb_core ()->server_request_interceptors (),
      _tao_server_request.interceptor_count ()
    );
  
  TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_describe_type _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      name.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            _tao_retval = 
              _tao_impl->describe_type (
                  name.in ()
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          ::CosTradingRepos::ServiceTypeRepository::TypeStruct * _tao_retval_info = _tao_retval._retn ();
          _tao_ri.result (_tao_retval_info);
          _tao_retval = _tao_retval_info;
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
#if (TAO_HAS_INTERCEPTORS == 1)
  if (!_tao_vfr.location_forwarded ())
    {
#endif /* TAO_HAS_INTERCEPTORS */
      TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
      
      if (!(
          (_tao_out << _tao_retval.in ())
          ))
        {
          TAO_OutputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
          ACE_CHECK;
        }
#if (TAO_HAS_INTERCEPTORS == 1)
    }
#endif /* TAO_HAS_INTERCEPTORS */
  
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/operation_ss.cpp:98

void POA_CosTradingRepos::ServiceTypeRepository::fully_describe_type_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
    TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
POA_CosTradingRepos::ServiceTypeRepository *_tao_impl =
    static_cast<
        POA_CosTradingRepos::ServiceTypeRepository *> (
        _tao_servant
      );
  ::CosTradingRepos::ServiceTypeRepository::TypeStruct_var _tao_retval;
  ::CORBA::String_var name;
  
  if (!(
      (_tao_in >> name.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    static_cast<
        TAO_Object_Adapter::Servant_Upcall *> (
        _tao_servant_upcall
      );
    
  TAO_ServerRequestInterceptor_Adapter _tao_vfr (
      _tao_server_request.orb_core ()->server_request_interceptors (),
      _tao_server_request.interceptor_count ()
    );
  
  TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_fully_describe_type _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      name.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            _tao_retval = 
              _tao_impl->fully_describe_type (
                  name.in ()
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          ::CosTradingRepos::ServiceTypeRepository::TypeStruct * _tao_retval_info = _tao_retval._retn ();
          _tao_ri.result (_tao_retval_info);
          _tao_retval = _tao_retval_info;
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
#if (TAO_HAS_INTERCEPTORS == 1)
  if (!_tao_vfr.location_forwarded ())
    {
#endif /* TAO_HAS_INTERCEPTORS */
      TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
      
      if (!(
          (_tao_out << _tao_retval.in ())
          ))
        {
          TAO_OutputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
          ACE_CHECK;
        }
#if (TAO_HAS_INTERCEPTORS == 1)
    }
#endif /* TAO_HAS_INTERCEPTORS */
  
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/operation_ss.cpp:98

void POA_CosTradingRepos::ServiceTypeRepository::mask_type_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
    TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
POA_CosTradingRepos::ServiceTypeRepository *_tao_impl =
    static_cast<
        POA_CosTradingRepos::ServiceTypeRepository *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CORBA::String_var name;
  
  if (!(
      (_tao_in >> name.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    static_cast<
        TAO_Object_Adapter::Servant_Upcall *> (
        _tao_servant_upcall
      );
    
  TAO_ServerRequestInterceptor_Adapter _tao_vfr (
      _tao_server_request.orb_core ()->server_request_interceptors (),
      _tao_server_request.interceptor_count ()
    );
  
  TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_mask_type _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      name.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            
              _tao_impl->mask_type (
                  name.in ()
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

// TAO_IDL - Generated from 
// be/be_visitor_operation/operation_ss.cpp:98

void POA_CosTradingRepos::ServiceTypeRepository::unmask_type_skel (
    TAO_ServerRequest &_tao_server_request,
    void *_tao_servant,
    void *_tao_servant_upcall
    ACE_ENV_ARG_DECL
  )
{
    TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
POA_CosTradingRepos::ServiceTypeRepository *_tao_impl =
    static_cast<
        POA_CosTradingRepos::ServiceTypeRepository *> (
        _tao_servant
      );
  _tao_server_request.argument_flag (0);
  
  ::CORBA::String_var name;
  
  if (!(
      (_tao_in >> name.out ())
      ))
    {
      TAO_InputCDR::throw_skel_exception (errno ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  
#if (TAO_HAS_INTERCEPTORS == 1)
  TAO_Object_Adapter::Servant_Upcall *_tao_upcall =
    static_cast<
        TAO_Object_Adapter::Servant_Upcall *> (
        _tao_servant_upcall
      );
    
  TAO_ServerRequestInterceptor_Adapter _tao_vfr (
      _tao_server_request.orb_core ()->server_request_interceptors (),
      _tao_server_request.interceptor_count ()
    );
  
  TAO_ServerRequestInfo_CosTradingRepos_ServiceTypeRepository_unmask_type _tao_ri (
      _tao_server_request,
      _tao_upcall,
      _tao_impl,
      
      name.in ()
      ACE_ENV_ARG_PARAMETER
    );
  
  ACE_TRY
    {
      {
        TAO::PICurrent_Guard _tao_pi_guard (_tao_ri.server_request (),
                                            true  /* Copy TSC to RSC */);
        
        _tao_vfr.receive_request (&_tao_ri ACE_ENV_ARG_PARAMETER);
        ACE_TRY_CHECK;
        
        if (!_tao_vfr.location_forwarded ())
          {
#endif /* TAO_HAS_INTERCEPTORS */
            
              _tao_impl->unmask_type (
                  name.in ()
                  ACE_ENV_ARG_PARAMETER
                );
            TAO_INTERCEPTOR_CHECK;
#if (TAO_HAS_INTERCEPTORS == 1)
          }
      }
      
      if (!_tao_vfr.location_forwarded ())
        {
          _tao_ri.reply_status (PortableInterceptor::SUCCESSFUL);
          _tao_vfr.send_reply (&_tao_ri ACE_ENV_ARG_PARAMETER);
          ACE_TRY_CHECK;
        }
    }
  ACE_CATCHANY
    {
      _tao_ri.exception (&ACE_ANY_EXCEPTION);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION
          || _tao_status == PortableInterceptor::USER_EXCEPTION)
        {
          ACE_RE_THROW;
        }
    }
  
# if defined (ACE_HAS_EXCEPTIONS) \
  && defined (ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS)
  ACE_CATCHALL
    {
      CORBA::UNKNOWN ex;
      
      _tao_ri.exception (&ex);
      _tao_vfr.send_exception (
          &_tao_ri
          ACE_ENV_ARG_PARAMETER
        );
      ACE_TRY_CHECK;
      
      PortableInterceptor::ReplyStatus _tao_status =
        _tao_ri.reply_status (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_TRY_CHECK;
      
      if (_tao_status == PortableInterceptor::SYSTEM_EXCEPTION)
        ACE_TRY_THROW (ex);
    }
# endif  /* ACE_HAS_EXCEPTIONS && ACE_HAS_BROKEN_UNEXPECTED_EXCEPTIONS */
  ACE_ENDTRY;
  ACE_CHECK;
#endif /* TAO_HAS_INTERCEPTORS */
  
  _tao_server_request.init_reply ();
  
  // In case _tao_servant_upcall is not used in this function
  ACE_UNUSED_ARG (_tao_servant_upcall);
}

// TAO_IDL - Generated from 
// be/be_visitor_interface/interface_ss.cpp:162

void POA_CosTradingRepos::ServiceTypeRepository::_is_a_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_servant,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
  
  POA_CosTradingRepos::ServiceTypeRepository *_tao_impl =
    (POA_CosTradingRepos::ServiceTypeRepository *) _tao_servant;
  
  CORBA::Boolean _tao_retval = 0;
  CORBA::String_var value;
  
  if (!(_tao_in >> value.out ()))
    {
      ACE_THROW (CORBA::MARSHAL ());
    }
  
  _tao_retval = _tao_impl->_is_a (value.in () ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  
  _tao_server_request.init_reply ();
  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
  
  if (!(_tao_out << CORBA::Any::from_boolean (_tao_retval)))
    {
      ACE_THROW (CORBA::MARSHAL ());
    }
}

void POA_CosTradingRepos::ServiceTypeRepository::_non_existent_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_servant,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  POA_CosTradingRepos::ServiceTypeRepository *_tao_impl =
    (POA_CosTradingRepos::ServiceTypeRepository *) _tao_servant;
  
  CORBA::Boolean _tao_retval =
    _tao_impl->_non_existent (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;
  
  _tao_server_request.init_reply ();
  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
  
  if (!(_tao_out << CORBA::Any::from_boolean (_tao_retval)))
    {
      ACE_THROW (CORBA::MARSHAL ());
    }
}

void POA_CosTradingRepos::ServiceTypeRepository::_interface_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_servant,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  TAO_IFR_Client_Adapter *_tao_adapter =
    ACE_Dynamic_Service<TAO_IFR_Client_Adapter>::instance (
        TAO_ORB_Core::ifr_client_adapter_name ()
      );
    
  if (_tao_adapter == 0)
    {
      ACE_THROW (CORBA::INTF_REPOS ());
    }
  
  POA_CosTradingRepos::ServiceTypeRepository *_tao_impl =
    (POA_CosTradingRepos::ServiceTypeRepository *) _tao_servant;
  
  CORBA::InterfaceDef_ptr _tao_retval = 
    _tao_impl->_get_interface (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;
  
  _tao_server_request.init_reply ();
  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
  
  CORBA::Boolean _tao_result =
    _tao_adapter->interfacedef_cdr_insert (
        _tao_out,
        _tao_retval
      );
  
  _tao_adapter->dispose (_tao_retval);
  
  if (_tao_result == 0)
    {
      ACE_THROW (CORBA::MARSHAL ());
    }
}

void POA_CosTradingRepos::ServiceTypeRepository::_component_skel (
    TAO_ServerRequest &_tao_server_request, 
    void * _tao_object_reference,
    void * /* Servant_Upcall */
    ACE_ENV_ARG_DECL
  )
{
  POA_CosTradingRepos::ServiceTypeRepository *_tao_impl =
    (POA_CosTradingRepos::ServiceTypeRepository *) _tao_object_reference;
  
  CORBA::Object_var _tao_retval =
    _tao_impl->_get_component (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;
  
  _tao_server_request.init_reply ();
  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
  
  if (!(_tao_out << _tao_retval.in ()))
    {
      ACE_THROW (CORBA::MARSHAL ());
    }
}

CORBA::Boolean POA_CosTradingRepos::ServiceTypeRepository::_is_a (
    const char* value
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/CosTradingRepos/ServiceTypeRepository:1.0"
        ) ||
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/CORBA/Object:1.0"
        )
     )
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

void* POA_CosTradingRepos::ServiceTypeRepository::_downcast (
    const char* logical_type_id
  )
{
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:omg.org/CosTradingRepos/ServiceTypeRepository:1.0") == 0)
    {
      return static_cast<POA_CosTradingRepos::ServiceTypeRepository_ptr> (this);
    }
  
  if (ACE_OS::strcmp (logical_type_id,
                      "IDL:omg.org/CORBA/Object:1.0") == 0)
    {
      return static_cast<PortableServer::Servant> (this);
    }
  
  return 0;
}

const char* POA_CosTradingRepos::ServiceTypeRepository::_interface_repository_id (void) const
{
  return "IDL:omg.org/CosTradingRepos/ServiceTypeRepository:1.0";
}

// TAO_IDL - Generated from
// be/be_visitor_interface/interface_ss.cpp:584

void POA_CosTradingRepos::ServiceTypeRepository::_dispatch (
    TAO_ServerRequest &req,
    void *servant_upcall
    ACE_ENV_ARG_DECL
  )
{
  this->synchronous_upcall_dispatch (req,
                                     servant_upcall,
                                     this
                                     ACE_ENV_ARG_PARAMETER);
}

// TAO_IDL - Generated from
// be/be_visitor_interface/interface_ss.cpp:526

CosTradingRepos::ServiceTypeRepository *
POA_CosTradingRepos::ServiceTypeRepository::_this (ACE_ENV_SINGLE_ARG_DECL)
{
  TAO_Stub *stub = this->_create_stub (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (0);
  
  TAO_Stub_Auto_Ptr safe_stub (stub);
  CORBA::Object_ptr tmp = CORBA::Object::_nil ();
  
  if (stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects ())
    {
      ACE_NEW_RETURN (
          tmp,
          CORBA::Object (stub, 1, this),
          0
        );
    }
  else
    {
      ACE_NEW_RETURN (
          tmp,
          CORBA::Object (stub, 0, this),
          0
        );
    }
  
  CORBA::Object_var obj = tmp;
  (void) safe_stub.release ();
  
  typedef ::CosTradingRepos::ServiceTypeRepository STUB_SCOPED_NAME;
  return
    TAO::Narrow_Utils<STUB_SCOPED_NAME>::unchecked_narrow (
        obj.in (),
        CosTradingRepos__TAO_ServiceTypeRepository_Proxy_Broker_Factory_function_pointer
      );
}

#endif /* ifndef */
