### Agent definitions: `Agents.oz`

Source File

>     functor

>     import
>        Tk

>        Plan(make: MakePlan)
>        Widgets(history: History
>                truck:   Truck)
>        AgentAbstractions(new:      NewAgent
>                          contract: Contract)

>     export
>        Broker
>        Company
>        Driver

>     define

>        class Broker
>           from Contract History
>           prop final
>           feat toplevel map

>           meth init(toplevel:T)
>              Contract, init
>              History, init(master:T suffix:'Broker')
>              self.toplevel = T
>           end

>           meth announce(...) = M
>              A R
>           in
>              Contract, {Adjoin M announce(answer:?A reply:R)}
>              if A\=reject then
>                 R=grant
>              end
>              History, M
>           end

>           meth add(company:C driver:D<=unit ...) = M
>              if D==unit then
>                 Contract,add(C {NewAgent Company
>                                 init(name:C toplevel:self.toplevel)})
>              else
>                 {Contract,get(C $) add(driver:D city:M.city)}
>              end
>           end

>           meth remove(company:C driver:D<=unit)
>              if D==unit then Contract,remove(C) else
>                 {Contract,get(C $) remove(D)}
>              end
>           end

>           meth close
>              History,  tkClose
>              Contract, close
>           end

>        end

>        class Company
>           from Contract History
>           prop final
>           feat toplevel

>           meth init(toplevel:T name:C)
>              Contract, init
>              History, init(master:T suffix:C)
>              self.toplevel = T
>           end

>           meth announce(answer:A reply:R ...) = Announcement
>              Contract, Announcement
>              History,  Announcement
>           end

>           meth add(driver:D city:C)
>              T          = self.toplevel
>              ThisDriver = {NewAgent Driver init(toplevel:T name:D city:C
>                                                 truck:ThisTruck)}
>              ThisTruck  = {NewAgent Truck  init(parent:T.map city:C
>                                                 driver:ThisDriver)}
>           in
>              Contract, add(D ThisDriver)
>           end

>           meth close
>              History,  tkClose
>              Contract, close
>           end

>        end

>        class Driver
>           from History
>           prop final

>           feat truck

>           attr plan:nil status:idle

>           meth init(toplevel:M name:N truck:T city:C)
>              History, init(master:M suffix:N)
>              plan <- [act(city:C load:0 lift:nil drop:nil)]
>              %% Create the truck
>              self.truck = T
>           end

>           meth deiconify
>              {Tk.send wm(deiconify self)}
>           end

>           meth announce(answer:A reply:R ...) = Announce
>              NewPlan
>           in
>              {MakePlan @plan Announce ?A ?NewPlan}
>              case R
>              of reject then skip
>              [] grant  then plan <- NewPlan
>              end
>              History, Announce
>              Driver,  check
>           end

>           meth check
>              case @status
>              of closed then {self.truck close}
>              [] idle   then
>                 N={Length @plan}
>              in
>                 if N>1 then
>                    case @plan of
>                       act(load:Load ...)|act(load:NewLoad city:Dst ...)|_
>                    then
>                       plan <- @plan.2
>                       if N>2 then status <- active
>                       end
>                       {self.truck drive(Dst Load NewLoad)}
>                    end
>                 end
>              [] active then skip
>              end
>           end

>           meth getMessage($)
>              case @status
>              of closed then close
>              [] idle then
>                 History, print('idle.')
>                 load(0)
>              [] active then
>                 case @plan of
>                    act(load:Load ...)|act(load:NewLoad city:Dst ...)|_
>                 then
>                    plan <- @plan.2
>                    if {Length @plan}=<1 then
>                       status <- idle
>                    end
>                    drive(Dst Load NewLoad)
>                 end
>              end
>           end

>           meth close
>              History, tkClose
>              if @status==idle then
>                 {self.truck close}
>              else
>                 status <- closed
>              end
>           end

>        end

>     end