Exclude object from result

@param   ChildAttributeAttributeType $attributeAttributeType Object to remove from the list of results

@return ChildAttributeAttributeTypeQuery The current query, for fluid interface
978522
public function prune($attributeAttributeType = null)
    {
        if ($attributeAttributeType) {
            $this->addUsingAlias(AttributeAttributeTypeTableMap::ID, $attributeAttributeType->getId(), Criteria::NOT_EQUAL);
        }

        return $this;
    }
755629
public function setChildrenAttributes($attributes)
    {
        if (! is_array($attributes)) {
            $attributes = [$attributes];
        }

        $this->children_attributes = $attributes;

        return $this;
    }
403119
protected function purgeMissingAttributes(OutputInterface $output)
    {
        $metadata = $this->entityManager->getClassMetadata($this->valueClass);
        $table = $metadata->getTableName();

        foreach ($this->familyRegistry->getFamilies() as $family) {
            $attributeCodes = [];
            foreach ($family->getAttributes() as $attribute) {
                $attributeCodes[] = $attribute->getCode();
            }

            $quotedFamilyCode = $this->entityManager->getConnection()->quote($family->getCode());
            $flattenedAttributeCodes = $this->quoteArray($attributeCodes);

            // LIMIT is not natively supported for delete statements in Doctrine
            $sql = "DELETE FROM `{$table}` WHERE family_code = {$quotedFamilyCode} AND attribute_code NOT IN ({$flattenedAttributeCodes}) LIMIT 1000";

            $count = $this->executeWithPaging($sql);

            if ($count) {
                $output->writeln(
                    "<comment>{$count} values purged in family {$family->getCode()} with missing attributes</comment>"
                );
            } else {
                $output->writeln("<info>No values to purge for family {$family->getCode()}</info>");
            }
        }
    }
247706
public function setAttrib($attribName, $attribDefinition = null)
    {
        $this->attribs[$attribName] = is_object($attribDefinition) && $attribDefinition instanceof \DataFilter\Attribute
            ? $attribDefinition
            : new \DataFilter\Attribute($attribName, $attribDefinition, $this);
        return $this->attribs[$attribName];
    }
47491
public function removeCustomerAttributes()
    {
        foreach ($this->_customerAttributes as $code => $attr) {
            $this->removeAttribute('customer', $code);
        }

        return $this;
    }
399948
public function getAttributeAttributeType(ConnectionInterface $con = null)
    {
        if ($this->aAttributeAttributeType === null && ($this->attribute_attribute_type_id !== null)) {
            $this->aAttributeAttributeType = ChildAttributeAttributeTypeQuery::create()->findPk($this->attribute_attribute_type_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->aAttributeAttributeType->addAttributeTypeAvMetas($this);
             */
        }

        return $this->aAttributeAttributeType;
    }
259999
public function item($resourceKey, array $data, $includeAttributes = true)
    {
        $item = parent::item($resourceKey, $data);
        if (!$includeAttributes) {
            unset($item['data']['attributes']);
        }

        return $item;
    }
636693
public function writeAttribute(string $attributeName, string $attributeValue): XmlStreamWriter
    {
        return $this->append(
                function(\DOMElement $parent) use ($attributeName, $attributeValue)
                {
                    $parent->setAttribute(
                            $attributeName,
                            $this->encode($attributeValue)
                    );
                },
                'attribute: "' . $attributeName . ':' . $attributeValue . '"'
        );
    }
949263
protected function uninlineAttribute(DOMAttr $attribute)
	{
		$xslAttribute = (strpos($attribute->value, '{') === false)
		              ? $this->uninlineStaticAttribute($attribute)
		              : $this->uninlineDynamicAttribute($attribute);

		// Set the xsl:attribute element's name
		$xslAttribute->setAttribute('name', $attribute->nodeName);

		// Remove the attribute from its parent element
		$attribute->parentNode->removeAttributeNode($attribute);

		return $xslAttribute;
	}
1088129
public function prune($attributeTypeI18n = null)
    {
        if ($attributeTypeI18n) {
            $this->addCond('pruneCond0', $this->getAliasedColName(AttributeTypeI18nTableMap::ID), $attributeTypeI18n->getId(), Criteria::NOT_EQUAL);
            $this->addCond('pruneCond1', $this->getAliasedColName(AttributeTypeI18nTableMap::LOCALE), $attributeTypeI18n->getLocale(), Criteria::NOT_EQUAL);
            $this->combine(array('pruneCond0', 'pruneCond1'), Criteria::LOGICAL_OR);
        }

        return $this;
    }
719194
public function deleteValue(AttributeValueInterface $attributeValue)
    {
        /* @var \Concrete\Core\Entity\Attribute\Value\AbstractValue $attributeValue */

        $genericValue = $attributeValue->getGenericValue();
        if ($genericValue !== null) {
            $genericValues = $this->getAttributeValueRepository()->findBy(['generic_value' => $genericValue]);
            if (count($genericValues) == 1) {

                // Handle legacy attributes with these three lines.
                $controller = $attributeValue->getAttributeKey()->getController();
                $controller->setAttributeValue($attributeValue);
                $controller->deleteValue();

                $value = $attributeValue->getValueObject();
                if (is_object($value)) {
                    $this->entityManager->remove($value);
                    $this->entityManager->flush();
                }
                $this->entityManager->remove($genericValue);
            }
            $this->entityManager->remove($attributeValue);
        }

        $this->entityManager->flush();
    }
318421
public function firstByAttribute($attributeName, $attributeValue)
    {
        $callback = function ($entity) use ($attributeName, $attributeValue) {
            $method = 'get'.ucfirst($attributeName);

            return $entity->$method() == $attributeValue;
        };

        return  $this->filter($callback)->first();
    }
774054
public function getProductLinkAttributeByLinkTypeCodeAndAttributeCode($linkTypeCode, $attributeCode)
    {

        // map the link type code => ID
        $linkTypeId = $this->mapLinkTypeCodeToLinkTypeId($linkTypeCode);

        // try to load the link attribute with the passed link type ID and attribute code
        foreach ($this->linkAttributes as $linkAttribute) {
            if ($linkAttribute[MemberNames::LINK_TYPE_ID] === $linkTypeId &&
                $linkAttribute[MemberNames::PRODUCT_LINK_ATTRIBUTE_CODE] === $attributeCode
            ) {
                // return the matching link attribute
                return $linkAttribute;
            }
        }
    }
791049
static function removeById( $attributeId, $version = null )
    {
        if ( $version !== null )
    	   $conds = array( 'contentobject_attribute_id' => $attributeId, 'contentobject_version' => $version  );
    	else
    	    $conds = array( 'contentobject_attribute_id' => $attributeId );

        eZPersistentObject::removeObject( self::definition(), $conds, null );
    }
670661
public function removeAttributeName($attributeName)
    {
        foreach ($this->attributeNames as $key => $attributeNameElement) {
            if ($attributeNameElement === $attributeName) {
                unset($this->attributeNames[$key]);
                break;
            }
        }

        return $this;
    }
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();
   }
74066
public function setAttributeType(ChildAttributeType $v = null)
    {
        if ($v === null) {
            $this->setId(NULL);
        } else {
            $this->setId($v->getId());
        }

        $this->aAttributeType = $v;

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


        return $this;
    }