Classes
stub class representing AMQPBasicProperties from pecl-amqp
stub class representing AMQPChannel from pecl-amqp
stub class representing AMQPChannelException from pecl-amqp
stub class representing AMQPConnection from pecl-amqp
stub class representing AMQPConnectionException from pecl-amqp
stub class representing AMQPDecimal from pecl-amqp
stub class representing AMQPEnvelope from pecl-amqp
stub class representing AMQPEnvelopeException from pecl-amqp
stub class representing AMQPException from pecl-amqp
stub class representing AMQPExchange from pecl-amqp
stub class representing AMQPExchangeException from pecl-amqp
stub class representing AMQPExchangeValue from pecl-amqp
stub class representing AMQPQueue from pecl-amqp
stub class representing AMQPQueueException from pecl-amqp
stub class representing AMQPTimestamp from pecl-amqp
Interface representing AMQP values
The APCIterator class
The APCUIterator class
The Aerospike client class
\Aerospike\Bytes is a utility for wrapping PHP strings containing potentially harmful bytes such as \0. By wrapping the binary-string, the Aerospike client will serialize the data into an as_bytes rather than an as_string.
An Iterator that iterates over several iterators one after the other.
ArgumentCountError is thrown when too few arguments are passed to a user defined routine.
ArithmeticError is thrown when an error occurs while performing mathematical operations.
Interface to provide accessing objects as arrays.
This iterator allows to unset and modify values and keys while iterating over Arrays and Objects.
This class allows objects to work as arrays.
AssertionError is thrown when an assertion made via {assert()} fails.
Exception thrown if a callback refers to an undefined function or if some arguments are missing.
Exception thrown if a callback refers to an undefined method or if some arguments are missing.
Blackfire extension stubs.
The COM class allows you to instantiate an OLE compatible COM object and call its methods and access its properties.
This object supports cached iteration over another iterator.
Filtered iterator using the callback to determine which items are accepted or rejected.
The main entry point to the PHP Driver for Apache Cassandra.
A PHP representation of an aggregate
Batch statements are used to execute a series of simple or prepared statements.
A PHP representation of the CQL bigint datatype
A PHP representation of the CQL blob datatype
Cluster object is used to create Sessions.
Cluster builder allows fluent configuration of the cluster instance.
A PHP representation of the CQL list datatype
A PHP representation of a column
A class for representing custom values.
A PHP representation of the CQL date type.
A PHP representation of the CQL decimal datatype
A PHP representation of an aggregate
Default cluster implementation.
A PHP representation of a column
A PHP representation of a public function
A PHP representation of an index
A PHP representation of a keyspace
A PHP representation of a materialized view
A PHP representation of a schema
A session is used to prepare and execute statements.
A PHP representation of a table
A PHP representation of the CQL duration datatype
An interface implemented by all exceptions thrown by the PHP Driver.
AlreadyExistsException is raised when attempting to re-create existing keyspace.
AuthenticationException is raised when client was not configured with valid authentication credentials.
ConfigurationException is raised when query is syntactically correct but invalid because of some configuration issue.
Cassandra domain exception.
Cassandra domain exception.
ExecutionException is raised when something went wrong during request execution.
Cassandra invalid argument exception.
InvalidQueryException is raised when query is syntactically correct but invalid.
InvalidSyntaxException is raised when CQL in the request is syntactically incorrect.
IsBootstrappingException is raised when a node is bootstrapping.
Cassandra logic exception.
OverloadedException is raised when a node is overloaded.
ProtocolException is raised when a client did not follow server's protocol, e.g. sending a QUERY message before STARTUP. Seeing this error can be considered a bug.
Cassandra domain exception.
ReadTimeoutException is raised when a coordinator failed to receive acks from the required number of replica nodes in time during a read.
Cassandra runtime exception.
ServerException is raised when something unexpected happened on the server.
TimeoutException is generally raised when a future did not resolve within a given time interval.
TruncateException is raised when something went wrong during table truncation.
UnauthorizedException is raised when the current user doesn't have sufficient permissions to access data.
UnavailableException is raised when a coordinator detected that there aren't enough replica nodes available to fulfill the request.
UnpreparedException is raised when a given prepared statement id does not exist on the server. The driver should be automatically re-preparing the statement in this case. Seeing this error could be considered a bug.
ValidationException is raised on invalid request, before even attempting to execute it.
WriteTimeoutException is raised when a coordinator failed to receive acks from the required number of replica nodes in time during a write.
Request execution options.
A PHP representation of the CQL float datatype
A PHP representation of a function
Futures are returns from asynchronous methods.
A future returned from Session::closeAsync().
A future returned from Session::prepareAsync()
This future will resolve with a PreparedStatement or an exception.
This future results is resolved with Rows.
A future that resolves with Session.
A future that always resolves in a value.
A PHP representation of an index
A PHP representation of the CQL inet datatype
A PHP representation of a keyspace
A PHP representation of the CQL map datatype
A PHP representation of a materialized view
Common interface implemented by all numeric types, providing basic arithmetic functions.
Prepared statements are faster to execute because the server doesn't need to process a statement's CQL during the execution.
Interface for retry policies.
The default retry policy. This policy retries a query, using the request's original consistency level, in the following cases:
A retry policy that will downgrade the consistency of a request in an attempt to save a request in cases where there is any chance of success. A write request will succeed if there is at least a single copy persisted and a read request will succeed if there is some data available even if it increases the risk of reading stale data. This policy will retry in the same scenarios as the default policy, and it will also retry in the following case:
A retry policy that never retries and allows all errors to fallthrough.
A retry policy that logs the decisions of its child policy.
Rows represent a result of statement execution.
SSL options for Cluster.
SSLOptions builder allows fluent configuration of ssl options.
A PHP representation of a schema
A session is used to prepare and execute statements.
A PHP representation of the CQL set datatype
Simple statements can be executed using a Session instance.
A PHP representation of the CQL smallint datatype.
All statements implement this common interface.
A PHP representation of a table
A PHP representation of the CQL time type.
A PHP representation of the CQL timestamp datatype
Interface for timestamp generators.
A timestamp generator that generates monotonically increasing timestamps client-side. The timestamps generated have a microsecond granularity with the sub-millisecond part generated using a counter. The implementation guarantees that no more than 1000 timestamps will be generated for a given clock tick even if shared by multiple session objects. If that rate is exceeded then a warning is logged and timestamps stop incrementing until the next clock tick.
A timestamp generator that allows the server-side to assign timestamps.
A PHP representation of the CQL timeuuid datatype
A PHP representation of the CQL tinyint datatype.
A PHP representation of the CQL tuple datatype
Cluster object is used to create Sessions.
A class that represents the list type. The list type contains the type of the elements contain in the list.
A class that represents a custom type.
A class that represents the map type. The map type contains two types that represents the types of the key and value contained in the map.
A class that represents a primitive type (e.g. varchar or bigint)
A class that represents the set type. The set type contains the type of the elements contain in the set.
A class that represents the tuple type. The tuple type is able to represent a composite type of one or more types accessed by index.
A class that represents a user type. The user type is able to represent a composite type of one or more types accessed by name.
A PHP representation of the CQL UDT datatype
A PHP representation of the CQL uuid datatype
A PHP representation of the CQL uuid datatype
Common interface implemented by all Cassandra value types.
A PHP representation of the CQL varint datatype
Class used to represent anonymous functions.
(PECL pthreads >= 2.0.8)
Represents a garbage-collectable object.
Class CompileError
Thrown for exceptions that originate from analytics operations.
Represents a Analytics query (currently experimental support).
Interface for retrieving results from analytics queries.
Occurs when authentication has failed.
Interface of authentication containers.
Occurs when an operation is attempted with bad input.
Base exception for exceptions that are thrown originating from Couchbase operations.
BinaryCollection is an object containing functionality for performing KeyValue operations against the server with binary documents.
A FTS query that queries fields explicitly indexed as boolean.
A compound FTS query that allows various combinations of sub-queries.
Represents connection to the Couchbase Server
Provides management capabilities for the Couchbase Bucket
Occurs when the specified bucket does not exist.
Occurs when an operation has been performed with a cas value that does not the value on the server.
Authenticator based on login/password credentials.
Represents a Couchbase Server Cluster.
Provides management capabilities for a Couchbase Server Cluster
Collection is an object containing functionality for performing KeyValue operations against the server.
Occurs when the specified collection does not exist.
A compound FTS query that performs a logical AND between all its sub-queries (conjunction).
Interface for results created by the counter operation.
A range (or bucket) for a date range facet result. Counts the number of matches that fall into the named range (which can overlap with other user-defined ranges).
A facet that categorizes hits inside date ranges (or buckets) provided by the user.
A FTS query that matches documents on a range of values. At least one bound is required, and the inclusiveness of each bound can be configured.
A compound FTS query that performs a logical OR between all its sub-queries (disjunction). It requires that a minimum of the queries match. The minimum is configurable (default 1).
A FTS query that matches on Couchbase document IDs. Useful to restrict the search space to a list of keys (by using this in a compound query).
Represents Couchbase Document, which stores metadata and the value.
A fragment of a JSON Document returned by the sub-document API.
Occurs when the requested document could not be found.
Occurs when the specified durability could not be met for a mutation operation.
An object which contains levels of durability that can be enforced when using mutation operations.
Exception represeting all errors generated by the extension
Interface for results created by the exists operation.
A FTS query which allows to match geo bounding boxes.
A FTS query that finds all matches from a given location (point) within the given distance.
A FTS query that finds all matches within the given polygon area.
Interface for results created by the getReplica operation.
Interface for results created by the get operation.
Thrown for exceptions that originate from underlying Http operations.
Occurs when an invalid configuration has been specified for an operation.
Occurs when a sub-document counter operation is performed and the specified delta is not valid.
Occurs when a multi-operation sub-document operation is performed on a soft-deleted document.
Occurs when an attempt is made to insert a document but a document with that key already exists.
Occurs when a mutation operation is attempted against a document that is locked.
Base for exceptions that originate from key value operations
Implements a default meter which logs metrics on a regular basis. Note that to reduce the performance impact of using this meter, this class is not actually used by the SDK, and simply acts as a placeholder which triggers a native implementation to be used instead.
Indicates to retrieve the count of array items or dictionary keys within a path in a document.
Indicates to check if a path exists in a document.
Indicates to retreive a whole document.
Indicates a path for a value to be retrieved from a document.
A builder for subdocument lookups. In order to perform the final set of operations, use the execute() method.
Interface for results created by the lookupIn operation.
LookupInSpec is an interface for providing subdocument lookup operations.
A FTS query that matches all indexed documents (usually for debugging purposes).
A FTS query that matches 0 document (usually for debugging purposes).
A FTS query that matches several given terms (a "phrase"), applying further processing like analyzers to them.
A FTS query that matches a given term, applying further processing to it like analyzers, stemming and even #fuzziness(int).
Providers an interface to create value recorders for recording metrics.
Indicates to add a value into an array at a path in a document so long as that value does not already exist in the array.
Indicates to append a value to an array at a path in a document.
Indicates to insert a value into an array at a path in a document.
Indicates to prepend a value to an array at a path in a document.
Indicates to increment or decrement a counter value at a path in a document.
A builder for subdocument mutations. In order to perform the final set of operations, use the execute() method.
Interface for results created by the mutateIn operation.
MutateInSpec is an interface for providing subdocument mutation operations.
Indicates to insert a value at a path in a document.
Indicates to remove a value at a path in a document.
Indicates to replace a value at a path if it doesn't exist in a document.
Indicates to replace a value at a path if it doesn't exist, otherwise create the path, in a document.
Interface for results created by operations that perform mutations.
Container for mutation tokens.
An object which contains meta information of the document needed to enforce query consistency.
Represents N1QL index definition
Represents a N1QL query
Occurs when various generic network errors occur.
Implements a no-op meter which performs no metrics instrumentation. Note that to reduce the performance impact of using this meter, this class is not actually used by the SDK, and simply acts as a placeholder which triggers a native implementation to be used instead.
Implements a no-op tracer which performs no work. Note that to reduce the performance impact of using this tracer, this class is not actually used by the SDK, and simply acts as a placeholder which triggers a native implementation to be used instead.
A range (or bucket) for a numeric range facet result. Counts the number of matches that fall into the named range (which can overlap with other user-defined ranges).
A facet that categorizes hits into numerical ranges (or buckets) provided by the user.
A FTS query that matches documents on a range of values. At least one bound is required, and the inclusiveness of each bound can be configured.
Authenticator based on RBAC feature of Couchbase Server 5+.
Occurs when a sub-document operation expects a path not to exists, but the path was found in the document.
Occurs when a sub-document operation targets a path which does not exist in the specified document.
A FTS query that matches several terms (a "phrase") as is. The order of the terms mater and no further processing is applied to them, so they must appear in the index exactly as provided. Usually for debugging purposes, prefer MatchPhraseQuery.
A FTS query that allows for simple matching on a given prefix.
Thrown for exceptions that originate from query operations.
Thrown for exceptions that originate from query operations.
Interface for retrieving metadata such as errors and metrics generated during N1QL queries.
Set of values for setting the profile mode of a query.
Interface for retrieving results from N1QL queries.
Set of values for the scan consistency level of a query.
A FTS query that performs a search according to the "string query" syntax.
A FTS query that allows for simple matching of regular expressions.
Represents a span of time an event occurs over.
Represents a tracer capable of creating trace spans.
Base interface for all results generated by KV operations.
Scope is an object for providing access to collections.
Occurs when the specified scope does not exist.
Thrown for exceptions that originate from search operations.
Common interface for all search facets
Interface representing facet results.
Interface for retrieving metadata such as error counts and metrics generated during search queries.
Represents full text search query
Common interface for all classes, which could be used as a body of SearchQuery
Interface for retrieving results from search queries.
Base class for all FTS sort options in querying.
Sort by a field in the hits.
Sort by a location and unit in the hits.
Sort by the document identifier.
Sort by the hit score.
Occurs when the requested service is not available.
Represents spatial Couchbase Map/Reduce View query
An object which contains how to define the document level action to take during a MutateIn operation.
Occurs when a subdocument operation could not be completed.
Occurs when an operation has failed for a reason that is temporary.
A range (or bucket) for a term search facet result.
A FTS query that matches documents on a range of values. At least one bound is required, and the inclusiveness of each bound can be configured.
A facet that gives the number of occurrences of the most recurring terms in all hits.
A facet that gives the number of occurrences of the most recurring terms in all hits.
This implements a basic default tracer which keeps track of operations which falls outside a specified threshold. Note that to reduce the performance impact of using this tracer, this class is not actually used by the SDK, and simply acts as a placeholder which triggers a native implementation to be used instead.
Occurs when an operation does not receive a response in a timely manner.
Represents settings for new/updated user.
Provides an interface for recording values.
Occurs when a document has gone over the maximum size allowed by the server.
Thrown for exceptions that originate from view operations.
Interface for retrieving metadata generated during view queries.
Represents regular Couchbase Map/Reduce View query
Common interface for all View queries
Interface for retrieving results from view queries.
Object for accessing a row returned as a part of the results from a viery query.
A FTS query that allows for simple matching using wildcard characters (* and ?).
Classes implementing Countable can be used with the count function.
Class for base64 encoding and docoding
Exception class for base64 errors
Class providing CMAC functionality
Class providing cipher algorithms
Exception class for cipher errors
Class providing HMAC functionality
Class providing hash algorithms
Exception class for hash errors
Abstract class for KDF subclasses
Exception class for KDF errors
Abstract class for MAC subclasses
Exception class for MAC errors
Class providing PBKDF2 functionality
Exception class for PBKDF2 errors
Class for generating random numbers
Exception class for rand errors
The DOMAttr interface represents an attribute in an DOMElement object.
The DOMCdataSection inherits from DOMText for textural representation of CData constructs.
The DOMCharacterData class represents nodes with character data.
The DOMComment class represents comment nodes, characters delimited by lt;!-- and -->.
The DOMDocument class represents an entire HTML or XML document; serves as the root of the document tree.
The DOMDocumentFragment class
The DOMDocumentType class
The DOMElement class
The DOMEntity class represents a known entity, either parsed or unparsed, in an XML document.
Extends DOMNode.
DOM operations raise exceptions under particular circumstances, i.e., when an operation is impossible to perform for logical reasons.
The DOMImplementation interface provides a number of methods for performing operations that are independent of any particular instance of the document object model.
The DOMNamedNodeMap class
The DOMNode class
The DOMNodeList class
The DOMNotation class
The DOMProcessingInstruction class
The DOMText class inherits from
The DOMXPath class (supports XPath 1.0)
The DOTNET class allows you to instantiate a class from a .Net assembly and call its methods and access its properties.
Representation of date interval. A date interval stores either a fixed amount of time (in years, months, days, hours etc) or a relative time string in the format that DateTime's constructor supports.
Representation of date period.
Representation of date and time.
Representation of time zone
Instances of Directory are created by calling the dir() function, not by the new operator.
The DirectoryIterator class provides a simple interface for viewing the contents of filesystem directories.
DivisionByZeroError is thrown when an attempt is made to divide a number by zero.
Exception thrown if a value does not adhere to a defined valid data domain.
Collection is the base interface which covers functionality common to all the data structures in this library. It guarantees that all structures are traversable, countable, and can be converted to json using json_encode().
Hashable is an interface which allows objects to be used as keys. It’s an alternative to spl_object_hash(), which determines an object’s hash based on its handle: this means that two objects that are considered equal by an implicit definition would not treated as equal because they are not the same instance.
A pair is used by Ds\Map to pair keys with values.
A PriorityQueue is very similar to a Queue. Values are pushed into the queue with an assigned priority, and the value with the highest priority will always be at the front of the queue.
A Queue is a “first in, first out” or “FIFO” collection that only allows access to the value at the front of the queue and iterates in that order, destructively.
A Sequence describes the behaviour of values arranged in a single, linear dimension. Some languages refer to this as a "List". It’s similar to an array that uses incremental integer keys, with the exception of a few characteristics:
- Values will always be indexed as [0, 1, 2, …, size - 1].
- Only allowed to access values by index in the range [0, size - 1].
Use cases:
- Wherever you would use an array as a list (not concerned with keys).
- A more efficient alternative to SplDoublyLinkedList and SplFixedArray.
A Set is a sequence of unique values. This implementation uses the same hash table as Ds\Map, where values are used as keys and the mapped value is ignored.
A Stack is a “last in, first out” or “LIFO” collection that only allows access to the value at the top of the structure and iterates in that order, destructively.
A Vector is a sequence of values in a contiguous buffer that grows and shrinks automatically. It’s the most efficient sequential structure because a value’s index is a direct mapping to its index in the buffer, and the growth factor isn't bound to a specific multiple or exponent.
Data to create custom error event
Class ElasticApm is a facade (as in Facade design pattern) to the rest of Elastic APM public API.
This interface has functionality shared between Transaction and Span contexts'.
This interface has functionality shared between Transaction and Span.
An object containing contextual data about the destination for spans
Class to gather optional parameters to start a new transaction
The EmptyIterator class for an empty iterator.
Error is the base class for all internal PHP error exceptions.
An Error Exception.
Ev is a singleton providing access to the default loop and to some common operations.
Class EvCheck
Class EvChild
Class EvEmbed
Class EvFork
Class EvIdle
Class EvIo
Class EvLoop
Class EvPeriodic
Class EvPrepare
Class EvSignal
Class EvStat
Class EvTimer
Class EvWatcher
Exception is the base class for all Exceptions.
Class FANNConnection
FFI class provides access to a simple way to call native functions, access native variables and create/access data structures defined in C language.
Proxy object that provides access to compiled structures.
Class containing C type information.
General FFI exception.
An exception that occurs when parsing invalid header files.
The Filesystem iterator
This abstract iterator filters out unwanted values. This class should be extended to implement custom iterator filters. The FilterIterator::accept must be implemented in the subclass.
Class GEOSGeometry
Class GEOSWKBReader
Class GEOSWKBWriter
Class GEOSWKTReader
Class GEOSWKTWriter
Class: GearmanClient
Class: GearmanException
Class: GearmanJob
Class: GearmanTask
Class: GearmanWorker
Generator objects are returned from generators, cannot be instantiated via new.
Iterates through a file system in a similar fashion to glob.
Class Call
Class CallCredentials
Class Channel
Class ChannelCredentials
Class Server
Class ServerCredentials
Class Timeval
The InfiniteIterator allows one to infinitely iterate over an iterator without having to manually rewind the iterator upon reaching its end.
IntlChar provides access to a number of utility methods that can be used to access information about Unicode characters.
The methods and constants adhere closely to the names and behavior used by the underlying ICU library.
Exception thrown if an argument is not of the expected type.
Interface for external iterators or objects that can be iterated themselves internally.
Interface to create an external Iterator.
This iterator wrapper allows the conversion of anything that is Traversable into an Iterator.
This is a generated file, do not modify it directly!
The attribute specifies possible array keys and their types.
The attribute specifies the expected values of an entity: return values for functions and arguments' values for methods.
Mark a property (or all class properties in the case of a class) as immutable.
For PhpStorm internal use only
For PhpStorm internal use only
For PhpStorm internal use only
For PhpStorm internal use only
Specifies that the parameter is a string that represents source code in a different language.
You can use this facility to mark the function as halting the execution flow.
The attribute specifies possible object field names and their types.
The attribute marks the function that has no impact on the program state or passed parameters used after the function execution.
Class JsonException
Objects implementing JsonSerializable can customize their JSON representation when encoded with json_encode.
Class Judy.
Exception thrown if a length is invalid.
Contains various information about errors thrown by libxml. The error codes are described within the official xmlError API documentation.
The LimitIterator class allows iteration over a limited subset of items in an Iterator.
Exception that represents error in the program logic. This kind of exception should lead directly to a fix in your code.
The LuaSandbox class creates a Lua environment and allows for execution of Lua code.
Base class for LuaSandbox exceptions.
Exception thrown when Lua encounters an error inside an error handler.
Uncatchable LuaSandbox exceptions.
Represents a Lua function, allowing it to be called from PHP.
Exception thrown when Lua cannot allocate memory.
Catchable LuaSandbox runtime exceptions.
Exception thrown when Lua code cannot be parsed.
Exception thrown when the configured CPU time limit is exceeded.
Represents a connection to a set of memcache servers.
Represents a connection to a set of memcached servers.
The connection point between MongoDB and PHP.
A connection between PHP and MongoDB. This class is used to create and manage connections See MongoClient::__construct() and the section on connecting for more information about creating connections.
Represents a database collection.
Result object for database query.
Instances of this class are used to interact with a database.
Class Binary
This interface is implemented by MongoDB\BSON\Binary but may also be used for type-hinting and userland classes.
BSON type for the "DbPointer" type. This BSON type is deprecated, and this class can not be instantiated. It will be created from a BSON symbol type while converting BSON to PHP, and can also be converted back into BSON while storing documents in the database.
BSON type for the Decimal128 floating-point format, which supports numbers with up to 34 decimal digits (i.e. significant digits) and an exponent range of −6143 to +6144.
This interface is implemented by MongoDB\BSON\Decimal128 but may also be used for type-hinting and userland classes.
BSON type for a 64-bit integer.
Class Javascript
Interface JavascriptInterface
Class MaxKey
This interface is implemented by MongoDB\BSON\MaxKey but may also be used for type-hinting and userland classes.
Class MinKey
This interface is implemented by MongoDB\BSON\MinKey but may also be used for type-hinting and userland classes.
Class ObjectId
This interface is implemented by MongoDB\BSON\ObjectId but may also be used for type-hinting and userland classes.
Classes may implement this interface to take advantage of automatic ODM (object document mapping) behavior in the driver.
Class Regex
Classes that implement this interface may return data to be serialized as a BSON array or document in lieu of the object's public properties
BSON type for the "Symbol" type. This BSON type is deprecated, and this class can not be instantiated. It will be created from a BSON symbol type while converting BSON to PHP, and can also be converted back into BSON while storing documents in the database.
Represents a BSON timestamp, which is an internal MongoDB type not intended for general date storage.
Interface TimestampInterface
Interface Type
Represents a BSON date.
This interface is implemented by MongoDB\BSON\UTCDateTime but may also be used for type-hinting and userland classes.
BSON type for the "Undefined" type. This BSON type is deprecated, and this class can not be instantiated. It will be created from a BSON undefined type while converting BSON to PHP, and can also be converted back into BSON while storing documents in the database.
Classes that implement this interface may be specified in a type map for unserializing BSON arrays and documents (both root and embedded).
The BulkWrite collects one or more write operations that should be sent to the server.
The MongoDB\Driver\ClientEncryption class handles creation of data keys for client-side encryption, as well as manually encrypting and decrypting values.
The MongoDB\Driver\Command class is a value object that represents a database command.
The MongoDB\Driver\Cursor class encapsulates the results of a MongoDB command or query and may be returned by MongoDB\Driver\Manager::executeCommand() or MongoDB\Driver\Manager::executeQuery(), respectively.
Class CursorId
This interface is implemented by MongoDB\Driver\Cursor but may also be used for type-hinting and userland classes.
Thrown when the driver fails to authenticate with the server.
Thrown when a bulk write operation fails.
Thrown when a command fails
Base class for exceptions thrown when the driver fails to establish a database connection.
Thrown when the driver fails to establish a database connection within a specified time limit (e.g. connectTimeoutMS).
Base class for exceptions thrown during client-side encryption.
Common interface for all driver exceptions. This may be used to catch only exceptions originating from the driver itself.
Thrown when a query or command fails to complete within a specified time limit (e.g. maxTimeMS).
Thrown when a driver method is given invalid arguments (e.g. invalid option types).
Thrown when the driver is incorrectly used (e.g. rewinding a cursor).
Thrown when the driver encounters a runtime error (e.g. internal error from » libmongoc).
Thrown when the driver fails to establish an SSL connection with the server.
Base class for exceptions thrown by the server. The code of this exception and its subclasses will correspond to the original error code from the server.
Thrown when the driver encounters an unexpected value (e.g. during BSON serialization or deserialization).
Base class for exceptions thrown by a failed write operation.
The MongoDB\Driver\Manager is the main entry point to the extension. It is responsible for maintaining connections to MongoDB (be it standalone server, replica set, or sharded cluster).
Encapsulates information about a failed command.
Encapsulates information about a failed command.
Classes may implement this interface to register an event subscriber that is notified for each started, successful, and failed command event.
Encapsulates information about a successful command.
Base interface for event subscribers.
The MongoDB\Driver\Query class is a value object that represents a database query.
MongoDB\Driver\ReadConcern controls the level of isolation for read operations for replica sets and replica set shards. This option requires the WiredTiger storage engine and MongoDB 3.2 or later.
Class ReadPreference
Class Session
WriteConcern controls the acknowledgment of a write operation, specifies the level of write guarantee for Replica Sets.
The MongoDB\Driver\WriteConcernError class encapsulates information about a write concern error and may be returned by MongoDB\Driver\WriteResult::getWriteConcernError().
The MongoDB\Driver\WriteError class encapsulates information about a write error and may be returned as an array element from MongoDB\Driver\WriteResult::getWriteErrors().
The MongoDB\Driver\WriteResult class encapsulates information about an executed MongoDB\Driver\BulkWrite and may be returned by MongoDB\Driver\Manager::executeBulkWrite().
(PECL mongo >= 1.5.0)
(PECL mongo >= 1.5.0)
A unique identifier created for database objects.
(PECL mongo >= 1.5.0)
(PECL mongo >= 1.3.0)
(PECL mongo >= 1.5.0)
An Iterator that sequentially iterates over all attached iterators
This iterator cannot be rewinded.
The OAuth extension provides a simple interface to interact with data providers using the OAuth HTTP specification to protect private resources.
Manages an OAuth provider class.
OCI8 Collection functionality.
OCI8 LOB functionality for large binary (BLOB) and character (CLOB) objects.
OCI8 Collection functionality.
OCI8 LOB functionality for large binary (BLOB) and character (CLOB) objects.
Exception thrown if a value is not a valid key. This represents errors that cannot be detected at compile time.
Exception thrown when an illegal index was requested. This represents errors that should be detected at compile time.
Classes implementing OuterIterator can be used to iterate over iterators.
Exception thrown when adding an element to a full container.
Represents a connection between PHP and a database server.
Represents an error raised by PDO. You should not throw a PDOException from your own code.
(PHP 5 >= 5.1.0, PHP 7, PECL pdo >= 1.0.0)
Represents a prepared statement and, after the statement is executed, an
associated result set.
A fully opaque class which replaces a pspell config resource as of PHP 8.1.0.
A fully opaque class which replaces a pspell resource as of PHP 8.1.0.
This extended FilterIterator allows a recursive iteration using RecursiveIteratorIterator that only shows those elements which have children.
Single state lexer class.
Parser class.
Multistate lexer class.
ParseError is thrown when an error occurs while parsing PHP code, such as when {eval()} is called.
A fully opaque class which replaces a pgsql link resource as of PHP 8.1.0.
A fully opaque class which replaces a pgsql large object resource as of PHP 8.1.0.
A fully opaque class which replaces a pgsql result resource as of PHP 8.1.0.
The Phar class provides a high-level interface to accessing and creating phar archives.
The PharData class provides a high-level interface to accessing and creating non-executable tar and zip archives. Because these archives do not contain a stub and cannot be executed by the phar extension, it is possible to create and manipulate regular zip and tar files using the PharData class even if phar.readonly php.ini setting is 1.
The PharException class provides a phar-specific exception class for try/catch blocks.
The PharFileInfo class provides a high-level interface to the contents and attributes of a single file within a phar archive.
A class for working with PHP tokens, which is an alternative to the {token_get_all()} function.
(PECL pthreads >= 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.
Class for creation of RRD database file.
Class for exporting data from RRD database to image file.
Class for updating RDD database file.
Exception thrown to indicate range errors during program execution.
This class represents a RAR archive, which may be formed by several volumes (parts) and which contains a number of RAR entries (i.e., files, directories and other special objects such as symbolic links).
A RAR entry, representing a directory or a compressed file inside a RAR archive
This class serves two purposes:
it is the type of the exceptions thrown by the RAR extension functions and methods and it allows, through static
methods to query and define the error behaviour of the extension, i.e., whether exceptions are thrown or only
warnings are emitted.
The following error codes are used:
- -1 - error outside UnRAR library
- 11 - insufficient memory
- 12 - bad data
- 13 - bad archive
- 14 - unknown format
- 15 - file open error
- 16 - file create error
- 17 - file close error
- 18 - read error
- 19 - write error
- 20 - buffer too small
- 21 - unkown RAR error
- 22 - password required but not given
Configuration reference: https://github.com/edenhill/librdkafka/blob/master/CONFIGURATION.md
Configuration reference: https://github.com/edenhill/librdkafka/blob/master/CONFIGURATION.md
This iterator allows to unset and modify values and keys while iterating over Arrays and Objects in the same way as the ArrayIterator. Additionally it is possible to iterate over the current iterator entry.
(PHP 5 >= 5.4.0)
RecursiveCallbackFilterIterator from a RecursiveIterator
The RecursiveDirectoryIterator provides an interface for iterating recursively over filesystem directories.
This abstract iterator filters out unwanted values for a RecursiveIterator.
Classes implementing RecursiveIterator can be used to iterate over iterators recursively.
Can be used to iterate through recursive iterators.
This recursive iterator can filter another recursive iterator via a regular expression.
Allows iterating over a RecursiveIterator to generate an ASCII graphic tree.
Helper autocomplete for php redis extension
Helper autocomplete for php redis extension
Helper autocomplete for php redis cluster extension.
Helper autocomplete for phpredis extension
The reflection class.
The ReflectionClassConstant class reports information about a class constant.
The ReflectionException class.
The ReflectionExtension class reports information about an extension.
The ReflectionFunction class reports information about a function.
A parent class to ReflectionFunction, read its description for details.
The ReflectionGenerator class reports information about a generator.
The ReflectionMethod class reports information about a method.
The ReflectionObject class reports information about an object.
The ReflectionParameter class retrieves information about function's or method's parameters.
The ReflectionProperty class reports information about a classes properties.
The ReflectionReference class provides information about a reference.
The ReflectionType class reports information about a function's parameters.
Reflector is an interface implemented by all exportable Reflection classes.
This iterator can be used to filter another iterator based on a regular expression.
Relay Cluster client.
Relay event class.
Relay flushed event class.
Relay invalidated event class.
Generic Relay exception.
Relay client.
Relay Sentinel client.
Relay Table is a persistent per-worker hash table that can store arbitrary data.
Exception thrown if an error which can only be found on runtime occurs.
Represents SNMP session.
Represents an error raised by SNMP. You should not throw a SNMPException from your own code.
A class that interfaces SQLite 3 databases.
A class that handles result sets for the SQLite 3 extension.
A class that handles prepared statements for the SQLite 3 extension.
Represents an unbuffered SQLite result set. Unbuffered results sets are sequential, forward-seeking only.
Support Vector Machine Library
The SVMModel is the end result of the training process. It can be used to classify previously unseen data.
The Seekable iterator.
Interface for customized serializing.
As of PHP 8.1.0, a class which implements Serializable without also implementing __serialize() and __unserialize()
will generate a deprecation warning.
SessionHandler a special class that can be used to expose the current internal PHP session save handler by inheritance. There are six methods which wrap the six internal session save handler callbacks (open, close, read, write, destroy and gc).
SessionHandlerInterface is an interface which defines a prototype for creating a custom session handler.
SessionUpdateTimestampHandlerInterface is an interface which defines a prototype for updating the life time of an existing session.
An error thrown by simdjson when processing json.
Thrown for error conditions on fields such as $depth that are not expected to be from user-provided JSON, with similar behavior to php 8.0.
Represents an element in an XML document.
The SimpleXMLIterator provides recursive iteration over all nodes of a SimpleXMLElement object.
The SoapClient class provides a client for SOAP 1.1, SOAP 1.2 servers. It can be used in WSDL or non-WSDL mode.
Represents a SOAP fault.
Represents a SOAP header.
Represents parameter to a SOAP call.
The SoapServer class provides a server for the SOAP 1.1 and SOAP 1.2 protocols. It can be used with or without a WSDL service description.
A class representing a variable or object for use with SOAP services.
(PECL solr >= 0.9.2)
Class SolrClient
This class is used to send requests to a Solr server. Currently, cloning and serialization of SolrClient instances is
not supported.
(PECL solr >= 0.9.2)
Class SolrClientException
An exception thrown when there is an error while making a request to the server from the client.
(PECL solr >= 2.2.0)
Class SolrCollapseFunction
(PECL solr >= 2.1.0)
Version not present on php.net documentation, determined here by using PECL solr changelog:
https://pecl.php.net/package-changelog.php?package=solr&release=2.1.0
Class SolrDisMaxQuery
(PECL solr >= 0.9.2)
Class SolrDocument
This class represents a Solr document retrieved from a query response.
(PECL solr >= 0.9.2)
Class SolrDocumentField
This class represents a field in a Solr document. All its properties are read-only.
(PECL solr >= 0.9.2)
Class SolrException
This is the base class for all exception thrown by the Solr extension classes.
(PECL solr >= 0.9.2)
Class SolrGenericResponse
This class represents a response from the solr server.
(PECL solr >= 0.9.2)
Class SolrIllegalArgumentException
This object is thrown when an illegal or invalid argument is passed to a method.
(PECL solr >= 0.9.2)
Class SolrIllegalOperationException
This object is thrown when an illegal or unsupported operation is performed on an object.
(PECL solr >= 0.9.2)
Class SolrInputDocument
This class represents a Solr document that is about to be submitted to the Solr index.
(PECL solr >= 2.2.0)
Class SolrMissingMandatoryParameterException
(PECL solr >= 0.9.2)
Class SolrModifiableParams
This class represents a collection of name-value pairs sent to the Solr server during a request.
(PECL solr >= 0.9.2)
Class SolrObject
This class represents an object whose properties can also by accessed using the array syntax. All its properties are
read-only.
(PECL solr >= 0.9.2)
Class SolrParams
This class represents a a collection of name-value pairs sent to the Solr server during a request.
(PECL solr >= 0.9.2)
Class SolrPingResponse
This class represents a response to a ping request to the server
(PECL solr >= 0.9.2)
Class SolrQuery
This class represents a collection of name-value pairs sent to the Solr server during a request.
(PECL solr >= 0.9.2)
Class SolrQueryResponse
This class represents a response to a query request.
(PECL solr >= 0.9.2)
Class SolrResponse
This class represents a response from the Solr server.
(PECL solr >= 1.1.0, >=2.0.0)
Class SolrServerException
An exception thrown when there is an error produced by the Solr Server itself.
(PECL solr >= 0.9.2)
Class SolrUpdateResponse
This class represents a response to an update request.
(PECL solr >= 0.9.2)
Class SolrUtils
Contains utility methods for retrieving the current extension version and preparing query phrases.
The SplBool class is used to enforce strong typing of the bool type.
SplEnum gives the ability to emulate and create enumeration objects natively in PHP.
The SplFileInfo class offers a high-level object oriented interface to information for an individual file.
The SplFileObject class offers an object oriented interface for a file.
The SplFloat class is used to enforce strong typing of the float type.
The SplInt class is used to enforce strong typing of the integer type.
The SplObserver interface is used alongside SplSubject to implement the Observer Design Pattern.
The SplString class is used to enforce strong typing of the string type.
The SplSubject interface is used alongside SplObserver to implement the Observer Design Pattern.
The SplTempFileObject class offers an object oriented interface for a temporary file.
Abstract parent class for all SPL types.
Stubs for stomp https://pecl.php.net/package/stomp
Stringable interface denotes a class as having a __toString() method.
The visitor is required to provide "parent" attribute to nodes
Class to test typehints of some Reflection* classes as reflection for these classes returns null.
(PECL pthreads >= 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.
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.
Throwable is the base interface for any object that can be thrown via a throw statement in PHP 7, including Error and Exception.
Interface to detect if a class is traversable using foreach.
There are three scenarios where a TypeError may be thrown.
Exception thrown when performing an invalid operation on an empty container, such as removing an element.
Exception thrown if a value does not match with a set of values. Typically this happens when a function calls another function and expects the return value to be of a certain type or value not including arithmetic or buffer related errors.
The VARIANT is COM's equivalent of the PHP zval; it is a structure that can contain a value with a range of different possible types. The VARIANT class provided by the COM extension allows you to have more control over the way that PHP passes values to and from COM.
Is thrown when the type of an argument is correct but the value of it is incorrect. For example, passing a negative integer when the function expects a positive one, or passing an empty string/array when the function expects it to not be empty.
(PECL pthreads >= 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.
Class Excel
Class Format
Weak maps allow creating a map from objects to arbitrary values (similar to SplObjectStorage) without preventing the objects that are used as keys from being garbage collected. If an object key is garbage collected, it will simply be removed from the map.
Weak references allow the programmer to retain a reference to an object which does not prevent the object from being destroyed.
(PECL pthreads >= 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:
- the Worker goes out of scope (no more references remain)
- the programmer calls shutdown
- the script dies
The XMLReader extension is an XML Pull parser. The reader acts as a cursor going forward on the document stream and stopping at each node on the way.
Stubs for XXTEA https://pecl.php.net/package/xxtea.
A action can be defined in a separate file in Yaf(see \Yaf\Controller_Abstract). that is a action method can also be a \Yaf\Action_Abstract class.
Since there should be a entry point which can be called by Yaf (as of PHP 5.3, there is a new magic method __invoke, but Yaf is not only works with PHP 5.3+, Yaf choose another magic method execute), you must implement the abstract method \Yaf\Action_Abstract::execute() in your custom action class.
\Yaf\Application provides a bootstrapping facility for applications which provides reusable resources, common- and module-based bootstrap classes and dependency checking.
Bootstrap is a mechanism used to do some initial config before a Application run.
User may define their own Bootstrap class by inheriting \Yaf\Bootstrap_Abstract
Any method declared in Bootstrap class with leading "_init", will be called by \Yaf\Application::bootstrap() one by one according to their defined order
\Yaf\Config\Ini enables developers to store configuration data in a familiar INI format and read them in the application by using nested object property syntax. The INI format is specialized to provide both the ability to have a hierarchy of configuration data keys and inheritance between configuration data sections. Configuration data hierarchies are supported by separating the keys with the dot or period character ("."). A section may extend or inherit from another section by following the section name with a colon character (":") and the name of the section from which data are to be inherited.
Note:
\Yaf\Config\Ini utilizes the » parse_ini_file() PHP function. Please review this documentation to be aware of its specific behaviors, which propagate to \Yaf\Config\Ini, such as how the special values of "TRUE", "FALSE", "yes", "no", and "NULL" are handled.
\Yaf\Controller_Abstract is the heart of Yaf's system. MVC stands for Model-View-Controller and is a design pattern targeted at separating application logic from display logic.
Every custom controller shall inherit \Yaf\Controller_Abstract.
You will find that you can not define __construct function for your custom controller, thus, \Yaf\Controller_Abstract provides a magic method: \Yaf\Controller_Abstract::init().
If you have defined a init() method in your custom controller, it will be called as long as the controller was instantiated.
Action may have arguments, when a request coming, if there are the same name variable in the request parameters(see \Yaf\Request_Abstract::getParam()) after routed, Yaf will pass them to the action method (see \Yaf\Action_Abstract::execute()).
Note:
These arguments are directly fetched without filtering, it should be carefully processed before use them.
\Yaf\Dispatcher purpose is to initialize the request environment, route the incoming request, and then dispatch any discovered actions; it aggregates any responses and returns them when the process is complete.
\Yaf\Dispatcher also implements the Singleton pattern, meaning only a single instance of it may be available at any given time. This allows it to also act as a registry on which the other objects in the dispatch process may draw.
\Yaf\Loader introduces a comprehensive autoloading solution for Yaf.
The first time an instance of \Yaf\Application is retrieved, \Yaf\Loader will instance a singleton, and registers itself with spl_autoload. You retrieve an instance using the \Yaf\Loader::getInstance()
\Yaf\Loader attempt to load a class only one shot, if failed, depend on yaf.use_spl_autoload, if this config is On \Yaf\Loader::autoload() will return FALSE, thus give the chance to other autoload function. if it is Off (by default), \Yaf\Loader::autoload() will return TRUE, and more important is that a very useful warning will be triggered (very useful to find out why a class could not be loaded).
Note:
Please keep yaf.use_spl_autoload Off unless there is some library have their own autoload mechanism and impossible to rewrite it.
If you want \Yaf\Loader search some classes(libraries) in the local class directory(which is defined in application.ini, and by default, it is application.directory . "/library"), you should register the class prefix using the \Yaf\Loader::registerLocalNameSpace()
Plugins allow for easy extensibility and customization of the framework.
Plugins are classes. The actual class definition will vary based on the component -- you may need to implement this interface, but the fact remains that the plugin is itself a class.
A plugin could be loaded into Yaf by using \Yaf\Dispatcher::registerPlugin(), after registered, All the methods which the plugin implemented according to this interface, will be called at the proper time.
All methods of \Yaf\Registry declared as static, making it universally accessible. This provides the ability to get or set any custom data from anyway in your code as necessary.
\Yaf\Request\Simple is particularly used for test purpose. ie. simulate a spacial request under CLI mode.
\Yaf\Route\Map is a built-in route, it simply convert a URI endpoint (that part of the URI which comes after the base URI: see \Yaf\Request_Abstract::setBaseUri()) to a controller name or action name(depends on the parameter passed to \Yaf\Route\Map::__construct()) in following rule: A => controller A. A/B/C => controller A_B_C. A/B/C/D/E => controller A_B_C_D_E.
If the second parameter of \Yaf\Route\Map::__construct() is specified, then only the part before delimiter of URI will used to routing, the part after it is used to routing request parameters (see the example section of \Yaf\Route\Map::__construct()).
\Yaf\Route\Regex is the most flexible route among the Yaf built-in routes.
For usage, please see the example section of \Yaf\Route\Rewrite::__construct()
\Yaf\Route\Simple will match the query string, and find the route info.
all you need to do is tell \Yaf\Route\Simple what key in the $_GET is module, what key is controller, and what key is action.
\Yaf\Route\Simple::route() will always return TRUE, so it is important put \Yaf\Route\Simple in the front of the Route stack, otherwise all the other routes will not be called
\Yaf\Route_Interface used for developer defined their custom route.
by default, \Yaf\Router only have a \Yaf\Route_Static as its default route.
\Yaf\Route_Static is designed to handle 80% of normal requirements.
Note:
it is unnecessary to instance a \Yaf\Route_Static, also unnecessary to add it into \Yaf\Router's routes stack, since there is always be one in \Yaf\Router's routes stack, and always be called at the last time.
\Yaf\Router is the standard framework router. Routing is the process of taking a URI endpoint (that part of the URI which comes after the base URI: see \Yaf\Request_Abstract::setBaseUri()) and decomposing it into parameters to determine which module, controller, and action of that controller should receive the request. This values of the module, controller, action and other parameters are packaged into a \Yaf\Request_Abstract object which is then processed by \Yaf\Dispatcher. Routing occurs only once: when the request is initially received and before the first controller is dispatched. \Yaf\Router is designed to allow for mod_rewrite-like functionality using pure PHP structures. It is very loosely based on Ruby on Rails routing and does not require any prior knowledge of webserver URL rewriting
Default Route
\Yaf\Router comes pre-configured with a default route \Yaf\Route_Static, which will match URIs in the shape of controller/action. Additionally, a module name may be specified as the first path element, allowing URIs of the form module/controller/action. Finally, it will also match any additional parameters appended to the URI by default - controller/action/var1/value1/var2/value2.
Note:
Module name must be defined in config, considering application.module="Index,Foo,Bar", in this case, only index, foo and bar can be considered as a module name. if doesn't config, there is only one module named "Index".
** See examples by opening the external documentation
\Yaf\View\Simple is the built-in template engine in Yaf, it is a simple but fast template engine, and only support PHP script template.
Yaf provides a ability for developers to use custom view engine instead of build-in engine which is \Yaf\View\Simple. There is a example to explain how to do this, please see \Yaf\Dispatcher::setView()
A action can be defined in a separate file in Yaf(see Yaf_Controller_Abstract). that is a action method can also be a Yaf_Action_Abstract class.
Since there should be a entry point which can be called by Yaf (as of PHP 5.3, there is a new magic method __invoke, but Yaf is not only works with PHP 5.3+, Yaf choose another magic method execute), you must implement the abstract method Yaf_Action_Abstract::execute() in your custom action class.
Yaf_Application provides a bootstrapping facility for applications which provides reusable resources, common- and module-based bootstrap classes and dependency checking.
Bootstrap is a mechanism used to do some initial config before a Application run.
User may define their own Bootstrap class by inheriting Yaf_Bootstrap_Abstract
Any method declared in Bootstrap class with leading "_init", will be called by Yaf_Application::bootstrap() one by one according to their defined order
Yaf_Config_Ini enables developers to store configuration data in a familiar INI format and read them in the application by using nested object property syntax. The INI format is specialized to provide both the ability to have a hierarchy of configuration data keys and inheritance between configuration data sections. Configuration data hierarchies are supported by separating the keys with the dot or period character ("."). A section may extend or inherit from another section by following the section name with a colon character (":") and the name of the section from which data are to be inherited.
Note:
Yaf_Config_Ini utilizes the » parse_ini_file() PHP function. Please review this documentation to be aware of its specific behaviors, which propagate to Yaf_Config_Ini, such as how the special values of "TRUE", "FALSE", "yes", "no", and "NULL" are handled.
Yaf_Controller_Abstract is the heart of Yaf's system. MVC stands for Model-View-Controller and is a design pattern targeted at separating application logic from display logic.
Every custom controller shall inherit Yaf_Controller_Abstract.
You will find that you can not define __construct function for your custom controller, thus, Yaf_Controller_Abstract provides a magic method: Yaf_Controller_Abstract::init().
If you have defined a init() method in your custom controller, it will be called as long as the controller was instantiated.
Action may have arguments, when a request coming, if there are the same name variable in the request parameters(see Yaf_Request_Abstract::getParam()) after routed, Yaf will pass them to the action method (see Yaf_Action_Abstract::execute()).
Note:
These arguments are directly fetched without filtering, it should be carefully processed before use them.
Yaf_Dispatcher purpose is to initialize the request environment, route the incoming request, and then dispatch any discovered actions; it aggregates any responses and returns them when the process is complete.
Yaf_Dispatcher also implements the Singleton pattern, meaning only a single instance of it may be available at any given time. This allows it to also act as a registry on which the other objects in the dispatch process may draw.
Yaf_Loader introduces a comprehensive autoloading solution for Yaf.
The first time an instance of Yaf_Application is retrieved, Yaf_Loader will instance a singleton, and registers itself with spl_autoload. You retrieve an instance using the Yaf_Loader::getInstance()
Yaf_Loader attempt to load a class only one shot, if failed, depend on yaf.use_spl_autoload, if this config is On Yaf_Loader::autoload() will return FALSE, thus give the chance to other autoload function. if it is Off (by default), Yaf_Loader::autoload() will return TRUE, and more important is that a very useful warning will be triggered (very useful to find out why a class could not be loaded).
Note:
Please keep yaf.use_spl_autoload Off unless there is some library have their own autoload mechanism and impossible to rewrite it.
If you want Yaf_Loader search some classes(libraries) in the local class directory(which is defined in application.ini, and by default, it is application.directory . "/library"), you should register the class prefix using the Yaf_Loader::registerLocalNameSpace()
Plugins allow for easy extensibility and customization of the framework.
Plugins are classes. The actual class definition will vary based on the component -- you may need to implement this interface, but the fact remains that the plugin is itself a class.
A plugin could be loaded into Yaf by using Yaf_Dispatcher::registerPlugin(), after registered, All the methods which the plugin implemented according to this interface, will be called at the proper time.
All methods of Yaf_Registry declared as static, making it universally accessible. This provides the ability to get or set any custom data from anyway in your code as necessary.
Yaf_Request_Simple is particularly used for test purpose. ie. simulate a spacial request under CLI mode.
Yaf_Route_Interface used for developer defined their custom route.
Yaf_Route_Map is a built-in route, it simply convert a URI endpoint (that part of the URI which comes after the base URI: see Yaf_Request_Abstract::setBaseUri()) to a controller name or action name(depends on the parameter passed to Yaf_Route_Map::__construct()) in following rule: A => controller A. A/B/C => controller A_B_C. A/B/C/D/E => controller A_B_C_D_E.
If the second parameter of Yaf_Route_Map::__construct() is specified, then only the part before delimiter of URI will used to routing, the part after it is used to routing request parameters (see the example section of Yaf_Route_Map::__construct()).
Yaf_Route_Regex is the most flexible route among the Yaf built-in routes.
For usage, please see the example section of Yaf_Route_Rewrite::__construct()
Yaf_Route_Simple will match the query string, and find the route info.
all you need to do is tell Yaf_Route_Simple what key in the $_GET is module, what key is controller, and what key is action.
Yaf_Route_Simple::route() will always return TRUE, so it is important put Yaf_Route_Simple in the front of the Route stack, otherwise all the other routes will not be called
by default, Yaf_Router only have a Yaf_Route_Static as its default route.
Yaf_Route_Static is designed to handle 80% of normal requirements.
Note:
it is unnecessary to instance a Yaf_Route_Static, also unnecessary to add it into Yaf_Router's routes stack, since there is always be one in Yaf_Router's routes stack, and always be called at the last time.
Yaf_Router is the standard framework router. Routing is the process of taking a URI endpoint (that part of the URI which comes after the base URI: see Yaf_Request_Abstract::setBaseUri()) and decomposing it into parameters to determine which module, controller, and action of that controller should receive the request. This values of the module, controller, action and other parameters are packaged into a Yaf_Request_Abstract object which is then processed by Yaf_Dispatcher. Routing occurs only once: when the request is initially received and before the first controller is dispatched. Yaf_Router is designed to allow for mod_rewrite-like functionality using pure PHP structures. It is very loosely based on Ruby on Rails routing and does not require any prior knowledge of webserver URL rewriting
Default Route
Yaf_Router comes pre-configured with a default route Yaf_Route_Static, which will match URIs in the shape of controller/action. Additionally, a module name may be specified as the first path element, allowing URIs of the form module/controller/action. Finally, it will also match any additional parameters appended to the URI by default - controller/action/var1/value1/var2/value2.
Note:
Module name must be defined in config, considering application.module="Index,Foo,Bar", in this case, only index, foo and bar can be considered as a module name. if doesn't config, there is only one module named "Index".
** See examples by opening the external documentation
Yaf provides a ability for developers to use custom view engine instead of build-in engine which is Yaf_View_Simple. There is a example to explain how to do this, please see Yaf_Dispatcher::setView()
Yaf_View_Simple is the built-in template engine in Yaf, it is a simple but fast template engine, and only support PHP script template.
Class Yar_Client_Exception Date 2018/6/9 下午3:05
Class Yar_Server Date 2018/6/9 下午3:02
Class Yar_Server_Exception Date 2018/6/9 下午3:06
Class ZMQ
Class ZMQContext
Class ZMQDevice
Class ZMQPoll
Class ZMQSocket
Describing a job in a queue In order to add/modify a job in the queue, a Job class must be created/retrieved and than saved in a queue
A file archive, compressed with Zip.
Zookeeper class.
Metadata entry for a single AST kind, as returned by ast\get_metadata().
This class describes a single node in a PHP AST.
Class Objects can be returned by the layerObj_ class, or can be
created using:
Instance of clusterObj is always embedded inside the layerObj_.
Instances of colorObj are always embedded inside other classes.
This extension will throw instances of the class com_exception whenever there is a potentially fatal error reported by COM. All COM exceptions have a well-defined code property that corresponds to the HRESULT return value from the various COM operations. You may use this code to make programmatic decisions on how to handle the exception.
GNUPG Encryption Class
The grid is always embedded inside a layer object defined as a grid (layer->connectiontype = MS_GRATICULE) (for more docs : https://github.com/mapserver/mapserver/wiki/MapServerGrid) A layer can become a grid layer by adding a grid object to it using : ms_newGridObj(layerObj layer) $oLayer = ms_newlayerobj($oMap); $oLayer->set("name", "GRID"); ms_newgridobj($oLayer); $oLayer->grid->set("labelformat", "DDMMSS");
Instance of hashTableObj is always embedded inside the classObj,
layerObj, mapObj and webObj. It is uses a read only.
The HTTP client. See http\Client\Curl's options which is the only driver currently supported.
Interface to an user event loop implementation for http\Client::configure()'s $use_eventloop option.
The http\Client\Request class provides an HTTP message implementation tailored to represent a request message to be sent by the client.
The http\Client\Response class represents an HTTP message the client returns as answer from a server to an http\Client\Request.
A class representing a list of cookies with specific attributes.
Base class for encoding stream implementations.
A stream decoding data encoded with chunked transfer encoding.
A deflate stream supporting deflate, zlib and gzip encodings.
A inflate stream supporting deflate, zlib and gzip encodings.
The http\Env class provides static methods to manipulate and inspect the server's current request's HTTP environment.
The http\Env\Request class' instances represent the server's current HTTP request.
The http\Env\Response class' instances represent the server's current HTTP response.
URL class using the HTTP environment by default.
The http extension's Exception interface.
A bad conversion (e.g. character conversion) was encountered.
A bad HTTP header was encountered.
A bad HTTP message was encountered.
A method was called on an object, which was in an invalid or unexpected state.
A bad querystring was encountered.
A bad HTTP URL was encountered.
One or more invalid arguments were passed to a method.
A generic runtime exception.
An unexpected value was encountered.
The http\Header class provides methods to manipulate, match, negotiate and serialize HTTP headers.
The parser which is underlying http\Header and http\Message.
The message class builds the foundation for any request and response message.
The message body, represented as a PHP (temporary) stream.
The parser which is underlying http\Message.
Parse, interpret and compose HTTP (header) parameters.
The http\QueryString class provides versatile facilities to retrieve, use and manipulate query strings and form data.
The http\Url class provides versatile means to parse, construct and manipulate URLs.
Instances of imageObj are always created by the mapObj_ class methods.
labelObj are always embedded inside other classes.
Layer Objects can be returned by the mapObj_ class, or can be
created using:
A second optional argument can be given to ms_newLayerObj() to create
the new layer as a copy of an existing layer. If a layer is given as
argument then all members of a this layer will be copied in the new
layer created.
Instances of legendObj are always are always embedded inside the mapObj_.
Interface BaseResult
Class Collection
Class CollectionAdd
Class CollectionFind
Class CollectionModify
Class ColumnResult
Interface CrudOperationBindable
Interface CrudOperationLimitable
Interface CrudOperationSkippable
Interface CrudOperationSortable
Interface DatabaseObject
Class DocResult
Class Exception
Interface Executable
Class ExecutionStatus
Class Expression
Class Result
Class RowResult
Class Schema
Interface SchemaObject
Class Session
Class SqlStatement
Class SqlStatementResult
Class Statement
Class Table
Class TableDelete
Class TableInsert
Class TableSelect
Class TableUpdate
Class Warning
Class XSession
Represents a connection between PHP and a MySQL database.
MySQLi Driver.
Represents the result set obtained from a query against the database.
Represents a prepared statement.
Represents one or more MySQL warnings.
This object has two methods that will render a distributed trace payload as text.
Instance of outputformatObj is always embedded inside the mapObj_.
Unbuffered Channels
An unbuffered channel will block on calls to Channel::send() until there is a receiver, and block on calls to Channel::recv() until there is a sender. This means an unbuffered channel is not only a way to share data among tasks but also a simple method of synchronization.
The Event Loop
The Event loop monitors the state of sets of futures and or channels (targets) in order to perform read (Future::value(), Channel::recv()) and write (Channel::send()) operations as the targets become available and the operations may be performed without blocking the event loop.
When an Event is returned, Event::$object shall be removed from the loop that returned it, should the event be a write event the Input for Event::$source shall also be removed.
Events Input
An Input object is a container for data that the \parallel\Events object will write to \parallel\Channel objects as they become available. Multiple event loops may share an Input container - parallel does not verify the contents of the container when it is set as the input for a \parallel\Events object.
A Future represents the return value or uncaught exception from a task, and exposes an API for cancellation.
Each runtime represents a single PHP thread, the thread is created (and bootstrapped) upon construction. The thread then waits for tasks to be scheduled: Scheduled tasks will be executed FIFO and then the thread will resume waiting until more tasks are scheduled, or it's closed, killed, or destroyed by the normal scoping rules of PHP objects.
The Sync class provides access to low level synchronization primitives, mutex, condition variables, and allows the implementation of semaphores.
Fast import/export using COPY.
Request cancellation of an asynchronous query.
The connection to the PostgreSQL server.
Interface for type conversions.
Declare a cursor.
A simple DateTime wrapper with predefined formats which supports stringification and JSON.
A base interface for all pq\Exception classes.
A method call was not expected.
Implementation or SQL syntax error.
An invalid argument was passed to a method.
A runtime exception occurred.
A large object.
A query result.
A named prepared statement.
A database transaction.
Accessor to the PostgreSQL pg_type relation.
Instances of querymapObj are always are always embedded inside the
mapObj_.
rectObj are sometimes embedded inside other objects. New ones can also be created with:
Instances of referenceMapObj are always embedded inside the mapObj_.
Instances of scalebarObj are always embedded inside the mapObj_.
Created by typecasting to object.
Instances of styleObj are always embedded inside a classObj or labelObj.
An HTML node in an HTML file, as detected by tidy.
An HTML node in an HTML file, as detected by tidy.
Instances of webObj are always are always embedded inside the mapObj_.