Cleanup code

Author: BenLauwens

src/base.jl

@@ -60,9 +60,7 @@ function state(ev::AbstractEvent) :: EVENT_STATE
 end
 
 function append_callback(func::Function, ev::AbstractEvent, args::Any...) :: Function
-  if ev.bev.state == triggered
-    throw(EventTriggered(ev))
-  end
+  ev.bev.state == triggered && throw(EventTriggered(ev))
   cb = ()->func(ev, args...)
   ev.bev.callbacks[cb] = ev.bev.cid+=one(UInt)
   return cb

src/coroutines.jl

@@ -59,17 +59,13 @@ function execute{E<:Environment}(ev::AbstractEvent{E}, proc::Coroutine{E})
     env = environment(ev)
     set_active_process(env, proc)
     target = proc.fsm(value(ev))
+    set_active_process(env)
     if iscoroutinedone(proc.fsm)
       schedule(proc.bev, value=target)
     else
-      if state(target) == triggered
-        proc.target = Timeout(env, value=value(target))
-      else
-        proc.target = target
-      end
+      proc.target = state(target) == triggered ? Timeout(env, value=value(target)) : target
       proc.resume = append_callback(execute, proc.target, proc)
     end
-    set_active_process(env)
   catch exc
     rethrow(exc)
   end

src/events.jl

@@ -11,9 +11,7 @@ end
 
 function succeed{E<:Environment}(ev::Event{E}; priority::Int8=Int8(0), value::Any=nothing) :: Event{E}
   sta = state(ev)
-  if sta == scheduled || sta == triggered
-    throw(EventNotIdle(ev))
-  end
+  (sta == scheduled || sta == triggered) && throw(EventNotIdle(ev))
   schedule(ev.bev, priority=priority, value=value)
   return ev
 end

src/processes.jl

@@ -57,16 +57,10 @@ end
 function yield{E<:Environment}(target::AbstractEvent{E})
   env = environment(target)
   proc = active_process(env)
-  if state(target) == triggered
-    proc.target = Timeout(env, value=value(target))
-  else
-    proc.target = target
-  end
+  proc.target = state(target) == triggered ? Timeout(env, value=value(target)) : target
   proc.resume = append_callback(execute, proc.target, proc)
   ret = SimJulia.produce(nothing)
-  if isa(ret, Exception)
-    throw(ret)
-  end
+  isa(ret, Exception) && throw(ret)
   return ret
 end
 
@@ -76,9 +70,7 @@ function execute{E<:Environment}(ev::AbstractEvent{E}, proc::Process{E})
     set_active_process(env, proc)
     ret = SimJulia.consume(proc.task, value(ev))
     set_active_process(env)
-    if istaskdone(proc.task)
-      schedule(proc.bev, value=ret)
-    end
+    istaskdone(proc.task) && schedule(proc.bev, value=ret)
   catch exc
     rethrow(exc)
   end

src/resources/base.jl

@@ -19,22 +19,16 @@ struct Get{E<:Environment} <: ResourceEvent{E}
 end
 
 function isless(a::ResourceKey, b::ResourceKey)
-  return (a.priority < b.priority) || (a.priority == b.priority && a.id < b.id)
+  (a.priority < b.priority) || (a.priority == b.priority && a.id < b.id)
 end
 
 function trigger_put{E<:Environment}(put_ev::ResourceEvent{E}, res::AbstractResource{E})
   queue = DataStructures.PriorityQueue(res.Put_queue)
   while length(queue) > 0
     (put_ev, key) = DataStructures.peek(queue)
     proceed = do_put(res, put_ev, key)
-    if state(put_ev) == scheduled
-      DataStructures.dequeue!(res.Put_queue, put_ev)
-    end
-    if proceed
-      DataStructures.dequeue!(queue)
-    else
-      break
-    end
+    state(put_ev) == scheduled && DataStructures.dequeue!(res.Put_queue, put_ev)
+    proceed ? DataStructures.dequeue!(queue) : break
   end
 end
 
@@ -43,14 +37,8 @@ function trigger_get{E<:Environment}(get_ev::ResourceEvent{E}, res::AbstractReso
   while length(queue) > 0
     (get_ev, key) = DataStructures.peek(queue)
     proceed = do_get(res, get_ev, key)
-    if state(get_ev) == scheduled
-      DataStructures.dequeue!(res.Get_queue, get_ev)
-    end
-    if proceed
-      DataStructures.dequeue!(queue)
-    else
-      break
-    end
+    state(get_ev) == scheduled && DataStructures.dequeue!(res.Get_queue, get_ev)
+    proceed ? DataStructures.dequeue!(queue) : break
   end
 end
 

src/simulation.jl

@@ -95,9 +95,7 @@ Does a simulation step and processes the next event.
 step(sim::Simulation) :: Bool
 """
 function step(sim::Simulation)
-  if isempty(sim.heap)
-    throw(EmptySchedule())
-  end
+  isempty(sim.heap) && throw(EmptySchedule())
   (bev, key) = DataStructures.peek(sim.heap)
   DataStructures.dequeue!(sim.heap)
   sim.time = key.time