friendica/library/dddbl2/dddbl.php

<?php

namespace DDDBL;

require_once __DIR__ . '/config.inc.php';

/**
  * @throws \Exception                       - if no parameter are given
  * @throws UnexpectedParameterTypeException - if first parameter is not a string
  *
  * @returns (mixed) - the result of the query-definition execution
  *
  * expect a list of parameter with at least one value. the
  * list is handled over to the queue, which will executed
  * with them
  *
  * in the end a result of the execution of the query-definition
  * through the stored handler is returned
  *
  **/
function get() {

  $arrParameter = func_get_args();
  
  if(empty($arrParameter))
    throw new \Exception ("no parameter given for execution");
  
  if(!is_string($arrParameter[0]))
    throw new UnexpectedParameterTypeException('string', $arrParameter[0]);

  # get instance of queue and work with a copy of it
  $objQueue = Singleton::getInstance('\DDDBL\Queue');
  $objQueue = $objQueue->getClone();
  
  return $objQueue->execute($arrParameter);

}

/**
  * @param $strFile - the file with the query definitions to store
  *
  * store all query-definitions from the given file
  *
  **/
function storeQueryFileContent($strFile) {

  storeDefinitionsFromFileInGroup($strFile, 'Query-Definition');

}

/**
  * @param $strDir   - the dir with query-definitions files
  * @param $strMatch - a rule files in the dir have to match
  *
  * iterate through all files in the given dir. if a file matches
  * the rule in $strMatch, the definitions in the file will be stored
  * as query-definitions. all files are match in default.
  *
  **/
function loadQueryDefinitionsInDir($strDir, $strMatch = '*') {

  walkDirForCallback($strDir, '\DDDBL\storeQueryFileContent', $strMatch);

}

/**
  * @param $strFile - the file with the database definitions to store
  *
  * store all database definition from the given file
  *
  **/
function storeDBFileContent($strFile) {

  $cloAdditionalHandler = function ($objDataObjectPool, $arrDefinition) {
    if(!empty($arrDefinition['DEFAULT'])  && true == (boolean) $arrDefinition['DEFAULT'])
      $objDataObjectPool->add('DEFAULT', $arrDefinition);
  };

  storeDefinitionsFromFileInGroup($strFile, 'Database-Definition', $cloAdditionalHandler);

}

/**
  * @param $strDir   - the dir with query-definitions files
  * @param $strMatch - a rule files in the dir have to match
  *
  * iterate through all files in the given dir. if a file matches
  * the rule in $strMatch, the definitions in the file will be stored
  * as database-definitions. all files are matched in default.
  *
  **/
function loadDBDefinitionsInDir($strDir, $strMatch = '*') {

  walkDirForCallback($strDir, '\DDDBL\loadDBDefinitionsInDir', $strMatch);

}

/**
  * @param $strPath          - the path to the dir to handle
  * @param $strCallback      - the callback to call when a matching file is found
  * @param $strFilenameMatch - the rule to filename has to match
  *
  * @throws UnexpectedParameterTypeException - if the given path or filematch-rule is not a string
  * @throws UnexpectedParameterTypeException - if the given callback is not a callable
  * @throws \Exception - if given path is not a directory
  * @throws \Exception - if the directory is not readable
  *
  * reads all files of the given directory (just directory, not recursive)
  * and checks, if the filename matches against the given rule. if
  * a match is found the given callback is called with the full
  * path to the file
  *
  **/
function walkDirForCallback($strPath, $strCallback, $strFilenameMatch) {

  if(!is_string($strPath))
    throw new UnexpectedParameterTypeException('string', $strPath);
  
  if(!is_callable($strCallback))
    throw new UnexpectedParameterTypeException('callable', $strCallback);
    
  if(!is_string($strFilenameMatch))
    throw new UnexpectedParameterTypeException('string', $strFilenameMatch);
  
  if(!is_dir($strPath))
    throw new \Exception ('given path is not an directory: ' . $strPath);
  
  $resDirHandle = opendir($strPath);
  
  if(!is_resource($resDirHandle))
    throw new \Exception ('could not read directory: ' . $strPath);
  
  while($strFile = readdir($resDirHandle))
    if(is_file($strPath.$strFile) && fnmatch($strFilenameMatch, $strFile)) 
      call_user_func_array($strCallback, array($strPath.$strFile));
  
  closedir($resDirHandle);
  
}

/**
  * @param $strFile  - the file with definitions
  * @param $strGroup - the group the definitions should be stored in
  *
  * @throws UnexpectedParameterTypeException - if the given file is not a string
  * @throws UnexpectedParameterTypeException - if the given optional handler is not a callable
  * @throws \Exception - if the given file is not a file or do not exists
  * @throws \Exception - if the given file is not readable
  *
  * generic function to store all definitions in a given file
  * in the specified group.
  *
  * if an additional handler is given, it is called AFTER the storage of the
  * definition. when called it will get the reference to the DataObjectPool and the 
  * found definition as parameter.
  *
  **/
function storeDefinitionsFromFileInGroup($strFile, $strGroup, $cloAdditionalHandler = null) {

  if(!is_string($strGroup))
    throw new UnexpectedParameterTypeException('string', $strGroup);
    
  if(!is_null($cloAdditionalHandler) && !is_callable($cloAdditionalHandler))
    throw new UnexpectedParameterTypeException('callable', $cloAdditionalHandler);

  if(!is_file($strFile) || !file_exists($strFile))
    throw new \Exception ("given file is not a file or doesn't exists: $strFile");

  if(!is_readable($strFile))
    throw new \Exception ("given file is not readable: $strFile");

  $arrDefinitions = parse_ini_file($strFile, true);
  
  $objDataObjectPool = new DataObjectPool($strGroup);
  
  foreach($arrDefinitions AS $strDefinitionAlias => $arrDefinition) {
    $objDataObjectPool->add($strDefinitionAlias, $arrDefinition);
    
    if(!is_null($cloAdditionalHandler))
      $cloAdditionalHandler($objDataObjectPool, $arrDefinition);

  }

}