Download the PHP package sun/staticreflection without Composer

On this page you can find all versions of the php package sun/staticreflection. It is possible to download/install these versions without Composer. Possible dependencies are resolved automatically.

FAQ

After the download, you have to make one include require_once('vendor/autoload.php');. After that you have to import the classes with use statements.

Example:
If you use only one package a project is not needed. But if you use more then one package, without a project it is not possible to import the classes with use statements.

In general, it is recommended to use always a project to download your libraries. In an application normally there is more than one library needed.
Some PHP packages are not free to download and because of that hosted in private repositories. In this case some credentials are needed to access such packages. Please use the auth.json textarea to insert credentials, if a package is coming from a private repository. You can look here for more information.

  • Some hosting areas are not accessible by a terminal or SSH. Then it is not possible to use Composer.
  • To use Composer is sometimes complicated. Especially for beginners.
  • Composer needs much resources. Sometimes they are not available on a simple webspace.
  • If you are using private repositories you don't need to share your credentials. You can set up everything on our site and then you provide a simple download link to your team member.
  • Simplify your Composer build process. Use our own command line tool to download the vendor folder as binary. This makes your build process faster and you don't need to expose your credentials for private repositories.
Please rate this library. Is it a good library?

Example code of sun/staticreflection

Informations about the package staticreflection

StaticReflection Build Status Code Coverage Code Quality

Static PHP class code reflection for post-discovery scenarios.

This utility library for PHP frameworks allows to reflect the file header of a PHP class without loading its code into memory, if its filesystem location is known already (e.g., via discovery/classmap).

Static reflection is useful to filter a large list of previously discovered class files for common aspects like interfaces or base classes.

ReflectionClass provides the same API as the native \ReflectionClass.

Native PHP Reflection can easily grow out of control, because it not only loads the reflected class, but also all dependent classes and interfaces. PHP code cannot be unloaded. A high memory consumption may cause the application to exceed PHP's memory limit. — Static reflection avoids to (auto-)load all dependencies and ancestor classes of each reflected class into memory.

In the worst/ideal use-case, you're only generating a list of available classes, without using them immediately (e.g., for user selection or swappable plugin implementations).

Example xhprof diff result:

1,538 candidate classes, of which 180 interfaces, traits, abstract and other helper classes are filtered out:

\ReflectionClass ReflectionClass Diff Diff%
Number of Function Calls 64,747 202,783 138,036 213.2%
Incl. Wall Time (microsecs) 2,514,801 3,272,539 757,738 30.1%
Incl. CPU (microsecs) 2,480,415 3,120,020 639,605 25.8%
Incl. MemUse (bytes) 108,805,120 10,226,160 -98,578,960 -90.6%
Incl. PeakMemUse (bytes) 108,927,216 10,347,608 -98,579,608 -90.5%

Usage Example

  1. Prerequisite: Some discovery produces a classmap:

    → You have a classname => pathname map.

  2. Filter all discovered class files:

    → You filtered the list of available classes, without loading all code into memory.

  3. Why this matters:

    → Only the ancestors of each class/interface were loaded. The statically reflected classes themselves did not get loaded.

  4. ProTip™ - ReflectionClass::isSubclassOfAny()

    To filter for a set of common parent classes/interfaces, check the statically reflected information first. Only proceed to isSubclassOf() in case you need to check further; e.g.:

Requirements

Limitations

  1. Only one class/interface/trait per file (PSR-2, PSR-0/PSR-4), which must be defined first in the file.

  2. implementsInterface($interface) returns TRUE even if $interface is a class.

  3. \ReflectionClass::IS_IMPLICIT_ABSTRACT is not supported, since methods are not analyzed. (only the file header is analyzed)

  4. \ReflectionClass::$name is read-only and thus not available. Use getName() instead.

  5. Calling any other \ReflectionClass methods that are not implemented (yet) causes a fatal error.

    The parent \ReflectionClass class might be lazily instantiated on-demand in the future (PRs welcome). ReflectionClass does implement all methods that can be technically supported already.

Notes

Inspirations

Static/Reflection:

PHPDoc tags/annotations:

License

MIT — Copyright (c) 2014 Daniel F. Kudwien (sun)

All versions of staticreflection with dependencies

PHP Build Version
Package Version
Requires php Version >=5.4.2
ext-tokenizer Version *
ext-reflection Version *
Composer command for our command line client (download client) This client runs in each environment. You don't need a specific PHP version etc. The first 20 API calls are free. Standard composer command

The package sun/staticreflection contains the following files

Loading the files please wait ....