fast-tcpn 0.0.5

data/lib/fast-tcpn/timed_hash_marking.rb

@@ -0,0 +1,87 @@
+module FastTCPN
+
+  # This class extends HashMarking to support timed tokens.
+  # It is however slower than not-timed version, so use it
+  # if you really need it.
+  class TimedHashMarking < HashMarking
+    InvalidTime = Class.new RuntimeError
+
+    attr_reader :time, :next_time
+
+    # Create a new TimedHashMarking
+    def initialize(*)
+      super
+      @time = 0
+      @waiting = {}
+      # Next time when more tokens will be available from this marking
+      @next_time = 0
+    end
+
+    # Creates token with +object+ as its value and adds it to the marking.
+    # if no timestamp is given, current time will be used.
+    def add(objects, timestamp = @time)
+      unless objects.kind_of? Array
+        objects = [ objects ]
+      end
+      objects.each do |object|
+        if object.instance_of? Hash
+          timestamp = object[:ts] || 0
+          object = object[:val]
+        end
+        token = prepare_token(object, timestamp)
+        timestamp = token.timestamp
+        if timestamp > @time
+          add_to_waiting token
+        else
+          add_token token
+        end
+      end
+    end
+
+    # Set current time for the marking.
+    # This will cause moving tokens from waiting to active list.
+    # Putting clock back will cause error.
+    def time=(time)
+      if time < @time
+        raise InvalidTime.new("You are trying to put back clock from #{@time} back to #{time}")
+      end
+      @time = time
+      @waiting.keys.sort.each do |timestamp|
+        if timestamp > @time
+          @next_time = timestamp
+          break
+        end
+        @waiting[timestamp].each { |token| add_token token }
+        @waiting.delete timestamp
+      end
+      @next_time = 0 if @waiting.empty?
+      @time
+    end
+
+    def token_type
+      TimedToken
+    end
+
+    private
+
+    def prepare_token(object, timestamp = 0)
+      if object.instance_of? token_type
+        clone object
+      elsif object.kind_of? token_type
+        token_type.new clone(object.value), object.timestamp
+      else
+        token_type.new clone(object), timestamp
+      end
+    end
+
+    def add_to_waiting(token)
+      @waiting[token.timestamp] ||= []
+      @waiting[token.timestamp] << token
+      if @next_time == 0 || token.timestamp < @next_time
+        @next_time = token.timestamp
+      end
+    end
+
+  end
+
+end

data/lib/fast-tcpn/timed_place.rb

@@ -0,0 +1,44 @@
+module FastTCPN
+  # This class extends Place class to support time and timed tokens.
+  # TimedHashMarking class is used to store tokens.
+  #
+  # It is however slower in simulation than not-timed version, so
+  # use with care when you really need it.
+  class TimedPlace < Place
+    # Create new timed place.
+    # +name+ is unique identifier of the place
+    # +keys+ are used to efficiently access marking in this place
+    # +net+ is TCPN class object, used to enable callbacks
+    def initialize(name, keys = {}, net = nil)
+      super
+      @marking = TimedHashMarking.new keys
+      @clock = 0
+    end
+
+    # returns next timestamp that will cause more tokens
+    # to be available in this place
+    def next_time
+      @marking.next_time
+    end
+
+    # set current time for this place 
+    # (will move tokens from waiting to active state).
+    # Putting clock back will cause error.
+    def time=(val)
+      @clock = val
+      @marking.time = val
+    end
+
+    # Adds token with specified timestamp to the place.
+    # Any callbacks defined for places will be fired.
+    def add(token, timestamp = nil)
+      @net.call_callbacks(:place, :add, Event.new(@name, [token], @net)) unless @net.nil?
+      if timestamp.nil?
+        @marking.add token
+      else
+        @marking.add token, timestamp
+      end
+    end
+
+  end
+end

data/lib/fast-tcpn/timed_token.rb

@@ -0,0 +1,27 @@
+module FastTCPN
+
+  # Extends Token class to support time.
+  # Stores also timestamp.
+  class TimedToken < Token
+
+    attr_accessor :timestamp
+
+    # Create new token with specified +value+ and +timestamp+.
+    def initialize(value, timestamp = 0)
+      super value
+      @timestamp = timestamp
+    end
+
+    # Create new token with the same value but new timestamp
+    # Use it to quickly delay tokens while firing a transition
+    # if token value change is not required.
+    def with_timestamp(timestamp)
+      self.class.new(value, timestamp)
+    end
+
+    def to_hash
+      { val: value, ts: timestamp }
+    end
+
+  end
+end

data/lib/fast-tcpn/token.rb

@@ -0,0 +1,30 @@
+module FastTCPN
+
+  # Represents tokens in CPN.
+  # Stores values, ensures correct handling of
+  # equality and hash values.
+  class Token
+    alias orig_hash hash
+    attr_reader :value, :hash, :token_id
+
+    def initialize(value)
+      @value = value
+      @token_id = object_id
+      @hash = orig_hash
+    end
+
+    def eql?(o)
+      @token_id == o.token_id
+    rescue # faster then checking for instance_of?
+      false
+    end
+
+    def to_hash
+      { val: value }
+    end
+
+    alias == eql?
+
+  end
+
+end

data/lib/fast-tcpn/transition.rb

@@ -0,0 +1,224 @@
+module FastTCPN
+
+  class OutputArc
+    attr_reader :place, :block
+    # the +block+ will be given actual binding and
+    # must return token that should be put in the
+    # +palce+
+    def initialize(place, block)
+      @place, @block = place, block
+    end
+  end
+
+  class TCPNBinding
+    TokenNotFound = Class.new RuntimeError
+
+    def initialize(mapping, marking_for)
+      @mapping, @marking_for = mapping, marking_for
+    end
+
+    def [](place_name)
+      token = @mapping[place_name]
+      if token.nil?
+        raise TokenNotFound.new("No mapping for place `#{place_name}`")
+      end
+      marking = @marking_for[place_name]
+      if marking.nil?
+        raise TokenNotFound.new("No marking for place `#{place_name}`")
+      end
+      if token.instance_of? Array
+        token.map { |t| get_new_token marking, t }
+      else
+        get_new_token marking, token
+      end
+    end
+
+    private
+
+    def get_new_token(marking, token)
+      new_token = marking.get token
+      if new_token.nil?
+        raise TokenNotFound.new("There was no `#{token.inspect}` in `#{marking.inspect}`!")
+      end
+      new_token
+    end
+  end
+
+  # This is implementation of TCPN transition.
+  # It has input and output places and it can be fired.
+  class Transition
+    InvalidToken = Class.new RuntimeError
+
+    class FiringError < RuntimeError
+      attr_reader :cause, :transition
+
+      def initialize(transition, cause)
+        @transition, @cause = transition, cause
+        set_backtrace @cause.backtrace
+      end
+
+      def inspect
+        "<#{self.class} #{@cause.inspect} in transition `#{@transition.name}`>"
+      end
+
+      def to_s
+        inspect
+      end
+    end
+
+    attr_reader :name
+
+    # Class passed to callback fired when a transition is fired.
+    # Describes details of the event that caused the callback to be fired.
+    Event = Struct.new(:transition, :binding, :clock, :tcpn)
+
+    # Create new Transition.
+    # +name+ identifies this transition
+    # +net+ is reference to TCPN object, required to enable callback handling.
+    def initialize(name, net = nil)
+      @name = name
+      @inputs = []
+      @outputs = []
+      @sentry = nil
+      @net = net
+    end
+
+    # Add input arc from the +place+.
+    # No inscription currently possible,
+    # one token will be taken from the +place+
+    # each time the transition is fired.
+    def input(place)
+      raise "This is not a Place object!" unless place.kind_of? Place
+      @inputs << place
+    end
+
+    # Add output arc to the +place+.
+    # +block+ is the arc's expresstion, it will be called while firing
+    # transition. Value returned from the block will be put in output 
+    # place. The block gets +binding+, and +clock+ values. +binding+ is
+    # a hash with names of input places as keys nad tokens as values.
+    def output(place, &block)
+      raise "This is not a Place object!" unless place.kind_of? Place
+      raise "Tried to define output arc without expression! Block is required!" unless block_given?
+      @outputs << OutputArc.new(place, block)
+    end
+
+    # Define sentry for this transition as a block.
+    # The block gets three parameters: +marking_for+, +clock+ and +result+.
+    # +marking_for+ is a hash with input place names as keys and marking objects
+    # as values. Thus one can iterate over tokens from specified input places. 
+    # This block is supposed to push a hash of valid binding to the result like this:
+    #          result << { output_place_name1 => token, output_place_name2 => token2 }
+    def sentry(&block)
+      @sentry = block
+    end
+
+    # fire this transition if possible
+    # returns true if fired false otherwise
+    def fire(clock = 0)
+
+      # Marking is shuffled each time before it is
+      # used so here we can take first found binding
+      mapping = Enumerator.new do |y|
+                  get_sentry.call(input_markings, clock, y)
+                end.first
+
+      return false if mapping.nil?
+
+      tcpn_binding = TCPNBinding.new mapping, input_markings
+
+      call_callbacks :before, Event.new(@name, tcpn_binding, clock, @net)
+
+      tokens_for_outputs = @outputs.map do |o|
+        o.block.call(tcpn_binding, clock)
+      end
+
+      mapping.each do |place_name, token|
+        unless token.kind_of? Token
+          t = if token.instance_of? Array
+                token
+              else
+                [ token ]
+              end
+          t.each do |t|
+            unless t.kind_of? Token
+              raise InvalidToken.new("#{t.inspect} put by sentry for transition `#{name}` in binding for `#{place_name}`")
+            end
+          end
+        end
+        deleted = find_input(place_name).delete(token)
+        if deleted.nil?
+          raise InvalidToken.new("#{token.inspect} put by sentry for transition `#{name}` does not exists in `#{place_name}`")
+        end
+      end
+
+      @outputs.each do |o|
+        token = tokens_for_outputs.shift
+        o.place.add token unless token.nil?
+      end
+
+      call_callbacks :after, Event.new(@name, mapping, clock, @net)
+
+      true
+    rescue InvalidToken
+      raise
+    rescue RuntimeError => e
+      raise FiringError.new(self, e)
+    end
+
+    # Returns true if no custom sentry was defined for this transition.
+    def default_sentry?
+      @sentry.nil?
+    end
+
+    # Number of input places
+    def inputs_size
+      @inputs.size
+    end
+
+    # Number of output places
+    def outputs_size
+      @outputs.size
+    end
+
+    private
+
+    def get_sentry
+      @sentry || default_sentry
+    end
+
+    def call_callbacks(event, event_object)
+      return if @net.nil?
+      @net.call_callbacks(:transition, event, event_object)
+    end
+
+    def input_markings
+      bnd = {}
+      @inputs.each do |place|
+        bnd[place.name] = place.marking
+      end
+      bnd
+    end
+
+    def find_input(name)
+      @inputs.each do |place|
+        return place if place.name == name
+      end
+      nil
+    end
+
+    def default_sentry
+      proc do |marking_for, clock, result|
+        mapping = marking_for.map do |place, marking|
+          break nil if marking.first.nil?
+          { place => marking.first }
+        end
+        unless mapping.nil?
+          result << mapping.compact.reduce(:merge)
+        end
+      end
+    end
+  end
+
+end
+

data/lib/fast-tcpn/version.rb

@@ -0,0 +1,3 @@
+module FastTCPN
+  VERSION = '0.0.5'
+end

data/spec/callbacks_spec.rb

@@ -0,0 +1,164 @@
+require 'spec_helper'
+
+describe FastTCPN::TCPN do
+  describe "callback" do
+    let :tcpn do
+      m = FastTCPN::TCPN.new
+      p1 = m.timed_place 'input'
+      p2 = m.place 'output'
+      t = m.transition 'send'
+      t.input p1
+      t.output p2 do |binding, clock|
+        binding['input']
+      end
+      p1.add :data_package, 100
+      m
+    end
+
+    describe "for transition" do
+      shared_examples "calls callbacks" do
+        it "is called when transition is fired" do
+          count = 0
+          tcpn.cb_for :transition, tag do |tag, event|
+            expect(event.binding['input'].value).to eq :data_package
+            expect(event.transition).to eq 'send'
+            expect(event.clock).to eq 100
+            count += 1
+          end
+          tcpn.sim
+          expect(count).to eq expected_count
+        end
+      end
+      describe "without tag" do
+        let(:expected_count) { 2 }
+        let(:tag) { }
+        include_examples "calls callbacks"
+      end
+
+      describe "with :before tag" do
+        let(:expected_count) { 1 }
+        let(:tag) { :before }
+        include_examples "calls callbacks"
+      end
+
+      describe "with :after tag" do
+        let(:expected_count) { 1 }
+        let(:tag) { :after }
+        include_examples "calls callbacks"
+      end
+
+    end
+
+    describe "for place" do
+      it "is called when token is removed" do
+        called = 0
+        tcpn.cb_for :place, :remove do |tag, event|
+          expect(tag).to eq :remove
+          expect(event.place).to eq 'input'
+          expect(event.clock).to eq 100
+          expect(event.tokens.first.value).to eq :data_package
+          called += 1
+        end
+        tcpn.sim
+        expect(called).to eq 1
+      end
+
+      it "is called when token is added" do
+        called = 0
+        tcpn.cb_for :place, :add do |tag, event|
+          expect(tag).to eq :add
+          expect(event.place).to eq 'output'
+          expect(event.clock).to eq nil # this place is not timed!
+          called += 1
+        end
+        tcpn.sim
+        expect(called).to eq 1
+      end
+
+      context "when token Array is added or removed" do
+        let :tcpn do
+          m = FastTCPN::TCPN.new
+          p1 = m.timed_place 'input'
+          p2 = m.place 'output'
+          t = m.transition 'send'
+          t.input p1
+          t.output p2 do |binding, clock|
+            binding['input']
+          end
+          t.sentry do |marking_for, clock, result|
+            unless marking_for[p1.name].empty?
+              tokens = marking_for[p1.name].to_a
+              result << { p1.name => tokens }
+            end
+          end
+          p1.add :data_package1, 100
+          p1.add :data_package2, 100
+          m
+        end
+
+        it "passes token array when it is added" do
+          called = 0
+          tcpn.cb_for :place, :add do |tag, event|
+            expect(tag).to eq :add
+            expect(event.place).to eq 'output'
+            expect(event.tokens.map{ |t| t.value }).to match_array [ :data_package1, :data_package2 ]
+            called += 1
+          end
+          tcpn.sim
+          expect(called).to eq 1
+        end
+        it "passes token array when it is removed" do
+          called = 0
+          tcpn.cb_for :place, :remove do |tag, event|
+            expect(tag).to eq :remove
+            expect(event.place).to eq 'input'
+            expect(event.clock).to eq 100
+            expect(event.tokens.map{ |t| t.value }).to match_array [ :data_package1, :data_package2 ]
+            called += 1
+          end
+          tcpn.sim
+          expect(called).to eq 1
+        end
+      end
+    end
+
+    describe "for clock" do
+
+      let :tcpn do
+        m = FastTCPN::TCPN.new
+        p1 = m.timed_place 'input'
+        p2 = m.place 'output'
+        t = m.transition 'send'
+        t.input p1
+        t.output p2 do |binding, clock|
+          binding['input']
+        end
+        p1.add :data_package, 100
+        m
+      end
+
+      it "is called before clock is changed" do
+        called = 0
+        tcpn.cb_for :clock, :before do |tag, event|
+          expect(tag).to eq :before
+          expect(event.clock).to eq(0) if called == 0
+          called += 1
+        end
+        tcpn.sim
+        expect(called).to be > 1
+      end
+
+      it "is called after clock is changed" do
+        called = 0
+        tcpn.cb_for :clock, :after do |tag, event|
+          expect(tag).to eq :after
+          expect(event.clock).to eq 100
+          expect(event.previous_clock).to eq 0
+          called += 1
+        end
+        tcpn.sim
+        expect(called).to eq 1
+      end
+    end
+  end
+end