Return options for Paginator component

@param array|string $excludeFields List of fields for excluding
from result
@return array Return array options for Paginator component.
187125
public function getPaginateOptions($excludeFields = null) {
		$page = 1;
		$limit = 20;
		$fields = $this->getListLocalFields($excludeFields);
		$order = $this->getOrderFiled();
		$contain = $this->getListContain('Subordinate');
		$result = compact(
			'page',
			'limit',
			'fields',
			'order',
			'contain'
		);

		return $result;
	}
426755
public static function getFieldOptions($field, $optionKey = false)
    {
        if ($optionKey) {
            return static::$_classFields[get_called_class()][$field][$optionKey];
        } else {
            return static::$_classFields[get_called_class()][$field];
        }
    }
1096352
protected function getFilteredFieldNames(array $exclude)
    {
        $fieldNames = $this->getFieldNames(true);
        $result     = [];
        foreach ($fieldNames as $fieldName) {
            if (!in_array($fieldName, $exclude)) {
                $result[] = $fieldName;
            }
        }
        return $result;
    }
291320
public function getParamsFilters($additionalFields = [])
    {
        if (is_array($additionalFields) && !empty($additionalFields))
        {
            $this->filterParams = array_merge_recursive($this->filterParams, $additionalFields);
        }

        return $this->filterParams;
    }
89733
def get_filter_fields(self, exclude=None):
        

        exclude_set = set(self.exclude)
        if exclude:
            exclude_set = exclude_set.union(set(exclude))

        return [name for name in self.fields
                if name not in exclude_set]
603944
public static function getList($excludeId = 0)
    {
        $list = [];
        $query = self::find()->orderBy('position DESC, title');

        if (!empty($excludeId)) {
            $query->where('`id` != :excludeId', ['excludeId' => $excludeId]);
        }

        $models = $query->all();

        foreach ($models as $model) {
            $list[$model->id] = $model->title;
        }

        return $list;
    }
1002850
public function getOptions()
    {
        $options = [
            'name'     => $this->name,
            'sparse'   => is_bool($this->sparse) ? $this->sparse : false,
            'dropDups' => $this->dropDuplicates,
            'unique'   => $this->unique
        ];

        if (is_array($this->sparse)) {
            $options['partialFilterExpression'] = $this->sparse;
        }

        return $options;
    }
50141
public static function getAll( $prefix = NULL, $excludePrefix = NULL )
	{
		$prefix	= strtoupper( $prefix );
		$length	= strlen( $prefix );
		if( $length	< 2 )
			throw new InvalidArgumentException( 'Prefix "'.$prefix.'" is to short.' );
		$map	= get_defined_constants();
		if( $prefix ){
			foreach( $map as $key => $value )
			{
				if( $key[0] !== $prefix[0] )
					unset( $map[$key] );
				else if( $key[1] !== $prefix[1] )
					unset( $map[$key] );
				else if( substr( $key, 0, $length ) !== $prefix )
					unset( $map[$key] );
#				remark( $prefix." - ".$key." - ".(int)isset( $map[$key] ) );
			}
		}
		if( $excludePrefix ){
			if( substr( $excludePrefix, 0, $length ) !== $prefix )
				$excludePrefix	= $prefix.$excludePrefix;
			foreach( $map as $key => $value ){
				if( substr( $key, 0, strlen( $excludePrefix ) ) === $excludePrefix )
					unset( $map[$key] );
			}
		}
		return $map;
	}
239925
private function getExcludedRoutes()
    {
        $result = $this->excludedRoutes;
        $resolver = new \Resolver($this->url);

        $result[] = [
            'extension' => $resolver->getExtensionFromURL(),
            'module' => $resolver->getModule(),
            'action' => $resolver->getAction(),
        ];

        return $result;
    }
1001385
public function groupBy($columns, array $excludeColumns = [])
    {
        $groupedData = [];
        $statsTable = $this->build();

        foreach ($statsTable->getData() as $line) {
            $key = join(
                '-_##_-',
                array_map(
                    function ($c) use ($line) {
                        return $line[$c];
                    },
                    $columns
                )
            );

            $groupedData[$key][] = $line;
        }

        $filterLine = function ($line) use ($excludeColumns) {
            foreach ($excludeColumns as $c) {
                unset($line[$c]);
            }

            return $line;
        };

        $headers = $filterLine(
            array_map(
                function (StatsColumnBuilder $c) {
                    return $c->getHeaderName();
                },
                $this->columns
            )
        );
        $formats = $filterLine(
            array_map(
                function (StatsColumnBuilder $c) {
                    return $c->getFormat();
                },
                $this->columns
            )
        );
        $aggregations = $filterLine(
            array_map(
                function (StatsColumnBuilder $c) {
                    return $c->getAggregation();
                },
                $this->columns
            )
        );
        $metaData = $filterLine(
            array_map(
                function (StatsColumnBuilder $c) {
                    return $c->getMetaData();
                },
                $this->columns
            )
        );

        $data = [];

        foreach ($groupedData as $lines) {
            $tmpAggregations = $aggregations;
            // Add static aggragation for group by fields
            foreach ($columns as $column) {
                $oneLine = current($lines);
                $value = $oneLine[$column];
                $tmpAggregations[$column] = new StaticAggregation($value, Format::STRING);
            }

            $tmpTableBuilder = new StatsTableBuilder(
                array_map($filterLine, $lines),
                $headers,
                $formats,
                $tmpAggregations,
                [],
                [],
                null,
                $metaData
            );
            $tmpTable = $tmpTableBuilder->build();
            $data[] = $tmpTable->getAggregations();
        }

        return new StatsTableBuilder(
            $data,
            $headers,
            $formats,
            $aggregations,
            [],
            [],
            null,
            $metaData
        );
    }
429383
public function getFields ($includeInactiveFields = false)
    {
        $fields = array();
        foreach ($this->getChildren(true, $includeInactiveFields) as $component)
            if ($component instanceof Field)
                array_push($fields, $component);
        return $fields;
    }
844972
def get_search_fields(self, exclude=None):
        
        exclude = set(exclude)
        if self.search_fields and len(self.search_fields) > 1:
            exclude = exclude.union(self.search_fields)

        return self.get_filter_fields(exclude=exclude)
1098298
public function process(PaginationInterface $pagination, array $fields)
    {
        $data = array();
        $identifier = array();
        /** @var \SymfonyId\AdminBundle\Model\ModelInterface $record */
        foreach ($pagination as $key => $record) {
            $temp = array();
            $identifier[$key] = $record->getId();

            foreach ($fields as $k => $property) {
                $field = $property;
                $numberFormat = array();
                if (is_array($property)) {
                    $field = $property['field'];
                    $numberFormat = $property['format'];
                }

                $result = MethodInvoker::invokeGet($record, $field);
                if (null !== $result) {
                    if (!empty($numberFormat)) {
                        $result = number_format($result, $numberFormat['decimal'], $numberFormat['decimal_point'], $numberFormat['thousand_separator']);
                    }
                } else {
                    $result = '';
                }

                array_push($temp, $result);
            }

            $data[$key] = $temp;
        }

        $records = new Records();
        $records->setData($data);
        $records->setIdentifier($identifier);

        return $records;
    }
1193439
private static function filterProperties(
        array $excludedNames,
        array $excludedVisibility,
        array $reflectionPropertiesArray
    ) {
        $propertyArray = [];

        /** @var ReflectionProperty $reflectionProperty */
        foreach ($reflectionPropertiesArray as $reflectionProperty) {
            if (self::excludeProperty($excludedNames, $excludedVisibility, $reflectionProperty)) {
                continue;
            }

            $reflectionProperty->setAccessible(true);
            $propertyArray[] = $reflectionProperty->getName();
        }

        return $propertyArray;
    }
291214
public function getMixableMethods($exclude = array())
    {
        $methods = parent::getMixableMethods($exclude);

        if($this->isSupported())
        {
            foreach($this->__actions as $action) {
                $methods[$action] = $this;
            }
        }

        return $methods;
    }
853582
protected function getBottomPositionValue($exclude = null)
    {
        $item = $this->getBottomItem($exclude);

        if ( ! $item) return null;

        return $item->getListifyPosition();
    }
973232
private function prepareFields(array $fields)
    {
        $include = null;
        foreach ($fields as $key => $type) {
            $type = (bool) $type;
            if (null === $include) {
                $include = $type;
            }
            if ($type !== $include) {
                PersisterException::badRequest('Field projection mismatch. You cannot both exclude and include fields.');
            }
            $fields[$key] = $type;
        }
        return [$fields, $include];
    }