Returns the name of the constant which matches the enum value
@return string
489282
public function getName(){
		
		foreach(static::getConstants() as $name => $value){
			if($this->_Value === $value){
				return $name;
			}
		}
		
		return null;
		
	}
277185
private function PlainValue()
    {
        if ($this->lexer->isNextToken(DocLexer::T_OPEN_CURLY_BRACES)) {
            return $this->Arrayx();
        }

        if ($this->lexer->isNextToken(DocLexer::T_AT)) {
            return $this->Annotation();
        }

        if ($this->lexer->isNextToken(DocLexer::T_IDENTIFIER)) {
            return $this->Constant();
        }

        switch ($this->lexer->lookahead['type']) {
            case DocLexer::T_STRING:
                $this->match(DocLexer::T_STRING);
                return $this->lexer->token['value'];

            case DocLexer::T_INTEGER:
                $this->match(DocLexer::T_INTEGER);
                return (int)$this->lexer->token['value'];

            case DocLexer::T_FLOAT:
                $this->match(DocLexer::T_FLOAT);
                return (float)$this->lexer->token['value'];

            case DocLexer::T_TRUE:
                $this->match(DocLexer::T_TRUE);
                return true;

            case DocLexer::T_FALSE:
                $this->match(DocLexer::T_FALSE);
                return false;

            case DocLexer::T_NULL:
                $this->match(DocLexer::T_NULL);
                return null;

            default:
                $this->syntaxError('PlainValue');
        }
    }
19122
public function getModeName()
    {
        return $this->isNumericData()
            ? self::NUMERIC_MODE
            : ( $this->isAlphaNumericData()
                ? self::ALPHA_NUMERIC_MODE
                : self::EIGHT_BITS_MODE
            );
    }
1338530
public static function getName($value)
    {
        $enumerables = self::getCache();
        $result = array_search($value, $enumerables, true);
        
        if ($result === false) {
            throw EnumerableException::valueNotFound();
        }
        
        return $result;
    }
1056844
public function getEnum()
    {
        $classNames = ClassInfo::subclassesFor($this->getBaseClass());
        $dataobject = strtolower(DataObject::class);
        unset($classNames[$dataobject]);
        return array_values($classNames);
    }
1197323
public static function getNameByConstant($constant)
    {
        switch ($constant) {
            case self::AUTHOR:
                return 'author';
            break;

            case self::CANDIDATE:
                return 'candidate';
            break;

            case self::PROCTOR:
                return 'proctor';
            break;

            case self::SCORER:
                return 'scorer';
            break;

            case self::TEST_CONSTRUCTOR:
                return 'testConstructor';
            break;

            case self::TUTOR:
                return 'tutor';
            break;

            default:
                return false;
            break;
        }
    }
667657
public function getNames(){
		
		$isSet = PHPArray::filter(static::getConstants(), function($value){
			return $this->hasFlag($value);
		});
		
		return \array_keys($isSet);
		
	}
132700
public function nameSuffix()
    {
        $atoms = $this->nameAtoms();
        if (count($atoms) > 1) {
            array_shift($atoms);

            return implode(static::EXTENSION_SEPARATOR, $atoms);
        }

        return null;
    }
260033
private function getConstants()
    {
        if (empty($this->constants)) {
            try {
                $reflection      = new \ReflectionClass($this->getClassName());
                $this->constants = $reflection->getConstants();
            } catch (\ReflectionException $e) {
                $this->constants = [];
            }
        }

        return $this->constants;
    }
620610
public function getConstant($name)
    {
        $constants = $this->getConstants();
        $value = array_key_exists($name, $constants);
        if ($value) {
            $value = $constants[$name];
        }
        return $value;
    }
789216
private function constDeclaration() {
    $node = new ConstantDeclarationNode();
    $name_node = new NameNode();
    $this->mustMatch(T_STRING, $name_node, NULL, TRUE);
    $node->addChild($name_node, 'name');
    if ($this->mustMatch('=', $node)) {
      $node->addChild($this->staticScalar(), 'value');
    }
    return $node;
  }
1171447
public function GetDeclarationCode()
    {
        $code = "";
        
        if($this->is_const)
            $code .= "const ";
        
        if($this->is_unsigned)
            $code .= "unsigned ";
        
        $code .= $this->type;
        
        if($this->is_reference)
            $code .= "&";
        
        if($this->is_pointer)
        {
            for($i=0; $i<$this->indirection_level; $i++)
            {
                $code .= "*";
            }
        }
        
        if($this->is_array)
            $code .= "[]";
    }
1195396
public static function getAllNames()
    {
        $className = get_called_class();

        if (!array_key_exists($className, self::$constantsArray)) {
            try {
                $class = new ReflectionClass($className);
            } catch (ReflectionException $e) {
                throw new RuntimeException($e->getMessage(), (int)$e->getCode(), $e);
            }

            self::$constantsArray[$className] = array_keys($class->getConstants());
        }

        return self::$constantsArray[$className];
    }
1100368
public function getConstants()
    {
        if ($this->constants === null) {
            $prettyPrinter = new PrettyPrinter\Standard;
            // lazy load class constants list
            $this->constants = array();
            foreach ($this->node->stmts as $stmt) {
                if ($stmt instanceof Node\Stmt\ClassConst) {
                    foreach ($stmt->consts as $const) {
                        $this->constants[$const->name] = trim(
                            $prettyPrinter->prettyPrintExpr($const->value),
                            '"\''
                        );
                    }
                }
            }
        }
        return $this->constants;
    }
874458
def enum_value(self):
        """"""
        if not hasattr(self, '_enum_value'):
            assert self.kind == CursorKind.ENUM_CONSTANT_DECL
            # Figure out the underlying type of the enum to know if it
            # is a signed or unsigned quantity.
            underlying_type = self.type
            if underlying_type.kind == TypeKind.ENUM:
                underlying_type = underlying_type.get_declaration().enum_type
            if underlying_type.kind in (TypeKind.CHAR_U,
                                        TypeKind.UCHAR,
                                        TypeKind.CHAR16,
                                        TypeKind.CHAR32,
                                        TypeKind.USHORT,
                                        TypeKind.UINT,
                                        TypeKind.ULONG,
                                        TypeKind.ULONGLONG,
                                        TypeKind.UINT128):
                self._enum_value = \
                  conf.lib.clang_getEnumConstantDeclUnsignedValue(self)
            else:
                self._enum_value = conf.lib.clang_getEnumConstantDeclValue(self)
        return self._enum_value
658823
public static function getNameByConstant($constant)
    {
        switch ($constant) {
            case self::IDENTIFIER:
                return 'identifier';
            break;

            case self::BOOLEAN:
                return 'boolean';
            break;

            case self::INTEGER:
                return 'integer';
            break;

            case self::FLOAT:
                return 'float';
            break;

            case self::STRING:
                return 'string';
            break;

            case self::POINT:
                return 'point';
            break;

            case self::PAIR:
                return 'pair';
            break;

            case self::DIRECTED_PAIR:
                return 'directedPair';
            break;

            case self::DURATION:
                return 'duration';
            break;

            case self::FILE:
                return 'file';
            break;

            case self::URI:
                return 'uri';
            break;

            case self::INT_OR_IDENTIFIER:
                return 'intOrIdentifier';
            break;

            case self::COORDS:
                return 'coords';
            break;

            default:
                return false;
            break;
        }
    }
1340382
public function get_option_name_from_constant($constant) {
        if (is_null(self::$constants)) {
            $constants = get_defined_constants(true);
            $constants = isset($constants['curl']) ? $constants['curl'] : array();
            $constants = array_flip($constants);
            self::$constants = $constants;
        }
        if (isset(self::$constants[$constant])) {
            return self::$constants[$constant];
        }
        throw new coding_exception('Unknown curl constant value: ' . $constant);
    }