costrading.idl

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

/* -*- C++ -*- */

// ========================================================================
// CosTrading.idl,v 1.13 2003/07/24 16:39:21 bala Exp
//
// = FILENAME
//   CosTrading.idl
//
// = DESCRIPTION
//   Trader  Service v1.0 described in CORBAservices: Common Object
//   Services Specification, chapter 16 OMG IDL for Trading Function
//   Module, p 16-74
//
// ========================================================================

#ifndef TAO_TRADING_IDL
#define TAO_TRADING_IDL

#pragma prefix "omg.org"

module CosTrading
{
  // forward references to our interfaces
  
  interface Lookup;
  interface Register;
  interface Link;
  interface Proxy;
  interface Admin;
  interface OfferIterator;
  interface OfferIdIterator;
  
  // type definitions used in more than one interface  
  typedef string Istring;
  typedef Object TypeRepository;
  
  typedef Istring PropertyName;
  typedef sequence<PropertyName> PropertyNameSeq;
  typedef any PropertyValue;
  
  struct Property
  {
    PropertyName name;
    PropertyValue value;
  };
  typedef sequence<Property> PropertySeq;

  struct Offer
  {
    Object reference;
    PropertySeq properties;
  };
  typedef sequence<Offer> OfferSeq;
  
  typedef string OfferId;
  typedef sequence<OfferId> OfferIdSeq;
  
  typedef Istring ServiceTypeName;  // similar structure to IR::Identifier
  
  typedef Istring Constraint;
  
  enum FollowOption
  {
    local_only,
    if_no_local,
    always
  };
  
  typedef Istring LinkName;
  typedef sequence<LinkName> LinkNameSeq;
  typedef LinkNameSeq TraderName;
  
  typedef string PolicyName;  // policy names restricted to Latin1
  typedef sequence<PolicyName> PolicyNameSeq;
  typedef any PolicyValue;

  struct Policy
  {
    PolicyName name;
    PolicyValue value;
  };
  typedef sequence<Policy> PolicySeq;
  
  // exceptions used in more than one interface
  
  exception UnknownMaxLeft {};
  
  exception NotImplemented {};
  
  exception IllegalServiceType
    {
      ServiceTypeName type;
    };
    
  exception UnknownServiceType
    {
      ServiceTypeName type;
    };
      
   exception IllegalPropertyName
     {
       PropertyName name;
     };

   exception DuplicatePropertyName
     {
       PropertyName name;
     };

   exception PropertyTypeMismatch
     {
       ServiceTypeName type;
       Property prop;
     };

   exception MissingMandatoryProperty
     {
       ServiceTypeName type;
       PropertyName name;
     };

   exception ReadonlyDynamicProperty
     {
       ServiceTypeName type;
       PropertyName name;
     };

   exception IllegalConstraint
     {
       Constraint constr;
     };

   exception InvalidLookupRef
     {
       Lookup target;
     };

   exception IllegalOfferId
     {
       OfferId id;
     };

   exception UnknownOfferId
     {
       OfferId id;
     };

   exception DuplicatePolicyName
     {
       PolicyName name;
     };

     // the interfaces
     
   interface TraderComponents
     {       
       readonly attribute Lookup lookup_if;
       readonly attribute Register register_if;
       readonly attribute Link link_if;
       readonly attribute Proxy proxy_if;
       readonly attribute Admin admin_if;
     };

   interface SupportAttributes
     {       
       readonly attribute boolean supports_modifiable_properties;
       readonly attribute boolean supports_dynamic_properties;
       readonly attribute boolean supports_proxy_offers;
       readonly attribute TypeRepository type_repos;
     };

   interface ImportAttributes
     {
       readonly attribute unsigned long def_search_card;
       readonly attribute unsigned long max_search_card;
       readonly attribute unsigned long def_match_card;
       readonly attribute unsigned long max_match_card;
       readonly attribute unsigned long def_return_card;
       readonly attribute unsigned long max_return_card;
       readonly attribute unsigned long max_list;
       readonly attribute unsigned long def_hop_count;
       readonly attribute unsigned long max_hop_count;
       readonly attribute FollowOption def_follow_policy;
       readonly attribute FollowOption max_follow_policy;
     };

   interface LinkAttributes
     {
       readonly attribute FollowOption max_link_follow_policy;
     };

   interface Lookup:TraderComponents,SupportAttributes,ImportAttributes
     {
       typedef Istring Preference;
       
       enum HowManyProps { none, some, all };
       
       union SpecifiedProps switch ( HowManyProps )
         {
         case some: PropertyNameSeq prop_names;
         };
       
       exception IllegalPreference {
         Preference pref;
       };
       
       exception IllegalPolicyName {
         PolicyName name;
       };
       
       exception PolicyTypeMismatch {
         Policy the_policy;
       };
       
       exception InvalidPolicyValue {
         Policy the_policy;
       };
       
       void query (in ServiceTypeName type,
                   in Constraint constr,
                   in Preference pref,
                   in PolicySeq policies,
                   in SpecifiedProps desired_props,
                   in unsigned long how_many,
                   out OfferSeq offers,
                   out OfferIterator offer_itr,
                   out PolicyNameSeq limits_applied)
         raises (IllegalServiceType,
                 UnknownServiceType,
                 IllegalConstraint,
                 IllegalPreference,
                 IllegalPolicyName,
                 PolicyTypeMismatch,
                 InvalidPolicyValue,
                 IllegalPropertyName,
                 DuplicatePropertyName,
                 DuplicatePolicyName);
     };
     
     interface Register : TraderComponents, SupportAttributes
       {                
         struct OfferInfo
         {
           Object reference;
           ServiceTypeName type;
           PropertySeq properties;
         };

         exception InvalidObjectRef {
           Object ref;
         };
         
         exception UnknownPropertyName {
           PropertyName name;
         };
         
         exception InterfaceTypeMismatch {
           ServiceTypeName type;
           Object reference;
         };
         
         exception ProxyOfferId {