PHP ReflectionClass::isIterateable方法代码示例

 /**
  * @covers \PHP\Manipulator\TokenContainer\Iterator
  */
 public function testIteratorClass()
 {
     $reflection = new \ReflectionClass('PHP\\Manipulator\\TokenContainer\\Iterator');
     $this->assertTrue($reflection->isIterateable());
     $this->assertTrue($reflection->implementsInterface('SeekableIterator'));
     $this->assertTrue($reflection->implementsInterface('Countable'));
     $this->assertTrue($reflection->hasMethod('previous'));
 }

 /**
  * Will sanitize mixed vars by capping recursion
  * and format them in a designer-friendly way by displaying objects' methods stubs
  * A bit dirty as this should be in another Class, but hey
  *
  * @param $value
  * @param int $maxRecursionDepth  The maximum depth of recursion
  * @param int $recursionDepth     The depth of recursion (used internally)
  * @return array|string
  */
 public function sanitize($value, $maxRecursionDepth = self::MAX_DEPTH, $recursionDepth = 0)
 {
     if (is_resource($value)) {
         return 'Resource';
     }
     if (is_array($value)) {
         return $this->sanitizeIterateable($value, $maxRecursionDepth, $recursionDepth);
     }
     if ($value instanceof InvokerException) {
         return $value->getMessage();
     }
     if (is_object($value)) {
         $class = new \ReflectionClass(get_class($value));
         if ($recursionDepth >= $maxRecursionDepth) {
             // We're full, just scrap the vital data
             $classInfo = $class->getName();
             if ($class->hasMethod('getId')) {
                 $getIdMethod = $class->getMethod('getId');
                 if (!$getIdMethod->getNumberOfRequiredParameters()) {
                     $id = $getIdMethod->invoke($value);
                     $classInfo .= $id !== null ? ' #' . $id : ' (no id)';
                 }
             }
             if ($class->hasMethod('__toString')) {
                 // robustness, we don't care about perf
                 try {
                     $classInfo .= ' ' . (string) $value;
                 } catch (\Exception $e) {
                     $classInfo .= '(string) casting throws Exception, please report or fix';
                 }
             }
             if ($value instanceof \DateTime) {
                 $classInfo .= ' : ' . $value->format('Y-m-d H:i:s');
             }
             return $classInfo;
         } else {
             // Get all accessors and their values
             $data = array();
             $data['class'] = '<span title="' . $class->getName() . '">' . $class->getShortName() . '</span>';
             if ($class->isIterateable()) {
                 $data['iterateable'] = $this->sanitizeIterateable($value, $maxRecursionDepth, $recursionDepth);
             } else {
                 $data['accessors'] = array();
                 foreach ($class->getMethods() as $method) {
                     if ($method->isPublic() && preg_match(self::METHOD_IS_ACCESSOR_REGEX, $method->getName())) {
                         $methodInfo = $method->getName() . '(';
                         foreach ($method->getParameters() as $parameter) {
                             $methodInfo .= '$' . $parameter->getName() . ', ';
                         }
                         $methodInfo = ($method->getNumberOfParameters() ? substr($methodInfo, 0, -2) : $methodInfo) . ')';
                         if (!$method->getNumberOfRequiredParameters()) {
                             // Get the value, we don't need params
                             try {
                                 $methodValue = $method->invoke($value);
                                 $data['accessors'][$methodInfo] = $this->sanitize($methodValue, $maxRecursionDepth, $recursionDepth + 1);
                             } catch (\Exception $e) {
                                 $data['accessors'][$methodInfo] = $this->sanitize(new InvokerException('Couldn\'t invoke method: Exception "' . get_class($e) . '" with message "' . $e->getMessage() . '"'), $maxRecursionDepth, $recursionDepth + 1);
                             }
                         } else {
                             // Get only method name and its params
                             $data['accessors'][] = $methodInfo;
                         }
                     }
                 }
             }
             return $data;
         }
     }
     if (is_string($value)) {
         $value = '(string) ' . $value;
     }
     if (is_int($value)) {
         $value = '(int) ' . $value;
     }
     if (is_float($value)) {
         $value = '(float) ' . $value;
     }
     if (is_null($value)) {
         $value = 'null';
     }
     if (is_bool($value)) {
         if ($value) {
             $value = '(bool) true';
         } else {
             $value = '(bool) false';
         }
     }
     return $value;
 }

 /**
  * @dataProvider dataProvider
  */
 public function testContainerIsIterator($container, $set)
 {
     $reflection = new \ReflectionClass($container);
     $this->assertTrue($reflection->isIterateable());
 }

print "\n";
print "--- isInstance() ---\n";
var_dump($rb->isInstance(new B()));
var_dump($rb->isInstance(new C()));
print "\n";
print "--- isInstantiable() ---\n";
var_dump($rb->isInstantiable());
print "\n";
print "--- isInterface() ---\n";
var_dump($rb->isInterface());
print "\n";
print "--- isInternal() ---\n";
var_dump($rb->isInternal());
print "\n";
print "--- isIterateable() ---\n";
var_dump($rb->isIterateable());
print "\n";
print "--- isSubclassOf() ---\n";
var_dump($rb->isSubclassOf('A'));
var_dump($rb->isSubclassOf('C'));
print "\n";
print "--- isUserDefined() ---\n";
var_dump($rb->isUserDefined());
print "\n";
print "--- newInstance() ---\n";
var_dump($rb->newInstance());
print "\n";
print "--- newInstanceArgs() ---\n";
var_dump($rb->newInstanceArgs());
print "\n";
print "--- get_defined_functions() ---\n";

 /**
  *  handles the m* calls
  *  
  *  if you have a list of values, then you can use this function to run the same function on
  *  all the values (similar to array_map). If your values are objects, then you can do stuff
  *  like: out::m($list_of_obj,'->getOne()->isvalid()'). lets, say you want to get see what
  *  the trim output of your list of strings, then do: out::m($list_of_str,'trim');         
  *      
  *  @todo allow the method names to be an array were the first index is the name and
  *        the second -> N is the arguments to pass into the method (eg, array('method',$arg1,$arg2,...))   
  *      
  *  @param  string  $method the externally called method
  *  @param  array $func_arg_list  the args passed into $method
  *  @return out_call   
  */
 private static function fHandle($method, $func_arg_list = array())
 {
     $call_handler = null;
     $list = $func_arg_list[0];
     $method_list = array_slice($func_arg_list, 1);
     $is_valid_list = false;
     if (!empty($method_list)) {
         $is_valid_list = is_array($list);
         if (empty($is_valid_list) && is_object($list)) {
             // http://www.php.net/manual/en/reflectionclass.isiterateable.php
             $rclass = new ReflectionClass(get_class($val));
             $is_valid_list = $rclass->isIterateable();
         }
         //if
     }
     //if
     if ($is_valid_list) {
         $call_handler = self::getCall($method);
         $format_handler = new out_format($call_handler->config());
         $output = array();
         foreach ($list as $key => $val) {
             foreach ($method_list as $method) {
                 if (is_object($val)) {
                     $output[] = sprintf('%d - %s', $key, $format_handler->wrap('span', get_class($val), out_config::COLOR_INDEX));
                     if ($method[0] == '-') {
                         // the method is something like: ->getThis()->get() so eval it...
                         $arg_handler = new out_arg($method, eval(sprintf('return $val%s;', $method)));
                         $arg_handler->config($call_handler->config());
                         $output[] = $format_handler->indent("\t", $arg_handler->out());
                     } else {
                         if (method_exists($val, $method)) {
                             $arg_handler = new out_arg(sprintf('->%s()', $method), call_user_func(array($val, $method)));
                             $arg_handler->config($call_handler->config());
                             $output[] = $format_handler->indent("\t", $arg_handler->out());
                         } else {
                             $output[] = $format_handler->indent("\t", sprintf('->%s() undefined', $method));
                         }
                         //if/else
                     }
                     //if/else
                 } else {
                     $output[] = sprintf('%d - %s', $key, $format_handler->wrap('span', $val, out_config::COLOR_INDEX));
                     // since $val isn't an object, then use it as the value to pass to a function...
                     $arg_handler = new out_arg(sprintf('%s(%s)', $method, $val), call_user_func($method, $val));
                     $arg_handler->config($call_handler->config());
                     $output[] = $format_handler->indent("\t", $arg_handler->out());
                 }
                 //if/else
             }
             //foreach
         }
         //foreach
         $output[] = '';
         $arg_handler = new out_arg('', join("\r\n", $output));
         $arg_handler->type(out_arg::TYPE_STRING_GENERATED);
         $call_handler->set($arg_handler);
     }
     //if
     return $call_handler;
 }

{
    public function getIterator()
    {
    }
}
class ExtendsIteratorImpl extends IteratorImpl
{
}
class ExtendsIteratorAggregateImpl extends IterarorAggregateImpl
{
}
class A
{
}
$classes = array('Traversable', 'Iterator', 'IteratorAggregate', 'ExtendsIterator', 'ExtendsIteratorAggregate', 'IteratorImpl', 'IterarorAggregateImpl', 'ExtendsIteratorImpl', 'ExtendsIteratorAggregateImpl', 'A');
foreach ($classes as $class) {
    $rc = new ReflectionClass($class);
    echo "Is {$class} iterable? ";
    var_dump($rc->isIterateable());
}
echo "\nTest invalid params:\n";
$rc = new ReflectionClass('IteratorImpl');
var_dump($rc->isIterateable(null));
var_dump($rc->isIterateable(null, null));
var_dump($rc->isIterateable(1));
var_dump($rc->isIterateable(1.5));
var_dump($rc->isIterateable(true));
var_dump($rc->isIterateable('X'));
var_dump($rc->isIterateable(null));
echo "\nTest static invocation:\n";
ReflectionClass::isIterateable();

 /**
  * {@inheritdoc}
  */
 public function isIterateable()
 {
     return $this->reflectionClass->isIterateable();
 }

 /**
  * 构造函数
  *
  * @param mixed $class
  */
 private function __construct($class)
 {
     if (!$class instanceof ReflectionClass) {
         $class = new ReflectionClass($class);
     }
     $this->name = $class->getName();
     $this->filename = $class->getFilename();
     $this->is_interface = $class->isInterface();
     $this->is_abstract = $class->isAbstract();
     $this->is_final = $class->isFinal();
     $this->is_iterateable = $class->isIterateable();
     $this->start_line = $class->getStartLine();
     $this->end_line = $class->getEndLine();
     $this->_reflection_class = $class;
 }

function dump_iterateable($obj)
{
    $reflection = new ReflectionClass($obj);
    var_dump($reflection->isIterateable());
}