costrading.idl

UCS (Ultra Corba Simulator) is one more powerful corba client/servant simulator tool than other simi

      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_iter,
         out PolicyNameSeq limits_applied
      )
      raises
      (
         IllegalServiceType,
         UnknownServiceType,
         IllegalConstraint,
         IllegalPreference,
         IllegalPolicyName,
         PolicyTypeMismatch,
         InvalidPolicyValue,
         IllegalPropertyName,
         DuplicatePropertyName,
         DuplicatePolicyName
      );
      /* enddoc */	
   };

/** This interface is used export offers of service to
 * the trader and manage these offers.
 */

   interface Register : TraderComponents, SupportAttributes
   {
      exception IllegalTraderName
      {
         TraderName name;
      };
      exception InvalidObjectRef
      {
         Object ref;
      };
      exception InterfaceTypeMismatch
      {
         ServiceTypeName type;
         Object reference;
      };
      exception MandatoryProperty
      {
         ServiceTypeName type;
         PropertyName name;
      };
      exception NoMatchingOffers
      {
         Constraint constr;
      };
      exception ProxyOfferId
      {
         OfferId id;
      };
      exception ReadonlyProperty
      {
         ServiceTypeName type;
         PropertyName name;
      };
      exception RegisterNotSupported
      {
         TraderName name;
      };
      exception UnknownPropertyName
      {
         PropertyName name;
      };
      exception UnknownTraderName
      {
         TraderName name;
      };

/** This structure holds information about an offer.
 * It contains a eference to the object making the
 * offer, the name of the service type it provides
 * and a set of properties it supports.
 */

      struct OfferInfo
      {
         Object reference;
         ServiceTypeName type;
         PropertySeq properties;
      };

/** This operation exports an offer of service to the
 * trader with a set of properties it supports.
 *
 * @returns - An offer identifier.
 *
 * @param reference - The object making the offer.
 * @param type - The service type name of the offer.
 * @param properties - A sequence of supported properties.
 *
 * @raises InvalidObjectRef - If the object reference is not valid.
 * @raises IllegalServiceType - If the specified service type
 *                              name is invalid.
 * @raises UnknownServiceType - If the specified service type
 *                              has not been registered.
 * @raises InterfaceTypeMismatch - The object does not support the interface
 *                                 specified in the service definition.
 * @raises IllegalPropertyName - If a property name is illegal.
 * @raises DuplicatePropertyName - If duplicate property names are specified.
 * @raises PropertyTypeMismatch - If the type of a property does not match
 *                                the type specified in the service definition.
 * @raises ReadonlyDynamicProperty - If an attempt has been made to assign a dynamic
 *                                   property value to a property defined as
 *                                   read-only in the service definition.
 * @raises MissingMandatoryProperty - If a property defined as mandatory in the
 *                                    service definition has not been supplied.
 */
      /* doc: 37 */	
      OfferId export
      (
         in Object reference,
         in ServiceTypeName type,
         in PropertySeq properties
      )
      raises
      (
         InvalidObjectRef,
         IllegalServiceType,
         UnknownServiceType,
         InterfaceTypeMismatch,
         IllegalPropertyName,
         PropertyTypeMismatch,
         ReadonlyDynamicProperty,
         MissingMandatoryProperty,
         DuplicatePropertyName
      );
      /* enddoc */
/** This operation withdraws an offer of service
 * from the trader.
 *
 * @param id - The identifier of the offer to be withdrawn.
 *
 * @raises IllegalOfferId - If the format of the offer identifier is invalid.
 * @raises UnknownOfferId - If the trader knows nothing of the identified offer.
 * @raises ProxyOfferId - The trader cannot withdraw the proxy offer.
 */

      /* doc: 35 */
      void withdraw
      (
         in OfferId id
      )
      raises
      (
         IllegalOfferId,
         UnknownOfferId,
         ProxyOfferId
      );
      /* enddoc */

/** This operation describes an offer of service
 * from the trader.
 *
 * @returns - An offer descriptor structure.
 *
 * @param id - The identifier of the offer to be described.
 *
 * @raises IllegalOfferId - If the format of the offer identifier is invalid.
 * @raises UnknownOfferId - If the trader knows nothing of the identified offer.
 * @raises ProxyOfferId - The trader cannot describe the proxy offer.
 */
      /* doc: 31 */
      OfferInfo describe
      (
         in OfferId id
      )
      raises
      (
         IllegalOfferId,
         UnknownOfferId,
         ProxyOfferId
      );
      /* enddoc */

/** This operation modifies the properties supported
 * by a traded offer of service. Properties that are read-only
 * or mandatory may not be deleted and properties that are
 * read-only may not be modified.
 *
 * @param id - The identifier of the offer to be modified.
 * @param del_list - The list of properties to be deleted.
 * @param modify_list - The list of properties to be added or modified.
 *
 * @raises NotImplemented - If this operation is not implemented by the trader.
 * @raises IllegalOfferId - If the format of the offer identifier is invalid.
 * @raises UnknownOfferId - If the trader knows nothing of the identified offer.
 * @raises ProxyOfferId - The trader cannot withdraw the proxy offer.
 * @raises IllegalPropertyName - If a property name is illegal.
 * @raises UnknownPropertyName - If the offer does not support the named property.
 * @raises PropertyTypeMismatch - If the type of a property does not match
 *                                the type specified in the service definition.
 * @raises ReadonlyDynamicProperty - If an attempt has been made to assign a dynamic
 *                                   property value to a mandatory property.
 * @raises MandatoryProperty - If an attemp has been made to delete a mandatory property
 * @raises ReadonlyProperty - If an attemp has been made to modify a read-only property
 * @raises DuplicatePropertyName - If duplicate property names are specified.
 */

      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
      );

/** This operation withdraws any offers matching the
 * specified constraints.
 *
 * @param type - The service type of offers to check. 
 * @param type - The constraint string to check offers against.
 *
 * @raises IllegalServiceType - If the specified service type
 *                              name is invalid.
 * @raises UnknownServiceType - If the specified service type
 *                              has not been registered.
 * @raises IllegalConstraint - If the constraint string is illegal.
 * @raises NoMatchingOffers - If no offers corresponding to the service type
 *                            and satisfying the constraints were found.
 */

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

/** This opreration resolves the Register interface of a linked trader.
 *
 * @param name - The name of the linked trader. 
 *
 * @raises IllegalTraderName - If the specified trader name has invalid syntax.
 * @raises UnknownTraderName - If the specified trader cannot be found.
 * @raises RegisterNotSupported - If the specified trader does not support
 *                                the Register interface.
 */

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

/** This interface is used to federate traders
 * together and manage the links between them.
 */

   interface Link : TraderComponents, SupportAttributes, LinkAttributes
   {
/** This structure holds information about federated
 * trader interfaces. It holds references to the Lookup
 * and Register interfaces on the linked trader. Plus
 * policy options about how the link is used.
 */

      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;
      };

/** This operation links a federated trader.
 *
 * @param name - The name of the linked trader. 
 * @param target - The Lookup interface to link.
 * @param def_pass_on_follow_rule - The default lookup policy to propagate 
 *                                  if none was specified in the query.
 * @param limiting_follow_rule - The most permissive link policy that can
 *                               be applied to the link. 
 *
 * @raises IllegalLinkName - If the specified link name has invalid syntax.
 * @raises DuplicateLinkName - If a link with the same name already exists.
 * @raises InvalidLookupRef - If the specified target reference is nil.
 * @raises DefaultFollowTooPermissive - If the default lookup policy for the
 *                                      link is more premissive than the limiting
 *                                      lookup policy for the link.
 * @raises LimitingFollowTooPermissive - If the link default lookup policy is
 *                                       more permissive that the corresponding
 *                                       trader maximum allowed value.
 */

      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,
         DefaultFollowTooPermissive,
         LimitingFollowTooPermissive
      );