PHPackages                             eloquent/enumeration - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Utility & Helpers](/categories/utility)
4. /
5. eloquent/enumeration

AbandonedArchivedLibrary[Utility & Helpers](/categories/utility)

eloquent/enumeration
====================

An enumeration implementation for PHP.

6.0.0(7y ago)1465.8M↑14.9%11[3 issues](https://github.com/eloquent/enumeration/issues)[1 PRs](https://github.com/eloquent/enumeration/pulls)20MITPHPPHP >=7.1

Since Mar 24Pushed 2y ago2 watchersCompare

[ Source](https://github.com/eloquent/enumeration)[ Packagist](https://packagist.org/packages/eloquent/enumeration)[ Docs](https://github.com/eloquent/enumeration)[ RSS](/packages/eloquent-enumeration/feed)WikiDiscussions master Synced 1mo ago

READMEChangelog (10)Dependencies (1)Versions (19)Used By (20)

> # No longer maintained
>
> [](#no-longer-maintained)
>
> This package is no longer maintained. See [this statement](https://gist.github.com/ezzatron/713a548735febe3d76f8ca831bc895c0) for more info.

Enumeration
===========

[](#enumeration)

*An enumeration implementation for PHP.*

[![Current version image](https://camo.githubusercontent.com/1717741e5894a3b288ea486cd3a35b3c03ee5b78629302a5cf31f26c451cd7cb/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f762f656c6f7175656e742f656e756d65726174696f6e2e7376673f7374796c653d666c61742d737175617265 "This project uses semantic versioning")](https://packagist.org/packages/eloquent/enumeration)[![Current build status image](https://camo.githubusercontent.com/402770ce623cd299a2f5c014f0f3dc927489e9af9e1a2b63a4e5efbb6f5bd539/687474703a2f2f696d672e736869656c64732e696f2f7472617669732f656c6f7175656e742f656e756d65726174696f6e2f6d61737465722e7376673f7374796c653d666c61742d737175617265 "Current build status for the master branch")](https://travis-ci.org/eloquent/enumeration)[![Current coverage status image](https://camo.githubusercontent.com/85c242788acee95570d2882f41374a7831cc176f1dba5e43f9466ede5bdf118b/68747470733a2f2f696d672e736869656c64732e696f2f636f6465636f762f632f6769746875622f656c6f7175656e742f656e756d65726174696f6e2f6d61737465722e7376673f7374796c653d666c61742d737175617265 "Current test coverage for the master branch")](https://codecov.io/github/eloquent/enumeration)

Installation
------------

[](#installation)

- Available as [Composer](http://getcomposer.org/) package [eloquent/enumeration](https://packagist.org/packages/eloquent/enumeration).

What is an Enumeration?
-----------------------

[](#what-is-an-enumeration)

In terms of software development, an enumeration (or "enumerated type") is essentially a fixed set of values. These values are called "members" or "elements".

An enumeration is used in circumstances where it is desirable to allow an argument to be only one of a particular set of values, and where anything else is considered invalid.

A basic example
---------------

[](#a-basic-example)

*Enumeration* can be used like [C++ enumerated types](https://en.wikipedia.org/wiki/Enumerated_type#C.2B.2B). Here is an example, representing a set of HTTP request methods:

```
use Eloquent\Enumeration\AbstractEnumeration;

final class HttpRequestMethod extends AbstractEnumeration
{
    const OPTIONS = 'OPTIONS';
    const GET = 'GET';
    const HEAD = 'HEAD';
    const POST = 'POST';
    const PUT = 'PUT';
    const DELETE = 'DELETE';
    const TRACE = 'TRACE';
    const CONNECT = 'CONNECT';
}
```

This class can now be used in a type hint to easily accept any valid HTTP request method:

```
function handleHttpRequest(HttpRequestMethod $method, $url, $body = null)
{
    // handle request...
}
```

Accessing enumeration members
-----------------------------

[](#accessing-enumeration-members)

Members are accessed by static method calls, like so:

```
handleHttpRequest(HttpRequestMethod::GET(), 'http://example.org/');
handleHttpRequest(HttpRequestMethod::POST(), 'http://example.org/', 'foo=bar&baz=qux');
```

For each member of the enumeration, a single instance of the enumeration class is instantiated (that is, an instance of `HttpRequestMethod` in the above example). This means that strict comparison (===) can be used to determine which member has been passed to a function:

```
function handleHttpRequest(HttpRequestMethod $method, $url, $body = null)
{
    if ($method === HttpRequestMethod::POST()) {
        // handle POST requests...
    } else {
        // handle other requests...
    }
}
```

Java-style enumerations
-----------------------

[](#java-style-enumerations)

[Java's enum types](https://en.wikipedia.org/wiki/Enumerated_type#Java) have slightly more functionality than C++ enumerated types. They can have additional properties and/or methods, and are really just a specialised kind of class where there are a fixed set of instances.

This is sometimes called the [Multiton](http://en.wikipedia.org/wiki/Multiton_pattern) pattern, and in fact, all enumerations in this implementation are Multitons. The `AbstractEnumeration` class simply defines its members based upon class constants.

Here is an example borrowed from the Java documentation for its enum types. The following multiton describes all of the planets in our solar system, including their masses and radii:

```
use Eloquent\Enumeration\AbstractMultiton;

final class Planet extends AbstractMultiton
{
    /**
     * Universal gravitational constant.
     *
     * @var float
     */
    const G = 6.67300E-11;

    /**
     * @return float
     */
    public function surfaceGravity()
    {
        return self::G * $this->mass / ($this->radius * $this->radius);
    }

    /**
     * @param float $otherMass
     *
     * @return float
     */
    public function surfaceWeight($otherMass)
    {
        return $otherMass * $this->surfaceGravity();
    }

    protected static function initializeMembers()
    {
        new static('MERCURY', 3.302e23,  2.4397e6);
        new static('VENUS',   4.869e24,  6.0518e6);
        new static('EARTH',   5.9742e24, 6.37814e6);
        new static('MARS',    6.4191e23, 3.3972e6);
        new static('JUPITER', 1.8987e27, 7.1492e7);
        new static('SATURN',  5.6851e26, 6.0268e7);
        new static('URANUS',  8.6849e25, 2.5559e7);
        new static('NEPTUNE', 1.0244e26, 2.4764e7);
        // new static('PLUTO',   1.31e22,   1.180e6);
    }

    /**
     * @param string $key
     * @param float  $mass
     * @param float  $radius
     */
    protected function __construct($key, $mass, $radius)
    {
        parent::__construct($key);

        $this->mass = $mass;
        $this->radius = $radius;
    }

    private $mass;
    private $radius;
}
```

The above class can be used to take a known weight on earth (in any unit) and calculate the weight on all of the planets (in the same unit):

```
$earthWeight = 175;
$mass = $earthWeight / Planet::EARTH()->surfaceGravity();

foreach (Planet::members() as $planet) {
    echo sprintf(
        'Your weight on %s is %f' . PHP_EOL,
        $planet,
        $planet->surfaceWeight($mass)
    );
}
```

If the above script is executed, it will produce something like the following output:

```
Your weight on MERCURY is 66.107480
Your weight on VENUS is 158.422560
Your weight on EARTH is 175.000000
Your weight on MARS is 66.279359
Your weight on JUPITER is 442.677903
Your weight on SATURN is 186.513785
Your weight on URANUS is 158.424919
Your weight on NEPTUNE is 199.055584

```

Enumerations and class inheritance
----------------------------------

[](#enumerations-and-class-inheritance)

When an enumeration is defined, the intent is usually to define a set of valid values that should not change, at least within the lifetime of a program's execution.

Since PHP has no in-built support for enumerations, this library implements them as regular PHP classes. Classes, however, allow for much more extensibility than is desirable in a true enumeration.

For example, a naive enumeration implementation might allow a developer to extend the `HttpRequestMethod` class from the examples above (assuming the `final` keyword is removed):

```
class CustomHttpMethod extends HttpRequestMethod
{
    const PATCH = 'PATCH';
}
```

The problem with this scenario is that all the code written to expect only the HTTP methods defined in `HttpRequestMethod` is now compromised. Anybody can extend `HttpRequestMethod` to add custom values, essentially voiding the reason for defining `HttpRequestMethod` in the first place.

This library provides built-in protection from these kinds of circumstances. Attempting to define an enumeration that extends another enumeration will result in an exception being thrown, unless the 'base' enumeration is abstract.

### Abstract enumerations

[](#abstract-enumerations)

Assuming that there really is a need to extend `HttpRequestMethod`, the way to go about it is to define an abstract base class, then extend this class to create the desired concrete enumerations:

```
use Eloquent\Enumeration\AbstractEnumeration;

abstract class AbstractHttpRequestMethod extends AbstractEnumeration
{
    const OPTIONS = 'OPTIONS';
    const GET = 'GET';
    const HEAD = 'HEAD';
    const POST = 'POST';
    const PUT = 'PUT';
    const DELETE = 'DELETE';
    const TRACE = 'TRACE';
    const CONNECT = 'CONNECT';
}

final class HttpRequestMethod extends AbstractHttpRequestMethod {}

final class CustomHttpMethod extends AbstractHttpRequestMethod
{
    const PATCH = 'PATCH';
}
```

In this way, when a developer uses a type hint for `HttpRequestMethod`, there is no chance they will ever receive the 'PATCH' method:

```
function handleHttpRequest(HttpRequestMethod $method, $url, $body = null)
{
    // only handles normal requests...
}

function handleCustomHttpRequest(
    CustomHttpRequestMethod $method,
    $url,
    $body = null
) {
    // handles normal requests, and custom requests...
}
```

###  Health Score

47

—

FairBetter than 94% of packages

Maintenance20

Infrequent updates — may be unmaintained

Popularity59

Moderate usage in the ecosystem

Community31

Small or concentrated contributor base

Maturity67

Established project with proven stability

 Bus Factor1

Top contributor holds 85.2% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Every ~152 days

Recently: every ~459 days

Total

17

Last Release

2735d ago

Major Versions

1.0.0 → 2.0.02012-07-04

2.1.2 → 3.0.02012-08-21

3.0.2 → 4.0.02013-08-13

4.0.0 → 5.0.02013-11-11

5.1.1 → 6.0.02018-11-22

PHP version history (3 changes)0.1.0PHP >=5.3.0

4.0.0PHP >=5.3

6.0.0PHP >=7.1

### Community

Maintainers

![](https://avatars.githubusercontent.com/u/100152?v=4)[Erin](/maintainers/ezzatron)[@ezzatron](https://github.com/ezzatron)

---

Top Contributors

[![ezzatron](https://avatars.githubusercontent.com/u/100152?v=4)](https://github.com/ezzatron "ezzatron (46 commits)")[![Bilge](https://avatars.githubusercontent.com/u/470626?v=4)](https://github.com/Bilge "Bilge (5 commits)")[![jmalloc](https://avatars.githubusercontent.com/u/761536?v=4)](https://github.com/jmalloc "jmalloc (1 commits)")[![koden-km](https://avatars.githubusercontent.com/u/1037307?v=4)](https://github.com/koden-km "koden-km (1 commits)")[![shin1x1](https://avatars.githubusercontent.com/u/88324?v=4)](https://github.com/shin1x1 "shin1x1 (1 commits)")

---

Tags

typeenumclassenumerationsetmultiton

###  Code Quality

TestsPHPUnit

### Embed Badge

![Health badge](/badges/eloquent-enumeration/health.svg)

```
[![Health](https://phpackages.com/badges/eloquent-enumeration/health.svg)](https://phpackages.com/packages/eloquent-enumeration)
```

###  Alternatives

[marc-mabe/php-enum

Simple and fast implementation of enumerations with native PHP

49644.8M97](/packages/marc-mabe-php-enum)[consistence/consistence

Consistence - consistent approach and additions to PHP's functionality

1831.1M18](/packages/consistence-consistence)[cerbero/enum

Zero-dependencies package to supercharge enum functionalities.

359207.5k2](/packages/cerbero-enum)[garoevans/php-enum

Convenient way to always have an Enum object available and utilise Spl Types if available.

19158.8k5](/packages/garoevans-php-enum)[cerbero/laravel-enum

Laravel package to supercharge enum functionalities.

18989.6k](/packages/cerbero-laravel-enum)[emreyarligan/enum-concern

A PHP package for effortless Enumeration handling with Laravel Collections 📦 ✨

21156.3k1](/packages/emreyarligan-enum-concern)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)