DataMuseum.dk

Presents historical artifacts from the history of:

Rational R1000/400

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about Rational R1000/400

Excavated with: AutoArchaeologist - Free & Open Source Software.


top - download

⟦1bcabed47⟧ Ada Source

    Length: 15360 (0x3c00)
    Types: Ada Source
    Notes: 03_class, FILE, R1k_Segment, e3_tag, package body Agent_Tools, seg_055c8e

Derivation

└─⟦8527c1e9b⟧ Bits:30000544 8mm tape, Rational 1000, Arrival backup of disks in PAM's R1000
    └─ ⟦cfc2e13cd⟧ »Space Info Vol 2« 
        └─⟦this⟧ 

E3 Source Code



with Bounded_String;
with Const_Orb;
with Text_Io;


package body Agent_Tools is

    function Get_Local_Id return My_Message.My_String is
    begin
        return Local_Id;
    end Get_Local_Id;

    function Is_Finished return Boolean is
    begin
        return Req_Id_Manager.Get_Is_Empty (Tab);
    end Is_Finished;


    procedure Content is
        Operation : constant My_Message.Kind_Of_Message := My_Message.Content;
        Mess : My_Message.Object;
        Content : My_Message.My_String;
        Request_Id : Positive;
    begin
        Bounded_String.Copy (Content, Const_Orb.No_Content);
        Req_Id_Manager.Get (Tab => Tab, Req_Id => Request_Id);
        Mess := My_Message.Initialize (Op => Operation,
                                       Cont => Content,
                                       Req_I => Request_Id,
                                       L_I => Local_Id);
        My_Message.Send (Mess => Mess, Rem_Id => Remote_Id);
    end Content;

    procedure Filtration (Contract : My_Message.My_String) is
        Operation : constant My_Message.Kind_Of_Message :=
           My_Message.Filtration;
        Mess : My_Message.Object;
        Content : My_Message.My_String;
    begin
        Bounded_String.Copy (Content, Contract);
        Mess := My_Message.Initialize
                   (Op => Operation, Cont => Content, L_I => Local_Id);
        My_Message.Send (Mess => Mess, Rem_Id => Remote_Id);
    end Filtration;

    procedure Notification (Note : My_Message.My_String) is
        Operation : constant My_Message.Kind_Of_Message :=
           My_Message.Notification;
        Mess : My_Message.Object;
    begin
        Mess := My_Message.Initialize (Op => Operation,
                                       Cont => Note,  
                                       L_I => Local_Id);
        My_Message.Send (Mess => Mess, Rem_Id => Remote_Id);
    end Notification;

    procedure Print (Mess_From_Reply : My_Message.Object) is
    begin  
        Req_Id_Manager.Delete
           (Tab => Tab,
            Req_Id => My_Message.Get_Request_Identifier (Mess_From_Reply));
        case My_Message.Get_Operation (Mess_From_Reply) is
            when My_Message.Notification =>
                Text_Io.Put
                   ("Message of notification from agent " &
                    Bounded_String.Image
                       (My_Message.Get_Local_Identifier (Mess_From_Reply)) &
                    " : ");
            when My_Message.Reply_Subscription =>
                Text_Io.Put
                   ("Message of subscription asked by agent " &
                    Bounded_String.Image
                       (My_Message.Get_Local_Identifier (Mess_From_Reply)) &
                    " : ");
            when others =>
                Text_Io.Put
                   ("Reply from the broker to the request number " &
                    Positive'Image
                       (My_Message.Get_Request_Identifier (Mess_From_Reply)) &
                    " : ");
        end case;
        Text_Io.Put_Line (Bounded_String.Image
                             (My_Message.Get_Content (Mess_From_Reply)));
    end Print;

    procedure Publication (Contract : My_Message.My_String) is
        Operation : constant My_Message.Kind_Of_Message :=
           My_Message.Publication;
        Mess : My_Message.Object;
    begin  
        Mess := My_Message.Initialize
                   (Op => Operation, Cont => Contract, L_I => Local_Id);  
        My_Message.Send (Mess => Mess, Rem_Id => Remote_Id);
    end Publication;

    procedure Publication_Filter (Contract : My_Message.My_String) is
        Operation : constant My_Message.Kind_Of_Message :=
           My_Message.Publication_Filter;
        Mess : My_Message.Object;
    begin  
        Mess := My_Message.Initialize
                   (Op => Operation, Cont => Contract, L_I => Local_Id);  
        My_Message.Send (Mess => Mess, Rem_Id => Remote_Id);
    end Publication_Filter;

    procedure Query is
        Operation : constant My_Message.Kind_Of_Message := My_Message.Query;
        Mess : My_Message.Object;
        Content : My_Message.My_String;
    begin  
        Bounded_String.Copy (Content, Const_Orb.No_Content);
        Mess := My_Message.Initialize
                   (Op => Operation, Cont => Content, L_I => Local_Id);
        My_Message.Send (Mess => Mess, Rem_Id => Remote_Id);
    end Query;

    procedure Registration is
        Operation : constant My_Message.Kind_Of_Message :=
           My_Message.Registration;
        Content, L_I_Tmp : My_Message.My_String;
        Local_Host : String (1 .. 255);
        Mess : My_Message.Object;
    begin
        Bounded_String.Copy (Content, "Registrating");
        Bounded_String.Copy (L_I_Tmp, Const_Orb.No_Local_Id);

        Mess := My_Message.Initialize
                   (Op => Operation, Cont => Content, L_I => L_I_Tmp);
        My_Message.Send (Mess => Mess, Rem_Id => Remote_Id);
        Local_Id := My_Message.Get_Local_Identifier (Mess);
    end Registration;

    procedure Reply (Mess_Received : My_Message.Object) is
        Operation : My_Message.Kind_Of_Message;
        Mess : My_Message.Object;  
        Data : My_Message.My_String;
    begin  
        case My_Message.Get_Operation (Mess_Received) is
            when My_Message.Forward_Filtration =>
                Operation := My_Message.Reply_Filtration;
            when others =>
                Operation := My_Message.Reply;
        end case;
        Bounded_String.Copy (Data, Service
                                      (My_Message.Get_Content (Mess_Received)));
        Mess := My_Message.Initialize
                   (Op => Operation,
                    Cont => Data,
                    Req_I => My_Message.Get_Request_Identifier (Mess_Received),
                    L_I => My_Message.Get_Local_Identifier (Mess_Received),
                    R_I => My_Message.Get_Remote_Identifier (Mess_Received));
        My_Message.Send (Mess => Mess, Rem_Id => Remote_Id);
    end Reply;

    procedure Request (Data : My_Message.My_String) is
        Operation : constant My_Message.Kind_Of_Message := My_Message.Request;
        Mess : My_Message.Object;  
        Request_Id : Positive;
    begin
        Req_Id_Manager.Get (Tab => Tab, Req_Id => Request_Id);
        Mess := My_Message.Initialize (Op => Operation,
                                       Cont => Data,
                                       Req_I => Request_Id,
                                       L_I => Local_Id);
        My_Message.Send (Mess => Mess, Rem_Id => Remote_Id);
    end Request;

    procedure Request (Data : My_Message.My_String;
                       Remote_Id : My_Message.My_String) is
        Operation : constant My_Message.Kind_Of_Message := My_Message.Request;
        Mess : My_Message.Object;  
        Request_Id : Positive;
    begin
        Req_Id_Manager.Get (Tab => Tab, Req_Id => Request_Id);
        Mess := My_Message.Initialize (Op => Operation,
                                       Cont => Data,
                                       Req_I => Request_Id,
                                       L_I => Local_Id,
                                       R_I => Remote_Id);
        My_Message.Send (Mess => Mess, Rem_Id => Remote_Id);
    end Request;

    procedure Subscription (Contract : My_Message.My_String) is
        Operation : constant My_Message.Kind_Of_Message :=
           My_Message.Subscription;
        Content : My_Message.My_String;
        Mess : My_Message.Object;
    begin
        Bounded_String.Copy (Content, Contract);
        Mess := My_Message.Initialize (Op => Operation,
                                       Cont => Content,  
                                       L_I => Local_Id);
        My_Message.Send (Mess => Mess, Rem_Id => Remote_Id);
    end Subscription;

    procedure Unfiltration (Contract : My_Message.My_String) is
        Operation : constant My_Message.Kind_Of_Message :=
           My_Message.Filtration;
        Mess : My_Message.Object;
        Content : My_Message.My_String;
    begin
        Bounded_String.Copy (Content, Contract);
        Mess := My_Message.Initialize
                   (Op => Operation, Cont => Content, L_I => Local_Id);
        My_Message.Send (Mess => Mess, Rem_Id => Remote_Id);
    end Unfiltration;

    procedure Unpublication (Contract : My_Message.My_String) is
        Operation : constant My_Message.Kind_Of_Message :=
           My_Message.Unpublication;
        Mess : My_Message.Object;
    begin  
        Mess := My_Message.Initialize
                   (Op => Operation, Cont => Contract, L_I => Local_Id);
        My_Message.Send (Mess => Mess, Rem_Id => Remote_Id);
    end Unpublication;

    procedure Unpublication_Filter (Contract : My_Message.My_String) is
        Operation : constant My_Message.Kind_Of_Message :=
           My_Message.Unpublication_Filter;
        Mess : My_Message.Object;
    begin  
        Mess := My_Message.Initialize
                   (Op => Operation, Cont => Contract, L_I => Local_Id);
        My_Message.Send (Mess => Mess, Rem_Id => Remote_Id);
    end Unpublication_Filter;

    procedure Unregistration is
        Operation : constant My_Message.Kind_Of_Message :=
           My_Message.Unregistration;
        Content : My_Message.My_String;
        Mess : My_Message.Object;
    begin
        Bounded_String.Copy (Content, "Unregistrating");

        Mess := My_Message.Initialize
                   (Op => Operation, Cont => Content, L_I => Local_Id);
        My_Message.Send (Mess => Mess, Rem_Id => Remote_Id);
    end Unregistration;

    procedure Unsubscription (Contract : My_Message.My_String) is
        Operation : constant My_Message.Kind_Of_Message :=
           My_Message.Unsubscription;
        Content : My_Message.My_String;
        Mess : My_Message.Object;
    begin
        Bounded_String.Copy (Content, "Request of unsubscription");

        Mess := My_Message.Initialize (Op => Operation,
                                       Cont => Content,  
                                       L_I => Local_Id);
        My_Message.Send (Mess => Mess, Rem_Id => Remote_Id);
    end Unsubscription;


begin

    Req_Id_Manager.Initialize (Tab);
    Bounded_String.Copy (Remote_Id, Const_Orb.Broker_Id);

end Agent_Tools;

E3 Meta Data

    nblk1=e
    nid=6
    hdr6=1a
        [0x00] rec0=20 rec1=00 rec2=01 rec3=076
        [0x01] rec0=1a rec1=00 rec2=07 rec3=01c
        [0x02] rec0=00 rec1=00 rec2=04 rec3=05c
        [0x03] rec0=16 rec1=00 rec2=09 rec3=062
        [0x04] rec0=18 rec1=00 rec2=0c rec3=036
        [0x05] rec0=19 rec1=00 rec2=0b rec3=070
        [0x06] rec0=16 rec1=00 rec2=02 rec3=068
        [0x07] rec0=15 rec1=00 rec2=0e rec3=034
        [0x08] rec0=04 rec1=00 rec2=0d rec3=008
        [0x09] rec0=16 rec1=00 rec2=05 rec3=008
        [0x0a] rec0=17 rec1=00 rec2=08 rec3=02a
        [0x0b] rec0=19 rec1=00 rec2=03 rec3=032
        [0x0c] rec0=11 rec1=00 rec2=0a rec3=000
        [0x0d] rec0=40 rec1=00 rec2=00 rec3=002
    tail 0x21760f11a87c05d91e117 0x42a00088462060003
Free Block Chain:
  0x6: 0000  00 00 00 3b 80 1f 65 6d 6f 74 65 5f 49 64 2c 20  ┆   ;  emote_Id, ┆