/** * @param string $name * * @return Blog|null */ public function find($name) { if ($this->blogs->containsKey($name)) { return $this->blogs[$name]; } return null; }
/** * @param string $class * @return ColumnTypeInterface */ public function getType(string $class) { if ($this->types->containsKey($class)) { return $this->types[$class]; } return null; }
/** * @inheritdoc */ public function remove(User $user) { if (!$this->collection->containsKey((string) $user->getId())) { throw new UserNotFoundException(); } return $this->collection->removeElement($user); }
public function addModel(BaseModel $model) { if (!$this->models->containsKey($model->name)) { $model->bundle = $this; $this->models->set($model->name, $model); } return $this; }
public function addBundle(BaseBundle $bundle) { if (!$this->bundles->containsKey($bundle->name)) { $bundle->map = $this; $this->bundles->set($bundle->name, $bundle); } return $this; }
/** * @param AbstractUser $user * @return string */ public function getAuditEntryFieldClass(AbstractUser $user) { $userClass = ClassUtils::getRealClass($user); if (!$this->entryFieldMap->containsKey($userClass)) { throw new \InvalidArgumentException(sprintf('Audit entry field not found for "%s"', $userClass)); } return $this->entryFieldMap->get($userClass); }
/** * * @param string $key * @param string $section * @return \Doctrine\Common\Collections\ArrayCollection */ public function getDefault($key, $section = "default") { $data = null; if ($this->defaults->containsKey($section . '.' . $key)) { $data = $this->defaults->get($section . '.' . $key); } return $data; }
/** * @param BlogId $id * * @return Blog|null */ public function find(BlogId $id) { $key = (string) $id; if (!$this->storage->containsKey($key)) { return null; } return $this->storage[$key]; }
/** * Set registered types * * @param string $typeName * @param IntegrationInterface $type * * @throws \LogicException * @return $this */ public function addChannelType($typeName, IntegrationInterface $type) { if (!$this->integrationTypes->containsKey($typeName)) { $this->integrationTypes->set($typeName, $type); } else { throw new LogicException(sprintf('Trying to redeclare integration type "%s".', $typeName)); } return $this; }
/** * Add activity * * @param Activity $activity * @return Student */ public function addActivity(Activity $activity) { $key = $activity->getMachineName(); if ($this->activities->containsKey($key)) { throw new \InvalidArgumentException('This Student already belongs to this Activity'); } $this->activities->set($key, $activity); return $this; }
/** * @param DiamanteUser|null $user * * @return string */ public function getAuditEntryFieldClass(DiamanteUser $user = null) { if ($user === null) { return $this->entryFieldMap->first(); } $userClass = ClassUtils::getRealClass($user); if (!$this->entryFieldMap->containsKey($userClass)) { throw new \InvalidArgumentException(sprintf('Audit entry field not found for "%s"', $userClass)); } return $this->entryFieldMap->get($userClass); }
/** * Get a Key/Value position by Key, if it exists - returns false if the * key does not exist * * @param mixed $key The key to search the index for * * @return integer|bool */ private function getPosition($key) { if ($this->index->containsKey($key)) { return $this->index->get($key); } return false; }
/** * Get preview image * * @return Image */ public function getPreviewImage() { if ($this->images->containsKey($this->previewImageKey)) { return $this->images->get($this->previewImageKey); } return $this->images->first(); }
/** * Get parameter. * * @param string $parameter * @param mixed $default * * @return mixed */ public function getParameter($parameter, $default = null) { if (!$this->parameters instanceof ArrayCollection) { return $default; } return $this->parameters->containsKey($parameter) ? $this->parameters->get($parameter) : $default; }
/** * @param string $providerAlias */ public function startProviderEmulation($providerAlias) { if (!$this->providers->containsKey($providerAlias)) { throw new \InvalidArgumentException(sprintf('Provider with "%s" alias not registered', $providerAlias)); } $this->emulatedProvider = $this->providers->get($providerAlias); }
static function load(Config $config) { $scenes = new ArrayCollection(); // Start with the entry scene $stack = array(); $scene = $config['entry_scene']; array_push($stack, $scene); // Loop until our stack is empty while (count($stack)) { // Load a scene from the stack $scenePath = array_pop($stack); $data = Yaml::load($config['base_directory'] . '/' . $scenePath . '.yml'); // Create a scene from the data $newScene = new Scene($scenePath, $data); $scenes->set($scenePath, $newScene); // If we have exit-scenes, add them to the stack so we can load them foreach ($data['scene']['exit'] as $direction => $exitScene) { $tmp['exit'][strtolower($direction)] = $exitScene; // Only add to stack when we haven't already processed that scene if (!$scenes->containsKey($exitScene)) { array_push($stack, $exitScene); } } } return $scenes; }
public function addKey($name, $value) { if (!$this->keys->containsKey($name)) { $this->keys->set($name, $value); } return $this; }
public function containsKey($key) { if (null === $this->entries) { $this->__load___(); } return $this->entries->containsKey($key); }
/** * @param $name * @param Command $command * @param $arguments * @param $priority */ public function addCommand($name, Command $command, $arguments, $priority) { if (!$this->commands->containsKey($name)) { $this->commands->set($name, new ArrayCollection()); } $meta = new CommandMeta($command, $arguments, $priority); $this->commands->get($name)->add($meta); }
/** * Add primary detail. * * @param PrimaryContactDetail $detail * * @return Contact */ public function setPrimaryDetails(PrimaryContactDetail $detail) { if (!$this->primaryDetails->containsKey($detail->getType()->getId())) { $this->primaryDetails->add($detail); } $detail->setContact($this); return $this; }
/** * Tests IdentityWrapper->containsKey() */ public function testContainsKey() { foreach (array_keys($this->entries) as $key) { $this->assertTrue($this->identityWrapper->containsKey($key)); $this->assertFalse($this->wrappedCollection->containsKey($key)); } $this->assertFalse($this->identityWrapper->contains('non-existent')); }
/** * Drops a Collection - removing all data * * @param string $collection The name of the Collection to drop */ public function drop($collection) { if (!$this->collections->containsKey($collection)) { return false; } $this->collections->get($collection)->drop(); $this->collections->remove($collection); return true; }
/** * Add student * * @param Student $student * * @return Activity */ public function addStudent(Student $student) { $key = $student->getId(); if ($this->students->containsKey($key)) { throw new \InvalidArgumentException('The Student has already joined this Activity'); } $this->students->set($key, $student); return $this; }
/** * @param Skill $skill * @return Activity */ public function addSkill(Skill $skill) { $key = $skill->getMachineName(); if ($this->skills->containsKey($key)) { throw new \InvalidArgumentException('This Category already has a skill of that name'); } $this->skills->set($key, $skill); return $this; }
/** * Set Snippet Data to the appropriate fields * * @param string $fieldName the name of the SnippetField * @param string $fieldData the data of the SnippetField * * @return Newscoop\Entity\Snippet */ public function setData($fieldName, $fieldData = null) { if ($this->fields->containsKey($fieldName)) { $this->fields->get($fieldName)->setData($fieldData); } else { throw new \Exception('Snippet: "' . $this->name . '" does not have Field: "' . $fieldName . '"'); } $this->setModified(); return $this; }
/** * Guestimate the title field of the model. * * @return mixed */ function titleField() { $keys = ['title', 'name', 'host', 'url', 'email']; foreach ($keys as $key) { if ($this->fields->containsKey($key)) { return $key; } } return $this->fields->first()->name; }
/** * Return registered database under given name * * @param string $connectionName * * @return \OrientDB */ public function getDatabase($connectionName = 'default') { if ($this->databases->containsKey($connectionName)) { return $this->databases->get($connectionName); } $configuration = $this->getConfiguration($connectionName); $database = $this->getConnection($connectionName); $database->DBOpen($configuration->getDatabase(), $configuration->getUser(), $configuration->getPassword()); $this->databases->set($connectionName, $database); return $this->databases->get($connectionName); }
/** * @param $className * @param null $fieldName * @return null|bool|AbstractConfigModel */ public function findModel($className, $fieldName = null) { if (in_array($className, $this->ignoreModel)) { return false; } $cacheKey = $className . $fieldName; if ($this->localCache->containsKey($cacheKey)) { return $this->localCache->get($cacheKey); } $entityConfigModelRepo = $this->getEntityManager()->getRepository(EntityConfigModel::ENTITY_NAME); $entity = $entityConfigModelRepo->findOneBy(array('className' => $className)); if ($fieldName) { $fieldConfigModelRepo = $this->getEntityManager()->getRepository(FieldConfigModel::ENTITY_NAME); $result = $fieldConfigModelRepo->findOneBy(array('entity' => $entity, 'fieldName' => $fieldName)); } else { $result = $entity; } $this->localCache->set($cacheKey, $result); return $result; }
/** * Create new translation object * * @return TranslationInterface */ protected function createTranslation() { $locale = $this->getLocale(); if ($this->translations->containsKey($locale)) { return $this->translations->get($locale); } if (!isset($this->translationClassName)) { throw new InvalidArgumentException('Translation class name is required to create new translation instances'); } $translation = new $this->translationClassName(); $translation->setObject($this); $translation->setLocale($locale); $this->setTranslation($translation); return $translation; }
/** * @param string $identifier * @return AbstractAddress */ public function getEntityByIdentifier($identifier) { $identifierData = explode(self::DELIMITER, $identifier); if (empty($identifierData[1]) || !empty($identifierData[2])) { throw new \InvalidArgumentException(sprintf('Wrong identifier "%s"', $identifier)); } $id = $identifierData[1]; if (!filter_var($id, FILTER_VALIDATE_INT)) { throw new \InvalidArgumentException(sprintf('Wrong entity id "%s"', $id)); } $alias = $identifierData[0]; if (!$alias || !$this->map->containsKey($alias)) { throw new \InvalidArgumentException(sprintf('Unknown alias "%s"', $alias)); } $className = $this->map->get($alias); return $this->registry->getManagerForClass($className)->find($className, (int) $id); }