/** * Returns the scheme info for the given id * * @param string $id * @return SecurityScheme */ public function get($id) { if (!$this->schemes->has($id)) { $this->schemes->set($id, new SecurityScheme($id)); } return $this->schemes->get($id); }
/** * Returns the path info for the given path * * @param string $path * @return Path */ public function get($path) { if (!$this->paths->has($path)) { $this->paths->set($path, new Path($path)); } return $this->paths->get($path); }
/** * Returns the scopes for the given id * * @param string $id * @return Set */ public function get($id) { if (!$this->securities->has($id)) { $this->securities->set($id, new Set()); } return $this->securities->get($id); }
/** * Returns the reponse info for the given code * * @param string $code * @return Response */ public function get($code) { if (!$this->responses->has($code)) { $this->responses->set($code, new Response($code)); } return $this->responses->get($code); }
/** * Returns a set of allowed action ids * * @param User $user * @return Set */ private function getPermissionTable(User $user) { $userId = $user->getId(); if ($this->permissionTable->has($userId)) { return $this->permissionTable->get($userId); } // always allow what guests can do $guestGroup = GroupQuery::create()->findOneByIsGuest(true); // collect groups from user $groups = GroupQuery::create()->filterByUser($user)->find(); $userGroup = GroupQuery::create()->filterByOwnerId($userId)->findOne(); if ($userGroup) { $groups[] = $userGroup; } $groups[] = $guestGroup; // ... structure them $permissionTable = new Set(); foreach ($groups as $group) { foreach ($group->getActions() as $action) { $permissionTable->add($action->getId()); } } $this->permissionTable->set($userId, $permissionTable); return $this->permissionTable->get($userId); }
/** * @param Skill $skill * @return Skill[] */ private function getDescendents(Skill $skill) { if (!$this->descendents->has($skill->getId())) { $this->descendents->set($skill->getId(), $skill->getDescendents()); } return $this->descendents->get($skill->getId()); }
/** * * @param string $packageName * @return CompletePackage */ public function getComposerPackage($packageName) { if ($this->composerCache->has($packageName)) { return $this->composerCache->get($packageName); } $package = $this->loader->load($this->getJson($this->getFile($packageName))); $this->composerCache->set($packageName, $package); return $package; }
/** * Returns the extension for the given key by a given packageName * * @param string $key * @param string $packageName * @return ArrayList */ public function getExtensionsByPackage($key, $packageName) { if ($this->packages->has($packageName)) { $pkg = $this->packages->get($packageName); if ($pkg->has($key)) { return $pkg->get($key); } } return []; }
protected function parse($contents) { $data = new Map($contents); if ($data->has('app')) { $this->app = new AppSchema($this->package, $data->get('app')); } if ($data->has('module')) { $this->module = new ModuleSchema($this->package, $data->get('module')); } }
/** * */ public function import($data, Event $event) { $csv = Reader::createFromString(trim($data)); $csv->setDelimiter(';'); // get startgroups at first $groups = new Map(); foreach ($csv->fetchColumn(0) as $name) { if (!$groups->has($name)) { $startgroup = $this->getStartgroup($name); $startgroup->setEvent($event); $groups->set($name, $startgroup); } } $id = 0; foreach ($csv as $row) { $id++; $routine = $this->getRoutine($id); $group = $groups->get($row[0]); $judges = (count($row) - 1) / 3; for ($j = 1; $j <= $judges; $j++) { $score = new PerformanceScore(); $score->setRoutine($routine); $score->setJudge($group->getPerformanceJudge($j)); $score->setExecution($row[($j - 1) * 3 + 1]); $score->setChoreography($row[($j - 1) * 3 + 2]); $score->setMusicAndTiming($row[($j - 1) * 3 + 3]); $score->setTotal($row[($j - 1) * 3 + 1] + $row[($j - 1) * 3 + 2] + $row[($j - 1) * 3 + 3]); $routine->addPerformanceScore($score); } $group->addRoutine($routine); $group->save(); } $event->save(); }
/** * Loads a module and returns the associated class or returns if already loaded * * @param String $packageName * @throws ModuleException * @return AbstractModule */ public function load($packageName) { if ($this->loadedModules->has($packageName)) { return $this->loadedModules->get($packageName); } // check existence if (!$this->installedModules->has($packageName)) { throw new ModuleException(sprintf('Module (%s) does not exist.', $packageName), 500); } // check activation if (!$this->activatedModules->has($packageName)) { throw new ModuleException(sprintf('Module (%s) not activated', $packageName), 501); } $model = $this->activatedModules->get($packageName); if ($model->getInstalledVersion() > $model->getActivatedVersion()) { throw new ModuleException(sprintf('Module Version Mismatch (%s). Module needs to be updated by the Administrator', $packageName), 500); } // load $className = $model->getClassName(); /* @var $module AbstractModule */ $module = new $className($model, $this->service); $this->loadedModules->set($packageName, $module); // load locale $localeService = $this->getServiceContainer()->getLocaleService(); $file = sprintf('/%s/locales/{locale}/translations.json', $packageName); $localeService->loadLocaleFile($file, $module->getCanonicalName()); return $module; }
/** * Returns additional includes for a given model * * @param string $modelName * @return ArrayList */ public function getIncludes($modelName) { if ($this->models->has($modelName) && $this->models->get($modelName)->has('includes')) { return $this->models->get($modelName)->get('includes'); } return new ArrayList(); }
public function testArrayAccess() { $map = new Map(); $map['a'] = 'b'; $this->assertEquals(1, $map->size()); $this->assertTrue($map->has('a')); $this->assertFalse($map->has('c')); $this->assertTrue($map->contains('b')); $this->assertFalse($map->contains('c')); $this->assertEquals($map['a'], $map->get('a')); $this->assertTrue(isset($map['a'])); $this->assertFalse(isset($map['c'])); $map['a'] = 'x'; $this->assertEquals('x', $map['a']); unset($map['a']); $this->assertFalse($map->has('a')); $this->assertEquals(0, $map->size()); }
/** * Returns a constant. * * @param string|PhpConstant $nameOrConstant * @throws \InvalidArgumentException If the constant cannot be found * @return PhpConstant */ public function getConstant($nameOrConstant) { if ($nameOrConstant instanceof PhpConstant) { $nameOrConstant = $nameOrConstant->getName(); } if (!$this->constants->has($nameOrConstant)) { throw new \InvalidArgumentException(sprintf('The constant "%s" does not exist.', $nameOrConstant)); } return $this->constants->get($nameOrConstant); }
/** * Returns a method * * @param string $nameOrMethod the methods name * @throws \InvalidArgumentException if the method cannot be found * @return PhpMethod */ public function getMethod($nameOrMethod) { if ($nameOrMethod instanceof PhpMethod) { $nameOrMethod = $nameOrMethod->getName(); } if (!$this->methods->has($nameOrMethod)) { throw new \InvalidArgumentException(sprintf('The method "%s" does not exist.', $nameOrMethod)); } return $this->methods->get($nameOrMethod); }
/** * Returns a property * * @param string $nameOrProperty property name * @throws \InvalidArgumentException If the property cannot be found * @return PhpProperty */ public function getProperty($nameOrProperty) { if ($nameOrProperty instanceof PhpProperty) { $nameOrProperty = $nameOrProperty->getName(); } if (!$this->properties->has($nameOrProperty)) { throw new \InvalidArgumentException(sprintf('The property "%s" does not exist.', $nameOrProperty)); } return $this->properties->get($nameOrProperty); }
private function parseType(Map $data) { $this->type = $data->get('type'); $this->format = $data->get('format'); $this->collectionFormat = $data->get('collectionFormat'); $this->default = $data->get('default'); $this->maximum = $data->get('maximum'); $this->exclusiveMaximum = $data->has('exclusiveMaximum') && $data->get('exclusiveMaximum'); $this->minimum = $data->get('minimum'); $this->exclusiveMinimum = $data->has('exclusiveMinimum') && $data->get('exclusiveMinimum'); $this->maxLength = $data->get('maxLength'); $this->minLength = $data->get('minLength'); $this->pattern = $data->get('pattern'); $this->maxItems = $data->get('maxItems'); $this->minItems = $data->get('minItems'); $this->uniqueItems = $data->has('uniqueItems') && $data->get('uniqueItems'); $this->enum = $data->get('enum'); $this->multipleOf = $data->get('multipleOf'); }
private function parse($contents) { $data = new Map($contents); $this->setFullName($data->get('name')); $this->description = $data->get('description'); $this->type = $data->get('type'); $this->license = $data->get('license'); $this->keywords = new ArrayList($data->get('keywords', [])); $this->authors = new ArrayList(); if ($data->has('authors')) { foreach ($data->get('authors') as $authorData) { $this->authors->add(new AuthorSchema($authorData)); } } $this->autoload = new AutoloadSchema($data->get('autoload', [])); $this->require = new Map($data->get('require', [])); $this->requireDev = new Map($data->get('require-dev', [])); $this->extra = CollectionUtils::toMap($data->get('extra', [])); $this->keeko = new KeekoSchema($this, $this->extra->get('keeko', [])); $this->data = $data; }
private function registerListeners() { $reg = $this->service->getExtensionRegistry(); $listeners = $reg->getExtensions(CoreModule::EXT_LISTENER); $map = new Map(); $getClass = function ($className) use($map) { if (class_exists($className)) { if ($map->has($className)) { $class = $map->get($className); } else { $class = new $className(); $map->set($className, $class); } if ($class instanceof KeekoEventListenerInterface) { $class->setServiceContainer($this->service); } return $class; } return null; }; foreach ($listeners as $listener) { // subscriber first if (isset($listener['subscriber'])) { $className = $listener['subscriber']; $subscriber = $getClass($className); if ($subscriber !== null && $subscriber instanceof KeekoEventSubscriberInterface) { $this->dispatcher->addSubscriber($subscriber); } } // class if (isset($listener['class']) && isset($listener['method']) && isset($listener['event'])) { $className = $listener['class']; $class = $getClass($className); if ($class !== null && $class instanceof KeekoEventListenerInterface && method_exists($class, $listener['method'])) { $this->dispatcher->addListener($listener['event'], [$class, $listener['method']]); } } } }
/** * Checks whether a responder with the given type is present * * @param string $type * @return boolean */ public function hasResponder($type) { return $this->responder->has($type); }
public function testTextAsKey() { $map = new Map(); $key = new Text('k'); $map->set($key, 'val'); $this->assertTrue($map->has($key)); $this->assertEquals('val', $map->get($key)); $map->remove($key); $this->assertEquals(0, $map->size()); }
/** * Returns definitions has a schema with the given name * * @param string $name * @return bool */ public function has($name) { return $this->definitions->has($name); }
/** * Checks whether an extension point with the given key exists * * @param string $key * @return boolean */ public function hasExtensionPoint($key) { return $this->extensionPoints->has($key); }
/** * A list of tags sorted by tag-name * * @return ArrayList */ public function getSortedTags() { if ($this->comparator === null) { $this->comparator = new TagNameComparator(); } // 1) group by tag name $group = new Map(); foreach ($this->tags as $tag) { if (!$group->has($tag->getTagName())) { $group->set($tag->getTagName(), new ArrayList()); } $group->get($tag->getTagName())->add($tag); } // 2) Sort the group by tag name $group->sortKeys(new TagNameComparator()); // 3) flatten the group $sorted = new ArrayList(); foreach ($group->values() as $tags) { $sorted->addAll($tags); } return $sorted; }
private function parseItems(Map $data) { if ($data->has('items')) { $this->items = new Items($data->get('items')); } }
private function parseRequired(Map $data) { $this->required = $data->has('required') && $data->get('required'); }
/** * Returns whether a header with the given name exists * * @param string $header * @return bool */ public function has($header) { return $this->headers->has($header); }
private function parseRef(Map $data) { $this->ref = $data->get('$ref'); $this->hasRef = $data->has('$ref'); }