/core/Utils/Exporter.class.php

<?php
/**
 * Exporter factory
 * @author Alex Gorbylev <alex@gorbylev.ru>
 * @date 2013.08.03
 */
class Exporter extends StaticFactory {

	const MAX_NESTING_DEPTH = 3;

	public static function null() {
		return function () {
			return null;
		};
	}

	public static function int() {
		return function ($value) {
			return intval($value);
		};
	}

	public static function float() {
		return function ($value) {
			return floatval($value);
		};
	}

	public static function double() {
		return function ($value) {
			return doubleval($value);
		};
	}

	public static function string() {
		return function ($value) {
			return strval($value);
		};
	}

	public static function set($level = 0) {
		return function(array $set) use ($level) {
			if( $level>=self::MAX_NESTING_DEPTH ) {
				return count($set);
			}
			$result = array();
			foreach($set as $key=>$value) {
				$result[$key] = call_user_func(Exporter::smart($level), $value);
			}
			return $result;
		};
	}

	public static function object($level = 0) {
		return function ($object) use ($level) {
			$properties = self::getObjectProperties($object);
			return call_user_func(Exporter::set($level), $properties);
		};
	}

	public static function date($format = null) {
		return function (Date $date) use ($format) {
			if( is_null($format) ) {
				return $date->toString($format);
			} else {
				return $date->toFormatString($format);
			}
		};
	}

	public static function hstore($filter = null, $asKeyVal = false) {
		return function (Hstore $hstore) use ($filter, $asKeyVal) {
			$result = null;
			if( is_string($filter) && $hstore->isExists($filter) ) {
				$result = $hstore->get($filter);
			} elseif( is_array($filter) ) {
				$result = array();
				foreach($filter as $key) {
					if( $asKeyVal ) {
						$result[$key] = $hstore->isExists($key) ? $hstore->get($key) : null;
					} else {
						$result[] = array(
							'key'=>$key,
							'value'=>$hstore->isExists($key) ? $hstore->get($key) : null,
						);
					}
				}
			} else {
				foreach($hstore->getList() as $key=>$value) {
					if( $asKeyVal ) {
						$result[$key] = $value;
					} else {
						$result[] = array(
							'key'=>$key,
							'value'=>$value,
						);
					}
				}
			}
			return $result;
		};
	}

	public static function prototypedAuto($level = 0) {
		return function (Prototyped $object) use ($level) {
			$result = array();
			/** @var LightMetaProperty $property */
			foreach($object->proto()->getPropertyList() as $property) {
				$value = null;
				$exporter = Exporter::null();
				if( $property->isIdentifier() ) {
					$value = call_user_func(array($object, $property->getGetter()));
					if( Assert::checkInteger($value) ) {
						$exporter = Exporter::int($level);
					} else {
						$exporter = Exporter::string($level);
					}
				} elseif( $property->isGenericType() ) {
					$value = call_user_func(array($object, $property->getGetter()));
					$exporter = Exporter::smart($level);
				} elseif( $property->getRelationId()===MetaRelation::ONE_TO_ONE ) {
					if( $level < self::MAX_NESTING_DEPTH ) {
						$value = call_user_func(array($object, $property->getGetter()));
						$exporter = Exporter::smart($level);
					} else {
						$value = call_user_func(array($object, $property->getGetter().'Id'));
						if( Assert::checkInteger($value) ) {
							$exporter = Exporter::int($level);
						} else {
							$exporter = Exporter::string($level);
						}
					}
				} elseif( $property->getRelationId()===MetaRelation::ONE_TO_MANY ) {
					$value = call_user_func(array($object, $property->getGetter()));
					$exporter = Exporter::lazy();
				} elseif( $property->getRelationId()===MetaRelation::MANY_TO_MANY ) {
					$value = call_user_func(array($object, $property->getGetter()));
					$exporter = Exporter::lazy();
				}
				$result[$property->getName()] = call_user_func($exporter, $value);
			}
			return $result;
		};
	}

	public static function prototypedByMap(array $map, $level = 0) {
		return function (Prototyped $object) use ($map, $level) {
			$result = array();
			foreach($map as $name=>$exporter) {
				$property = $object->proto()->getPropertyByName($name);
				$value = call_user_func(array($object, $property->getGetter()));
				$result[$name] = $exporter($value);
			}
			return $result;
		};
	}

	public static function lazy() {
		return function (UnifiedContainer $container) {
			return $container->getCount();
		};
	}

	public static function cascade($level) {
		return function (UnifiedContainer $container) use ($level) {
			return call_user_func(Exporter::set($level), $container->getList());
		};
	}

	public static function smart($level = 0) {
		return function ($value) use ($level) {
			$level++;
			if( is_null($value) ) {
				return null;
			} elseif( is_scalar($value) ) {
				return $value;
			} elseif( is_array($value) ) {
				return call_user_func(Exporter::set($level), $value);
			} elseif( is_object($value) ) {
				if( $value instanceof Date ) {
					return call_user_func(Exporter::date(), $value);
				} elseif( $value instanceof Hstore ) {
					return call_user_func(Exporter::hstore(), $value);
				} elseif( $value instanceof Prototyped ) {
					return call_user_func(Exporter::prototypedAuto($level), $value);
				} elseif( $value instanceof UnifiedContainer ) {
					return 'UnifiedContainer';
//					return call_user_func(Exporter::prototyped(null, $level), $value);
				} else {
					return call_user_func(Exporter::object($level), $value);
				}
			} else {
				return null;
			}
		};
	}

	public static function model(array $exportMap = null) {
		return function (Model $model) use ($exportMap) {
			// if exporters empty, try to build them smartly
			if( is_null($exportMap) ) {
				$exportMap = array();
				foreach($model->getList() as $key=>$value) {
					$exportMap[$key] = Exporter::smart();
				}
			}
			// execute exporters
			$result = array();
			foreach($exportMap as $key=>$exporter) {
				$value = null;
				if( $model->has($key) ) {
					$value = $exporter($model->get($key));
				}
				$result[$key] = $value;
			}
			return $result;
		};
	}

	protected static function getObjectProperties($object) {
		return Closure::bind(function ($object) {
			return get_object_vars($object);
		}, null, $object)->__invoke($object);
	}

}