Sid Gifari File Manager

Sid Gifari File Manager

🏠 Root / home / genremedia08 / musicjukebox.overlookedtracks.com / vendor / jetbrains / phpstorm-stubs / pthreads /

Editing: pthreads.php

<?php

// Start of PECL pthreads 3.1.6

/**
 * The default options for all Threads, causes pthreads to copy the environment
 * when new Threads are started
 * @link https://php.net/manual/en/pthreads.constants.php
 */
define('PTHREADS_INHERIT_ALL', 1118481);

/**
 * Do not inherit anything when new Threads are started
 * @link https://php.net/manual/en/pthreads.constants.php
 */
define('PTHREADS_INHERIT_NONE', 0);

/**
 * Inherit INI entries when new Threads are started
 * @link https://php.net/manual/en/pthreads.constants.php
 */
define('PTHREADS_INHERIT_INI', 1);

/**
 * Inherit user declared constants when new Threads are started
 * @link https://php.net/manual/en/pthreads.constants.php
 */
define('PTHREADS_INHERIT_CONSTANTS', 16);

/**
 * Inherit user declared classes when new Threads are started
 * @link https://php.net/manual/en/pthreads.constants.php
 */
define('PTHREADS_INHERIT_CLASSES', 4096);

/**
 * Inherit user declared functions when new Threads are started
 * @link https://php.net/manual/en/pthreads.constants.php
 */
define('PTHREADS_INHERIT_FUNCTIONS', 256);

/**
 * Inherit included file information when new Threads are started
 * @link https://php.net/manual/en/pthreads.constants.php
 */
define('PTHREADS_INHERIT_INCLUDES', 65536);

/**
 * Inherit all comments when new Threads are started
 * @link https://php.net/manual/en/pthreads.constants.php
 */
define('PTHREADS_INHERIT_COMMENTS', 1048576);

/**
 * Allow new Threads to send headers to standard output (normally prohibited)
 * @link https://php.net/manual/en/pthreads.constants.php
 */
define('PTHREADS_ALLOW_HEADERS', 268435456);

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * A Pool is a container for, and controller of, an adjustable number of
 * Workers. 
 * Pooling provides a higher level abstraction of the Worker functionality,
 * including the management of references in the way required by pthreads.
 * @link https://secure.php.net/manual/en/class.pool.php
 */
class Pool
{
 /**
 * Maximum number of Workers this Pool can use
 * @var int
 */
 protected $size;

/**
     * The class of the Worker
     * @var string
     */
    protected $class;

/**
     * The arguments for constructor of new Workers
     * @var array
     */
    protected $ctor;

/**
     * References to Workers
     * @var array
     */
    protected $workers;

/**
     * Offset in workers of the last Worker used
     * @var int
     */
    protected $last;

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * Construct a new pool of workers. Pools lazily create their threads, which means
 * new threads will only be spawned when they are required to execute tasks.
 * @link https://secure.php.net/manual/en/pool.construct.php
 * @param int $size The maximum number of workers for this pool to create
 * @param string $class [optional] The class for new Workers. If no class is
 * given, then it defaults to the {@link Worker} class.
 * @param array $ctor [optional] An array of arguments to be passed to new
 * Workers
 */
 public function __construct(int $size, string $class = 'Worker', array $ctor = []) {}

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * Allows the pool to collect references determined to be garbage by the
 * optionally given collector
 * @link https://secure.php.net/manual/en/pool.collect.php
 * @param null|callable $collector [optional] A Callable collector that returns a
 * boolean on whether the task can be collected or not. Only in rare cases should
 * a custom collector need to be used.
 * @return int The number of remaining tasks in the pool to be collected
 */
 public function collect(?callable $collector = null) {}

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * Resize the Pool
 * @link https://secure.php.net/manual/en/pool.resize.php
 * @param int $size The maximum number of Workers this Pool can create
 * @return void
 */
 public function resize(int $size) {}

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * Shuts down all of the workers in the pool. This will block until all submitted
 * tasks have been executed.
 * @link https://secure.php.net/manual/en/pool.shutdown.php
 * @return void
 */
 public function shutdown() {}

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * Submit the task to the next Worker in the Pool
 * @link https://secure.php.net/manual/en/pool.submit.php
 * @param Threaded $task The task for execution
 * @return int the identifier of the Worker executing the object
 */
 public function submit(Threaded $task) {}

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * Submit a task to the specified worker in the pool. The workers are indexed
 * from 0, and will only exist if the pool has needed to create them (since
 * threads are lazily spawned).
 * @link https://secure.php.net/manual/en/pool.submitTo.php
 * @param int $worker The worker to stack the task onto, indexed from 0
 * @param Threaded $task The task for execution
 * @return int The identifier of the worker that accepted the task
 */
 public function submitTo(int $worker, Threaded $task) {}
}

/**
 * Threaded objects form the basis of pthreads ability to execute user code
 * in parallel; they expose synchronization methods and various useful
 * interfaces. 
 * Threaded objects, most importantly, provide implicit safety for the programmer;
 * all operations on the object scope are safe.
 *
 * @link https://secure.php.net/manual/en/class.threaded.php
 */
class Threaded implements Collectable, Traversable, Countable, ArrayAccess
{
 /**
 * Worker object in which this Threaded is being executed
 * @var Worker
 */
 protected $worker;

/**
 * (PECL pthreads &gt;= 3.0.0) 
 * Increments the internal number of references to a Threaded object
 * @return void
 */
 public function addRef() {}

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * Fetches a chunk of the objects property table of the given size,
 * optionally preserving keys
 * @link https://secure.php.net/manual/en/threaded.chunk.php
 * @param int $size The number of items to fetch
 * @param bool $preserve [optional] Preserve the keys of members, by default false
 * @return array An array of items from the objects property table
 */
 public function chunk($size, $preserve = false) {}

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * Returns the number of properties for this object
 * @link https://secure.php.net/manual/en/threaded.count.php
 * @return int The number of properties for this object
 */
 public function count() {}

/**
 * (PECL pthreads &gt;= 3.0.0) 
 * Decrements the internal number of references to a Threaded object
 * @return void
 */
 public function delRef() {}

/**
 * (PECL pthreads &gt;= 2.0.8) 
 * Makes thread safe standard class at runtime
 * @link https://secure.php.net/manual/en/threaded.extend.php
 * @param string $class The class to extend
 * @return bool A boolean indication of success
 */
 public static function extend($class) {}

/**
 * (PECL pthreads &gt;= 3.0.0) 
 * Retrieves the internal number of references to a Threaded object
 * @return int The number of references to the Threaded object
 */
 public function getRefCount() {}

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * Tell if the referenced object is executing
 * @link https://secure.php.net/manual/en/thread.isrunning.php
 * @return bool A boolean indication of state
 */
 public function isRunning() {}

/**
 * (PECL pthreads &gt;= 3.1.0) 
 * @inheritdoc
 * @see Collectable::isGarbage()
 */
 public function isGarbage(): bool {}

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * Tell if the referenced object was terminated during execution; suffered
 * fatal errors, or threw uncaught exceptions
 * @link https://secure.php.net/manual/en/threaded.isterminated.php
 * @return bool A boolean indication of state
 */
 public function isTerminated() {}

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * Merges data into the current object
 * @link https://secure.php.net/manual/en/threaded.merge.php
 * @var mixed The data to merge
 * @var bool [optional] Overwrite existing keys, by default true
 * @return bool A boolean indication of success
 */
 public function merge($from, $overwrite = true) {}

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * Send notification to the referenced object
 * @link https://secure.php.net/manual/en/threaded.notify.php
 * @return bool A boolean indication of success
 */
 public function notify() {}

/**
 * (PECL pthreads &gt;= 3.0.0) 
 * Send notification to the referenced object. This unblocks at least one
 * of the blocked threads (as opposed to unblocking all of them, as seen with
 * Threaded::notify()).
 * @link https://secure.php.net/manual/en/threaded.notifyone.php
 * @return bool A boolean indication of success
 */
 public function notifyOne() {}

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * Pops an item from the objects property table
 * @link https://secure.php.net/manual/en/threaded.pop.php
 * @return mixed The last item from the objects property table
 */
 public function pop() {}

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * The programmer should always implement the run method for objects
 * that are intended for execution.
 * @link https://secure.php.net/manual/en/threaded.run.php
 * @return void
 */
 public function run() {}

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * Shifts an item from the objects property table
 * @link https://secure.php.net/manual/en/threaded.shift.php
 * @return mixed The first item from the objects property table
 */
 public function shift() {}

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * Executes the block while retaining the referenced objects
 * synchronization lock for the calling context
 * @link https://secure.php.net/manual/en/threaded.synchronized.php
 * @param Closure $block The block of code to execute
 * @param mixed ...$_ [optional] Variable length list of arguments
 * to use as function arguments to the block
 * @return mixed The return value from the block
 */
 public function synchronized(Closure $block, ...$_) {}

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * Will cause the calling context to wait for notification from the
 * referenced object
 * @link https://secure.php.net/manual/en/threaded.wait.php
 * @param int $timeout [optional] An optional timeout in microseconds
 * @return bool A boolean indication of success
 */
 public function wait(int $timeout = 0) {}

/**
     * @inheritdoc
     * @see ArrayAccess::offsetExists()
     */
    public function offsetExists($offset) {}

/**
     * @inheritdoc
     * @see ArrayAccess::offsetGet()
     */
    public function offsetGet($offset) {}

/**
     * @inheritdoc
     * @see ArrayAccess::offsetSet()
     */
    public function offsetSet($offset, $value) {}

/**
     * @inheritdoc
     * @see ArrayAccess::offsetUnset()
     */
    public function offsetUnset($offset) {}
}

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * When the start method of a Thread is invoked, the run method code will be
 * executed in separate Thread, in parallel. 
 * After the run method is executed the Thread will exit immediately, it will
 * be joined with the creating Thread at the appropriate time.
 *
 * @link https://secure.php.net/manual/en/class.thread.php
 */
class Thread extends Threaded implements Countable, Traversable, ArrayAccess
{
 /**
 * (PECL pthreads &gt;= 2.0.0) 
 * Will return the identity of the Thread that created the referenced Thread
 * @link https://secure.php.net/manual/en/thread.getcreatorid.php
 * @return int A numeric identity
 */
 public function getCreatorId() {}

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * Return a reference to the currently executing Thread
 * @link https://secure.php.net/manual/en/thread.getcurrentthread.php
 * @return Thread An object representing the currently executing Thread
 */
 public static function getCurrentThread() {}

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * Will return the identity of the currently executing Thread
 * @link https://secure.php.net/manual/en/thread.getcurrentthreadid.php
 * @return int A numeric identity
 */
 public static function getCurrentThreadId() {}

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * Will return the identity of the referenced Thread
 * @link https://secure.php.net/manual/en/thread.getthreadid.php
 * @return int A numeric identity
 */
 public function getThreadId() {}

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * Tell if the referenced Thread has been joined
 * @link https://secure.php.net/manual/en/thread.isjoined.php
 * @return bool A boolean indication of state
 */
 public function isJoined() {}

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * Tell if the referenced Thread was started
 * @link https://secure.php.net/manual/en/thread.isstarted.php
 * @return bool A boolean indication of state
 */
 public function isStarted() {}

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * Causes the calling context to wait for the referenced Thread to finish executing
 * @link https://secure.php.net/manual/en/thread.join.php
 * @return bool A boolean indication of success
 */
 public function join() {}

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * Will start a new Thread to execute the implemented run method
 * @link https://secure.php.net/manual/en/thread.start.php
 * @param int $options [optional] An optional mask of inheritance
 * constants, by default {@link PTHREADS_INHERIT_ALL}
 * @return bool A boolean indication of success
 */
 public function start(int $options = PTHREADS_INHERIT_ALL) {}
}

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * Worker Threads have a persistent context, as such should be used over
 * Threads in most cases. 
 * When a Worker is started, the run method will be executed, but the Thread will
 * not leave until one of the following conditions are met: <ul>
 * <li>the Worker goes out of scope (no more references remain)</li>
 * <li>the programmer calls shutdown</li>
 * <li>the script dies</li></ul>
 * This means the programmer can reuse the context throughout execution; placing
 * objects on the stack of the Worker will cause the Worker to execute the stacked
 * objects run method.
 * @link https://secure.php.net/manual/en/class.worker.php
 */
class Worker extends Thread implements Traversable, Countable, ArrayAccess
{
 /**
 * (PECL pthreads &gt;= 3.0.0) 
 * Allows the worker to collect references determined to be garbage by the
 * optionally given collector
 * @link https://secure.php.net/manual/en/worker.collect.php
 * @param null|callable $collector [optional] A Callable collector that returns
 * a boolean on whether the task can be collected or not. Only in rare cases
 * should a custom collector need to be used
 * @return int The number of remaining tasks on the worker's stack to be
 * collected
 */
 public function collect(?callable $collector = null) {}

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * Returns the number of tasks left on the stack
 * @link https://secure.php.net/manual/en/worker.getstacked.php
 * @return int Returns the number of tasks currently waiting to be
 * executed by the worker
 */
 public function getStacked() {}

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * Whether the worker has been shutdown or not
 * @link https://secure.php.net/manual/en/worker.isshutdown.php
 * @return bool Returns whether the worker has been shutdown or not
 */
 public function isShutdown() {}

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * Shuts down the Worker after executing all of the stacked tasks
 * @link https://secure.php.net/manual/en/worker.shutdown.php
 * @return bool Whether the worker was successfully shutdown or not
 */
 public function shutdown() {}

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * Appends the new work to the stack of the referenced worker
 * @link https://secure.php.net/manual/en/worker.stack.php
 * @param Threaded $work A Threaded object to be executed by the Worker
 * @return int The new size of the stack
 */
 public function stack(Threaded $work) {}

/**
 * (PECL pthreads &gt;= 2.0.0) 
 * Removes the first task (the oldest one) in the stack
 * @link https://secure.php.net/manual/en/worker.unstack.php
 * @return Threaded|null The item removed from the stack
 */
 public function unstack() {}
}

/**
 * (PECL pthreads &gt;= 2.0.8) 
 * Represents a garbage-collectable object.
 * @link https://secure.php.net/manual/en/class.collectable.php
 */
interface Collectable
{
 /**
 * (PECL pthreads &gt;= 2.0.8) 
 * Can be called in {@link Pool::collect()} to determine if this object is garbage
 * @link https://secure.php.net/manual/en/collectable.isgarbage.php
 * @return bool Whether this object is garbage or not
 */
 public function isGarbage(): bool;
}

/**
 * (PECL pthreads &gt;= 3.0.0) 
 * The Volatile class is new to pthreads v3. Its introduction is a consequence of
 * the new immutability semantics of Threaded members of Threaded classes. The
 * Volatile class enables for mutability of its Threaded members, and is also
 * used to store PHP arrays in Threaded contexts.
 * @see Threaded
 * @link https://secure.php.net/manual/en/class.volatile.php
 */
class Volatile extends Threaded implements Collectable, Traversable {}