Loads container of elements from the reader. Supports the container ref.
        Returns loaded container.

        :param reader:
        :param container_type:
        :param params:
        :param container:
        :return:
1189
async def _load_container(
            self, reader, container_type, params=None, container=None
    ):
        

        c_len = (
            container_type.SIZE
            if container_type.FIX_SIZE
            else await load_uvarint(reader)
        )
        if container and get_elem(container) and c_len != len(container):
            raise ValueError("Size mismatch")

        elem_type = container_elem_type(container_type, params)
        res = container if container else []
        for i in range(c_len):
            try:
                self.tracker.push_index(i)
                fvalue = await self.load_field(
                    reader,
                    elem_type,
                    params[1:] if params else None,
                    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
78462
def get(self, container):
        
        name = utils.get_name(container)
        uri = "/%s" % name
        resp, resp_body = self.api.method_head(uri)
        hdrs = resp.headers
        data = {"total_bytes": int(hdrs.get("x-container-bytes-used", "0")),
                "object_count": int(hdrs.get("x-container-object-count", "0")),
                "name": name}
        return Container(self, data, loaded=False)
1169237
def _read_stream(self, stream):
        
        data = yaml.safe_load_all(stream=stream)
        obj = self._find_convertable_object(data)
        pod = self.pod_types[obj['kind']](obj)
        return obj, pod.get('containers'), self.ingest_volumes_param(pod.get('volumes', []))
1268066
def _load(stream, container, sep=_SEP, dkey=DEFAULTSECT, **kwargs):
    
    (kwargs_1, psr) = _make_parser(**kwargs)
    if IS_PYTHON_3:
        psr.read_file(stream, **kwargs_1)
    else:
        psr.readfp(stream, **kwargs_1)

    cnf = container()
    kwargs["sep"] = sep

    defaults = psr.defaults()
    if defaults:
        cnf[dkey] = container(_parsed_items(iteritems(defaults), **kwargs))

    for sect in psr.sections():
        cnf[sect] = container(_parsed_items(psr.items(sect), **kwargs))

    return cnf
64552
def DeserializeForImport(self, reader):
        
        super(Block, self).Deserialize(reader)

        self.Transactions = []
        transaction_length = reader.ReadVarInt()

        for i in range(0, transaction_length):
            tx = Transaction.DeserializeFrom(reader)
            self.Transactions.append(tx)

        if len(self.Transactions) < 1:
            raise Exception('Invalid format %s ' % self.Index)
916431
async def blob(self, elem=None, elem_type=None, params=None):
        
        elem_type = elem_type if elem_type else elem.__class__
        if hasattr(elem_type, 'blob_serialize'):
            elem = elem_type() if elem is None else elem
            return await elem.blob_serialize(self, elem=elem, elem_type=elem_type, params=params)

        if self.writing:
            return await x.dump_blob(self.iobj, elem=elem, elem_type=elem_type, params=params)
        else:
            return await x.load_blob(self.iobj, elem_type=elem_type, params=params, elem=elem)
1050145
public Object parse(Reader reader) {
        if (reader == null) {
            throw new IllegalArgumentException("Reader must not be null");
        }

        Object content;
        JsonParser parser = createParser();
        content = parser.parse(reader);
        return content;
    }
976214
def _read_frame(cls, reader):
        '''
        
        '''
        frame_type = reader.read_octet()
        channel_id = reader.read_short()
        size = reader.read_long()

        payload = Reader(reader, reader.tell(), size)

        # Seek to end of payload
        reader.seek(size, 1)

        ch = reader.read_octet()  # footer
        if ch != 0xce:
            raise Frame.FormatError(
                'Framing error, unexpected byte: %x.  frame type %x. channel %d, payload size %d',
                ch, frame_type, channel_id, size)

        frame_class = cls._frame_type_map.get(frame_type)
        if not frame_class:
            raise Frame.InvalidFrameType("Unknown frame type %x", frame_type)
        return frame_class.parse(channel_id, payload)
1311906
async def _dump_container_val(self, writer, elem, container_type, params=None):
        
        elem_type = container_elem_type(container_type, params)
        await self.dump_field(writer, elem, elem_type, params[1:] if params else None)
1023133
public static List<Certificate> loadCertificates(final Reader reader) throws IOException,
            CertificateException {
        try (PEMParser pemParser = new PEMParser(reader)) {
            List<Certificate> certificates = new ArrayList<>();

            JcaX509CertificateConverter certificateConverter = new JcaX509CertificateConverter()
                    .setProvider(BouncyCastleProvider.PROVIDER_NAME);
            Object certObj = pemParser.readObject();

            if (certObj instanceof X509CertificateHolder) {
                X509CertificateHolder certificateHolder = (X509CertificateHolder) certObj;
                certificates.add(certificateConverter.getCertificate(certificateHolder));
            }

            return certificates;
        }
    }
726256
def load_reader(reader_configs, **reader_kwargs):
    """"""
    reader_info = read_reader_config(reader_configs)
    reader_instance = reader_info['reader'](config_files=reader_configs, **reader_kwargs)
    return reader_instance
1316709
def loadFromNode(self, parent, element):
        
        reader = self.__readerClass(element)
        schema = XMLSchema(parent)
        #HACK to keep a reference
        schema.wsdl = parent
        schema.setBaseUrl(self.__base_url)
        schema.load(reader)
        return schema
861296
def create_reader(name, *args, format=None, registry=default_registry, **kwargs):
    
    return registry.get_reader_factory_for(name, format=format)(name, *args, **kwargs)
509392
def load(cls, partname, content_type, blob, package):
        
        return cls(partname, content_type, blob)
323738
def container(wobj)
      s = @epub.container
      if !s.nil? && !wobj.nil?
        wobj.puts s
      end
    end
863846
def load_children(self):
        

        # Containers
        children = list()
        statuses = list()
        version = None
        titles = list()
        descriptions = list()
        platforms = list()
        idents = list()

        # Element load
        for element in self.xml_element:
            uri, tag = Element.get_namespace_and_tag(element.tag)
            if tag == 'version':
                if version is None:
                    version = Version(element)
                else:
                    error_msg = 'version element found more than once'
                    raise CardinalityException(error_msg)
            elif tag == 'status':
                statuses.append(Status(element))
            elif tag == 'title':
                titles.append(Title(element))
            elif tag == 'description':
                descriptions.append(Description(element))
            elif tag == 'platform':
                platforms.append(Platform(element))
            elif tag == 'ident':
                idents.append(Ident(element))

        # List construction
        children.extend(statuses)
        if version is not None:
            children.append(version)
        children.extend(titles)
        children.extend(descriptions)
        children.extend(platforms)
        children.extend(idents)

        return children
1183031
def get_all(content, container, object_type):
    '''
    
    '''
    obj_list = list()
    view_manager = content.viewManager
    object_view = view_manager.CreateContainerView(
        container, [object_type], True
    )
    for obj in object_view.view:
        if isinstance(obj, object_type):
            obj_list.append(obj)
    object_view.Destroy()
    return obj_list