public function import($scope) { if (!$this->className) { throw new WrongStateException("no class defined for PrimitiveUuidIdentifierList '{$this->name}'"); } if (!BasePrimitive::import($scope)) { return null; } if (!is_array($scope[$this->name])) { return false; } $list = array_unique($scope[$this->name]); $values = array(); foreach ($list as $id) { if (!Assert::checkUUID($id)) { return false; } $values[] = $id; } $objectList = $this->dao()->getListByIds($values); if (count($objectList) == count($values) && !($this->min && count($values) < $this->min) && !($this->max && count($values) > $this->max)) { $this->value = $objectList; return true; } return false; }
public static function isIndexExists($array, $key, $message = null) { Assert::isArray($array); if (!array_key_exists($key, $array)) { throw new WrongArgumentException($message . ', ' . self::dumpArgument($key)); } }
/** * @return GmpBigInteger **/ public static function make($number, $base = 10) { Assert::isTrue(is_numeric($number)); $result = new self(); $result->resource = gmp_init($number, $base); return $result; }
public function rebind($name, $object) { Assert::isNotNull($object); $this->map[$name] = $object; $this->reverseMap[spl_object_hash($object)] = $name; return $this; }
public static function swap(DAOConnected $first, DAOConnected $second, $property = 'position') { Assert::isTrue(get_class($first) === get_class($second)); $setMethod = 'set' . ucfirst($property); $getMethod = 'get' . ucfirst($property); Assert::isTrue(method_exists($first, $setMethod) && method_exists($first, $getMethod)); /** @var StorableDAO $dao */ $dao = $first->dao(); $db = DBPool::me()->getByDao($dao); $oldPosition = $first->{$getMethod}(); $newPosition = $second->{$getMethod}(); $db->begin(); $e = null; try { $dao->save($first->{$setMethod}(self::$nullValue)); $dao->save($second->{$setMethod}($oldPosition)); $dao->save($first->{$setMethod}($newPosition)); $db->commit(); } catch (DatabaseException $e) { $db->rollback(); } $dao->uncacheByIds([$first->getId(), $second->getId()]); if ($e) { throw $e; } }
public function import($scope) { if (!$this->className) { throw new WrongStateException("no class defined for PrimitiveIdentifierList '{$this->name}'"); } if (!BasePrimitive::import($scope)) { return null; } if (!is_array($scope[$this->name])) { return false; } $list = array_unique($scope[$this->name]); $values = array(); foreach ($list as $id) { if (!Assert::checkScalar($id)) { return false; } $values[] = $id; } $objectList = array(); foreach ($values as $value) { $className = $this->className; $objectList[] = new $className($value); } if (count($objectList) == count($values)) { $this->value = $objectList; return true; } return false; }
public function set($name, $value) { if (!isset($this->mapping[$name])) { throw new WrongArgumentException("knows nothing about property '{$name}'"); } $primitive = $this->mapping[$name]; $setter = 'set' . ucfirst($primitive->getName()); if (!method_exists($this->object, $setter)) { throw new WrongArgumentException("cannot find mutator for '{$name}' in class " . get_class($this->object)); } if (is_object($value)) { if ($primitive instanceof PrimitiveAnyType && $value instanceof PrototypedEntity) { $value = ObjectToDTOConverter::create($value->entityProto())->make($value); } else { $value = $this->dtoValue($value, $primitive); } } elseif (is_array($value) && is_object(current($value))) { $dtoValue = []; foreach ($value as $oneValue) { Assert::isTrue(is_object($oneValue), 'array must contain only objects'); $dtoValue[] = $this->dtoValue($oneValue, $primitive); } $value = $dtoValue; } return $this->object->{$setter}($value); }
/** * @throws WrongArgumentException * @return PrimitiveIdentifier **/ public function of($class) { $className = $this->guessClassName($class); Assert::isTrue(class_exists($className, true) || interface_exists($className, true), "knows nothing about '{$className}' class/interface"); $this->ofClassName = $className; return $this; }
/** * @return DoctypeDeclaration **/ public function setPublic($isPublic) { Assert::isBoolean($isPublic); $this->public = $isPublic; $this->inline = false; return $this; }
/** * @return StripTagsFilter **/ public function setAllowableTags($exclude) { if (null !== $exclude) { Assert::isString($exclude); } $this->exclude = $exclude; return $this; }
/** * @throws WrongArgumentException * @return DBSchema **/ public function addTable(DBTable $table) { $name = $table->getName(); Assert::isFalse(isset($this->tables[$name]), "table '{$name}' already exist"); $this->tables[$table->getName()] = $table; $this->order[] = $name; return $this; }
public function getRequestGetter() { Assert::isNotNull($this->requestType); if (!$this->requestGetter) { $this->requestGetter = self::$requestGetterMap[$this->requestType->getId()]; } return $this->requestGetter; }
/** * @return PrimitiveMultiList **/ public function setDefault($default) { Assert::isArray($default); foreach ($default as $index) { Assert::isTrue(array_key_exists($index, $this->list)); } return parent::setDefault($default); }
/** * @throws WrongArgumentException * @return LogicalChain **/ public static function getOpenPoint($left, $right, $point) { Assert::isFalse($point === null, 'how can i build logic from emptyness?'); $point = new DBValue($point); $chain = new LogicalChain(); $chain->expOr(Expression::orBlock(Expression::andBlock(Expression::notNull($left), Expression::notNull($right), Expression::between($point, $left, $right)), Expression::andBlock(Expression::isNull($left), Expression::ltEq($point, $right)), Expression::andBlock(Expression::isNull($right), Expression::ltEq($left, $point)), Expression::andBlock(Expression::isNull($left), Expression::isNull($right)))); return $chain; }
protected function prepareResponseFormat() { if ($this->request->hasAttachedVar('format')) { Assert::isNotFalse(array_search($this->request->getAttachedVar('format'), $this->allowedFormatList)); } else { $this->request->setAttachedVar('format', self::DEFAULT_FORMAT); } }
public function __construct($left, $right, $logic) { Assert::isTrue($right instanceof Query || $right instanceof Criteria || $right instanceof MappableObject || is_array($right)); Assert::isTrue($logic == self::IN || $logic == self::NOT_IN); $this->left = $left; $this->right = $right; $this->logic = $logic; }
/** * @throws WrongArgumentException * @return DBTable **/ public function addColumn(DBColumn $column) { $name = $column->getName(); Assert::isFalse(isset($this->columns[$name]), "column '{$name}' already exist"); $this->order[] = $this->columns[$name] = $column; $column->setTable($this); return $this; }
/** * @return FileInputStream **/ private function getStream() { if (!$this->stream) { Assert::isNotNull($this->queue->getFileName()); $this->stream = FileInputStream::create($this->queue->getFileName())->seek($this->queue->getOffset()); } return $this->stream; }
private function getStream() { if (!$this->stream) { Assert::isNotNull($this->queue->getFileName()); $this->stream = FileOutputStream::create($this->queue->getFileName(), true); } return $this->stream; }
public function importValue($value) { if ($value) { Assert::isEqual(get_class($value), $this->className); } else { return parent::importValue(null); } return $this->import([$this->getName() => $value->getId()]); }
/** * @throws WrongArgumentException * @return Range **/ public function setMax($max = null) { if ($max !== null) { Assert::isInteger($max); } else { return $this; } return parent::setMax($max); }
protected function cacheListByQuery(SelectQuery $query, $array) { if ($array !== Cache::NOT_FOUND) { Assert::isArray($array); Assert::isTrue(current($array) instanceof Identifiable); } Cache::me()->mark($this->className)->add($this->makeQueryKey($query, self::SUFFIX_LIST), $array, Cache::EXPIRES_FOREVER); return $array; }
public static final function create(StorageEngineType $type = null, $linkId = null) { if (!$type) { return new self($linkId); } $className = $type->toString(); Assert::classExists($className); return new $className($linkId); }
public function getBitmask($config) { Assert::isInstance($config, AMQPQueueConfig::class); $bitmask = parent::getBitmask($config); if ($config->getExclusive()) { $bitmask = $bitmask | AMQP_EXCLUSIVE; } return $bitmask; }
/** * @return ArgumentParser **/ public function validate() { Assert::isNotNull($this->result); $this->form->import($this->result); if ($errors = $this->form->getErrors()) { throw new WrongArgumentException("\nArguments wrong:\n" . print_r($errors, true)); } return $this; }
public function addPeer($label, CachePeer $peer, $mountPoint) { Assert::isLesserOrEqual($mountPoint, $this->summaryWeight); Assert::isGreaterOrEqual($mountPoint, 0); $this->doAddPeer($label, $peer); $this->peers[$label]['mountPoint'] = $mountPoint; $this->sorted = false; return $this; }
public function getBytes($numberOfBytes) { Assert::isPositiveInteger($numberOfBytes); $bytes = null; for ($i = 0; $i < $numberOfBytes; $i += 4) { $bytes .= pack('L', mt_rand()); } return substr($bytes, 0, $numberOfBytes); }
public function __construct($class) { Assert::isTrue(ClassUtils::isInstanceOf($class, Prototyped::class)); if (is_object($class)) { $this->className = get_class($class); } else { $this->className = $class; } }
public function getBitmask($config) { Assert::isInstance($config, AMQPExchangeConfig::class); $bitmask = parent::getBitmask($config); if ($config->getInternal()) { $bitmask = $bitmask | AMQP_INTERNAL; } return $bitmask; }
/** * @return ProjectionChain **/ public function add(ObjectProjection $projection, $name = null) { if ($name) { Assert::isFalse(isset($this->list[$name])); $this->list[$name] = $projection; } else { $this->list[] = $projection; } return $this; }