tla-sbuilder 0.2.2 → 0.3.4

data/lib/sbuilder/extension_loader_step_generator.rb

@@ -0,0 +1,876 @@
+# coding: utf-8
+module Sbuilder
+  #
+  # This module is used to generate paramter bindings for interface  operations
+  #
+  # API usage:
+  #
+  # step_generator = Sbuilder::StepGenerator.new
+  #
+  # step_generator.initParamSet( inputParamSet, validators )
+  # values = step_generator.values
+  # if values.nil?
+  #   puts "no value"
+  # else
+  #   values.each do {|value| puts value }
+  # end
+  #
+  # Data model:
+  # 
+  #
+  #               +----------------+
+  #               |                |<-----------------+
+  #               | Parameter set  |                  |
+  #               |                |                  |
+  #               +----------------+                  |
+  #                       |                           |
+  #                       |                           |
+  #               +-------*--------+                  |
+  #               |                |                  |
+  #               |    Parameter   |                  |
+  #               |                |                  |
+  #               +----------------+                  |
+  #                       A                           |
+  #                       |                           |
+  #          +------------+---------------+           |
+  #          |                            |           |
+  #          |                            |           |
+  #  +----------------+          +----------------+   |
+  #  |                |          |                |   |
+  #  | Domain paramate|          | Ref. parameter |---+
+  #  |                |          |                |
+  #  +----------------+          +----------------+
+  #          |
+  #          |
+  #  +----------------+
+  #  |                |
+  #  |    Domain      |
+  #  |                |
+  #  +----------------+
+  #
+  #
+  # - A parameter set is a composition of parameters.
+  # - A parameter is  domain parmeter or reference paramter.
+  # - Domain parmater reference domain (definin values for parameter)
+  # - Reference paramter refers to paramater set
+  # - A parameter definies 'name' property
+  # - A parameter definies 'isArray' property  
+  #
+  #
+  # Generating values (nextValue operation)
+  #
+  # - domain parameter: Cycle a pointer trough values in parameter
+  #   domain. Return false, when pointer cycles from last domain entry
+  #   to the first domain entry, else return true.
+
+  # - parameter set: iterate all parameters in the parameter set,
+  #   return 'true', when first parameter nextValue returns 'true',
+  #   return false if none of parameter nextValue operations return
+  #   'true'.
+  #
+  # - array parameter (for domain parameter and refernce parameter):
+  #   parameter domain is powerset of the underlying value range.
+  #
+  # - exceptions raised
+  #   -- when creating powerset for set with cardilality >= 6
+  #   -- when cardinality of reference set exceeds >= 100
+  #
+  # Input:
+  #
+  # 'validators' is an array of "rule", "rule_value", "action",
+  # "action_value" -properties. Property "rule" checks, whether "action"
+  # prorperty should be used screen domain values, when genarating
+  # value binding to paramters.
+  #
+  # Valid values for "rule" property are defined in RULES array. In
+  # this array, "rule" property is mapped to a lambda function
+  # returning boolean value. First "action", where "rule" lambda return
+  # true is applied, an error is raised if no valid "rule" is
+  # found. Optional property "rule_value" is passed to the lamdba
+  # function, along with parameter object, and the the path to the
+  # paramter in parameter set.
+  #
+  # Valid values for "action" property are defined in ACTIONS
+  # array. This array maps "action" property value to lambda function
+  # returning boolean, if given domain value should be used in value
+  # binding. Property "action_value" is passed to the lambda function,
+  # along with domain index, and domain value to check.
+  #
+  #
+
+  #
+
+  # module implementing '@validIndex' and '@validValues' array to
+  # return values.
+  #
+  # Class including this module must implement 'validValuesSet'
+
+  module StepGeneratorValue
+
+
+    # @attr [Integer] index array valid values
+    attr_accessor :validIndex
+
+    # ------------------------------------------------------------------
+    # @!group Public services
+
+    # Update 'memo' key 'parameterName' with current 'validValue'
+    #
+    # @param [Hash] memo hash where current 'validValue' gets updated
+    #
+    # @return [Boolean,Hash] true when valid value found, updated 'memo'
+    def currentValue( memo )
+      currentValue = validValue( validIndex )
+      memo[parameterName] = currentValue
+      return !currentValue.nil?, memo
+    end
+
+    # Advance '@validIndex' to point to next valid entry in
+    # '@validValue' -set.
+    #
+    # @return [Boolean] true is not wrapped around
+    def nextValue
+
+      self.validIndex= validIndex + 1
+
+        # loop until next valid value found (or wrapped around)
+        if validIndex >= validValueCount
+          # Wrapped around
+          self.validIndex= 0
+          return false
+        end
+
+        # not wrapped around
+        return true
+
+    end
+
+    # @!endgroup
+
+    # ------------------------------------------------------------------
+    # @!group Implement set of valid values
+
+    # @return [String] element in position 'indx' of 'validValues'
+    def validValue( indx )
+      validValues[indx]
+    end
+
+
+    # @return [Integer] number of domain elements passed 'action'
+    # validation
+    def validValueCount
+      validValues.length
+    end
+
+    # Return (cached ) set of valid values. For non isArray generator
+    # return 'validValuesSet', else (i.e. isArray = true ) return
+    # powerset( validValuesSet )
+    #
+    # @return [String:Array|Hash:Array] valid_values set for parameter
+    #
+    def validValues
+      return @validValues if @validValues
+
+      Sbuilder::StepGenerator.logger.info "#{__method__}, parameter=#{parameter.name}, isArray=#{isArray}, validValuesSet.length=#{validValuesSet.length}"
+
+      Sbuilder::StepGenerator.maxPowerSet( validValuesSet.length ) if isArray
+      @validValues = isArray ? Sbuilder::Powerset.powerset( validValuesSet ) : validValuesSet
+      
+      return @validValues
+    end
+
+    # @!endgroup
+
+
+  end # module StepGeneratorValue
+
+  # ------------------------------------------------------------------
+
+
+  class StepGenerator
+
+    PROGNAME = nil                        # progname for logger default class name
+    include Sbuilder::Utils::MyLogger     # mix logger
+
+
+    # check validator hash properties
+    @@validator_required = %w( rule action )
+    @@validator_allowed = %w( action_value rule_value )
+
+    # @attr [Sbuilder::ParamSet] paramSet initilized to generates values
+    attr_accessor  :paramSet
+
+    # @attr [StepGeneratorValueDomain:Array] generating value
+    attr_reader :domainValues
+
+    RULES = {
+      # triggers on all fields
+      'default' => -> (parameter, path, rule_value) { true },
+      # triiggers on field with 'path' matching 'rule_value'
+      'path' => -> (parameter, path, rule_value ) { path == rule_value },
+    }
+
+    ACTIONS = {
+      # all domain values are used in value binding, does not yield
+      # fixed value
+      'all' => {
+        :func => -> (index,domValue,validator_value) { true },
+        :fixedValue => false,
+      },
+      # no  domain values are used in value binding, fixed value (no values)
+      'none' => {
+        :func => -> (index,domValue,validator_value) { false },
+        :fixedValue => true,
+      },
+      # only domain value in "action_value" is used in value binding,
+      # fixed value (one domain element)
+      'domain' => {
+        :func => -> (index,domValue,validator_value) { index==validator_value },
+        :fixedValue => true,
+      },
+    }
+
+    # known rules have an entry here
+    #
+    # @options RULE_VALIDATION [Array] :required array of properties
+    # required in validator
+    #
+    # @options RULE_VALIDATION [Array] :allowed array of properties
+    # allowed in validator
+    #
+    # @options RULE_VALIDATION [Array] :advance lambda function to act
+    # on 'validator' when recurding down paramter sets
+    RULE_VALIDATION = {
+      'path' =>{
+        :required => %w( rule_value ),
+        :allowed => [],
+      },
+      'default' =>{
+        :required => [],
+        :allowed => [],
+      }
+    }
+
+    # known actions have an entry here
+    ACTION_VALIDATION = {
+      'domain' =>{
+        :required => %w( action_value ),
+        :allowed => []
+      },
+      'all' =>{
+        :required => [],
+        :allowed => [],
+      },
+      'none' =>{
+        :required => [],
+        :allowed => [],
+      }
+    }
+    
+
+
+    # ------------------------------------------------------------------
+    # @!group Constructor & build
+
+    def initialize( options = {} )
+      if !defined?(@@logger )
+        @@logger =getLogger( PROGNAME, options )
+      end
+      @@logger.info( "#{__method__} initialized, options=#{options}" )        
+    end
+
+    # Allow the one logger to be accessed via class method (within module)
+    def self.logger
+      @@logger
+    end
+
+    def isArray
+      paramSet.respond_to?( :isArray ) && paramSet.isArray
+
+    end
+
+    # Public service to associate step generator with parameter set,
+    # activate validator lamdb for each parameter in parameter set.
+    #
+    # @param [Sbuilder::ParamSet] initSet used to generate values
+    def initParamSet( initSet, validators=[ {"rule"=>'default', "action"=>'none'} ], parameter_path=[] )
+      # validator congiruation ok wrt initSet
+      validateValidators( initSet, validators )
+
+      # no path yet
+      parameter_path = []
+      startGenerator( initSet, validators, parameter_path )
+      
+    end
+
+    # Module internal service, which actually implemented 'initParamSet'
+    def startGenerator( initSet, validators, parameter_path )
+
+      Sbuilder::StepGenerator.logger.info "#{__method__}, parameter.length = #{initSet.parameters.length}, validators=#{validators.join(',')}"
+
+      self.paramSet= initSet
+
+      @domainValues = []
+      paramSet.parameters.each do |parameter|
+
+        case [parameter.class]
+        when [Sbuilder::Parameter_Dom]
+          validator, action_value, fixedValue = chooseValidator( parameter, validators, parameter_path )
+          domainValue = StepGeneratorValueDomain.new( parameter, validator, action_value, parameter_path, fixedValue  )
+          @domainValues << domainValue
+        when [Sbuilder::Parameter_Ref]
+          referenceValue = StepGeneratorValueRef.new( parameter, validators, parameter_path )
+          @domainValues << referenceValue
+        else
+          msg = "Unknown class #{parameter.class}"
+          Sbuilder::StepGenerator.logger.error msg 
+          raise msg
+        end # case
+      end # each
+
+      # # if somethig generated
+      # val = currentValue
+
+      # # return empty array else nil
+      # return val.nil? ? val : [ ]
+
+    end
+    
+
+    # Iterate 'validators' and activate validator["action"] for first
+    # 'validator["rule"]' matching for 'parameter'
+    #
+    # @param [Sbuilder::Parameter] parameter for which validator should be returned
+    #
+    # @param [Hash:Array] validator array of rules choosing validator
+    #
+    # @option validator [lambda] "rule" to match with 'parameter'
+    #
+    # @option validator [lambda] "action" to validate domains values in
+    # 'parameter' 'domain'
+    #
+    # @return [Lambda, String, Boolean] actionLambda, action_value,
+    # fixedValue 
+    private def chooseValidator( parameter, validators, parameter_path )
+
+      validators = validators || []
+
+      validators.each do |validator|
+        if RULES[validator["rule"]].call( parameter, parameter_path + [parameter.name], validator["rule_value"] )
+          # returns two! values
+          return instantiateValidator( parameter, validator["action"] ), validator["action_value"],  ACTIONS[validator["action"]][:fixedValue]
+        end
+      end # each validators
+      msg = <<-EOS
+      Could not locate validator for parameter #{parameter}
+
+      No matching rule found in validators: [ #{validators.join(',')} ]
+      EOS
+      Sbuilder::StepGenerator.logger.error msg 
+      raise StepGeneratorException.new, msg
+    end
+
+    private def instantiateValidator( parameter, validatorAction )
+      if ACTIONS[validatorAction].nil?
+        msg = <<-EOS
+        Unknown validator action '#{validatorAction}' when instantiating validator for parameter #{parameter}.
+
+        Valid validator action names:  #{ACTIONS.keys.join(',')}
+        EOS
+        Sbuilder::StepGenerator.logger.error msg         
+        raise StepGeneratorException.new, msg
+      end
+      ACTIONS[validatorAction][:func]
+    end
+
+    # @!endgroup
+
+    # ------------------------------------------------------------------
+    # @!group Build values set 
+
+    # Iterate all parmeters and return with 'true' for the first
+    # parameter, which can be advanced. If none of the parameter can
+    # be advances, return false. Advancing a parameter cycles a
+    # pointer to the next value in an array for valid value bindings
+    # for the paramter.
+    #
+    # @return [Boolean] true is next value generated, false when no more values to return
+    def nextValue()
+      goon = false
+      domainValues.each do |domainValue|
+        goon = goon || domainValue.nextValue
+        break if goon
+      end
+      goon
+    end
+
+    # Retrieve current value (stepped)
+    #
+    # @return [Hash] current value if valid value found, nil if no current value found
+    def currentValue
+      memo={}
+      # toggle true - if at least one memo element gets generated
+      anyValueFound = false
+      domainValues.each do |domainValue|
+        valueFound,memo = domainValue.currentValue( memo )
+        anyValueFound = anyValueFound || valueFound
+      end
+      # # if value found
+      # anyValueFound ? memo : nil
+      memo
+
+    end
+
+    # @!endgroup
+
+    # ------------------------------------------------------------------
+    # @!group Implement set of valid values
+
+    # @return [nil|Values] return (cached) value set generated by this generated
+    def values
+
+      Sbuilder::StepGenerator.logger.info "#{__method__}, @values=#{@values}, lengh=#{ @values.is_a?(Array) ? @values.length : 'undefined' }"
+
+      return @values if @values
+
+      # ensure that we do not return sets too large
+      Sbuilder::StepGenerator.maxSet( validValuesSetCardinality, nil )
+      
+      baseSet = doValues
+      
+      Sbuilder::StepGenerator.logger.info "#{__method__}, isArray=#{isArray}, baseSet.length=#{baseSet.length}, validValuesSetCardinality=#{validValuesSetCardinality}"
+      
+      # ensure that powerset does not grow too large
+      Sbuilder::StepGenerator.maxPowerSet( baseSet.length ) if isArray
+      @values = isArray ? Sbuilder::Powerset.powerset( baseSet ) :  baseSet
+
+      return @values
+    end
+
+    def doValues
+      val = currentValue
+      return nil unless val
+      vals = [val]
+      while nextValue
+        vals << currentValue
+      end
+      vals
+    end
+
+    # @!endgroup
+
+    # ------------------------------------------------------------------
+    # @!group Implement set of valid values
+
+    # @param [Integer] size of set used to generate powerset
+    #
+    # @return [Integer] max elements in set used to generate powerset    
+    def self.maxPowerSet( size )
+      self.maxSet( 2 ** size, nil )
+    end
+
+    # @param [Integer] cardinality number of elemets in a set
+    #
+    # @param [Sbuilder:Parameter] parameter where cardinality violated
+    #
+    # @param [Integer] maxElements number of elements to check
+    # againts, normally use default value, 
+    # 
+    #
+    #           
+    def self.maxSet( cardinality, parameter, maxElements=32)
+      if ( cardinality > maxElements )
+        msg =  <<-EOS
+        Set cardinality '#{cardinality}' too large, max allowed( #{maxElements}).
+
+        EOS
+        msg += <<-EOS  if parameter
+
+        when considering domains for parameter '#{parameter.name}'
+        EOS
+        
+        Sbuilder::StepGenerator.logger.error msg 
+        raise StepGeneratorException.new, msg
+      end
+    end
+
+    # Multiply cardinalities of referenced parameters for the
+    # cardinality of generator (base set i.e. WITHOUT considering
+    # isArray property in @paramSet).
+    #
+    # @return [Integer] cardinality of the generated set 
+    def validValuesSetCardinality
+
+      totalCardinality = 1
+      domainValues.each do |domainValue|
+        totalCardinality *= domainValue.validValuesSetCardinality
+      end
+      Sbuilder::StepGenerator.logger.info "#{__method__}, totalCardinality=#{totalCardinality}"      
+      totalCardinality
+      
+    end
+
+    # Validate that validators are correct w.r.t. initSet. Check for
+    # mandatory properties, valid 'rule', and 'action' properities,
+    # valid properties for 'rule' and 'action'.
+    #
+    # @param [Sbuilder::ParamSet] initSet used to generate values
+    #
+    #
+    # @param [Hash:Array] validators
+    # @option validator [] rule
+    # @option validator [] rule_value
+    # @option validator [] action
+    # @option validator [] action_value    
+    
+    # "action_value" -properties.
+    def validateValidators( initSet, validators )
+
+      validators.each do |validator|
+
+        # mantatory properties
+        Sbuilder::Utils::Validate.validateProperties( validator, @@validator_required, @@validator_allowed )
+
+        # known rule
+        if RULES[validator["rule"]].nil?
+          msg= <<-EOS
+              Unknown validator rule '#{validator["rule"]}' 
+
+              Valid validator rules:  #{RULES.keys.join(',')}
+
+          EOS
+          Sbuilder::StepGenerator.logger.error msg 
+          raise StepGeneratorException.new, msg
+
+        end
+
+        # known actions
+        if ACTIONS[validator["action"]].nil?
+          msg= <<-EOS
+              Unknown validator action '#{validator["action"]}' 
+
+              Valid validator rules:  #{ACTIONS.keys.join(',')}
+
+          EOS
+          Sbuilder::StepGenerator.logger.error msg 
+          raise StepGeneratorException.new, msg
+
+        end
+
+        # rule configuration ok?
+        Sbuilder::Utils::Validate.validateProperties(
+          validator,
+          RULE_VALIDATION[validator['rule']][:required],
+          @@validator_required +  @@validator_allowed + RULE_VALIDATION[validator['rule']][:allowed] )        
+
+        # action validation configuration ok?
+        Sbuilder::Utils::Validate.validateProperties(
+          validator,
+          ACTION_VALIDATION[validator['action']][:required],
+          @@validator_required +  @@validator_allowed + ACTION_VALIDATION[validator['action']][:allowed] )
+
+        if validator['rule'] == 'path'
+          validatePath( initSet, validator['rule_value'] )
+        end
+        
+      end
+    end
+
+    # @param [Sbuilder::ParamSet] paramSet where path should be exist
+    # 
+    # @param [String:Array] array of parameter names
+    def validatePath( initSet, path )
+
+      # init loop
+      currentSet = initSet
+
+      # each path element must find define a path in the tree defined
+      # by parameter set
+      path.each do |parameterName|
+        parameter = currentSet.lookupParameter( parameterName )
+        if parameter.nil?
+          msg= <<-EOS.unindent
+          Path element '#{parameterName}' does not match any valid parameter name: #{currentSet.parameters.map{|p|p.name}.join(',')}
+
+          Error occurred when trying to resolve path #{path} starting from parameter set 
+          with parameter names: #{initSet.parameters.map{|p|p.name}.join(',')}
+          EOS
+          Sbuilder::StepGenerator.logger.error msg 
+          raise StepGeneratorException.new, msg
+        end
+        # advance to next if possible
+        currentSet = parameter.respond_to?( :getResolvedReference ) ? parameter.getResolvedReference : nil
+      end
+    end
+
+    # @!endgroup
+
+
+  end
+
+
+
+  # ------------------------------------------------------------------
+
+  # Abstact class for generating values
+  class StepGeneratorValueRoot
+
+    # ədd '@validIndex' and @validValues, must implement
+    # validValuesSet and validValuesSetCardinality
+    include Sbuilder::StepGeneratorValue
+
+    # @attr [Sbuilder::Parameter_Dom|Sbuilder::Parameter_Ref] parameter generating value
+    attr_accessor :parameter
+
+    # @attr [String:Array] path to parent
+    attr_accessor :parameter_path
+
+
+    # ------------------------------------------------------------------
+    # @!group Construct & configure
+
+    def initialize( parameter, parameter_path  )
+      self.parameter= parameter
+      self.parameter_path = parameter_path
+      self.validIndex = 0
+      Sbuilder::StepGenerator.logger.debug "#{__method__}, parameter=#{parameter.name}, isArray=#{isArray}"      
+    end
+
+    # @return name of parameter generating values
+    def parameterName
+      parameter.name
+    end
+
+    # @return [Boolean] true if parameter.isArray
+    def isArray
+      parameter.isArray
+    end
+
+    # Path to me is path to my parent + my name
+    #
+    # @attr [String:Array] path to me
+    def parameter_path_to_me
+      parameter_path + [parameter.name]
+    end
+
+    # @!endgroup
+
+    # ------------------------------------------------------------------
+    # @!group Implement set of valid values for StepGeneratorValue
+
+    # must implement this method in sub-class
+    def validValuesSet
+      raise "Missing implmementation"
+    end
+
+    # @return [Integer] calculatedCardinality validValues  
+    def validValuesSetCardinality
+      raise "Missing implmementation"      
+    end
+
+    # @!endgroup
+
+  end # class StepGeneratorValueRoot
+
+  # ------------------------------------------------------------------
+  # Class pointing to Parameter_Dom, and generating values
+  class StepGeneratorValueRef < StepGeneratorValueRoot
+
+    # @attr [Sbuilder::StepGenerator] generator producing values for
+    # 'super.@parameter'
+    attr_accessor :refGenerator
+
+    # ------------------------------------------------------------------
+    # @!group Construct & configure
+
+
+    def initialize( parameter, validators, parameter_path )
+      super( parameter, parameter_path )
+
+      Sbuilder::StepGenerator.logger.info "#{__method__}, StepGeneratorValueRef parameter_path=#{parameter_path}"            
+      # create refGenerator
+      initReference( parameter, validators )
+    end
+
+    # Create 'StepGenerator', and initiliaze it with
+    # 'paramsetRef.getResolvedReference'. Sets attribute
+    # @refGenerator.
+    #
+    # @param [Sbuilder::Parameter_Ref] paramsetRef parameter pointint
+    # to another parameter set, with which the genarator should be
+    # initilized
+    #
+    private def initReference( paramsetRef, validators )
+      self.refGenerator = Sbuilder::StepGenerator.new
+      refGenerator.startGenerator( paramsetRef.getResolvedReference, validators, parameter_path_to_me )
+    end
+
+
+    # @!endgroup
+
+    # ------------------------------------------------------------------
+    # @!group Implement set of valid values for StepGeneratorValue
+
+    # Generate  array of values using refGenerator.
+    #
+    # @return [Hash:Array] valid values
+    def validValuesSet
+
+      Sbuilder::StepGenerator.logger.info "#{__method__}, parameter=#{parameter.name}, isArray=#{isArray}, validValuesSetCardinality=#{validValuesSetCardinality}"            
+      
+      # ensure that valid values set would not grow too large
+      # prior generatring valid the actual set
+      Sbuilder::StepGenerator.maxSet( validValuesSetCardinality, parameter )
+      
+      refGenerator.values
+
+    end
+
+    # Delegates the task of counting number of elements in the
+    # set to '@refGenerator'
+    #
+    # @return [Integer] calculatedCardinality validValues  
+    def validValuesSetCardinality
+      refGenerator.validValuesSetCardinality
+    end
+    
+    # @!endgroup
+
+  end #   class StepGeneratorValueRef < StepGeneratorValueRoot
+
+
+  # ------------------------------------------------------------------
+  # Class pointing to Parameter_Dom
+  class StepGeneratorValueDomain < StepGeneratorValueRoot
+
+    # @attr [Lambda] lambda limiting values generated
+    attr_accessor :action
+
+    # @attr [object] validator_context set using validators array
+    attr_accessor :action_value
+
+    # @attr [Boolean] fixedValue if action limit underlying domain to
+    # a fixed value
+    attr_accessor :fixedValue
+
+    # ------------------------------------------------------------------
+    # @!group Construct & configure
+
+    #
+    # @param [Sbuilder::Parameter] parameter for which to generate
+    # values
+    #
+    # @param [lambda(i,domValue,action_value )] action returns
+    # true if domValue accepted
+    #
+    # @param [object] action_value defined in 'validators' -array
+    #
+    # @param [String:Array] parameter_path leading to this param
+    def initialize( parameter, action, action_value, parameter_path, fixedValue )
+      super( parameter, parameter_path )
+      self.validIndex = 0
+      self.action = action
+      self.action_value = action_value
+      self.fixedValue = fixedValue
+    end
+
+    # @!endgroup
+
+    # ------------------------------------------------------------------
+    # @!group Implement set of valid values for StepGeneratorValue
+
+    #
+    # Generate array of domain values from resolved domain for
+    # '@parameter'. Use @action -lambda to screen domain values which
+    # should be included to 'validValues'.
+    #
+    # @return [String:Array] valid domain values
+    #
+    def validValuesSet
+      Sbuilder::StepGenerator.logger.info "#{__method__}, parameter=#{parameter.name}, isArray=#{isArray}"
+
+      # return String:Array
+      vals = [] 
+      if fixedValue
+        # at this time use 'action_value' to access parameter value,
+        # may chg later? to smtg better
+        val = parameterValue( action_value ) if action_value
+        # include to 'vals' if 'action' says yes
+        vals << val if action.call( action_value, val, action_value )
+      else
+
+        # not fixed value - need access domain range & filter using actions
+
+        # normally 0..cardinality, for integer ranges smthg 1..3
+        range = retriveParameterRange
+        Sbuilder::StepGenerator.logger.debug "#{__method__}: range=#{range}, first=#{range.first}, last=#{range.last}"
+
+        # not using fixedValue, guard againts ridicilous range
+        Sbuilder::StepGenerator.maxSet( range.last - range.first, parameter, 10000 )
+        # (0..parameterMaxIndex).to_a.map { |i|
+        
+        vals = range.to_a.map { |i|
+          # access domain element for range index
+          {
+            :i=>i,
+            :v=>parameterValue( i )
+          }
+        }.select { |iv_hash|
+          # use action to select what is actually needed
+          action.call( iv_hash[:i], iv_hash[:v], action_value )
+        }.map { |iv_hash|
+          # take value
+          iv_hash[:v]
+        }
+      end
+      return vals
+      
+    end
+
+    # # @return [Integer] number of elements in underlying domain,
+    # # including Nil, if it there
+    # private def parameterMaxIndex
+    #   ret = parameter.resolvedDomain.cardinality
+    #   # Nil NOT included --> take it away
+    #   ret -= 1 if !parameter.resolvedDomain.includeNil
+    #   ret
+    # end
+
+
+    # @return [String|Integer|false] 'inIndex'-th domain value from
+    # resolved domain for '@parameter'
+    private def parameterValue( inIndex )
+      pv = retriveParameterValue( inIndex ) 
+      # pv = '"' + pv  + '"' if pv
+      pv 
+    end
+
+    # @return [Integer..Integer] range for +parameter.resolvedDomain+
+    # to iterate +parameterValue+
+    private def retriveParameterRange
+      parameter.resolvedDomain.domain_range
+    end
+
+    # @return [String] 'inIndex'-th domain value from resolved domain
+    # for the '@parameter'
+    private def retriveParameterValue( inIndex )
+       parameter.resolvedDomain.render_entry( inIndex )
+    end
+    
+
+    # Count number of elements in set after domain elements has been
+    # filtered. If '@action' chooses fixed value, i.e. when
+    # 'fixedValue' == true, return 1
+    #
+    # @return [Integer] lenght of underlying set, or 1 when fixedValue
+    def validValuesSetCardinality
+      fixedValue ? 1 : validValuesSet.length
+      # validValuesSet.length
+    end
+    
+
+    # @!endgroup
+
+  end  # class StepGeneratorValueDomain
+
+end