costrading.idl

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

           OfferId id;
         };
         
         exception MandatoryProperty {
           ServiceTypeName type;
           PropertyName name;
         };
         
         exception ReadonlyProperty {
           ServiceTypeName type;
           PropertyName name;
         };
         
         exception NoMatchingOffers {
           Constraint constr;
         };
         
         exception IllegalTraderName {
           TraderName name;
         };
         
         exception UnknownTraderName {
           TraderName name;
         };
         
         exception RegisterNotSupported {
           TraderName name;
         };

         OfferId export (in Object reference,
                         in ServiceTypeName type,
                         in PropertySeq properties)
           raises (InvalidObjectRef,
                   IllegalServiceType,
                   UnknownServiceType,
                   InterfaceTypeMismatch,
                   IllegalPropertyName, // e.g. prop_name = "<foo-bar"
                   PropertyTypeMismatch,
                   ReadonlyDynamicProperty,
                   MissingMandatoryProperty,
                   DuplicatePropertyName);

         void withdraw (in OfferId id)
           raises (IllegalOfferId,
                   UnknownOfferId,
                   ProxyOfferId);
         
         OfferInfo describe (in OfferId id)
           raises (IllegalOfferId,
                   UnknownOfferId,
                   ProxyOfferId);

         void modify (in OfferId id,
                      in PropertyNameSeq del_list,
                      in PropertySeq modify_list)
           raises (NotImplemented,
                   IllegalOfferId,
                   UnknownOfferId,
                   ProxyOfferId,
                   IllegalPropertyName,
                   UnknownPropertyName,
                   PropertyTypeMismatch,
                   ReadonlyDynamicProperty,
                   MandatoryProperty,
                   ReadonlyProperty,
                   DuplicatePropertyName);

         void withdraw_using_constraint (in ServiceTypeName type,
                                         in Constraint constr)
           raises (IllegalServiceType,
                   UnknownServiceType,
                   IllegalConstraint,
                   NoMatchingOffers);

         Register resolve (in TraderName name)
           raises (IllegalTraderName,
                   UnknownTraderName,
                   RegisterNotSupported);
       };

	interface Link : TraderComponents, SupportAttributes, LinkAttributes
          {
		struct LinkInfo
                {
                  Lookup target;
                  Register target_reg;
                  FollowOption def_pass_on_follow_rule;
                  FollowOption limiting_follow_rule;
		};

		exception IllegalLinkName {
                  LinkName name;
		};
                
		exception UnknownLinkName {
                  LinkName name;
		};
                
		exception DuplicateLinkName {
                  LinkName name;
		};
                
		exception DefaultFollowTooPermissive {
                  FollowOption def_pass_on_follow_rule;
                  FollowOption limiting_follow_rule;
		};
                
		exception LimitingFollowTooPermissive {
                  FollowOption limiting_follow_rule;
                  FollowOption max_link_follow_policy;
		};
                
		void add_link (in LinkName name,
                               in Lookup target,
                               in FollowOption def_pass_on_follow_rule,
                               in FollowOption limiting_follow_rule)
                  raises (IllegalLinkName,
                          DuplicateLinkName,
                          InvalidLookupRef, // e.g. nil
                          DefaultFollowTooPermissive,
                          LimitingFollowTooPermissive);

		void remove_link (in LinkName name)
                  raises (IllegalLinkName,
                          UnknownLinkName);

		LinkInfo describe_link (in LinkName name)
                  raises (IllegalLinkName,
                          UnknownLinkName);

		LinkNameSeq list_links ( );

		void modify_link (in LinkName name,
                                  in FollowOption def_pass_on_follow_rule,
                                  in FollowOption limiting_follow_rule)
                  raises (IllegalLinkName,
                          UnknownLinkName,
                          DefaultFollowTooPermissive,
                          LimitingFollowTooPermissive);
	};

	interface Proxy : TraderComponents, SupportAttributes
          {
            typedef Istring ConstraintRecipe;
            
            struct ProxyInfo
            {
              ServiceTypeName type;
              Lookup target;
              PropertySeq properties;
              boolean if_match_all;
              ConstraintRecipe recipe;
              PolicySeq policies_to_pass_on;
            };

            exception IllegalRecipe {
              ConstraintRecipe recipe;
            };
            
            exception NotProxyOfferId {
              OfferId id;
            };
            
            OfferId export_proxy (in Lookup target,
                                  in ServiceTypeName type,
                                  in PropertySeq properties,
                                  in boolean if_match_all,
                                  in ConstraintRecipe recipe,
                                  in PolicySeq policies_to_pass_on)
              raises (IllegalServiceType,
                      UnknownServiceType,
                      InvalidLookupRef, // e.g. nil
                      IllegalPropertyName,
                      PropertyTypeMismatch,
                      ReadonlyDynamicProperty,
                      MissingMandatoryProperty,
                      IllegalRecipe,
                      DuplicatePropertyName,
                      DuplicatePolicyName);

            void withdraw_proxy (in OfferId id)
              raises (IllegalOfferId,
                      UnknownOfferId,
                      NotProxyOfferId);
            
            ProxyInfo describe_proxy (in OfferId id)
              raises (IllegalOfferId,
                      UnknownOfferId,
                      NotProxyOfferId);
          };
          
          interface Admin : TraderComponents, SupportAttributes, ImportAttributes, LinkAttributes
            {              
              typedef sequence<octet> OctetSeq;
              
              readonly attribute OctetSeq request_id_stem;
              
              unsigned long set_def_search_card (in unsigned long value);
              unsigned long set_max_search_card (in unsigned long value);
              
              unsigned long set_def_match_card (in unsigned long value);
              unsigned long set_max_match_card (in unsigned long value);
              
              unsigned long set_def_return_card (in unsigned long value);
              unsigned long set_max_return_card (in unsigned long value);
              
              unsigned long set_max_list (in unsigned long value);
              
              boolean set_supports_modifiable_properties (in boolean value);
              boolean set_supports_dynamic_properties (in boolean value);
              boolean set_supports_proxy_offers (in boolean value);
              
              unsigned long set_def_hop_count (in unsigned long value);
              unsigned long set_max_hop_count (in unsigned long value);
              
              FollowOption set_def_follow_policy (in FollowOption policy);
              FollowOption set_max_follow_policy (in FollowOption policy);
              
              FollowOption set_max_link_follow_policy (in FollowOption policy);
              
              TypeRepository set_type_repos (in TypeRepository repository);
              
              OctetSeq set_request_id_stem (in OctetSeq stem);
              
              void list_offers (in unsigned long how_many,
                                out OfferIdSeq ids,
                                out OfferIdIterator id_itr)
                raises (NotImplemented);

              void list_proxies (in unsigned long how_many,
                                 out OfferIdSeq ids,
                                 out OfferIdIterator id_itr)
                raises (NotImplemented);
	};

	interface OfferIterator
          {
		unsigned long max_left ()
                  raises (UnknownMaxLeft);

		boolean next_n (in unsigned long n,
                                out OfferSeq offers);

		void destroy ();
	};

	interface OfferIdIterator
          {
            unsigned long max_left ()
              raises (UnknownMaxLeft);
            
            boolean next_n (in unsigned long n,
                            out OfferIdSeq ids);

            void destroy ();
          };
          
}; /* end module CosTrading */

#endif /* TAO_TRADING_IDL */