1: <?php
  2: 
  3: /**
  4:  * Picon Framework
  5:  * http://code.google.com/p/picon-framework/
  6:  *
  7:  * Copyright (C) 2011-2012 Martin Cassidy <martin.cassidy@webquub.com>
  8: 
  9:  * Picon Framework is free software: you can redistribute it and/or modify
 10:  * it under the terms of the GNU General Public License as published by
 11:  * the Free Software Foundation, either version 3 of the License, or
 12:  * (at your option) any later version.
 13: 
 14:  * Picon Framework is distributed in the hope that it will be useful,
 15:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 16:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 17:  *  General Public License for more details.
 18: 
 19:  * You should have received a copy of the GNU General Public License
 20:  * along with Picon Framework.  If not, see <http://www.gnu.org/licenses/>.
 21:  * */
 22: 
 23: namespace picon;
 24: 
 25: /**
 26:  * Generic helper class for validating method arguments
 27:  *
 28:  * @author Martin Cassidy
 29:  * @package utilities
 30:  */
 31: class Args
 32: {
 33:     /**
 34:      * Throws and excpetion if not a callback
 35:      * @param mixed $object The object to test
 36:      */
 37:     public static function callBack($object, $argName)
 38:     {
 39:         if(!is_callable($object) && !($object instanceof SerializableClosure))
 40:         {
 41:             throw new \InvalidArgumentException(sprintf("%s expected argument %s to be callable", self::getCallingMethod(), $argName));
 42:         }
 43:     }
 44:     
 45:     /**
 46:      * Throws an exception if the callback does not accept the required number of
 47:      * arguments
 48:      * @param Closure $callback The callback to test
 49:      * @param int $amount The number of arguments the callback should have
 50:      */
 51:     public static function callBackArgs($callback, $amount, $argName)
 52:     {
 53:         self::isNumeric($amount, 'amount');
 54:         
 55:         if(!is_callable($callback) && !($callback instanceof SerializableClosure))
 56:         {
 57:             throw new \InvalidArgumentException(sprintf("%s expected argument %s to be callable", self::getCallingMethod(), $argName));
 58:         }
 59:         
 60:         if($callback instanceof SerializableClosure)
 61:         {
 62:             $reflection = $callback->getReflection();
 63:         }
 64:         else
 65:         {
 66:             $reflection = new \ReflectionFunction($callback);
 67:         }
 68:         if(count($reflection->getParameters())!=$amount)
 69:         {
 70:             throw new \InvalidArgumentException(sprintf("%s expected argument %s to be callable and take %d argument(s)", self::getCallingMethod(), $argName, $amount));
 71:         }
 72:     }
 73:     
 74:     /**
 75:      * Throws an exception if not numeric
 76:      * @param type $number 
 77:      */
 78:     public static function isNumeric($number, $argName)
 79:     {
 80:         if(!is_numeric($number))
 81:         {
 82:             throw new \InvalidArgumentException(sprintf("%s expected argument %s to be numeric", self::getCallingMethod(), $argName));
 83:         }
 84:     }
 85:     
 86:     /**
 87:      * Throw an exception if the object is not an array
 88:      * @param type $object
 89:      * @param type $argName 
 90:      */
 91:     public static function isArray($object, $argName)
 92:     {
 93:         if(!is_array($object))
 94:         {
 95:             throw new \InvalidArgumentException(sprintf("%s expected argument %s to be an array", self::getCallingMethod(), $argName));
 96:         }
 97:     }
 98:     
 99:     /**
100:      * Throw an exception if the object is not a string
101:      * @param type $object
102:      * @param type $argName 
103:      */
104:     public static function isString($object, $argName)
105:     {
106:         if(!is_string($object))
107:         {
108:             throw new \InvalidArgumentException(sprintf("%s expected argument %s to be a string", self::getCallingMethod(), $argName));
109:         }
110:     }
111:     
112:     /**
113:      * Throw an exception if the object is not a boolean
114:      * @param type $object
115:      * @param type $argName 
116:      */
117:     public static function isBoolean($object, $argName)
118:     {
119:         if(!is_bool($object))
120:         {
121:             throw new \InvalidArgumentException(sprintf("%s expected argument %s to be a boolean", self::getCallingMethod(), $argName));
122:         }
123:     }
124:     
125:     /**
126:      * Helper for finding the calling class so that a better error message can be given
127:      * @return type 
128:      */
129:     private static function getCallingMethod()
130:     {
131:         $trace = debug_backtrace();
132:         return $trace[2]['class'].$trace[2]['type'].$trace[2]['function'].'()';
133:     }
134:     
135:     /**
136:      * Throw an exception if the object is null
137:      * @param type $object
138:      * @param type $argName 
139:      */
140:     public static function notNull($object, $argName)
141:     {
142:         if($object==null)
143:         {
144:             throw new \InvalidArgumentException(sprintf("%s expected argument %s to be non null", self::getCallingMethod(), $argName));
145:         }
146:     }
147:     
148:     /**
149:      * Throw an exception if the object identifier is not a subclass or implementer of expected
150:      * @param Identifier $object
151:      * @param Identifier $expected
152:      * @param type $argName 
153:      */
154:     public static function identifierOf(Identifier $object, Identifier $expected, $argName)
155:     {
156:         if(!$object->of($expected))
157:         {
158:             throw new \InvalidArgumentException(sprintf("%s expected argument %s to be an identifier of %s, actual %s", self::getCallingMethod(), $argName, $expected->getFullyQualifiedName(), $object->getFullyQualifiedName()));
159:         }
160:     }
161: }
162: 
163: ?>
164: