ormMapParser Class Reference
[Parser., Database Connectivity]

This file is part of Zigmoyd PHP Framework. More...

Inheritance diagram for ormMapParser:

[legend]

Collaboration diagram for ormMapParser:

[legend]

Public Member Functions
	ormMapParser ()
	__construct ()
	parse_var_list ($str)
	explode_token ($token_str)
	parseMap ($map)
	The Raw Parser Goes through the Orm Map and Generates a Raw Array of Tokens and returns that You must supply the Full Path to Orm Map to work.
	loadMap ($map_path)
	Gets the file onced parsed by the parseMap() and Uses its returned array as the input and generates another easy to understand object and stores it into $this->__struct However you must supply the full path to orm map.
Data Fields
	$__map_file_name
	$__struct

---

Detailed Description

This file is part of Zigmoyd PHP Framework.

Copyright (C) 2008 Neel Basu (Sunanda Bose)

Zigmoyd PHP Framework is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

Zigmoyd PHP Framework is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with Zigmoyd PHP Framework. If not, see <http://www.gnu.org/licenses/>. Parses the orm Map and generates and Intermediate code on $this->__struct that the Child class(s) can access and use

Definition at line 31 of file prs_orm.php.

---

Constructor & Destructor Documentation

ormMapParser::__construct( ) 

Reimplemented from zCore.

Definition at line 38 of file prs_orm.php.

Referenced by orm_CodeGen::orm_CodeGen(), and ormMapParser().

Show Source

                        {
    parent::__construct();
    $this->__struct = new stdClass();
  }

Top 

---

Member Function Documentation

ormMapParser::ormMapParser( ) 

Definition at line 35 of file prs_orm.php.

References __construct().

Show Source

                         {
    $this->__construct();
  }

Here is the call graph for this function:

Top 

ormMapParser::parse_var_list( unknown $str ) 

Definition at line 42 of file prs_orm.php.

Referenced by parseMap().

Show Source

                               {
    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;
  }

Top 

ormMapParser::explode_token( unknown $token_str ) 

Definition at line 67 of file prs_orm.php.

References perror().

Referenced by parseMap().

Show Source

                                    {
    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;
  }

Here is the call graph for this function:

Top 

ormMapParser::parseMap( string $map ) 

The Raw Parser Goes through the Orm Map and Generates a Raw Array of Tokens and returns that You must supply the Full Path to Orm Map to work.

Parameters:

$map

Returns:

array

Definition at line 103 of file prs_orm.php.

References $__struct, explode_token(), parse_var_list(), and perror().

Referenced by loadMap().

Show Source

                         {
    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;
  }

Here is the call graph for this function:

Top 

ormMapParser::loadMap( string $map_path ) 

Gets the file onced parsed by the parseMap() and Uses its returned array as the input and generates another easy to understand object and stores it into $this->__struct However you must supply the full path to orm map.

Parameters:

$map_path

Definition at line 177 of file prs_orm.php.

References parseMap(), and perror().

Show Source

                             {
    $__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;
        }
        //}}}
      }
      //}}
    }
    //}
  }

Here is the call graph for this function:

Top 

---

Field Documentation

ormMapParser::$__map_file_name

Definition at line 32 of file prs_orm.php.

Top 

ormMapParser::$__struct

Definition at line 33 of file prs_orm.php.

Referenced by parseMap().

Top 

---

The documentation for this class was generated from the following file:

• prs_orm.php