@param      $varUuid
@param bool $blnCheckExists

@return null|string Return the path of the file, or null if not exists
178774
public static function getPathFromUuid($varUuid, $blnCheckExists = true)
    {
        if (($objFile = \FilesModel::findByUuid($varUuid)) !== null)
        {
            if (!$blnCheckExists)
            {
                return $objFile->path;
            }

            if (file_exists(TL_ROOT . '/' . $objFile->path))
            {
                return $objFile->path;
            }
        }

        return null;
    }
846105
public static function varDump($blnDisplayOutput = true)
    {
        $strToReturn = '';
        foreach (static::$objTimerArray as $objTimer) {
            $strToReturn .= $objTimer->__toString() . "\n";
        }
        if ($blnDisplayOutput) {
            echo nl2br($strToReturn);
            return '';
        } else {
            return $strToReturn;
        }
    }
720023
public function getAltImageUrl($sFilePath, $sFile, $blSSL = null)
    {
        $oConfig = \OxidEsales\Eshop\Core\Registry::getConfig();

        $sAltUrl = $oConfig->getConfigParam('sAltImageUrl');
        if (!$sAltUrl) {
            $sAltUrl = $oConfig->getConfigParam('sAltImageDir');
        }

        if ($sAltUrl) {
            if ((is_null($blSSL) && $oConfig->isSsl()) || $blSSL) {
                $sSslAltUrl = $oConfig->getConfigParam('sSSLAltImageUrl');
                if (!$sSslAltUrl) {
                    $sSslAltUrl = $oConfig->getConfigParam('sSSLAltImageDir');
                }

                if ($sSslAltUrl) {
                    $sAltUrl = $sSslAltUrl;
                }
            }

            if (!is_null($sFile)) {
                $sAltUrl = Registry::getUtils()->checkUrlEndingSlash($sAltUrl) . $sFilePath . $sFile;
            }
        }

        return $sAltUrl;
    }
728185
private function getBasePath($uuid = null, $default = 1)
    {
        if (null !== $uuid) {
            return str_replace('{uuid}', $uuid, $this->apiBasePath[2]);
        } else {
            return $this->apiBasePath[$default];
        }
    }
1011753
public function getStep($uuid)
    {
        foreach ($this->steps as $step) {
            if ($step->getUuid() === $uuid) {
                return $step;
            }
        }

        return null;
    }
599173
private function getClosestResourceLocator($uuid, $webspaceKey, $languageCode)
    {
        if (!$uuid) {
            return null;
        }

        $document = $this->documentManager->find($uuid, $languageCode, ['load_ghost_content' => false]);

        do {
            try {
                return $this->loadByContentUuid($this->documentInspector->getUuid($document), $webspaceKey, $languageCode);
            } catch (ResourceLocatorNotFoundException $e) {
                $document = $document->getParent();
            }
        } while ($document instanceof ParentBehavior);
    }
685982
public function getBySlug($sSlug)
    {
        foreach ($this->aComponents as $oComponent) {
            if ($sSlug == $oComponent->slug) {
                return $oComponent;
            }
        }

        return null;
    }
1015599
public static function getBaseDirectory($blnAppendTrailingSlash)
	{
		$path = \FilesModel::findByUuid($GLOBALS['TL_CONFIG']['dmsBaseDirectory'])->path;
		
		if ($blnAppendTrailingSlash)
		{
			$path .= "/";
		}
		return $path;
	}
319025
function find(pathname, patterns) {
  for (const entry of patterns)
    if (minimatch(pathname, entry.pattern))
      return entry.handler
  return null
}
461317
def getFlag(self, flagName):
        
        assert (len(flagName) > 0)

        return Flag(os.path.join(self._variablesDirPath, flagName))
1365100
function find(test, paths, callback, one) {
  var state = {
    broken: false,
    checked: [],
    test: augment(test)
  }

  if (!callback) {
    callback = paths
    paths = [process.cwd()]
  } else if (typeof paths === 'string') {
    paths = [paths]
  }

  return visitAll(state, paths, null, one, done)

  function done(result) {
    callback(null, one ? result[0] || null : result)
  }
}
500064
function getServerBuildDirectory(): string {
  // Generate a random string to ensure uniqueness
  const buildToken = crypto.randomBytes(16).toString('hex');
  return path.resolve(os.tmpdir(), `nucleate-${buildToken}`);
}
1129695
public Long retrieveChecksum(Block lostBlock, Path p,
      long lostBlockOffset, FileSystem fs, Context context) 
          throws IOException {
    Long oldCRC = null;  
    if (checksumStore != null) { 
      IOException caughtException = null;
      try {
        oldCRC = checksumStore.getChecksum(lostBlock); 
      } catch (IOException ioe) {
        LOG.error(" Fail to get checksum for block " + lostBlock, ioe);
        caughtException = ioe;
      }
      // Checksum is not record, we should report
      if (oldCRC == null) {
        LogUtils.logRaidReconstructionMetrics(LOGRESULTS.FAILURE, 0,
            codec, p, lostBlockOffset,
            LOGTYPES.OFFLINE_RECONSTRUCTION_GET_CHECKSUM,
            fs, caughtException, context);
      }
    }
    return oldCRC;
  }
483395
public function getAnswer($questionUuid)
    {
        $found = null;
        foreach ($this->answers as $answer) {
            if ($answer->getQuestionId() === $questionUuid) {
                $found = $answer;
                break;
            }
        }

        return $found;
    }
1014038
function getResourcePath(sResourceName, sSuffix) {

		var sNamePrefix = sResourceName,
			p = sResourceName.length,
			sPath;

		// search for a registered name prefix, starting with the full name and successively removing one segment
		while ( p > 0 && !mUrlPrefixes[sNamePrefix] ) {
			p = sNamePrefix.lastIndexOf('/');
			// Note: an empty segment at p = 0 (leading slash) will be ignored
			sNamePrefix = p > 0 ? sNamePrefix.slice(0, p) : '';
		}

		assert((p > 0 || sNamePrefix === '') && mUrlPrefixes[sNamePrefix], "there always must be a mapping");

		sPath = mUrlPrefixes[sNamePrefix].url + sResourceName.slice(p + 1); // also skips a leading slash!

		//remove trailing slash
		if ( sPath.slice(-1) === '/' ) {
			sPath = sPath.slice(0, -1);
		}
		return sPath + (sSuffix || '');

	}
336917
protected function getCachedFilepath(array $vars)
	{
		if (!isset($this->cacheDir))
		{
			return null;
		}

		$filepath = $this->cacheDir . '/http.' . $this->getCacheKey($vars);
		if (extension_loaded('zlib'))
		{
			$filepath = 'compress.zlib://' . $filepath . '.gz';
		}

		return $filepath;
	}
1113011
function findPath(path, directories) {
  var cwd = directories[0];

  if (!cwd) {
    return null;
  }

  return findup(path, {cwd: cwd}) || findPath(path, slice.call(directories, 1));
}