spnet 0.1.4 → 0.1.5

data/lib/spnet/limiters/upper_limiter.rb

@@ -0,0 +1,31 @@
+module SPNet
+# Keeps values at or below the given Limit.
+#
+# @author James Tunnell
+class UpperLimiter < Limiter
+  attr_reader :limit, :inclusive
+  
+  def initialize limit, inclusive
+    @limit = limit
+    @inclusive = inclusive
+  end
+
+  # Limit the given value to be at or below @limit. Ignores the current_value parameter.
+  def apply_limit value, current_value = nil
+    if inclusive
+      if value <= @limit
+        return value
+      else
+        return @limit
+      end
+    else
+      if value < @limit
+        return value
+      else
+        return @limit - Float::EPSILON
+      end
+    end
+  end
+end
+
+end

data/lib/spnet/ports/command_in_port.rb

@@ -1,25 +1,33 @@
-require 'hashmake'
-
 module SPNet
+
+# Provides a means to list and execute commands in a Block object.
+#
+# @author James Tunnell
 class CommandInPort < InPort
   
   include Hashmake::HashMakeable
 
-  ARG_SPECS = [
-    Hashmake::ArgSpec.new(:key => :command_map, :reqd => true, :type => Proc, :container => Hashmake::ArgSpec::CONTAINER_HASH),
-  ]
+  # Define arg specs to use in processing hashed arguments during #initialize.
+  ARG_SPECS = {
+    :command_map => arg_spec_hash(:reqd => true, :type => Proc, :validator => ->(a){a.arity == 1}),
+  }
 
+  # A new instance of CommandInPort.
+  # @param [Hash] hashed_args Hashed arguments for initialization. See Network::ARG_SPECS
+  #                    for details.
   def initialize hashed_args
-    hash_make(CommandInPort::ARG_SPECS, hashed_args)
-    hashed_args.merge!(:matching_port_class => CommandOutPort)
-    super(hashed_args)
+    hash_make CommandInPort::ARG_SPECS, hashed_args
+    super(:matching_class => CommandOutPort)
   end
   
+  # List the commands that are available.
   def list_commands
     @command_map.keys
   end
   
+  # Execute a command with the given data (nil by default).
   def exec_command command, data
+    raise "Command #{command} not found in command list" unless @command_map.has_key?(command)
     @command_map[command].call data
   end  
 end

data/lib/spnet/ports/command_out_port.rb

@@ -1,25 +1,31 @@
 module SPNet
+
+# Execute commands for a connected CommandInPort object.
+#
+# @author James Tunnell
 class CommandOutPort < OutPort
 
-  def initialize hashed_args = {}
-    hashed_args.merge!(:matching_port_class => CommandInPort)
-    super(hashed_args)
+  # A new instance of CommandOutPort.
+  def initialize
+    super(:matching_class => CommandInPort)
   end
   
+  # If linked, return the result of calling the connected CommandInPort object's
+  # list_commands method. Otherwise, return false.
   def list_commands
-    rvs = []
-    @links.each do |link|
-      rvs.push link.list_commands
+    unless @link.nil?
+      return @link.to.list_commands
     end
-    return rvs
+    return false
   end
 
+  # If linked, return the result of calling the connected CommandInPort object's
+  # exec_command method. Otherwise, return false.
   def exec_command command, data = nil
-    rvs = []
-    @links.each do |link|
-      rvs.push link.exec_command(command, data)
+    unless @link.nil?
+      return @link.to.exec_command(command, data)
     end
-    return rvs
+    return false
   end
 
 end

data/lib/spnet/ports/param_in_port.rb

@@ -0,0 +1,42 @@
+module SPNet
+
+# Provides a means to get/set a parameter value in a Block object.
+#
+# @author James Tunnell
+class ParamInPort < InPort
+  
+  include Hashmake::HashMakeable
+
+  # Define arg specs to use in processing hashed arguments during #initialize.
+  ARG_SPECS = {
+    :limiter => arg_spec(:reqd => false, :type => Limiter, :default => ->(){ NoLimiter.new } ),
+    :get_value_handler => arg_spec(:reqd => true, :type => Proc, :validator => ->(p){ p.arity == 0 }),
+    :set_value_handler => arg_spec(:reqd => true, :type => Proc, :validator => ->(p){ p.arity == 1 })
+  }
+
+  attr_reader :limiter
+  
+  # A new instance of ParamInPort.
+  # @param [Hash] hashed_args Hashed arguments for initialization. See Network::ARG_SPECS
+  #                    for details.
+  def initialize hashed_args = {}
+    hash_make ParamInPort::ARG_SPECS, hashed_args
+    @skip_limiting = @limiter.is_a?(NoLimiter)
+    
+    super(:matching_class => ParamOutPort)
+  end
+  
+  # Set the parameter to the given value.
+  def set_value value
+    unless @skip_limiting
+      value = @limiter.apply_limit value, get_value
+    end
+    @set_value_handler.call value
+  end
+  
+  # Get the parameter's current value.
+  def get_value
+    @get_value_handler.call
+  end
+end
+end

data/lib/spnet/ports/param_out_port.rb

@@ -0,0 +1,32 @@
+module SPNet
+
+# Output value to a connected ParamInPort object.
+#
+# @author James Tunnell
+class ParamOutPort < OutPort
+
+  # A new instance of ParamOutPort.
+  def initialize
+    super(:matching_class => ParamInPort)
+  end
+  
+  # If linked, return the result of calling the connected ParamInPort object's
+  # set_value method. Otherwise, return false.
+  def set_value value
+    if linked?
+      return @link.to.set_value value
+    end
+    return false
+  end
+
+  # If linked, return the result of calling the connected ParamInPort object's
+  # get_value method. Otherwise, return false.
+  def get_value
+    if linked?
+      return @link.to.get_value
+    end
+    return false
+  end
+
+end
+end

data/lib/spnet/ports/signal_in_port.rb

@@ -1,39 +1,44 @@
-require 'hashmake'
-require 'spcore'
-
 module SPNet
+
+# Recieves signal input for processing in a Block object.
+#
+# @author James Tunnell
 class SignalInPort < InPort
 
   include Hashmake::HashMakeable
   
-  DEFAULT_LIMITS = (-Float::MAX..Float::MAX)
+  # Define arg specs to use in processing hashed arguments during #initialize.  
+  ARG_SPECS = {
+    :limiter => arg_spec(:reqd => false, :type => Limiter, :default => ->(){ NoLimiter.new }, :validator => ->(a){ !a.is_a?(EnumLimiter) }),
+  }
   
-  ARG_SPECS = [
-    Hashmake::ArgSpec.new(:reqd => false, :key => :limits, :type => Range, :default => DEFAULT_LIMITS)
-  ]
-  
-  attr_reader :limits, :queue
+  attr_reader :limiter, :queue
 
+  # A new instance of SignalInPort.
+  # @param [Hash] hashed_args Hashed arguments for initialization. See Network::ARG_SPECS
+  #                    for details.
   def initialize hashed_args = {}
-    hash_make(SignalInPort::ARG_SPECS, hashed_args)
+    hash_make SignalInPort::ARG_SPECS, hashed_args
+    
     @queue = []
-    @skip_limiting = (@limits == DEFAULT_LIMITS)
-    @limiter = SPCore::Limiters.make_range_limiter @limits
+    @skip_limiting = @limiter.is_a?(NoLimiter)
 
-    hashed_args.merge!(:matching_port_class => SignalOutPort)
-    super(hashed_args)
+    super(:matching_class => SignalOutPort)
   end
 
+  # Add values to queue.
   def enqueue_values values
     unless @skip_limiting
       for i in 0...values.count
-        values[i] = @limiter.call(values[i])
+        values[i] = @limiter.apply_limit values[i]
       end
     end
     
     @queue.concat values
   end
   
+  # Remove values to queue.
+  # @param [Fixnum] count Number of values to remove.
   def dequeue_values count = @queue.count
     raise ArgumentError, "count is greater than @queue.count" if count > @queue.count
     @queue.slice!(0...count)

data/lib/spnet/ports/signal_out_port.rb

@@ -1,17 +1,22 @@
-require 'set'
-
 module SPNet
+
+# Output signal values to a connected SignalInPort object.
+#
+# @author James Tunnell
 class SignalOutPort < OutPort
 
-  def initialize hashed_args = {}
-    hashed_args.merge!(:matching_port_class => SignalInPort)
-    super(hashed_args)
+  # A new instance of SignalOutPort.
+  def initialize
+    super(:matching_class => SignalInPort)
   end
   
+  # If linked, return the result of calling the connected SignalInPort object's
+  # enqueue_values method. Otherwise, return false.
   def send_values values
-    @links.each do |link|
-      link.enqueue_values values
+    if linked?
+      @link.to.enqueue_values values
     end
+    return false
   end
 
 end

data/lib/spnet/storage/block_state.rb

@@ -0,0 +1,41 @@
+module SPNet
+
+# Represent a Block object using only serializeable objects.
+#
+# @author James Tunnell
+class BlockState
+  include Hashmake::HashMakeable
+
+  # Define arg specs to use in processing hashed arguments during #initialize.  
+  ARG_SPECS = {
+    :class_sym => arg_spec(:reqd => true, :type => Symbol),
+    :port_params => arg_spec_hash(:reqd => false, :type => Object)
+  }
+  
+  attr_reader :class_sym, :hashed_args, :port_params
+  
+  # A new instance of NetworkState. 
+  # @param [Hash] args Hashed arguments for initialization. See Network::ARG_SPECS
+  #                    for details of which keys are required.
+  def initialize args
+    hash_make BlockState::ARG_SPECS, args
+  end
+  
+  # Produce a Block object from the current BlockState object.
+  def make_block args
+    raise ArgumentError, "args does not have :sample_rate key" unless args.has_key?(:sample_rate)
+    
+    klass = Kernel.const_get(@class_sym)
+    block = klass.new :sample_rate => args[:sample_rate]
+    
+    @port_params.each do |port_name,value|
+      if block.in_ports.has_key?(port_name)
+        port = block.in_ports[port_name]
+        port.set_value value
+      end
+    end
+    
+    return block
+  end
+end
+end

data/lib/spnet/storage/link_state.rb

@@ -0,0 +1,38 @@
+module SPNet
+
+# Represent a Link object using only serializeable objects.
+#
+# @author James Tunnell
+class LinkState
+  include Hashmake::HashMakeable
+
+  # Define arg specs to use in processing hashed arguments during #initialize.  
+  ARG_SPECS = {
+    :from => arg_spec(:reqd => true, :type => PortLocater),
+    :to => arg_spec(:reqd => true, :type => PortLocater)
+  }
+  
+  attr_reader :from, :to
+  
+  def initialize args
+    hash_make ARG_SPECS, args
+  end
+
+  # Make a Link objet from the current LinkState object.  
+  def make_link blocks
+    raise "from block #{@from.block_name} not found" unless blocks.has_key?(@from.block_name)
+    raise "to block #{@to.block_name} not found" unless blocks.has_key?(@to.block_name)
+    
+    from_block = blocks[@from.block_name]
+    to_block = blocks[@to.block_name]
+    
+    raise "from port #{@from.port_name} not found" unless from_block.out_ports.has_key?(@from.port_name)
+    raise "to port #{@to.port_name} not found" unless to_block.in_ports.has_key?(@to.port_name)
+    
+    from_port = from_block.out_ports[@from.port_name]
+    to_port = to_block.in_ports[@to.port_name]
+    
+    return Link.new(:from => from_port, :to => to_port)
+  end
+end
+end

data/lib/spnet/storage/network_state.rb

@@ -0,0 +1,44 @@
+module SPNet
+
+# Represents a Network object using only serializeable objects.
+#
+# @author James Tunnell
+class NetworkState
+  include Hashmake::HashMakeable
+
+  # Define arg specs to use in processing hashed arguments during #initialize.  
+  ARG_SPECS = {
+    :name => arg_spec(:reqd => false, :type => String, :default => ""),
+    :block_states => arg_spec_hash(:reqd => false, :type => BlockState),
+    :link_states => arg_spec_array(:reqd => false, :type => LinkState),
+  }
+  
+  attr_reader :sample_rate, :name, :block_models, :link_models
+  
+  # A new instance of NetworkState. 
+  # @param [Hash] args Hashed arguments for initialization. See Network::ARG_SPECS
+  #                    for details of which keys are required.
+  def initialize args = {}
+    hash_make NetworkState::ARG_SPECS, args
+  end
+  
+  # Produce a Network object from the current NetworkState object.
+  # @param [Hash] args Hashed arguments. The only key required is :sample_rate.
+  def make_network args
+    raise ArgumentError, "args does not have :sample_rate key" unless args.has_key?(:sample_rate)
+    sample_rate = args[:sample_rate]
+    
+    blocks = {}
+    @block_states.each do |block_name, block_state|
+      blocks[block_name] = block_state.make_block :sample_rate => sample_rate
+    end
+    
+    links = []
+    @link_states.each do |link_state|
+      links.push link_state.make_link blocks
+    end
+    
+    Network.new :name => @name, :blocks => blocks, :links => links, :sample_rate => sample_rate
+  end
+end
+end

data/lib/spnet/storage/port_locater.rb

@@ -0,0 +1,21 @@
+module SPNet
+
+# Locate a port based on the block and port name, rather than an object reference.
+#
+# @author James Tunnell
+class PortLocater
+  include Hashmake::HashMakeable
+  
+  # Define arg specs to use in processing hashed arguments during #initialize.
+  ARG_SPECS = {
+    :block_name => arg_spec(:reqd => true, :type => String),
+    :port_name => arg_spec(:reqd => true, :type => String),
+  }
+  
+  attr_reader :block_name, :port_name
+  
+  def initialize args
+    hash_make ARG_SPECS, args
+  end
+end
+end

data/lib/spnet/version.rb

@@ -1,4 +1,5 @@
+# Provide infrastructure for forming processing networks.
 module SPNet
   # spnet version
-  VERSION = "0.1.4"
+  VERSION = "0.1.5"
 end

data/spec/core/block_spec.rb

@@ -0,0 +1,80 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe SPNet::Block do
+  before :all do
+    @sample_rate = 1.0
+  end
+  
+  context '.new' do
+    context 'no I/O ports given' do
+      before :all do
+        @block = SPNet::Block.new :sample_rate => @sample_rate, :algorithm => ->(a){}
+      end
+      
+      it 'should have no input ports' do
+        @block.in_ports.should be_empty
+      end
+  
+      it 'should have no output ports' do
+        @block.out_ports.should be_empty
+      end
+    end
+    
+    context '1 in and 1 out port given' do
+      before :all do
+        @block = SPNet::Block.new(
+          :sample_rate => @sample_rate, :algorithm => ->(a){},
+          :in_ports => { "IN" => SPNet::SignalInPort.new }, :out_ports => { "OUT" => SPNet::SignalOutPort.new },
+        )
+      end
+      
+      it 'should have 1 input port' do
+        @block.in_ports.count.should be 1
+        @block.in_ports.has_key?("IN")
+      end
+  
+      it 'should have 1 output port' do
+        @block.out_ports.count.should be 1
+        @block.out_ports.has_key?("OUT")
+      end      
+    end
+  end
+
+  context '#sample_rate' do
+    it 'should return the given sample_rate' do
+      block = TestBlock.new :sample_rate => @sample_rate
+      block.sample_rate.should eq(@sample_rate)
+    end
+  end
+    
+  context '#step' do
+    it 'should exercise the given algorithm, passing the count' do
+      block = TestBlock.new :sample_rate => @sample_rate
+      collector = SignalInPort.new
+      link = Link.new(:from => block.out_ports["OUT"], :to => collector)
+      link.activate
+      block.in_ports["IN"].enqueue_values [1,3,5]
+      block.step 1
+      collector.dequeue_values(1).should eq([1])
+      block.step 2
+      collector.dequeue_values(2).should eq([3,5])
+    end
+  end
+  
+  context '#export_state' do
+    before :all do
+      block = TestBlock.new :sample_rate => @sample_rate
+      block.in_ports["VALUE1"].set_value(4.4)
+      block.in_ports["VALUE2"].set_value(5.5)
+      @state = block.export_state
+    end
+
+    it 'should set class_sym to :Block' do
+      @state.class_sym.should eq(:TestBlock)
+    end
+
+    it 'should set port_params according to ParamInPort settings' do
+      @state.port_params.should eq("VALUE1" => 4.4, "VALUE2" => 5.5)
+    end
+  end
+end