src/op5/ninja_sdk/orm/ORMObjectGenerator.php

   1 <?php
   2
   3 class ORMObjectGenerator extends class_generator {
   4
   5         private $name;
   6         private $structure;
   7         private $associations;
   8
   9         /**
  10          * Construct
  11          *
  12          * @return void
  13          **/
  14         public function __construct( $name, $structure ) {
  15                 $this->name = $name;
  16                 $this->structure = $structure[$name];
  17                 $this->key = $this->structure['key'];
  18                 $this->classname = 'Base'.$this->structure['class'];
  19
  20                 $this->associations = array();
  21
  22                 foreach( $structure as $table => $tbl_struct ) {
  23                         foreach( $tbl_struct['structure'] as $name => $type ) {
  24                                 if( is_array( $type ) ) {
  25                                         if( $type[0] == $this->structure['class'] ) {
  26                                                 $this->associations[] = array(
  27                                                         $table,
  28                                                         $tbl_struct['class'],
  29                                                         substr( $type[1], 0, -1 ) // Drop last _
  30                                                 );
  31                                         }
  32                                 }
  33                         }
  34                 }
  35
  36                 $this->set_model();
  37         }
  38
  39         /**
  40          * Generate
  41          *
  42          * @return void
  43          **/
  44         public function generate($skip_generated_note = false) {
  45                 parent::generate($skip_generated_note);
  46                 $this->init_class( 'Object', array('abstract') );
  47                 $this->variable( '_table', $this->name, 'protected' );
  48                 $this->write();
  49
  50                 /* Storage */
  51                 foreach( $this->structure['structure'] as $field => $type ) {
  52                         if( is_array($type) ) {
  53                                 $this->{"storage_object"}( $field, $type );
  54                         } else {
  55                                 $this->{"storage_$type"}( $field );
  56                         }
  57                 }
  58
  59                 $this->generate_construct();
  60                 $this->generate_get_key();
  61
  62                 /* Getters and setters */
  63                 foreach( $this->structure['structure'] as $field => $type ) {
  64                         if( is_array($type) ) {
  65                                 $this->{"get_object"}( $field, $type );
  66                         } else {
  67                                 $this->{"get_$type"}( $field );
  68                         }
  69                 }
  70
  71                 foreach( $this->associations as $assoc ) {
  72                         $this->generate_association_get_set( $assoc[0], $assoc[1], $assoc[2] );
  73                 }
  74
  75                 $this->finish_class();
  76         }
  77
  78         /**
  79          * Generates a class construct
  80          *
  81          * @return void
  82          **/
  83         private function generate_construct() {
  84                 $this->init_function( "__construct", array( 'values', 'prefix', 'export' ) );
  85                 $this->write( '$this->export = array();' );
  86                 $this->write( '$subobj_export = array();' );
  87                 $this->write( 'if($export === false) $export = array();'); //FIXME
  88                 $this->write( 'foreach( $export as $expcol ) {');
  89                 $this->write(     '$parts = explode(".", $expcol, 2);');
  90                 $this->write(     'if(count($parts) == 2) {');
  91                 $this->write(         'if(!isset($subobj_export[$parts[0]])) {');
  92                 $this->write(             '$subobj_export[$parts[0]] = array();');
  93                 $this->write(         '}');
  94                 $this->write(         '$subobj_export[$parts[0]][] = $parts[1];');
  95                 $this->write(         '$this->export[] = $parts[0];');
  96                 $this->write(     '} else {');
  97                 $this->write(         '$this->export[] = $parts[0];');
  98                 $this->write(     '}');
  99                 $this->write( '}');
 100                 $this->comment('If object fields exists, make sure the object only exists in the export array once');
 101                 $this->write( '$this->export = array_unique($this->export);');
 102                 foreach( $this->structure['structure'] as $field => $type ) {
 103                         $backend_name = $field;
 104                         if(isset($this->structure['rename']) && isset($this->structure['rename'][$field])) {
 105                                 $backend_name = $this->structure['rename'][$field];
 106                         }
 107                         if( is_array($type) ) {
 108                                 $this->{"fetch_object"}( $field, $backend_name, $type );
 109                         } else {
 110                                 $this->{"fetch_$type"}( $field, $backend_name );
 111                         }
 112                 }
 113                 $this->write( 'parent::__construct( $values, $prefix, $export ); ');
 114                 $this->finish_function();
 115         }
 116
 117         /**
 118          * Generate association get set
 119          *
 120          * @param $table string
 121          * @param $class string
 122          * @param field string
 123          * @return void
 124          **/
 125         private function generate_association_get_set($table, $class, $field) {
 126                 $this->init_function('get_'.$table.'_set');
 127                 $this->write('$set = '.$class.'Pool'.self::$model_suffix.'::all();');
 128                 foreach( $this->key as $key_field ) {
 129                         $this->write('$set = $set->reduce_by(%s,$this->get_'.$key_field.'(),"=");', $field.'.'.$key_field);
 130                 }
 131                 $this->write('return $set;');
 132                 $this->finish_function();
 133         }
 134
 135         /**
 136          * Generate get key
 137          *
 138          * @return void
 139          **/
 140         private function generate_get_key() {
 141                 $this->init_function("get_key");
 142                 $matchline = '$key = $this%s;';
 143                 $got = false;
 144                 foreach( $this->key as $keypart ) {
 145                         // Build getter sequence
 146                         $call = "";
 147                         foreach( explode('.',$keypart) as $part ) {
 148                                 $call .= "->get_$part()";
 149                         }
 150
 151                         // Use sprintf instead of embedded in write. write escapes
 152                         $this->write( sprintf( $matchline, $call ) );
 153                         $got = true;
 154                         $matchline = '$key .= ";".$this%s;';
 155                 }
 156                 if( $got ) {
 157                         $this->write('return $key;');
 158                 } else {
 159                         $this->write('return false;');
 160                 }
 161                 $this->finish_function();
 162         }
 163
 164         /**
 165          * Writes a private variable to class
 166          *
 167          * @param $name string
 168          * @param $type string          Unused?
 169          * @return void
 170          **/
 171         private function storage_object( $name, $type ) {
 172                 $this->write( "private \$$name = false;" );
 173         }
 174
 175         /**
 176          * Writes an object fetcher
 177          *
 178          * @param $name string
 179          * @param $type string
 180          * @return void
 181          **/
 182         private function fetch_object( $name, $backend_name, $type ) {
 183                 list( $class, $prefix ) = $type;
 184                 // Livestatus handles only one level of prefixes... might change in future? (for example comments: service.host.name should be host.name
 185                 $this->write( "\$this->$name = new $class".self::$model_suffix."( \$values, %s, isset(\$subobj_export[%s]) ? \$subobj_export[%s] : array() );", $prefix, $backend_name, $name );
 186         }
 187
 188         /**
 189          * Writes function getting object named $name
 190          *
 191          * @param $name string
 192          * @param $type string          Unused?
 193          * @return void
 194          **/
 195         private function get_object( $name, $type ) {
 196                 $this->init_function( "get_$name" );
 197                 $this->write( "return \$this->$name;" );
 198                 $this->finish_function();
 199         }
 200
 201         /**
 202          * undocumented function
 203          *
 204          * @return void
 205          **/
 206         private function storage_string( $name ) {
 207                 $this->write( "private \$$name = false;" );
 208         }
 209
 210         /**
 211          * undocumented function
 212          *
 213          * @return void
 214          **/
 215         private function fetch_string( $name, $backend_name ) {
 216                 $this->write( "if(array_key_exists(\$prefix.'$backend_name', \$values)) { ");
 217                 $this->write( "\$this->$name = (string)\$values[\$prefix.'$backend_name'];" );
 218                 $this->write( "}" );
 219         }
 220
 221         /**
 222          * undocumented function
 223          *
 224          * @return void
 225          **/
 226         private function get_string( $name ) {
 227                 $this->init_function( "get_$name" );
 228                 $this->write( "return \$this->$name;" );
 229                 $this->finish_function();
 230         }
 231
 232         /* Time FIXME */
 233
 234         /**
 235          * undocumented function
 236          *
 237          * @return void
 238          **/
 239         private function storage_time( $name ) {
 240                 $this->write( "private \$$name = false;" );
 241         }
 242
 243         /**
 244          * undocumented function
 245          *
 246          * @return void
 247          **/
 248         private function fetch_time( $name, $backend_name ) {
 249                 $this->write( "if(array_key_exists(\$prefix.'$backend_name', \$values)) { ");
 250                 $this->write( "\$this->$name = \$values[\$prefix.'$backend_name'];" );
 251                 $this->write( "}" );
 252         }
 253
 254         /**
 255          * undocumented function
 256          *
 257          * @return void
 258          **/
 259         private function get_time( $name ) {
 260                 $this->init_function( "get_$name" );
 261                 $this->write( "return \$this->$name;" );
 262                 $this->finish_function();
 263         }
 264
 265         /* Int */
 266
 267         /**
 268          * undocumented function
 269          *
 270          * @return void
 271          **/
 272         private function storage_int( $name ) {
 273                 $this->write( "private \$$name = false;" );
 274         }
 275
 276         /**
 277          * undocumented function
 278          *
 279          * @return void
 280          **/
 281         private function fetch_int( $name, $backend_name ) {
 282                 $this->write( "if(array_key_exists(\$prefix.'$backend_name', \$values)) {" );
 283                 $this->write( "\$this->$name = intval( \$values[\$prefix.'$backend_name'] );" );
 284                 $this->write( "}" );
 285         }
 286
 287         /**
 288          * undocumented function
 289          *
 290          * @return void
 291          **/
 292         private function get_int( $name ) {
 293                 $this->init_function( "get_$name" );
 294                 $this->write( "return \$this->$name;" );
 295                 $this->finish_function();
 296         }
 297
 298         /* Float */
 299
 300         /**
 301          * undocumented function
 302          *
 303          * @return void
 304          **/
 305         private function storage_float( $name ) {
 306                 $this->write( "private \$$name = false;" );
 307         }
 308
 309         /**
 310          * undocumented function
 311          *
 312          * @return void
 313          **/
 314         private function fetch_float( $name, $backend_name ) {
 315                 $this->write( "if(array_key_exists(\$prefix.'$backend_name', \$values)) {" );
 316                 $this->write( "\$this->$name = floatval( \$values[\$prefix.'$backend_name'] );" );
 317                 $this->write( "}" );
 318         }
 319
 320         /**
 321          * undocumented function
 322          *
 323          * @return void
 324          **/
 325         private function get_float( $name ) {
 326                 $this->init_function( "get_$name" );
 327                 $this->write( "return \$this->$name;" );
 328                 $this->finish_function();
 329         }
 330
 331         /* List */
 332
 333         /**
 334          * undocumented function
 335          *
 336          * @return void
 337          **/
 338         private function storage_list( $name ) {
 339                 $this->write( "private \$$name = false;" );
 340         }
 341
 342         /**
 343          * undocumented function
 344          *
 345          * @return void
 346          **/
 347         private function fetch_list( $name, $backend_name ) {
 348                 $this->write( "if(array_key_exists(\$prefix.'$backend_name', \$values)) {" );
 349                 $this->write( "\$this->$name = \$values[\$prefix.'$backend_name'];" );
 350                 $this->write( "}" );
 351         }
 352
 353         /**
 354          * undocumented function
 355          *
 356          * @return void
 357          **/
 358         private function get_list( $name ) {
 359                 $this->init_function( "get_$name" );
 360                 $this->write( "return \$this->$name;" );
 361                 $this->finish_function();
 362         }
 363
 364         /* Dict */
 365
 366         /**
 367          * undocumented function
 368          *
 369          * @return void
 370          **/
 371         private function storage_dict( $name ) {
 372                 $this->write( "private \$$name = false;" );
 373         }
 374
 375         /**
 376          * undocumented function
 377          *
 378          * @return void
 379          **/
 380         private function fetch_dict( $name, $backend_name ) {
 381                 $this->write( "if(array_key_exists(\$prefix.'$backend_name', \$values)) {" );
 382                 $this->write( "\$this->$name = \$values[\$prefix.'$backend_name'];" );
 383                 $this->write( "}" );
 384         }
 385
 386         /**
 387          * undocumented function
 388          *
 389          * @return void
 390          **/
 391         private function get_dict( $name ) {
 392                 $this->init_function( "get_$name" );
 393                 $this->write( "return \$this->$name;" );
 394                 $this->finish_function();
 395         }
 396 }