Removes a value from the [dealer_admin_versions] array column value.
@param      mixed $value

@return   \Dealer\Model\DealerVersion The current object (for fluent API support)
358557
public function removeDealerAdminVersion($value)
    {
        $targetArray = array();
        foreach ($this->getDealerAdminVersions() as $element) {
            if ($element != $value) {
                $targetArray []= $element;
            }
        }
        $this->setDealerAdminVersions($targetArray);

        return $this;
    }
886104
public function removeKkTrixionarySkillVersion($value)
    {
        $targetArray = array();
        foreach ($this->getKkTrixionarySkillVersions() as $element) {
            if ($element != $value) {
                $targetArray []= $element;
            }
        }
        $this->setKkTrixionarySkillVersions($targetArray);

        return $this;
    }
271494
public function removeDealerAdminId($value)
    {
        $targetArray = array();
        foreach ($this->getDealerAdminIds() as $element) {
            if ($element != $value) {
                $targetArray []= $element;
            }
        }
        $this->setDealerAdminIds($targetArray);

        return $this;
    }
635000
public function removeDealerProductId($value)
    {
        $targetArray = array();
        foreach ($this->getDealerProductIds() as $element) {
            if ($element != $value) {
                $targetArray []= $element;
            }
        }
        $this->setDealerProductIds($targetArray);

        return $this;
    }
1042150
protected function neverObsolete($value)
    {
        // Remove any keys that can never be obsolete
        foreach ($this->config('never_obsolete_keys', []) as $remove) {
            $remove = "{$remove}.";

            if (substr($value, 0, strlen($remove)) === $remove
                || strpos($value, ".{$remove}") !== false
            ) {
                return true;
            }
        }

        return false;
    }
381893
public function addDealerContactInfoVersion($value)
    {
        $currentArray = $this->getDealerContactInfoVersions();
        $currentArray []= $value;
        $this->setDealerContactInfoVersions($currentArray);

        return $this;
    }
740941
public function prune($dealerFolderVersion = null)
    {
        if ($dealerFolderVersion) {
            $this->addCond('pruneCond0', $this->getAliasedColName(DealerFolderVersionTableMap::ID), $dealerFolderVersion->getId(), Criteria::NOT_EQUAL);
            $this->addCond('pruneCond1', $this->getAliasedColName(DealerFolderVersionTableMap::VERSION), $dealerFolderVersion->getVersion(), Criteria::NOT_EQUAL);
            $this->combine(array('pruneCond0', 'pruneCond1'), Criteria::LOGICAL_OR);
        }

        return $this;
    }
909532
public function version(string $value = null)
    {
        if (null === $value) {
            return $this->version;
        }
        $this->version = $value;
        return $this;
    }
829380
public function remove($value)
    {
        if (false === ($index = array_search($value, $this->data, true))) {
            throw new \InvalidArgumentException('index out of bounds');
        }

        $this->pop($index);
    }
859502
protected function cleanUpValue( $value ) {
		$cleanValue = [];
		if ( !is_array( $value ) ) {
			return $cleanValue;
		}
		foreach ( $value as $singleValue ) {
			$singleValue = parent::cleanUpValue( $singleValue );
			// Remove options that we don't have here
			if ( !isset( $this->fields[ $singleValue ] ) ) {
				continue;
			}
			$cleanValue[] = $singleValue;
		}
		return $cleanValue;
	}
1097910
public function remove($value)
    {
        if ($this->hasNot($value)) {
            return;
        }

        $item = $this->get($value);

        $this->unset($value);

        return $item;
    }
1044051
protected function finalizeValue($value)
    {
        if (false === $value) {
            $msg = sprintf('Unsetting key for path "%s", value: %s', $this->getPath(), json_encode($value));
            throw new UnsetKeyException($msg);
        }

        foreach ($this->children as $name => $child) {
            if (!array_key_exists($name, $value)) {
                if ($child->isRequired()) {
                    $msg = sprintf('The child node "%s" at path "%s" must be configured.', $name, $this->getPath());
                    $ex = new InvalidConfigurationException($msg);
                    $ex->setPath($this->getPath());

                    throw $ex;
                }

                if ($child->hasDefaultValue()) {
                    $value[$name] = $child->getDefaultValue();
                }

                continue;
            }

            if ($child->isDeprecated()) {
                @trigger_error($child->getDeprecationMessage($name, $this->getPath()), E_USER_DEPRECATED);
            }

            try {
                $value[$name] = $child->finalize($value[$name]);
            } catch (UnsetKeyException $e) {
                unset($value[$name]);
            }
        }

        return $value;
    }
146116
public function remove($value)
    {
        foreach ($this->values as $i => $v) {
            if ($value == $v) {
                unset($this->values[$i]);
                break;
            }
        }
        $this->stateChanged();
    }
1084716
public function removeFilterByValue($value)
    {
        return $this->removeFilterByFunction(
            function($key, $query) use ($value) {
                $query = $query->getQuery();
                return $query == $value;
            }
        );
    }
755612
public function removeValue($value)
    {
        if (! $this->canHaveMultipleValues() && ! isset($value)) {
            $this->values = [];
            $this->enable($enable = false);

            return $this;
        }

        $this->assertValueIsValid($value);
        $this->assertCanHaveValue();

        if ($this->hasValue($value)) {
            $index = array_search($value, $this->values);
            unset($this->values[$index]);
            $this->values = array_values($this->values);
        }

        return $this;
    }
567123
public function removeDealerContentId($value)
    {
        $targetArray = array();
        foreach ($this->getDealerContentIds() as $element) {
            if ($element != $value) {
                $targetArray []= $element;
            }
        }
        $this->setDealerContentIds($targetArray);

        return $this;
    }
1301872
protected function normalizeValue($value)
    {
        if (false === $value) {
            return $value;
        }

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

        $isAssoc = array_keys($value) !== range(0, \count($value) - 1);
        $normalized = [];
        foreach ($value as $k => $v) {
            if (null !== $this->keyAttribute && \is_array($v)) {
                if (!isset($v[$this->keyAttribute]) && \is_int($k) && !$isAssoc) {
                    $ex = new InvalidConfigurationException(sprintf('The attribute "%s" must be set for path "%s".', $this->keyAttribute, $this->getPath()));
                    $ex->setPath($this->getPath());

                    throw $ex;
                } elseif (isset($v[$this->keyAttribute])) {
                    $k = $v[$this->keyAttribute];

                    // remove the key attribute when required
                    if ($this->removeKeyAttribute) {
                        unset($v[$this->keyAttribute]);
                    }

                    // if only "value" is left
                    if (array_keys($v) === ['value']) {
                        $v = $v['value'];
                        if ($this->prototype instanceof ArrayNode && ($children = $this->prototype->getChildren()) && \array_key_exists('value', $children)) {
                            $valuePrototype = current($this->valuePrototypes) ?: clone $children['value'];
                            $valuePrototype->parent = $this;
                            $originalClosures = $this->prototype->normalizationClosures;
                            if (\is_array($originalClosures)) {
                                $valuePrototypeClosures = $valuePrototype->normalizationClosures;
                                $valuePrototype->normalizationClosures = \is_array($valuePrototypeClosures) ? array_merge($originalClosures, $valuePrototypeClosures) : $originalClosures;
                            }
                            $this->valuePrototypes[$k] = $valuePrototype;
                        }
                    }
                }

                if (\array_key_exists($k, $normalized)) {
                    $ex = new DuplicateKeyException(sprintf('Duplicate key "%s" for path "%s".', $k, $this->getPath()));
                    $ex->setPath($this->getPath());

                    throw $ex;
                }
            }

            $prototype = $this->getPrototypeForChild($k);
            if (null !== $this->keyAttribute || $isAssoc) {
                $normalized[$k] = $prototype->normalize($v);
            } else {
                $normalized[] = $prototype->normalize($v);
            }
        }

        return $normalized;
    }