docs: def read_from(self, provider, null_allowed=False, **options):
          """ Reads from the data :class:`Provider` the necessary number of bytes
          for the :attr:`data` object referenced by the `Pointer` field.
  
          A `Pointer` field stores the binary data read from the data
          :class:`Provider` in its :attr:`bytestream`.
  
          :param Provider provider: data :class:`Provider`.
          :param bool null_allowed: if ``True`` read access of address zero (Null)
              is allowed.
          :keyword bool nested: if ``True`` all :class:`Pointer` fields in the
              :attr:`data` object of the `Pointer` field reads their referenced
              :attr:`~Pointer.data` object fields as well (chained method call).
              Each `Pointer` field stores the bytes for its referenced
              :attr:`data` object in its :attr:`bytestream`.
          """
          if self._data is None:
              pass
          elif is_provider(provider):
              if self._value < 0:
                  pass
              elif null_allowed or self._value > 0:
                  while True:
                      self.bytestream = provider.read(self.address, self.data_size)
                      index = self.deserialize_data()
                      # Incomplete data object
                      if index.bit != 0:
                          length = index.byte, index.bit
                          raise ContainerLengthError(self, length)
                      if not index.update:
                          break
                  if is_mixin(self._data) and get_nested(options):
                      self._data.read_from(provider, **options)
              else:
                  self.bytestream = bytes()
                  self.deserialize_data()
          else:
              raise ProviderTypeError(self, provider)