/** * */ private static function _initLexer($class) { $reflection = Woops_Core_Reflection_Class::getInstance($class); $constants = $reflection->getConstants(); $staticProps = $reflection->getStaticProperties(); if (!isset($staticProps['_tokens'])) { throw new Woops_Lexical_Analyser_Exception('', Woops_Lexical_Analyser_Exception::EXCEPTION_NO_TOKENS); } self::$_lexers[$class] = true; self::$_tokensByNames[$class] = array(); self::$_tokensByCode[$class] = array(); self::$_tokensByValues[$class] = array(); self::$_tokensByChar[$class] = array(); foreach ($staticProps['_tokens'] as $name => $str) { if (!isset($constants[$name])) { throw new Woops_Lexical_Analyser_Exception('', Woops_Lexical_Analyser_Exception::EXCEPTION_NO_TOKEN_CONSTANT); } $code = $constants[$name]; if (isset(self::$_tokensByCode[$class][$code])) { throw new Woops_Lexical_Analyser_Exception('', Woops_Lexical_Analyser_Exception::EXCEPTION_DUPLICATE_TOKEN_CODE); } self::$_tokensByNames[$class][$name] = $code; self::$_tokensByCode[$class][$code] = $name; self::$_tokensByValues[$class][$str] = $code; $strLen = strlen($str); $storage =& self::$_tokensByChar[$class]; for ($i = 0; $i < $strLen; $i++) { if (!isset($storage[$str[$i]])) { $storage[$str[$i]] = array(); } $storage =& $storage[$str[$i]]; } } }
/** * Class constructor * * @param string The name of the class for which to build an AOP version * @return void */ public function __construct($className) { // Checks if the static variables are set if (!self::$_hasStatic) { // Sets the static variables self::_setStaticVars(); } // Checks if the class exists if (!class_exists($className)) { // Error - No such class throw new Woops_Core_Aop_Class_Builder_Exception('The class ' . $className . ' does not exist', Woops_Core_Aop_Class_Builder_Exception::EXCEPTION_NO_CLASS); } // Gets a reflection class object $reflection = Woops_Core_Reflection_Class::getInstance($className); // Gets the path to the PHP file $filePath = $reflection->getFileName(); // Gets the PHP code $this->_classCode = file_get_contents($filePath); // Checks if the class is a subclass of the AOP advisor class if ($reflection->isAopReady()) { // Adds the AOP method suffix to all the public methods $this->_classAopCode = preg_replace(self::PUBLIC_METHODS_REGEXP, '\\1\\2' . Woops_Core_Aop_Advisor::JOINPOINT_METHOD_SUFFIX, $this->_classCode); } else { // Nothing to do, the class does not have AOP features $this->_classAopCode = $this->_classCode; } }
$CLASSNAME = $GETVARS['className']; // Path to the cache directory $CACHEDIR = Woops_Core_Env_Getter::getInstance()->getPath('cache/classes/'); // Checks if the class caching is enabled (or the AOP), and checks the cache directory if (Woops_Core_Config_Getter::getInstance()->getVar('classCache', 'enable') || Woops_Core_Config_Getter::getInstance()->getVar('aop', 'enable') && $CACHEDIR && is_dir($CACHEDIR) && is_writeable($CACHEDIR) && !file_exists($CACHEDIR . $CLASSNAME)) { // We don't want any error here try { // Checks if AOP is enabled, and if the class is not an interface if (Woops_Core_Config_Getter::getInstance()->getVar('aop', 'enable') && substr($CLASSNAME, -9) !== 'Interface') { // Creates an AOP version of the class $AOP = new Woops_Core_Aop_Class_Builder($CLASSNAME); // Gets the code of the AOP version $CLASSCODE = (string) $AOP; } else { // Creates a reflection object for the class $REF = Woops_Core_Reflection_Class::getInstance($CLASSNAME); // Gets the PHP source code $CLASSCODE = file_get_contents($REF->getFileName()); } // Checks if the source code must be optimized if (Woops_Core_Config_Getter::getInstance()->getVar('classCache', 'optimize')) { // Creates a source optimizer $OPT = new Woops_Php_Source_Optimizer($CLASSCODE); // Gets the optimized source code $CLASSCODE = (string) $OPT; } // Writes the class in the cache file_put_contents($CACHEDIR . $CLASSNAME . '.class.php', $CLASSCODE); // The cached version of the class was built header('X-WOOPS-CLASS-CACHE-BUILD-STATUS: OK'); // Aborts the script
/** * Adds an AOP advice on a target * * This method registers a callback as an AOP advice, for a target. The * target can be a class name or an instance of class. In the first case, * the advice callback will be executed on all instances of the class. In * the second case, it will only be executed for the given instance. * * Two categories of advice types are available: * * - The first one allows you to execute code when a PHP magic method is * called on the target. The advices types are, in such a case: * * -# Woops_Core_Aop_Advisor::ADVICE_TYPE_CONSTRUCT * Called when the constructor of the target class is called * -# Woops_Core_Aop_Advisor::ADVICE_TYPE_DESTRUCT * Called when the destructor of the target class is called * -# Woops_Core_Aop_Advisor::ADVICE_TYPE_CLONE * Called when an object of the target class is cloned * -# Woops_Core_Aop_Advisor::ADVICE_TYPE_SLEEP * Called when an object of the target class is serialized * -# Woops_Core_Aop_Advisor::ADVICE_TYPE_WAKEUP * Called when an object of the target class is unserialized * -# Woops_Core_Aop_Advisor::ADVICE_TYPE_TO_STRING * Called when an object of the target class is converted to a string * * - The second one allows you to execute specific code on specific join * points, registered in the target class. In that case, you must specify * the name of the join point on which to place the advice as the fourth * parameter. Available advices types in such a case are: * * -# Woops_Core_Aop_Advisor::ADVICE_TYPE_VALID_CALL * Called before the join point is executed, and may prevents the join * point to be executed * -# Woops_Core_Aop_Advisor::ADVICE_TYPE_BEFORE_CALL * Called before the join point is executed * -# Woops_Core_Aop_Advisor::ADVICE_TYPE_BEFORE_RETURN * Called before the return value of the join point is return, and may * change the return value * -# Woops_Core_Aop_Advisor::ADVICE_TYPE_AFTER_CALL * Called after the join point is executed * -# Woops_Core_Aop_Advisor::ADVICE_TYPE_AFTER_THROWING * Called after an exception is thrown from the join point. The * original exception won't be thrown if the callback method * returns true * * @param int The type of the advice (one of the Woops_Core_Aop_Advisor::ADVICE_TYPE_XXX constant) * @param callback The callback to invoke (must be a valid PHP callback) * @param mixed The target on which to place the advice (either a class name or an object) * @param string The join point on which to place the advice * @return boolean * @throws Woops_Core_Aop_Advisor_Exception If the passed callback is not a valid PHP callback * @throws Woops_Core_Aop_Advisor_Exception If the target class does not exist * @throws Woops_Core_Aop_Advisor_Exception If the no join point is specified, when trying to register a user advice type * @throws Woops_Core_Aop_Advisor_Exception If the join point has not been registered in the target * @throws Woops_Core_Aop_Advisor_Exception If the advice type is not allowed for the join point * @throws Woops_Core_Aop_Advisor_Exception If the advice type does not exist */ public static final function addAdvice($type, $callback, $target, $joinPoint = '') { // Checks if the configuration object exists if (!is_object(self::$_conf)) { // Gets the instance of the configuration object self::$_conf = Woops_Core_Config_Getter::getInstance(); // Gets the AOP mode from the configuration to know if it's turned on or not self::$_enableAop = self::$_conf->getVar('aop', 'enable'); } // If we are not using class caching, the AOP features must be turned off if (defined('WOOPS_CLASS_CACHE_MODE_OFF') || !self::$_enableAop) { // Nothing to do, as AOP is disabled return true; } // Checks if the callback must be executed for a specific object or for all instances if (is_object($target)) { // Gets the class name and object hash, so the callback will be added for the specific object only $className = $target->_className; $objectHash = $target->_objectHash; } else { // Callback will be executed for all instances $className = $target; $objectHash = false; // Checks if the class exists if (!class_exists($className)) { // Error - Unexisting class throw new Woops_Core_Aop_Advisor_Exception('Cannot add an advice on unexisting class ' . $className, Woops_Core_Aop_Advisor_Exception::EXCEPTION_NO_CLASS); } } // Checks if the advice type is for a specific join point or not if ($type & self::ADVICE_TYPE_GLOBAL) { // Process the global advice types foreach (self::$_globalAdvices as $adviceType) { // Checks if the requested type matches a global advice type if ($type & $adviceType) { // Checks if the storage array for the advice exists if (!isset(self::$_advices[$adviceType][$className])) { // Creates the storage array for the advice self::$_advices[$adviceType][$className] = array(); } // Adds the advice callback for the join point self::$_advices[$adviceType][$className][] = array(new Woops_Core_Callback($callback), $objectHash); } } // The advice(s) was(were) added return true; } elseif ($type & self::ADVICE_TYPE_USER_DEFINED) { // Checks if a join point is specified if (!$joinPoint) { // Error - A join point must be specified throw new Woops_Core_Aop_Advisor_Exception('A join point must be specified for that type of advice', Woops_Core_Aop_Advisor_Exception::EXCEPTION_NO_JOINPOINT); } // Checks if the join point exists if (!isset(self::$_joinPointsByName[$className][$joinPoint])) { // Creates a reflection object for the class // If no instance exist at the moment the advice is added, the automatic join points won't be declared, so we'll have to check it manually $reflection = Woops_Core_Reflection_Class::getInstance($className); // Name of the method $methodName = $joinPoint . self::JOINPOINT_METHOD_SUFFIX; // Checks if we are processing an automatic join point if (!$reflection->hasMethod($methodName) || !$reflection->getMethod($methodName)->isPublic()) { // Error - No such join point in the target class throw new Woops_Core_Aop_Advisor_Exception('The join point ' . $joinPoint . ' does not exist in class ' . $className, Woops_Core_Aop_Advisor_Exception::EXCEPTION_NO_JOINPOINT); } // Process the user advice types foreach (self::$_userAdvices as $adviceType) { // Checks if the requested type matches a user advice type if ($type & $adviceType) { // Checks if the storage array for the requested join point exists if (!isset(self::$_advices[$adviceType][$className][$joinPoint])) { // Creates the storage array self::$_advices[$adviceType][$className][$joinPoint] = array(); } // Adds the advice self::$_advices[$adviceType][$className][$joinPoint][] = array(new Woops_Core_Callback($callback), $objectHash); } } // The advice(s) was(were) added return true; } // Storage for the allowed advice types $allowedAdviceTypes = 0; // Process the join points for each instance of the target class foreach (self::$_joinPoints[$className] as $joinPoints) { // Adds the allowed types of advices for the joint point $allowedAdviceTypes |= $joinPoints[$joinPoint][1]; } // Process the user advice types foreach (self::$_userAdvices as $adviceType) { // Checks if the requested type matches a user advice type if ($type & $adviceType) { // Checks if the advice type is allowed if ($adviceType & $allowedAdviceTypes) { // Adds the advice callback for the join point self::$_advices[$adviceType][$className][$joinPoint][] = array(new Woops_Core_Callback($callback), $objectHash); return true; } else { // Error - The advice type is not allowed for the join point throw new Woops_Core_Aop_Advisor_Exception('Advice of type ' . $adviceType . ' is not permitted for join point ' . $joinPoint, Woops_Core_Aop_Advisor_Exception::EXCEPTION_ADVICE_TYPE_NOT_PERMITTED); } } } } // Error - Advice type is invalid throw new Woops_Core_Aop_Advisor_Exception('Invalid advice type (' . $type . ')', Woops_Core_Aop_Advisor_Exception::EXCEPTION_INVALID_ADVICE_TYPE); }
/** * Gets an instance of a multi-singleton class * * @param string The name of the class * @param string The name of the instance * @return object The instance of the class */ public function getMultiSingleton($className, $instanceName) { // Creates a reflection object for the requested class $reflection = Woops_Core_Reflection_Class::getInstance($className); // Checks if the class is a multi-singleton if ($reflection->isMultiSingleton()) { // Returns the singleton instance return $reflection->getMethod('getInstance')->invoke(array($instanceName)); } else { // Error, the class is not a multi-singleton throw new Woops_Core_Class_Manager_Exception('The class \'' . $className . '\' is not a multi-singleton', Woops_Core_Class_Manager_Exception::EXCEPTION_NOT_MULTISINGLETON); } }
/** * Creates the cached version of a class * * @param string The name of the class for which to build a cached version * @return void */ function createClassCache($className) { // The environment object static $env; // The configuration object static $conf; // The path to the cache directory for the PHP classes static $cacheDir; // Whether AOP is enabled static $aop; // Whether the PHP code must be optimized static $optimize; // Checks if we already have the environment object if (!is_object($env)) { // Gets the environment object $env = Woops_Core_Env_Getter::getInstance(); // Gets the configuration object $conf = Woops_Core_Config_Getter::getInstance(); // Sets the path to the cache directory $cacheDir = $env->getPath('cache/classes/'); // Gets the AOP state $aop = $conf->getVar('aop', 'enable'); // Gets the optimize state $optimize = $conf->getVar('classCache', 'optimize'); } // Checks if the cached version already exists if (file_exists($cacheDir . $className . '.class.php')) { // Nothing to do, the cached version already exists return; } // Checks if AOP is enabled, and if the class is not an interface if ($aop && substr($className, -9) !== 'Interface') { // Creates an AOP version of the class $aopBuilder = new Woops_Core_Aop_Class_Builder($className); // Gets the code of the AOP version $classCode = (string) $aopBuilder; } else { // Creates a reflection object $reflection = Woops_Core_Reflection_Class::getInstance($className); // Gets the PHP source code $classCode = file_get_contents($reflection->getFileName()); } // Checks if the source code must be optimized if ($optimize) { // Creates a source optimizer $optimizer = new Woops_Php_Source_Optimizer($classCode); // Gets the optimized source code $classCode = (string) $optimizer; } // Writes the class in the cache file_put_contents($cacheDir . $className . '.class.php', $classCode); }
/** * Creates a new IFD in the current TIFF file * * @param string An optionnal PHP classname, for a custom IFD object (the class MUST extends the Woops_Tiff_Ifd class) * @return Woops_Tiff_Ifd The IFD object * @throws Woops_Tiff_File_Exception If the custom class does not extends Woops_Tiff_Ifd */ public function newIfd($customClass = '') { // Checks for a custom class if ($customClass) { // Creates a reflection object for the custom class $ref = Woops_Core_Reflection_Class::getInstance($customClass); // Checks if the custom class implements the Woops_Tiff_Ifd_Interface class if (!$ref->implementsInterface('Woops_Tiff_Ifd_Interface')) { // Error - INvalid IFD class throw new Woops_Tiff_File_Exception('Invalid IFD custom class \'' . $customClass . '\'. It must implement the Woops_Tiff_Ifd_Interface interface', Woops_Tiff_File_Exception::EXCEPTION_INVALID_IFD_CLASS); } // Creates the IFD $ifd = new $customClass($this); } else { // Creates the IFD $ifd = new Woops_Tiff_Ifd($this); } // Stores the IFD $this->_ifds[] = $ifd; // Returns the IFD return $ifd; }
/** * Class constructor * * @param mixed The class that will handle the SOAP requests, either as a string or as an object * @param string The URL of the web service * @return void * @throws Soap_Wsdl_Generator_Exception If the XmlWriter class is not available */ public function __construct($handlerClass, $url) { // Checks if the static variables are set if (!self::$_hasStatic) { // Sets the static variables self::_setStaticVars(); } // Checks for the XmlWriter class if (!class_exists('XMLWriter')) { // Error - XmlWriter is not available throw new Soap_Wsdl_Generator_Exception('The XMLWriter class is not available', Soap_Wsdl_Generator_Exception::EXCEPTION_NO_XML_WRITER); } // Checks if we have an object or a class name if (is_object($handlerClass)) { // Creates the reflection object $this->_reflection = Woop_Core_Reflection_Object::getInstance($handlerClass); // Stores the web service name $this->_name = get_class($handlerClass); } else { // Creates the reflection object $this->_reflection = Woops_Core_Reflection_Class::getInstance($handlerClass); // Stores the web service name $this->_name = $handlerClass; } // Stores the URL of the web service $this->_url = $url; // Stores the web service target namespace $this->_tns = self::$_env->SSL ? 'https://' . self::$_env->HTTP_HOST . '/' . $this->_name : 'http://' . self::$_env->HTTP_HOST . '/' . $this->_name; // Gets and stores the available SOAP procedures $this->_soapProcedures = $this->_getSoapProcedures(); // Creates the XML writer object $this->_xml = new XmlWriter(); $this->_xml->openMemory(); $this->_xml->setIndent(4); // Creates the WSDL document $this->_createWsdl(); // Ends the XML documents $this->_xml->endDocument(); // Stores the XML output $this->_wsdl = $this->_xml->flush(); }
/** * */ private final function _getParentClass() { if (!$this->_hasParentClass) { $parentClass = $this->_reflector->getParentClass(); if ($parentClass) { $this->_parentClass = Woops_Core_Reflection_Class::getInstance($parentClass->getName()); } else { $this->_parentClass = $parentClass; } $this->_hasParentClass = true; } return $this->_parentClass; }
/** * */ public static function getExceptionString($class, $code = 0) { if (is_object($class)) { $code = $class->getCode(); $reflector = Woops_Core_Reflection_Object::getInstance($class); } else { $reflector = Woops_Core_Reflection_Class::getInstance($class); } $constants = array_flip($reflector->getConstants()); return isset($constants[$code]) ? $constants[$code] : ''; }