code: async def container_load(self, container_type, params=None, container=None, obj=None):
          
          elem_type = x.container_elem_type(container_type, params)
          elem_size = await self.get_element_size(elem_type=elem_type, params=params)
  
          # If container is of fixed size we know the size to load from the input.
          # Otherwise we have to read to the end
          data_left = len(self.iobj.buffer)
          c_len = container_type.SIZE
          if not container_type.FIX_SIZE:
              if data_left == 0:
                  return None
              if data_left % elem_size != 0:
                  raise helpers.ArchiveException('Container size mod elem size not 0')
              c_len = data_left // elem_size
  
          res = container if container else []
          for i in range(c_len):
              try:
                  self.tracker.push_index(i)
                  fvalue = await self._load_field(elem_type,
                                                  params[1:] if params else None,
                                                  x.eref(res, i) if container else None)
                  self.tracker.pop()
              except Exception as e:
                  raise helpers.ArchiveException(e, tracker=self.tracker) from e
  
              if not container:
                  res.append(fvalue)
          return res
docs: Loads container of elements from the reader. Supports the container ref.
          Returns loaded container.
          Blob array writer as in XMRRPC is serialized without size serialization.
  
          :param container_type:
          :param params:
          :param container:
          :param obj:
          :return: