Exclude object from result

@param   ChildMaprating $maprating Object to remove from the list of results

@return $this|ChildMapratingQuery The current query, for fluid interface
335410
public function prune($maprating = null)
    {
        if ($maprating) {
            $this->addUsingAlias(MapratingTableMap::COL_ID, $maprating->getId(), Criteria::NOT_EQUAL);
        }

        return $this;
    }
454312
public function removeMap(Map $map, $login = null, $force = false)
    {
        if ($force) {
            return $this->remove($map);
        }

        if (!$login) {

            return false;
        }
        // no some restrictions for admin
        if ($this->adminGroups->hasPermission($login, "jukebox")) {
            return $this->remove($map);
        } else {
            // restrict 1 map per 1 login
            $check = $this->getMap($login);
            if ($check && $check->getMap() === $map) {
                return $this->remove($map);


            }
        }

        return false;
    }
1354263
public function getChildSkuSelectionMapping($childSku)
    {

        // query whether or not a child SKU selection ID mapping is available
        if (isset($this->childSkuSelectionIdMapping[$childSku])) {
            return $this->childSkuSelectionIdMapping[$childSku];
        }

        // throw an exception if the SKU has not been mapped yet
        throw new \Exception(
            $this->appendExceptionSuffix(
                sprintf('Found not mapped selection ID mapping for SKU %s', $childSku)
            )
        );
    }
866740
public function getRewardRuleConditionMapper()
    {
        if (null === $this->rewardRuleConditionMapper) {
            $this->rewardRuleConditionMapper = $this->serviceLocator->get(
                'playgroundreward_rewardrulecondition_mapper'
            );
        }

        return $this->rewardRuleConditionMapper;
    }
1074587
protected function _validateAndCompleteOneToManyMapping(array $mapping)
    {
        $mapping = $this->_validateAndCompleteAssociationMapping($mapping);

        // OneToMany-side MUST be inverse (must have mappedBy)
        if ( ! isset($mapping['mappedBy'])) {
            throw MappingException::oneToManyRequiresMappedBy($mapping['fieldName']);
        }

        $mapping['orphanRemoval']   = isset($mapping['orphanRemoval']) ? (bool) $mapping['orphanRemoval'] : false;
        $mapping['isCascadeRemove'] = $mapping['orphanRemoval'] ? true : $mapping['isCascadeRemove'];

        if (isset($mapping['orderBy'])) {
            if ( ! is_array($mapping['orderBy'])) {
                throw new InvalidArgumentException("'orderBy' is expected to be an array, not ".gettype($mapping['orderBy']));
            }
        }

        return $mapping;
    }
1176678
public function removeChild($childNode)
    {
        if ($childNode instanceof Element) {
            $childNode = $childNode->getNode();
        }

        if (!$childNode instanceof DOMNode) {
            throw new InvalidArgumentException(sprintf('Argument 1 passed to %s must be an instance of %s or DOMNode, %s given', __METHOD__, __CLASS__, (is_object($childNode) ? get_class($childNode) : gettype($childNode))));
        }

        $removedNode = $this->node->removeChild($childNode);

        return new Element($removedNode);
    }
1097159
public function validateChildClasses()
    {
        if (count($this->childClasses) > 0 && $this->isLeaf) {
            throw new MappingException(sprintf(
                'Cannot map a document as a leaf and define child classes for "%s"',
                $this->name
            ));
        }
    }
1319893
protected static function removeResourcesNotIncluded(array &$mappings, $parentType, array $inArrayValue)
    {
        foreach ($inArrayValue as $position => $includeValue) {
            if (self::isDeleteableIncludedResource($mappings, $parentType, $includeValue)) {
                unset($inArrayValue[$position]);
            }
        }

        return $inArrayValue;
    }
436970
public function getRewardMapper()
    {
        if (null === $this->rewardMapper) {
            $this->rewardMapper = $this->serviceLocator->get('playgroundreward_reward_mapper');
        }

        return $this->rewardMapper;
    }
448996
protected static function isDeleteableIncludedResource(array &$mappings, $parentType, $includeValue)
    {
        if (!isset($includeValue[Serializer::CLASS_IDENTIFIER_KEY])) {
            return true;
        }

        return !empty($mappings[$parentType])
        && count($mappings[$parentType]->getIncludedResources()) > 0
        && false === in_array($includeValue[Serializer::CLASS_IDENTIFIER_KEY], $mappings[$parentType]->getIncludedResources(), true);
    }
678005
public function removeChilds($pDbContainer = NULL)
    {
        if ($pDbContainer === NULL) {
            $containers = Agl::app()->getDb()->listCollections(array($this->getIdField()));
        } else {
            $containers = array($pDbContainer);
        }

        foreach ($containers as $container) {
            if ($container === $this->getDbContainer()) {
                continue;
            }

            $childs = $this->getChilds($container);
            foreach ($childs as $child) {
                $child->removeParent($this)->save();
            }
        }

        return $this;
    }
64567
public function prune($userCustomerRelation = null)
    {
        if ($userCustomerRelation) {
            $this->addUsingAlias(UserCustomerRelationPeer::ID, $userCustomerRelation->getId(), Criteria::NOT_EQUAL);
        }

        return $this;
    }
826232
public function setListMapper(ListMapper $mapper)
	{
		$this->listMapper = $mapper;
		$mapper->setAdmin($this);
		return $this;
	}
1266477
public function prune($personTeamLink = null)
    {
        if ($personTeamLink) {
            $this->addUsingAlias(PersonTeamLinkTableMap::ID, $personTeamLink->getId(), Criteria::NOT_EQUAL);
        }

        return $this;
    }
256506
public static Mapper filterMapper(final Predicate pred){
        return new Mapper(){
            public Object map(Object a) {
                return pred.evaluate(a) ? a : null;
            }
        };
    }
90933
public static function deleteMapping()
    {
        $instance = new static;

        $params = $instance->getBasicEsParams();

        return $instance->getElasticSearchClient()->indices()->deleteMapping($params);
    }
806091
@Override
	public Controller<M, V> removeChild(final String key)
	{
		return children.remove(key);
	}