Exclude object from result

@param   ChildFeatureTypeAvMeta $featureTypeAvMeta Object to remove from the list of results

@return ChildFeatureTypeAvMetaQuery The current query, for fluid interface
353670
public function prune($featureTypeAvMeta = null)
    {
        if ($featureTypeAvMeta) {
            $this->addUsingAlias(FeatureTypeAvMetaTableMap::ID, $featureTypeAvMeta->getId(), Criteria::NOT_EQUAL);
        }

        return $this;
    }
269621
public function getFeature(ConnectionInterface $con = null)
    {
        if ($this->aFeature === null && ($this->feature_id !== null)) {
            $this->aFeature = FeatureQuery::create()->findPk($this->feature_id, $con);
            /* The following can be used additionally to
                guarantee the related object contains a reference
                to this object.  This level of coupling may, however, be
                undesirable since it could result in an only partially populated collection
                in the referenced object.
                $this->aFeature->addFeatureFeatureTypes($this);
             */
        }

        return $this->aFeature;
    }
209960
public function prune($attributeTypeAvMeta = null)
    {
        if ($attributeTypeAvMeta) {
            $this->addUsingAlias(AttributeTypeAvMetaTableMap::ID, $attributeTypeAvMeta->getId(), Criteria::NOT_EQUAL);
        }

        return $this;
    }
99433
public function getFeatureVariableFromKey($featureFlagKey, $variableKey)
    {
        $featureFlag = $this->getFeatureFlagFromKey($featureFlagKey);
        if ($featureFlag && !($featureFlag->getKey())) {
            return null;
        }

        if (isset($this->_featureFlagVariableMap[$featureFlagKey])
            && isset($this->_featureFlagVariableMap[$featureFlagKey][$variableKey])
        ) {
            return $this->_featureFlagVariableMap[$featureFlagKey][$variableKey];
        }

        $this->_logger->log(
            Logger::ERROR,
            sprintf(
                'No variable key "%s" defined in datafile for feature flag "%s".',
                $variableKey,
                $featureFlagKey
            )
        );
        $this->_errorHandler->handleError(
            new InvalidFeatureVariableException('Provided feature variable is not in datafile.')
        );
        return null;
    }
780799
private function validateDatabase(EntityMetadata $metadata)
    {
        $persistence = $metadata->persistence;
        if (false === $metadata->isChildEntity() && (empty($persistence->db) || empty($persistence->collection))) {
            throw MetadataException::invalidMetadata($metadata->type, 'The persistence database and collection names cannot be empty.');
        }
    }
1172462
static public function removeByAttribute( $objectAttributeID, $objectAttributeVersion = null )
    {
        if ( !is_numeric( $objectAttributeID ) )
            return;

        $conditions = array( 'objectattribute_id' => (int) $objectAttributeID );
        if ( is_numeric( $objectAttributeVersion ) )
            $conditions['objectattribute_version'] = (int) $objectAttributeVersion;

        parent::removeObject( self::definition(), $conditions );
    }
547338
protected Set<String> getExclusions(AnnotationMetadata metadata,
			AnnotationAttributes attributes) {
		Set<String> excluded = new LinkedHashSet<>();
		excluded.addAll(asList(attributes, "exclude"));
		excluded.addAll(Arrays.asList(attributes.getStringArray("excludeName")));
		excluded.addAll(getExcludeAutoConfigurationsProperty());
		return excluded;
	}
664203
public function isFeatureMatch(FeatureNode $feature)
    {
        return $this->filterMinLine <= $feature->getLine()
            && $this->filterMaxLine >= $feature->getLine();
    }
719130
public void removeFeature(FeatureInterface<AbstractSequence<C>, C> feature) {
		features.remove(feature);
		ArrayList<FeatureInterface<AbstractSequence<C>, C>> featureList = groupedFeatures.get(feature.getType());
		if (featureList != null) {
			featureList.remove(feature);
			if (featureList.isEmpty()) {
				groupedFeatures.remove(feature.getType());
			}
		}
	}
125112
public boolean remove(Tree child) {
		if (Config.META.equals(child.key)) {
			Tree meta = getMeta();
			if (meta != null && meta.parent != null) {
				meta.parent.meta = null;
				return true;
			}
		}
		return remove((test) -> {
			return test.key.equals(child.key);
		}
1203321
public function deleteTemplateFeature(TemplateDeleteFeatureEvent $event, $eventName, EventDispatcherInterface $dispatcher)
    {
        // Detete the removed feature in all products which are using this template
        $products = ProductQuery::create()
            ->filterByTemplateId($event->getTemplate()->getId())
            ->find()
        ;
        
        foreach ($products as $product) {
            $dispatcher->dispatch(
                TheliaEvents::PRODUCT_FEATURE_DELETE_VALUE,
                new FeatureProductDeleteEvent($product->getId(), $event->getFeatureId())
            );
        }
    }
632503
public function setFeaturedPicture(ChildPicture $v = null)
    {
        if ($v === null) {
            $this->setPictureId(NULL);
        } else {
            $this->setPictureId($v->getId());
        }

        $this->aFeaturedPicture = $v;

        // Add binding for other direction of this n:n relationship.
        // If this object has already been added to the ChildPicture object, it will not be re-added.
        if ($v !== null) {
            $v->addFeaturedSkill($this);
        }


        return $this;
    }
758518
public function removeMeta(\Sulu\Bundle\MediaBundle\Entity\FileVersionMeta $meta)
    {
        $this->meta->removeElement($meta);
    }
63741
public function getFeatureVariableBoolean($featureFlagKey, $variableKey, $userId, $attributes = null)
    {
        return $this->getFeatureVariableValueForType(
            $featureFlagKey,
            $variableKey,
            $userId,
            $attributes,
            FeatureVariable::BOOLEAN_TYPE
        );
    }
1112747
public void removeChild(AttributeId attribute) {
      if (children == null) {
         throw new IllegalArgumentException("No child found : " + attribute);
      }
      AttributeNode<AttributeMetadata, AttributeId> child = children.get(attribute);
      if (child == null) {
         throw new IllegalArgumentException("No child found : " + attribute);
      }
      children.remove(attribute);
      rebuildChildrenArray();
   }
392729
public function delete(ConnectionInterface $con = null)
    {
        if ($this->isDeleted()) {
            throw new PropelException("This object has already been deleted.");
        }

        if ($con === null) {
            $con = Propel::getServiceContainer()->getWriteConnection(CategoryTableMap::DATABASE_NAME);
        }

        $con->transaction(function () use ($con) {
            $deleteQuery = ChildCategoryQuery::create()
                ->filterByPrimaryKey($this->getPrimaryKey());
            $ret = $this->preDelete($con);
            // nested_set behavior
            if ($this->isRoot()) {
                throw new PropelException('Deletion of a root node is disabled for nested sets. Use ChildCategoryQuery::deleteTree() instead to delete an entire tree');
            }

            if ($this->isInTree()) {
                $this->deleteDescendants($con);
            }

            if ($ret) {
                $deleteQuery->delete($con);
                $this->postDelete($con);
                // nested_set behavior
                if ($this->isInTree()) {
                    // fill up the room that was used by the node
                    ChildCategoryQuery::shiftRLValues(-2, $this->getRightValue() + 1, null, $con);
                }

                $this->setDeleted(true);
            }
        });
    }
725650
static function removeReferencesToProductCategory( $cartegoryID )
    {
        $db = eZDB::instance();
        $query = "DELETE FROM ezvatrule_product_category WHERE product_category_id=" . (int) $cartegoryID;
        $db->query( $query );
    }