Class: Tins::Generator

### Home Classes Methods

### In Files

- lib/tins/generator.rb

### Parent

Object

### Methods

- ::[]
- ::new
- #add_dimension
- #each
- #size

### Included Modules

- Enumerable

### Class/Module Index

Quicksearch

- Tins
- Tins
- Tins
- Tins::Annotate
- Tins::AskAndSend
- Tins::Attempt
- Tins::Bijection
- Tins::Blank
- Tins::Blank::Array
- Tins::Blank::FalseClass
- Tins::Blank::Hash
- Tins::Blank::NilClass
- Tins::Blank::Numeric
- Tins::Blank::Object
- Tins::Blank::String
- Tins::Blank::TrueClass
- Tins::BlankSlate
- Tins::BlockSelf
- Tins::CasePredicate
- Tins::ClassMethod
- Tins::Concern
- Tins::Concern::ModuleMixin
- Tins::Constant
- Tins::ConstantMaker
- Tins::CountBy
- Tins::DSLAccessor
- Tins::DateDummy
- Tins::DateTimeDummy
- Tins::DeepConstGet
- Tins::DeepDup
- Tins::Deflect
- Tins::Deflect::DeflectError
- Tins::Deflect::Deflector
- Tins::Deflect::DeflectorCollection
- Tins::Delegate
- Tins::DynamicScope
- Tins::DynamicScope::Context
- Tins::Eigenclass
- Tins::ExtractLastArgumentOptions
- Tins::FileBinary
- Tins::FileBinary::ClassMethods
- Tins::FileBinary::Constants
- Tins::Find
- Tins::Find::Finder
- Tins::Find::Finder::PathExtension
- Tins::FromModule
- Tins::Full
- Tins::GO
- Tins::GO::EnumerableExtension
- Tins::Generator
- Tins::HashSymbolizeKeysRecursive
- Tins::HashUnion
- Tins::IfPredicate
- Tins::InstanceExec
- Tins::Interpreter
- Tins::Limited
- Tins::LinesFile
- Tins::LinesFile::LineExtension
- Tins::Memoize
- Tins::Memoize::CacheMethods
- Tins::MethodDescription
- Tins::MethodMissingDelegator
- Tins::MethodMissingDelegator::DelegatorClass
- Tins::MethodMissingDelegator::DelegatorModule
- Tins::Minimize
- Tins::ModuleGroup
- Tins::NamedSet
- Tins::Null
- Tins::Null::Kernel
- Tins::NullClass
- Tins::NullPlus
- Tins::Once
- Tins::P
- Tins::ParameterizedModule
- Tins::PartialApplication
- Tins::ProcCompose
- Tins::ProcPrelude
- Tins::RangePlus
- Tins::RequireMaybe
- Tins::Responding
- Tins::Rotate
- Tins::Scope
- Tins::SecureWrite
- Tins::SexySingleton
- Tins::SexySingleton::SingletonClassMethods
- Tins::Shuffle
- Tins::StringByteOrderMark
- Tins::StringCamelize
- Tins::StringUnderscore
- Tins::StringVersion
- Tins::StringVersion::Version
- Tins::Subhash
- Tins::SymbolMaker
- Tins::Terminal
- Tins::ThreadGlobal
- Tins::ThreadLocal
- Tins::TimeDummy
- Tins::TimeFreezer
- Tins::To
- Tins::ToProc
- Tins::Token
- Tins::UniqBy
- Tins::Write
- Object
- Object::DSLKit
- Object::Spruz
- Array
- Date
- DateTime
- Enumerable
- File
- Hash
- IO
- IRB
- Method
- Module
- Proc
- Range
- String
- Symbol
- Time
- UnboundMethod

No matching classes.

# Tins::Generator

This class can create generator objects, that can produce all tuples, that would be created by as many for-loops as dimensions were given.

The generator

    g = Tins::Generator[1..2, %w[a b c]]

produces

    g.to_a # => [[1, "a"], [1, "b"], [1, "c"], [2, "a"], [2, "b"], [2, "c"]]

The 'each' method can be used to iterate over the tuples

    g.each { |a, b| puts "#{a} #{b}" }

and Tins::Generator includes the Enumerable module, so Enumerable.instance_methods can be used as well:

    g.select { |a, b| %w[a c].include? b  } # => [[1, "a"], [1, "c"], [2, "a"], [2, "c"]]

### Public Class Methods

[](*enums) click to toggle source

Create a new Generator object from the enumberables enums.

    # File lib/tins/generator.rb, line 20
    def self.[](*enums)
      new(enums)
    end

new(enums) click to toggle source

Create a new Generator instance. Use the objects in the Array enums as dimensions. The should all respond to the :each method (see module Enumerable in the core ruby library).

    # File lib/tins/generator.rb, line 27
    def initialize(enums)
      @enums, @iterators, @n = [], [], 0
      enums.each { |e| add_dimension(e) }
    end

### Public Instance Methods

add_dimension(enum, iterator = :each) click to toggle source

Add another dimension to this generator. enum is an object, that ought to respond to the iterator method (defaults to :each).

    # File lib/tins/generator.rb, line 55
    def add_dimension(enum, iterator = :each)
      @enums << enum
      @iterators << iterator
      @n += 1
    end

each() click to toggle source

Iterate over all tuples produced by this generator and yield to them.

    # File lib/tins/generator.rb, line 33
    def each(&block) # :yield: tuple
      recurse(&block)
      self
    end

size() click to toggle source

Return the size of this generator, that is the number of its dimensions.

    # File lib/tins/generator.rb, line 62
    def size
      @enums.size
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.