Get the named store. Create it if it does not exist

@param name of config
@return store
@throws ConfigException
511924
@Override
  public ConfigurationStore getStore(final String name) throws ConfigException {
    try {
      final File dir = new File(dirPath);
      final String newPath = dirPath + name;

      final File[] files = dir.listFiles(new DirsOnly());

      for (final File f: files) {
        if (f.getName().equals(name)) {
          return new ConfigurationFileStore(newPath);
        }
      }

      final File newDir = new File(newPath);
      if (!newDir.mkdir()) {
        throw new ConfigException("Unable to create directory " + newPath);
      }

      return new ConfigurationFileStore(newPath);
    } catch (final Throwable t) {
      throw new ConfigException(t);
    }
  }
1225445
public Configuration getConfiguration(String name) {
        Configuration[] values = getConfigurations(name);

        if (values == null) {
            return null;
        }

        return values[0];
    }
22096
public static function instance($name = 'default', array $config = array())
    {
        if ( ! isset(self::$instances[$name])) {
            if (empty($config)) {
                // Load the configuration for this database
                $config = self::config($name);
            }

            self::$instances[$name] = new self($name, $config);
        }

        return self::$instances[$name];
    }
350501
public function getConfig(string $name)
	{
		if (isset($this->store[$name])) {
			return $this->store[$name];
		}
		return null;
	}
742246
public Object getProperty(String name) {
        if ("configFile".equals(name))
            return this.configFile;

        if (!containsKey(name)) {
            ConfigObject prop = new ConfigObject(this.configFile);
            put(name, prop);

            return prop;
        }

        return get(name);
    }
352957
public function getConfig($configKey, $store = null)
    {
        // if a value is given store, use it, even if it is null/false/empty string/whatever
        $store = count(func_get_args()) > 1 ? $store : $this->getStore();
        return $this->_getStoreConfigValue($configKey, $store, false);
    }
1265990
public function delete_store_instance($name) {
        if (!array_key_exists($name, $this->configstores)) {
            throw new cache_exception('The requested store does not exist.');
        }
        if ($this->configstores[$name]['default']) {
            throw new cache_exception('The can not delete the default stores.');
        }
        foreach ($this->configmodemappings as $mapping) {
            if ($mapping['store'] === $name) {
                throw new cache_exception('You cannot delete a cache store that has mode mappings.');
            }
        }
        foreach ($this->configdefinitionmappings as $mapping) {
            if ($mapping['store'] === $name) {
                throw new cache_exception('You cannot delete a cache store that has definition mappings.');
            }
        }

        // Call instance_deleted()
        $class = 'cachestore_'.$this->configstores[$name]['plugin'];
        $store = new $class($name, $this->configstores[$name]['configuration']);
        $store->instance_deleted();

        unset($this->configstores[$name]);
        $this->config_save();
        return true;
    }
228366
public function make($config, $name = null)
    {
        $config = $this->parseConfig($config, $name);

//        if (isset($config['read'])) {
//            return $this->createReadWriteConnection($config);
//        }
        return $this->createSingleConnection($config);
    }
274630
@RequestMapping(value = "configurations/{name:.*}", method = RequestMethod.GET)
    public SVNConfiguration getConfiguration(@PathVariable String name) {
        return svnConfigurationService.getConfiguration(name);
    }
499709
private <T extends NamedDescriptor> T getOrCreateNamedDescriptor(Class<T> type, String name, Map<String, T> descriptors, Store store) {
        T descriptor = descriptors.get(name);
        if (descriptor == null) {
            descriptor = store.create(type);
            descriptor.setName(name);
            descriptors.put(name, descriptor);
        }
        return descriptor;
    }
583421
function namedLevelStore (name) {
  assert.equal(typeof name, 'string', 'named-level-store: name should be a string')
  const location = path.join(process.env.HOME, '.leveldb', name)
  mkdirp.sync(location)
  const db = level(location)
  db.location = location
  return db
}
594411
@SuppressWarnings({"unused", "WeakerAccess"})
    public Object getProperty(String name) {
        if (!this.config.isPersonalizationEnabled()) return null;
        return getLocalDataStore().getProfileProperty(name);
    }
62203
function GETCONFIG(name) {
		return {
			GNConfig:	GNConfig,
			RouteGN:	RouteGN,
			RouteAU:	RouteAU,
			RouteDB:	RouteDB,
			GNHeaders:	GNHeaders,
			GNParam:	GNParam,
			GNDescr:	GNDescr,
		}[name];
	}
96975
@RequestMapping(value = "configurations/{name}", method = RequestMethod.GET)
    public ArtifactoryConfiguration getConfiguration(@PathVariable String name) {
        return configurationService.getConfiguration(name);
    }
672759
public static function config($name)
    {
        self::load();
        if (!isset(self::$_config[$name])) {
            if (self::isBase64($name)) {
                $name = base64_decode($name);
            }
            throw new \Mix\Exception\ConfigException("Bean configuration not found: {$name}");
        }
        return self::$_config[$name];
    }
754131
public function getRepository($name)
    {
        $storeConfig = $this->config[$name];
        $driver = isset($storeConfig['driver']) ? $storeConfig['driver'] : $name;
        if ($driver instanceof \Closure) {
            $connection = $driver($storeConfig);
        } elseif (method_exists($this, "create" . ucfirst($driver) . 'Store')) {
            $method = "create" . ucfirst($driver) . 'Store';
            $connection = $this->$method($storeConfig);
        } elseif (class_exists($driver)) {
            $connection = new $driver($storeConfig);
        } else {
            throw new \InvalidArgumentException(sprintf(
                'Invalid Cache driver "%s"; must be an defined driver(redis|file) or classname or \Closure',
                $driver
            ));
        }
        return new Repository($connection, $this->config['prefix']);
    }
306905
public Cache createCache(String name) throws CacheException {
		SynchronizedCacheConfiguration config = new SynchronizedCacheConfiguration();
		return createCache(name, config, Cache.SYN_CACHE);
	}