Use this API to fetch all the config objects resources that are available on netscaler.
960525
public static configobjects get(nitro_service service) throws Exception{
		configobjects obj = new configobjects();
		configobjects[] response = (configobjects[])obj.get_resources(service);
		return response[0];
	}
569892
public static nshttpprofile[] get(nitro_service service) throws Exception{
		nshttpprofile obj = new nshttpprofile();
		nshttpprofile[] response = (nshttpprofile[])obj.get_resources(service);
		return response;
	}
644827
def get_properties(self):
        # type: () -> dict
        
        # Get service properties
        properties = self.__reference.get_properties()

        # Merge with local properties
        properties.update(self.__properties)

        # Some properties can't be merged
        for key in pelix.constants.OBJECTCLASS, pelix.constants.SERVICE_ID:
            properties[key] = self.__reference.get_property(key)

        # Force the exported configurations
        properties[pelix.remote.PROP_EXPORTED_CONFIGS] = self.configurations

        return properties
602703
static public void loadConfigs(){
        IConfigLoader configLoader;
        Map<String, Object> startupConfig = Config.getInstance().getJsonMapConfig(STARTUP_CONFIG_NAME);
        if(startupConfig ==null || startupConfig.get(CONFIG_LOADER_CLASS) ==null){
            configLoader = new DefaultConfigLoader();
        }else{
            try {
                Class clazz = Class.forName((String) startupConfig.get(CONFIG_LOADER_CLASS));
                configLoader = (IConfigLoader) clazz.getConstructor().newInstance();
            } catch (Exception e) {
                throw new RuntimeException("configLoaderClass mentioned in startup.yml could not be found or constructed", e);
            }
        }
        configLoader.init();
    }
1240500
def resources_of_config(config):
    
    return set(             # unique values
        sum([               # join lists to flat list
            list(value)     # if value is iter (ex: list of resources)
            if hasattr(value, '__iter__')
            else [value, ]  # if value is not iter (ex: model or resource)
            for value in config.values()
        ], [])
    )
610478
public static nsconfig get(nitro_service service) throws Exception{
		nsconfig obj = new nsconfig();
		nsconfig[] response = (nsconfig[])obj.get_resources(service);
		return response[0];
	}
813728
def get_config(self):
        
        data = self.message(MessageType.GET_CONFIG, '')
        return json.loads(data, object_hook=ConfigReply)
1013027
def _get_service_config(self):
        
        key = self._get_or_create_service_key()

        config = {}
        config['service_key'] = [{'name': self.name}]
        config.update(key['entity']['credentials'])

        return config
1154693
def get_config(self):
        
        # Fill this dict with config data
        return {
            'hash_name': self.hash_name,
            'dim': self.dim,
            'bin_width': self.bin_width,
            'projection_count': self.projection_count,
            'normals': self.normals
        }
164491
public Map<String, Object> getAllConfig() {
        Map<String, Object> map = config.getAll();
        map.put("version", version);
        map.put("buildDate", buildDate);
        return map;
    }
274189
def get_resources(resources):  # pylint:disable=too-many-branches
    
    limits = {}
    requests = {}
    if resources is None:
        return None
    if resources.cpu:
        if resources.cpu.limits:
            limits['cpu'] = resources.cpu.limits
        if resources.cpu.requests:
            requests['cpu'] = resources.cpu.requests

    if resources.memory:
        if resources.memory.limits:
            limits['memory'] = '{}Mi'.format(resources.memory.limits)
        if resources.memory.requests:
            requests['memory'] = '{}Mi'.format(resources.memory.requests)

    if resources.gpu:
        if resources.gpu.limits:
            limits[conf.get('K8S_GPU_RESOURCE_KEY')] = resources.gpu.limits
        if resources.gpu.requests:
            requests[conf.get('K8S_GPU_RESOURCE_KEY')] = resources.gpu.requests

    if resources.tpu:
        if resources.tpu.limits:
            limits[conf.get('K8S_TPU_RESOURCE_KEY')] = resources.tpu.limits
        if resources.tpu.requests:
            requests[conf.get('K8S_TPU_RESOURCE_KEY')] = resources.tpu.requests
    return client.V1ResourceRequirements(limits=limits or None, requests=requests or None)
1078757
public static nssavedconfig get(nitro_service service) throws Exception{
		nssavedconfig obj = new nssavedconfig();
		nssavedconfig[] response = (nssavedconfig[])obj.get_resources(service);
		return response[0];
	}
1279356
public static nsrunningconfig get(nitro_service service) throws Exception{
		nsrunningconfig obj = new nsrunningconfig();
		nsrunningconfig[] response = (nsrunningconfig[])obj.get_resources(service);
		return response[0];
	}
1111872
def get_config(self):
        
        # Fill this dict with config data
        return {
            'hash_name': self.hash_name,
            'dim': self.dim,
            'bin_width': self.bin_width,
            'projection_count': self.projection_count,
            'components': self.components
        }
383036
def get_resources(cls):
        """"""
        plural_mappings = resource_helper.build_plural_mappings(
            {}, RESOURCE_ATTRIBUTE_MAP)
        if NEUTRON_VERSION.version[0] <= NEUTRON_NEWTON_VERSION.version[0]:
            attr.PLURALS.update(plural_mappings)
        action_map = {DEVICE: {'get_hosting_device_config': 'GET'}}
        return resource_helper.build_resource_info(plural_mappings,
                                                   RESOURCE_ATTRIBUTE_MAP,
                                                   constants.DEVICE_MANAGER,
                                                   action_map=action_map)
338047
def _retrieve_resources(self, url, class_, full):
        ''''''
        objects_to_return = []
        response = self.session.get(url)
        if response.status_code == 200:
            result = response.json()
            resources = result['results']
            objects_to_return.extend([class_(session=self.session, **resource)
                                      for resource in resources])
            while full and result['next'] is not None:
                response = self.session.get(result['next'])
                if response.status_code == 200:
                    result = response.json()
                    resources = result['results']
                    objects_to_return.extend([class_(session=self.session,
                                                     **resource)
                                              for resource in resources])
                else:
                    raise RuntimeError("Failed downloading data with status {}"
                            ". The response was: '{}'"
                            .format(response.status_code, response.text))
            return objects_to_return
        else:
            raise RuntimeError("Failed downloading data with status {}"
                    ". The response was: '{}'"
                    .format(response.status_code, response.text))
712442
def get_config_object():
    """"""
    global _DEFAULT_CONFIG_WRAPPER
    if _DEFAULT_CONFIG_WRAPPER is not None:
        return _DEFAULT_CONFIG_WRAPPER
    with _DEFAULT_CONFIG_WRAPPER_LOCK:
        if _DEFAULT_CONFIG_WRAPPER is not None:
            return _DEFAULT_CONFIG_WRAPPER
        _DEFAULT_CONFIG_WRAPPER = ConfigWrapper()
        return _DEFAULT_CONFIG_WRAPPER