Login   Register  
PHP Classes
elePHPant
Icontem

File: QAPI.class.php

Recommend this page to a friend!
Stumble It! Stumble It! Bookmark in del.icio.us Bookmark in del.icio.us
  Classes of Ingvar Stepanyan  >  QuickAPI  >  QAPI.class.php  >  Download  
File: QAPI.class.php
Role: Class source
Content type: text/plain
Description: Main class
Class: QuickAPI
Implement an API with other classes or functions
Author: By
Last change: New method getParams() for getting parameters
Date: 3 years ago
Size: 6,948 bytes
 

Contents

Class file image Download
<?php
/**
 * @package QuickAPI
 * @version 1.0
 * @author RReverser
 */

/** Interface to mark class for auto-registering of methods */
interface QAPI_Interface {}

/** Main class for API methods manipulation */
class QAPI implements Serializable
{
    
/** Registered methods */
    
private $methods = array();
    
    
/**
     * Register callable as API handler
     * @param string|array $funcName Callable API handler
     * @param string $name Name for API method
     * @return bool
     */
    
function registerFunction($funcName$name null)
    {
        if(
is_callable($funcName))
        {
            if(
$name === null)
            {
                
$name is_array($funcName) ? $funcName[1] : $funcName;
            }
            
$name strtolower($name);
            
$this->methods[$name] = $funcName;
            return 
true;
        } else
        {
            return 
false;
        }
    }
    
    
/**
     * Register object method
     * @param object $object Object with method to be registered as API handler
     * @param string $methodName Name of method to be registered
     * @param string $name Name for API method
     * @return bool
     */
    
function registerMethod($object$methodName$name null)
    {
        if(
substr($methodName02) == '__')
        {
            return 
false;
        }
        if(
$name === null)
        {
            
$name $methodName;
        }
        return 
$this->registerFunction(array($object$methodName), $name);
    }
    
    
/**
     * Register class static method
     * @param string $className Class with static method to be registered as API handler
     * @param string $methodName Name of method to be registered
     * @param string $name Name for API method
     * @return bool
     */
    
function registerStatic($className$methodName$name null)
    {
        if(
substr($methodName02) == '__')
        {
            return 
false;
        }
        if(
$name === null)
        {
            
$name $methodName;
        }
        return 
$this->registerFunction($className '::' $methodName$name);
    }
    
    
/**
     * Register object
     * @param object $object Object with methods to be registered as API handlers
     * @param string $prefix Prefix for object and class methods (use '$' to insert class name)
     * @return bool
     */
    
function registerObject($object$prefix '')
    {
        if(!
is_object($object)) return false;
        
$className get_class($object);
        
$prefix str_replace('$'$className$prefix);
        
$methods get_class_methods($className);
        
$result 1;
        foreach(
$methods as $methodName)
        {
            
$result &= $this->registerMethod($object$methodName$prefix $methodName);
        }
        return (bool)
$result;
    }

    
/**
     * Register class
     * @param string $className Class with static methods to be registered as API handlers
     * @param string $prefix Prefix for object and class methods (use '$' to insert class name)
     * @return bool
     */
    
function registerClass($className$prefix '')
    {
        if(!
class_exists($className)) return false;
        
$prefix str_replace('$'$className$prefix);
        
$methods get_class_methods($className);
        
$result 1;
        foreach(
$methods as $methodName)
        {
            
$result &= $this->registerStatic($className$methodName$prefix $methodName);
        }
        return (bool)
$result;
    }
   
    
/**
     * Register classes that implement QAPI_Interface
     * @param string $prefix Prefix for object and class methods (use '$' to insert class name)
     * @return bool
     */
    
function registerClasses($prefix '')
    {
        
$classes get_declared_classes();
        
$result 1;
        foreach(
$classes as $className)
        {
            if(
in_array('QAPI_Interface'class_implements($className)))
            {
                
$result &= $this->registerClass($className$prefix);
            }
        }
        return (bool)
$result;
    }
    
    
/**
     * Register global objects that implement QAPI_Interface
     * @param string $prefix Prefix for object and class methods (use '$' to insert class name)
     * @return bool
     */
    
function registerObjects($prefix '')
    {
        
$objects $GLOBALS;
        
$result 1;
        foreach(
$objects as $object)
        {
            if(
in_array('QAPI_Interface'class_implements(get_class($object))))
            {
                
$result &= $this->registerObject($object$prefix);
            }
        }
        return (bool)
$result;
    }
    
    
/**
     * Auto-recognize and register API handler(s)
     * @param object|string|array $handler Object, class or callable to be registered
     * @param string $prefix Prefix for object and class methods (use '$' to insert class name)
     * @return bool
     */
    
function register($handler null$prefix '')
    {
        if(
$handler === null)
        {
            return 
$this->registerClasses($prefix);
        }
        if(
is_object($handler))
            return 
$this->registerObject($handler$prefix);
        elseif(
class_exists((string)$handler))
            return 
$this->registerClass($handler$prefix);
        elseif(
is_callable($handler))
            return 
$this->registerFunction($handler);
        else
            return 
false;
    }
    
    
/**
     * Call registered method
     * @param string $name API method name
     * @return string
     */
    
function call($name)
    {
        return 
$this->__call($name$this->getParams());
    }
    
    
/**
     * Magic wrapper for call method
     * @ignore
     */
    
function __call($name$params)
    {
        
$name strtolower($name);
        return isset(
$this->methods[$name]) ? $this->dataToString(call_user_func_array($this->methods[$name], $params)) : null;
    }

    
/**
     * Serialize formed array of registered methods
     * @ignore
     */
    
function serialize()
    {
        return 
serialize($this->methods);
    }
    
    
/**
     * Unserialize methods
     * @ignore
     */
    
function unserialize($methods)
    {
        
$this->methods unserialize($methods);
    }
    
    
/**
     * Wrapper for converting result to string (JSON here, may be overridden in descendant class)
     * @param mixed $result Data to be converted
     * @return string
     */
    
function dataToString($result)
    {
        return 
json_encode($result);
    }

    
/**
     * Wrapper for getting params for method being called (URI 'params' value here, may be overridden in descendant class)
     * @return array
     */
    
function getParams()
    {
        return 
$_GET['params'];
    }
}