@param bool $isConst

@return \Fubhy\GraphQL\Language\Node\ValueInterface

@throws \Exception
485026
protected function parseValue($isConst)
    {
        $start = $this->token->getStart();
        $token = $this->token;

        switch ($this->token->getType()) {
            case Token::BRACKET_L_TYPE:
                return $this->parseArray($isConst);
            case Token::BRACE_L_TYPE:
                return $this->parseObject($isConst);
            case Token::INT_TYPE:
                $this->advance();
                return new IntValue($token->getValue(), $this->location($start));
            case Token::FLOAT_TYPE:
                $this->advance();
                return new FloatValue($token->getValue(), $this->location($start));
            case Token::STRING_TYPE:
                $this->advance();
                return new StringValue($token->getValue(), $this->location($start));
            case Token::NAME_TYPE:
                $this->advance();
                switch ($value = $token->getValue()) {
                    case 'true':
                    case 'false':
                        return new BooleanValue($value === 'true', $this->location($start));
                }
                return new EnumValue($value, $this->location($start));
            case Token::DOLLAR_TYPE:
                if (!$isConst) {
                    return $this->parseVariable();
                }
                break;
        }

        throw $this->unexpected();
    }
92789
protected function lexList(bool $isConst): ListValueNode
    {
        $start = $this->lexer->getToken();

        $parseFunction = function () use ($isConst) {
            return $this->lexValue($isConst);
        };

        return new ListValueNode(
            $this->any(
                TokenKindEnum::BRACKET_L,
                $parseFunction,
                TokenKindEnum::BRACKET_R
            ),
            $this->createLocation($start)
        );
    }
318035
public function addValue(ValueInterface $value)
    {
        if ($value instanceof ContextualValueInterface && !$value->getContext()) {
            $value->setContext($this->getCurrentContext());
        }
        $this->getAttribute($value->getAttributeCode()); // Only to check that the attribute does exists

        $this->values->add($value);
        $value->setData($this);

        $this->addValueByAttribute($value);

        return $this;
    }
1079010
private function startApp(bool $isConsole)
  {
    /**
     * Create a new instance of the service resolver
     */
    $this->service = new AppServiceResolver;

    /**
     * Start the App Service Resolver
     */
    $this->service->start(Application::prototype($isConsole));

    /**
     * Load framework plugins
     */
    Load::plugins($isConsole);

    /**
     * Extend the medusa templating language
     */
    $this->directives();
  }
1001475
public function ifFalse($bool)
    {
        if (null !== $this->apply) {
            throw new \RuntimeException('Cannot nest ifTrue or ifFalse call');
        }

        $this->apply = (false === $bool);

        return $this;
    }
1328402
public function equals(ValueObjectInterface $obj)
    {
        if (get_called_class() !== get_class($obj)) {
            return false;
        }

        /** @var ValueObjectInterface $this */
        return $this->getValue() === $obj->getValue();
    }
884549
private function assertBoolean($key, $value)
    {
        if (!is_bool($value) && null !== $value) {
            throw new InvalidConfigException(sprintf(
                'The config key "%s" must be a bool. Got: %s',
                $key,
                is_object($value) ? get_class($value) : gettype($value)
            ));
        }
    }
168036
public static function init($isFinal = true) {
		
		$parent = get_parent_class(get_called_class());
		if( empty($parent) ) {
			return;
		}
		
		static::$fields = array_unique(array_merge(static::$fields, $parent::$fields));
		// Deprecated, no more defining editable fields, rely on form and EntityDescriptor
		if( !$parent::$editableFields ) {
			static::$editableFields = !static::$editableFields ? $parent::$editableFields : array_unique(array_merge(static::$editableFields, $parent::$editableFields));
		}
		// Deprecated, should use EntityDescriptor as validator
		if( is_array(static::$validator) && is_array($parent::$validator) ) {
			static::$validator = array_unique(array_merge(static::$validator, $parent::$validator));
		}
		if( !static::$domain ) {
			static::$domain = static::$table;
		}
	}
1191372
protected function evaluateConst()
    {
        
        common_Logger::d('CONSTANTE TYPE', array('Generis Term evaluateConst'));
	    $property = new core_kernel_classes_Property(RulesRdf::PROPERTY_TERM_VALUE);
	    return $this->getUniquePropertyValue($property); 
        
    }
1141514
public function setBoolValue($boolValue)
    {
        if (\is_array($boolValue) || \is_object($boolValue)) {
            $m = "Invalid value type for attribute {$this->getFamilyCode()}.{$this->getAttributeCode()}, ";
            $m .= 'expecting boolean, got'.gettype($boolValue);
            throw new \UnexpectedValueException($m);
        }
        $this->boolValue = null === $boolValue ? null : (bool) $boolValue;

        return $this;
    }
509108
private function getValueTypeCheckCallback($valueTypes)
    {
        $callback = function ($value) {
            return false;
        };

        // the callback code will return true as soon as an accepted value type is found
        if ($valueTypes & Specifications::TYPE_INTEGER) {
            $callback = function ($value) use ($callback) {
                return is_numeric($value) || $callback($value);
            };
        }
        if ($valueTypes & Specifications::TYPE_STRING) {
            $callback = function ($value) use ($callback) {
                return is_string($value) || $callback($value);
            };
        }
        if ($valueTypes & Specifications::TYPE_BOOLEAN) {
            $callback = function ($value) use ($callback) {
                return is_bool($value) || $callback($value);
            };
        }

        return $callback;
    }
275310
protected function lexObjectField(bool $isConst): ObjectFieldNode
    {
        $start = $this->lexer->getToken();

        /**
         * @param bool $isConst
         * @return NodeInterface|TypeNodeInterface|ValueNodeInterface
         */
        $parseValue = function (bool $isConst): NodeInterface {
            $this->expect(TokenKindEnum::COLON);
            return $this->lexValue($isConst);
        };

        return new ObjectFieldNode(
            $this->lexName(),
            $parseValue($isConst),
            $this->createLocation($start)
        );
    }
131649
public function prepare($bindings= array (), $byValue= true, $cacheFlag= null) {
        $this->stmt= null;
        if ($this->construct() && $this->stmt= $this->xpdo->prepare($this->sql)) {
            $this->bind($bindings, $byValue, $cacheFlag);
        } else {
            $this->xpdo->log(xPDO::LOG_LEVEL_ERROR, 'Could not construct or prepare query because it is invalid or could not connect: ' . $this->sql);
        }
        return $this->stmt;
    }
1126656
public function when(bool $condition, callable $trueCallable, callable $falseCallable): BaseQueryRelateContract
    {
        $this->query = call_user_func($condition ? $trueCallable : $falseCallable, $this)->getQuery();

        return $this;
    }
1186831
public function setType($type = null)
    {
        if (is_array($type)) {
            $detected = 0;
            foreach ($type as $value) {
                if (is_int($value)) {
                    $detected += $value;
                } elseif (in_array($value, $this->constants)) {
                    $detected += array_search($value, $this->constants);
                }
            }

            $type = $detected;
        } elseif (is_string($type) && in_array($type, $this->constants)) {
            $type = array_search($type, $this->constants);
        }

        if (!is_int($type) || ($type < 0) || ($type > self::TYPE_ALL)) {
            throw new Exception\InvalidArgumentException(sprintf(
                'Unknown type value "%s" (%s)',
                $type,
                gettype($type)
            ));
        }

        $this->options['type'] = $type;
        return $this;
    }
869206
public function is($value, bool $is_column = false): WhereStatement
    {
        return $this->addCondition($value, '=', $is_column);
    }
16038
public function isTransaction($newValue = null)
    {
        if (null !== $newValue) {
            $this->isTransaction = (bool) $newValue;
        }
        return $this->isTransaction;
    }