docs: def load(self, file, **options):
          """ Loads the field *value* for each :class:`Field` *nested* in the
          `Container` from an ``.ini`` *file*.
  
          :param str file: name and location of the ``.ini`` *file*.
          :keyword str section: section in the ``.ini`` *file* to lookup the
              value for each :class:`Field` in the `Container`.
              If no *section* is specified the class name of the instance is used.
          :keyword bool nested: if ``True`` all :class:`Pointer` fields in the
              `Container` load their referenced :attr:`~Pointer.data` object
              field valus as well (chained method call).
          :keyword bool verbose: if ``True`` the loading is executed in verbose
              mode.
  
          File `foo.ini`:
  
          .. code-block:: ini
  
              [Foo]
              stream =
              float = 0.0
              structure.decimal = 0
              array[0] = 0x0
              array[1] = 0x0
              array[2] = 0x0
              pointer = 0x0
  
          Example:
  
          >>> class Foo(Structure):
          ...     def __init__(self):
          ...         super().__init__()
          ...         self.stream = Stream()
          ...         self.float = Float()
          ...         self.structure = Structure()
          ...         self.structure.decimal = Decimal(8)
          ...         self.array = Array(Byte, 3)
          ...         self.pointer = Pointer()
          >>> foo = Foo()
          >>> foo.load('foo.ini')
          [Foo]
          Foo.stream =
          Foo.float = 0.0
          Foo.structure.decimal = 0
          Foo.array[0] = 0x0
          Foo.array[1] = 0x0
          Foo.array[2] = 0x0
          Foo.pointer = 0x0
          >>> foo.to_list(nested=True)
          [('Foo.stream', ''),
           ('Foo.float', 0.0),
           ('Foo.structure.decimal', 0),
           ('Foo.array[0]', '0x0'),
           ('Foo.array[1]', '0x0'),
           ('Foo.array[2]', '0x0'),
           ('Foo.pointer', '0x0')]
          >>> foo.to_json(nested=True)
          '{"stream": "",
            "float": 0.0,
            "structure": {"decimal": 0},
            "array": ["0x0", "0x0", "0x0"],
            "pointer": {"value": "0x0",
                        "data": null}}'
          """
          section = options.pop('section', self.__class__.__name__)
  
          parser = ConfigParser()
          parser.read(file)
  
          if parser.has_section(section):
              verbose(options, "[{0}]".format(section))
  
              for field_path, field in self.field_items(**options):
                  if field_path.startswith('['):
                      # Sequence element
                      option = '_' + field_path
                  else:
                      option = field_path
                  if parser.has_option(section, option):
                      # Bool fields
                      if field.is_bool():
                          field.value = parser.getboolean(section, option)
                      # Float fields
                      elif field.is_float():
                          field.value = parser.getfloat(section, option)
                      # String fields
                      elif field.is_string():
                          field.value = parser.get(section, option)
                      # Stream fields
                      elif field.is_stream():
                          value = parser.get(section, option)
                          stream = bytes.fromhex(value.replace("'", ""))
                          # Auto size a zero sized stream field to the current length
                          if not field:
                              field.resize(len(stream))
                          field.value = stream
                      # Decimal fields
                      else:
                          field.value = parser.get(section, option)
                      if field_path.startswith('['):
                          verbose(options,
                                  "{0}{1} = {2}".format(section,
                                                        field_path,
                                                        field.value))
                      else:
                          verbose(options,
                                  "{0}.{1} = {2}".format(section,
                                                         field_path,
                                                         field.value))
          else:
              verbose(options, "No section [{0}] found.".format(section))