Top Level Namespace

Defined Under Namespace

Modules: BinData

Instance Method Summary collapse

Instance Method Details

#_def_enum(size) ⇒ Object 



3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/bindata-contrib/enum.rb', line 3

def _def_enum(size)
  eval %(
    module BinData
      class Enum#{size} < Primitive
        mandatory_parameter :list

        endian :big
        uint#{size} :enum, initial_value: 0

        def get
          list.invert.fetch(enum)
        rescue KeyError
          enum
        end

        def set(value)
          self.enum = list.fetch(value)
        rescue KeyError
          self.enum = value
        end

        private

        def list
          list = eval_parameter(:list)
          case list.class.to_s
          when 'Array'
            shift = 0
            list.each_with_object({}) do |each, result|
              result[each] = shift
              shift += 1
              result
            end
          when 'Hash'
            list
          end
        end
      end
    end
  )
end

#_def_flags(size) ⇒ Object 



3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
# File 'lib/bindata-contrib/flags.rb', line 3

def _def_flags(size)
  eval %(
    module BinData
      class Flags#{size} < Primitive
        mandatory_parameter :list

        endian :big
        uint#{size} :flags, initial_value: 0

        def get
          list.each_with_object([]) do |(key, value), result|
            result << key if (flags & value != 0) || (flags == value)
            result
          end
        end

        def set(value)
          value.each do |each|
            fail "Invalid flag: \#{value}" unless list.keys.include?(each)
          end
          self.flags = value.empty? ?
                       0 :
                       value.map { |each| list[each] }.inject(:|)
        end

        private

        def list
          list = eval_parameter(:list)
          case list.class.to_s
          when 'Array'
            shift = 0
            list.each_with_object({}) do |each, result|
              result[each] = 1 << shift
              shift += 1
              result
            end
          when 'Hash'
            list
          end
        end
      end
    end
  )
end