@param string $property
@param string $values
@param string $format

@Given the ":format" response should be filtered by ":property" ":values"
506092
public function assertResponseFiltering($property, $values, $format)
    {
        \PHPUnit_Framework_Assert::assertSame(
            $expected = !empty($values) ? array_map('trim', explode(';', $values)) : [],
            $data = $this->decodeByProperty($property, $format),
            sprintf(
                'The filtering does not match for the property "%s". Expected "%s", got "%s".',
                $property,
                json_encode($expected),
                json_encode($data)
            )
        );
    }
1028022
public function applyFilterRule($property, Rules\Rule $filterRule) 
    {
                
        $value = $this->getPropertyValue($property);
        
        $filteredValue = $filterRule->applyFilter($value);
        
        $this->setPropertyValue($property, $filteredValue);
        
    }
700230
public function setFieldsPropertyValues($property,$values){
		$i=0;
		if(\is_array($values)===false){
			$values=\array_fill(0, $this->count(),$values);
		}
		foreach ($values as $value){
			$c=$this->content[$i++];
			if(isset($c)){
				$df=$c->getDataField();
				$df->setProperty($property,$value);
			}
			else{
				return $this;
			}
		}
		return $this;
	}
664444
private function addRequestFormats(Request $request, array $formats): void
    {
        foreach ($formats as $format => $mimeTypes) {
            $request->setFormat($format, (array) $mimeTypes);
        }
    }
637832
public static function setFormatDefinition($name, $format) {
        if (!self::$formats) {
            self::$formats = self::initFormats();
        }

        self::$formats[$name] = $format;
    }
756003
public function addPropertyValues($property,$values){
		if(\is_array($values)===false){
			$values=\array_fill(0, $this->count(),$values);
		}
		foreach ($values as $i=>$value){
			if(isset($this->content[$i])){
				$this->content[$i++]->addToProperty($property,$value);
			}
			else{
				return $this;
			}
		}
		return $this;
	}
155042
protected function coerceArrayValue(string $format, $value): array
    {
        switch ($format) {
            case 'csv':
                return explode(',', $value);
            case 'ssv':
                return explode(' ', $value);
            case 'tsv':
                return explode("\t", $value);
            case 'pipes':
                return explode('|', $value);
            default:
                throw new \RuntimeException(
                    "Array 'collectionFormat' '$format' is not currently supported"
                );
        }
    }
866607
protected function validateAfterWithFormat($format, $value, $parameters)
    {
        $param = $this->getValue($parameters[0]) ?: $parameters[0];

        return $this->checkDateTimeOrder($format, $param, $value);
    }
647701
public function setFormat($format, $mimeTypes)
    {
        if (null === static::$formats) {
            static::initializeFormats();
        }

        static::$formats[$format] = \is_array($mimeTypes) ? $mimeTypes : [$mimeTypes];
    }
453156
public function formatPropertyValue($value, string $property) : string
    {
        $valueOutput = (string) $value;

        switch ($this->propertyHolder->getPropertyType($property)) {
            case PropertyHolder::TYPE_STRING:
                $valueOutput = trim((string) $value);

                break;
            case PropertyHolder::TYPE_BOOLEAN:
                if (true === $value || 'true' === $value) {
                    $valueOutput = 'true';
                } elseif (false === $value || 'false' === $value) {
                    $valueOutput = 'false';
                } else {
                    $valueOutput = '';
                }

                break;
            case PropertyHolder::TYPE_IN_ARRAY:
                try {
                    $valueOutput = $this->propertyHolder->checkValueInArray($property, (string) $value);
                } catch (\InvalidArgumentException $ex) {
                    $valueOutput = '';
                }

                break;
            default:
                // nothing t do here
                break;
        }

        if ('unknown' === $valueOutput) {
            $valueOutput = '';
        }

        return '"' . str_replace('"', '""', $valueOutput) . '"';
    }
1210011
public function bindValues($values): void
    {
        $params = func_get_args();
        if (isset($params[0]) && is_array($params[0])) {
            $this->bindedValues = new \ArrayObject($params[0]);
        } else {
            $this->bindedValues = new \ArrayObject($params);
        }
    }
398662
private function addFormatFromFormatNode(\DOMNode $formatNode, &$formats)
    {
        $key = $this->getKeyFromFormatNode($formatNode);
        $internal = $this->getInternalFlagFromFormatNode($formatNode);

        $meta = $this->getMetaFromFormatNode($formatNode);
        $scale = $this->getScaleFromFormatNode($formatNode);
        $transformations = $this->getTransformationsFromFormatNode($formatNode);
        $options = $this->getOptionsFromFormatNode($formatNode);

        $formats[$key] = [
            'key' => $key,
            'internal' => $internal,
            'meta' => $meta,
            'scale' => $scale,
            'transformations' => $transformations,
            'options' => array_merge($this->globalOptions, $options),
        ];
    }
465224
public function applyFilterRules($property, $filterRules = array())
    {
        foreach ($filterRules as $rule) {
            $this->applyFilterRule($property, $rule);
        }
    }
1129527
public function date($field, $format)
    {
        $fieldValue = $this->get($field);

        try {

            $date = new \DateTime($fieldValue);

            return $fieldValue === $date->format($format);
        } catch (\Exception $exception) {
            return $this->error($field, __FUNCTION__);
        }
    }
913260
public function setFilterFormat(string $format = 'DD MMM YY'): ColumnInterface
    {
        $this->filter[self::FILTER_KEY_FORMAT] = $format;

        return $this;
    }
871100
public static function encode( $data, $format )
    {
        if(!in_array($format, self::$supported)) return null;
        $formatter = self::$formatMap[$format];
        return forward_static_call(array($formatter, 'encode'), $data);
    }
366051
protected function writePropertyElements($properties, $format = '%s %s\l', $indent = -1)
    {
        $propertyString = '';

        foreach ($properties as $property) {
            if ($property->isPrivate()) {
                $visibility = '-';
            } elseif ($property->isProtected()) {
                $visibility = '#';
            } else {
                $visibility = '+';
            }

            $line = sprintf(
                $format,
                $visibility,
                $property->getName()
            );
            if ($indent >= 0) {
                $propertyString .= $this->formatLine($line, $indent);
            } else {
                $propertyString .= $line;
            }
        }
        return $propertyString;
    }