update to run on Julia v0.6

Author: BenLauwens

REQUIRE

@@ -1 +1,2 @@
 julia 0.5
+DataStructures

src/SimJulia.jl

@@ -5,6 +5,7 @@ Main module for SimJulia.jl – a combined continuous time / discrete event proc
 """
 module SimJulia
   using Base.Collections, Base.Dates
+  using DataStructures
 
   import Base.==, Base.+, Base.*, Base.&, Base.|
   import Base.isless, Base.yield, Base.schedule, Base.run, Base.now, Base.eps

src/base.jl

@@ -31,11 +31,11 @@ type BaseEvent{E<:Environment}
   env :: E
   id :: UInt
   cid :: UInt
-  callbacks :: PriorityQueue{Function, UInt}
+  callbacks :: DataStructures.PriorityQueue{Function, UInt}
   state :: EVENT_STATE
   value :: Any
   function BaseEvent(env::E)
-    new(env, env.eid+=one(UInt), zero(UInt), PriorityQueue(Function, UInt), idle, nothing)
+    new(env, env.eid+=one(UInt), zero(UInt), DataStructures.PriorityQueue(Function, UInt), idle, nothing)
   end
 end
 
@@ -69,5 +69,5 @@ function append_callback(func::Function, ev::AbstractEvent, args::Any...) :: Fun
 end
 
 function remove_callback(cb::Function, ev::AbstractEvent)
-  dequeue!(ev.bev.callbacks, cb)
+  DataStructures.dequeue!(ev.bev.callbacks, cb)
 end

src/resources/base.jl

@@ -23,43 +23,43 @@ function isless(a::ResourceKey, b::ResourceKey)
 end
 
 function trigger_put{E<:Environment}(put_ev::ResourceEvent{E}, res::AbstractResource{E})
-  queue = PriorityQueue(res.Put_queue)
+  queue = DataStructures.PriorityQueue(res.Put_queue)
   while length(queue) > 0
-    (put_ev, key) = peek(queue)
+    (put_ev, key) = DataStructures.peek(queue)
     proceed = do_put(res, put_ev, key)
     if state(put_ev) == scheduled
-      dequeue!(res.Put_queue, put_ev)
+      DataStructures.dequeue!(res.Put_queue, put_ev)
     end
     if proceed
-      dequeue!(queue)
+      DataStructures.dequeue!(queue)
     else
       break
     end
   end
 end
 
 function trigger_get{E<:Environment}(get_ev::ResourceEvent{E}, res::AbstractResource{E})
-  queue = PriorityQueue(res.Get_queue)
+  queue = DataStructures.PriorityQueue(res.Get_queue)
   while length(queue) > 0
-    (get_ev, key) = peek(queue)
+    (get_ev, key) = DataStructures.peek(queue)
     proceed = do_get(res, get_ev, key)
     if state(get_ev) == scheduled
-      dequeue!(res.Get_queue, get_ev)
+      DataStructures.dequeue!(res.Get_queue, get_ev)
     end
     if proceed
-      dequeue!(queue)
+      DataStructures.dequeue!(queue)
     else
       break
     end
   end
 end
 
 function cancel{E<:Environment}(res::AbstractResource{E}, put_ev::Put{E})
-  dequeue!(res.Put_queue, put_ev)
+  DataStructures.dequeue!(res.Put_queue, put_ev)
 end
 
 function cancel{E<:Environment}(res::AbstractResource{E}, get_ev::Get{E})
-  dequeue!(res.Get_queue, get_ev)
+  DataStructures.dequeue!(res.Get_queue, get_ev)
 end
 
 function capacity(res::AbstractResource)

src/resources/containers.jl

@@ -9,10 +9,10 @@ type Container{N<:Number, E<:Environment} <: AbstractResource{E}
   capacity :: N
   level :: N
   seid :: UInt
-  Put_queue :: PriorityQueue{Put{E}, ContainerKey{N}}
-  Get_queue :: PriorityQueue{Get{E}, ContainerKey{N}}
+  Put_queue :: DataStructures.PriorityQueue{Put{E}, ContainerKey{N}}
+  Get_queue :: DataStructures.PriorityQueue{Get{E}, ContainerKey{N}}
   function Container(env::E, capacity::N, level::N)
-    new(env, capacity, level, zero(UInt), PriorityQueue(Put{E}, ContainerKey{N}), PriorityQueue(Get{E}, ContainerKey{N}))
+    new(env, capacity, level, zero(UInt), DataStructures.PriorityQueue(Put{E}, ContainerKey{N}), DataStructures.PriorityQueue(Get{E}, ContainerKey{N}))
   end
 end
 

src/resources/stores.jl

@@ -15,10 +15,10 @@ type Store{T, E<:Environment} <: AbstractResource{E}
   capacity :: UInt
   items :: Set{T}
   seid :: UInt
-  Put_queue :: PriorityQueue{Put{E}, StorePutKey{T}}
-  Get_queue :: PriorityQueue{Get{E}, StoreGetKey}
+  Put_queue :: DataStructures.PriorityQueue{Put{E}, StorePutKey{T}}
+  Get_queue :: DataStructures.PriorityQueue{Get{E}, StoreGetKey}
   function Store(env::E, capacity::UInt)
-    new(env, capacity, Set{T}(), zero(UInt), PriorityQueue(Put{E}, StorePutKey{T}), PriorityQueue(Get{E}, StoreGetKey))
+    new(env, capacity, Set{T}(), zero(UInt), DataStructures.PriorityQueue(Put{E}, StorePutKey{T}), DataStructures.PriorityQueue(Get{E}, StoreGetKey))
   end
 end
 

src/simulation.jl

@@ -33,12 +33,12 @@ An initial_time for the simulation can be specified. By default, it starts at 0.
 """
 type Simulation{T<:TimeType} <: Environment
   time :: T
-  heap :: PriorityQueue{BaseEvent{Simulation{T}}, EventKey{T}}
+  heap :: DataStructures.PriorityQueue{BaseEvent{Simulation{T}}, EventKey{T}}
   eid :: UInt
   sid :: UInt
   active_proc :: Nullable{Process{Simulation{T}}}
   function Simulation(initial_time::T)
-    new(initial_time, PriorityQueue(BaseEvent{Simulation{T}}, EventKey{T}), zero(UInt), zero(UInt), Nullable{Process{Simulation{T}}}())
+    new(initial_time, DataStructures.PriorityQueue(BaseEvent{Simulation{T}}, EventKey{T}), zero(UInt), zero(UInt), Nullable{Process{Simulation{T}}}())
   end
 end
 
@@ -96,12 +96,12 @@ function step(sim::Simulation)
   if isempty(sim.heap)
     throw(EmptySchedule())
   end
-  (bev, key) = peek(sim.heap)
-  dequeue!(sim.heap)
+  (bev, key) = DataStructures.peek(sim.heap)
+  DataStructures.dequeue!(sim.heap)
   sim.time = key.time
   bev.state = triggered
   while !isempty(bev.callbacks)
-    dequeue!(bev.callbacks)()
+    DataStructures.dequeue!(bev.callbacks)()
   end
 end