Register stream wrapper.
771808
public static function register(string $protocol, string $root = null, int $flags = 0): bool
    {
        $wrappers = stream_get_wrappers();
        if (in_array($protocol, $wrappers)) {
            throw new Exception(
                "Protocol '$protocol' has been already registered"
            );
        }
        $wrapper = stream_wrapper_register($protocol, get_called_class(), $flags);

        if ($wrapper) {
            if (null !== $root) {
                $content = Entity::newInstance($root);
            } else {
                $content = null;
            }

            $partition = new Partition($content);

            self::$partitions[$protocol] = $partition;
        }

        return $wrapper;
    }
428284
public function register()
    {
        $loader = AliasLoader::getInstance();

        // Register aliases
        foreach ($this->getAliases() as $alias => $class) {
            $loader->alias($alias, $class);
        }

        // Register service containers
        foreach ($this->getServiceContainers() as $abstract => $concrete) {
            $this->app->singleton($abstract, $concrete);
        }
    }
656194
public function registerStreamWrapper($protocol=null)
    {
        if ($this->registered_wrapper) {
            throw new \RuntimeException("Unregister the wrapper before registering it again!");
        }
        if ($protocol && !$this->protocol) {
            $this->protocol = $protocol; 
        }
        $this->registered_wrapper = true;
        self::$handlers[$this->protocol] = $this;
        return stream_wrapper_register($this->protocol, __CLASS__, 0);
    }
875826
public static function register()
    {
        if (!in_array(self::FILTERNAME, stream_get_filters(), true)) {
            stream_filter_register(self::FILTERNAME, self::class);
        }
    }
825291
public static function registerWrapper($wrapper)
    {
        $wrapper = (string) $wrapper;
        if (!in_array($wrapper, static::$wrapperRegistry, true)) {
            static::$wrapperRegistry[] = $wrapper;
        }
    }
613203
function streamWrappers (grunt, fileData, options) {
    stream.createWriteStream(fileData.tmpWrapStart, () => {
        streamWrapperEnd(grunt, fileData, options);
    });

    if (options.license) {
        streamLicense(grunt, fileData, options);
    } else {
        streamWrapperStart(grunt, fileData, options);
    }
}
1234211
async def _async_register(self):  # pragma: no cover
        
        metadata = aioxmpp.make_security_layer(None, no_verify=not self.verify_security)
        query = ibr.Query(self.jid.localpart, self.password)
        _, stream, features = await aioxmpp.node.connect_xmlstream(self.jid, metadata, loop=self.loop)
        await ibr.register(stream, query)
513252
public function registerStream(StreamInterface $stream, $replaceWrapper = false)
    {
        $protocol = $stream->getProtocol();
        if ($replaceWrapper === true && in_array($protocol, stream_get_wrappers())) {
            stream_wrapper_unregister($protocol);
        }

        if (stream_wrapper_register($protocol, $stream->getStreamWrapperClass())) {
            self::$streams[$protocol] = $stream;
        }

        return $this;
    }
952499
static function isRegistered($wrapper)
    {
        if ($wrapper instanceof iWrapperStream)
            $wrapper = $wrapper->getLabel();

        return in_array($wrapper, self::listWrappers());
    }
745121
def get_wrapped_stream(stream):
    

    if stream is None:
        raise TypeError("must provide a stream to wrap")
    encoding = getattr(stream, "encoding", None)
    encoding = get_output_encoding(encoding)
    return StreamWrapper(stream, encoding, "replace", line_buffering=True)
1054249
public function register()
    {
        $app = $this->app;
        $this->app->singleton('cloudder', function () use ($app) {
            return new CloudinaryWrapper($app['config'], new Cloudinary, new Cloudinary\Uploader, new Cloudinary\Api);
        });
    }
1186789
public static function register()
    {
        if ( self::$hasBeenRegistered === true ) {
            return;
        }

        if ( stream_filter_register(self::getFilterName(), __CLASS__) === false ) {
            throw new RuntimeException('Failed to register stream filter: '.self::getFilterName());
        }

        self::$hasBeenRegistered = true;
    }
1176575
public HttpServerExchange addRequestWrapper(final ConduitWrapper<StreamSourceConduit> wrapper) {
        ConduitWrapper<StreamSourceConduit>[] wrappers = requestWrappers;
        if (requestChannel != null) {
            throw UndertowMessages.MESSAGES.requestChannelAlreadyProvided();
        }
        if (wrappers == null) {
            wrappers = requestWrappers = new ConduitWrapper[2];
        } else if (wrappers.length == requestWrapperCount) {
            requestWrappers = new ConduitWrapper[wrappers.length + 2];
            System.arraycopy(wrappers, 0, requestWrappers, 0, wrappers.length);
            wrappers = requestWrappers;
        }
        wrappers[requestWrapperCount++] = wrapper;
        return this;
    }
376827
public static function register($scheme = 'gaufrette')
    {
        static::streamWrapperUnregister($scheme);

        if (!static::streamWrapperRegister($scheme, __CLASS__)) {
            throw new \RuntimeException(sprintf(
                'Could not register stream wrapper class %s for scheme %s.',
                __CLASS__,
                $scheme
            ));
        }
    }
248255
private void register() {
        this.yamlConstructors.put(Tag.MAP, mapConstruct());
        this.yamlConstructors.put(Tag.OMAP, omapConstruct());
        this.yamlConstructors.put(Tag.PAIRS, pairsConstruct());
        this.yamlConstructors.put(Tag.SEQ, seqConstruct());
        this.yamlConstructors.put(Tag.SET, setConstruct());
        this.yamlConstructors.put(Tag.BINARY, binaryConstruct());
        this.yamlConstructors.put(Tag.BOOL, boolConstruct());
        this.yamlConstructors.put(Tag.FLOAT, floatConstruct());
        this.yamlConstructors.put(Tag.INT, intConstruct());
        this.yamlConstructors.put(Tag.NULL, nullConstruct());
        this.yamlConstructors.put(Tag.STR, strConstruct());
        this.yamlConstructors.put(Tag.TIMESTAMP, timestampConstruct());
    }
161552
public function registerHttpServiceProvider()
    {
        $this->registerRateLimiting();
        $this->registerHttpValidation();
        $this->registerHttpParsers();
        $this->registerResponseFactory();
        $this->registerMiddleware();
    }
879563
def addStreamingListener(self, streamingListener):
        
        self._jssc.addStreamingListener(self._jvm.JavaStreamingListenerWrapper(
            self._jvm.PythonStreamingListenerWrapper(streamingListener)))