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:

async def container_load(self, container_type, params=None, container=None, obj=None):
        """
        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:
        """
        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