Loads the service data from storage.

@return
The data array, as stored by the ServicesCollector.
347407
protected function loadServiceData() {
    if (!isset($this->serviceData)) {
      $this->serviceData = $this->environment->getStorage()->retrieve('services');
    }

    // Populate the keys, in case analysis crashed.
    $this->serviceData += [
      'primary' => [],
      'all' => [],
    ];

    return $this->serviceData;
  }
237120
public byte []data()
  {
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    
    try {
      toData(bos);
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
    
    return bos.toByteArray();
  }
579755
public function load()
    {
        $data = [];

        $settings = $this->database->select('SELECT * FROM '.$this->table);

        foreach ($settings as $setting) {
            $id = $setting->id;
            $value = $setting->value;

            $decoded = json_decode($value, 1, 512);
            if (is_array($decoded)) {
                $value = $decoded;
            }

            Arr::set($data, $id, $value);
        }

        return $data;
    }
798583
@ReadOperation(produces = {ActuatorMediaType.V2_JSON, "application/vnd.cas.services+yaml", MediaType.APPLICATION_JSON_VALUE})
    public Collection<RegisteredService> handle() {
        return this.servicesManager.load();
    }
411315
public function getData()
    {
        $this->validateParams();

        $data = $this->filter($this->parameters->all());

        $data['service']   = $this->service;
        $data['sign']      = $this->sign($data, $this->getSignType());
        $data['sign_type'] = $this->getSignType();

        return $data;
    }
1015163
public ArrayContainer toArrayContainer() {
    ArrayContainer ac = new ArrayContainer(cardinality);
    ac.loadData(this);
    if (ac.getCardinality() != cardinality) {
      throw new RuntimeException("Internal error.");
    }
    return ac;
  }
58351
public function toArray()
	{
		$list = parent::toArray();

		$list['service.typeid'] = $this->getTypeId();
		$list['service.type'] = $this->getType();
		$list['service.code'] = $this->getCode();
		$list['service.label'] = $this->getLabel();
		$list['service.provider'] = $this->getProvider();
		$list['service.position'] = $this->getPosition();
		$list['service.config'] = $this->getConfig();
		$list['service.status'] = $this->getStatus();

		return $list;
	}
906112
protected function loadService()
    {
        $service = $this->wsdl->getService();
        $this->log('Starting to load service ' . $service->getName());

        $this->service = new Service($this->config, $service->getName(), $this->types, $service->getDocumentation());

        foreach ($this->wsdl->getOperations() as $function) {
            $this->log('Loading function ' . $function->getName());

            $this->service->addOperation(new Operation($function->getName(), $function->getParams(), $function->getDocumentation(), $function->getReturns()));
        }

        $this->log('Done loading service ' . $service->getName());
    }
880692
public function getServiceInstances()
    {
        $instances = [];

        foreach ($this->getServices() as $name => $info) {
            if (!isset($info['type'])) {
                continue;
            }
            $type = $info['type'];
            unset($info['type']);

            $instances[$name] = [
                'type' => $type,
                'options' => $info,
                'instance' => static::loadService($this, $type, $name),
            ];
        }

        return $instances;
    }
519004
public static <T> Collection<T> getServices(Class<T> serviceType) {
        return getServiceProvider().getServices(serviceType);
    }
671114
public function collectData()
    {
        $collectedData = [];

        foreach ($this->dataCollectors as $collector) {
            $collectedData = $collectedData + $collector->collect();
        }

        return $collectedData;
    }
1366857
public byte[] getServiceData()
    {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "getServiceData", this);

        byte[] serviceData = null;

        if (_logFileHeader != null)
        {
            serviceData = _logFileHeader.getServiceData();
        }

        if (tc.isEntryEnabled())
            Tr.exit(tc, "getServiceData", RLSUtils.toHexString(serviceData, RLSUtils.MAX_DISPLAY_BYTES));
        return serviceData;
    }
995825
public MBeanData[] getData()
   {
      MBeanData[] data = new MBeanData[domainData.size()];
      domainData.toArray(data);
      return data;
   }
322018
protected function getStorage()
    {
        if (! $this->storage) {
            $storage = $this->getServiceLocator()->get(Storage::SERVICE_ID);
            if (! $storage instanceof PaginatedStorage) {
                throw new StorageException(__('The storage service provided to store the diagnostic results must be upgraded to support reads!'));
            }
            $this->storage = $storage;
        }
        return $this->storage;
    }
579352
public function getData()
    {
        if ($this->_cache === null) {
            $this->_cache = $this->asArray(); // Throws.
        }

        if ($this->_type !== null) {
            foreach ($this->_cache as &$value) {
                if (is_array($value)) {
                    $value = new $this->_type($value); // Throws.
                }
            }
        }

        return $this->_cache;
    }
143916
private <T> List<T> loadServices(final Class<T> serviceType) {
        List<T> services = new ArrayList<>();
        try {
            for (T t : ServiceLoader.load(serviceType)) {
                services.add(t);
            }
            services.sort(PriorityAwareServiceProvider::compareServices);
            @SuppressWarnings("unchecked")
            final List<T> previousServices = (List<T>) servicesLoaded.putIfAbsent(serviceType, (List<Object>) services);
            return Collections.unmodifiableList(previousServices != null ? previousServices : services);
        } catch (Exception e) {
            Logger.getLogger(PriorityAwareServiceProvider.class.getName()).log(Level.WARNING,
                    "Error loading services of type " + serviceType, e);
            services.sort(PriorityAwareServiceProvider::compareServices);
            return services;
        }
    }
176833
@Override
    public Map<String, String> loadDocStrings(Set<ServiceConfig> serviceConfigs) {
        return serviceConfigs.stream()
                             .flatMap(c -> c.service().as(THttpService.class).get().entries().values().stream())
                             .flatMap(entry -> entry.interfaces().stream().map(Class::getClassLoader))
                             .flatMap(loader -> docstringExtractor.getAllDocStrings(loader)
                                                                  .entrySet().stream())
                             .collect(toImmutableMap(Map.Entry::getKey, Map.Entry::getValue, (a, b) -> a));
    }