public static function trimMap($map)
{
$trimmedMap = NULL;
if (isset($map)) {
foreach ($map as $key => $value) {
$key = StringHelper::trim($key);
$value = is_array($value) ? ArrayHelper::isIndexedArray($value) ? self::trimList($value) : self::trimMap($value) : StringHelper::trim($value);
$trimmedMap[$key] = $value;
}
}
return $trimmedMap;
}
protected function adjustParameters($parameters)
{
$adjustedParameters = NULL;
if (isset($parameters)) {
if (is_array($parameters) && ArrayHelper::isIndexedArray($parameters)) {
foreach ($parameters as $key => $compositeParameter) {
$adjustedParameters[$key] = $this->adjustCompositeParameter($compositeParameter);
}
} else {
$adjustedParameters = $this->adjustCompositeParameter($parameters);
}
}
return $adjustedParameters;
}
public static function mergeWith(&$instance, $source, $mergeCompositeProperty = FALSE)
{
if (isset($source)) {
if (is_object($source) || is_array($source)) {
foreach ($source as $name => $value) {
// source does not have value for the property
if (!isset($value)) {
continue;
}
// we do not support composite properties
if (is_object($value) || is_array($value)) {
if ($mergeCompositeProperty) {
if (!isset($instance->{$name})) {
$instance->{$name} = NULL;
}
if (is_object($value)) {
// support for an object
self::mergeWith($instance->{$name}, $value, TRUE);
} else {
if (ArrayHelper::isIndexedArray($value)) {
// support for an indexed array
$a = NULL;
foreach ($value as $index => $v) {
$o = NULL;
self::mergeWith($o, $v, TRUE);
$a[$index] = $o;
}
$instance->{$name} = $a;
} else {
// support for an associative array
self::mergeWith($instance->{$name}, $value, TRUE);
}
}
}
continue;
}
// overriding is not allowed
if (isset($instance->{$name}) && $instance->{$name} != $value) {
LogHelper::log_error(t("'@propertyName' property already contains value: @existingPropertyValue. Merge cannot be performed with new value: @newPropertyValue", array('@propertyName' => $name, '@existingPropertyValue' => $instance->{$name}, '@newPropertyValue' => $value)));
throw new UnsupportedOperationException(t("'@propertyName' property already contains value. Merge cannot be performed", array('@propertyName' => $name)));
}
$instance->{$name} = $value;
}
} else {
$instance = $source;
}
}
return $instance;
}
public function addCompositeQueryValues($compositeQuery)
{
if (!isset($compositeQuery)) {
return;
}
$isIndexedArray = ArrayHelper::isIndexedArray($compositeQuery);
if ($isIndexedArray && count($compositeQuery) === 1) {
$compositeQuery = $compositeQuery[0];
$isIndexedArray = FALSE;
}
if ($isIndexedArray) {
foreach ($compositeQuery as $query) {
$this->addCompositeQueryValues($query);
}
} else {
$index = count($this->queries);
foreach ($compositeQuery as $name => $value) {
$this->addQueryValues($index, $name, $value);
}
}
}
public static function parseParameters(array $parameters = NULL)
{
if (!isset($parameters)) {
return NULL;
}
$adjustedParameters = NULL;
foreach ($parameters as $parameterIndex => $parameterProperties) {
if (!is_array($parameterProperties)) {
$parameterProperties = array($parameterProperties);
}
$isParameterPropertyDetected = FALSE;
$parameterName = NULL;
if (is_int($parameterIndex)) {
if (!isset($parameterProperties[self::$QUERY_PARAMETER__COLUMN_NAME])) {
throw new IllegalArgumentException(t('Could not find corresponding column name for the parameter: @parameterIndex', array('@parameterIndex' => $parameterIndex)));
}
$parameterName = $parameterProperties[self::$QUERY_PARAMETER__COLUMN_NAME];
unset($parameterProperties[self::$QUERY_PARAMETER__COLUMN_NAME]);
$isParameterPropertyDetected = TRUE;
} else {
$parameterName = $parameterIndex;
}
$operatorName = NULL;
if (isset($parameterProperties[self::$QUERY_PARAMETER__OPERATOR_NAME])) {
$operatorName = $parameterProperties[self::$QUERY_PARAMETER__OPERATOR_NAME];
unset($parameterProperties[self::$QUERY_PARAMETER__OPERATOR_NAME]);
$isParameterPropertyDetected = TRUE;
} else {
$operatorName = EqualOperatorHandler::$OPERATOR__NAME;
}
$parameterValues = NULL;
if (isset($parameterProperties[self::$QUERY_PARAMETER__OPERATOR_VALUE])) {
$parameterValues = $parameterProperties[self::$QUERY_PARAMETER__OPERATOR_VALUE];
unset($parameterProperties[self::$QUERY_PARAMETER__OPERATOR_VALUE]);
$isParameterPropertyDetected = TRUE;
}
if (!$isParameterPropertyDetected) {
$parameterValues = $parameterProperties;
// marking that all properties are processed in the variable
$parameterProperties = NULL;
}
// some properties are left and we do not know what to do with them
if (count($parameterProperties) > 0) {
throw new IllegalArgumentException(t('Unsupported keys for parameter definition: @unsupportedKeys', array('@unsupportedKeys' => implode(', ', array_keys($parameterProperties)))));
}
$operatorValues = NULL;
if (isset($parameterValues)) {
if (ArrayHelper::isIndexedArray($parameterValues)) {
$operatorValues = $parameterValues;
} else {
// named operator value parameters are provided
// we need to order the values in the same order as the parameters defined for the operator
$operatorMetaData = OperatorFactory::getInstance()->getOperatorMetaData($operatorName);
$operatorParameterMetaDatas = $operatorMetaData->getParameters();
if (isset($operatorParameterMetaDatas)) {
foreach ($operatorParameterMetaDatas as $operatorParameterMetaData) {
$name = $operatorParameterMetaData->name;
$value = NULL;
if (isset($parameterValues[$name])) {
$value = $parameterValues[$name];
unset($parameterValues[$name]);
}
$operatorValues[] = $value;
}
}
// some named parameters are not recognized
if (count($parameterValues) > 0) {
throw new IllegalArgumentException(t('Unsupported keys for parameter value definition: @unsupportedKeys', array('@unsupportedKeys' => implode(', ', array_keys($parameterValues)))));
}
}
}
$operator = OperatorFactory::getInstance()->initiateHandler($operatorName, $operatorValues);
if (isset($adjustedParameters[$parameterName])) {
$previousOperator = $adjustedParameters[$parameterName];
if (is_array($previousOperator)) {
$adjustedParameters[$parameterName][] = $operator;
} else {
$adjustedParameters[$parameterName] = array($previousOperator, $operator);
}
} else {
$adjustedParameters[$parameterName] = $operator;
}
}
return $adjustedParameters;
}
