public static function process($source, $process = array())
{
$args = func_get_args();
if (count($args) > 2) {
$process = array_slice($args, 1);
}
if (empty($process)) {
return $source;
}
$process = (array) $process;
foreach ($process as $name => $config) {
if (is_int($name) && is_string($config)) {
$name = $config;
$config = array();
} else {
if (is_int($name) && is_array($config)) {
$source = self::process($source, $config);
}
}
if (!isset(self::$process[$name])) {
continue;
}
if (!is_string(self::$process[$name])) {
$source = Core::invoke(self::$process[$name], array($source));
} else {
$p = Core::make(self::$process[$name]);
if (!Core_Types::is_subclass_of('Text.Process.ProcessInterface', $p)) {
continue;
}
$p->configure($config);
$source = $p->process($source);
}
}
return $source;
}
public function maps_to($prototype)
{
if (!($class_name = Core_Types::real_class_name_for($prototype))) {
throw new Core_InvalidArgumentTypeException('prototype', $prototype);
}
if (Core_Types::is_object($prototype)) {
$this->prototype = $prototype;
} else {
$this->prototype = new $class_name();
}
if (Core_Types::is_subclass_of('DB.SQL.Entity', $this->prototype)) {
DB_SQL::db()->map_class(Core_Types::real_class_name_for($this->prototype), $this);
}
return $this;
}
public static function replace_class($class)
{
if (!empty(self::$replace_classes[$class]) && Core_Types::is_subclass_of($class, self::$replace_classes[$class])) {
return self::$replace_classes[$class];
} else {
return $class;
}
}
/**
* @param array $json
* @param Object_AttrsListInterface $object
* @param Object_Attribute $attr
* @param $flavor
* @param $columns
*
* @return object
*/
protected function decode_collection($json, Object_AttrListInterface $object, Object_Attribute $attr, $flavor = null, $columns = array())
{
$operation = isset($attr->operation) ? $attr->operation : 'append';
foreach ($json->{$attr->name} as $v) {
if (Core_Types::is_subclass_of('Object_AttrListInterface', $attr->items)) {
$item = $this->decode_object($v, Core::make($attr->items));
} else {
$item = $this->decode_scalar($v, $attr->items);
}
if (is_string($operation) && method_exists($object->{$attr->name}, $operation)) {
$object->{$attr->name}->{$operation}($item);
} else {
if (is_array($operation)) {
call_user_func($operation, $item);
}
}
}
return $object;
}
/**
* @param string $name
* @param array $data
* @param CMS_ORM_Entity $item
*
* @return CMS_Fields_ValueContainer
*/
public function container($name, $data, $item)
{
$class = $this->container_class();
if (isset($data['container']) && Core_Types::is_subclass_of('CMS.Fields.ValueContainer', $data['container'])) {
$class = $data['container'];
}
return Core::make($class, $name, $data, $item, $this);
}
/**
* @param string $name
*
* @return Dev_Unit_AssertBundle
*/
private function load_bundle($name)
{
$mname = 'Dev.Unit.Assert.' . Core_Strings::capitalize($name);
$mclass = Core_Types::real_class_name_for($mname);
Core::load($mname);
if (Core_Types::is_subclass_of('Dev.Unit.AssertBundleModuleInterface', $mclass) && ($bundle = call_user_func(array($mclass, 'bundle'))) instanceof Dev_Unit_AssertBundle) {
return $this->bundles[$name] = $bundle;
} else {
throw new Dev_Unit_InvalidAssertBundleException($name);
}
}
/**
* Возвращает объект строки результата
*
* Обрабатывает строку результата и возвращает построенный на её основе объект
*
* @params array $row массив, соответствующий записи
*
* @return object
*/
protected function make_row_instance(array $row)
{
if ($this->prototype) {
$class_field = DB::option('row_class_field');
$prototype = isset($row[$class_field]) && !$this->ignore_type && Core_Types::is_subclass_of($this->prototype, $type = $row[$class_field]) ? new $type() : $this->prototype;
$array_access = $prototype instanceof ArrayAccess;
$result = clone $prototype;
foreach ($row as $k => $v) {
$v = $this->adapter->cast_column($this->metadata[$k], $v);
$array_access ? $result[$k] = $v : ($result->{$k} = $v);
}
return $result;
} else {
foreach ($row as $k => &$v) {
$v = $this->adapter->cast_column($this->metadata[$k], $v);
}
return $row;
}
}
