fast-tcpn 0.0.5

data/lib/fast-tcpn/hash_marking.rb

@@ -0,0 +1,220 @@
+class Array
+
+  # This will slow down with time -- the more
+  # times we yield, the harder will be to hit
+  # an unused value. So use standerd shuffle
+  # if you need significant amount of values
+  # shuffled. But if you need just a few, this
+  # one is faster ;-)
+  def lazy_shuffle
+    return enum_for(:lazy_shuffle) unless block_given?
+    was = {}
+    self.size.times do
+      i = 0
+      begin
+        i = rand self.size
+      end while was.has_key?(i)
+      was[i] = true
+      yield self[i]
+    end
+  end
+end
+
+module FastTCPN
+
+  class HashMarking
+
+    include Clone
+
+
+    InvalidToken = Class.new RuntimeError
+    InvalidKey = Class.new RuntimeError
+    CannotAddKeys = Class.new RuntimeError
+
+    include Enumerable
+
+    attr_reader :keys
+
+    # Creates new HashMarking with specified keys. At least
+    # one key must be specified. The keys are used to
+    # store tokens in Hashes -- one hash for each key. Thus
+    # finding tokens by the keys is fast.
+    #
+    # +keys+ is a hash of the form: { key_name => method }, where +key_name+ is a name that
+    # will be used to access tokens indexed by this key and +method+ is a method that should
+    # be called on token's value to get value that should be used group tokens indexed by this key.
+    def initialize(keys = {})
+      @keys = keys
+      @lists = {}
+      @global_list = {}
+    end
+
+    # Allows to iterate over all values in marking or over all values for which
+    # specified +key+ has specified +value+. If no block is given, returns adequate
+    # Enumerator. Yielded values are deep-cloned so you can use them without fear of
+    # interfering with TCPN simulation.
+    #
+    # Values are yielded in random order -- each time each is called with block
+    # or a new Enumerator is created, the order is changed. Thus tokens are selection 
+    # is `in some sense fair`. Current implementation assumes, that in most cases iteration
+    # will finish quickly, without yielding large number of tokens. In such cases the 
+    # shuffling algorithm is efficient. But if for some reason most tokens from marking
+    # should be yielded, it will be less and less efficient, with every nxt token. In this
+    # case one should consider using standard +shuffle+ method here instead of +lazy_shuffle+.
+    def each(key = nil, value = nil)
+      return enum_for(:each, key, value) unless block_given?
+      return if empty?
+      list_for(key, value).lazy_shuffle do |token|
+        yield clone token
+      end
+    end
+
+    # Add new keys to this marking. This list will be merged with exisiting keys.
+    # Adding keys is possible only if marking is empty, otherwise CannotAddKeys 
+    # exception will be raised.
+    def add_keys(keys)
+      unless empty?
+        raise CannotAddKeys.new("marking not empty!");
+      end
+      @keys.merge!(keys)
+    end
+
+    # True if the marking is empty.
+    def empty?
+      size == 0
+    end
+
+    # Creates new token of the +object+ and adds it to the marking.
+    # Objects added to the marking are deep-cloned, so you can use them
+    # without fear to interfere with TCPN simulation. But have it in mind!
+    # If you put a large object with a lot of references in the marking,
+    # it will significanntly slow down simulation and increase memory usage.
+    def add(objects)
+      unless objects.kind_of? Array
+        objects = [ objects ]
+      end
+      objects.each do |object|
+        value = object
+        if object.instance_of? Hash
+          value = object[:val]
+        end
+        add_token prepare_token(value)
+      end
+    end
+
+    alias << add
+
+    # Deletes the +token+ from the marking.
+    # To do it you must first find the token in
+    # the marking.
+    def delete(tokens)
+      unless tokens.instance_of? Array
+        tokens = [ tokens ]
+      end
+      removed = tokens.map do |token|
+        validate_token!(token)
+        delete_token(token)
+      end
+      if removed.size == 1
+        removed.first
+      else
+        removed
+      end
+    end
+
+    # Returns number of tokens in this marking
+    def size
+      @global_list.size
+    end
+
+    # :nodoc:
+    # Return fresh, unaltered clone of given token
+    # The given token's value could have been changed when it was
+    # passed to a user-defined code. Use this method to refresh this value.
+    # Will work as long as user interfered with token value, but not with
+    # the token object iself.
+    #
+    # For internal use, while firing transition
+    def get(token)
+      clone @global_list[token]
+    end
+
+    # reimplement if inherited classes need different one
+    def token_type
+      Token
+    end
+
+    private
+
+    def tokens_by_key(key_name, value)
+      unless @keys.has_key? key_name
+        raise InvalidKey.new(key_name)
+      end
+      @lists[key_name][value]
+    end
+
+    def each_key_with(token)
+      @keys.each do |name, method_with_params|
+        params = nil
+        method = method_with_params
+        if method_with_params.instance_of? Array
+          method = method_with_params.first
+          params = method_with_params[1..-1]
+        end
+        unless token.value.respond_to? method
+          raise InvalidToken.new("#{token.inspect} does not respond to #{method.inspect}")
+        end
+        value = token.value.send(method, *params)
+        yield name, value
+      end
+    end
+
+    def prepare_token(object)
+      if object.instance_of? token_type
+        clone object
+      elsif object.kind_of? token_type
+        token_type.new clone(object.value)
+      else
+        token_type.new clone(object)
+      end
+    end
+
+    def add_token(token)
+      @global_list[token] = token
+      each_key_with(token) do |key_name, value|
+        @lists[key_name] ||= {}
+        @lists[key_name][value] ||= []
+        @lists[key_name][value] << token
+      end
+    end
+
+    def validate_token!(token)
+      unless token.instance_of? token_type
+        raise InvalidToken.new "#{token} is not a #{token_type} object!"
+      end
+    end
+
+    def delete_token(token)
+      return nil unless @global_list.delete token
+      each_key_with(token) do |key_name, value|
+        next unless @lists.has_key? key_name
+        next unless @lists[key_name].has_key? value
+        @lists[key_name][value].delete token
+      end
+      token
+    end
+
+    def list_for(key, value)
+      list = if !key.nil? && !value.nil?
+        tokens_by_key key, value
+      else
+        @global_list.keys
+      end
+      if list.nil?
+        list = []
+      end
+      list
+    end
+  end
+
+end

data/lib/fast-tcpn/place.rb

@@ -0,0 +1,70 @@
+module FastTCPN
+
+  # This class imlements standard place of CPN model.
+  # Marking reprezented as HashMarking object with
+  # specified keys (see #new and #add_keys)
+  #
+  # It supports neither time nor timed tokens!
+  class Place
+
+    # Class passed to callback fired when tokens are added and/or removed from places.
+    # Describes details of the event that caused the callback to be fired.
+    Event = Struct.new(:place, :tokens, :clock, :tcpn) do
+      def initialize(*)
+        super
+        unless self.tokens.instance_of? Array
+          self.tokens = [ self.tokens ]
+        end
+      end
+    end
+
+    attr_reader :name
+
+    # Create new Place object.
+    # +name+ is unique identifier of this place
+    # +keys+ are token keys used to quickly find tokens in marking (see HashMarking)
+    # +net+ is reference to TCPN object, required to support callbacks
+    def initialize(name, keys = {}, net = nil)
+      @name = name
+      @marking = HashMarking.new keys
+      @net = net
+    end
+
+    # Return reference this place's marking.
+    # If you modify marking using this reference, no
+    # callbacks defined for places will be fired!
+    def marking
+      @marking
+    end
+
+    # Removes +token+ from this place
+    # Callbacks defined for places will be fired
+    def delete(token)
+      @net.call_callbacks(:place, :remove, Event.new(@name, token, @clock, @net)) unless @net.nil?
+      @marking.delete token
+    end
+
+    # Add +token+ to this place
+    # Callbacks defined for places will be fired
+    def add(token)
+      @net.call_callbacks(:place, :add, Event.new(@name, token, @clock, @net)) unless @net.nil?
+      @marking.add token
+    end
+
+    # Add keys that will be used to store and quickly find tokens in this place's marking.
+    # see HashMarking for more info.
+    def add_keys(keys)
+      @marking.add_keys keys
+    end
+
+    # returns keys used to store and access tokens in this place.
+    def keys
+      @marking.keys
+    end
+
+    def inspect
+      "<#{self.class} name: #{name.inspect}>"
+    end
+  end
+
+end

data/lib/fast-tcpn/tcpn.rb

@@ -0,0 +1,288 @@
+module FastTCPN
+
+  # This class represents TCPN model: places, transitions, arcs
+  class TCPN
+
+    PlaceTypeDoesNotMach = Class.new RuntimeError
+    InvalidCallback = Class.new RuntimeError
+    StopSimulation = Class.new RuntimeError
+
+    class SimulationError < RuntimeError
+      def initialize(cause)
+        @cause = cause
+        set_backtrace @cause.backtrace
+        set_dir
+      end
+
+      alias full_backtrace backtrace
+
+      def backtrace
+        return full_backtrace if @dir.nil?
+        return full_backtrace if FastTCPN.debug
+        full_backtrace.select { |b| b !~ /#{@dir}/ }
+      end
+
+      def inspect
+        "<#{self.class} #{@cause.inspect}>"
+      end
+
+      def message
+        "#{self.class}: #{@cause.message}"
+      end
+
+      private
+      def set_dir
+        @dir = __FILE__
+        @dir = File.dirname(@dir) while(File.basename(@dir) != 'lib' && !@dir.empty? && @dir != '/')
+        @dir = nil if @dir.empty? || @dir == '/'
+      end
+    end
+
+    ClockEvent = Struct.new(:clock, :previous_clock, :tcpn)
+
+    class Clock
+      # :nodoc:
+
+      def initialize
+        @value = 0
+      end
+
+      def set(value)
+        return false if value <= @value
+        @value = value
+        true
+      end
+
+      def get
+        @value
+      end
+
+    end
+
+    def initialize
+      @places = {}
+      @timed_places = {}
+      @transitions = []
+      @clock = Clock.new
+      @callbacks = {
+        transition: { before: [], after: [] },
+        place: { add: [], remove: [] },
+        clock: { before: [], after: [] }
+      }
+      @stopped = false
+    end
+
+    # Create and return new not timed place for this model.
+    #
+    # If a place with this
+    # name exists somewhere in the model (e.g. on other pages), and object
+    # representing exisiting place will be returned. Keys of both keys will
+    # be merged. For description of keys see doc for HashMarking.
+    def place(name, keys = {})
+      create_or_find_place(name, keys, Place)
+    end
+
+    # Create and return a new timed place for this model.
+    #
+    # If a place with this
+    # name exists somewhere in the model (e.g. on other pages), and object
+    # representing exisiting place will be returned. Keys of both keys will
+    # be merged. For description of keys see doc for HashMarking.
+    def timed_place(name, keys = {})
+      place = create_or_find_place(name, keys, TimedPlace)
+      @timed_places[place] = true
+      place
+    end
+
+    # Create and return new transition for this model.
+    # +name+ identifies transition in the net.
+    def transition(name)
+      t = find_transition name
+      if t.nil?
+        t = Transition.new name, self
+        @transitions << t
+      end
+      t
+    end
+
+    # Returns place with given name for this net.
+    def find_place(name)
+      @places[name]
+    end
+
+    # Returns transition with given name for this net.
+    def find_transition(name)
+      @transitions.select { |t| t.name == name }.first
+    end
+
+    # Number of places in this net.
+    def places_count
+      @places.size
+    end
+
+    # Number of transitions in this net.
+    def transitions_count
+      @transitions.size
+    end
+
+    # Starts simulation of this net.
+    def sim
+      @stopped = catch :stop_simulation do
+        begin
+          fired = fire_transitions
+          advanced = move_clock_to find_next_time
+        end while fired || advanced
+      end
+      @stopped = false if @stopped == nil
+    rescue StandardError => e
+      raise SimulationError.new(e)
+    end
+
+    alias run sim
+
+    # Returns current value of global simulation clock for this net.
+    def clock
+      @clock.get
+    end
+
+    # Defines new callback for this net.
+    # +what+ can be +:transition+, +:place+ or +:clock+.
+    # Transition callbacks are fired when transitions are fired, place
+    # callbacks when place marking changes, clock callbacks when clock is moved.
+    # +tag+ for transition and clock callback can be +:before+ or +:after+, for
+    # place, can be +:add+ or +:remove+. It defines when the callbacks fill be
+    # fired. If omitted, it will be called for both cases.
+    #
+    # Callback block for transition gets value of event +tag+ (:before or :after)
+    # FastTCPN::Transition::Event object.
+    #
+    # Callback block for place gets value of event +tag+ (:add or :remove)
+    # and FastTCPN::Place::Event object.
+    #
+    # Callback block for clock gets value of event +tag+ (:before or :after)
+    # and FastTCPN::TCPN::ClockEvent object.
+    def cb_for(what, tag = nil, &block)
+      if what == :transition
+        cb_for_transition tag, &block
+      elsif what == :place
+        cb_for_place tag, &block
+      elsif what == :clock
+        cb_for_clock tag, &block
+      else
+        raise InvalidCallback.new "Don't know how to add callback for #{what}"
+      end
+    end
+
+    # :nodoc:
+    # Calls callbacks, for internal use.
+    def call_callbacks(what, tag, *params)
+      @callbacks[what][tag].each do |block|
+        block.call tag, *params
+      end
+    end
+
+
+    # OLD API, derived from tcpn gem
+
+    # Return marking for specified place in a form of Hash:
+    # { val: token_value, ts: token_timestamp }
+    def marking_for(name)
+      find_place(name).marking.map { |t| t.to_hash }
+    end
+
+    def add_marking_for(name, m)
+      token = m
+      find_place(name).add token
+    end
+
+    # stop simulation now, no matter if there are any enabled transitions
+    def stop
+      # raise StopSimulation.new
+      throw :stop_simulation, true
+    end
+
+    # True if simulation was stopped using #stop method
+    def stopped?
+      @stopped
+    end
+
+    private
+
+    def cb_for_transition(tag, &block)
+      if tag == :before || tag.nil?
+        @callbacks[:transition][:before] << block
+      end
+      if tag == :after || tag.nil?
+        @callbacks[:transition][:after] << block
+      end
+    end
+
+    def cb_for_place(tag, &block)
+      if tag == :add || tag.nil?
+        @callbacks[:place][:add] << block
+      end
+      if tag == :remove || tag.nil?
+        @callbacks[:place][:remove] << block
+      end
+    end
+
+    def cb_for_clock(tag, &block)
+      if tag == :before || tag.nil?
+        @callbacks[:clock][:before] << block
+      end
+      if tag == :after || tag.nil?
+        @callbacks[:clock][:after] << block
+      end
+    end
+
+    def create_or_find_place(name, keys, type)
+      place = @places[name]
+      if place.nil?
+        place = type.new name, keys, self
+      else
+        unless type == place.class
+          raise PlaceTypeDoesNotMatch.new "You tried to create place #{name} of type #{type}, but it already exsists and has type #{place.class}"
+        end
+        place.add_keys keys
+      end
+      @places[name] = place
+    end
+
+    def move_clock_to(val)
+      previous_clock = @clock.get
+      call_callbacks(:clock, :before, ClockEvent.new(@clock.get, nil, @tcpn))
+      return false unless @clock.set val
+      @timed_places.each_key do |place|
+        place.time = val
+      end
+      call_callbacks(:clock, :after, ClockEvent.new(@clock.get, previous_clock, @tcpn))
+      true
+    end
+
+    def fire_transitions
+      fired_count = 0
+      begin
+        fired = false
+        @transitions.shuffle.each do |transition|
+          if transition.fire clock
+            fired_count += 1
+            fired = true
+          end
+        end
+      end while fired
+      fired_count > 0
+    end
+
+    def find_next_time
+      time = 0
+      @timed_places.each_key do |place|
+        next_time = place.next_time
+        if next_time > clock && (time == 0 || next_time < time)
+          time = next_time
+        end
+      end
+      time
+    end
+
+  end
+end