Return additional information for the result.

@param  \Nuwave\Lighthouse\Events\BuildExtensionsResponse  $buildExtensionsResponse
@return \Nuwave\Lighthouse\Execution\ExtensionsResponse
972590
public function handleBuildExtensionsResponse(BuildExtensionsResponse $buildExtensionsResponse): ExtensionsResponse
    {
        $requestEnd = Carbon::now();
        $requestEndPrecise = $this->getTime();

        return new ExtensionsResponse(
            'tracing',
            [
                'version' => 1,
                'startTime' => $this->requestStart->format(Carbon::RFC3339_EXTENDED),
                'endTime' => $requestEnd->format(Carbon::RFC3339_EXTENDED),
                'duration' => $this->diffTimeInNanoseconds($this->requestStartPrecise, $requestEndPrecise),
                'execution' => [
                    'resolvers' => $this->resolverTraces,
                ],
            ]
        );
    }
1030439
public function data($buildId)
    {
        $response = new JsonResponse();
        $build = BuildFactory::getBuildById($buildId);

        if (!$build) {
            $response->setResponseCode(404);
            $response->setContent(array());
            return $response;
        }

        $response->setContent($this->getBuildData($build));
        return $response;
    }
480854
public function getReferencedObject(Project $fallback = null)
    {
        $project = $fallback ?? $this->project;

        if ($this->refid === null) {
            throw new BuildException("No reference specified");
        }
        $o = $project->getReference($this->refid);
        if ($o === null) {
            throw new BuildException("Reference {$this->refid} not found.");
        }

        return $o;
    }
396087
public ProcessorDef getExtends() throws BuildException {
    if (this.extendsRef != null) {
      final Object obj = this.extendsRef.getReferencedObject(getProject());
      if (!getClass().isInstance(obj)) {
        throw new BuildException("Referenced object " + this.extendsRef.getRefId() + " not correct type, is "
            + obj.getClass().getName() + " should be " + getClass().getName());
      }
      return (ProcessorDef) obj;
    }
    return null;
  }
778562
public function getExtension()
    {
        $extensionName  = $this->getExtensionName();
        if (null === $extensionName || false === $extensionName) {
            return null;
        }
        
        $moufRefExtension = new MoufReflectionExtension($extensionName);
        return $moufRefExtension;
    }
732383
def extend(self, builder):
        
        for extension in self._extensions:
            getattr(self, '_add_%s' % extension)(builder)

        builder.on_delete(self._on_delete)
1231022
private function buildResponse(Event $event)
    {
        $request = $event->getData()['request'];
        $response = $event->getData()['response'];

        if ('xml' === Configure::read('ApiRequest.responseType')) {
            $response->withType('xml');
        } else {
            $response->withType('json');
        }

        $response->cors($request)
                ->allowOrigin(Configure::read('ApiRequest.cors.origin'))
                ->allowMethods(Configure::read('ApiRequest.cors.allowedMethods'))
                ->allowHeaders(Configure::read('ApiRequest.cors.allowedHeaders'))
                ->allowCredentials()
                ->maxAge(Configure::read('ApiRequest.cors.maxAge'))
                ->build();

        return true;
    }
35389
public static function getTypeByExtension(ExtensionContract $extension) : string {
        if($extension->isRequired()) {
            return self::TYPE_CORE;
        }

        return self::TYPE_ADDITIONAL;
    }
203987
public static function getExtensionVersion($extensionKey)
    {
        $version = null;
        /** @var ObjectManager $om */
        $om = GeneralUtility::makeInstance(ObjectManager::class);
        /** @var ListUtility $listUtility */
        $listUtility = $om->get(ListUtility::class);

        $packages = $listUtility->getAvailableExtensions();

        if (array_key_exists($extensionKey, $packages)) {
            /** @var Package $ext */
            $package = $listUtility->getExtension($extensionKey);

            if ($package instanceof Package) {
                $version = $package->getValueFromComposerManifest('version');
            }
        }

        return $version;
    }
582203
private function preBuild($result)
    {
        $container = $this->preBuild->handle(new BuilderContainer($this, $result));

        if ($container instanceof BuilderContainer) {
            return $container->getValue();
        }

        throw new \RuntimeException();
    }
755255
public function build(array $buildSubject) {

        $data = [
            'successUrl' => $this->configProvider->getSuccessUrl(),
            'failUrl'  => $this->configProvider->getFailUrl(),
        ];

        return $data;
    }
872214
public function addExtension($extension = null)
    {
        if ($extension == null) {
            return $this->twigEnvironment->addExtension($this->twigDebug());
        }

        return $this->twigEnvironment->addExtension($extension);
    }
225852
public function build(): SearchInResponseBodyRequest
	{
		$instance = new SearchInResponseBodyRequest();
		if ($this->requestId === null) {
			throw new BuilderException('Property [requestId] is required.');
		}
		$instance->requestId = $this->requestId;
		if ($this->query === null) {
			throw new BuilderException('Property [query] is required.');
		}
		$instance->query = $this->query;
		$instance->caseSensitive = $this->caseSensitive;
		$instance->isRegex = $this->isRegex;
		return $instance;
	}
516239
def build_extension(self, ext):
        
        try:
            build_ext.build_ext.build_extension(self, ext)
        except (
            distutils.errors.CCompilerError,
            distutils.errors.DistutilsExecError,
            distutils.errors.DistutilsPlatformError,
            ValueError,
        ):
            raise BuildFailed()
987210
private function _get_buildprop()
    {
        if ($this->_buildprop === null) {
           if (!CommonFunctions::rfts('/system/build.prop', $this->_buildprop, 0, 4096, false)) {
               CommonFunctions::rfts('/system//build.prop', $this->_buildprop, 0, 4096, false); //fix some access issues
           }
        }

        return $this->_buildprop;
    }
862424
public static function buildMessage(ResultException $result)
    {
        $translateKey = self::TRANSLATE_KEY_PREFIX . $result->globalCode;
        $message = self::translate($translateKey);

        return empty($message) ? $result->getAlias() : $message;
    }
717241
private function determineExtension()
    {
        $ext = 'php';
        if (in_array($this->driverClass, $this->extensionToDriver)) {
            $map = array_flip($this->extensionToDriver);
            $ext = $map[$this->driverClass];
        }
        return $ext;
    }