# /*

# IDL for ORBLink administrative interfaces

The IDL source in this file, which is in the `code` font, encapsulates pseudointerfaces to ORB functionality in excess of what is required by the CORBA IDL/Lisp mapping. In order to understand the way in which this file describes Lisp functions, you should be familiar with that mapping. The functionality described in this document, thus, is only necessary for advanced CORBA applications. Each IDL definition in this file is linked to a text description of the semantics of that definition.

# */

    module  ORBLink {
      native value;
      native Condition;

      exception  Forward ;
        Object location;
      }
      exception orblink_servant_exception
        any original_condition;
        string message;}

      pseudo interface Junction {
        readonly attribute value socket;
        unsigned long SecondsIdle();
        boolean isOpen();
    };
      pseudo interface ActiveJunction : Junction {
        readonly attribute unsigned long MessagesReceived;
        readonly attribute string RemoteHost;
        readonly attribute unsigned long RemotePort;
        void close();
        };
      pseudo interface PassiveJunction: Junction {;};
      pseudo interface ClientJunction : ActiveJunction {;};
      pseudo interface ServerJunction : ActiveJunction {};
      typedef sequence < ServerJunction> ServerJunctionList;
      typedef sequence < ClientJunction> ClientJunctionList;
      typedef sequence < PassiveJunction> PassiveJunctionList;

      pseudo interface Message{
        enum MessageDirection {incoming,outgoing,unknown};
        readonly attribute MessageDirection direction;
        enum MessageType {Request,Reply,CancelRequest,LocateRequest,
    		       LocateReply,CloseConnection,MessageError,Fragment};
        readonly attribute MessageType type;
        readonly attribute junction ForwardingJunction;
      }

      pseudo interface ORB : CORBA::ORB {
        Object _narrow(in Object obj, in Symbol class_name);
        void HandleJunctionError (in Junction j, in Condition c);
        void HandleJunctionClose (in Junction j);

        readonly attribute ServerJunctionList ServerJunctions;
        readonly attribute ClientJunctionList ClientJunctions;
        readonly attribute PassiveJunctionList PassiveJunctions;
        enum ServerJunctionErrorPolicyType {continue, debug, handle};
        attribute ServerJunctionErrorPolicyType ServerJunctionErrorPolicy;
        attribute boolean HandleJunctionClosePolicy;

        enum break_policy_type {return,break};
        attribute break_policy_type break_policy;
        enum thread_policy_type {singly_threaded, thread_per_request}
        enum verbose_level_type {low, high};
        attribute verbose_level_type verbose_level;
        attribute thread_policy_type thread_policy;
        attribute boolean tracing;
        attribute unsigned long port;
        attribute string  domain ;
        attribute string host;
        readonly attribute string version;
     };

    };

    module CORBA {
      const ORB orb;
    pseudo interface ORB {
      String object_to_string (in Object obj);
      Object string_to_object (in String str);
    {;

      pseudo interface Object {
      };

      pseudo interface Proxy (Object) {
        readonly attribute _junction;
      }

      pseudo interface Servant (Object) {
        readonly attribute string _marker;
        void _forward (in Object location) raises (ORBLink::Forward);
      }
    }