Loading Please wait...

prs_orm.php

Go to the documentation of this file.

<?php
class ormMapParser extends zCore{
  var $__map_file_name;
  var $__struct;

  function ormMapParser(){
    $this->__construct();
  }
  function __construct(){
    parent::__construct();
    $this->__struct = new stdClass();
  }
  function parse_var_list($str){
    trim(&$str);
    if(strlen($str) < 3){
      return false;
    }
    $carry_char = '';
    $__list = array();
    for($offset = 0;$offset<strlen($str);$offset++){
      switch(true){
        case ($str[$offset] == ':'):
            $current_token = trim($carry_char.$str[$offset], "\r\n\t :");
            $carry_char = '';
          break;
        case ($str[$offset] == "\r"):
        case ($str[$offset] == "\n"):
        case ($offset == strlen($str)-1):
            $__list[$current_token] = trim($carry_char.$str[$offset], "\r\n\t :");
            $carry_char = '';
          break;
        default:
          $carry_char .= $str[$offset];
      }
    }
    return $__list;
  }
  function explode_token($token_str){
    trim(&$token_str);
    $__token = array();
    $tmp = preg_split('~\s+~', $token_str);
    if(count($tmp) < 2){
      perror('EROOER PARSING ORM Map on file '.$this->__map_file_name.' near <br />'.$token_str.'<br />ELEMENT Must be in `STRING as STRING` format');
    }
    $__token['type'] = $tmp[0];
    switch($__token['type']){
      case 'connection':
          $__token['alias'] = $tmp[count($tmp)-1];
        break;
      case 'table':
          $__token['element'] = $tmp[1];
          $__token['alias'] = $tmp[count($tmp)-1];
        break;
      case 'readonly':
      case 'writable':
          $__token['type'] = 'attribute';
          $__token['permession'] = $tmp[0];
          $__token['element'] = $tmp[1];
          $__token['alias'] = $tmp[count($tmp)-1];
        break;
      default:
        perror('EROOER PARSING ORM Map on file '.$this->__map_file_name.' near <br />'.$token_str.'<br />Unexpected TOKEN TYPE '.$__token['type']);
    }
    return $__token;
  }
  function parseMap($map){
    if(!file_exists($map)){
      perror('ERROR While Parsing the ORM Map The File '.$map.' Doesn\'t exists');
      exit;
    }
    $this->__map_file_name = $map;
    $handle = fopen($map, "r");
    $buffer = '';
    $offset = 0;
    $previous_char = null;
    $pstk = array();//Perent Stack Array
    $carrier = '';
    $__token = array();
    $__tree = array();//Holds the Tree Structure of Parent Child Reletionship
    $p = 0;
    //{ Primary Tokenization Completed
    while(!feof($handle)){
      $buffer = fread($handle, 1);
      //{{ Handle the Current Character
      switch($buffer){
        case '{':
            $pstk[trim($offset-strlen($offset))] = trim($carrier);
            $tmp = array_keys($pstk);
              $__tree[$p]['self'] = $pstk[$tmp[count($tmp)-1]];
              if(isset($tmp[count($tmp)-2]) && isset($pstk[$tmp[count($tmp)-2]])){
                $__tree[$p]['parent'] = $pstk[$tmp[count($tmp)-2]];
              }else{
                $__tree[$p]['parent'] = false;
              }
              $p++;
            $carrier = '';
          break;
        case '}':
            $__token[trim(array_pop($pstk))] = trim($carrier);
            $carrier = '';
          break;
        default:
            $carrier .= $buffer;
      }
      //}}
      $offset++;
      $previous_char = $buffer;
    }
    //}
    $__struct = array();//an array that Holds the Structure
    $__uid = array();//an array that Stores Unique ID of each Token
    $__cptr = array();//array of Child Location Pointers;
    $p = 0;
    $t = 0;//Token Pointer to carry on the uniqueness of each token in token stream
    foreach($__tree as $lxr){
      $self = &$lxr['self'];
      $parent = &$lxr['parent'];
      if(!$parent){//Element Under root
        $__struct[$p] = array('token' => $this->explode_token($self), 'value' => $this->parse_var_list($__token[$self]), 'child' => false);
        $__uid[$self] = $t;
        $__cptr[$t] = &$__struct[$p]['child'];
        ++$p;
      }else{//Element non root
        $p_id = $__uid[$parent];
        $__cptr[$p_id][] = array('token' => $this->explode_token($self), 'value' => $this->parse_var_list($__token[$self]), 'child' => false);
        $__uid[$self] = $t;
      }
      $t++;
    }
    fclose($handle);
    return $__struct;
  }
  function loadMap($map_path){
    $__token_table = $this->parseMap($map_path);
    //{ Parse the Cnnection
    if($__token_table[0]['token']['type'] != 'connection'){
      perror('ERROR While Parsing the ORM Map on file '.$this->__map_file_name.' Unexpected Token `'.$__token_table[0]['token']['type'].'` at the Begening');
    }
    $this->__struct->connection->alias = $__token_table[0]['token']['alias'];
//    foreach($__token_table[0]['value'] as $key => $val){
//      $this->__struct->connection->{$key} = $val;
//    }
    //}
    //{ Parse The Tables
    for($i=1;$i<count($__token_table);$i++){
      if($__token_table[$i]['token']['type'] != 'table'){
        perror('ERROR While Parsing the ORM Map on file '.$this->__map_file_name.' Unexpected Token `'.$__token_table[$i]['token']['type'].'` at '.$i.' Parent Node <br />Expecting table');
        exit;
      }
      $this->__struct->tables->$__token_table[$i]['token']['element'] = new stdClass();
      $link = &$this->__struct->tables->$__token_table[$i]['token']['element'];
      $link->alias = $__token_table[$i]['token']['alias'];
      //{{ Parse The Fields
      if(!is_array($__token_table[$i]['child'])){
        perror('ERROR While Parsing the ORM Map on file '.$this->__map_file_name.' No Child Attributes Found For Table '.$__token_table[$i]['token']['element']);
        exit;
      }
      $link->Attributes = array();
      foreach($__token_table[$i]['child'] as $j => $child){
        if($child['token']['type'] != 'attribute'){
          perror('ERROR While Parsing the ORM Map on file '.$this->__map_file_name.' Unexpected Token '.$child['token']['type'].' Expecting attribute near '.$child['token']['permession'].' '.$child['token']['element'].' as '.$child['token']['alias']);
          exit;
        }
        $link->Attributes[$child['token']['element']] = new stdClass();
        $link->Attributes[$child['token']['element']]->alias = $child['token']['alias'];
        $link->Attributes[$child['token']['element']]->permission = $child['token']['permession'];
        //{{{ Parse The Criteria
        switch($child['token']['permession']){
          case 'readonly':
            if(is_array($child['value'])){
              perror('ERROR While Parsing the ORM Map on file '.$this->__map_file_name.' a Read only Field `'.$child['token']['element'].'` can not Contain Criteria cause No data is going to be written on that Field By the Layer or By you');
              exit;
            }
          break;
          case 'writable':
            if(is_array($child['value'])){
              $link->Attributes[$child['token']['element']]->criteria = array();
              foreach($child['value'] as $criteria => $err_msg){
                if($criteria == 'required' && isset($link->Attributes[$child['token']['element']]->default)){
                  perror('ERROR While Parsing the ORM Map on file '.$this->__map_file_name.'<br />You cannot use a default Value if you use required as a criteria Use optional criteria Instead<br />near<br />'.$criteria.': '.$err_msg.' under Attribute '.$child['token']['element']);
                }
                if($criteria != '__default'){
                  $link->Attributes[$child['token']['element']]->criteria[$criteria] = $err_msg;
                }else{
                  $link->Attributes[$child['token']['element']]->default = $err_msg;
                }
              }
            }
            break;
          default:
            perror('ERROR While Parsing the ORM Map on file '.$this->__map_file_name.' Unexpected Permission Type '.$child['token']['permession']);
            exit;
        }
        //}}}
      }
      //}}
    }
    //}
  }
}

?>

---