bouchon pour tests unitaires
548114
@SuppressWarnings("unchecked")
	private <T> T createMockResultOfCall() throws IOException {
		final Object result;
		final String request = url.toString();
		if (!request.contains(HttpParameter.PART.getName() + '=')
				&& !request.contains(HttpParameter.JMX_VALUE.getName())
				|| request.contains(HttpPart.DEFAULT_WITH_CURRENT_REQUESTS.getName())) {
			final String message = request.contains("/test2") ? null
					: "ceci est message pour le rapport";
			result = Arrays.asList(new Counter(Counter.HTTP_COUNTER_NAME, null),
					new Counter("services", null), new Counter(Counter.ERROR_COUNTER_NAME, null),
					new JavaInformations(null, true), message);
		} else {
			result = LabradorMock.createMockResultOfPartCall(request);
		}
		return (T) result;
	}
1200377
public <T> void validate(T entity) {
		
		// Obtention de l'ensemble des violations
		Set<ConstraintViolation<T>> constraintViolations = validator.validate(entity);
		
		// Si l'ensemble est vide
		if(constraintViolations == null || constraintViolations.size() == 0) return;

		// Obtention de la première violation
		ConstraintViolation<T> first = constraintViolations.iterator().next();
		
		// Obtention du descripteur de la contrainte
		ConstraintDescriptor<?> constraintDescriptor = first.getConstraintDescriptor();
		
		// Nom du bean en echec
		String entityName = first.getRootBeanClass().getSimpleName();
		
		// Nom de la propriété en echec
		String propertyName = first.getPropertyPath().toString();
		
		// Message de violation
		String message = first.getMessage();
		
		// Obtention de l'annotation en cours
		String[] parameters = buildAnnotationConstraintParameters(constraintDescriptor.getAnnotation());
		
		// On leve une Exception
		throw new InvalidEntityInstanceStateException(entityName, propertyName, message, parameters);
	}
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;
    }
964255
def FRStaeckel(u,v,pot,delta): #pragma: no cover because unused
    
    R,z= bovy_coords.uv_to_Rz(u,v,delta=delta)
    return _evaluateRforces(pot,R,z)
1364739
def check_conditions(f, args, kwargs):
    
    member_function = is_member_function(f)

    # check the functions direct pre conditions
    check_preconditions(f, args, kwargs)

    # for member functions check the pre conditions up the chain
    base_classes = []
    if member_function:
        base_classes = inspect.getmro(type(args[0]))[1:-1]
        for clz in base_classes:
            super_fn = getattr(clz, f.func_name, None)
            check_preconditions(super_fn, args, kwargs)

    # run the real function
    return_value = f(*args, **kwargs)

    # check the functions direct post conditions
    check_postconditions(f, return_value)

    # for member functions check the post conditions up the chain
    if member_function:
        for clz in base_classes:
            super_fn = getattr(clz, f.func_name, None)
            check_postconditions(super_fn, return_value)

    return return_value
601341
public function isValid()
    {
        $this->key    = [];
        $this->errors = [];
        $this->correctInputs();
        foreach ($this->rules as $key => $test) {
            /* Si la valeur est requise uniquement avec la présence de certains champs. */
            if ($this->isRequiredWhith($key) && $this->isOneVoidValue($key)) {
                continue;
            }
            /* Si la valeur est requise uniquement en l'absence de certains champs. */
            if ($this->isRequiredWhithout($key) && !$this->isAllVoidValue($key)) {
                continue;
            }
            /* Si la valeur n'est pas requise et vide. */
            if ($this->isNotRequired($key) && $this->isVoidValue($key)) {
                continue;
            }
            /* Pour chaque règle cherche les fonctions séparées par un pipe. */
            foreach (explode('|', $test) as $rule) {
                $this->parseRules($key, $rule);
            }
        }

        return empty($this->errors);
    }
4405
function prepareTemplates(templates){
  var valueGeneratorsDict = {
    select: function(obj){
      var types = {
        random:function(){
          return obj.choice[Math.floor(Math.random() * obj.choice.length)];
        },
        liner: function(){
          var el = obj.choice.shift();
          obj.choice.push(el);
          return el;
        },
        random_unique: function(){
          function shuffle(o) {
            for(var j, x, i = o.length; i; j = parseInt(Math.random() * i), x = o[--i], o[i] = o[j], o[j] = x);
            return o;
          };
          if(!obj.randomized){obj.randomized = shuffle(obj.choice.slice());}
          var el = obj.randomized.shift();
          if(el===undefined){
            log.notEnoughChoice('random_unique','choice');
            process.exit()
          }
          return el;
        }
      }
      if(!types[obj.type]){
        return log.noTemplateType('select', obj.type, Object.keys(types))
      }
      return types[obj.type]
    },
    lipsum: function(obj){
      if(!(obj.max_char_length&&obj.min_char_length)){
        return log.missingSettings('lipsum', '', ['max_char_length','mim_char_length'])
      }
      var lorem = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.'
      return function(){
        var chars = Math.floor(Math.random()*(obj.max_char_length-obj.min_char_length)+obj.min_char_length)
        var str = lorem.slice(0, chars)
        while(str.length < chars){
          var len = chars - str.length
          str += ' '+lorem.slice(0, len)
        }
        return str
      }
    },
    number: function(obj){
      var types = {
        random:function(){
          return Math.floor(Math.random()*(obj.max_num-obj.min_num)+obj.min_num);
        },
        incremental: function(){
          tempdata += obj.increments
          return tempdata;
        }
      }

      if(!types[obj.type]){
        return log.noTemplateType('number', obj.type, Object.keys(types))
      }
      if(obj.type == 'random' && !(obj.max_num&&obj.min_num)){
        return log.missingSettings('number', 'random', ['max_num','min_num'])
      }
      if(obj.type == 'incremental'){
        if(!(obj.starting_num&&obj.increments)){
          return log.missingSettings('number', 'incremental', ['starting_num','increments'])
        }
        var tempdata = this[obj.id] = obj.starting_num - obj.increments
      }

      return types[obj.type]
    },
    datetime: function(obj){
      var types = {
        random:function(){
          return output[obj.output_format](new Date(Math.floor(Math.random()*(max-min)+min)));
        },
        incremental: function(){
          tempdata += obj.increments
          return output[obj.output_format](new Date(tempdata));
        }
      }
      var output = {
        toString: function(d){ return d.toString(); },
        toDateString: function(d){ return d.toDateString(); },
        toISOString: function(d){ return d.toISOString(); },
        toJSON: function(d){ return d.toJSON(); },
        toGMTString: function(d){ return d.toGMTString(); },
        toLocaleDateString: function(d){ return d.toLocaleDateString(); },
        toLocaleString: function(d){ return d.toLocaleString(); },
        toLocaleTimeString: function(d){ return d.toLocaleTimeString(); },
        toTimeString: function(d){ return d.toTimeString(); },
        toUTCString: function(d){ return d.toUTCString(); },
        toYMDString:function(d){
          return d.toJSON().split('T')[0]
        }
      }

      if(!types[obj.type]){
        return log.noTemplateType('date', obj.type, Object.keys(types))
      }
      if(obj.type == 'random'){
        if(!(obj.max_datetime&&obj.min_datetime&&obj.output_format)){
          return log.missingSettings('date', 'random', ['max_datetime','min_datetime','output_format'])
        }
        var min = Date.parse(obj.min_datetime)
        var max = Date.parse(obj.max_datetime)
        if(isNaN(min)){
          return log.notParseableDatetime('min_datetime', obj.min_datetime)
        }else if(isNaN(max)){
          return log.notParseableDatetime('max_datetime', obj.max_datetime)
        }
      }
      if(obj.type == 'incremental'){
        if(!(obj.starting_datetime&&obj.increments&&obj.output_format)){
          return log.missingSettings('number', 'incremental', ['starting_datetime','increments','output_format'])
        }
        var tempdata = this[obj.id] = Date.parse(obj.starting_datetime) - obj.increments
        if(isNaN(tempdata)){
          return log.notParseableDatetime('starting_datetime', obj.starting_datetime)
        }
      }

      return types[obj.type]
    }
  }

  /*
  Recursively iterate each key in template object to find `stub_type` key.
  If the object has `stub_type` key, replace itself with corresponding
  function in valueGenerators valid
  Arg:
    - obj (Object)
  */
  function parseTemplate(obj) {
    for (var key in obj) {
      if (obj[key] !== null && typeof(obj[key])=="object") {
        if(obj[key].stub_type){
          if(!valueGeneratorsDict[obj[key].stub_type]){
            log.stubTypeNotFound(obj[key].stub_type)
          }else{
            obj[key].id = crypto.randomBytes(16).toString('hex');
            obj[key] = valueGeneratorsDict[obj[key].stub_type](obj[key])
          }
        }else{
          parseTemplate(obj[key]);
        }
      }
    }
  }

  if(templates){
    Object.keys(templates).map(function(t){
      parseTemplate(templates[t]);
    })
    return templates;
  }else{
    return [];
  }
}
204222
def frombools(cls, bools=()):
        """"""
        return cls.fromint(sum(compress(cls._atoms, bools)))
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;
    }
1142686
def _le_from_gt(self, other):
    """"""
    op_result = self.__gt__(other)
    if op_result is NotImplemented:
        return NotImplemented
    return not op_result
216124
@Override
	public void processValidation(Object entity) {
		
		// Si la liste des validateurs est vide
		if(this.validators == null || this.validators.length == 0) {
						
			// On sort
			return;
		}
		
		// Classe d'execution de la validation
		SizeDAOValidatorRule rule = new SizeDAOValidatorRule();
		
		// Parcours de la liste
		for (Annotation annotation : this.validators) {
			
			// On initialize
			rule.initialize(annotation, entityManager, this.systemDAOMode, this.systemEvaluationTime);
			
			// On valide
			rule.processValidation(entity);
		}
	}
1202362
function cubicBezierAtTime(t,p1x,p1y,p2x,p2y,duration) {
      var ax = 0,bx = 0,cx = 0,ay = 0,by = 0,cy = 0;
      function sampleCurveX(t) {return ((ax * t + bx) * t + cx) * t;}
      function sampleCurveY(t) {return ((ay * t + by) * t + cy) * t;}
      function sampleCurveDerivativeX(t) {return (3.0 * ax * t + 2.0 * bx) * t + cx;}
      function solveEpsilon(duration) {return 1.0 / (200.0 * duration);}
      function solve(x,epsilon) {return sampleCurveY(solveCurveX(x,epsilon));}
      function fabs(n) {if (n >= 0) {return n;}else {return 0 - n;}}
      function solveCurveX(x,epsilon) {
        var t0,t1,t2,x2,d2,i;
        for (t2 = x, i = 0; i < 8; i++) {x2 = sampleCurveX(t2) - x; if (fabs(x2) < epsilon) {return t2;} d2 = sampleCurveDerivativeX(t2); if (fabs(d2) < 1e-6) {break;} t2 = t2 - x2 / d2;}
        t0 = 0.0; t1 = 1.0; t2 = x; if (t2 < t0) {return t0;} if (t2 > t1) {return t1;}
        while (t0 < t1) {x2 = sampleCurveX(t2); if (fabs(x2 - x) < epsilon) {return t2;} if (x > x2) {t0 = t2;}else {t1 = t2;} t2 = (t1 - t0) * 0.5 + t0;}
        return t2; // Failure.
      }
      cx = 3.0 * p1x; bx = 3.0 * (p2x - p1x) - cx; ax = 1.0 - cx - bx; cy = 3.0 * p1y; by = 3.0 * (p2y - p1y) - cy; ay = 1.0 - cy - by;
      return solve(t, solveEpsilon(duration));
    }
70510
function normalizeUnits(units, momentObj) {
    if (isJalali(momentObj)) {
        units = toJalaliUnit(units);
    }
    if (units) {
        var lowered = units.toLowerCase();
        units = unitAliases[lowered] || lowered;
    }
    // TODO : add unit test
    if (units === "jday") units = "day";
    else if (units === "jd") units = "d";
    return units;
}
1050988
@Override
	public boolean isValid(String value, ConstraintValidatorContext constraintContext) {
		
		// Si l'objet est null : false
		if(value == null) return false;
		
		// Si l'objet n'est pas une chaine : false
		if(!(value instanceof String)) return false;
		
		// On caste
		String stringValue = (String) value;
		
		// Si la chaine est vide : false
		if(stringValue == null || stringValue.length() == 0) return false;
		
		// Obtention du tableau de valeurs
		String[] parts = stringValue.split("\\.");
		
		// Si la tableau n'a pas une taille de 4
		if(parts == null || parts.length < 4) return false;
		
		// Pattern Numerique
		Pattern pattern = Pattern.compile("\\d+");
		
		// Parcours du tableau
		for (String part : parts) {

			// Si ce n'est pas un Numerique
			if(!pattern.matcher(part).matches()) return false;
		}
		
		// On retourne true
		return true;
	}
989760
def unitcheck(u, nonperiodic=None):
    """"""

    if nonperiodic is None:
        # No periodic boundary conditions provided.
        return np.all(u > 0.) and np.all(u < 1.)
    else:
        # Alternating periodic and non-periodic boundary conditions.
        return (np.all(u[nonperiodic] > 0.) and
                np.all(u[nonperiodic] < 1.) and
                np.all(u[~nonperiodic] > -0.5) and
                np.all(u[~nonperiodic] < 1.5))
602850
public static void main(String[] args) throws IOException {

		
		// TODO : le pcm mutate est bien différent du pcm de base, mais les changements ne sont pas pris en compte. A travailler !
		
		// inputpath = args[0];
		inputpath = "off_output/pcms/test_paget/input";
		outputpath = "off_output/pcms/test_paget/output";

		try {


			Stream<Path> paths = Files.walk(Paths.get(inputpath));

			paths.forEach(filePath -> {
				
				if (Files.isRegularFile(filePath) && filePath.toString().endsWith(".pcm")) {
					System.out.println("> PCM read from " + filePath);
				     
					//File pcmFile = new File(filePath.toString());

					PCMContainer pcmC = null ;
					//PCMContainer pcmC = JSONtoPCM.JSONFormatToPCM(JSONReader.importJSON(filePath.toString())) ;
					//PCMLoader loader = new KMFJSONLoader();
					//List<PCMContainer> pcmContainers = null;
					try {
						pcmC = JSONtoPCM.JSONFormatToPCM(JSONReader.importJSON(filePath.toString())) ;
					} catch (Exception e) {
						e.printStackTrace();
					}

//					for (PCMContainer pcmContainer : pcmContainers) {
//						// Get the PCM
						
						PCMInfoContainerMuted pcmic = null;
						
						try {
							System.out.println(pcmic.toString());
							pcmic = new PCMInfoContainerMuted(pcmC);
						} catch (Exception e) {
							e.printStackTrace();
						}
						if (pcmic != null) {
							if (pcmic.isSameSizePcm()) {
								System.out.println("> PCM muted is the same");
							} else {
								pcmC.setPcm(pcmic.getMutedPcm().getPcm());
								KMFJSONExporter pcmExporter = new KMFJSONExporter();
								String pcmString = pcmExporter.export(pcmC);
								
								Path p = Paths.get(outputpath + "muted_" ) ;//filePath.getFileName());
								try {
									Files.write(p, pcmString.getBytes());
								} catch (Exception e) {
									e.printStackTrace();
								}
								System.out.println("> PCM exported to " + p);
							}
						}
						else {
							System.out.println("> PCM corrompu");
						}

				}

			});
			// mongoClient.close();
			paths.close();

		} catch (Exception e) {
			// mongoClient.close();
			e.printStackTrace();
		}
	}
200872
@Override
	public T save(T entity, boolean validateIntegrityConstraint, boolean preValidateReferentialConstraint, boolean postValidateReferentialConstraint) {
		
		// Si l'entite est nulle
		if(entity == null) throw new JPersistenceToolsException("NullEntityException.message");
		
		// Generation des valeurs
		generateEntityValues(entity, DAOMode.SAVE, DAOValidatorEvaluationTime.PRE_CONDITION);
		
		// Si on doit valider les contraintes d'integrites
		if(validateIntegrityConstraint) validateEntityIntegrityConstraint(entity, DAOMode.SAVE, DAOValidatorEvaluationTime.PRE_CONDITION);
		
		// Si on doit pre-valider les contraintes referentielles
		if(preValidateReferentialConstraint) validateEntityReferentialConstraint(entity, DAOMode.SAVE, DAOValidatorEvaluationTime.PRE_CONDITION);
		
		try {
			
			// Enregistrement
			getEntityManager().persist(entity);
			
		} catch (Exception e) {
			
			// On relance
			throw new JPersistenceToolsException("jpagenericdaorulesbased.save.error", e);
		}
		
		// Validation de l'entite
		if(postValidateReferentialConstraint) validateEntityReferentialConstraint(entity, DAOMode.SAVE, DAOValidatorEvaluationTime.POST_CONDITION);
		
		// On retourne l'entite enregistree
		return entity;
	}