Chat LIVE With Programming Experts! There Are 23 Online Right Now...

Programming Help

Web Development



What's Here?

  • Members: 244,258
  • Replies: 693,056
  • Topics: 113,147
  • Snippets: 3,863
  • Tutorials: 935
  • Total Online: 1,284
  • Members: 97
  • Guests: 1,187
 

Code Snippets

  

PHP Source Code
Welcome to Dream.In.Code
Become a PHP Expert!

Join 244,258 PHP Programmers for FREE! Get instant access to thousands of PHP experts, tutorials, code snippets, and more! There are 1,284 people online right now. Registration is fast and FREE... Join Now!





Strict_args (v0.2)

A class to provide rudimentary strongly typed arguments for functions and class methods in the PHP language.

Submitted By: snoj
Actions:
Rating:
Views: 634

Language: PHP
Last Modified: December 31, 1969
Instructions: See test1() and test2() at the end for examples on the basics of how to use. Also, reading the PHPDoc styled comments should be of help. You can find a "live" version here.

Snippet


  1. <?php
  2. /*
  3.     Copyright (C) 2007  Josh Erickson <josh @ josherickson.org>
  5.     This program is free software; you can redistribute it and/or modify
  6.     it under the terms of the GNU General Public License as published by
  7.     the Free Software Foundation; either version 2 of the License, or
  8.     (at your option) any later version.
  10.     This program is distributed in the hope that it will be useful,
  11.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.     GNU General Public License for more details.
  15.     You should have received a copy of the GNU General Public License
  16.     along with this program; if not, write to the Free Software
  17.     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18. */
  19.  
  20. /*
  21. * Version 0.1:
  22. *         First version.
  23. *
  24. * Version 0.2:
  25. *         -Fixed issue with specifying $type as 'any' which would result in a "Unknown Error".
  26. */
  27.  
  28. /**
  29. * A class to provide rudimentary strongly typed arguments for functions and class methods.
  30. */
  31. class strict_args {
  32.         /**
  33.         * This holds the function and arguments for the functions we're working with.
  34.         *
  35.         * @static
  36.         * @name $funcs
  37.         * @access private
  38.         */
  39.         private static $funcs = array();
  40.        
  41.         /**
  42.         * This holds the last error.
  43.         *
  44.         * @static       
  45.         * @name $lastError
  46.         * @access private
  47.         */
  48.         private static $lastError = null;
  49.        
  50.         /**
  51.         * Add an argument you wish to have parsed.
  52.         *
  53.         * Only supplied arguments will be returned after parsing is done. False on error. Check strict_args::lastError() for details.
  54.         *
  55.         * @static
  56.         * @name add
  57.         * $param string $function The name of the function this argument will apply to.
  58.         * $param string|int $argument The argument name that will be used.
  59.         * $param string $type The type of variable it is suppose to be. 'any' is default. See http://us.php.net/manual/en/language.types.php for valid types.
  60.         * $param mixed $default The default value of the argument if none is given. Default value is NULL.
  61.         * $param bool $require Whether or not the argument is require. If false, default value is given. Default value is FALSE.
  62.         * $param bool $strict Whether or not the supplied argument is suppose to be of a specific type or not. Default value is FALSE.
  63.         * @return bool Always returns true.
  64.         * @access public
  65.         */
  66.         public static function add($function,$arg,$type='any',$default=null,$require=false,$strict=false) {
  67.                 //$hash = md5($name,$type,$default,$require,$strict);
  68.                 //self::$funcs[$hash] = array($name,$type,$default,$require,$strict);
  69.                 self::$funcs[$function][$arg] = array($type,$default,$require,$strict);
  70.                 return true;
  71.         }
  72.        
  73.         /**
  74.         * Get the last error, if there be one
  75.         *
  76.         * Returns the last error if there is one or false if there are none.
  77.         *
  78.         * @static
  79.         * @return mixed
  80.         */
  81.         public static function lastError() {
  82.                 if(self::$lastError===null) {
  83.                         return false;
  84.                 } else {
  85.                         return self::$lastError;
  86.                 }
  87.                 return false;
  88.         }
  89.         /**
  90.         * Checks whether or not the functions supplied arguments are valid or not based on provided criteria.
  91.         *
  92.         * <p>Returns an array of values if they all match up to supplied parameters for them. However if
  93.         * $onlyReturnBool is set to TRUE, it will only return a boolean as to whether or the check
  94.         * succeeds.</p>
  95.         * <p>The $arguments parameter must contain keys that align to the argument names provided to
  96.         * strict_args::add().</p>
  97.         *
  98.         * @static
  99.         * @param string $function The name of the function that will be checked.
  100.         * @param array $arguments The arguments that are to be checked.
  101.         * @param bool $onlyReturnBool If set to true, will only return a boolean value to whether or not it succeeds. Default is false;
  102.         * @return mixed
  103.         */
  104.         public static function check($function,$arguments,$onlyReturnBool = false) {
  105.                 if(!isset(self::$funcs[$function])) {
  106.                         self::$lastError = "The function '{$function}' is never supplied to strict_args.";
  107.                         return false;
  108.                 }
  109.                 foreach(self::$funcs[$function] AS $k => $v) {
  110.                         //Do we have corresponding values?
  111.                         //Check if arg exists in provided, if not, is it required?
  112.                         $val = null;
  113.                         if(!isset($arguments[$k]) AND self::$funcs[$function][$k][2]==true) {
  114.                                 self::$lastError = "Argument '{$k}' is required but not given.";
  115.                                 return false;
  116.                         } elseif(!isset($arguments[$k]) AND self::$funcs[$function][$k][2]==false) {
  117.                                 $val = self::$funcs[$function][$k][1];
  118.                         } else {
  119.                                 $val = $arguments[$k];
  120.                         }
  121.                        
  122.                         $strict = self::$funcs[$function][$k][3];
  123.                         if($strict == true AND self::$funcs[$function][$k][0] != 'any') {
  124.                                 switch(self::$funcs[$function][$k][0]) {
  125.                                         case 'array':
  126.                                                 if(!is_array($val)) { self::$lastError = "Argument '{$k}' is required to be an array."; return false;}
  127.                                                 break;
  128.                                         case 'bool':
  129.                                                 if(!is_bool($val)) { self::$lastError = "Argument '{$k}' is required to be a boolean."; return false;}
  130.                                                 break;
  131.                                         case 'float':
  132.                                                 if(!is_float($val)) { self::$lastError = "Argument '{$k}' is required to be a float."; return false;}
  133.                                                 break;
  134.                                         case 'int':
  135.                                                 if(!is_int($val)) { self::$lastError = "Argument '{$k}' is required to be an integer."; return false;}
  136.                                                 break;
  137.                                         case 'null':
  138.                                                 if(!is_null($val)) { self::$lastError = "Argument '{$k}' is required to be null."; return false;}
  139.                                                 break;
  140.                                         case 'numeric':
  141.                                                 if(!is_muneric($val)) { self::$lastError = "Argument '{$k}' is required to be numeric."; return false;}
  142.                                                 break;
  143.                                         case 'object':
  144.                                                 if(!is_object($val)) { self::$lastError = "Argument '{$k}' is required to be an object."; return false;}
  145.                                                 break;
  146.                                         case 'resource':
  147.                                                 if(!is_resource($val)) { self::$lastError = "Argument '{$k}' is required to be a resource."; return false;}
  148.                                                 break;
  149.                                         case 'scalar':
  150.                                                 if(!is_scalar($val)) { self::$lastError = "Argument '{$k}' is required to be scalar."; return false;}
  151.                                                 break;
  152.                                         case 'string':
  153.                                                 if(!is_string($val)) { self::$lastError = "Argument '{$k}' is required to be a string."; return false;}
  154.                                                 break;
  155.                                         default:
  156.                                                 self::$lastError = "Unknown Error";
  157.                                                 return false;
  158.                                 }
  159.                         }
  160.                         $rtn[$k] = $val;
  161.                 }
  162.                 return ($onlyReturnBool==true)?(bool)$rtn:$rtn;
  163.         }
  164. }
  165.  
  166. //Typical function definition.
  167. function test1($a,$b,$c=false) {
  168.         /*
  169.                 $a should be an integer.
  170.                 $b and $c should be a boolean.
  171.         */
  172.         strict_args::add(__FUNCTION__,0,'int');
  173.         strict_args::add(__FUNCTION__,1,'bool',null,true,true);
  174.         strict_args::add(__FUNCTION__,2,'string',null,true,true);
  175.        
  176.         $args = func_get_args();
  177.         $parsed_args = strict_args::check(__FUNCTION__,$args);
  178.        
  179.         if($parsed_args == false) {
  180.                 echo strict_args::lastError();
  181.         } else {
  182.                 echo "Arguments have passed check.";
  183.         }
  184. }
  185.  
  186. //Overloading a function
  187. function test2() {
  188.         $args = func_get_args();
  189.         /*
  190.         Try #1. Same as test1()
  191.                 $a should be an integer.
  192.                 $b and $c should be a boolean.
  193.         */
  194.         strict_args::add(__FUNCTION__,0,'int');
  195.         strict_args::add(__FUNCTION__,1,'bool',null,true,true);
  196.         strict_args::add(__FUNCTION__,2,'string',null,true,true);
  197.        
  198.         if(strict_args::check(__FUNCTION__,$args,true)) {
  199.                 //We could just call test1() right here! :O
  200.                 echo "try #1 passed.";
  201.         } else {
  202.                 echo "try #1 did not passed.";
  203.         }
  204.        
  205.         /*
  206.         Try #2. slightly modified.
  207.                 $a should be an integer.
  208.                 $b should be a boolean.
  209.                 $c should be a string.
  210.         */
  211.         strict_args::add(__FUNCTION__,0,'int');
  212.         strict_args::add(__FUNCTION__,1,'bool',null,true,true);
  213.         strict_args::add(__FUNCTION__,2,'string',null,'lol',true);
  214.        
  215.         if(strict_args::check(__FUNCTION__,$args,true)) {
  216.                 echo "try #2 passed.";
  217.         } else {
  218.                 echo "try #2 did not passed.";
  219.         }
  220.        
  221.         /*
  222.         Try #3. ...And yet a little more slightly modified.
  223.                 $a should be an integer.
  224.                 $b should be a boolean.
  225.                 $c should be a string.
  226.         */
  227.         strict_args::add(__FUNCTION__,0,'int');
  228.         strict_args::add(__FUNCTION__,1,'bool',null,true,true);
  229.         strict_args::add(__FUNCTION__,2,'string','lol',false,false);
  230.        
  231.         if(strict_args::check(__FUNCTION__,$args,true)) {
  232.                 echo "try #3 passed.";
  233.         } else {
  234.                 echo "try #3 did not passed.";
  235.         }
  236.        
  237. }
  238. test1(1,false,true);
  239. test2(1,false);
  240. ?>

Copy & Paste

Comments


There are currently no comments for this snippet. Be the first to comment!

Add comment


You must be registered and logged on to </dream.in.code> to leave comments.





Live PHP Help!

Be Social

Dream.In.Code RSS Feed Dream.In.Code LinkedIn Group Follow Us On Twitter Fan Us On Facebook

PHP Tutorials

Reference Sheets

PHP Snippets

DIC Chatroom

Bye Bye Ads

Monthly Drawing

Thumb Drive

Top Contributors

Top 10 Kudos This Month