jaxon-php / jaxon-mono

jaxon-core/src/App/Metadata/Data/ExportData.php

Switch Indentation +31 added lines, -31 removed lines

@@ -22,53 +22,53 @@
 
 class ExportData extends AbstractData
 {
-    /**
+/**
      * @var array<string, array<string>>
      */
-    private array $aMethods = [];
+private array $aMethods = [];
 
-    /**
+/**
      * @return string
      */
-    public function getName(): string
-    {
-        return 'export';
-    }
+public function getName(): string
+{
+return 'export';
+}
 
-    /**
+/**
      * @return mixed
      */
-    public function getValue(): mixed
-    {
-        return $this->aMethods;
-    }
+public function getValue(): mixed
+{
+return $this->aMethods;
+}
 
-    /**
+/**
      * @param array $aMethods
      *
      * @return void
      */
-    public function setMethods(array $aMethods): void
+public function setMethods(array $aMethods): void
+{
+foreach(['base', 'only', 'except'] as $sKey)
+{
+foreach($aMethods[$sKey] ?? [] as $sMethod)
+{
+    if(!is_string($sMethod) || !$this->validateMethod($sMethod))
     {
-        foreach(['base', 'only', 'except'] as $sKey)
-        {
-            foreach($aMethods[$sKey] ?? [] as $sMethod)
-            {
-                if(!is_string($sMethod) || !$this->validateMethod($sMethod))
-                {
-                    throw new SetupException("'$sMethod' is not a valid method name.");
-                }
-            }
-        }
-        $this->aMethods = $aMethods;
+        throw new SetupException("'$sMethod' is not a valid method name.");
     }
+}
+}
+$this->aMethods = $aMethods;
+}
 
-    /**
+/**
      * @inheritDoc
      */
-    public function encode(string $sVarName): array
-    {
-        $sMethods = addslashes(json_encode($this->aMethods));
-        return ["{$sVarName}->setMethods(json_decode(\"$sMethods\", true));"];
-    }
+public function encode(string $sVarName): array
+{
+$sMethods = addslashes(json_encode($this->aMethods));
+return ["{$sVarName}->setMethods(json_decode(\"$sMethods\", true));"];
+}
 }

jaxon-core/src/Plugin/Request/CallableClass/ComponentOptions.php

Switch Indentation +169 added lines, -169 removed lines

@@ -34,224 +34,224 @@ 
 
 class ComponentOptions
 {
-    /**
+/**
      * Check if the js code for this object must be generated
      *
      * @var bool
      */
-    private $bExcluded = false;
+private $bExcluded = false;
 
-    /**
+/**
      * The character to use as separator in javascript class names
      *
      * @var string
      */
-    private $sSeparator = '.';
+private $sSeparator = '.';
 
-    /**
+/**
      * A list of methods of the user registered callable object the library can export to javascript
      *
      * @var array
      */
-    private $aPublicMethods = [];
+private $aPublicMethods = [];
 
-    /**
+/**
      * The methods in the export attributes
      *
      * @var array
      */
-    private $aExportMethods = ['except' => []];
+private $aExportMethods = ['except' => []];
 
-    /**
+/**
      * A list of methods to call before processing the request
      *
      * @var array
      */
-    private $aBeforeMethods = [];
+private $aBeforeMethods = [];
 
-    /**
+/**
      * A list of methods to call after processing the request
      *
      * @var array
      */
-    private $aAfterMethods = [];
+private $aAfterMethods = [];
 
-    /**
+/**
      * The javascript class options
      *
      * @var array
      */
-    private $aJsOptions = [];
+private $aJsOptions = [];
 
-    /**
+/**
      * The DI options
      *
      * @var array
      */
-    private $aDiOptions = [];
+private $aDiOptions = [];
 
-    /**
+/**
      * The constructor
      *
      * @param array $aMethods
      * @param array $aOptions
      * @param Metadata|null $xMetadata
      */
-    public function __construct(array $aMethods, array $aOptions, Metadata|null $xMetadata)
-    {
-        $this->bExcluded = ($xMetadata?->isExcluded() ?? false) ||
-            (bool)($aOptions['excluded'] ?? false);
-
-        // Options from the config.
-        $sSeparator = $aOptions['separator'] ?? '.';
-        $this->sSeparator = $sSeparator === '_' ? '_' : '.';
-        $this->addProtectedMethods($aOptions['protected'] ?? []);
-        foreach($aOptions['functions'] ?? [] as $sNames => $aFunctionOptions)
-        {
-            // Names are in a comma-separated list.
-            $aFunctionNames = explode(',', $sNames);
-            foreach($aFunctionNames as $sFunctionName)
-            {
-                $this->addFunctionOptions($sFunctionName, $aFunctionOptions);
-            }
-        }
+public function __construct(array $aMethods, array $aOptions, Metadata|null $xMetadata)
+{
+$this->bExcluded = ($xMetadata?->isExcluded() ?? false) ||
+(bool)($aOptions['excluded'] ?? false);
+
+// Options from the config.
+$sSeparator = $aOptions['separator'] ?? '.';
+$this->sSeparator = $sSeparator === '_' ? '_' : '.';
+$this->addProtectedMethods($aOptions['protected'] ?? []);
+foreach($aOptions['functions'] ?? [] as $sNames => $aFunctionOptions)
+{
+// Names are in a comma-separated list.
+$aFunctionNames = explode(',', $sNames);
+foreach($aFunctionNames as $sFunctionName)
+{
+    $this->addFunctionOptions($sFunctionName, $aFunctionOptions);
+}
+}
 
-        // Options from the attributes or annotations.
-        if($xMetadata !== null)
-        {
-            $this->readMetadataOptions($xMetadata);
-        }
+// Options from the attributes or annotations.
+if($xMetadata !== null)
+{
+$this->readMetadataOptions($xMetadata);
+}
 
-        $this->aPublicMethods = $this->filterPublicMethods($aMethods);
-    }
+$this->aPublicMethods = $this->filterPublicMethods($aMethods);
+}
 
-    /**
+/**
      * @param array|string $xMethods
      *
      * @return void
      */
-    private function addProtectedMethods(array|string $xMethods): void
-    {
-        $this->aExportMethods['except'] = array_merge($this->aExportMethods['except'],
-            !is_array($xMethods) ? [trim((string)$xMethods)] :
-            array_map(fn($sMethod) => trim((string)$sMethod), $xMethods));
-    }
+private function addProtectedMethods(array|string $xMethods): void
+{
+$this->aExportMethods['except'] = array_merge($this->aExportMethods['except'],
+!is_array($xMethods) ? [trim((string)$xMethods)] :
+array_map(fn($sMethod) => trim((string)$sMethod), $xMethods));
+}
 
-    /**
+/**
      * @param Metadata $xMetadata
      *
      * @return void
      */
-    private function readMetadataOptions(Metadata $xMetadata): void
-    {
-        // Excluded methods must be merged with the existing ones.
-        $aExportMethods = $xMetadata->getExportMethods();
-        $aExportMethods['except'] = array_unique(array_merge(
-            $aExportMethods['except'] ?? [], $this->aExportMethods['except']));
-        $this->aExportMethods = $aExportMethods;
-        foreach($xMetadata->getProperties() as $sFunctionName => $aFunctionOptions)
-        {
-            $this->addFunctionOptions($sFunctionName, $aFunctionOptions);
-        }
-    }
+private function readMetadataOptions(Metadata $xMetadata): void
+{
+// Excluded methods must be merged with the existing ones.
+$aExportMethods = $xMetadata->getExportMethods();
+$aExportMethods['except'] = array_unique(array_merge(
+$aExportMethods['except'] ?? [], $this->aExportMethods['except']));
+$this->aExportMethods = $aExportMethods;
+foreach($xMetadata->getProperties() as $sFunctionName => $aFunctionOptions)
+{
+$this->addFunctionOptions($sFunctionName, $aFunctionOptions);
+}
+}
 
-    /**
+/**
      * @param array $aMethods
      *
      * @return array
      */
-    private function filterPublicMethods(array $aMethods): array
-    {
-        if($this->bExcluded || in_array('*', $this->aExportMethods['except']))
-        {
-            return [];
-        }
+private function filterPublicMethods(array $aMethods): array
+{
+if($this->bExcluded || in_array('*', $this->aExportMethods['except']))
+{
+return [];
+}
 
-        $aBaseMethods = $aMethods[1];
-        $aNoMethods = $aMethods[2];
-        $aMethods = $aMethods[0];
-        if(isset($this->aExportMethods['only']))
-        {
-            $aMethods = array_intersect($aMethods, $this->aExportMethods['only']);
-        }
-        $aMethods = array_diff($aMethods, $this->aExportMethods['except']);
-        if(count($aBaseMethods) > 0 && isset($this->aExportMethods['base']))
-        {
-            $aBaseMethods = array_diff($aBaseMethods, $this->aExportMethods['base']);
-        }
+$aBaseMethods = $aMethods[1];
+$aNoMethods = $aMethods[2];
+$aMethods = $aMethods[0];
+if(isset($this->aExportMethods['only']))
+{
+$aMethods = array_intersect($aMethods, $this->aExportMethods['only']);
+}
+$aMethods = array_diff($aMethods, $this->aExportMethods['except']);
+if(count($aBaseMethods) > 0 && isset($this->aExportMethods['base']))
+{
+$aBaseMethods = array_diff($aBaseMethods, $this->aExportMethods['base']);
+}
 
-        return array_values(array_diff($aMethods, $aBaseMethods, $aNoMethods));
-    }
+return array_values(array_diff($aMethods, $aBaseMethods, $aNoMethods));
+}
 
-    /**
+/**
      * @return array
      */
-    public function getPublicMethods(): array
-    {
-        return $this->aPublicMethods;
-    }
+public function getPublicMethods(): array
+{
+return $this->aPublicMethods;
+}
 
-    /**
+/**
      * @param string $sMethodName
      *
      * @return bool
      */
-    public function isPublicMethod(string $sMethodName): bool
-    {
-        return in_array($sMethodName, $this->aPublicMethods);
-    }
+public function isPublicMethod(string $sMethodName): bool
+{
+return in_array($sMethodName, $this->aPublicMethods);
+}
 
-    /**
+/**
      * Check if the js code for this object must be generated
      *
      * @return bool
      */
-    public function excluded(): bool
-    {
-        return $this->bExcluded;
-    }
+public function excluded(): bool
+{
+return $this->bExcluded;
+}
 
-    /**
+/**
      * @return string
      */
-    public function separator(): string
-    {
-        return $this->sSeparator;
-    }
+public function separator(): string
+{
+return $this->sSeparator;
+}
 
-    /**
+/**
      * @return array
      */
-    public function beforeMethods(): array
-    {
-        return $this->aBeforeMethods;
-    }
+public function beforeMethods(): array
+{
+return $this->aBeforeMethods;
+}
 
-    /**
+/**
      * @return array
      */
-    public function afterMethods(): array
-    {
-        return $this->aAfterMethods;
-    }
+public function afterMethods(): array
+{
+return $this->aAfterMethods;
+}
 
-    /**
+/**
      * @return array
      */
-    public function diOptions(): array
-    {
-        return $this->aDiOptions;
-    }
+public function diOptions(): array
+{
+return $this->aDiOptions;
+}
 
-    /**
+/**
      * @return array
      */
-    public function jsOptions(): array
-    {
-        return $this->aJsOptions;
-    }
+public function jsOptions(): array
+{
+return $this->aJsOptions;
+}
 
-    /**
+/**
      * Set hook methods
      *
      * @param array $aHookMethods    The array of hook methods
@@ -259,36 +259,36 @@ 
      *
      * @return void
      */
-    private function setHookMethods(array &$aHookMethods, $xValue): void
-    {
-        foreach($xValue as $sCalledMethod => $xMethodToCall)
-        {
-            if(!isset($aHookMethods[$sCalledMethod]))
-            {
-                $aHookMethods[$sCalledMethod] = [];
-            }
-            if(is_array($xMethodToCall))
-            {
-                $aHookMethods[$sCalledMethod] =
-                    array_merge($aHookMethods[$sCalledMethod], $xMethodToCall);
-                continue;
-            }
-            if(is_string($xMethodToCall))
-            {
-                $aHookMethods[$sCalledMethod][] = $xMethodToCall;
-            }
-        }
-    }
+private function setHookMethods(array &$aHookMethods, $xValue): void
+{
+foreach($xValue as $sCalledMethod => $xMethodToCall)
+{
+if(!isset($aHookMethods[$sCalledMethod]))
+{
+    $aHookMethods[$sCalledMethod] = [];
+}
+if(is_array($xMethodToCall))
+{
+    $aHookMethods[$sCalledMethod] =
+        array_merge($aHookMethods[$sCalledMethod], $xMethodToCall);
+    continue;
+}
+if(is_string($xMethodToCall))
+{
+    $aHookMethods[$sCalledMethod][] = $xMethodToCall;
+}
+}
+}
 
-    /**
+/**
      * @param array $aDiOptions
      */
-    private function addDiOption(array $aDiOptions): void
-    {
-        $this->aDiOptions = array_merge($this->aDiOptions, $aDiOptions);
-    }
+private function addDiOption(array $aDiOptions): void
+{
+$this->aDiOptions = array_merge($this->aDiOptions, $aDiOptions);
+}
 
-    /**
+/**
      * Set configuration options / call options for each method
      *
      * @param string $sName    The name of the configuration option
@@ -296,25 +296,25 @@ 
      *
      * @return void
      */
-    private function addOption(string $sName, $xValue): void
-    {
-        switch($sName)
-        {
-        // Set the methods to call before processing the request
-        case '__before':
-            $this->setHookMethods($this->aBeforeMethods, $xValue);
-            break;
-        // Set the methods to call after processing the request
-        case '__after':
-            $this->setHookMethods($this->aAfterMethods, $xValue);
-            break;
-        // Set the attributes to inject in the callable object
-        case '__di':
-            $this->addDiOption($xValue);
-            break;
-        default:
-            break;
-        }
+private function addOption(string $sName, $xValue): void
+{
+switch($sName)
+{
+// Set the methods to call before processing the request
+case '__before':
+$this->setHookMethods($this->aBeforeMethods, $xValue);
+break;
+// Set the methods to call after processing the request
+case '__after':
+$this->setHookMethods($this->aAfterMethods, $xValue);
+break;
+// Set the attributes to inject in the callable object
+case '__di':
+$this->addDiOption($xValue);
+break;
+default:
+break;
+}
     }
 
     /**

jaxon-annotations/src/AnnotationReader.php

Switch Indentation +152 added lines, -152 removed lines

@@ -37,207 +37,207 @@
 
 class AnnotationReader implements MetadataReaderInterface
 {
-    /**
+/**
      * @var AnnotationManager
      */
-    protected $xManager;
+protected $xManager;
 
-    /**
+/**
      * @var Metadata
      */
-    protected $xMetadata;
+protected $xMetadata;
 
-    /**
+/**
      * Properties types, read from the "var" annotations.
      *
      * @var array
      */
-    protected $aPropTypes;
+protected $aPropTypes;
 
-    /**
+/**
      * The type of the class member being currently processed.
      *
      * @var string
      */
-    protected $sCurrMemberType;
+protected $sCurrMemberType;
 
-    /**
+/**
      * The constructor
      *
      * @param AnnotationManager $xManager
      */
-    public function __construct(AnnotationManager $xManager)
-    {
-        $this->xManager = $xManager;
-        $this->xManager->registry['upload'] = UploadAnnotation::class;
-        $this->xManager->registry['databag'] = DatabagAnnotation::class;
-        $this->xManager->registry['exclude'] = ExcludeAnnotation::class;
-        $this->xManager->registry['export'] = ExportAnnotation::class;
-        $this->xManager->registry['before'] = BeforeAnnotation::class;
-        $this->xManager->registry['after'] = AfterAnnotation::class;
-        $this->xManager->registry['di'] = ContainerAnnotation::class;
-        $this->xManager->registry['callback'] = CallbackAnnotation::class;
-        // Missing standard annotations.
-        // We need to define this, otherwise they throw an exception, and make the whole processing fail.
-        $this->xManager->registry['const'] = false;
-        $this->xManager->registry['inheritDoc'] = false;
-        $this->xManager->registry['template'] = false;
-        $this->xManager->registry['param-closure-this'] = false;
-    }
+public function __construct(AnnotationManager $xManager)
+{
+$this->xManager = $xManager;
+$this->xManager->registry['upload'] = UploadAnnotation::class;
+$this->xManager->registry['databag'] = DatabagAnnotation::class;
+$this->xManager->registry['exclude'] = ExcludeAnnotation::class;
+$this->xManager->registry['export'] = ExportAnnotation::class;
+$this->xManager->registry['before'] = BeforeAnnotation::class;
+$this->xManager->registry['after'] = AfterAnnotation::class;
+$this->xManager->registry['di'] = ContainerAnnotation::class;
+$this->xManager->registry['callback'] = CallbackAnnotation::class;
+// Missing standard annotations.
+// We need to define this, otherwise they throw an exception, and make the whole processing fail.
+$this->xManager->registry['const'] = false;
+$this->xManager->registry['inheritDoc'] = false;
+$this->xManager->registry['template'] = false;
+$this->xManager->registry['param-closure-this'] = false;
+}
 
-    /**
+/**
      * @return array
      */
-    public function getPropTypes(): array
-    {
-        return $this->aPropTypes;
-    }
+public function getPropTypes(): array
+{
+return $this->aPropTypes;
+}
 
-    /**
+/**
      * @return bool
      */
-    public function annotationIsOnProperty(): bool
-    {
-        return $this->sCurrMemberType === AnnotationManager::MEMBER_PROPERTY;
-    }
+public function annotationIsOnProperty(): bool
+{
+return $this->sCurrMemberType === AnnotationManager::MEMBER_PROPERTY;
+}
 
-    /**
+/**
      * @param string $sClass
      *
      * @return void
      * @throws AnnotationException
      */
-    private function readClassAnnotations(string $sClass): void
-    {
-        // Only keep the annotations declared in this package.
-        /** @var array<AbstractAnnotation> */
-        $aAnnotations = array_filter(
-            $this->xManager->getClassAnnotations($sClass),
-            fn($xAnnotation) => is_a($xAnnotation, AbstractAnnotation::class)
-        );
-        // First check if the class is excluded.
-        foreach($aAnnotations as $xAnnotation)
-        {
-            if(is_a($xAnnotation, ExcludeAnnotation::class))
-            {
-                $xAnnotation->saveValue($this->xMetadata);
-            }
-        }
-        if($this->xMetadata->isExcluded())
-        {
-            return;
-        }
-
-        foreach($aAnnotations as $xAnnotation)
-        {
-            if(!is_a($xAnnotation, ExcludeAnnotation::class))
-            {
-                $xAnnotation->saveValue($this->xMetadata);
-            }
-        }
-    }
+private function readClassAnnotations(string $sClass): void
+{
+// Only keep the annotations declared in this package.
+/** @var array<AbstractAnnotation> */
+$aAnnotations = array_filter(
+$this->xManager->getClassAnnotations($sClass),
+fn($xAnnotation) => is_a($xAnnotation, AbstractAnnotation::class)
+);
+// First check if the class is excluded.
+foreach($aAnnotations as $xAnnotation)
+{
+if(is_a($xAnnotation, ExcludeAnnotation::class))
+{
+    $xAnnotation->saveValue($this->xMetadata);
+}
+}
+if($this->xMetadata->isExcluded())
+{
+return;
+}
 
-    /**
+foreach($aAnnotations as $xAnnotation)
+{
+if(!is_a($xAnnotation, ExcludeAnnotation::class))
+{
+    $xAnnotation->saveValue($this->xMetadata);
+}
+}
+}
+
+/**
      * @param string $sClass
      * @param string $sProperty
      *
      * @return void
      * @throws AnnotationException
      */
-    private function readPropertyAnnotations(string $sClass, string $sProperty): void
+private function readPropertyAnnotations(string $sClass, string $sProperty): void
+{
+/** @var array<ContainerAnnotation> */
+// Only keep the annotations declared in this package.
+$aAnnotations = array_filter(
+$this->xManager->getPropertyAnnotations($sClass, $sProperty),
+function($xAnnotation) use($sProperty) {
+    // Save the property type
+    if(is_a($xAnnotation, VarAnnotation::class))
     {
-        /** @var array<ContainerAnnotation> */
-        // Only keep the annotations declared in this package.
-        $aAnnotations = array_filter(
-            $this->xManager->getPropertyAnnotations($sClass, $sProperty),
-            function($xAnnotation) use($sProperty) {
-                // Save the property type
-                if(is_a($xAnnotation, VarAnnotation::class))
-                {
-                    $this->aPropTypes[$sProperty] = $xAnnotation->type;
-                }
-                // Only container annotations are allowed on properties
-                return is_a($xAnnotation, ContainerAnnotation::class);
-            }
-        );
-        if(count($aAnnotations) > 1)
-        {
-            throw new AnnotationException('Only one @di annotation is allowed on a property');
-        }
-
-        foreach($aAnnotations as $xAnnotation)
-        {
-            $xAnnotation->setAttr($sProperty);
-            $xAnnotation->saveValue($this->xMetadata);
-        }
+        $this->aPropTypes[$sProperty] = $xAnnotation->type;
     }
+    // Only container annotations are allowed on properties
+    return is_a($xAnnotation, ContainerAnnotation::class);
+}
+);
+if(count($aAnnotations) > 1)
+{
+throw new AnnotationException('Only one @di annotation is allowed on a property');
+}
+
+foreach($aAnnotations as $xAnnotation)
+{
+$xAnnotation->setAttr($sProperty);
+$xAnnotation->saveValue($this->xMetadata);
+}
+}
 
-    /**
+/**
      * @param string $sClass
      * @param string $sMethod
      *
      * @return void
      * @throws AnnotationException
      */
-    private function readMethodAnnotations(string $sClass, string $sMethod): void
-    {
-        // Only keep the annotations declared in this package.
-        /** @var array<AbstractAnnotation> */
-        $aAnnotations = array_filter(
-            $this->xManager->getMethodAnnotations($sClass, $sMethod),
-            fn($xAnnotation) => is_a($xAnnotation, AbstractAnnotation::class)
-        );
-        foreach($aAnnotations as $xAnnotation)
-        {
-            $xAnnotation->saveValue($this->xMetadata, $sMethod);
-        }
-    }
+private function readMethodAnnotations(string $sClass, string $sMethod): void
+{
+// Only keep the annotations declared in this package.
+/** @var array<AbstractAnnotation> */
+$aAnnotations = array_filter(
+$this->xManager->getMethodAnnotations($sClass, $sMethod),
+fn($xAnnotation) => is_a($xAnnotation, AbstractAnnotation::class)
+);
+foreach($aAnnotations as $xAnnotation)
+{
+$xAnnotation->saveValue($this->xMetadata, $sMethod);
+}
+}
 
-    /**
+/**
      * @throws SetupException
      */
-    public function getAttributes(InputData $xInput): Metadata
-    {
-        ContainerAnnotation::$xReader = $this;
-        $this->aPropTypes = [];
-        $this->xMetadata = new Metadata();
-        $sClass = $xInput->getReflectionClass()->getName();
-
-        try
-        {
-            // Processing class annotations
-            $this->sCurrMemberType = AnnotationManager::MEMBER_CLASS;
-
-            $this->readClassAnnotations($sClass);
-
-            // Processing properties annotations
-            $this->sCurrMemberType = AnnotationManager::MEMBER_PROPERTY;
-
-            // Properties annotations
-            foreach($xInput->getProperties() as $sProperty)
-            {
-                $this->readPropertyAnnotations($sClass, $sProperty);
-            }
-
-            // The methods annotations are not taken for excluded classes.
-            if($this->xMetadata->isExcluded())
-            {
-                return $this->xMetadata;
-            }
-
-            // Processing methods annotations
-            $this->sCurrMemberType = AnnotationManager::MEMBER_METHOD;
-
-            foreach($xInput->getMethods() as $sMethod)
-            {
-                $this->readMethodAnnotations($sClass, $sMethod);
-            }
-
-            return $this->xMetadata;
-        }
-        catch(AnnotationException $e)
-        {
-            throw new SetupException($e->getMessage());
-        }
-    }
+public function getAttributes(InputData $xInput): Metadata
+{
+ContainerAnnotation::$xReader = $this;
+$this->aPropTypes = [];
+$this->xMetadata = new Metadata();
+$sClass = $xInput->getReflectionClass()->getName();
+
+try
+{
+// Processing class annotations
+$this->sCurrMemberType = AnnotationManager::MEMBER_CLASS;
+
+$this->readClassAnnotations($sClass);
+
+// Processing properties annotations
+$this->sCurrMemberType = AnnotationManager::MEMBER_PROPERTY;
+
+// Properties annotations
+foreach($xInput->getProperties() as $sProperty)
+{
+    $this->readPropertyAnnotations($sClass, $sProperty);
+}
+
+// The methods annotations are not taken for excluded classes.
+if($this->xMetadata->isExcluded())
+{
+    return $this->xMetadata;
+}
+
+// Processing methods annotations
+$this->sCurrMemberType = AnnotationManager::MEMBER_METHOD;
+
+foreach($xInput->getMethods() as $sMethod)
+{
+    $this->readMethodAnnotations($sClass, $sMethod);
+}
+
+return $this->xMetadata;
+}
+catch(AnnotationException $e)
+{
+throw new SetupException($e->getMessage());
+}
+}
 }