<?php

final class XOOPValidator
{

  private static $_settableTypes = array( 'int',
                                          'bool',
                                          'float',
                                          'string',
                                          'array' );


  public static function validateParameters( $parameters, $expectedTypes, $castTo = false )
  {
    $returningParameters = array();

    // if array has undefined amount of values and is expected to contain only certain type
    if ( is_array( $expectedTypes ) === false ) {
      $expectedTypes = array_fill( 0, count( $parameters ), $expectedTypes );
    }

    // require equal amount of parameters and expected types
    if ( count( $parameters ) === count( $expectedTypes ) ) {

      // loop through parameters and see if they are of expected type
      foreach ( $parameters as $param ) {
        if ( self::_varIsOfType( $param, current( $expectedTypes ) ) === false ) {
          // cast to expected type if requested
          if ( $castTo === true ) {
            self::_castToType( $param, current( $expectedTypes ) );
          }
          else {
            return false;
          }
        } // if (var is not of type)
        $returningParameters[] = $param;
        next( $expectedTypes );
      } // foreach (params)

    } // if (params as many as types)

    else {
      return false;
    }

    return $returningParameters;
  } // method validateParameters


  private static function _varIsOfType( $var, $type )
  {

    /*
     * Test for type case-sensitively.
     */
    if ( $type === 'array' ) {
      return is_array( $var );
    }
    elseif ( $type === 'bool' ) {
      return is_bool( $var );
    }
    elseif ( $type === 'float' ) {
      return is_float( $var );
    }
    elseif ( $type === 'int' ) {
      return is_int( $var );
    }
    elseif ( $type === 'resource' ) {
      return is_resource( $var );
    }
    elseif ( $type === 'string' ) {
      return is_string( $var );
    }
    else {
      return ( $var instanceof $type );
    }

  } // method _varIsOfType


  private static function _castToType( &$var, $type )
  {

    // use setType if possible
    if ( in_array( $type, self::$_settableTypes ) === true ) {
      setType( $var, $type );
    }

    // otherwise assume object casting
    else {
      $var = unserialize( preg_replace( "/^O:[0-9]+:\"[^\"]+\":/i",
                                        "O:" . strlen( $type ) . ":\"" . $type . "\":",
                                        serialize( $var ) ) );
    }

  } // method _castToType

} // class XOOPValidator

?>