Get all the objects returned in this response.
If a type is provided will be converted to the supplied class using the convert api.

@param string $type

@return \Riak\Client\Core\Query\RiakList
481883
public function getValues($type = null)
    {
        if ($type == null) {
            return $this->values;
        }

        $converter  = $this->converterFactory->getConverter($type);
        $resultList = [];

        foreach ($this->values as $riakObject) {
            $reference = new RiakObjectReference($riakObject, $this->location, $type);
            $converted = $converter->toDomain($reference);

            $resultList[] = $converted;
        }

        return new DomainObjectList($resultList);
    }
1209253
public function getClasses($type)
    {
        if (!is_string($type) || !isset($this->algos[$type])) {
            throw new \InvalidArgumentException();
        }
        return $this->algos[$type];
    }
116780
public function getTypeClass($type)
    {
        if (isset($this->types[$type])) {
            return $this->types[$type];
        }

        if (\class_exists($type)) {
            return $type;
        }

        return null;
    }
415225
public function getBodyByType($type)
    {
        if (isset($this->bodyList[$type])) {
            return $this->bodyList[$type];
        }
        if (isset($this->bodyList['*/*'])) {
            return $this->bodyList['*/*'];
        }

        throw new \InvalidArgumentException(\sprintf('No body found for type "%s"', $type));
    }
7555
public static function items($type)
	{
		if(!isset(self::$_items[$type]))
			self::loadItems($type);
		return self::$_items[$type];
	}
1305659
public function getNewType($type = null)
    {
        $className = $this->getTypeClass($type);
        /** @var GenericType $object */
        $object = new $className();
        $object->setManager($this);

        return $object;
    }
936729
private function getClass($type)
    {
        $collType = \SwaggerValidator\Common\CollectionType::getInstance();
        $class    = $collType->get($type);

        if (empty($class)) {
            $e = new \SwaggerValidator\Exception('Cannot retrieve the callable for this type : ' . $type);
            $e->setFile(__METHOD__);
            $e->setLine(__LINE__);
            throw $e;
        }

        return $class;
    }
141367
public function get( $type = null ) 
	{
		if ( is_null( $type ) )
		{
			return $this->assets;
		}
		
		if ( !isset( $this->assets[$type] ) )
		{
			return array();
		}
		
		return $this->assets[$type];
	}
538281
public function returnType($type = null)
  {
    if (null === $type)
    {
      return $this->responseConfig['returnType'];
    }

    $this->responseConfig['returnType'] = $type;

    return $this;
  }
601589
public static function getInstance($type)
  {
    $type = strtolower(preg_replace('/[^A-Z0-9_]/i', '', $type));

    if ( !isset(self::$instances[$type]) ){
      $class = __NAMESPACE__ . '\\'.ucfirst($type).'Format';
      
      if ( !class_exists($class) ){
        throw new \RuntimeException('Unable to read Registry/Format class ('.$type.')');
      }
      
      self::$instances[$type] = new $class;
    }
    
    return self::$instances[$type];
  }
126592
private function getClientInternal($type = null) {
		if ($type != null) {
			if (isset($this->clients[$type])) {
				return $this->clients[$type];
			} else {
				throw new \Exception("No http client with type '$type' found.");
			}
		} else {
			foreach ($this->clients as $client) {
				if ($client->isSupported()) {
					return $client;
				}
			}
			throw new \Exception('No supported http client found.');
		}
	}
996465
public static function getInstance($type)
    {
        self::checkType($type);

        if (!isset(self::$instances[$type])) {
            self::$instances[$type] = new \Tx_Oelib_Session($type);
        }

        return self::$instances[$type];
    }
100205
private static function getClassByType($type)
    {
        if (!isset(self::$types[$type])) {
            throw new UnknownMessageException(
                'Unable to parse message because type ('.$type.')'
                .' is not mapped.'
            );
        }

        return self::$types[$type];
    }
1122222
private static function getClass($type)
    {
        if (!\array_key_exists($type, self::$types)) {
            throw new \RuntimeException('invalid type');
        }

        return self::$types[$type];
    }
1112694
public static function get($type)
    {
        $instance = null;

        switch ($type) {

            case 'IM/Send':
                $instance = new SendService();
                break;

            case 'IM/Status':
                $instance = new StatusService();
                break;

            case 'TFA/Request':
                $instance = new RequestService();
                break;

            case 'TFA/Validate':
                $instance = new ValidateService();
                break;

            default:
                throw new \Exception("Error - Unknow service", 1);

        }
        return $instance;
    }
249788
public static function get($type)
    {
        if (!array_key_exists($type, self::$endpoints)) {
            throw new \RuntimeException('Endpoint does not exist.');
        }

        return new self::$endpoints[$type]();
    }
1300596
public function get(string $type): array
    {
        try {
            return $this->converters[$this->resolveType($type)];
        } catch (\Throwable $t) {
            throw new InvalidTypeConverterException(
                sprintf('Invalid converter type `%s`.', $type)
            );
        }
    }