/** * Create and return a StorageInterface instance * * @param string $type * @param array|Traversable $options * @return StorageInterface * @throws Exception\InvalidArgumentException for unrecognized $type or individual options */ public static function factory($type, $options = array()) { if (!is_string($type)) { throw new Exception\InvalidArgumentException(sprintf('%s expects the $type argument to be a string class name; received "%s"', __METHOD__, is_object($type) ? get_class($type) : gettype($type))); } if (!class_exists($type)) { $class = __NAMESPACE__ . '\\' . $type; if (!class_exists($class)) { throw new Exception\InvalidArgumentException(sprintf('%s expects the $type argument to be a valid class name; received "%s"', __METHOD__, $type)); } $type = $class; } if ($options instanceof Traversable) { $options = ArrayUtils::iteratorToArray($options); } if (!is_array($options)) { throw new Exception\InvalidArgumentException(sprintf('%s expects the $options argument to be an array or Traversable; received "%s"', __METHOD__, is_object($options) ? get_class($options) : gettype($options))); } switch (true) { case in_array('Zend\\Session\\Storage\\AbstractSessionArrayStorage', class_parents($type)): return static::createSessionArrayStorage($type, $options); break; case $type === 'Zend\\Session\\Storage\\ArrayStorage': case in_array('Zend\\Session\\Storage\\ArrayStorage', class_parents($type)): return static::createArrayStorage($type, $options); break; case in_array('Zend\\Session\\Storage\\StorageInterface', class_implements($type)): return new $type($options); break; default: throw new Exception\InvalidArgumentException(sprintf('Unrecognized type "%s" provided; expects a class implementing %s\\StorageInterface', $type, __NAMESPACE__)); } }
private function validatePackage($packageName) { if (class_exists($packageName) && in_array('Tohmua\\IntegrationGate\\IntegrationGate', class_implements($packageName))) { return true; } return false; }
public function testGenerator() { /** @var OpsWay\Test2\Solid\I $generator */ $generator = OpsWay\Test2\Solid\Factory::create('i'); $generator->generate(); $this->assertFileExists($file = __DIR__ . '/../../test/I/IGeometric.php'); include $file; $this->assertTrue(interface_exists('IGeometric')); $this->assertFileExists($file = __DIR__ . '/../../test/I/IAngular.php'); include $file; $this->assertTrue(interface_exists('IAngular')); $this->assertFileExists($file = __DIR__ . '/../../test/I/ISquarable.php'); include $file; $this->assertTrue(interface_exists('ISquarable')); $this->assertFileExists($file = __DIR__ . '/../../test/I/Square.php'); include $file; $this->assertTrue(class_exists('Square')); $this->assertTrue(in_array('IGeometric', class_implements('Square'))); $this->assertFileExists($file = __DIR__ . '/../../test/I/Circle.php'); include $file; $this->assertTrue(class_exists('Circle')); $this->assertTrue(in_array('IGeometric', class_implements('Circle'))); $this->assertTrue(method_exists('IGeometric', 'square')); $this->assertTrue(method_exists('ISquarable', 'square')); $this->assertTrue(method_exists('IAngular', 'countAngles')); }
/** * Class mutator * * @param string $class Class name * * @return void * @throws \InvalidArgumentException If wrong class is given */ private function _setClass($class) { if (!in_array(IBasket::class, class_implements($class))) { throw new \InvalidArgumentException('Class must implement IBasket'); } $this->_class = $class; }
public function canCreate(ContainerInterface $container, $requestedName) { $isClassExists = class_exists($requestedName); $isDispatchable = in_array(DispatchableInterface::class, class_implements($requestedName)); $isController = preg_match('/^[a-z]+\\\\Controller\\\\.*Controller/i', $requestedName); return $isClassExists && $isDispatchable && $isController; }
public static function is_multiselectable($object) { if (is_object($object)) { if ($object instanceof VP_MultiSelectable) { return true; } } elseif (is_string($object)) { $class = self::field_class_from_type($object); if (function_exists('class_implements')) { if (class_exists($class)) { $interfaces = class_implements($class); if (isset($interfaces['VP_MultiSelectable'])) { return true; } } else { return false; } } else { $dummy = new $class(); if ($dummy instanceof VP_MultiSelectable) { return true; } unset($dummy); } } return false; }
/** * Dumps a set of routes to a PHP class. * * Available options: * * * class: The class name * * base_class: The base class name * * @param array $options An array of options * * @return string A PHP class representing the matcher class */ public function dump(array $options = array()) { $options = array_replace(array('class' => 'ProjectUrlMatcher', 'base_class' => 'Symfony\\Component\\Routing\\Matcher\\UrlMatcher'), $options); // trailing slash support is only enabled if we know how to redirect the user $interfaces = class_implements($options['base_class']); $supportsRedirections = isset($interfaces['Symfony\\Component\\Routing\\Matcher\\RedirectableUrlMatcherInterface']); return <<<EOF <?php use Symfony\\Component\\Routing\\Exception\\MethodNotAllowedException; use Symfony\\Component\\Routing\\Exception\\ResourceNotFoundException; use Symfony\\Component\\Routing\\RequestContext; /** * {$options['class']} * * This class has been auto-generated * by the Symfony Routing Component. */ class {$options['class']} extends {$options['base_class']} { /** * Constructor. */ public function __construct(RequestContext \$context) { \$this->context = \$context; } {$this->generateMatchMethod($supportsRedirections)} } EOF; }
/** * Returns a list of interfaces implemented by instance * @param $instance * @return array */ protected function getDependencyInterfaces($instance) : array { $interfaces = class_implements($instance); array_push($interfaces, get_class($instance)); $interfaces += class_parents($instance); return $interfaces; }
/** * {@inheritdoc} */ public function getType($name) { if (!is_string($name)) { throw new UnexpectedTypeException($name, 'string'); } if (!isset($this->types[$name])) { $type = null; foreach ($this->extensions as $extension) { if ($extension->hasType($name)) { $type = $extension->getType($name); break; } } if (!$type) { // Support fully-qualified class names if (class_exists($name) && in_array('Symfony\\Component\\Form\\FormTypeInterface', class_implements($name))) { $type = new $name(); } else { throw new InvalidArgumentException(sprintf('Could not load type "%s"', $name)); } } $this->resolveAndAddType($type); } if (isset($this->legacyNames[$name])) { @trigger_error('Accessing types by their string name is deprecated since version 2.8 and will be removed in 3.0. Use the fully-qualified type class name instead.', E_USER_DEPRECATED); } return $this->types[$name]; }
/** * Loads the composite driver from constants * @param $level * @return \Stash\Interfaces\DriverInterface */ protected function loadConfig($level) { $drivers = array(); $driver_configs = Config::get("concrete.cache.levels.{$level}.drivers", array()); foreach ($driver_configs as $driver_build) { if (!$driver_build) { continue; } $class = array_get($driver_build, 'class', ''); if ($class && class_exists($class)) { $implements = class_implements($class); // Make sure that the provided class implements the DriverInterface if (isset($implements['Stash\\Interfaces\\DriverInterface'])) { /** @type \Stash\Interfaces\DriverInterface $temp_driver */ $temp_driver = new $class(); if ($options = array_get($driver_build, 'options', null)) { $temp_driver->setOptions($options); } $drivers[] = $temp_driver; } else { throw new \RuntimeException('Cache driver class must implement \\Stash\\Interfaces\\DriverInterface.'); } } } $count = count($drivers); if ($count > 1) { $driver = new Composite(); $driver->setOptions(array('drivers' => $drivers)); } elseif ($count === 1) { $driver = $drivers[0]; } else { $driver = new BlackHole(); } return $driver; }
protected function afterSaving($request) { if (!in_array('LiveCMS\\Models\\Contracts\\UserOnlyInterface', class_implements($this->model))) { if ($request->has('permalink')) { $permalink = $this->model->permalink; if ($permalink == null) { $permalink = new Permalink(); $permalink->postable()->associate($this->model); } $permalink->permalink = $request->get('permalink'); $permalink->save(); } else { if ($this->model->permalink) { $this->model->permalink->delete(); } } } if ($request->hasFile('picture') && $request->file('picture')->isValid()) { $object = $this->model; Upload::setFilenameMaker(function ($file, $object) { $title = $object->title ? $object->title : $object->name; return str_limit(str_slug($title . ' ' . date('YmdHis')), 200) . '.' . $file->getClientOriginalExtension(); }, $object); Upload::model($object); $this->model->save(); } if (empty($this->model->status)) { $status = Model::STATUS_DRAFT; $this->model->update(compact('status')); } return parent::afterSaving($request); }
/** * Get a new function core instance * * @param array $cfg Function core configuration for initialization * @param array $common Common configuration for initialization * @param \Facula\Framework $parent Instance of Facula Framework itself. * * @return mixed Return a instance of function core when success, false otherwise */ public static final function getInstance(array $cfg, array $common, Framework $parent) { $caller = get_called_class(); // If $cfg['Core'] has beed set, means user wants // to use their own core instead of default one if (isset($cfg['Custom'][0])) { $class = $cfg['Custom']; } elseif (isset(static::$default)) { $class = static::$default; } else { new Error('CLASS_NOTFOUND', array($caller), 'ERROR'); return false; } if (!isset(self::$instances[$class])) { if (!class_exists($class)) { new Error('CLASS_NOTLOAD', array($class), 'ERROR'); return false; } $classInterface = class_implements($class); if (!isset($classInterface[static::$interface])) { new Error('CLASS_INTERFACE', array($class, static::$interface), 'ERROR'); return false; } if (!is_subclass_of($class, 'Facula\\Base\\Prototype\\Core')) { new Error('CLASS_BASE', array($class, 'Facula\\Base\\Prototype\\Core'), 'ERROR'); return false; } return self::$instances[$class] = new $class($cfg, $common, $parent); } return self::$instances[$class]; }
/** * Serialize data * * @param mixed $data the data to serialize * * @return string serialized form of $data */ public static function sanitizeForSerialization($data) { if (is_scalar($data) || null === $data) { return $data; } elseif ($data instanceof \DateTime) { return $data->format(\DateTime::ATOM); } elseif (is_array($data)) { foreach ($data as $property => $value) { $data[$property] = self::sanitizeForSerialization($value); } return $data; } elseif (is_object($data)) { if (!isset(class_implements($data)["ArrayAccess"])) { return $data; } $values = array(); foreach (array_keys($data::swaggerTypes()) as $property) { $getter = $data::getters()[$property]; if ($data->{$getter}() !== null) { $values[$data::attributeMap()[$property]] = self::sanitizeForSerialization($data->{$getter}()); } } return (object) $values; } else { return (string) $data; } }
static function class_implements($c, $autoload = true) { if (is_object($c)) { $class = get_class($c); } else { if (!class_exists($c, $autoload) && !interface_exists($c, false) && !trait_exists($c, false)) { user_error(__FUNCTION__ . '(): Class ' . $c . ' does not exist and could not be loaded', E_USER_WARNING); return false; } else { $c = self::ns2us($c); } } /**/ if (function_exists('class_implements')) { $autoload = class_implements($c, false); /**/ } else { if (class_exists('ReflectionClass', false)) { $autoload = array(); $c = new ReflectionClass($c); foreach ($c->getInterfaceNames() as $c) { $autoload[$c] = $c; } /**/ } else { return false; /**/ } } foreach ($autoload as $c) { isset(self::$us2ns[$a = strtolower($c)]) && ($autoload[$c] = self::$us2ns[$a]); } return $autoload; }
/** * @param ApiCallData $data * * @return ApiResponseInterface * * @throws \Exception */ public static function create(ApiCallData $data) { $type = $data->getResponseType(); if (!class_exists($type)) { throw new \Exception("Type Class '" . $type . "', could not be loaded"); } $interfaces = class_implements($type); if ($type == '\\Exception' || $type === '\\Packaged\\Api\\Exceptions\\ApiException' || in_array('\\Packaged\\Api\\Exceptions\\ApiException', $interfaces) || array_key_exists('Exception', class_parents($type))) { $code = $data->getStatusCode(); if (!is_numeric($code)) { $code = 500; } $exception = new $type($data->getStatusMessage(), $code); $rawData = $data->getRawResult(); if (is_object($rawData)) { Objects::hydrate($exception, $rawData); } throw $exception; } else { if (in_array('Packaged\\Api\\Interfaces\\ApiResponseInterface', $interfaces)) { $class = new $type(); /** * @var $class \Packaged\Api\Interfaces\ApiResponseInterface */ $class->setApiCallData($data); return $class; } else { throw new ApiException("An invalid message type was used '" . $type . "'"); } } }
public function findRepositoryName($className) { //Check repository name using convention of "Repository" suffix //in the same namespace. //C.o.C is awesome, you should use it !! $repoName = "{$className}Repository"; if (class_exists($repoName) && in_array("Spot\\Domain\\Repository", class_implements($repoName)) && $repoName::repositoryOf() == $className) { return $repoName; } $repos = $this->reflection->find(substr($className, 0, strpos($className, "\\")), Match::instantiableOnly()->andIt(Match::subTypeOf("Spot\\Domain\\Repository"))); foreach ($repos as $repo) { $repoName = $repo->name; if ($repoName::repositoryOf() == $className) { return $repoName; } } // search class inheritance hierarchies $candidates = []; $classParents = array_values(class_parents($className) ?: []); foreach ($repos as $repo) { $repoName = $repo->name; $index = array_search($repoName::repositoryOf(), $classParents); if ($index !== false) { $candidates[$index] = $repoName; } } if (!empty($candidates)) { // check closest candidates return $candidates[min(array_keys($candidates))]; } throw new \RuntimeException("Repository of {$className} can't be found"); }
/** * @param $argument * @return array */ private function getAllInterfaces($argument) { $interfaces = array_filter(class_implements($argument), function ($el) { return 0 !== strpos($el, 'Prophecy\\'); }); return $interfaces; }
private static function _dumpWithReflection($var, $maxDepth) { $return = null; $isObj = is_object($var); if ($isObj && in_array('Doctrine\\Common\\Collections\\Collection', class_implements($var))) { $var = $var->toArray(); } if ($maxDepth) { if (is_array($var)) { $return = array(); foreach ($var as $k => $v) { $return[$k] = self::_dumpWithReflection($v, $maxDepth - 1); } } else { if ($isObj) { $reflClass = new \ReflectionClass(get_class($var)); $return = new \stdclass(); $return->{'__CLASS__'} = get_class($var); foreach ($reflClass->getProperties() as $reflProperty) { $reflProperty->setAccessible(true); $name = $reflProperty->getName(); $value = $reflProperty->getValue($var); $return->{$name} = self::_dumpWithReflection($value, $maxDepth - 1); } } else { $return = $var; } } } else { $return = is_object($var) ? get_class($var) : (is_array($var) ? 'Array(' . count($var) . ')' : $var); } return $return; }
/** * @return array */ public function getTypesWithin() { if ($this->typesWithing !== NULL) { return $this->typesWithing; } return $this->typesWithing = class_parents($class = $this->originalType->getName()) + class_implements($class) + [$class => $class]; }
/** * Kaltura client constructor * * @param KalturaConfiguration $config */ public function __construct(KalturaConfiguration $config) { $this->config = $config; $logger = $this->config->getLogger(); if ($logger) { $this->shouldLog = true; } // load all plugins $pluginsFolder = realpath(dirname(__FILE__)) . '/KalturaPlugins'; if (is_dir($pluginsFolder)) { $dir = dir($pluginsFolder); while (false !== ($fileName = $dir->read())) { $matches = null; if (preg_match('/^([^.]+).php$/', $fileName, $matches)) { require_once "{$pluginsFolder}/{$fileName}"; $pluginClass = $matches[1]; if (!class_exists($pluginClass) || !in_array('IKalturaClientPlugin', class_implements($pluginClass))) { continue; } $plugin = call_user_func(array($pluginClass, 'get'), $this); if (!$plugin instanceof IKalturaClientPlugin) { continue; } $pluginName = $plugin->getName(); $services = $plugin->getServices(); foreach ($services as $serviceName => $service) { $service->setClient($this); $this->pluginServices[$serviceName] = $service; } } } } }
/** * Creates a new button of the given type * * @param string $button ButtonClass to invoke. Must implement ButtonInterface * * @throws \InvalidArgumentException In case a ButtonClass does not implement * ButtonInterface * * @return ButtonInterface */ public function makeButton($button) { if (!in_array(ButtonInterface::class, class_implements($button), true)) { throw new \InvalidArgumentException('A Button must implement ButtonInterface', 1441706378); } return GeneralUtility::makeInstance($button); }
private function callStaticInfoMethod($classnames, $methodName) { $knownItems = []; foreach ($classnames as $classname) { $implementedInterfaces = class_implements($classname); if ($implementedInterfaces === false) { throw new JigException("Failed to load plugin class {$classname} to get info from it."); } if (in_array('Jig\\Plugin', $implementedInterfaces) == false) { $message = "Class {$classname} does not implement interface Jig\\Plugin, cannot be used as a plugin."; throw new JigException($message); } $callable = [$classname, $methodName]; $listItems = call_user_func($callable); if (is_array($listItems) == false) { $message = sprintf("Method %s for class %s must return an array of the names, and the names must be strings", $methodName, $classname); throw new JigException($message, JigException::FILTER_NO_INFO); } foreach ($listItems as $item) { if (is_string($item) == false) { $message = sprintf("Method %s for class %s must return an array of the names, and the names must be strings", $methodName, $classname); throw new JigException($message, JigException::FILTER_NO_INFO); } } //TODO - should we detect and warn on duplicate filters here? $knownItems = array_merge($knownItems, $listItems); } return $knownItems; }
/** * @param DataObject $record * @throws InvalidArgumentException if record doesn't implement CMSPreviewable */ public function __construct($record) { if (!in_array('CMSPreviewable', class_implements($record))) { throw new InvalidArgumentException(sprintf('SilverStripeNavigator: Record of type %s doesn\'t implement CMSPreviewable', get_class($record))); } $this->record = $record; }
/** * {@inheritdoc} */ public function register(GloubsterServerInterface $server) { foreach ($server['configuration']['listeners'] as $listenerConf) { $class_name = $listenerConf['type']; if (!class_exists($class_name)) { $server['monolog']->addError(sprintf('%s is not a valid classname', $class_name)); continue; } if (!in_array('Gloubster\\Server\\Listener\\JobListenerInterface', class_implements($class_name))) { $server['monolog']->addError(sprintf('%s is not implementing JobListenerInterface', $class_name)); continue; } try { $listener = $class_name::create($server, $listenerConf['options']); } catch (RuntimeException $e) { $server['monolog']->addError(sprintf('Error while creating listener %s : %s', $listenerConf['type'], $e->getMessage())); continue; } $server['monolog']->addInfo(sprintf('Attaching listener %s', get_class($listener))); $listener->attach($server['message-handler']); $this->listeners[] = $listener; } $component = $this; $server['dispatcher']->on('booted', function (GloubsterServerInterface $server) use($component) { foreach ($component->listeners as $listener) { $listener->listen(); } }); $server['dispatcher']->on('stop', function ($server) use($component) { foreach ($component->listeners as $listener) { $listener->shutdown(); } }); }
/** * {@inheritdoc} */ public function guessPatternType($contextClass) { if (!in_array('Behat\\Behat\\Context\\CustomSnippetAcceptingContext', class_implements($contextClass))) { return null; } return $contextClass::getAcceptedSnippetType(); }
/** * Return the title, description, keywords and language metatags. * * @todo Move <title> tag in separate getter for easier customization and more obvious usage * * @param boolean|string $includeTitle Show default <title>-tag, set to false for custom templating * @return string The XHTML metatags */ public function MetaTags($includeTitle = true) { $tags = ""; if ($includeTitle === true || $includeTitle == 'true') { $tags .= "<title>" . Convert::raw2xml($this->Title) . "</title>\n"; } $generator = trim(Config::inst()->get('SiteTree', 'meta_generator')); if (!empty($generator)) { $tags .= "<meta name=\"generator\" content=\"" . Convert::raw2att($generator) . "\" />\n"; } $charset = Config::inst()->get('ContentNegotiator', 'encoding'); $tags .= "<meta http-equiv=\"Content-type\" content=\"text/html; charset={$charset}\" />\n"; if ($this->MetaDescription) { $tags .= "<meta name=\"description\" content=\"" . Convert::raw2att($this->MetaDescription) . "\" />\n"; } if ($this->ExtraMeta) { $tags .= $this->ExtraMeta . "\n"; } if (Permission::check('CMS_ACCESS_CMSMain') && in_array('CMSPreviewable', class_implements($this)) && !$this instanceof ErrorPage) { $tags .= "<meta name=\"x-page-id\" content=\"{$this->ID}\" />\n"; $tags .= "<meta name=\"x-cms-edit-link\" content=\"" . $this->CMSEditLink() . "\" />\n"; } $this->extend('MetaTags', $tags); return $tags; }
/** * Gets the correct class for the given library and module. More documentation to come... */ private static function _construct($entity_or_library, $module, $filename = false, $meta_info = false) { $library = self::_get_library($entity_or_library); if (!$filename) { $filename = 'classes/media/' . $library . '/' . $module . '.php'; } if (reason_file_exists($filename)) { reason_include_once($filename); $classname = self::_convert_to_camel_case($module); if ($meta_info) { $library_classname = ucfirst($library) . $meta_info . $classname; } else { $library_classname = ucfirst($library) . $classname; } if (class_exists($library_classname)) { $interface_file = 'classes/media/interfaces/' . $module . '_interface.php'; if (reason_file_exists($interface_file)) { reason_include_once($interface_file); $class = new $library_classname(); $implemented = class_implements($class); if (isset($implemented[$classname . 'Interface'])) { return $class; } else { trigger_error($library_classname . ' must implement ' . $classname . 'Interface.'); } } else { trigger_error($module . ' interface file does not exist: ' . $interface_file); } } else { trigger_error($module . ' class does not exist: ' . $library_classname); } } else { trigger_error($module . ' file does not exist: ' . $filename); } }
/** * Asserts that item type is collection defined type * * @param string $instanceName * @param string|int|null $index * @return void * @throws \InvalidArgumentException */ private function assertValidTypeLazy($instanceName, $index = null) { $realType = $this->configInterface->getInstanceType($this->configInterface->getPreference($instanceName)); if (!in_array($this->type, array_unique(array_merge(class_parents($realType), class_implements($realType))), true)) { $this->throwTypeException($realType, $index); } }
protected function dumpObject($obj, $hash) { if (isset($this->objectsDepth[$hash])) { if ($this->objectsDepth[$hash] < $this->depth) { $this->refPool[$this->counter]['ref_counter'] = $this->counter; $this->dumpRef(true, $this->counter, $obj, 'object'); return; } else { unset($this->objectsDepth[$hash]); } } $a = (array) $obj; $c = get_class($obj); $p = array($c => $c) + class_parents($obj) + class_implements($obj) + array('*' => '*'); foreach (array_reverse($p) as $p) { if (!empty($this->casters[$p = 'o:' . strtolower($p)])) { foreach ($this->casters[$p] as $p) { try { $a = call_user_func($p, $obj, $a); } catch (\Exception $e) { } } } } $this->walkHash($c, $a, count($a)); }
/** * Dynamically loads a plugin by name. * * @param string $className Fully qualified plugin class name * @param array $options Options * * @throws \Exception */ public function load($className, $options) { if (!class_exists($className)) { throw new \Exception('The plugin class "' . $className . '" could not be found.'); } // make sure the class implements the plugin interface if (!in_array(PluginInterface::class, class_implements($className))) { throw new \Exception('The class "' . $className . '" is not a plugin.'); } try { /** @var PluginInterface $instance */ $instance = new $className($this->bot, $this); foreach ($options as $key => $value) { if (property_exists($instance, $key)) { $instance->{$key} = $value; } else { throw new \Exception('Unknown plugin parameter: ' . $key); } } $instance->enable(); $this->plugins[$className] = $instance; $this->bot->getApplication()->getLogger()->info('Plugin initialized: ' . $className); } catch (\Exception $exception) { throw new \Exception('Error in loading plugin "' . $className . '": ' . $exception->getMessage()); } }