Current File : /home2/selectio/public_html/3-idiots/vendor/psy/psysh/src/Reflection/ReflectionClassConstant.php
<?php
/*
* This file is part of Psy Shell.
*
* (c) 2012-2023 Justin Hileman
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Psy\Reflection;
/**
* Somehow the standard reflection library didn't include class constants until 7.1.
*
* ReflectionClassConstant corrects that omission.
*/
class ReflectionClassConstant implements \Reflector
{
public $class;
public $name;
private $value;
/**
* Construct a ReflectionClassConstant object.
*
* @param string|object $class
* @param string $name
*/
public function __construct($class, string $name)
{
if (!$class instanceof \ReflectionClass) {
$class = new \ReflectionClass($class);
}
$this->class = $class;
$this->name = $name;
$constants = $class->getConstants();
if (!\array_key_exists($name, $constants)) {
throw new \InvalidArgumentException('Unknown constant: '.$name);
}
$this->value = $constants[$name];
}
/**
* Exports a reflection.
*
* @param string|object $class
* @param string $name
* @param bool $return pass true to return the export, as opposed to emitting it
*
* @return string|null
*/
public static function export($class, string $name, bool $return = false)
{
$refl = new self($class, $name);
$value = $refl->getValue();
$str = \sprintf('Constant [ public %s %s ] { %s }', \gettype($value), $refl->getName(), $value);
if ($return) {
return $str;
}
echo $str."\n";
}
/**
* Gets the declaring class.
*/
public function getDeclaringClass(): \ReflectionClass
{
$parent = $this->class;
// Since we don't have real reflection constants, we can't see where
// it's actually defined. Let's check for a constant that is also
// available on the parent class which has exactly the same value.
//
// While this isn't _technically_ correct, it's prolly close enough.
do {
$class = $parent;
$parent = $class->getParentClass();
} while ($parent && $parent->hasConstant($this->name) && $parent->getConstant($this->name) === $this->value);
return $class;
}
/**
* Get the constant's docblock.
*
* @return false
*/
public function getDocComment(): bool
{
return false;
}
/**
* Gets the class constant modifiers.
*
* Since this is only used for PHP < 7.1, we can just return "public". All
* the fancier modifiers are only available on PHP versions which have their
* own ReflectionClassConstant class :)
*/
public function getModifiers(): int
{
return \ReflectionMethod::IS_PUBLIC;
}
/**
* Gets the constant name.
*/
public function getName(): string
{
return $this->name;
}
/**
* Gets the value of the constant.
*
* @return mixed
*/
public function getValue()
{
return $this->value;
}
/**
* Checks if class constant is private.
*
* @return bool false
*/
public function isPrivate(): bool
{
return false;
}
/**
* Checks if class constant is protected.
*
* @return bool false
*/
public function isProtected(): bool
{
return false;
}
/**
* Checks if class constant is public.
*
* @return bool true
*/
public function isPublic(): bool
{
return true;
}
/**
* To string.
*/
public function __toString(): string
{
return $this->getName();
}
/**
* Gets the constant's file name.
*
* Currently returns null, because if it returns a file name the signature
* formatter will barf.
*/
public function getFileName()
{
return;
// return $this->class->getFileName();
}
/**
* Get the code start line.
*
* @throws \RuntimeException
*/
public function getStartLine()
{
throw new \RuntimeException('Not yet implemented because it\'s unclear what I should do here :)');
}
/**
* Get the code end line.
*
* @throws \RuntimeException
*/
public function getEndLine()
{
return $this->getStartLine();
}
/**
* Get a ReflectionClassConstant instance.
*
* In PHP >= 7.1, this will return a \ReflectionClassConstant from the
* standard reflection library. For older PHP, it will return this polyfill.
*
* @param string|object $class
* @param string $name
*
* @return ReflectionClassConstant|\ReflectionClassConstant
*/
public static function create($class, string $name)
{
if (\class_exists(\ReflectionClassConstant::class)) {
return new \ReflectionClassConstant($class, $name);
}
return new self($class, $name);
}
}
Mini Shell