trunk/obj/MetadataFactory.class.php

<?php

use \ReflectionObject;
use \DirectoryIterator;

require_once __DIR__.'/Metadata.class.php';

/**
 * Représente une usine (logicielle) à Métadonnées.
 */
class MetadataFactory
{
    const METADATA_BASE_CLASSNAME = 'Metadata';

    protected $minimalSetOfKv = array();

    /**
     * Construit un ensemble de metadonnée à partir d'un type.
     *
     * @param  string  $type  Type de métadonnée à construire
     * @param  array   $key   Clés/valeurs à assigner (doit contenir au moins les métadonnées de la
     *                        classe de base METADATA_BASE_CLASSNAME)
     *
     * @return  string|Metadata  Chaîne si une erreur est rencontrée, Metadata sinon
     */
    public function build(string $type, array $kv) {

        // s'assure que le minimum des métadonnées est renseigné
        foreach(self::getMinimalSetOfKv() as $key) {
            if (! isset($kv[$key]) || empty($kv[$key])) {
                return __("La métadonnée '$key' est obligatoire (de base)");
            }
        }

        // charge la classe de cet ensemble de métadonnées
        $className = '/Metadata'.ucwords($type).'.class.php';
        $classPath = __DIR__."/$className";
        if (! file_exists($classPath)) {
            return __("Le fichier '$classPath' des métadonnées de type '$type' n'existe pas");
        }
        require_once "$classPath";

        // constuit l'objet
        return $this->build($className, $kv);
    }

    /**
     * Obtient l'ensemble minimum de métadonnée à fournir pour construire un ensemble.
     *
     * @return array  La liste des noms des métadonnées à fournir
     */
    protected function getMinimalSetOfKv() {
        if (empty($this->minimalSetOfKv)) {
            $refObj = new ReflectionObject(self::METADATA_BASE_CLASSNAME);
            $props = $refObj->getProperties(ReflectionProperty::IS_PUBLIC | ReflectionProperty::IS_PROTECTED);
            foreach($props as $prop) {
                $this->minimalSetOfKv[] = $prop->getName();
            }
        }
        return $this->minimalSetOfKv;
    }

    /**
     * Construit l'objet de l'ensemble de métadonnées.
     *
     * @param  string  $type  Type de métadonnée à construire
     * @param  array   $key   Clés/valeurs à assigner (doit contenir au moins les métadonnées de la
     *                        classe générique 'Metadata')
     *
     * @return  string|Metadata  Chaîne si une erreur est rencontrée, Metadata sinon
     */
    protected function buildMetadata(string $className, array $kv) {
        $md = new $className();

        $refObj = new ReflectionObject($md);
        $props = $refObj->getProperties(ReflectionProperty::IS_PUBLIC | ReflectionProperty::IS_PROTECTED);
        foreach($props as $prop) {
            $propName = $prop->getName();
            if (isset($kv[$propName]) && ! empty($kv[$propName])) {
                $md->$propName = $kv[$propName];
            }
        }
        return $md;
    }

    /**
     * Liste les différents types de métadonnées existantes
     * (basés sur les nom des fichiers des classes de métadonnées).
     *
     * @return array  La liste des nom des types de métadonnées disponibles
     */
    public function listTypes() {
        $types = array();
        foreach (new DirectoryIterator(__DIR__) as $file) {
            if ($file->isFile()) {
                $fn = $file->getFilename();
                if (strpos($fn, self::METADATA_BASE_CLASSNAME) === 0 && $fn != basename(__FILE__) &&
                        substr($fn, -10, 10) == '.class.php') {
                    $types[] = substr($fn, strlen(self::METADATA_BASE_CLASSNAME), -10);
                }
            }
        }
        return $types;
    }
}
1	mbideau	9946	<?php
2
3			use \ReflectionObject;
4			use \DirectoryIterator;
5
6			require_once __DIR__.'/Metadata.class.php';
7
8			/**
9			* Représente une usine (logicielle) à Métadonnées.
10			*/
11			class MetadataFactory
12			{
13			const METADATA_BASE_CLASSNAME = 'Metadata';
14
15			protected $minimalSetOfKv = array();
16
17			/**
18			* Construit un ensemble de metadonnée à partir d'un type.
19			*
20			* @param string $type Type de métadonnée à construire
21			* @param array $key Clés/valeurs à assigner (doit contenir au moins les métadonnées de la
22			* classe de base METADATA_BASE_CLASSNAME)
23			*
24			* @return string\|Metadata Chaîne si une erreur est rencontrée, Metadata sinon
25			*/
26			public function build(string $type, array $kv) {
27
28			// s'assure que le minimum des métadonnées est renseigné
29			foreach(self::getMinimalSetOfKv() as $key) {
30			if (! isset($kv[$key]) \|\| empty($kv[$key])) {
31			return __("La métadonnée '$key' est obligatoire (de base)");
32			}
33			}
34
35			// charge la classe de cet ensemble de métadonnées
36			$className = '/Metadata'.ucwords($type).'.class.php';
37			$classPath = __DIR__."/$className";
38			if (! file_exists($classPath)) {
39			return __("Le fichier '$classPath' des métadonnées de type '$type' n'existe pas");
40			}
41			require_once "$classPath";
42
43			// constuit l'objet
44			return $this->build($className, $kv);
45			}
46
47			/**
48			* Obtient l'ensemble minimum de métadonnée à fournir pour construire un ensemble.
49			*
50			* @return array La liste des noms des métadonnées à fournir
51			*/
52			protected function getMinimalSetOfKv() {
53			if (empty($this->minimalSetOfKv)) {
54			$refObj = new ReflectionObject(self::METADATA_BASE_CLASSNAME);
55			$props = $refObj->getProperties(ReflectionProperty::IS_PUBLIC \| ReflectionProperty::IS_PROTECTED);
56			foreach($props as $prop) {
57			$this->minimalSetOfKv[] = $prop->getName();
58			}
59			}
60			return $this->minimalSetOfKv;
61			}
62
63			/**
64			* Construit l'objet de l'ensemble de métadonnées.
65			*
66			* @param string $type Type de métadonnée à construire
67			* @param array $key Clés/valeurs à assigner (doit contenir au moins les métadonnées de la
68			* classe générique 'Metadata')
69			*
70			* @return string\|Metadata Chaîne si une erreur est rencontrée, Metadata sinon
71			*/
72			protected function buildMetadata(string $className, array $kv) {
73			$md = new $className();
74
75			$refObj = new ReflectionObject($md);
76			$props = $refObj->getProperties(ReflectionProperty::IS_PUBLIC \| ReflectionProperty::IS_PROTECTED);
77			foreach($props as $prop) {
78			$propName = $prop->getName();
79			if (isset($kv[$propName]) && ! empty($kv[$propName])) {
80			$md->$propName = $kv[$propName];
81			}
82			}
83			return $md;
84			}
85
86			/**
87			* Liste les différents types de métadonnées existantes
88			* (basés sur les nom des fichiers des classes de métadonnées).
89			*
90			* @return array La liste des nom des types de métadonnées disponibles
91			*/
92			public function listTypes() {
93			$types = array();
94			foreach (new DirectoryIterator(__DIR__) as $file) {
95			if ($file->isFile()) {
96			$fn = $file->getFilename();
97			if (strpos($fn, self::METADATA_BASE_CLASSNAME) === 0 && $fn != basename(__FILE__) &&
98			substr($fn, -10, 10) == '.class.php') {
99			$types[] = substr($fn, strlen(self::METADATA_BASE_CLASSNAME), -10);
100			}
101			}
102			}
103			return $types;
104			}
105			}