Convert an item of the array using the converter-map

@param $item

@return mixed
969098
protected function convertItem($item)
    {
        foreach ($item as $key => $value) {
            if (!isset($this->converters[$key])) {
                continue;
            }

            foreach ($this->converters[$key] as $converter) {
                $item[$key] = call_user_func($converter, $item[$key]);
            }
        }

        return $item;
    }
274782
public function get($item)
    {
        $data = $this->getData();

        return empty($data->$item) ? null : $data->$item;
    }
200417
public static function get($item)
    {
        if (isset($_POST[$item])) {
            return $_POST[$item];
        } elseif (isset($_GET[$item])) {
            return $_GET[$item];
        } else {
            return '';
        }
    }
1302729
protected function extractValue($item, $key)
    {
        if (is_object($item)) {
            if (method_exists($item, 'hasMethod') && $item->hasMethod($key)) {
                return $item->{$key}();
            }
            return $item->{$key};
        } else {
            if (array_key_exists($key, $item)) {
                return $item[$key];
            }
        }
    }
43032
protected function getValues($item, array $keys)
    {
        $values = [];
        foreach ($keys as $key) {
            $values[] = Vale::get($item, $key);
        }

        return $values;
    }
82392
public function transformWithRelated($item)
    {
        $transformedItem = $this->getTransformation($item);

        return $this->transformRelated($transformedItem, $item);
    }
951720
public function process($item, callable $next)
    {
        try {
            foreach ($this->mappings as $from => $to) {
                $value = $this->accessor->getValue($item, $from);
                $this->accessor->setValue($item, $to, $value);

                $from = str_replace(['[',']'], '', $from);

                // Check if $item is an array, because properties can't be unset.
                // So we don't call unset for objects to prevent side affects.
                if (is_array($item) && array_key_exists($from, $item)) {
                    unset($item[$from]);
                }
            }
        } catch (NoSuchPropertyException $exception) {
            throw new MappingException('Unable to map item', null, $exception);
        } catch (UnexpectedTypeException $exception) {
            throw new MappingException('Unable to map item', null, $exception);
        }

        return $next($item);
    }
1303872
public static function getValue($item, $key)
    {
        $parts = explode('.', $key);
        $value = $item;
        foreach ($parts as $part) {
            if ($value) {
                if (is($value, 'AnObject')) {
                    $value = $value->get($part);
                } else {
                    $value = is_array($value) ? $value[$part] : $value->$part;
                }
            }
        }

        return $value;
    }
896973
public function transform($item): array
    {
        $analyticsService = app()->make(
            'InetStudio\PollsPackage\Analytics\Contracts\Services\Back\AnalyticsServiceContract'
        );

        return [
            'id' => (int) $item->id,
            'question' => $item->question,
            'votes_count' => $item->votes_count,
            'articles' => view(
                'admin.module.polls.analytics::back.partials.datatables.articles',
                [
                    'items' => $analyticsService->getArticlesWithPoll($item->id),
                ]
            )->render(),
            'results' => view(
                'admin.module.polls.analytics::back.partials.datatables.result',
                [
                    'id' => $item->id,
                ]
            )->render(),
        ];
    }
615502
public function render($item = -1)
	{
		if (!$this->isEnabled()) {
			return;
		}

		return $this->view->make('googlmapper::mapper')
			->withView($this->view)
			->withOptions($this->generateRenderOptions($item))
			->withItems($item > -1 ? [$item => $this->getItem($item)] : $this->getItems())
			->render();
	}
140893
protected function htmlEntityEncode($item)
    {
        if (is_array($item)) {
            array_walk_recursive($item, function (&$value) {
                $value = htmlentities($value);
            });
        } else {
            $item = htmlentities($item);
        }

        return $item;
    }
1214611
public function transformItem($item, $meta = [])
    {
        return $this->getFractalFactory()->makeItem($item, $meta, $this->getTransformer());
    }
57214
protected function convertItems($items)
    {
        $convertedItems = new Collection();

        foreach ($items as $item) {
            $convertedItems->add(new ItemContainer($item));
        }

        return $convertedItems;
    }
1145638
public function isObject($item=null) {
    list($item) = self::_wrapArgs(func_get_args(), 1);
    return self::_wrap(is_object($item));
  }
394777
protected function getItemOptions($item)
    {
        $options = '';
        if ($orderOptions = $this->getItemOrderOptions($item)) {
            foreach ($orderOptions as $_option) {
                if (strlen($options) > 0) {
                    $options .= ', ';
                }
                $options .= $_option['label'].': '.$_option['value'];
            }
        }
        return $options;
    }
951039
protected function recursiveToArray($item)
    {
        if (is_array($item)) {

            foreach ($item as &$subitem) {
                $subitem = $this->recursiveToArray($subitem);
            }

            unset($subitem);

            return $item;
        }

        if ($item instanceof Arrayable) {
            return $item->toArray();
        }

        return $item;
    }
597533
public function spell($item)
    {
        $formatter = new NumberFormatter($this->config['locale'], NumberFormatter::SPELLOUT);

        if (is_int($item)) {
            return $formatter->format($item);
        }

        return preg_replace_callback('/([0-9]+)/', function ($matches) use ($formatter) {
            return $formatter->format($matches[0]);
        }, $item);
    }