*************************************************************************************************************************************
555855
public function supprimer($idEvenement, $idHistoriqueEvenement = '')
    {
        $html = '';
        $idEvenementGroupeAdresse = 0;
        if ($idHistoriqueEvenement !='') {
            $adresse = new archiAdresse();
            $reqRecupIdEvenementGroupeAdresse = "
					SELECT DISTINCT ee.idEvenement as idEvenementGroupeAdresse
					FROM evenements he
					LEFT JOIN _evenementEvenement ee ON ee.idEvenementAssocie = he.idEvenement
					WHERE idEvenement ='".$idHistoriqueEvenement."'";
            //debug($reqRecupIdEvenementGroupeAdresse);
            $resRecupIdEvenementGroupeAdresse = $this->connexionBdd->requete($reqRecupIdEvenementGroupeAdresse);
            $fetchRecupIdEvenementGroupeAdresse = mysql_fetch_assoc($resRecupIdEvenementGroupeAdresse);
            $idEvenementGroupeAdresse = $fetchRecupIdEvenementGroupeAdresse['idEvenementGroupeAdresse'];



            // recup d'idAdresse pour l'affichage du detail de l'adresse a la fin de la suppression
            $reqSuppHistorique = "DELETE FROM evenements WHERE idEvenement = '".idEvenement."'";
            //debug($reqSuppHistorique);
            $resSupprHistorique = $this->connexionBdd->requete($reqSuppHistorique);


            // maj des position au cas ou , meme si dans ce cas en principe ce n'est pas la peine (a moins que ce ne soit le dernier historique du groupe d'adresse
            $this->majPositionsEvenements(array('idEvenementGroupeAdresse'=>$idEvenementGroupeAdresse,'refreshAfterDelete'=>true));


            $idAdresse = $adresse->getIdAdresseFromIdEvenementGroupeAdresse($idEvenementGroupeAdresse);
        } else {
            $image = new archiImage();
            $personne = new archiPersonne();
            $courant = new archiCourantArchitectural();
            $adresse = new archiAdresse();

            // suppression d'un evenement
            // verification que l'evenement est le seul ou pas lié au groupe d'adresse
            $idEvenementGroupeAdresse = $this->getParent($idEvenement);


            foreach ($_SESSION['lastVisited'] as $key => $lastVisit) {
                if ($lastVisit['idEvenementGroupeAdresse'] == $idEvenementGroupeAdresse) {
                    unset($_SESSION['lastVisited'][$key]);
                }
            }

            //debug($idEvenementGroupeAdresse);
            // on verifie que l'evenement n'a qu'un seul parent
            $reqVerifParent = "
					SELECT idEvenement
					FROM _evenementEvenement
					WHERE idEvenementAssocie = '".$idEvenement."'
							";
            //debug($reqVerifParent);

            $resVerifParent = $this->connexionBdd->requete($reqVerifParent);
            if (mysql_num_rows($resVerifParent)==1) {
            // on verifie que l'evenement parent est bien un groupe d'adresse ( pour le jour ou on ajoutera les sous sous evenements)
                if ($this->isEvenementGroupeAdresse($idEvenementGroupeAdresse)) {
                // comptage du nombre d'elements du groupe d'adresse
                    $req = "select idEvenementAssocie from _evenementEvenement where idEvenement = '".$idEvenementGroupeAdresse."'";
                    //debug($req);
                    $res = $this->connexionBdd->requete($req);

                    if (mysql_num_rows($res)==1) {
                    // un seul element a supprimer , on supprime aussi le groupe d'adresse dans un deuxieme temps , voir plus bas, et donc les commentaires lies a ce groupe d'adresse

                        // evenement images
                        $image->deleteImagesFromIdEvenement($idEvenement);
                        // personnes
                        $personne->deleteLiaisonsPersonneFromIdEvenement($idEvenement);
                        // courant architectural
                        $courant->deleteLiaisonsCourantFromIdEvenement($idEvenement);
                        // commentaires
                        $adresse->deleteCommentairesFromIdEvenement($idEvenementGroupeAdresse);
                        // adresses liees à l'evenement , on supprime la liaison
                        $this->deleteLiaisonsAdressesLieesSurEvenement($idEvenement);

                        // quand il y aura des sous sous evenements , il faudra aussi les supprimer
                        // ...
                        $reqDeleteEvenement = "DELETE FROM evenements WHERE idEvenement = '".$idEvenement."'";
                        //debug($reqDeleteEvenement);
                        $resDeleteEvenement = $this->connexionBdd->requete($reqDeleteEvenement);

                        $reqDeleteEvenementGroupeEvenement = "DELETE FROM evenements WHERE idEvenement = ( SELECT idEvenement FROM _evenementEvenement WHERE idEvenementAssocie = '".$idEvenement."' )";
                        $reqDeleteEvenementEvenement = "DELETE FROM _evenementEvenement WHERE idEvenementAssocie = '".$idEvenement."'";
                        //debug($reqDeleteEvenementEvenement);
                        $resDeleteEvenementEvenement = $this->connexionBdd->requete($reqDeleteEvenementEvenement);

                        // maj des position
                        $this->majPositionsEvenements(array('idEvenementGroupeAdresse'=>$idEvenementGroupeAdresse,'refreshAfterDelete'=>true)); // dans ce cas la fonction va se charger de supprimer les positions des evenements du groupe d'adresse supprimé
                    } elseif (mysql_num_rows($res)>1) {
                        $image = new archiImage();
                        $personne = new archiPersonne();
                        $courant = new archiCourantArchitectural();
                        // plusieurs elements , on supprime simplement l'evenement passé en parametre de la fonction

                        // evenement images
                        $image->deleteImagesFromIdEvenement($idEvenement);
                        // personnes
                        $personne->deleteLiaisonsPersonneFromIdEvenement($idEvenement);
                        // courant architectural
                        $courant->deleteLiaisonsCourantFromIdEvenement($idEvenement);
                        // quand il y aura des sous sous evenements , il faudra aussi les supprimer
                        // ...
                        // adresses liees à l'evenement , on supprime la liaison
                        $this->deleteLiaisonsAdressesLieesSurEvenement($idEvenement);

                        $reqDeleteEvenementEvenement = "DELETE FROM _evenementEvenement WHERE idEvenementAssocie = '".$idEvenement."'";
                        //debug($reqDeleteEvenementEvenement);
                        $resDeleteEvenementEvenement = $this->connexionBdd->requete($reqDeleteEvenementEvenement);

                        //supression de l'evenement
                        $reqDeleteEvenement = "DELETE FROM evenements WHERE idEvenement = '".$idEvenement."'";
                        //debug($reqDeleteEvenement);
                        $resDeleteEvenement = $this->connexionBdd->requete($reqDeleteEvenement);

                        $this->majPositionsEvenements(array('idEvenementGroupeAdresse'=>$idEvenementGroupeAdresse,'refreshAfterDelete'=>true)); // dans ce cas la fonction va mettre a jour les positions des evenements pour que ceux ci se suivent, et supprimera la liaison vers l'evenement qui n'existe plus
                    } elseif (mysql_num_rows($res)==0) {
                    // probleme , il n'y a pas d'evenements fils correspondant a l'idEvenementGroupeAdresse
                        echo "l'événement n'existe plus. Veuillez contacter l'administrateur.<br>";
                    }
                } else {
                    echo "L'événement parent n'est pas de type groupe d'adresse : veuillez contactez l'administrateur.<br>";
                }
            } elseif (mysql_num_rows($resVerifParent)>1) {
                echo "Erreur : l'evenement appartient a plusieurs groupes d'adresses : contactez l'administrateur<br>";
            } else {
                echo "Erreur : l'evenement n'appartient a aucun groupe d'adresse : contactez l'administrateur<br>";
            }



            // pour l'affichage de retour : on recupere l'adresse
            $idAdresse = $adresse->getIdAdresseFromIdEvenementGroupeAdresse($idEvenementGroupeAdresse); // attention si l'evenement groupe adresse a ete supprimé precedemment


            $nbEvenementLiesAuGroupeAdresse = $this->getNbEvenementsFromGroupeAdresse($idEvenementGroupeAdresse);

            if ($nbEvenementLiesAuGroupeAdresse==0 && $idEvenementGroupeAdresse!='' && $idEvenementGroupeAdresse !='0') {
            // s'il n'y a aucun evenement lié au groupe d'adresses , on peut supprimer le groupe d'adresse et les liaisons vers celui ci
                $reqDeleteGroupeAdresseHistorique = "DELETE FROM evenements WHERE idEvenement = '".$idEvenementGroupeAdresse."'";
                //debug($reqDeleteGroupeAdresseHistorique);
                $resDeleteGroupeAdresseHistorique = $this->connexionBdd->requete($reqDeleteGroupeAdresseHistorique);

                $reqDeleteAdresseGroupeAdresse = "DELETE FROM _adresseEvenement WHERE idEvenement = '".$idEvenementGroupeAdresse."'";
                //debug($reqDeleteAdresseGroupeAdresse);
                $resDeleteAdresseGroupeAdresse = $this->connexionBdd->requete($reqDeleteAdresseGroupeAdresse);

                // on supprime aussi les liaisons vers le groupe d'adresse dans les adresses liés
                $reqDeleteLiaisonsAdressesLiees = "DELETE FROM _evenementAdresseLiee WHERE idEvenementGroupeAdresse='".$idEvenementGroupeAdresse."'";
                //debug($reqDeleteLiaisonsAdressesLiees);
                $resDeleteAdresseGroupeAdresse = $this->connexionBdd->requete($reqDeleteLiaisonsAdressesLiees);

                // supprimons aussi les liaisons vueSur et prisDepuis sur le groupe d'adresse
                $reqDeleteVueSurPrisDepuis = "DELETE FROM _adresseImage WHERE idEvenementGroupeAdresse = '".$idEvenementGroupeAdresse."' AND (vueSur='1' OR prisDepuis='1')";
                //debug($reqDeleteVueSurPrisDepuis);
                $resDeleteVueSurPrisDepuis = $this->connexionBdd->requete($reqDeleteVueSurPrisDepuis);

                // suppression des liaisons entre evenement et evenement groupe d'adresse
                $reqDeleteEvenementGAEvenementAssocie = "DELETE FROM _evenementEvenement WHERE idEvenement='".$idEvenementGroupeAdresse."'";
                //debug($reqDeleteEvenementGAEvenementAssocie);
                $resDeleteEvenementGAEvenementAssocie = $this->connexionBdd->requete($reqDeleteEvenementGAEvenementAssocie);
                $idEvenementGroupeAdresse=0;
            }
        }
        if ($idPerson=archiPersonne::isPerson($idEvenementGroupeAdresse)) {
            header("Location: ".$this->creerUrl('', '', array('archiAffichage'=>'evenementListe', 'selection'=>"personne", 'id'=>$idPerson), false, false));
        }
        if ($idEvenementGroupeAdresse == 0) {
            header("Location: index.php");
        } else {
            header("Location: ".$this->creerUrl('', '', array('archiAffichage'=>'adresseDetail', 'archiIdAdresse'=>$idAdresse, 'archiIdEvenementGroupeAdresse'=>$idEvenementGroupeAdresse), false, false));
        }
    }
60858
@Override
  protected void perturbation(List<DoubleSolution> swarm)  {
    nonUniformMutation.setCurrentIteration(currentIteration);

    for (int i = 0; i < swarm.size(); i++) {
      if (i % 3 == 0) {
        nonUniformMutation.execute(swarm.get(i));
      } else if (i % 3 == 1) {
        uniformMutation.execute(swarm.get(i));
      }
    }
  }
234389
function () {
            if (this._tplcfg) {
                var tplcfg = this._tplcfg;
                var toDispose = tplcfg.toDispose;
                if (toDispose) {
                    var toDisposeLength = toDispose.length;
                    for (var i = 0; i < toDisposeLength; i++) {
                        toDispose[i].$dispose();
                    }
                }
                tplcfg.toDispose = null;
                tplcfg.tplDiv = null;
                tplcfg.div = null;
                tplcfg.data = null;
                this._tplcfg = null;
            }
        }
1104178
private function checkDefinitions(): void {
    // Add many to many stuff if necessary
    foreach($this->unchecked as $def) {
      foreach($def->many_to_many as $relation) {
        //echo "Processing many to many for {$def->name}\n";

        // Set up left keys
        $related = $this->defs[$relation->entity_left];

        if(empty($relation->id_left)) {
          //echo "Setting {$relation->alias_join} id_left to {$related->id->alias}\n";
          $relation->idLeft($related->id->alias);
        }

        if(empty($relation->key_left)) {
          //echo "Setting {$relation->alias_join} key_left to " . keyify($related->name) . "\n";
          $relation->keyLeft(keyify($related->name));
        }
        //

        // Set up right keys
        $related = $this->defs[$relation->entity_right];

        if(empty($relation->id_right)) {
          //echo "Setting {$relation->alias_join} id_right to {$related->id->alias}\n";
          $relation->idRight($related->id->alias);
        }

        if(empty($relation->key_right)) {
          //echo "Setting {$relation->alias_join} key_right to " . keyify($related->name) . "\n";
          $relation->keyRight(keyify($related->name));
        }
        //

        // Left side relations
        $related = $this->defs[$relation->entity_left];

        //echo "Adding {$related->name} hasManyThrough {$relation->alias_join} to {$relation->alias_right}\n";
        $related->hasManyThrough(pluralize($relation->alias_right), $relation->entity_join, $relation->entity_right)
          ->idLocal($relation->id_left)
          ->idForeign($relation->id_right)
          ->keyLocal($relation->key_left)
          ->keyForeign($relation->key_right)
        ;

        if(!array_key_exists($relation->alias_join, $def->has_many)) {
          //echo "Adding {$related->name} hasMany {$def->name}\n";
          $related->hasMany($relation->alias_join, $def->full_name)
            ->localKey  ($relation->id_left)
            ->foreignKey($relation->key_left)
          ;
        }

        if(!array_key_exists($relation->alias_left, $def->belongs_to)) {
          //echo "Adding {$def->name} belongsTo {$related->name}\n";
          $def->belongsTo($relation->alias_left, $related->full_name);
        }
        //

        // Right side relations
        $related = $this->defs[$relation->entity_right];

        //echo "Adding {$related->name} hasManyThrough {$relation->alias_join} to {$relation->alias_left}\n";
        $related->hasManyThrough(pluralize($relation->alias_left), $relation->entity_join, $relation->entity_left)
          ->idLocal($relation->id_right)
          ->idForeign($relation->id_left)
          ->keyLocal($relation->key_right)
          ->keyForeign($relation->key_left)
        ;

        if(!array_key_exists($relation->alias_join, $def->has_many)) {
          //echo "Adding {$related->name} hasMany {$def->name}\n";
          $related->hasMany($relation->alias_join, $def->full_name)
            ->localKey  ($relation->id_right)
            ->foreignKey($relation->key_right)
          ;
        }

        if(!array_key_exists($relation->alias_right, $def->belongs_to)) {
          //echo "Adding {$def->name} belongsTo {$related->name}\n";
          $def->belongsTo($relation->alias_right, $related->full_name);
        }
        //
      }
    }

    // Add has many stuff if necessary
    foreach($this->unchecked as $def) {
      foreach($def->has_many as $relation) {
        //echo "Processing has many for {$def->name}\n";

        $related = $this->defs[$relation->foreign_entity];

        if(empty($relation->local_key)) {
          //echo "Setting {$relation->alias} local_key to {$def->id->alias}\n";
          $relation->localKey($def->id->alias);
        }

        if(empty($relation->foreign_key)) {
          //echo "Setting {$relation->alias} foreign_key to " . keyify($related->name) . "\n";
          $relation->foreignKey(keyify($related->name));
        }
      }
    }

    // Add belongs to stuff if necessary
    foreach($this->unchecked as $def) {
      foreach($def->belongs_to as $relation) {
        //echo "Processing belongs to for {$def->name}\n";

        $related = $this->defs[$relation->foreign_entity];

        if(empty($relation->local_key)) {
          //echo "Setting {$relation->alias} local_key to " . keyify($related->name) . "\n";
          $relation->localKey(keyify($related->name));
        }

        if(empty($relation->foreign_key)) {
          //echo "Setting {$relation->alias} foreign_key to {$def->id->alias}\n";
          $relation->foreignKey($related->id->alias);
        }

        if(!array_key_exists($relation->local_key, $related->required)) {
          //echo "Adding {$def->name} column {$relation->local_key} of type {$related->id->type}\n";
          $def->required($relation->local_key, $related->id->type);
        }
      }
    }

    // We've checked everything in the queue.  Clear it out.
    $this->unchecked = [];
  }
767330
@Override
   public void onCreate(SQLiteDatabase db) {
      int pointer = context.getResources().getIdentifier(INIT_CREATE_SQL, "string", context.getPackageName());
      if (pointer == 0) {
         Log.e(TAG, "undefined sql id - " + INIT_CREATE_SQL);
      } else {
         String createTabelSql = context.getResources().getString(pointer);
         for (String sql : createTabelSql.split(";")) {
            db.execSQL(sql);
         }
      }
   }
126459
void initInputsByIdMap() {
    inputsById.clear();
    for (CompilerInput input : externs) {
      InputId id = input.getInputId();
      CompilerInput previous = putCompilerInput(id, input);
      if (previous != null) {
        report(JSError.make(DUPLICATE_EXTERN_INPUT, input.getName()));
      }
    }
    for (CompilerInput input : moduleGraph.getAllInputs()) {
      InputId id = input.getInputId();
      CompilerInput previous = putCompilerInput(id, input);
      if (previous != null) {
        report(JSError.make(DUPLICATE_INPUT, input.getName()));
      }
    }
  }
810772
public function initialize()
    {
        if ($this->initialized || ! $this->association) {
            return;
        }

        $this->doInitialize();

        $this->initialized = true;
    }
362130
public function process()
    {
        parent::process();

        $data = &$this->getForm()->getFormData();

        if (!isset($data[$this->id])) {
            return;
        }

        $this->value = $data[$this->id];
        $length = $this->getValueLength();

        if ($length === 0) {
            $this->value = null;
        }

        if ($this->required && $length === 0) {
            $message = $this->getValidationMessage('required');
            $this->addMessage($message);
        } elseif ($this->maxlength !== null && $length > $this->maxlength) {
            $message = $this->getValidationMessage('too-long');
            $message->primary_content = sprintf(
                $message->primary_content,
                $this->maxlength
            );

            $this->addMessage($message);
        }
    }
328688
public function execute()
    {
        if (!$this->isEmpty()) {
            $this->table->update($this->context + $this->values, $this->where)->run();
        }

        parent::execute();
    }
316320
public function populate($data = array())
    {
        if (isset($data['title']) && $data['title'] !== null) {
            $this->title = $data['title'];
        }

        if (isset($data['identifier']) && $data['identifier'] !== null) {
            $this->identifier = $data['identifier'];
        }

        if (isset($data['active']) && $data['active'] !== null) {
            $this->active = $data['active'];
        }

        if (isset($data['picto']) && $data['picto'] !== null) {
            $this->picto = $data['picto'];
        }
    }
734008
public function execute()
    {
        $this->insertID = $this->table->insertOne($this->context + $this->data);
        parent::execute();
    }
898114
public function execute($request)
    {
        RequestNotSupportedException::assertSupports($this, $request);

        /** @var PaymentInterface $payment */
        $payment = $request->getModel();

        if (in_array($payment->getState(), array(PaymentInterface::STATE_APPROVED, PaymentInterface::STATE_DEPOSITED))) {
            $request->markCaptured();

            return;
        }

        if (in_array($payment->getState(), array(PaymentInterface::STATE_DEPOSITING))) {
            $request->markPending();

            return;
        }

        if (in_array($payment->getState(), array(PaymentInterface::STATE_CANCELED))) {
            $request->markCanceled();

            return;
        }

        if (in_array($payment->getState(), array(PaymentInterface::STATE_EXPIRED))) {
            $request->markExpired();

            return;
        }

        if (in_array($payment->getState(), array(PaymentInterface::STATE_FAILED))) {
            $request->markFailed();

            return;
        }

        if (in_array($payment->getState(), array(PaymentInterface::STATE_NEW, PaymentInterface::STATE_APPROVING))) {
            $request->markNew();

            return;
        }

        $request->markUnknown();
    }
1136189
function(){
        while(this.numPairs>0){
            var pair=this.pairs[--this.numPairs];
            pair.shape1=null;
            pair.shape2=null;
        }
        this.numPairChecks=0;
        this.collectPairs();
    }
1367861
public function merge($data) {

		if (! is_array($data)) {
			$data = $this->makeArray($data);
		}
		
		$this->_data = array_merge($this->_data, $data);
	}
280629
@Override
  public final void sample()
  {
    long count = _count.getAndSet(0);
    long time = _time.getAndSet(0);

    if (count == 0)
      _value = 0;
    else
      _value = time / (double) count;
  }
950258
public function methodChanged(): void
    {
        assert($this->offsetExists(self::VAR_LINE_METHOD));

        if (self::METHOD_POST === $this->offsetGet(self::VAR_LINE_METHOD)) {
            $this->offsetSet(self::VAR_BODY, null);
            if ($this->offsetExists(self::VAR_PARSED_POST)
                && is_null($this->offsetGet(self::VAR_PARSED_POST))) {
                $this->offsetSet(self::VAR_PARSED_POST, new MutableArray());
            }
            if ($this->offsetExists(self::VAR_PARSED_FILES)
                && is_null($this->offsetGet(self::VAR_PARSED_FILES))) {
                $this->offsetSet(self::VAR_PARSED_FILES, new MutableArray());
            }
        } else if (self::METHOD_PUT === $this->offsetGet(self::VAR_LINE_METHOD)) {
            if ($this->offsetExists(self::VAR_BODY)
                && is_null($this->offsetGet(self::VAR_BODY))) {
                $this->offsetSet(self::VAR_BODY, '');
            }
            $this->offsetSet(self::VAR_PARSED_POST, null);
            $this->offsetSet(self::VAR_PARSED_FILES, null);
        } else {
            $this->offsetSet(self::VAR_BODY, null);
            $this->offsetSet(self::VAR_PARSED_POST, null);
            $this->offsetSet(self::VAR_PARSED_FILES, null);
        }
    }
1330059
public function validate($value, Constraint $constraint): void
    {
        if ($value !== null) {
            $type = $constraint->type;
            $values = $type::getValues();
            if (!\in_array($value, $values, true)) {
                $this->context->buildViolation($constraint->message)
                    ->setParameter('{{ type }}', $constraint->type)
                    ->setParameter('{{ value }}', $value)
                    ->addViolation();
            }
        }
    }