Filtrer, mettre en cache ou maper, ou trier un iterateur

Description

le titre est incorrect, mais si j'avais voulu mettre dans le titre tout ce que fait cette source, j'aurais probablement fait un titre beaucoup trop long...

cette source contient quelques Exceptions personalisees, quelques interfaces, deux fonctions et une trentaine de classes (peut-etre plus)

des classes pour "agreer" un tableau en iterator.

une Stack

un arbre binaire

une classe (Comparator) pour gerer des criteres de comparaisons d'objets comparables (c'est pas tres clair...)
exemple : vous avez des fichiers, vous voulez les trier, mais pour les trier, vous devez pouvoir comparer deux a deux ces fichiers.
Votre critere de tri n'est pas un simple critere, vous voulez trier par type : dossier, fichier, etc... puis par nom.
C'est la que ma classe intervient : soit vous faites deux tris successifs, ce qui rend votre tri lent... soit vous faites un tri, mais avec des criteres de tris composes. c'est a ca que sert cette classe.

Ensuite, on a la classe qui trie vraiment, elle effectue un tri par insertion dans un arbre de recherche. c'est un tri en n * log(n) sur une liste non triee, mais en n*n sur une liste triee.

j'ai quelques classes qui gerent les fichiers et dossiers unix, (fichier permissions, fichiers, dossiers, dossiers recursifs)

j'ai une classe de filtre : elle prend un iterateur, et ne renvoie que les valeurs de cet iterateur qui satisfont une propriete. (ici aussi, on peut composer ces proprietes, grace a un FiltreParam)

un iterateur qui liste recursivement l'iterateur qu'on lui passe en parametre (pour des dossiers par exemple)

un OrderedIt qui redefinit les clefs de l'iterateur.

un dynamicIt qui memorise dans un cache (array) les valeurs de l'iterateur qu'il liste, ce qui fait que le second acces a l'iterateur se trouve (parfois) etre plus rapide

une classe Seg qui represente un segment de IR (en math) [a, b]

une classe PaginateIt qui decoupe un morceau d'iterateur (par exemple, on peut prendre des valeurs de 5 a 15)

une classe ReverseIterator qui lit un iterateur a l'envers

et une classe MapIterator qui applique une fonction aux elements d'un iterateur

j'ai fait un truc que les haskelliens aiment bien : le mode paresseux. c'est a dire que si vous n'appellez pas current, alors pour certains iterateurs, les calculs ne sont pas faits (map, filter, dynamic, etc...)

Source / Exemple :


try{
  /*$i = new TestIt();
  foreach ($i as $indice => $val){
    echo $indice.' '.$val.'
';
  }*/

  /*
  $d=new DossierRec(new Factory(), './');
  $d=new Filterit($d, new FiltreParam(UnixFile::IsHidden, FiltreParam::Non));
  $d=new Recurit($d);
  $d=new SortItterator($d, new Comparator(UnixFile::Type | UnixFile::Asc, new Comparator(UnixFile::Name)));
  $d=new OrderedIt($d);
  $d=new dynamicIt($d);

  echo '<ul>';
  foreach ($d as $i=>$f)
    echo '<li>'.$i.' ) '.$f.'</li>';
  echo '</ul>';

  • /
$s=new Syracuse(45); $s=new Filterit($s, Integer::IsPaire); $s=new PaginateIt($s, new Seg(3, 13)); $s=new PaginateIt($s, new Seg(1, 10)); $s=new MapIterator($s, 'neg', MapIterator::Appl | MapIterator::Meth); //$s=new ReverseIterator($s); echo '<ul>'; foreach ($s as $k=>$c){ echo '<li>'.$k.' ==> '.$c.'</li>'; } echo '</ul>'. count($s); /* $s=new Stack(); $s->push(1); $s->push(2); $s->push(3); echo '<ul>'; foreach ($s as $k=>$c){ echo '<li>'.$k.' ==> '.$c.'</li>'; } echo '</ul>';
  • /
}catch (MException $e){ echo $e; } ?>

Conclusion :


je trouvais la SPL trop peu souple pour les dossiers, voila un recode qui corrige tout ca.

Codes Sources

A voir également

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.