Class yii\data\ActiveDataFilter

                public function __call($name, $params)
{
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $object) {
        if ($object->hasMethod($name)) {
            return call_user_func_array([$object, $name], $params);
        }
    }
    throw new UnknownMethodException('Calling unknown method: ' . get_class($this) . "::$name()");
}

            

                public function __clone()
{
    parent::__clone();
    $this->_errors = null;
    $this->_validators = null;
}

            

                public function __construct($config = [])
{
    if (!empty($config)) {
        Yii::configure($this, $config);
    }
    $this->init();
}

            

                public function __get($name)
{
    if ($name === $this->filterAttributeName) {
        return $this->getFilter();
    }
    return parent::__get($name);
}

            

                public function __isset($name)
{
    if ($name === $this->filterAttributeName) {
        return $this->getFilter() !== null;
    }
    return parent::__isset($name);
}

            

                public function __set($name, $value)
{
    if ($name === $this->filterAttributeName) {
        $this->setFilter($value);
    } else {
        parent::__set($name, $value);
    }
}

            

                public function __unset($name)
{
    if ($name === $this->filterAttributeName) {
        $this->setFilter(null);
    } else {
        parent::__unset($name);
    }
}

            

                public function activeAttributes()
{
    $scenario = $this->getScenario();
    $scenarios = $this->scenarios();
    if (!isset($scenarios[$scenario])) {
        return [];
    }
    $attributes = array_keys(array_flip($scenarios[$scenario]));
    foreach ($attributes as $i => $attribute) {
        if (strncmp($attribute, '!', 1) === 0) {
            $attributes[$i] = substr($attribute, 1);
        }
    }
    return $attributes;
}

            

                public function addError($attribute, $error = '')
{
    $this->_errors[$attribute][] = $error;
}

            

                public function addErrors(array $items)
{
    foreach ($items as $attribute => $errors) {
        if (is_array($errors)) {
            foreach ($errors as $error) {
                $this->addError($attribute, $error);
            }
        } else {
            $this->addError($attribute, $errors);
        }
    }
}

            

                public function afterValidate()
{
    $this->trigger(self::EVENT_AFTER_VALIDATE);
}

            

                public function attachBehavior($name, $behavior)
{
    $this->ensureBehaviors();
    return $this->attachBehaviorInternal($name, $behavior);
}

            

                public function attachBehaviors($behaviors)
{
    $this->ensureBehaviors();
    foreach ($behaviors as $name => $behavior) {
        $this->attachBehaviorInternal($name, $behavior);
    }
}

            

                public function attributeHints()
{
    return [];
}

            

                public function attributeLabels()
{
    return [
        $this->filterAttributeName => $this->filterAttributeLabel,
    ];
}

            

                public function attributes()
{
    return [
        $this->filterAttributeName,
    ];
}

            

                public function beforeValidate()
{
    $event = new ModelEvent();
    $this->trigger(self::EVENT_BEFORE_VALIDATE, $event);
    return $event->isValid;
}

            

                public function behaviors()
{
    return [];
}

            

                public function build($runValidation = true)
{
    if ($runValidation && !$this->validate()) {
        return false;
    }
    return $this->buildInternal();
}

            

                public function canGetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if ($name === $this->filterAttributeName) {
        return true;
    }
    return parent::canGetProperty($name, $checkVars, $checkBehaviors);
}

            

                public function canSetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if ($name === $this->filterAttributeName) {
        return true;
    }
    return parent::canSetProperty($name, $checkVars, $checkBehaviors);
}

            

                public static function className()
{
    return get_called_class();
}

            

                public function clearErrors($attribute = null)
{
    if ($attribute === null) {
        $this->_errors = [];
    } else {
        unset($this->_errors[$attribute]);
    }
}

            

                public function createValidators()
{
    $validators = new ArrayObject();
    foreach ($this->rules() as $rule) {
        if ($rule instanceof Validator) {
            $validators->append($rule);
        } elseif (is_array($rule) && isset($rule[0], $rule[1])) { // attributes, validator type
            $validator = Validator::createValidator($rule[1], $this, (array) $rule[0], array_slice($rule, 2));
            $validators->append($validator);
        } else {
            throw new InvalidConfigException('Invalid validation rule: a rule must specify both attribute names and validator type.');
        }
    }
    return $validators;
}

            

                protected function defaultErrorMessages()
{
    return [
        'invalidFilter' => Yii::t('yii', 'The format of {filter} is invalid.'),
        'operatorRequireMultipleOperands' => Yii::t('yii', 'Operator "{operator}" requires multiple operands.'),
        'unknownAttribute' => Yii::t('yii', 'Unknown filter attribute "{attribute}"'),
        'invalidAttributeValueFormat' => Yii::t('yii', 'Condition for "{attribute}" should be either a value or valid operator specification.'),
        'operatorRequireAttribute' => Yii::t('yii', 'Operator "{operator}" must be used with a search attribute.'),
        'unsupportedOperatorType' => Yii::t('yii', '"{attribute}" does not support operator "{operator}".'),
    ];
}

            

                public function detachBehavior($name)
{
    $this->ensureBehaviors();
    if (isset($this->_behaviors[$name])) {
        $behavior = $this->_behaviors[$name];
        unset($this->_behaviors[$name]);
        $behavior->detach();
        return $behavior;
    }
    return null;
}

            

                public function detachBehaviors()
{
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $name => $behavior) {
        $this->detachBehavior($name);
    }
}

            

                protected function detectSearchAttributeType(Validator $validator)
{
    if ($validator instanceof BooleanValidator) {
        return self::TYPE_BOOLEAN;
    }
    if ($validator instanceof NumberValidator) {
        return $validator->integerOnly ? self::TYPE_INTEGER : self::TYPE_FLOAT;
    }
    if ($validator instanceof StringValidator) {
        return self::TYPE_STRING;
    }
    if ($validator instanceof EachValidator) {
        return self::TYPE_ARRAY;
    }
    if ($validator instanceof DateValidator) {
        if ($validator->type == DateValidator::TYPE_DATETIME) {
            return self::TYPE_DATETIME;
        }
        if ($validator->type == DateValidator::TYPE_TIME) {
            return self::TYPE_TIME;
        }
        return self::TYPE_DATE;
    }
}

            

                protected function detectSearchAttributeTypes()
{
    $model = $this->getSearchModel();
    $attributeTypes = [];
    foreach ($model->activeAttributes() as $attribute) {
        $attributeTypes[$attribute] = self::TYPE_STRING;
    }
    foreach ($model->getValidators() as $validator) {
        $type = $this->detectSearchAttributeType($validator);
        if ($type !== null) {
            foreach ((array) $validator->attributes as $attribute) {
                $attributeTypes[$attribute] = $type;
            }
        }
    }
    return $attributeTypes;
}

            

                public function ensureBehaviors()
{
    if ($this->_behaviors === null) {
        $this->_behaviors = [];
        foreach ($this->behaviors() as $name => $behavior) {
            $this->attachBehaviorInternal($name, $behavior);
        }
    }
}

            

                public function extraFields()
{
    return [];
}

            

                protected function extractFieldsFor(array $fields, $rootField)
{
    $result = [];
    foreach ($fields as $field) {
        if (0 === strpos($field, "{$rootField}.")) {
            $result[] = preg_replace('/^' . preg_quote($rootField, '/') . '\./i', '', $field);
        }
    }
    return array_unique($result);
}

            

                protected function extractRootFields(array $fields)
{
    $result = [];
    foreach ($fields as $field) {
        $result[] = current(explode('.', $field, 2));
    }
    if (in_array('*', $result, true)) {
        $result = [];
    }
    return array_unique($result);
}

            

                public function fields()
{
    $fields = array_keys(Yii::getObjectVars($this));
    return array_combine($fields, $fields);
}

            

                protected function filterAttributeValue($attribute, $value)
{
    $model = $this->getSearchModel();
    if (!$model->isAttributeSafe($attribute)) {
        $this->addError($this->filterAttributeName, $this->parseErrorMessage('unknownAttribute', ['attribute' => $attribute]));
        return $value;
    }
    $model->{$attribute} = $value;
    if (!$model->validate([$attribute])) {
        $this->addError($this->filterAttributeName, $model->getFirstError($attribute));
        return $value;
    }
    return $model->{$attribute};
}

            

                public function formName()
{
    return '';
}

            

                public function generateAttributeLabel($name)
{
    return Inflector::camel2words($name, true);
}

            

                public function getActiveValidators($attribute = null)
{
    $activeAttributes = $this->activeAttributes();
    if ($attribute !== null && !in_array($attribute, $activeAttributes, true)) {
        return [];
    }
    $scenario = $this->getScenario();
    $validators = [];
    foreach ($this->getValidators() as $validator) {
        if ($attribute === null) {
            $validatorAttributes = $validator->getValidationAttributes($activeAttributes);
            $attributeValid = !empty($validatorAttributes);
        } else {
            $attributeValid = in_array($attribute, $validator->getValidationAttributes($attribute), true);
        }
        if ($attributeValid && $validator->isActive($scenario)) {
            $validators[] = $validator;
        }
    }
    return $validators;
}

            

                public function getAttributeHint($attribute)
{
    $hints = $this->attributeHints();
    return isset($hints[$attribute]) ? $hints[$attribute] : '';
}

            

                public function getAttributeLabel($attribute)
{
    $labels = $this->attributeLabels();
    return isset($labels[$attribute]) ? $labels[$attribute] : $this->generateAttributeLabel($attribute);
}

            

                public function getAttributes($names = null, $except = [])
{
    $values = [];
    if ($names === null) {
        $names = $this->attributes();
    }
    foreach ($names as $name) {
        $values[$name] = $this->$name;
    }
    foreach ($except as $name) {
        unset($values[$name]);
    }
    return $values;
}

            

                public function getBehavior($name)
{
    $this->ensureBehaviors();
    return isset($this->_behaviors[$name]) ? $this->_behaviors[$name] : null;
}

            

                public function getBehaviors()
{
    $this->ensureBehaviors();
    return $this->_behaviors;
}

            

                public function getErrorMessages()
{
    if (!is_array($this->_errorMessages)) {
        if ($this->_errorMessages === null) {
            $this->_errorMessages = $this->defaultErrorMessages();
        } else {
            $this->_errorMessages = array_merge(
                $this->defaultErrorMessages(),
                call_user_func($this->_errorMessages)
            );
        }
    }
    return $this->_errorMessages;
}

            

                public function getErrorSummary($showAllErrors)
{
    $lines = [];
    $errors = $showAllErrors ? $this->getErrors() : $this->getFirstErrors();
    foreach ($errors as $es) {
        $lines = array_merge($lines, (array)$es);
    }
    return $lines;
}

            

                public function getErrors($attribute = null)
{
    if ($attribute === null) {
        return $this->_errors === null ? [] : $this->_errors;
    }
    return isset($this->_errors[$attribute]) ? $this->_errors[$attribute] : [];
}

            

                public function getFilter()
{
    return $this->_filter;
}

            

                public function getFirstError($attribute)
{
    return isset($this->_errors[$attribute]) ? reset($this->_errors[$attribute]) : null;
}

            

                public function getFirstErrors()
{
    if (empty($this->_errors)) {
        return [];
    }
    $errors = [];
    foreach ($this->_errors as $name => $es) {
        if (!empty($es)) {
            $errors[$name] = reset($es);
        }
    }
    return $errors;
}

            

                #[\ReturnTypeWillChange]
public function getIterator()
{
    $attributes = $this->getAttributes();
    return new ArrayIterator($attributes);
}

            

                public function getScenario()
{
    return $this->_scenario;
}

            

                public function getSearchAttributeTypes()
{
    if ($this->_searchAttributeTypes === null) {
        $this->_searchAttributeTypes = $this->detectSearchAttributeTypes();
    }
    return $this->_searchAttributeTypes;
}

            

                public function getSearchModel()
{
    if (!is_object($this->_searchModel) || $this->_searchModel instanceof \Closure) {
        $model = Yii::createObject($this->_searchModel);
        if (!$model instanceof Model) {
            throw new InvalidConfigException('`' . get_class($this) . '::$searchModel` should be an instance of `' . Model::className() . '` or its DI compatible configuration.');
        }
        $this->_searchModel = $model;
    }
    return $this->_searchModel;
}

            

                public function getValidators()
{
    if ($this->_validators === null) {
        $this->_validators = $this->createValidators();
    }
    return $this->_validators;
}

            

                public function hasErrors($attribute = null)
{
    return $attribute === null ? !empty($this->_errors) : isset($this->_errors[$attribute]);
}

            

                public function hasEventHandlers($name)
{
    $this->ensureBehaviors();
    if (!empty($this->_events[$name])) {
        return true;
    }
    foreach ($this->_eventWildcards as $wildcard => $handlers) {
        if (!empty($handlers) && StringHelper::matchWildcard($wildcard, $name)) {
            return true;
        }
    }
    return Event::hasHandlers($this, $name);
}

            

                public function hasMethod($name, $checkBehaviors = true)
{
    if (method_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->hasMethod($name)) {
                return true;
            }
        }
    }
    return false;
}

            

                public function hasProperty($name, $checkVars = true, $checkBehaviors = true)
{
    return $this->canGetProperty($name, $checkVars, $checkBehaviors) || $this->canSetProperty($name, false, $checkBehaviors);
}

            

                public function init()
{
}

            

                public static function instance($refresh = false)
{
    $className = get_called_class();
    if ($refresh || !isset(self::$_instances[$className])) {
        self::$_instances[$className] = Yii::createObject($className);
    }
    return self::$_instances[$className];
}

            

                public function isAttributeActive($attribute)
{
    return in_array($attribute, $this->activeAttributes(), true);
}

            

                public function isAttributeRequired($attribute)
{
    foreach ($this->getActiveValidators($attribute) as $validator) {
        if ($validator instanceof RequiredValidator && $validator->when === null) {
            return true;
        }
    }
    return false;
}

            

                public function isAttributeSafe($attribute)
{
    return in_array($attribute, $this->safeAttributes(), true);
}

            

                public function load($data, $formName = null)
{
    $scope = $formName === null ? $this->formName() : $formName;
    if ($scope === '' && !empty($data)) {
        $this->setAttributes($data);
        return true;
    } elseif (isset($data[$scope])) {
        $this->setAttributes($data[$scope]);
        return true;
    }
    return false;
}

            

                public static function loadMultiple($models, $data, $formName = null)
{
    if ($formName === null) {
        /* @var $first Model|false */
        $first = reset($models);
        if ($first === false) {
            return false;
        }
        $formName = $first->formName();
    }
    $success = false;
    foreach ($models as $i => $model) {
        /* @var $model Model */
        if ($formName == '') {
            if (!empty($data[$i]) && $model->load($data[$i], '')) {
                $success = true;
            }
        } elseif (!empty($data[$formName][$i]) && $model->load($data[$formName][$i], '')) {
            $success = true;
        }
    }
    return $success;
}

            

                public function normalize($runValidation = true)
{
    if ($runValidation && !$this->validate()) {
        return false;
    }
    $filter = $this->getFilter();
    if (!is_array($filter) || empty($filter)) {
        return [];
    }
    return $this->normalizeComplexFilter($filter);
}

            

                public function off($name, $handler = null)
{
    $this->ensureBehaviors();
    if (empty($this->_events[$name]) && empty($this->_eventWildcards[$name])) {
        return false;
    }
    if ($handler === null) {
        unset($this->_events[$name], $this->_eventWildcards[$name]);
        return true;
    }
    $removed = false;
    // plain event names
    if (isset($this->_events[$name])) {
        foreach ($this->_events[$name] as $i => $event) {
            if ($event[0] === $handler) {
                unset($this->_events[$name][$i]);
                $removed = true;
            }
        }
        if ($removed) {
            $this->_events[$name] = array_values($this->_events[$name]);
            return true;
        }
    }
    // wildcard event names
    if (isset($this->_eventWildcards[$name])) {
        foreach ($this->_eventWildcards[$name] as $i => $event) {
            if ($event[0] === $handler) {
                unset($this->_eventWildcards[$name][$i]);
                $removed = true;
            }
        }
        if ($removed) {
            $this->_eventWildcards[$name] = array_values($this->_eventWildcards[$name]);
            // remove empty wildcards to save future redundant regex checks:
            if (empty($this->_eventWildcards[$name])) {
                unset($this->_eventWildcards[$name]);
            }
        }
    }
    return $removed;
}

            

                #[\ReturnTypeWillChange]
public function offsetExists($offset)
{
    return isset($this->$offset);
}

            

                #[\ReturnTypeWillChange]
public function offsetGet($offset)
{
    return $this->$offset;
}

            

                #[\ReturnTypeWillChange]
public function offsetSet($offset, $value)
{
    $this->$offset = $value;
}

            

                #[\ReturnTypeWillChange]
public function offsetUnset($offset)
{
    $this->$offset = null;
}

            

                public function on($name, $handler, $data = null, $append = true)
{
    $this->ensureBehaviors();
    if (strpos($name, '*') !== false) {
        if ($append || empty($this->_eventWildcards[$name])) {
            $this->_eventWildcards[$name][] = [$handler, $data];
        } else {
            array_unshift($this->_eventWildcards[$name], [$handler, $data]);
        }
        return;
    }
    if ($append || empty($this->_events[$name])) {
        $this->_events[$name][] = [$handler, $data];
    } else {
        array_unshift($this->_events[$name], [$handler, $data]);
    }
}

            

                public function onUnsafeAttribute($name, $value)
{
    if (YII_DEBUG) {
        Yii::debug("Failed to set unsafe attribute '$name' in '" . get_class($this) . "'.", __METHOD__);
    }
}

            

                protected function parseErrorMessage($messageKey, $params = [])
{
    $messages = $this->getErrorMessages();
    if (isset($messages[$messageKey])) {
        $message = $messages[$messageKey];
    } else {
        $message = Yii::t('yii', 'The format of {filter} is invalid.');
    }
    $params = array_merge(
        [
            'filter' => $this->getAttributeLabel($this->filterAttributeName),
        ],
        $params
    );
    return Yii::$app->getI18n()->format($message, $params, Yii::$app->language);
}

            

                protected function resolveFields(array $fields, array $expand)
{
    $fields = $this->extractRootFields($fields);
    $expand = $this->extractRootFields($expand);
    $result = [];
    foreach ($this->fields() as $field => $definition) {
        if (is_int($field)) {
            $field = $definition;
        }
        if (empty($fields) || in_array($field, $fields, true)) {
            $result[$field] = $definition;
        }
    }
    if (empty($expand)) {
        return $result;
    }
    foreach ($this->extraFields() as $field => $definition) {
        if (is_int($field)) {
            $field = $definition;
        }
        if (in_array($field, $expand, true)) {
            $result[$field] = $definition;
        }
    }
    return $result;
}

            

                public function rules()
{
    return [
        [$this->filterAttributeName, 'validateFilter', 'skipOnEmpty' => false],
    ];
}

            

                public function safeAttributes()
{
    $scenario = $this->getScenario();
    $scenarios = $this->scenarios();
    if (!isset($scenarios[$scenario])) {
        return [];
    }
    $attributes = [];
    foreach ($scenarios[$scenario] as $attribute) {
        if (
            $attribute !== ''
            && strncmp($attribute, '!', 1) !== 0
            && !in_array('!' . $attribute, $scenarios[$scenario])
        ) {
            $attributes[] = $attribute;
        }
    }
    return $attributes;
}

            

                public function scenarios()
{
    $scenarios = [self::SCENARIO_DEFAULT => []];
    foreach ($this->getValidators() as $validator) {
        foreach ($validator->on as $scenario) {
            $scenarios[$scenario] = [];
        }
        foreach ($validator->except as $scenario) {
            $scenarios[$scenario] = [];
        }
    }
    $names = array_keys($scenarios);
    foreach ($this->getValidators() as $validator) {
        if (empty($validator->on) && empty($validator->except)) {
            foreach ($names as $name) {
                foreach ($validator->attributes as $attribute) {
                    $scenarios[$name][$attribute] = true;
                }
            }
        } elseif (empty($validator->on)) {
            foreach ($names as $name) {
                if (!in_array($name, $validator->except, true)) {
                    foreach ($validator->attributes as $attribute) {
                        $scenarios[$name][$attribute] = true;
                    }
                }
            }
        } else {
            foreach ($validator->on as $name) {
                foreach ($validator->attributes as $attribute) {
                    $scenarios[$name][$attribute] = true;
                }
            }
        }
    }
    foreach ($scenarios as $scenario => $attributes) {
        if (!empty($attributes)) {
            $scenarios[$scenario] = array_keys($attributes);
        }
    }
    return $scenarios;
}

            

                public function setAttributes($values, $safeOnly = true)
{
    if (is_array($values)) {
        $attributes = array_flip($safeOnly ? $this->safeAttributes() : $this->attributes());
        foreach ($values as $name => $value) {
            if (isset($attributes[$name])) {
                $this->$name = $value;
            } elseif ($safeOnly) {
                $this->onUnsafeAttribute($name, $value);
            }
        }
    }
}

            

                public function setErrorMessages($errorMessages)
{
    if (is_array($errorMessages)) {
        $errorMessages = array_merge($this->defaultErrorMessages(), $errorMessages);
    }
    $this->_errorMessages = $errorMessages;
}

            

                public function setFilter($filter)
{
    $this->_filter = $filter;
}

            

                public function setScenario($value)
{
    $this->_scenario = $value;
}

            

                public function setSearchAttributeTypes($searchAttributeTypes)
{
    $this->_searchAttributeTypes = $searchAttributeTypes;
}

            

                public function setSearchModel($model)
{
    if (is_object($model) && !$model instanceof Model && !$model instanceof \Closure) {
        throw new InvalidConfigException('`' . get_class($this) . '::$searchModel` should be an instance of `' . Model::className() . '` or its DI compatible configuration.');
    }
    $this->_searchModel = $model;
}

            

                public function toArray(array $fields = [], array $expand = [], $recursive = true)
{
    $data = [];
    foreach ($this->resolveFields($fields, $expand) as $field => $definition) {
        $attribute = is_string($definition) ? $this->$definition : $definition($this, $field);
        if ($recursive) {
            $nestedFields = $this->extractFieldsFor($fields, $field);
            $nestedExpand = $this->extractFieldsFor($expand, $field);
            if ($attribute instanceof Arrayable) {
                $attribute = $attribute->toArray($nestedFields, $nestedExpand);
            } elseif ($attribute instanceof \JsonSerializable) {
                $attribute = $attribute->jsonSerialize();
            } elseif (is_array($attribute)) {
                $attribute = array_map(
                    function ($item) use ($nestedFields, $nestedExpand) {
                        if ($item instanceof Arrayable) {
                            return $item->toArray($nestedFields, $nestedExpand);
                        } elseif ($item instanceof \JsonSerializable) {
                            return $item->jsonSerialize();
                        }
                        return $item;
                    },
                    $attribute
                );
            }
        }
        $data[$field] = $attribute;
    }
    if ($this instanceof Linkable) {
        $data['_links'] = Link::serialize($this->getLinks());
    }
    return $recursive ? ArrayHelper::toArray($data) : $data;
}

            

                public function trigger($name, Event $event = null)
{
    $this->ensureBehaviors();
    $eventHandlers = [];
    foreach ($this->_eventWildcards as $wildcard => $handlers) {
        if (StringHelper::matchWildcard($wildcard, $name)) {
            $eventHandlers[] = $handlers;
        }
    }
    if (!empty($this->_events[$name])) {
        $eventHandlers[] = $this->_events[$name];
    }
    if (!empty($eventHandlers)) {
        $eventHandlers = call_user_func_array('array_merge', $eventHandlers);
        if ($event === null) {
            $event = new Event();
        }
        if ($event->sender === null) {
            $event->sender = $this;
        }
        $event->handled = false;
        $event->name = $name;
        foreach ($eventHandlers as $handler) {
            $event->data = $handler[1];
            call_user_func($handler[0], $event);
            // stop further handling if the event is handled
            if ($event->handled) {
                return;
            }
        }
    }
    // invoke class-level attached handlers
    Event::trigger($this, $name, $event);
}

            

                public function validate($attributeNames = null, $clearErrors = true)
{
    if ($clearErrors) {
        $this->clearErrors();
    }
    if (!$this->beforeValidate()) {
        return false;
    }
    $scenarios = $this->scenarios();
    $scenario = $this->getScenario();
    if (!isset($scenarios[$scenario])) {
        throw new InvalidArgumentException("Unknown scenario: $scenario");
    }
    if ($attributeNames === null) {
        $attributeNames = $this->activeAttributes();
    }
    $attributeNames = (array)$attributeNames;
    foreach ($this->getActiveValidators() as $validator) {
        $validator->validateAttributes($this, $attributeNames);
    }
    $this->afterValidate();
    return !$this->hasErrors();
}

            

                protected function validateAttributeCondition($attribute, $condition)
{
    $attributeTypes = $this->getSearchAttributeTypes();
    if (!isset($attributeTypes[$attribute])) {
        $this->addError($this->filterAttributeName, $this->parseErrorMessage('unknownAttribute', ['attribute' => $attribute]));
        return;
    }
    if (is_array($condition)) {
        $operatorCount = 0;
        foreach ($condition as $rawOperator => $value) {
            if (isset($this->filterControls[$rawOperator])) {
                $operator = $this->filterControls[$rawOperator];
                if (isset($this->operatorTypes[$operator])) {
                    $operatorCount++;
                    $this->validateOperatorCondition($rawOperator, $value, $attribute);
                }
            }
        }
        if ($operatorCount > 0) {
            if ($operatorCount < count($condition)) {
                $this->addError($this->filterAttributeName, $this->parseErrorMessage('invalidAttributeValueFormat', ['attribute' => $attribute]));
            }
        } else {
            // attribute may allow array value:
            $this->validateAttributeValue($attribute, $condition);
        }
    } else {
        $this->validateAttributeValue($attribute, $condition);
    }
}

            

                protected function validateAttributeValue($attribute, $value)
{
    $model = $this->getSearchModel();
    if (!$model->isAttributeSafe($attribute)) {
        $this->addError($this->filterAttributeName, $this->parseErrorMessage('unknownAttribute', ['attribute' => $attribute]));
        return;
    }
    $model->{$attribute} = $value === $this->nullValue ? null : $value;
    if (!$model->validate([$attribute])) {
        $this->addError($this->filterAttributeName, $model->getFirstError($attribute));
        return;
    }
}

            

                protected function validateBlockCondition($operator, $condition)
{
    $this->validateCondition($condition);
}

            

                protected function validateCondition($condition)
{
    if (!is_array($condition)) {
        $this->addError($this->filterAttributeName, $this->parseErrorMessage('invalidFilter'));
        return;
    }
    if (empty($condition)) {
        return;
    }
    foreach ($condition as $key => $value) {
        $method = 'validateAttributeCondition';
        if (isset($this->filterControls[$key])) {
            $controlKey = $this->filterControls[$key];
            if (isset($this->conditionValidators[$controlKey])) {
                $method = $this->conditionValidators[$controlKey];
            }
        }
        $this->$method($key, $value);
    }
}

            

                protected function validateConjunctionCondition($operator, $condition)
{
    if (!is_array($condition) || !ArrayHelper::isIndexed($condition)) {
        $this->addError($this->filterAttributeName, $this->parseErrorMessage('operatorRequireMultipleOperands', ['operator' => $operator]));
        return;
    }
    foreach ($condition as $part) {
        $this->validateCondition($part);
    }
}

            

                public function validateFilter()
{
    $value = $this->getFilter();
    if ($value !== null) {
        $this->validateCondition($value);
    }
}

            

                public static function validateMultiple($models, $attributeNames = null)
{
    $valid = true;
    /* @var $model Model */
    foreach ($models as $model) {
        $valid = $model->validate($attributeNames) && $valid;
    }
    return $valid;
}

            

                protected function validateOperatorCondition($operator, $condition, $attribute = null)
{
    if ($attribute === null) {
        // absence of an attribute indicates that operator has been placed in a wrong position
        $this->addError($this->filterAttributeName, $this->parseErrorMessage('operatorRequireAttribute', ['operator' => $operator]));
        return;
    }
    $internalOperator = $this->filterControls[$operator];
    // check operator type :
    $operatorTypes = $this->operatorTypes[$internalOperator];
    if ($operatorTypes !== '*') {
        $attributeTypes = $this->getSearchAttributeTypes();
        $attributeType = $attributeTypes[$attribute];
        if (!in_array($attributeType, $operatorTypes, true)) {
            $this->addError($this->filterAttributeName, $this->parseErrorMessage('unsupportedOperatorType', ['attribute' => $attribute, 'operator' => $operator]));
            return;
        }
    }
    if (in_array($internalOperator, $this->multiValueOperators, true)) {
        // multi-value operator:
        if (!is_array($condition)) {
            $this->addError($this->filterAttributeName, $this->parseErrorMessage('operatorRequireMultipleOperands', ['operator' => $operator]));
        } else {
            foreach ($condition as $v) {
                $this->validateAttributeValue($attribute, $v);
            }
        }
    } else {
        // single-value operator :
        $this->validateAttributeValue($attribute, $condition);
    }
}