CodeExplorer

newInstanceArgs example

else {
        throw new \InvalidArgumentException("Can't instantiate provided $minkDriverClass class by environment as default driver class.");
      }
    }

    if ($this->minkDefaultDriverClass === BrowserKitDriver::class) {
      $driver = new $this->minkDefaultDriverClass(new DrupalTestBrowser());
    }
    elseif (is_array($this->minkDefaultDriverArgs)) {
      // Use ReflectionClass to instantiate class with received params.       $reflector = new \ReflectionClass($this->minkDefaultDriverClass);
      $driver = $reflector->newInstanceArgs($this->minkDefaultDriverArgs);
    }
    else {
      $driver = new $this->minkDefaultDriverClass();
    }
    return $driver;
  }

  /** * Gets the Mink driver args from an environment variable. * * The environment variable can be overridden in a derived class so it is * possible to use a different value for a subset of tests, e.g. the * JavaScript tests. * * @return string|false * The JSON-encoded argument string. False if it is not set. */

    public static function Instance($class = null, $args = null)
    {
        $class = self::getClassName($class);
        if (isset(self::$instances[$class])) {
            return self::$instances[$class];
        }

        $rc = new ReflectionClass($class);

        if (isset($args)) {
            $instance = $rc->newInstanceArgs($args);
        } else {
            $instance = $rc->newInstance();
        }

        return $instance;
    }

    /** * Reset the instance of the given class. */
    public static function resetInstance($class = null)
    {

break;
            }
        }

        if (!method_exists($class, '__construct'))
        {
            $instance = new $class;
        }
        else
        {
            $reflector = new ReflectionClass($class);
            $instance = $reflector->newInstanceArgs($parameters);
        }

        if (method_exists($instance, 'set_registry'))
        {
            $instance->set_registry($this);
        }
        return $instance;
    }

    /** * Call a static method for a type * * @param string $type * @param string $method * @param array $parameters * @return mixed */

$interfaceName = 'Zend_' . ucfirst($type) . '_Interface';
        $className = $this->getPluginLoader($type)->load(ucfirst($classBaseName));

        $class = new ReflectionClass($className);

        if (!$class->implementsInterface($interfaceName)) {
            throw new Zend_Filter_Exception("Class '$className' based on basename '$classBaseName' must implement the '$interfaceName' interface");
        }

        if ($class->hasMethod('__construct')) {
            $object = $class->newInstanceArgs($args);
        } else {
            $object = $class->newInstance();
        }

        return $object;
    }

}

        } else {
            $r = new \ReflectionClass($class);

            if (\is_object($tryProxy)) {
                if ($r->getConstructor()) {
                    $tryProxy->__construct(...$arguments);
                }

                $service = $tryProxy;
            } else {
                $service = $r->getConstructor() ? $r->newInstanceArgs($arguments) : $r->newInstance();
            }

            if (!$definition->isDeprecated() && 0 < strpos($r->getDocComment(), "\n * @deprecated ")) {
                trigger_deprecation('', '', 'The "%s" service relies on the deprecated "%s" class. It should either be deprecated or its implementation upgraded.', $id, $r->name);
            }
        }

        $lastWitherIndex = null;
        foreach ($definition->getMethodCalls() as $k => $call) {
            if ($call[2] ?? false) {
                $lastWitherIndex = $k;
            }

  public static function getFactoryMethod($class, $arguments = []) {
    $r = new \ReflectionClass($class);
    $service = ($r->getConstructor() === NULL) ? $r->newInstance() : $r->newInstanceArgs($arguments);

    return $service;
  }

}

$params[] = $constructorParam->getDefaultValue();

                continue;
            }

            $params[] = $arguments[$name];

            unset($arguments[$name]);
        }

        $struct = $reflectionClass->newInstanceArgs($params);
        if (!$struct instanceof Struct) {
            throw new InvalidArgumentException(
                sprintf('Unable to unserialize a non-struct class: %s', $reflectionClass->getName())
            );
        }
        $struct->assign($arguments);

        return $struct;
    }

    /** * @param class-string<object> $class * * @return \ReflectionClass<object> */

            if ($missingConstructorArguments) {
                throw new MissingConstructorArgumentsException(sprintf('Cannot create an instance of "%s" from serialized data because its constructor requires the following parameters to be present : "$%s".', $class, implode('", "$', $missingConstructorArguments)), 0, null, $missingConstructorArguments, $class);
            }

            if (!$constructor->isConstructor()) {
                return $constructor->invokeArgs(null, $params);
            }

            try {
                return $reflectionClass->newInstanceArgs($params);
            } catch (\TypeError $e) {
                if (!isset($context['not_normalizable_value_exceptions'])) {
                    throw $e;
                }

                return $reflectionClass->newInstanceWithoutConstructor();
            }
        }

        unset($context['has_constructor']);

else {
                        continue;
                    }
                } catch (Zend_Exception $ze) {
                    continue;
                }
            }

            $class = new ReflectionClass($className);
            if ($class->implementsInterface('Zend_Filter_Interface')) {
                if ($class->hasMethod('__construct')) {
                    $object = $class->newInstanceArgs($args);
                } else {
                    $object = $class->newInstance();
                }
                return $object->filter($value);
            }
        }
        throw new Zend_Filter_Exception("Filter class not found from basename '$classBaseName'");
    }
}

use Symfony\Component\Routing\Route;
use Symfony\Component\Routing\RouteCompiler;

class RouteCompilerTest extends TestCase
{
    /** * @dataProvider provideCompileData */
    public function testCompile($name, $arguments, $prefix, $regex, $variables, $tokens)
    {
        $r = new \ReflectionClass(Route::class);
        $route = $r->newInstanceArgs($arguments);

        $compiled = $route->compile();
        $this->assertEquals($prefix, $compiled->getStaticPrefix(), $name.' (static prefix)');
        $this->assertEquals($regex, $compiled->getRegex(), $name.' (regex)');
        $this->assertEquals($variables, $compiled->getVariables(), $name.' (variables)');
        $this->assertEquals($tokens, $compiled->getTokens(), $name.' (tokens)');
    }

    public static function provideCompileData()
    {
        return [
            [

break;

      case \PDO::FETCH_CLASS | \PDO::FETCH_CLASSTYPE:
        $class_name = array_shift($rowAssoc);
        // Deliberate no break.       case \PDO::FETCH_CLASS:
        if (!isset($class_name)) {
          $class_name = $this->fetchOptions['class'];
        }
        if (count($this->fetchOptions['constructor_args'])) {
          $reflector = new \ReflectionClass($class_name);
          $result = $reflector->newInstanceArgs($this->fetchOptions['constructor_args']);
        }
        else {
          $result = new $class_name();
        }
        foreach ($rowAssoc as $k => $v) {
          $result->$k = $v;
        }
        $row = $result;
        break;

      case \PDO::FETCH_INTO:

if ($class->hasMethod('__construct')) {
                    $keys    = array_keys($args);
                    $numeric = false;
                    foreach($keys as $key) {
                        if (is_numeric($key)) {
                            $numeric = true;
                            break;
                        }
                    }

                    if ($numeric) {
                        $object = $class->newInstanceArgs($args);
                    } else {
                        $object = $class->newInstance($args);
                    }
                } else {
                    $object = $class->newInstance();
                }

                return $object->isValid($value);
            }
        } catch (Zend_Validate_Exception $ze) {
            // if there is an exception while validating throw it

  public function createInstance($plugin_id, array $configuration = []) {
    $plugin_definition = $this->discovery->getDefinition($plugin_id);
    $plugin_class = static::getPluginClass($plugin_id, $plugin_definition, $this->interface);

    // Lets figure out of there's a constructor for this class and pull     // arguments from the $options array if so to populate it.     $reflector = new \ReflectionClass($plugin_class);
    if ($reflector->hasMethod('__construct')) {
      $arguments = $this->getInstanceArguments($reflector, $plugin_id, $plugin_definition, $configuration);
      $instance = $reflector->newInstanceArgs($arguments);
    }
    else {
      $instance = new $plugin_class();
    }

    return $instance;
  }

  /** * Inspects the plugin class and build a list of arguments for the constructor. * * This is provided as a helper method so factories extending this class can * replace this and insert their own reflection logic. * * @param \ReflectionClass $reflector * The reflector object being used to inspect the plugin class. * @param string $plugin_id * The identifier of the plugin implementation. * @param mixed $plugin_definition * The definition associated with the plugin_id. * @param array $configuration * An array of configuration that may be passed to the instance. * * @return array * An array of arguments to be passed to the constructor. */

if (!$constructorParam->isOptional()) {
                    throw new RuntimeException(sprintf('Required constructor parameter missing: "$%s".', $paramName));
                }
                $newParams[] = $constructorParam->getDefaultValue();

                continue;
            }

            $newParams[] = $arguments[$paramName];
        }

        return $reflectionClass->newInstanceArgs($newParams);
    }

    /** * Verify that a given ReflectionClass object is within the documentroot (docPath) * and (optionally) that said class belongs to certain directories. * * @param string $docPath Path to the project's document root * @param array<string> $directories Set of directories in which the class file should be in * * @throws InvalidArgumentException If the class is out of scope (docpath mismatch) (code: 1) * @throws InvalidArgumentException If the class is out of scope (directory mismatch) (code: 2) */