protected $resultClass = 'Hochstrasser\Wirecard\Model\Seamless\Frontend\DataStorageInitResult';
426206
function getRequestParameters()
    {
        $params = $this->getRawParameters();

        $fingerprintOrder = array_merge(
            ['customerId', 'shopId', 'password', 'secret', 'language'],
            $this->fingerprintOrder
        );

        $requiredParameters = array_merge(
            ['customerId', 'requestFingerprint', 'password', 'language'],
            $this->requiredParameters
        );

        switch ($this->getParam('fundTransferType')) {
        case FundTransferType::EXISTINGORDER:
            $fingerprintOrder[] = 'sourceOrderNumber';
            $requiredParameters[] = 'sourceOrderNumber';
            break;
        case FundTransferType::MONETA:
            $fingerprintOrder[] = 'consumerWalletId';
            $requiredParameters[] = 'consumerWalletId';
            break;
        case FundTransferType::SEPA_CT:
            $fingerprintOrder[] = 'bankAccountOwner';
            $fingerprintOrder[] = 'bankBic';
            $fingerprintOrder[] = 'bankAccountIban';
            $requiredParameters[] = 'bankAccountOwner';
            $requiredParameters[] = 'bankBic';
            $requiredParameters[] = 'bankAccountIban';
            break;
        case FundTransferType::SKRILLWALLET:
            $fingerprintOrder[] = 'consumerEmail';
            $requiredParameters[] = 'consumerEmail';
            $requiredParameters[] = 'customerStatement';
            break;
        }

        $params['requestFingerprint'] = Fingerprint::fromParameters($params)
            ->setContext($this->getContext())
            ->setFingerprintOrder($fingerprintOrder);
        $this->assertParametersAreValid($params, $requiredParameters);

        return $params;
    }
1219433
public function getResultType() {
		if ($this->result === null) {
			$this->result = self::RESULTSET_COLLECTION | self::RESULT_MODEL;
		}

		return $this->result;
	}
518390
public function processColumnListing($results)
	{
		$mapping = function ($r) {
			$r = (object) $r;

			return $r->name;
		};

		return array_map($mapping, $results);
	}
1154876
public function result() {
    /* @var $criteria \Phalcon\Mvc\Model\Criteria */
    
    $criteria = $this->newCriteria();
    
    if (count($this->selection))
      $criteria->columns($this->selection);
    
    if ($this->match)
      $this->addConditionsFromArray($this->match);
    
    if ($this->searchstr && $text=$this->getSelect('text'))
      $this->addconditions(
          $text." LIKE :searchstr:",
          ['searchstr'=>"%{$this->searchstr}%"]
      );
    
    if (is_array($this->conditions) && count($this->conditions))
      foreach ($this->conditions as $condition=>$bind)
        $criteria->andWhere($condition,$bind);
      
    if ($this->getOrder())
      $criteria->orderBy($this->getOrder());
    
    
    // limit/offset
    if ($this->offset)
      $criteria->limit($this->limit,$this->offset);
    
    elseif ($this->page)
      $criteria->limit($this->limit,($this->page-1) * $this->limit);
    
    elseif ($this->limit)
      $criteria->limit($this->limit);
    
    
    $this->_fireEvent('beforeCriteriaExecute',$criteria);
    $resultset = $criteria->execute();
    
    $this->_fireEvent('beforeResultsetToArray',$resultset);
    $result    = $resultset->toArray();
    
    $modified  = $this->_fireEvent('AfterResultsetToArray',$result);
    
    $this->result = is_array($modified) ? $modified : $result;
    return $this->result;
  }
1273058
function() {

		var resultClasses = this._static_classes.clone(),
			name,
			value;

		for (name in this._class_bindings) {

			// do not need to check or convert, cause join() will convert everything to string, and nulls to empty string
			resultClasses.push(
				this._class_bindings[name].getValue()
			);

		}

		value = resultClasses.join(' ');

		if (Lava.schema.view.VALIDATE_CLASS_NAMES) {
			this.assertClassStringValid(value);
		}

		return value;

	}
556195
public function result()
    {
        $keys      = array_keys($this->data);
        $first_key = reset($keys);

        return (!is_int($first_key)) ? $this->associativeColumns() : $this->columns();
    }
999207
public function execute() {
		$results = ArrayList::create();
		foreach($this->classes as $c) {

			if($this->isOmitted($c)) continue;

			$list = DataList::create($c)
						->filter('ClassName', $c)
						->limit($this->getLimitFor($c))
						->sort("RAND()");

			foreach($list as $record) {
				$results->push($record);
			}
		}

		return $results;		
	}
962569
protected function process()
    {

        // initialize the store view code
        $this->getSubject()->prepareStoreViewCode();

        // load the PK
        $pk = $this->getValue($this->getPrimaryKeyColumnName());

        // load the store view - if no store view has been set, we assume the admin
        // store view, which will contain the default (fallback) attribute values
        $storeViewCode = $this->getSubject()->getStoreViewCode(StoreViewCodes::ADMIN);

        // query whether or not the row has already been processed
        if ($this->storeViewHasBeenProcessed($pk, $storeViewCode)) {
            // log a message
            $this->getSystemLogger()->warning(
                $this->getSubject()->appendExceptionSuffix(
                    sprintf(
                        'Attributes for %s "%s" + store view code "%s" has already been processed',
                        $this->getPrimaryKeyColumnName(),
                        $pk,
                        $storeViewCode
                    )
                )
            );

            // return immediately
            return;
        }

        // load the store ID, use the admin store if NO store view code has been set
        $storeId = $this->getSubject()->getRowStoreId(StoreViewCodes::ADMIN);

        // load the image attribute
        $attribute = $this->getEavAttributeByAttributeCode('image');

        // remove the image if one exists
        if ($value = $this->loadVarcharAttribute($pk, $attribute[MemberNames::ATTRIBUTE_ID], $storeId)) {
            $this->deleteVarcharAttribute(array(MemberNames::VALUE_ID => $value[MemberNames::VALUE_ID]));
        }
    }
1315659
public function setResult($result, $data = null)
    {
        if (null === $result) {
            return $this;
        }

        if (is_numeric($result)) {
            if ($result > 1000) {
                $result = ResultException::factory($result, $data);
            } else {
                $result = new static::$resultClass((int) $result, $data);
            }
        } elseif ($result instanceof ResultException) {
            // continue
        } elseif (is_array($result) && isset($result[self::RESULT_P_GLOBAL_CODE])) {
            $result = ResultException::factory($result[self::RESULT_P_GLOBAL_CODE], $result[self::RESULT_P_DATA]);
        } else {
            $result = new ResultException(ResultException::E_INTERNAL, $result);
        }

        if (!empty($data)) {
            $result->addData($data);
        }

        $this->result = $result;
        $this->setData(self::P_RESULT, [
            self::RESULT_P_GLOBAL_CODE => $result->getGlobalCode(),
            self::RESULT_P_DATA        => $result->getData(),
        ]);

        return $this;
    }
814626
protected function setResultMethod()
    {
        if (!empty($this->arExistIDList) && in_array($this->sExternalID, $this->arExistIDList)) {
            $this->setUpdatedResult();

            return;
        }

        $this->setCreatedResult();
    }
122687
private function loadResults($my_std_class)
    {
        if(property_exists($my_std_class->table,'row'))
        {
            foreach ($my_std_class->table->row as $row)
            {
                $this->result->push($this->convertToStdClass($row));
            }
        }

    }
1072598
private function applyTransformersToResult(Result $result): Result
    {
        return empty($result->getSubresults())
            ? Result::create(
                $result->getQueryUUID(),
                $result->getTotalItems(),
                $result->getTotalHits(),
                $result->getAggregations(),
                $result->getSuggests(),
                $this
                    ->transformer
                    ->fromItems(
                        $result->getItems()
                    )
            )
            : Result::createMultiResult(
                array_map(function (Result $subresult) {
                    return $this->applyTransformersToResult($subresult);
                }, $result->getSubresults())
            );
    }
733576
public static ResultMap getResultMap(Configuration configuration,Class<?> entityClass) {
        List<ResultMapping> resultMappings = new ArrayList<ResultMapping>();
        
        Set<ColumnMapper> entityClassColumns = EntityHelper.getEntityMapper(entityClass).getColumnsMapper();
        for (ColumnMapper entityColumn : entityClassColumns) {
            ResultMapping.Builder builder = new ResultMapping.Builder(configuration, entityColumn.getProperty(), entityColumn.getColumn(), entityColumn.getJavaType());
            if (entityColumn.getJdbcType() != null) {
                builder.jdbcType(entityColumn.getJdbcType());
            }

            List<ResultFlag> flags = new ArrayList<ResultFlag>();
            if (entityColumn.isId()) {
                flags.add(ResultFlag.ID);
            }
            builder.flags(flags);
            builder.lazy(false);
            resultMappings.add(builder.build());
        }
        ResultMap.Builder builder = new ResultMap.Builder(configuration, "BaseResultMap", entityClass, resultMappings, true);
        return builder.build();
    }
924155
def add_result(self, content_id, content, **kwargs):
        """""""
        result_object = self.ResultClass(content_id, self.name, self.version,
                                         formats.JSON, content, **kwargs)
        self.results.append(result_object)
        return
1243285
public function addSqlResultSetMapping(array $resultMapping)
    {
        if (!isset($resultMapping['name'])) {
            throw MappingException::nameIsMandatoryForSqlResultSetMapping($this->name);
        }

        if (isset($this->sqlResultSetMappings[$resultMapping['name']])) {
            throw MappingException::duplicateResultSetMapping($this->name, $resultMapping['name']);
        }

        if (isset($resultMapping['entities'])) {
            foreach ($resultMapping['entities'] as $key => $entityResult) {
                if (!isset($entityResult['entityClass'])) {
                    throw MappingException::missingResultSetMappingEntity($this->name, $resultMapping['name']);
                }

                $entityResult['isSelfClass'] = false;
                if ($entityResult['entityClass'] === '__CLASS__') {

                    $entityResult['isSelfClass'] = true;
                    $entityResult['entityClass'] = $this->name;

                }

                $entityResult['entityClass'] = $this->fullyQualifiedClassName($entityResult['entityClass']);

                $resultMapping['entities'][$key]['entityClass'] = ltrim($entityResult['entityClass'], '\\');
                $resultMapping['entities'][$key]['isSelfClass'] = $entityResult['isSelfClass'];

                if (isset($entityResult['fields'])) {
                    foreach ($entityResult['fields'] as $k => $field) {
                        if (!isset($field['name'])) {
                            throw MappingException::missingResultSetMappingFieldName($this->name, $resultMapping['name']);
                        }

                        if (!isset($field['column'])) {
                            $fieldName = $field['name'];
                            if (strpos($fieldName, '.')) {
                                list(, $fieldName) = explode('.', $fieldName);
                            }

                            $resultMapping['entities'][$key]['fields'][$k]['column'] = $fieldName;
                        }
                    }
                }
            }
        }

        $this->sqlResultSetMappings[$resultMapping['name']] = $resultMapping;
    }
51980
private function renderResult()
    {
        /* @var ResultEvent $resultEvent */
        $results = array();

        $file = static::getCacheFileName();
        if (!file_exists($file)) {
            throw new \RuntimeException(sprintf(
                'Unknown PhpSpec results'
            ));
        }

        $data = Filesystem::create()->unserialize($file);

        // processing succeed first
        foreach ($data as $resultEvent) {
            $file = $resultEvent->getArgument('file');
            $failedKey = md5($file);
            if ($resultEvent->isSucceed()) {
                if (isset($this->failed[$failedKey])) {
                    unset($this->failed[$failedKey]);
                }
            }
        }

        foreach ($data as $resultEvent) {
            $file = $resultEvent->getArgument('file');
            $failedKey = md5($file);
            if (!$resultEvent->isSucceed()) {
                $this->failed[$failedKey] = $resultEvent;
                $results[] = $resultEvent;
            }
        }

        return $results;
    }
204708
protected function collectionFromResult($result)
    {
        // If we have one result which is not an assoc array, make it the first element of an array for the
        // collectionFromResult function so we always return a collection from filter
        if ((bool) count(array_filter(array_keys($result), 'is_string'))) {
            $result = [$result];
        }

        $class = $this->class;
        $collection = [];

        foreach ($result as $r) {
            $collection[] = new $class($this->connection, $r);
        }

        return $collection;
    }