Exclude object from result

@param   ChildPersonImage $personImage Object to remove from the list of results

@return ChildPersonImageQuery The current query, for fluid interface
15360
public function prune($personImage = null)
    {
        if ($personImage) {
            $this->addUsingAlias(PersonImageTableMap::ID, $personImage->getId(), Criteria::NOT_EQUAL);
        }

        return $this;
    }
216210
public function getPersonneLibelle($idPersonne = 0)
    {
        $req = "SELECT nom, prenom FROM personne WHERE idPersonne = '".$idPersonne."'";
        $res = $this->connexionBdd->requete($req);
        $fetch = mysql_fetch_assoc($res);
        return $fetch['nom'].' '.$fetch['prenom'];
    }
762157
@Override
    public <U extends ApiBaseUser> Response exclude(Collection<U> users) {
    	for(U user : users)
    		this.usernames.remove(user.getName());
    	return this;
    }
851340
protected function getEmailFromPerson($personId)
    {
        if ($personId) {
            try {
                return \Scool\EbreEscoolModel\Person::find($personId)->person_email;
            } catch (\Exception $e){
                info($e->getMessage());
            }
        }
        return null;
    }
163460
public function removePersonImageVersion($value)
    {
        $targetArray = array();
        foreach ($this->getPersonImageVersions() as $element) {
            if ($element != $value) {
                $targetArray []= $element;
            }
        }
        $this->setPersonImageVersions($targetArray);

        return $this;
    }
872548
public function exclude(DataQuery $query)
    {
        if (($key = array_search('not', $this->modifiers)) !== false) {
            unset($this->modifiers[$key]);
            return $this->apply($query);
        }
        if (is_array($this->value)) {
            return $this->excludeMany($query);
        } else {
            return $this->excludeOne($query);
        }
    }
1153565
public function setPersonFunction(ChildPersonFunction $v = null)
    {
        if ($v === null) {
            $this->setFunctionId(NULL);
        } else {
            $this->setFunctionId($v->getId());
        }

        $this->aPersonFunction = $v;

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


        return $this;
    }
1158521
public function getPersonFilter($key = null)
    {
        if ($key == 'category') {
            return $this->personFilter['category'];
        }

        if ($key == 'person') {
            return $this->personFilter['person'];
        }

        return implode('=', $this->personFilter);
    }
1237308
public function revokeAccess($object, UserInterface $user, $permission = Permissions::PERMISSIONS_VIEW)
    {
        $objectIdentity = $this->getObjectIdentity($object);
        try {
            $acl = $this->aclProvider->findAcl($objectIdentity);
        } catch (AclNotFoundException $e) {
            // nothing to do
            return $this;
        }

        $securityIdentity = UserSecurityIdentity::fromAccount($user);
        $mask = $this->getMask($permission);

        foreach ($acl->getObjectAces() as $i => $ace) {
            /** @var EntryInterface $ace */
            if ($securityIdentity->equals($ace->getSecurityIdentity())) {
                $this->revokeMask($i, $acl, $ace, $mask);
            }
        }

        $this->aclProvider->updateAcl($acl);

        return $this;
    }
1121480
public function removePermission(ChildPermission $permission)
    {
        if ($this->getPermissions()->contains($permission)) { $rolePermission = new ChildRolePermission();

            $rolePermission->setPermission($permission);
            if ($permission->isRolesLoaded()) {
                //remove the back reference if available
                $permission->getRoles()->removeObject($this);
            }

            $rolePermission->setRole($this);
            $this->removeRolePermission(clone $rolePermission);
            $rolePermission->clear();

            $this->collPermissions->remove($this->collPermissions->search($permission));

            if (null === $this->permissionsScheduledForDeletion) {
                $this->permissionsScheduledForDeletion = clone $this->collPermissions;
                $this->permissionsScheduledForDeletion->clear();
            }

            $this->permissionsScheduledForDeletion->push($permission);
        }


        return $this;
    }
23026
public function equals(Person $person)
    {
        return $person->getName() === $this->name && $person->getEmail() === $this->email;
    }
87689
public function setPersonImage(ChildPersonImage $v = null)
    {
        if ($v === null) {
            $this->setId(NULL);
        } else {
            $this->setId($v->getId());
        }

        $this->aPersonImage = $v;

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


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

        return $this;
    }
123119
public function prune($object = null)
    {
        if ($object) {
            $this->addUsingAlias(ObjectTableMap::COL_ID, $object->getId(), Criteria::NOT_EQUAL);
        }

        return $this;
    }
576250
public function prune($personFunction = null)
    {
        if ($personFunction) {
            $this->addUsingAlias(PersonFunctionTableMap::ID, $personFunction->getId(), Criteria::NOT_EQUAL);
        }

        return $this;
    }
1097803
public function delete($project_id, $person_id)
    {
        $this->validates($project_id, $person_id);
        return $this->rest->delete("/projects/$project_id/people/$person_id");
    }
160090
protected function applyCredits(array $data, Person $person)
    {
        $hydrator = new ObjectHydrator();
        $types    = ['movie_credits', 'tv_credits', 'combined_credits'];

        foreach ($types as $type) {
            if (array_key_exists($type, $data)) {
                $method = $hydrator->camelize(sprintf('get_%s', $type));

                if (array_key_exists('cast', $data[$type])) {
                    $cast = $this->createCustomCollection(
                        $data[$type]['cast'],
                        new Person\Credit(),
                        new People\Cast()
                    );

                    foreach ($cast as $member) {
                        $member->setPosterImage($this->getPosterImageForCredit($member->getPosterPath()));
                    }

                    $person->$method()->setCast($cast);
                }

                if (array_key_exists('crew', $data[$type])) {
                    $crew = $this->createCustomCollection(
                        $data[$type]['crew'],
                        new Person\Credit(),
                        new People\Crew()
                    );

                    foreach ($crew as $member) {
                        $member->setPosterImage($this->getPosterImageForCredit($member->getPosterPath()));
                    }

                    $person->$method()->setCrew($crew);
                }
            }
        }
    }