Charge et établit une liste qui donne, chaque contraction, forme non contracte qui lui correspond.
502308
def ajContractions(self):
        
        for lin in lignesFichier(self.path("contractions.la")):
            ass1, ass2 = tuple(lin.split(':'))
            self.lemmatiseur._contractions[ass1] = ass2
879711
protected void addOrders(CriteriaBuilder criteriaBuilder, Root<T> root, CriteriaQuery<T> criteriaQuery, Map<String, OrderType> orders) {
		
		// Si la liste est vide
		if(orders == null || orders.size() == 0) return;
		
		// Liste d'ordres
		List<Order> lOrders = new ArrayList<Order>();
		
		// Parcours
		for (String property : orders.keySet()) {
			
			// Si la propriete est vide
			if(property == null || property.trim().length() == 0) continue;
			
			// Evaluation de la ppt
			Path<?> path = buildPropertyPathForAnyType(root, property.trim());
			
			// Obtention du Type
			OrderType type = orders.get(property);
			
			// Si le type est null
			if(type == null) continue;
			
			// Si on est en ASC
			if(type.equals(OrderType.ASC)) lOrders.add(criteriaBuilder.asc(path));
			else lOrders.add(criteriaBuilder.desc(path));
		}
		
		// Ajout
		criteriaQuery.orderBy(lOrders);
	}
845685
protected function load() {

        // On initialise les variables
        $roles     = $this->getRoles();
        $resources = $this->getResources();
        $sections  = $this->getActions();
        $rules     = $this->getRules();

        // On parcourt les actions par section.
        foreach ($sections as $section) {

            // Si la section a des actions.
            if (!empty($section->actions)) {

                // On récupère la ressource.
                $resource = $resources[$section->name];

                // On crée une règle pour chaque action.
                foreach ($section->actions as $action) {

                    // On récupère les autorisations des rôles pour cette action.
                    if (isset($rules[$section->name]) && isset($rules[$section->name]->rules->{$action->name})) {
                        $ruleValues = $rules[$section->name]->rules->{$action->name};

                        // Et pour chaque rôle.
                        foreach ($roles as $role) {

                            // 3 valeurs possibles :
                            //   1    => le groupe est présent et autorisé
                            //   0    => le groupe est présent et non autorisé
                            //   null => le groupe n'est pas présent et donc hérite des droits du parent.
                            // Le groupe est présent, on crée une règle ACL pour le tri action-rôle-ressource.

                            if (is_object($ruleValues) && property_exists($ruleValues, $role->getName())) {

                                $rule = new Rule($action->name);
                                $rule->setRole($role);
                                $rule->setResource($resource);
                                $rule->setAction((bool) $ruleValues->{$role->getName()});

                                // On ajoute la règle au gestionnaire.
                                $this->acl->addRule($rule);

                            }

                        }
                    }

                }

            }

        }

    }
1197494
def solve_assignement(self, costs):
        
        if costs is None or len(costs) == 0:
            return dict()

        n = costs.shape[0]

        pairs = [(i, j) for i in range(0, n) for j in range(0, n) if costs[i, j] < invalid_match]

        costs_list = [costs[i, j] for (i, j) in pairs]

        assignment = lapjv.lapjv(list(zip(*pairs))[0], list(zip(*pairs))[1], costs_list)

        indexes = enumerate(list(assignment[0]))

        return dict([(row, col) for row, col in indexes])
290239
public function ajouter()
    {
        $html = '';
        $erreur = array();
        $tabForm = array();
        $ajoutOk = false;
        $aAuthentification = new archiAuthentification();
        $formulaire = new formGenerator();
        if ($aAuthentification->estConnecte() == 0) {
            echo 'utilisateur non connecté';
            $this->erreurs->ajouter('Vous n\'êtes pas connecté !');
        } elseif (isset($this->variablesPost['ajoutSousEvenement'])) {
            $tabForm=$this->getEvenementFields('nouveauDossier');

            $erreur = $formulaire->getArrayFromPost($tabForm);

            if (count($erreur) == 0) {
                $this->connexionBdd->getLock(array('evenements'));

                //***************
                //**  GESTION DES VARIABLES
                //**

                $titre              = mysql_escape_string($tabForm['titre']['value']);
                $description        = mysql_escape_string($tabForm['description']['value']);
                $dateDebut          = $this->date->toBdd($this->date->convertYears($tabForm['dateDebut']['value']));
                $isDateDebutEnviron = $tabForm['isDateDebutEnviron']['value'];
                $dateFin            = $this->date->toBdd($this->date->convertYears($tabForm['dateFin']['value']));
                $idSource=0;
                if ($tabForm['source']['value']!='') {
                    $idSource    = $tabForm['source']['value'];
                }
                $idUtilisateur   = $aAuthentification->getIdUtilisateur();
                $idTypeStructure = $tabForm['typeStructure']['value'];
                $idTypeEvenement = $tabForm['typeEvenement']['value'];
                $nbEtages = $tabForm['nbEtages']['value'];


                $ISMH           = $tabForm['ISMH']['value'];
                $MH             = $tabForm['MH']['value'];


                //**************
                //**  VERIFICATION DOUBLON
                //**

                $sqlVerificationDoublon = "
						SELECT he1.idEvenement
						FROM evenements he2, evenements he1
						RIGHT JOIN _evenementEvenement ee ON ee.idEvenement = '".$this->variablesPost['evenementGroupeAdresse']."'
						WHERE he2.idEvenement = he1.idEvenement
						AND he1.titre='".$titre."'
						AND he1.idEvenement = ee.idEvenementAssocie
						AND he1.description = \"".$description."\"
						AND he1.dateDebut = \"".$dateDebut."\"
						AND he1.isDateDebutEnviron = '".$isDateDebutEnviron."'
						AND he1.dateFin = \"".$dateFin."\"
						AND he1.idSource = '".$idSource."'
						AND he1.idTypeStructure='".$idTypeStructure."'
						AND he1.idTypeEvenement='".$idTypeEvenement."'
						GROUP BY he1.idEvenement, he1.idEvenement
						";

                $res = $this->connexionBdd->requete($sqlVerificationDoublon);

                if (mysql_num_rows($res) != 0) {
                    $this->erreurs->ajouter(_("Exactement le même enregistrement existe déjà !"));

                    // on défini les informations pour pouvoir tout de même afficher l'événement
                    $rep         = mysql_fetch_object($res);
                    $idEvenement = $rep->idEvenement;
                    $ajoutOk     = true;
                } else {
                    //***************
                    //**  ENREGISTREMENT
                    //**
                    //$idEvenement = $this->getNewIdEvenement();
                    // si c'est un événement sans événements parents
                    // c'est qu'il faut créer un evenement vide
                    // ayant pour type d'événement un groupe d'adresses
                    // sur lequel on va donc lier les adresses

                    if (!isset($this->variablesPost['evenementGroupeAdresse']) || $this->variablesPost['evenementGroupeAdresse']=='') {//(empty($tabForm['evenements']['value']))
                    // creation de l'evenement parent groupe d'adresse
                        $sql = "INSERT INTO evenements (titre, description, dateDebut, dateFin, idSource, idUtilisateur, idTypeStructure, idTypeEvenement,dateCreationEvenement)
								VALUES ('', '', '', '', ".$idSource.", ".$idUtilisateur.", 0, '".$this->getIdTypeEvenementGroupeAdresse()."', now())";

                        $this->connexionBdd->requete($sql);
                        $tabForm['evenements']['value'][] = $idEvenement;

                        $idEvenement = $this->connexionBdd->getLastId();
                        $idSousEvenement =$idEvenement+ 1; // id du sous evenements lié à l'evenement groupe d'adresses


                        // on lie les adresses a l'evenement groupe d'adresse
                        if (!empty($tabForm['adresses']['value'])) {
                            $sqlEvenementAdresse = "INSERT INTO _adresseEvenement (idAdresse,idEvenement) VALUES ";
                            foreach (array_unique($tabForm['adresses']['value']) as $idAdresse) {
                                $sqlEvenementAdresse .= '('.$idAdresse.', '.$idEvenement.'),';
                            }
                            $sqlEvenementAdresse = pia_substr($sqlEvenementAdresse, 0, -1);
                            $this->connexionBdd->requete($sqlEvenementAdresse);
                        }
                    } else {
                        $idSousEvenement = $idEvenement; // si on est dans le cas d'un ajout de sous evenement simple , sans creation de groupe d'adresse, on recupere l'id d'un nouvel element virtuel (getNewIdEVenement)
                    }



                    // debug
                    if ($nbEtages=='') {
                        $nbEtages=0;
                    }

                    // ajout de l'evenement fils
                    $sqlHistoriqueEvenement =
                    "INSERT INTO evenements (
								titre,
								description,
								dateDebut,
								dateFin,
								idSource,
								idUtilisateur,
								idTypeStructure,
								idTypeEvenement,
								dateCreationEvenement ,
								nbEtages,
								ISMH,
								MH,
								isDateDebutEnviron
							)

							VALUES (
								\"".$titre."\",
								\"".$description."\",
								'".$dateDebut."',
								'".$dateFin."',
								 ".$idSource.",
								 ".$idUtilisateur.",
						 		'".$idTypeStructure."',
				 				'".$idTypeEvenement."',
		 						now(),
		 						".$nbEtages.",
	 							'".$ISMH."',
	 							'".$MH."',
	 							'".$isDateDebutEnviron."'
 														)";
                    $this->connexionBdd->requete($sqlHistoriqueEvenement);


                    $idSousEvenement=$this->connexionBdd->getLastId();


                    if (!empty($tabForm['courant']['value'])) {
                        $sqlEvenementCourantArchitectural = "INSERT INTO _evenementCourantArchitectural (idCourantArchitectural, idEvenement) VALUES ";
                        foreach (array_unique($tabForm['courant']['value']) as $idCourant) {
                            $sqlEvenementCourantArchitectural .= '('.$idCourant.', '.$idSousEvenement.'),';
                        }
                        $sqlEvenementCourantArchitectural = pia_substr($sqlEvenementCourantArchitectural, 0, -1);

                        $this->connexionBdd->requete($sqlEvenementCourantArchitectural);
                    }

                    if (!empty($tabForm['personnes']['value'])) {
                        $sqlEvenementPersonne = "INSERT INTO _evenementPersonne (idPersonne, idEvenement) VALUES ";
                        foreach (array_unique($tabForm['personnes']['value']) as $idPersonne) {
                            $sqlEvenementPersonne .= '('.$idPersonne.', '.$idSousEvenement.'),';
                        }
                        $sqlEvenementPersonne = pia_substr($sqlEvenementPersonne, 0, -1);
                        $this->connexionBdd->requete($sqlEvenementPersonne);
                    }


                    //TODO : Gestion du tableau de source
                    /*
					 if(!empty($tabForm['source']['value'])){
					$sqlEvenementSource = "INSERT INTO _evenementSource (idSource, idEvenement) VALUES ";
					foreach ( array_unique($tabForm['source']['value']) AS $idSource)
					{
					$sqlEvenementSource .= '('.$idSource.', '.$idSousEvenement.'),';
					}
					$sqlEvenementSource = pia_substr( $sqlEvenementSource, 0, -1);

					$this->connexionBdd->requete($sqlEvenementSource);
					}
					*/




                    // ajout de l'evenement enfant à l'evenement groupe d'adresse

                    if (!isset($this->variablesPost['evenementGroupeAdresse']) || $this->variablesPost['evenementGroupeAdresse']=='') {//(empty($tabForm['evenements']['value']))
                    // cas liaison entre le nouvel evenement groupe d'adresse et le nouvel evenement fils // ajout d'un evenement
                        $sqlEvenementEvenement = "
								insert into _evenementEvenement (idEvenement,idEvenementAssocie)
								values ('".$idEvenement."','".$idSousEvenement."');
										";
                        //debug($sqlEvenementEvenement);
                        $this->connexionBdd->requete($sqlEvenementEvenement);
                    } else {
                        // cas liaison entre l'element groupe d'adresse precisé dans $tabForm['evenementGroupeAdresse'] et le nouvel evenement fils // ajout d'un sous evenement
                        $sqlEvenementEvenement = "
								insert into _evenementEvenement (idEvenement,idEvenementAssocie)
								values ('".$this->variablesPost['evenementGroupeAdresse']."','".$idSousEvenement."')
										";
                        //debug($sqlEvenementEvenement);
                        $this->connexionBdd->requete($sqlEvenementEvenement);
                    }

                    $ajoutOk = true;
                }

                // libération de la table
                $this->connexionBdd->freeLock(array('evenements'));
            }
        }

        if ($ajoutOk === true) {
            if (isset($idSousEvenement)) {
                $idEvenementGroupeAdresse = $this->getIdEvenementGroupeAdresseFromIdEvenement($idSousEvenement);

                // d'abord on classe les evenements (les positions précédentes sont conservees)
                $this->majPositionsEvenements(array('idEvenementGroupeAdresse'=>$idEvenementGroupeAdresse,'idNouvelEvenement'=>$idSousEvenement));

                $mail = new mailObject();
                $adresse = new archiAdresse();
                $reqAdresses = $adresse->getIdAdressesFromIdEvenement(array('idEvenement'=>$idSousEvenement));

                $resAdresses = $this->connexionBdd->requete($reqAdresses);
                $arrayVilles=array();
                $arrayAdresses = array();
                while ($fetchAdresses = mysql_fetch_assoc($resAdresses)) {
                    $arrayVilles[] = $adresse->getIdVilleFrom($fetchAdresses['idAdresse'], 'idAdresse');
                    $arrayAdresses[] = $fetchAdresses['idAdresse'];
                }

                $arrayVilles = array_unique($arrayVilles);
                $arrayAdresses = array_unique($arrayAdresses);

                if ($idPerson=archiPersonne::isPerson($idEvenementGroupeAdresse)) {
                    header("Location: ".$this->creerUrl('', '', array('archiAffichage'=>'evenementListe', 'selection'=>"personne", 'id'=>$idPerson), false, false));
                }

                // ************************************************************************************************************************************************
                // envoi d'un mail a l'auteur de l'adresse
                // ************************************************************************************************************************************************
                $utilisateur = new archiUtilisateur();
                $arrayUtilisateurs = $utilisateur->getCreatorsFromAdresseFrom($idSousEvenement, 'idEvenement');

                $intituleAdresse = $adresse->getIntituleAdresseFrom($idSousEvenement, 'idEvenement');
                foreach ($arrayUtilisateurs as $indice => $idUtilisateurAdresse) {
                    if ($idUtilisateurAdresse != $aAuthentification->getIdUtilisateur()) {
                        $infosUtilisateur = $utilisateur->getArrayInfosFromUtilisateur($idUtilisateurAdresse);
                        if ($infosUtilisateur['alerteAdresses']=='1' && $infosUtilisateur['compteActif']=='1' && $infosUtilisateur['idProfil']!='4') {
                            $messageDebut = "Un utilisateur a ajouté un événement sur une adresse dont vous êtes l'auteur.";
                            $messageDebut.= "Pour vous rendre sur l'événement : <br>";
                            $messageDebut.="<a href='".$this->creerUrl('', '', array('archiAffichage'=>'adresseDetail','archiIdAdresse'=>$arrayAdresses[0],'archiIdEvenementGroupeAdresse'=>$idEvenementGroupeAdresse))."'>".$intituleAdresse."</a><br>";
                            $messageFin= $this->getMessageDesabonnerAlerteMail();

                            if ($utilisateur->isMailEnvoiImmediat($idUtilisateurAdresse)) {
                                $mail->sendMail($mail->getSiteMail(), $infosUtilisateur['mail'], 'Mise a jour d\'un événement d\'une adresse dont vous êtes l\'auteur.', $messageDebut.$messageFin, true);
                            } else {
                                $utilisateur->ajouteMailEnvoiRegroupes(array('contenu'=>$messageDebut,'idDestinataire'=>$idUtilisateurAdresse,'idTypeMailRegroupement'=>10));
                            }
                        }
                    }
                }
                // ************************************************************************************************************************************************

                // ************************************************************************************************************************************************
                // envoi au administrateurs qui sont en mode alerteAdresse
                // ************************************************************************************************************************************************

                $message = "";
                $message .= "Un nouvel événement a été ajouté sur l'adresse suivante : <br>";
                $message.="<a href='".$this->creerUrl('', '', array('archiAffichage'=>'adresseDetail','archiIdAdresse'=>$arrayAdresses[0],'archiIdEvenementGroupeAdresse'=>$idEvenementGroupeAdresse))."'>".$adresse->getIntituleAdresseFrom($idSousEvenement, 'idEvenement')."</a>";

                $mail->sendMailToAdministrators($mail->getSiteMail(), "Un nouvel événement a été ajouté - ".$intituleAdresse, $message, " AND alerteAdresses='1' ", true);
                $utilisateur->ajouteMailEnvoiRegroupesAdministrateurs(array('contenu'=>$message,'idTypeMailRegroupement'=>10,'criteres'=>" and alerteAdresses='1' "));
                // ************************************************************************************************************************************************

                // *************************************************************************************************************************************************************
                // envoi mail aussi au moderateur si ajout sur adresse de ville que celui ci modere
                $u = new archiUtilisateur();


                $arrayListeModerateurs = $u->getArrayIdModerateursActifsFromVille($arrayVilles[0], array("sqlWhere"=>" AND alerteAdresses='1' "));
                if (count($arrayListeModerateurs)>0) {
                    foreach ($arrayListeModerateurs as $indice => $idModerateur) {
                        if ($aAuthentification->getIdUtilisateur()!=$idModerateur) {
                            if ($u->isMailEnvoiImmediat($idModerateur)) {
                                $mailModerateur = $u->getMailUtilisateur($idModerateur);
                                $mail->sendMail($mail->getSiteMail(), $mailModerateur, "Un nouvel événement a été ajouté - ".$intituleAdresse, $message, true);
                            } else {
                                $u->ajouteMailEnvoiRegroupes(array('contenu'=>$message,'idDestinataire'=>$idModerateur,'idTypeMailRegroupement'=>10));
                            }
                        }
                    }
                }

                // *************************************************************************************************************************************************************

                if ($idPerson=archiPersonne::isPerson($idEvenementGroupeAdresse)) {
                    header("Location: ".$this->creerUrl('', '', array('archiAffichage'=>'evenementListe', 'selection'=>"personne", 'id'=>$idPerson), false, false));
                } else {
                    $adresse = new archiAdresse();
                    $idGroupeAdresse = $this->getParent($idSousEvenement);
                    $idAdresse = $this->getIdAdresseFromIdEvenementGroupeAdresse($idGroupeAdresse);

                    $url= $this->creerUrl(
                        '',
                        '',
                        array(
                                'archiAffichage'=>'adresseDetail',
                                "archiIdAdresse"=>$idAdresse,
                                "archiIdEvenementGroupeAdresse"=>$idGroupeAdresse
                        )
                    );
                        header("Location: ".htmlspecialchars_decode($url));
                }
            }
        } else {
            $html .= $this->afficheFormulaire($tabForm);
        }

        return $html;
    }
1122800
def constraints_since(self, other):
        

        constraints = [ ]
        cur = self
        while cur is not other and cur is not None:
            constraints.extend(cur.recent_constraints)
            cur = cur.parent
        return constraints
1127687
function quote(inst, list, argv, event, fin) {
    // Remember to charge for the 'quote' function as a transaction
    if (!ok(inst, inst.options.quoteTransaction)) return exit(inst, list, fin);
    var entity = list[list.length - 1];
    if (_isValue(entity)) return fin(null, entity);
    var quotation = {};
    quotation[RUNIQ_QUOTED_ENTITY_PROP_NAME] = entity;
    return fin(null, quotation);
}
48948
def droit_d_accise(depense, droit_cn, consommation_cn, taux_plein_tva):
    
    return depense * ((1 + taux_plein_tva) * droit_cn) / (consommation_cn - (1 + taux_plein_tva) * droit_cn)
259726
public function afficher($id)
    {
        $html = '';
        $formulaire = new formGenerator();
        if ($formulaire->estChiffre($id) == 1) {
            $sql = 'SELECT p.nom as nom, p.prenom as prenom,  m.nom as metier,  p.idPersonne as idPersonne,  p.dateNaissance as dateNaissance,  p.dateDeces as dateDeces,  p.description as description
                    FROM personne p
                    LEFT JOIN metier m ON m.idMetier = p.idMetier
                    WHERE p.idPersonne='.$id.' LIMIT 1';
            $rep = $this->connexionBdd->requete($sql);
            if (mysql_num_rows($rep) == 1) {
                $res = mysql_fetch_object($rep);

                $t = new Template('modules/archi/templates/');
                $t->set_filenames((array('pe'=>'personne.tpl')));

                $e = new archiEvenement();

                $t->assign_vars(
                    array(
                        'prenom' => $res->prenom,
                        'nom'    => $res->nom,
                        'metier' => $res->metier,
                        'dateNaissance'=> $this->date->toFrench($res->dateNaissance),
                        'dateDeces'    => $this->date->toFrench($res->dateDeces),
                        'description'  => $res->description,
                        'urlAjout'     => $this->creerUrl('ajouterPersonne'),
                        'evenementLies'=> $e->afficherListe(array( 'selection' => 'personne',  'id' => $res->idPersonne))
                    )
                );

                ob_start();
                $t->pparse('pe');
                $html .= ob_get_contents();
                ob_end_clean();
            } else {
                $html .= 'ERREUR aucun résultat !';
            }
        } else {
            $html .= 'ERREUR mauvais ID!';
        }
        return $html;
    }
896373
protected function doExecute() {

        $container = $this->getContainer();

        // On affecte le logger si besoin.
        if ($container->has('logger')) {
            $this->setLogger($container->get('logger'));
        }

        // Config
        $container->get('config')->merge($this->config);
        $this->setConfiguration($container->get('config'));

        // On récupère la session.
        $session = $container->get('session');
        $this->setSession($session);

        // On nettoie les veilles sessions
        $this->sessionCleanUp();

        // On démarre la session.
        $session->start();

        // Si c'est une requête pour garder en vie la session, on peut quitter ici.
        if ($this->input->get('stayAlive', false, 'bool') === true) {
            echo "1";
            $this->close();
        }

        // On initialise l'état utilisateur.
        if ($session->isNew() || $session->get('state') === null) {
            $session->set('state', new Registry);
        }

        // On tente d'auto-connecter l'utilisateur.
        $this->loginWithCookie();

        // On personnalise l'environnement suivant l'utilisateur dans la session.
        $user = $session->get('user');
        if ($user) {

            $language = $user->params->get('language');
            $helper   = new LanguageHelper;

            // On s'assure que la langue de l'utilisateur existe.
            if ($language && $helper->exists($language, JPATH_ROOT)) {
                $this->set('language', $language);
            }

            $timezone = $user->params->get('timezone');
            if ($timezone) {
                $this->set('timezone', $timezone);
            }

        }

        // On définit le fuseau horaire.
        @date_default_timezone_set($this->get('timezone', 'Europe/Paris'));

        // On récupère le controller.
        $controller = $this->route();

        // On contrôle si l'utilisateur doit changer son mot de passe.
        $this->checkUserRequireReset($controller);

        // On redirige en HTTPS si besoin.
        /*if ($this->get('force_ssl') && !$this->isSSLConnection() && $controller->isSSLEnabled()) {
            $uri = new Uri($this->get('uri.request'));
            $uri->setScheme('https');
            $this->redirect((string)$uri);
        }*/

        // On sauvegarde le controller actif.
        $this->_activeController = strtolower($controller->getName());

        try {

            $profiler = $this->container->has('profiler') ? $this->container->get('profiler') : false;

            if ($profiler) {
                $profiler->mark('beforeControllerExecute');
            }

            // On exécute la logique du controller et on récupère le résultat.
            $result = $controller->execute();

            if ($profiler) {
                $profiler->mark('afterControllerExecute');
            }

            // On effectue le rendu de la page avec le résultat.
            $this->render($result);

        } catch (\Exception $e) {
            $this->raiseError($e->getMessage(), $e->getCode(), $e);
        }

    }
522902
def _parse_req(requnit, reqval):
        '''  '''
        assert reqval[0] != '='

        try:
            retn = []
            for val in reqval.split(','):
                if requnit == 'month':
                    if reqval[0].isdigit():
                        retn.append(int(reqval))  # must be a month (1-12)
                    else:
                        try:
                            retn.append(list(calendar.month_abbr).index(val.title()))
                        except ValueError:
                            retn.append(list(calendar.month_name).index(val.title()))
                else:
                    retn.append(int(val))
        except ValueError:
            return None

        if not retn:
            return None

        return retn[0] if len(retn) == 1 else retn
73532
private void assignAsymIds(List<List<Chain>> polys, List<List<Chain>> nonPolys, List<List<Chain>> waters) {

		for (int i=0; i<polys.size(); i++) {
			String asymId = "A";

			for (Chain poly:polys.get(i)) {
				poly.setId(asymId);
				asymId = getNextAsymId(asymId);
			}
			for (Chain nonPoly:nonPolys.get(i)) {
				nonPoly.setId(asymId);
				asymId = getNextAsymId(asymId);
			}
			for (Chain water:waters.get(i)) {
				water.setId(asymId);
				asymId = getNextAsymId(asymId);
			}
		}
	}
437122
private function ajoutRue($idSousQuartier, $nom, $prefixe)
    {
        // on verifie qu'il n'existe pas deja une rue du meme nom dans la ville
        // recherche de la ville
        $reqVille = "
                    SELECT distinct v.idVille as idVille
                    FROM ville v
                    LEFT JOIN quartier q ON q.idVille = v.idVille
                    LEFT JOIN sousQuartier sq ON sq.idQuartier = q.idQuartier
                    WHERE
                        sq.idSousQuartier = '$idSousQuartier'
                    ";
        $resVille = $this->connexionBdd->requete($reqVille);
        $adresseExistante = 0;
        if (mysql_num_rows($resVille)>0) {
            $fetchVille = mysql_fetch_assoc($resVille);
            $idVille =$fetchVille['idVille'];


            $reqVerif = "
            SELECT r.idRue
            FROM rue r
            LEFT JOIN sousQuartier sq ON sq.idSousQuartier = r.idSousQuartier
            LEFT JOIN quartier q ON q.idQuartier = sq.idQuartier
            LEFT JOIN ville v ON v.idVille = q.idVille
            WHERE
            LOWER(r.nom) = LOWER(\"".$nom."\")
            AND LOWER(r.prefixe) = LOWER(\"".$prefixe."\")
            AND v.idVille = '".$idVille."'
            ";

            $resVerif=$this->connexionBdd->requete($reqVerif);
            if (mysql_num_rows($resVerif)>0) {
                $adresseExistante = 1;
            }
        }


        $sql="
            SELECT idRue
            FROM rue
            WHERE idSousQuartier = '".$idSousQuartier."'
            AND LOWER(nom) = LOWER(\"".$nom."\")
            AND LOWER(prefixe) = LOWER(\"".$prefixe."\")
        ";

        $res=$this->connexionBdd->requete($sql);
        $newIdRue = 0;
        if ($adresseExistante || mysql_num_rows($res)>0) {
            $this->erreurs->ajouter(_("Erreur :")." "._("il y a déjà un enregistrement de rue du même nom dans cette ville"));
        } else {
            // ajout
            $this->connexionBdd->requete("
                INSERT INTO rue (idSousQuartier,nom,prefixe)
                VALUES ('".$idSousQuartier."',\"".$nom."\",\"".$prefixe."\")
            ");

            $newIdRue = mysql_insert_id();
        }

        return $newIdRue;
    }
899134
function loadOneComponent(name) {
        // Si le composant est déjà chargé, on le retourne.
        if (components[name] !== undefined) return components[name];

        // Le composant n'est pas encore chargé.
        // On tente de le trouver dans la conf IOC.
        if (!that.config) throw new Error("La configuration est indéfinie.");
        if (!that.config.ioc || !that.config.ioc[name]) throw new Error(`La configuration ioc est indéfinie pour le composant "${name}".`);

        // Le composant a un chemin défini.
        var componentPath = that.config.ioc[name];
        var componentClass = require(componentPath);
        var componentClassStr = componentClass.toString();

        // Si le constructeur du composant a des arguments, on va tenter de les charger comme dépendances.
        var m = componentClassStr.match(/^function +[\$a-zA-Z_][\$\w_]*\((.+?)\)[ \t\r\n]*\{/);
        // Syntaxe ES6 avec une méthode "constructor"
        if (!m) m = componentClassStr.match(/[^\w]constructor *\((.+?)\)[ \t\r\n]*\{/);

        var pDependencies;
        if (m) {
            var constructorArgs = m[1].split(/[ \t\r\n]*,[ \t\r\n]*/);
            pDependencies = that.load(constructorArgs);
        } else {
            pDependencies = Promise.resolve([]);
        }

        // Une fois les dépendances résolues, on instancie le composant.
        var pComponent = pDependencies.then(function(dependenciesInstances) {
            var args = [null].concat(dependenciesInstances);
            var instance = new (componentClass.bind.apply(componentClass, args));

            if (typeof instance.init === "function") {
                return Promise.resolve(instance.init()).then(function() {
                    return instance;
                });
            }
            return instance;
        });

        // On le stocke...
        components[name] = pComponent;

        // Puis on le retourne.
        return pComponent;
    }
874271
public void ecrire(String texte)
	{
		//on va chercher le chemin et le nom du fichier et on me tout ca dans un String
		String adressedufichier = System.getProperty("user.dir") + "\\monfichier.txt";
	
		//on me try si jamais il y a une exception
		try
		{
			
			//BufferedWriter a besoin d un FileWriter, 
			//les 2 vont ensemble, on donne comme argument le nom du fichier
			//true signifie qu on ajoute dans le fichier (append), on ne marque pas par dessus 
			FileWriter fw = new FileWriter(adressedufichier, true);
			
			// le BufferedWriter output auquel on donne comme argument le FileWriter fw cree juste au dessus
			BufferedWriter output = new BufferedWriter(fw);
			
			//on marque dans le fichier ou plutot dans le BufferedWriter qui sert comme un tampon(stream)
			output.write(texte);
			//on peut utiliser plusieurs fois methode write
			
			output.flush();
			//ensuite flush envoie dans le fichier, ne pas oublier cette methode pour le BufferedWriter
			
			output.close();
			//et on le ferme
			
		}
		catch(IOException ioe){System.out.println("erreur : " + ioe );}
		//on "catch" l exception ici si il y en a une, et on l affiche sur la console 

	}
1333220
private function buildOriginReference()
    {
        /* - Code produit (2 positions numériques) : voir annexe 12.2
         * - Numéro de colis (10 positions numériques) : ce numéro doit être unique. Vous le composez à votre
         *   guise suivant la logique qui vous convient (chrono, numéro commande…) Il pourra également vous
         *   servir pour le suivi colis
         * - Constante : 0000
         * - Pays de destination (2 positions alpha.) : idem T100
         *
         * Exemple : T8975:0200000000800000FR */

        return Service::getNumerical($this->service) .
            str_pad($this->number, 10, '0', STR_PAD_LEFT) .
            '0000' .
            $this->get(Config::T100);
    }
1207842
function addToList(i, L, R) {
    R[L[i + 1]] = R[i];
    L[R[i]] = L[i + 1];
    R[i] = i + 1;
    L[i + 1] = i;
}