/**
* @throws WrongArgumentException
* @return PrimitiveEnumeration
**/
public function of($class)
{
$className = $this->guessClassName($class);
Assert::classExists($className);
Assert::isInstance($className, Enumeration::class);
$this->className = $className;
return $this;
}
public function send(Message $message)
{
if (!$this->queue) {
throw new WrongStateException('you must set the queue first');
}
Assert::isInstance($message, 'TextMessage');
$this->getStream()->write($message->getTimestamp()->toString() . "\t" . str_replace(PHP_EOL, ' ', $message->getText()) . PHP_EOL);
}
/**
* @return PrimitiveRegistryList
**/
public function setValue($value)
{
if ($value) {
Assert::isArray($value);
Assert::isInstance(current($value), Registry::class);
}
$this->value = $value;
return $this;
}
public function getBitmask($config)
{
Assert::isInstance($config, AMQPQueueConfig::class);
$bitmask = parent::getBitmask($config);
if ($config->getExclusive()) {
$bitmask = $bitmask | AMQP_EXCLUSIVE;
}
return $bitmask;
}
public function getBitmask($config)
{
Assert::isInstance($config, AMQPExchangeConfig::class);
$bitmask = parent::getBitmask($config);
if ($config->getInternal()) {
$bitmask = $bitmask | AMQP_INTERNAL;
}
return $bitmask;
}
public function importValue($value)
{
if ($value) {
Assert::isInstance($value, $this->className);
// Assert::isEqual(get_class($value), $this->className);
} else {
return parent::importValue(null);
}
return $this->import(array($this->getName() => $value->getId()));
}
public function uncache()
{
foreach ($this->classNameMap as $className => $tags) {
$dao = ClassUtils::callStaticMethod("{$className}::dao");
/* @var $dao StorableDAO */
$worker = Cache::worker($dao);
Assert::isInstance($worker, TaggableDaoWorker::class);
$worker->expireTags($tags);
}
}
public function compare($one, $two)
{
Assert::isInstance($one, Date::class);
Assert::isInstance($two, Date::class);
$stamp1 = $one->toStamp();
$stamp2 = $two->toStamp();
if ($stamp1 == $stamp2) {
return 0;
}
return $stamp1 < $stamp2 ? -1 : 1;
}
public function compare($one, $two)
{
Assert::isInstance($one, Identifiable::class);
Assert::isInstance($two, Identifiable::class);
$oneId = $one->getId();
$twoId = $two->getId();
if ($oneId === $twoId) {
return 0;
}
return $oneId < $twoId ? -1 : 1;
}
/**
* @throws WrongArgumentException
* @return AMQPPool
**/
public function addLink($name, AMQP $amqp)
{
if (isset($this->pool[$name])) {
throw new WrongArgumentException("amqp link with name '{$name}' already registered");
}
if ($this->pool) {
Assert::isInstance($amqp, current($this->pool));
}
$this->pool[$name] = $amqp;
return $this;
}
public function getBitmask($config)
{
Assert::isInstance($config, AMQPOutgoingMessage::class);
$bitmask = 0;
if ($config->getMandatory()) {
$bitmask = $bitmask | AMQP_MANDATORY;
}
if ($config->getImmediate()) {
$bitmask = $bitmask | AMQP_IMMEDIATE;
}
return $bitmask;
}
public function cloneInnerBuilder($property)
{
$mapping = $this->getFormMapping();
Assert::isIndexExists($mapping, $property);
$primitive = $mapping[$property];
Assert::isInstance($primitive, PrimitiveForm::class);
$result = new $this($primitive->getProto());
if (isset($this->limitedPropertiesList[$primitive->getName()])) {
$result->setLimitedPropertiesList($this->limitedPropertiesList[$primitive->getName()]);
}
return $result;
}
public static function getIdsArray($objectsList)
{
$out = [];
if (!$objectsList) {
return $out;
}
Assert::isInstance(current($objectsList), Identifiable::class, 'only identifiable lists accepted');
foreach ($objectsList as $object) {
$out[] = $object->getId();
}
return $out;
}
/**
* @return Form
**/
public function fillOwn($object, &$result)
{
Assert::isInstance($result, Form::class);
foreach ($this->getFormMapping() as $primitive) {
if ($primitive instanceof PrimitiveForm && $result->exists($primitive->getName()) && $primitive->isComposite()) {
Assert::isEqual($primitive->getProto(), $result->get($primitive->getName())->getProto());
continue;
}
$result->add($primitive);
}
$result = parent::fillOwn($object, $result);
$result->setProto($this->proto);
return $result;
}
public final function validate($object, $form, $previousObject = null)
{
if (is_array($object)) {
return $this->validateList($object, $form, $previousObject);
}
Assert::isInstance($object, $this->className());
Assert::isInstance($form, Form::class);
if ($previousObject) {
Assert::isInstance($previousObject, $this->className());
}
if ($this->baseProto()) {
$this->baseProto()->validate($object, $form, $previousObject);
}
return $this->validateSelf($object, $form, $previousObject);
}
public static function getAgeByBirthDate(Date $birthDate, $actualDate = null)
{
if ($actualDate) {
Assert::isInstance($actualDate, Date::class);
} else {
$actualDate = Date::makeToday();
}
$result = $actualDate->getYear() - $birthDate->getYear();
if ($actualDate->getMonth() < $birthDate->getMonth() || $actualDate->getMonth() == $birthDate->getMonth() && $actualDate->getDay() < $birthDate->getDay()) {
// - Happy birthday?
// - Happy go to hell. Not yet in this year.
--$result;
}
return $result;
}
public function uncache()
{
foreach ($this->classNameMap as $className => $uncaches) {
list($idKeys, $tags) = $uncaches;
$dao = ClassUtils::callStaticMethod("{$className}::dao");
/* @var $dao StorableDAO */
$worker = Cache::worker($dao);
Assert::isInstance($worker, TaggableDaoWorker::class);
$worker->expireTags($tags);
foreach ($idKeys as $key) {
Cache::me()->mark($className)->delete($key);
}
$dao->uncacheLists();
}
}
public function importValue($value)
{
if ($value !== null) {
Assert::isArray($value);
} else {
return null;
}
$result = true;
$resultValue = [];
foreach ($value as $id => $form) {
Assert::isInstance($form, Form::class);
$resultValue[$id] = $form;
if ($form->getErrors()) {
$result = false;
}
}
$this->value = $resultValue;
return $result;
}
protected function call($method, DTOMessage $request, $resultClass)
{
$requestDto = $request->makeDto();
Assert::isInstance($requestDto, DTOClass::class);
if (defined('__LOCAL_DEBUG__') && !defined('SIMPLE_TEST')) {
// self-validation
$form = ObjectToFormConverter::create($request->entityProto())->make($request);
Assert::isTrue(!$form->getErrors() && $request->entityProto()->validate($request, $form), Assert::dumpArgument($request));
}
try {
try {
$resultDto = $this->getSoapClient()->{$method}($requestDto);
} catch (BaseException $e) {
if (get_class($e) == BaseException::class) {
throw new SoapFault('Server', get_class($e) . ': ' . $e->getMessage());
} else {
$this->logCall();
throw $e;
}
}
} catch (SoapFault $e) {
$this->logCall();
throw self::convertSoapFault($e);
}
$this->logCall();
if (!$resultClass) {
Assert::isNull($resultDto);
$result = null;
} else {
Assert::isInstance($resultDto, DTOClass::class);
Assert::isEqual($resultDto->entityProto()->className(), $resultClass);
$form = DTOToFormImporter::create($resultDto->entityProto())->make($resultDto);
Assert::isTrue(!$form->getErrors(), Assert::dumpArgument($resultDto));
$result = $resultDto->makeObject($form);
Assert::isInstance($result, DTOMessage::class);
Assert::isEqual(get_class($result), $resultClass);
Assert::isTrue($result->entityProto()->validate($result, $form), Assert::dumpArgument($result));
}
return $result;
}
public function __construct(EntityProto $proto, $object)
{
Assert::isInstance($object, Form::class);
return parent::__construct($proto, $object);
}
/**
* @return Criteria
**/
public function dropProjectionByType($dropTypes)
{
Assert::isInstance($this->projection, ProjectionChain::class);
$this->projection->dropByType($dropTypes);
return $this;
}
/**
* @return DaoSynchronizer
**/
public function setSlave(GenericDAO $slave)
{
Assert::isInstance($slave, ProtoDAO::class);
return parent::setSlave($slave);
}
public function import($scope)
{
if (!$this->className) {
throw new WrongStateException("no class defined for PrimitiveIdentifier '{$this->name}'");
}
$className = $this->className;
if (isset($scope[$this->name]) && $scope[$this->name] instanceof $className) {
$value = $scope[$this->name];
$this->raw = $this->actualExportValue($value);
$this->setValue($value);
return $this->imported = true;
}
$result = parent::import($scope);
if ($result === true) {
try {
$result = $this->actualImportValue($this->value);
Assert::isInstance($result, $className);
$this->value = $result;
return true;
} catch (WrongArgumentException $e) {
// not imported
} catch (ObjectNotFoundException $e) {
// not imported
}
$this->value = null;
return false;
}
return $result;
}
protected function checkObjectType(Identifiable $object)
{
Assert::isInstance($object, $this->getObjectName(), 'strange object given, i can not inject it');
// Assert::isSame(get_class($object), $this->getObjectName(), 'strange object given, i can not inject it');
}
/**
* @param $uncacher UncacherGenericDAO same as self class
*
* @return UncacherBase (this)
*/
public function merge(UncacherBase $uncacher)
{
Assert::isInstance($uncacher, self::class);
return $this->mergeSelf($uncacher);
}
/**
* @return TextFileReceiver
**/
public function setQueue(MessageQueue $queue)
{
Assert::isInstance($queue, TextFileQueue::class);
$this->queue = $queue;
return $this;
}
public function __construct(Identifiable $parent, GenericDAO $dao, $lazy = true)
{
Assert::isBoolean($lazy);
$this->parent = $parent;
$this->lazy = $lazy;
$this->dao = $dao;
Assert::isInstance($dao->getObjectName(), Identifiable::class);
$this->comparator = SerializedObjectComparator::me();
}
/**
* @return PrimitiveIdentifier
**/
public static function prototypedIdentifier($class, $name = null)
{
Assert::isInstance($class, DAOConnected::class);
$dao = is_string($class) ? call_user_func([$class, 'dao']) : $class->dao();
return self::prototyped($class, $dao->getIdName(), $name);
}
/**
* @param $uncacher UncacherNullDaoWorker same as self class
*
* @return UncacherBase (this)
*/
public function merge(UncacherBase $uncacher)
{
Assert::isInstance($uncacher, get_class($this));
return $this->mergeSelf($uncacher);
}
public function setDefault($default)
{
Assert::isInstance($default, $this->className);
$this->default = $default;
return $this;
}
