Specify a literal (non looked up) value for the constructor of the
previously registered item.

@see withDependencies(), addConstructorLookup()

@param mixed $value

@return Dependency
500377
public function addConstructorValue($value)
        {
            $endPoint =& $this->_getEndPoint();

            if (!isset($endPoint['args'])) {
                $endPoint['args'] = array();
            }

            $endPoint['args'][] = array(
                'type' => 'value',
                'item' => $value
            );

            return $this;
        }
804464
protected function buildValue($value)
    {
        if ($value instanceof Model || is_null($value)) {
            return $value;
        }

        $model = $this->attribute->getAttribute('type');
        $instance = new $model();

        $instance->setAttribute('entity_id', $this->entity->getKey());
        $instance->setAttribute('entity_type', get_class($this->entity));
        $instance->setAttribute($this->attribute->getForeignKey(), $this->attribute->getKey());
        $instance->setAttribute('content', $value);

        return $instance;
    }
288316
public function setNewValue($value)
    {
        if ((!$this->disablePurifier) && $value && is_string($value)) {
            $value = Purifier::clean($value, $this->purifierConfig);
        }

        $this->newValue = $value;

        return $this;
    }
184632
public function addKkTrixionarySkillVersion($value)
    {
        $currentArray = $this->getKkTrixionarySkillVersions();
        $currentArray []= $value;
        $this->setKkTrixionarySkillVersions($currentArray);

        return $this;
    }
1293074
public function setValue($value)
    {
        switch ($this->type) {
            case Parameter::TYPE_INTEGER:
                $this->value = (int) $value;
                break;
            case Parameter::TYPE_STRING:
            case Parameter::TYPE_ANY:
            default:
                $this->value = (string) $value;
        }

        return $this;
    }
341049
public function wrap($value)
		{
			// This method is primarily for convenience so we can just pass a
			// column or table instance into the wrap method without sending
			// in the name each time we need to wrap one of these objects.
			if ($value instanceof Table) {
				return $this->wrap_table($value->name);
			} elseif ($value instanceof Fluent) {
				$value = $value->name;
			}

			return parent::wrap($value);
		}
502223
public static function make($value)
    {
        if (is_resource($value)) {
            $value = null;
        } elseif (Arr::accessible($value)) {
            $value = new ArraySerialization($value);
        } elseif ($value instanceof stdClass) {
            $value = new ObjectSerialization($value);
        } elseif ($value instanceof Container) {
            $value = new ContainerSerialization($value);
        } elseif ($value instanceof DateTime) {
            $value = new DateTimeSerialization($value);
        } elseif ($value instanceof Validator) {
            $value = new ValidatorSerialization($value);
        } elseif ($value instanceof Throwable) {
            $value = new ThrowableSerialization($value);
        } elseif ($value instanceof Closure) {
            $value = null;
        }

        return $value;
    }
1024397
public function wrap($value)
    {
        if ($value instanceof Fluent) $value = $value->name;

        return parent::wrap($value);
    }
628416
public function match($value)
    {
        usort($this->rules, array($this, 'sort'));

        foreach ($this->rules as $rule) {
            $match = $rule->match($value);

            if ($match === false) {
                continue;
            }

            $this->matchParams = $match;

            return $this->dependencyManager->get($rule->getController());
        }

        return $this->dependencyManager->get($this->catchallController);
    }
573205
public static function fromValue( $value )
	{
		$result = new ContextProvider();
		$result->m_iter = XPath2NodeIterator::Create( $value );
		return $result;
	}
447018
public function setValue($value = null)
    {
        if (is_callable($value)) {
            $value = call_user_func($value);
        }

        $value = $this->handleJsonType($value);

        $this->value = $value;

        return $this;
    }
567327
protected static function fix($value)
    {
        if (is_array($value)) {
            return new Seq(array_map(function ($item) {
                return self::fix($item);
            }, $value));
        }

        // kinda redundant
        if (is_object($value) && get_class($value) === \stdClass::class) {
            return new Dict(array_map(function ($item) {
                return self::fix($item);
            }, (array)$value));
        }

        return $value;
    }
765429
protected function resolveInstanceMethod($value)
	{
		$callable = explode('->', $value);
		$instantiator = $this->instantiator;
		$callable[0] = $instantiator($callable[0]);
		return function (...$params) use ($callable) {
			return call_user_func_array($callable, $params);
		};
	}
702919
public function equivalentTo($value)
    {
        $message = ['%s is {{not|}} equivalent to %s', $this->value, $value];
        $this->assert(($this->value == $value), $message);

        return $this;
    }
683399
public function exor($value){
        if($this->value !== null){
            return $this->markErrorIf($value !== null);
        }
        if($value !== null){
            return $this->markErrorIf($this->value !== null);
        }
        return $this;
    }
415537
public function wrap($value = null)
    {
        $exceptionFactory   = new ExceptionFactory($this->presenter);
        $wrappedObject      = new WrappedObject($value, $this->presenter);
        $caller             = new Caller($wrappedObject, $this->example, $this->dispatcher, $exceptionFactory, $this);
        $arrayAccess        = new SubjectWithArrayAccess($caller, $this->presenter, $this->dispatcher);
        $expectationFactory = new ExpectationFactory($this->example, $this->dispatcher, $this->matchers);

        return new Subject(
            $value, $this, $wrappedObject, $caller, $arrayAccess, $expectationFactory
        );
    }
193687
public function typeIs($value)
    {
        $this->add(new Criterium(self::CRITERIUM_TYPE_IS, (int) $value));

        return $this;
    }