Returns a boolean reflecting whether or not the database and collection are defined in the config
@param string $storeName
@param string $pod
@return bool
15618
public function isPodWithinStore($storeName,$pod)
    {
        return (array_key_exists($storeName,$this->podConnections)) ? array_key_exists($pod,$this->podConnections[$storeName]) : false;
    }
989277
public function has($itemName)
    {
        return array_key_exists($itemName, $this->store)
            && isset($this->store[$itemName]['lookupType']);
    }
686213
public function useDatabase(string $dbName): bool
    {
        $sql = sprintf('USE %s;', $this->quoter->quoteName($dbName));
        $result = $this->db->exec($sql);

        return (bool)$result;
    }
861371
public function has($key)
    {
        $keyExp = explode('.', $key);

        if ($this->cache->has($key))
        {
            return true;
        }

        $row = $this->database
            ->table($this->config['db_table'])
            ->where('setting_key', $keyExp[0])
            ->first(['setting_value']);

        if ( ! is_null($row))
        {
            $setting_value = json_decode($row->setting_value, true);

            array_shift($keyExp);

            return multi_key_exists($keyExp, $setting_value);
        }

        return false;
    }
61615
public function get(string $storage_name, string $key = '')
    {
        // Calls only with app name indicates, that the complete app config is requested
        if (empty($key) && !empty($this->storage[$storage_name])) {
            return $this->storage[$storage_name];
        }

        // Calls with app and key are normal cfg requests
        if (!empty($key)) {

            if (!isset($this->storage[$storage_name]->{$key})) {
                Throw new ConfigException(sprintf('Config "%s" of app "%s" does not exist.', $key, $storage_name));
            }

            return $this->storage[$storage_name]->{$key};
        }

        // All other will result in an error exception
        Throw new ConfigException(sprintf('Config "%s" of app "%s" not found.', $key, $storage_name));
    }
368648
protected function checkForStaticCache(string $storeKey): bool
    {
        return !empty(self::$STATIC_CACHE)
               &&
               \array_key_exists($storeKey, self::$STATIC_CACHE)
               &&
               \array_key_exists($storeKey, self::$STATIC_CACHE_EXPIRE)
               &&
               \time() <= self::$STATIC_CACHE_EXPIRE[$storeKey];
    }
475373
public function isSandboxModeSet($store = null)
    {
        return $this->getScopeConfig()->isSetFlag(
            self::XML_PATH_SANDBOX_MODE,
            ScopeInterface::SCOPE_STORE,
            $store
        );
    }
65302
private function getSpecificationTypes(Array $specifications, $podName=null)
    {
        $types = [];
        foreach($specifications as $spec){

            if(!empty($podName)){
                if($spec['from'] !== $podName){
                    continue; // skip this view spec if it isnt for the collection
                }
            }

            if(is_array($spec[_ID_TYPE])){
                $types = array_merge($spec[_ID_TYPE], $types);
            } else {
                $types[] = $spec[_ID_TYPE];
            }
        }
        return $types;
    }
1311650
public static boolean getBoolean(IPreferenceStore store, String preferenceContainerID, String preferenceName) {
		return store.getBoolean(getPrefixedKey(preferenceContainerID, preferenceName));
	}
964106
protected function isDatabaseConfigured(\OxidEsales\Eshop\Core\ConfigFile $config)
    {
        $isValid = true;

        // If the shop has not been configured yet the hostname has the format '<dbHost>'
        if (false  !== strpos($config->getVar('dbHost'), '<')) {
            $isValid = false;
        }

        return $isValid;
    }
1146443
protected function isExcludedFromDb($basename)
    {
        if (in_array(mb_strtolower($basename), $this->excludeFromDb)) {
            return true;
        }

        return Helper::startsWith($basename, '.') || Helper::startsWith($basename, '_');

    }
1053262
public function getDataSourceForPod($storeName, $podName)
    {
        if(isset($this->podConnections[$storeName]) && isset($this->podConnections[$storeName][$podName]))
        {
            return $this->podConnections[$storeName][$podName];
        }
        throw new \Tripod\Exceptions\ConfigException("'{$podName}' not configured for store '{$storeName}'");
    }
540078
public function doRequestSync(array $request, $storeId)
    {
        $requestUrl = self::ENDPOINT_TERMINAL_CLOUD_LIVE;
        if ($this->_helper()->getConfigDataDemoMode($storeId)) {
            $requestUrl = self::ENDPOINT_TERMINAL_CLOUD_TEST;
        }

        $apiKey = $this->_helper()->getPosApiKey($storeId);
        $timeout = $this->_helper()->getConfigData('timeout', 'adyen_pos_cloud', $storeId);
        $response = $this->doRequestJson($request, $requestUrl, $apiKey, $storeId, $timeout);
        return json_decode($response, true);
    }
1250758
public function isCollectionValuedAssociation($fieldName) : bool
    {
        return isset($this->associationMappings[$fieldName]['type']) &&
            $this->associationMappings[$fieldName]['type'] === 'many';
    }
1251985
public function getTypesInViewSpecifications($storeName, $pod=null)
    {
        return array_unique($this->getSpecificationTypes($this->getViewSpecifications($storeName), $pod));
    }
231737
public function getTableSpecification($storeName, $tid)
    {
        if (isset($this->tableSpecs[$storeName]) && isset($this->tableSpecs[$storeName][$tid]))
        {
            return $this->tableSpecs[$storeName][$tid];
        }
        else
        {
            return null;
        }
    }
217758
public static function selectDatabase($key) {
		if (self::$currentDB===$key) return false;
		self::configureFacadeWithToolbox(self::$toolboxes[$key]);
		self::$currentDB = $key;
		return true;
	}