Class: Mingle::MingleSymbolMap

Inherits:

MingleValue

• Object
• BitGirderClass
• MingleValue
• Mingle::MingleSymbolMap

Extended by:

BitGirder::Core::BitGirderMethods, Forwardable

Includes:

Enumerable

Defined in:

lib/mingle.rb

Defined Under Namespace

Classes: NoSuchKeyError

Constant Summary

Constants included from BitGirder::Core::BitGirderMethods

BitGirder::Core::BitGirderMethods::PARAM_TYPE_ARG, BitGirder::Core::BitGirderMethods::PARAM_TYPE_ENVVAR, BitGirder::Core::BitGirderMethods::PARAM_TYPE_KEY

Class Method Summary

• .create(map = {}) ⇒ Object

Instance Method Summary

• #==(other) ⇒ Object
• #[](key) ⇒ Object (also: #get)
• #expect(key) ⇒ Object
• #fields ⇒ Object
• #get_map ⇒ Object
• #initialize(map) ⇒ MingleSymbolMap constructor

  A new instance of MingleSymbolMap.

• #values_at(*arg) ⇒ Object

Methods included from BitGirder::Core::BitGirderMethods

argv_to_argh, check_fail_prefix, class_name_to_sym, code, compares_to, console, ext_to_class_name, ext_to_sym, has_env, has_key, has_keys, nonnegative, not_nil, positive, raisef, set_from_key, set_var, split_argv, sym_to_cli_switch, sym_to_ext_id, to_bool, unpack_argv_array, unpack_argv_hash, warn

Constructor Details

#initialize(map) ⇒ MingleSymbolMap

Returns a new instance of MingleSymbolMap.

# File 'lib/mingle.rb', line 2142

def initialize( map )
    @map = map.freeze
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(meth, *args) ⇒ Object (private)

# File 'lib/mingle.rb', line 2214

def method_missing( meth, *args )
    
    case meth.to_s

        when /^(expect|get)_(mingle_[a-z][a-z\d]*(?:_[a-z][a-z\d]*)*)$/
            
            case val = send( $1.to_sym, expect_one_arg( args ) )
                when nil then nil
                else MingleModels.as_mingle_instance( val, $2.to_sym )
            end

        when /^(expect|get)_string$/
            s = send( :"#{$1}_mingle_string", *args ) and s.to_s

        when /^(expect|get)_int$/
            s = send( :"#{$1}_mingle_int64", *args ) and s.to_i

        when /^(expect|get)_timestamp$/
            s = send( :"#{$1}_mingle_timestamp", *args )

        when /^(expect|get)_boolean$/
            s = send( :"#{$1}_mingle_boolean", *args ) and s.to_bool

        else super
    end
end

Class Method Details

.create(map = {}) ⇒ Object

# File 'lib/mingle.rb', line 2127

def self.create( map = {} )
    
    res = {}

    not_nil( map, "map" ).each_pair do |k, v| 
        
        mv = MingleModels.as_mingle_value( v )
        res[ MingleIdentifier::get( k ) ] = mv unless mv.is_a?( MingleNull )
    end

    new( res )
end

Instance Method Details

#==(other) ⇒ Object

# File 'lib/mingle.rb', line 2196

def ==( other )
 
    other.is_a?( MingleSymbolMap ) &&
        other.instance_variable_get( :@map ) == @map
end

#[](key) ⇒ Object Also known as: get

# File 'lib/mingle.rb', line 2156

def []( key )

    case not_nil( key, :key )

        when MingleIdentifier then @map[ key ]

        when String then self[ key.to_sym ]

        when Symbol
            if res = ( @vals_by_sym ||= {} )[ key ]
                res
            else
                res = self[ MingleIdentifier.get( key ) ]
                @vals_by_sym[ key ] = res if res

                res
            end
        
        else raise TypeError, "Unexpected key type: #{key.class}"
    end
end

#expect(key) ⇒ Object

# File 'lib/mingle.rb', line 2181

def expect( key )

    if ( res = self[ key ] ) == nil
        raise NoSuchKeyError, "Map has no value for key: #{key}"
    else
        res
    end
end

#fields ⇒ Object

# File 'lib/mingle.rb', line 2151

def fields
    self
end

#get_map ⇒ Object

# File 'lib/mingle.rb', line 2146

def get_map
    {}.merge( @map )
end

#values_at(*arg) ⇒ Object

# File 'lib/mingle.rb', line 2191

def values_at( *arg )
    not_nil( arg, :arg ).map { |k| get( k ) }
end