contains
Contains is as same as "*value*" match
@param mixed $field
@param mixed $value
@access public
@return void
502933
public function contains($field, $value)
    {
        if(!$value instanceof Expr\ConditionalExpression) {
            $value = $this->buildPart($value);
        }
        return new Expr\TextComparisonExpression($field, $value, Expr\TextComparisonExpression::CONTAIN);
    }
501054
public function containsField($field)
    {
        $identifier = $field instanceof FieldInterface ? $field->getFieldElementName() : $field;
        foreach ($this->getList() as $error) {
            $field = $error->getField();
            if (is_object($field) && $field->getFieldElementName() == $identifier) {
                return true;
            }
        }

        return false;
    }
468245
public function contains($value)
    {
        if (\is_array($value)) {
            /** @noinspection ForeachSourceInspection */
            foreach ($value as $item) {
                $this->contains($item);
            }
        } else {
            $this->predicates[] = '*' . $this->processValue($value) . '*';
        }

        return $this;
    }
1353191
public function like($field, $value) {
        $this->add($field, Expr::LIKE, $value);

        return $this;
    }
917290
public function containsValue($value): bool {
        TypeHelper::validateValue($value, $this);
        foreach ($this as $v) {
            if ($value == $v) {
                return true;
            }
        }

        return false;
    }
523508
public function contains($value): bool
    {
        if (null === $value) {
            return false;
        }

        if ($this->belowMinBorder($value)) {
            return false;
        }

        return !$this->aboveMaxBorder($value);
    }
377749
public function prefilled($field, $value)
    {
        $this->fields[ $field ] = [
            'type'  => self::TYPE_PREFILLED_VALUE,
            'value' => $value
        ];

        return $this;
    }
505479
public function contains($value, $strict = TRUE)
    {
        return $this->containsIn($value, $strict, $this->all());
    }
718248
protected function validateContains($field, $value, $params)
    {
        if (!isset($params[0])) {
            return false;
        }
        if (!\is_string($value) || !\is_string($params[0])) {
            return false;
        }

        $strict = true;
        if (isset($params[1])) {
            $strict = (bool) $params[1];
        }

        if ($strict) {
            return \mb_strpos($value, $params[0]) !== false;
        }

        return \mb_stripos($value, $params[0]) !== false;
    }
1154363
public function set($field, $value)
    {
        $client = $this->getClient();

        $client->hset(
            $this->getKey()->getName(),
            $field,
            $value
        );

        // Integer reply, specifically:
        // 1 if field is a new field in the hash and value was set.
        // 0 if field already exists in the hash and the value was updated.

        return true;
    }
243096
public function setNewValue($field, $value)
    {
        $this->assertValidField($field);

        $this->entityChangeSet[$field][1] = $value;
    }
976531
private function isRequired($field, $value) {
		
		if(true === isset($this -> required[$field])) {
			
			$empty = true;

			if(true === is_array($value)) {

				foreach($value as $val) {

					if(strlen(trim($val)) > 0) {
						$empty = false;
					}
				}
			}

			if(true === is_string($value) && strlen(trim($value)) > 0) {
				$empty = false;
			}

			if(false === $this -> required[$field] && $empty) {
			    return true;
			}
		}

		return false;
	}
312228
public function containsValue($value): bool {
        $node = $this->getHead();
        while ($node !== null) {
            if (Comparator::equals($node->getValue(), $value)) {
                return true;
            }
            $node = $node->getNext();
        }
        return false;
    }
997298
public function contains($key, $value = null): bool
    {
        if (func_num_args() == 2) {
            return $this->contains(function ($k, $item) use ($key, $value) {
                return ArrayHelper::getValue($item, $key) == $value;
            });
        }

        if ($this->useAsCallable($key)) {
            return !is_null($this->first($key));
        }

        return in_array($key, $this->items);
    }
1051148
protected function validateRequired($field, $value)
    {
        if (is_null($value)) {
            return false;
        } elseif (is_string($value) && '' === trim($value)) {
            return false;
        }

        return true;
    }
1100411
public function setResult($field, $value)
    {
        if (!isset($this->results[$field])) {
            $this->results[$field] = $value;
        }

        return $this;
    }
42160
public function contains($value)
    {
        if (is_array($this->value)) {
            /** @var Element $val */
            foreach ($this->value as $val) {
                if ($val->equals($value)) {
                    return true;
                }
            }

            return false;
        } else {
            return $this->equals($value);
        }
    }