Get the response object (if it's not converted do the conversion also).

@return \eZ\Publish\API\Repository\Values\ValueObject
779895
public function getResponseObject()
    {
        if (empty($this->responseObject)) {
            $this->responseObject = $this->convertResponseBodyToObject(
                $this->restDriver->getBody(),
                $this->restDriver->getHeader('content-type')
            );
        }

        return $this->responseObject;
    }
1273105
public function getValue()
    {
        try {
            return JsonValidator::validate($this->value) ? $this->value : '';
        } catch (InvalidArgumentException $e) {
            return $e->getMessage();
        }
    }
106962
protected Object getValue() {
        Object value = this.value;
        if (value == null) {
            this.value = value = fromBinary("value");
        }
        return value;
    }
1308194
public function getValueAttribute()
    {
        if (!isset($this->cachedValue)) {
            $this->cachedValue = $this->getDataTypeRegistry()
                ->getHandlerForType($this->type)
                ->unserializeValue($this->attributes['value']);
        }

        return $this->cachedValue;
    }
774367
protected function getResponseBody() {
        $body = json_decode((string) $this->response->getBody());

        if (json_last_error() !== JSON_ERROR_NONE) {
            throw new InvalidArgumentException('The response body does not contain valid JSON data.');
        } else if (!is_array($body) && !($body instanceof stdClass)) {
            throw new InvalidArgumentException('The response body does not contain a valid JSON array / object.');
        }

        return $body;
    }
1276468
public function index(): HTTPResponse
    {
        $body = null;
        $contentType = $this->getRequest()->getHeader('Content-Type');

        if ($contentType === 'application/json') {
            $body = json_decode($this->getRequest()->getBody(), true);
        } else {
            $body = $this->getRequest()->postVars();
        }

        if (empty($body)) {
            return $this->getErrorResponse(
                'No parameters could be found in request body. Did you correctly set the Content-Type header?',
                500
            );
        }

        // request needs parsed body
        $psrRequest = (new HttpRequestAdapter())->toPsr7($this->getRequest())
            ->withParsedBody($body);
        $psrResponse = new Response();

        $authServer = $this->serverGenerator->getServer();

        try {
            return (new HttpResponseAdapter())
                ->fromPsr7($authServer->respondToAccessTokenRequest($psrRequest, $psrResponse));
        } catch (OAuthServerException $e) {
            return $this->convertResponse($e->generateHttpResponse(new Response()));
        } catch (Exception $e) {
            return $this->getErrorResponse($e->getMessage());
        }
    }
213406
public function getValue()
    {
        $value = $this->getRawValue();
        if (is_array($value)) {
            foreach ($value as $key => $part) {
                $value[$key] = $this->getFilterChain()
                    ->filter($part);
            }
            return $value;
        }
        return $this->getFilterChain()
            ->filter($value);
    }
1218084
function payload()
    {
        if ( $this->IsFault )
        {
            return json_encode( array(
                'result' => null,
                'error' => array( 'faultCode' => $this->FaultCode, 'faultString' => $this->FaultString ),
                'id' => $this->Id ) );
        }
        else
        {
            return json_encode( array(
                'result' => $this->Value,
                'error' => null,
                'id' => $this->Id ) );
        }
    }
925059
public function getResponse()
    {
        $this->execute();
        
        switch ($this->def['dataType']) {
            case 'array':
                $result = static::toArray();
                break;
            case 'object':
            case 'json':
                $result = static::toJson();
                break;
            default:
                $result = $this->getErrorString() ? : $this->responseText;
        }
        
        return $result;
    }
1052908
public function getValue() : ArrayObject
    {
        $this->value = [];
        foreach ((array)$this as $field) {
            $this->value[$field->getName()] = $field->getElement()->getValue();
        }
        return new ArrayObject($this->value);
    }
33523
public function getValue() : ArrayObject
    {
        foreach ((array)$this as $element) {
            if ($element->getElement() instanceof Radio
                && $element->getElement()->checked()
            ) {
                return new class([$element->getElement()->getValue()]) extends ArrayObject {
                    public function __toString() : string
                    {
                        return "{$this[0]}";
                    }
                };
            }
        }
        return new class([$this->value]) extends ArrayObject {
            public function __toString() : string
            {
                return "{$this[0]}";
            }
        };
    }
1089269
function response()
    {
        if (!$this->response) {
            $settings = new DataParseResponsePhp;
            $response = new HttpResponse(
                new BuildHttpResponse( BuildHttpResponse::parseWith($settings) )
            );

            $this->response = $response;
        }

        return $this->response;
    }
202813
protected function _getPriceObject()
    {
        $oPrice = oxNew(\OxidEsales\Eshop\Core\Price::class);

        if ($this->isCalculationModeNetto()) {
            $oPrice->setNettoPriceMode();
        } else {
            $oPrice->setBruttoPriceMode();
        }

        return $oPrice;
    }
819980
public function getRequest()
    {
        if(!$this->_request instanceof ControllerRequestInterface)
        {
            //Setup the request
            $this->_request->url  = $this->getIdentifier();
            $this->_request->user = $this->getUser();

            $this->_request = $this->getObject('lib:controller.request', ObjectConfig::unbox($this->_request));

            if(!$this->_request instanceof ControllerRequestInterface)
            {
                throw new \UnexpectedValueException(
                    'Request: '.get_class($this->_request).' does not implement ControllerRequestInterface'
                );
            }
        }

        return $this->_request;
    }
832486
public function getValue()
    {
        if ( ! $this->isSet() and isset($this->default))
        {
            $this->setValue($this->default, true);
        }

        return $this->value;
    }
717567
protected function convertValue()
    {
        $values = $this->getValue();
        $convertedValues = array();

        if (($values instanceof Collection) || is_array($values)) {
            foreach ($values as $value) {
                if (!is_object($value) || !method_exists($value, 'getId')) {
                    continue;
                }

                $convertedValues[] = $value->getId();
            }
        } elseif (is_object($values) && method_exists($values, 'getId')) {
            $convertedValues[] = $values->getId();
        }

        return $convertedValues;
    }
1228076
public function getValue() : ArrayObject
    {
        $array = [];
        foreach ($this as $value) {
            if ($value instanceof Hidden) {
                continue;
            }
            if ($value->getElement()->checked()) {
                $array[] = $value->getElement()->getValue();
            }
        }
        return new ArrayObject($array);
    }