/**
* Filter the query by a related File object
*
* @param File|PropelCollection $file The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return StatusActionQuery The current query, for fluid interface
*/
public function filterByFile($file, $comparison = null)
{
if ($file instanceof File) {
return $this->addUsingAlias(StatusActionPeer::FILE_ID, $file->getId(), $comparison);
} elseif ($file instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(StatusActionPeer::FILE_ID, $file->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByFile() only accepts arguments of type File or PropelCollection');
}
}
/**
* Filter the query by a related AbsenceEleveNotification object
*
* @param AbsenceEleveNotification|PropelCollection $absenceEleveNotification The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return JNotificationResponsableEleveQuery The current query, for fluid interface
*/
public function filterByAbsenceEleveNotification($absenceEleveNotification, $comparison = null)
{
if ($absenceEleveNotification instanceof AbsenceEleveNotification) {
return $this
->addUsingAlias(JNotificationResponsableElevePeer::A_NOTIFICATION_ID, $absenceEleveNotification->getId(), $comparison);
} elseif ($absenceEleveNotification instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this
->addUsingAlias(JNotificationResponsableElevePeer::A_NOTIFICATION_ID, $absenceEleveNotification->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByAbsenceEleveNotification() only accepts arguments of type AbsenceEleveNotification or PropelCollection');
}
}
/**
* Filter the query by a related sfGuardUser object
*
* @param sfGuardUser|PropelCollection $sfGuardUser The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return CommentQuery The current query, for fluid interface
*/
public function filterBysfGuardUserRelatedByCheckUserId($sfGuardUser, $comparison = null)
{
if ($sfGuardUser instanceof sfGuardUser) {
return $this->addUsingAlias(CommentPeer::CHECK_USER_ID, $sfGuardUser->getId(), $comparison);
} elseif ($sfGuardUser instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(CommentPeer::CHECK_USER_ID, $sfGuardUser->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterBysfGuardUserRelatedByCheckUserId() only accepts arguments of type sfGuardUser or PropelCollection');
}
}
/**
* Filter the query by a related Usuario object
*
* @param Usuario|PropelCollection $usuario The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return Libro_colaboradorQuery The current query, for fluid interface
*/
public function filterByUsuario($usuario, $comparison = null)
{
if ($usuario instanceof Usuario) {
return $this->addUsingAlias(Libro_colaboradorPeer::IDUSUARIO, $usuario->getId(), $comparison);
} elseif ($usuario instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(Libro_colaboradorPeer::IDUSUARIO, $usuario->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByUsuario() only accepts arguments of type Usuario or PropelCollection');
}
}
/**
* Filter the query by a related User object
*
* @param User|PropelCollection $user The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ActionQuery The current query, for fluid interface
*/
public function filterByUser($user, $comparison = null)
{
if ($user instanceof User) {
return $this->addUsingAlias(ActionPeer::USER_ID, $user->getId(), $comparison);
} elseif ($user instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(ActionPeer::USER_ID, $user->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByUser() only accepts arguments of type User or PropelCollection');
}
}
/**
* Filter the query by a related AbsenceEleveLieu object
*
* @param AbsenceEleveLieu|PropelCollection $absenceEleveLieu The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return AbsenceEleveSaisieQuery The current query, for fluid interface
*/
public function filterByAbsenceEleveLieu($absenceEleveLieu, $comparison = null)
{
if ($absenceEleveLieu instanceof AbsenceEleveLieu) {
return $this
->addUsingAlias(AbsenceEleveSaisiePeer::ID_LIEU, $absenceEleveLieu->getId(), $comparison);
} elseif ($absenceEleveLieu instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this
->addUsingAlias(AbsenceEleveSaisiePeer::ID_LIEU, $absenceEleveLieu->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByAbsenceEleveLieu() only accepts arguments of type AbsenceEleveLieu or PropelCollection');
}
}
/**
* Filter the query by a related AbsenceEleveTraitement object
*
* @param AbsenceEleveTraitement|PropelCollection $absenceEleveTraitement The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return JTraitementSaisieEleveQuery The current query, for fluid interface
*/
public function filterByAbsenceEleveTraitement($absenceEleveTraitement, $comparison = null)
{
if ($absenceEleveTraitement instanceof AbsenceEleveTraitement) {
return $this
->addUsingAlias(JTraitementSaisieElevePeer::A_TRAITEMENT_ID, $absenceEleveTraitement->getId(), $comparison);
} elseif ($absenceEleveTraitement instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this
->addUsingAlias(JTraitementSaisieElevePeer::A_TRAITEMENT_ID, $absenceEleveTraitement->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByAbsenceEleveTraitement() only accepts arguments of type AbsenceEleveTraitement or PropelCollection');
}
}
/**
* Filter the query by a related MeshingSchema object
*
* @param MeshingSchema|PropelCollection $meshingSchema The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return MeshingSchemaTableQuery The current query, for fluid interface
*/
public function filterByMeshingSchema($meshingSchema, $comparison = null)
{
if ($meshingSchema instanceof MeshingSchema) {
return $this->addUsingAlias(MeshingSchemaTablePeer::SCHEMA_ID, $meshingSchema->getId(), $comparison);
} elseif ($meshingSchema instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(MeshingSchemaTablePeer::SCHEMA_ID, $meshingSchema->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByMeshingSchema() only accepts arguments of type MeshingSchema or PropelCollection');
}
}
/**
* Filter the query by a related Classe object
*
* @param Classe|PropelCollection $classe The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return PeriodeNoteQuery The current query, for fluid interface
*/
public function filterByClasse($classe, $comparison = null)
{
if ($classe instanceof Classe) {
return $this
->addUsingAlias(PeriodeNotePeer::ID_CLASSE, $classe->getId(), $comparison);
} elseif ($classe instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this
->addUsingAlias(PeriodeNotePeer::ID_CLASSE, $classe->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByClasse() only accepts arguments of type Classe or PropelCollection');
}
}
/**
* Filter the query by a related Chart object
*
* @param Chart|PropelCollection $chart The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return JobQuery The current query, for fluid interface
*/
public function filterByChart($chart, $comparison = null)
{
if ($chart instanceof Chart) {
return $this->addUsingAlias(JobPeer::CHART_ID, $chart->getId(), $comparison);
} elseif ($chart instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(JobPeer::CHART_ID, $chart->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByChart() only accepts arguments of type Chart or PropelCollection');
}
}
/**
* Filter the query by a related CategorieMatiere object
*
* @param CategorieMatiere|PropelCollection $categorieMatiere The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return MatiereQuery The current query, for fluid interface
*/
public function filterByCategorieMatiere($categorieMatiere, $comparison = null)
{
if ($categorieMatiere instanceof CategorieMatiere) {
return $this
->addUsingAlias(MatierePeer::CATEGORIE_ID, $categorieMatiere->getId(), $comparison);
} elseif ($categorieMatiere instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this
->addUsingAlias(MatierePeer::CATEGORIE_ID, $categorieMatiere->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByCategorieMatiere() only accepts arguments of type CategorieMatiere or PropelCollection');
}
}
/**
* Filter the query by a related Libro object
*
* @param Libro|PropelCollection $libro The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return ClasificadosQuery The current query, for fluid interface
*/
public function filterByLibro($libro, $comparison = null)
{
if ($libro instanceof Libro) {
return $this->addUsingAlias(ClasificadosPeer::ID_LIBRO, $libro->getId(), $comparison);
} elseif ($libro instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(ClasificadosPeer::ID_LIBRO, $libro->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByLibro() only accepts arguments of type Libro or PropelCollection');
}
}
/**
* Filter the query by a related Usuario object
*
* @param Usuario|PropelCollection $usuario The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return Solicitud_amistadQuery The current query, for fluid interface
*/
public function filterByUsuarioRelatedById_usuario_solicitante($usuario, $comparison = null)
{
if ($usuario instanceof Usuario) {
return $this->addUsingAlias(Solicitud_amistadPeer::ID_USUARIO_SOLICITANTE, $usuario->getId(), $comparison);
} elseif ($usuario instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(Solicitud_amistadPeer::ID_USUARIO_SOLICITANTE, $usuario->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByUsuarioRelatedById_usuario_solicitante() only accepts arguments of type Usuario or PropelCollection');
}
}
/**
* Filter the query by a related Lista object
*
* @param Lista|PropelCollection $lista The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return Lista_audiolibroQuery The current query, for fluid interface
*/
public function filterByLista($lista, $comparison = null)
{
if ($lista instanceof Lista) {
return $this->addUsingAlias(Lista_audiolibroPeer::ID_LISTA, $lista->getId(), $comparison);
} elseif ($lista instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(Lista_audiolibroPeer::ID_LISTA, $lista->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByLista() only accepts arguments of type Lista or PropelCollection');
}
}
/**
* Filter the query by a related Tipo_notificacion object
*
* @param Tipo_notificacion|PropelCollection $tipo_notificacion The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return NotificacionQuery The current query, for fluid interface
*/
public function filterByTipo_notificacion($tipo_notificacion, $comparison = null)
{
if ($tipo_notificacion instanceof Tipo_notificacion) {
return $this->addUsingAlias(NotificacionPeer::ID_TIPO_NOTIFICACION, $tipo_notificacion->getId(), $comparison);
} elseif ($tipo_notificacion instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(NotificacionPeer::ID_TIPO_NOTIFICACION, $tipo_notificacion->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByTipo_notificacion() only accepts arguments of type Tipo_notificacion or PropelCollection');
}
}
/**
* Filter the query by a related sfGuardGroup object
*
* @param sfGuardGroup|PropelCollection $sfGuardGroup The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return sfGuardUserGroupQuery The current query, for fluid interface
*/
public function filterBysfGuardGroup($sfGuardGroup, $comparison = null)
{
if ($sfGuardGroup instanceof sfGuardGroup) {
return $this->addUsingAlias(sfGuardUserGroupPeer::GROUP_ID, $sfGuardGroup->getId(), $comparison);
} elseif ($sfGuardGroup instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(sfGuardUserGroupPeer::GROUP_ID, $sfGuardGroup->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterBysfGuardGroup() only accepts arguments of type sfGuardGroup or PropelCollection');
}
}
/**
* Filter the query by a related AidDetails object
*
* @param AidDetails|PropelCollection $aidDetails The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return EdtEmplacementCoursQuery The current query, for fluid interface
*/
public function filterByAidDetails($aidDetails, $comparison = null)
{
if ($aidDetails instanceof AidDetails) {
return $this
->addUsingAlias(EdtEmplacementCoursPeer::ID_AID, $aidDetails->getId(), $comparison);
} elseif ($aidDetails instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this
->addUsingAlias(EdtEmplacementCoursPeer::ID_AID, $aidDetails->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByAidDetails() only accepts arguments of type AidDetails or PropelCollection');
}
}
/**
* Filter the query by a related Dept object
*
* @param Dept|PropelCollection $dept The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return CourseQuery The current query, for fluid interface
*/
public function filterByDept($dept, $comparison = null)
{
if ($dept instanceof Dept) {
return $this->addUsingAlias(CoursePeer::DEPT_ID, $dept->getId(), $comparison);
} elseif ($dept instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(CoursePeer::DEPT_ID, $dept->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByDept() only accepts arguments of type Dept or PropelCollection');
}
}
/**
* Filter the query by a related Pelicula object
*
* @param Pelicula|PropelCollection $pelicula The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return SocioAlquilerQuery The current query, for fluid interface
*/
public function filterByPelicula($pelicula, $comparison = null)
{
if ($pelicula instanceof Pelicula) {
return $this->addUsingAlias(SocioAlquilerPeer::PELICULA_ID, $pelicula->getId(), $comparison);
} elseif ($pelicula instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(SocioAlquilerPeer::PELICULA_ID, $pelicula->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByPelicula() only accepts arguments of type Pelicula or PropelCollection');
}
}
/**
* Filter the query by a related Socio object
*
* @param Socio|PropelCollection $socio The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return AlquilerQuery The current query, for fluid interface
*/
public function filterBySocio($socio, $comparison = null)
{
if ($socio instanceof Socio) {
return $this->addUsingAlias(AlquilerPeer::SOCIO_ID, $socio->getId(), $comparison);
} elseif ($socio instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(AlquilerPeer::SOCIO_ID, $socio->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterBySocio() only accepts arguments of type Socio or PropelCollection');
}
}
/**
* Filter the query by a related Genero object
*
* @param Genero|PropelCollection $genero The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return Usuario_interesesQuery The current query, for fluid interface
*/
public function filterByGenero($genero, $comparison = null)
{
if ($genero instanceof Genero) {
return $this->addUsingAlias(Usuario_interesesPeer::ID_GENERO, $genero->getId(), $comparison);
} elseif ($genero instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(Usuario_interesesPeer::ID_GENERO, $genero->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByGenero() only accepts arguments of type Genero or PropelCollection');
}
}
/**
* Filter the query by a related AncienEtablissement object
*
* @param AncienEtablissement|PropelCollection $ancienEtablissement The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return JEleveAncienEtablissementQuery The current query, for fluid interface
*/
public function filterByAncienEtablissement($ancienEtablissement, $comparison = null)
{
if ($ancienEtablissement instanceof AncienEtablissement) {
return $this
->addUsingAlias(JEleveAncienEtablissementPeer::ID_ETABLISSEMENT, $ancienEtablissement->getId(), $comparison);
} elseif ($ancienEtablissement instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this
->addUsingAlias(JEleveAncienEtablissementPeer::ID_ETABLISSEMENT, $ancienEtablissement->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByAncienEtablissement() only accepts arguments of type AncienEtablissement or PropelCollection');
}
}
/**
* Filter the query by a related Adresse object
*
* @param Adresse|PropelCollection $adresse The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return AbsenceEleveNotificationQuery The current query, for fluid interface
*/
public function filterByAdresse($adresse, $comparison = null)
{
if ($adresse instanceof Adresse) {
return $this
->addUsingAlias(AbsenceEleveNotificationPeer::ADR_ID, $adresse->getId(), $comparison);
} elseif ($adresse instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this
->addUsingAlias(AbsenceEleveNotificationPeer::ADR_ID, $adresse->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByAdresse() only accepts arguments of type Adresse or PropelCollection');
}
}
/**
* Filter the query by a related sfGuardUser object
*
* @param sfGuardUser|PropelCollection $sfGuardUser The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return FileQuery The current query, for fluid interface
*/
public function filterBysfGuardUser($sfGuardUser, $comparison = null)
{
if ($sfGuardUser instanceof sfGuardUser) {
return $this->addUsingAlias(FilePeer::LAST_CHANGE_COMMIT_USER, $sfGuardUser->getId(), $comparison);
} elseif ($sfGuardUser instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(FilePeer::LAST_CHANGE_COMMIT_USER, $sfGuardUser->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterBysfGuardUser() only accepts arguments of type sfGuardUser or PropelCollection');
}
}
/**
* Filter the query by a related Groupe object
*
* @param Groupe|PropelCollection $groupe The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return JGroupesProfesseursQuery The current query, for fluid interface
*/
public function filterByGroupe($groupe, $comparison = null)
{
if ($groupe instanceof Groupe) {
return $this
->addUsingAlias(JGroupesProfesseursPeer::ID_GROUPE, $groupe->getId(), $comparison);
} elseif ($groupe instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this
->addUsingAlias(JGroupesProfesseursPeer::ID_GROUPE, $groupe->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByGroupe() only accepts arguments of type Groupe or PropelCollection');
}
}
/**
* Filter the query by a related Eleve object
*
* @param Eleve|PropelCollection $eleve The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return AbsenceAgregationDecompteQuery The current query, for fluid interface
*/
public function filterByEleve($eleve, $comparison = null)
{
if ($eleve instanceof Eleve) {
return $this
->addUsingAlias(AbsenceAgregationDecomptePeer::ELEVE_ID, $eleve->getId(), $comparison);
} elseif ($eleve instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this
->addUsingAlias(AbsenceAgregationDecomptePeer::ELEVE_ID, $eleve->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByEleve() only accepts arguments of type Eleve or PropelCollection');
}
}
/**
* Filter the query by a related MeshingTrustType object
*
* @param MeshingTrustType|PropelCollection $meshingTrustType The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return MeshingTrustLocalQuery The current query, for fluid interface
*/
public function filterByMeshingTrustType($meshingTrustType, $comparison = null)
{
if ($meshingTrustType instanceof MeshingTrustType) {
return $this->addUsingAlias(MeshingTrustLocalPeer::TYPE, $meshingTrustType->getId(), $comparison);
} elseif ($meshingTrustType instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(MeshingTrustLocalPeer::TYPE, $meshingTrustType->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByMeshingTrustType() only accepts arguments of type MeshingTrustType or PropelCollection');
}
}
/**
* Filter the query by a related sfGuardPermission object
*
* @param sfGuardPermission|PropelCollection $sfGuardPermission The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return sfGuardUserPermissionQuery The current query, for fluid interface
*/
public function filterBysfGuardPermission($sfGuardPermission, $comparison = null)
{
if ($sfGuardPermission instanceof sfGuardPermission) {
return $this->addUsingAlias(sfGuardUserPermissionPeer::PERMISSION_ID, $sfGuardPermission->getId(), $comparison);
} elseif ($sfGuardPermission instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(sfGuardUserPermissionPeer::PERMISSION_ID, $sfGuardPermission->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterBysfGuardPermission() only accepts arguments of type sfGuardPermission or PropelCollection');
}
}
/**
* Filter the query by a related CahierTexteSequence object
*
* @param CahierTexteSequence|PropelCollection $cahierTexteSequence The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return CahierTexteCompteRenduQuery The current query, for fluid interface
*/
public function filterByCahierTexteSequence($cahierTexteSequence, $comparison = null)
{
if ($cahierTexteSequence instanceof CahierTexteSequence) {
return $this
->addUsingAlias(CahierTexteCompteRenduPeer::ID_SEQUENCE, $cahierTexteSequence->getId(), $comparison);
} elseif ($cahierTexteSequence instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this
->addUsingAlias(CahierTexteCompteRenduPeer::ID_SEQUENCE, $cahierTexteSequence->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByCahierTexteSequence() only accepts arguments of type CahierTexteSequence or PropelCollection');
}
}
/**
* Filter the query by a related afWidgetCategory object
*
* @param afWidgetCategory|PropelCollection $afWidgetCategory The related object(s) to use as filter
* @param string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
*
* @return afWidgetSelectorQuery The current query, for fluid interface
*/
public function filterByafWidgetCategory($afWidgetCategory, $comparison = null)
{
if ($afWidgetCategory instanceof afWidgetCategory) {
return $this->addUsingAlias(afWidgetSelectorPeer::CATEGORY_ID, $afWidgetCategory->getId(), $comparison);
} elseif ($afWidgetCategory instanceof PropelCollection) {
if (null === $comparison) {
$comparison = Criteria::IN;
}
return $this->addUsingAlias(afWidgetSelectorPeer::CATEGORY_ID, $afWidgetCategory->toKeyValue('PrimaryKey', 'Id'), $comparison);
} else {
throw new PropelException('filterByafWidgetCategory() only accepts arguments of type afWidgetCategory or PropelCollection');
}
}
