custom.pl

MySql C++ library

  struct NAME { 
$defs 
    NAME () {} 
    NAME (const MysqlRow &row);
    void set (const MysqlRow &row);
    sql_compare_define_##CMP(NAME, $parmC)
    sql_construct_define_##CONTR(NAME, $parmC)
    static char *names[];
    static char *_table;
    static char *& table() {return _table;}

    /* cus_data */

    NAME##_cus_value_list<quote_type0> value_list($cusparms1) const {
      return value_list(",", mysql_quote, $cusparmsv);
    }
    NAME##_cus_value_list<quote_type0> value_list($cusparms2) const {
      return value_list(",", mysql_quote, $cusparmsv);
    }
    NAME##_cus_value_list<quote_type0> value_list(vector<bool> *i) const {
      return value_list(",", mysql_quote, i);
    }
    NAME##_cus_value_list<quote_type0> value_list(sql_cmp_type sc) const {
      return value_list(",", mysql_quote, sc);
    }

    NAME##_cus_value_list<quote_type0> value_list(cchar *d, $cusparms1) const {
      return value_list(d, mysql_quote, $cusparmsv);
    }
    NAME##_cus_value_list<quote_type0> value_list(cchar *d, $cusparms2) const {
      return value_list(d, mysql_quote, $cusparmsv);
    }
    NAME##_cus_value_list<quote_type0> value_list(cchar *d, 
						vector<bool> *i) const {
      return value_list(d, mysql_quote, i);
    }
    NAME##_cus_value_list<quote_type0> value_list(cchar *d, 
						sql_cmp_type sc) const {
      return value_list(d, mysql_quote, sc);
    }

    template <class Manip>
    NAME##_cus_value_list<Manip> value_list(cchar *d, Manip m,
					  $cusparms1) const; 
    template <class Manip>
    NAME##_cus_value_list<Manip> value_list(cchar *d, Manip m,
					  $cusparms2) const; 
    template <class Manip>
    NAME##_cus_value_list<Manip> value_list(cchar *d, Manip m, 
					  vector<bool> *i) const;
    template <class Manip>
    NAME##_cus_value_list<Manip> value_list(cchar *d, Manip m, 
					  sql_cmp_type sc) const;
    /* cus field */

    NAME##_cus_field_list<do_nothing_type0> field_list($cusparms1) const {
      return field_list(",", mysql_do_nothing, $cusparmsv);
    }
    NAME##_cus_field_list<do_nothing_type0> field_list($cusparms2) const {
      return field_list(",", mysql_do_nothing, $cusparmsv);
    }
    NAME##_cus_field_list<do_nothing_type0> field_list(vector<bool> *i) const {
      return field_list(",", mysql_do_nothing, i);
    }
    NAME##_cus_field_list<do_nothing_type0> field_list(sql_cmp_type sc) const
    {
      return field_list(",", mysql_do_nothing, sc);
    }

    NAME##_cus_field_list<do_nothing_type0> field_list(cchar *d, 
						       $cusparms1) const {
      return field_list(d, mysql_do_nothing, $cusparmsv);
    }
    NAME##_cus_field_list<do_nothing_type0> field_list(cchar *d,
						       $cusparms2) const {
      return field_list(d, mysql_do_nothing, $cusparmsv);
    }
    NAME##_cus_field_list<do_nothing_type0> field_list(cchar *d, 
						vector<bool> *i) const {
      return field_list(d, mysql_do_nothing, i);
    }
    NAME##_cus_field_list<do_nothing_type0> field_list(cchar *d, 
						sql_cmp_type sc) const {
      return field_list(d, mysql_do_nothing, sc);
    }

    template <class Manip>
    NAME##_cus_field_list<Manip> field_list(cchar *d, Manip m,
					    $cusparms1) const; 
    template <class Manip>
    NAME##_cus_field_list<Manip> field_list(cchar *d, Manip m,
					    $cusparms2) const; 
    template <class Manip>
    NAME##_cus_field_list<Manip> field_list(cchar *d, Manip m,
					    vector<bool> *i) const;
    template <class Manip>
    NAME##_cus_field_list<Manip> field_list(cchar *d, Manip m, 
					    sql_cmp_type sc) const;

    /* cus equal */

    NAME##_cus_equal_list<quote_type0> equal_list($cusparms1) const {
      return equal_list(",", " = ", mysql_quote, $cusparmsv);
    }
    NAME##_cus_equal_list<quote_type0> equal_list($cusparms2) const {
      return equal_list(",", " = ", mysql_quote, $cusparmsv);
    }
    NAME##_cus_equal_list<quote_type0> equal_list(vector<bool> *i) const {
      return equal_list(",", " = ", mysql_quote, i);
    }
    NAME##_cus_equal_list<quote_type0> equal_list(sql_cmp_type sc) const {
      return equal_list(",", " = ", mysql_quote, sc);
    }

    NAME##_cus_equal_list<quote_type0> equal_list(cchar *d, $cusparms1) const {
      return equal_list(d, " = ", mysql_quote, $cusparmsv);
    }
    NAME##_cus_equal_list<quote_type0> equal_list(cchar *d, $cusparms2) const {
      return equal_list(d, " = ", mysql_quote, $cusparmsv);
    }
    NAME##_cus_equal_list<quote_type0> equal_list(cchar *d, 
						vector<bool> *i) const {
      return equal_list(d, " = ", mysql_quote, i);
    }
    NAME##_cus_equal_list<quote_type0> equal_list(cchar *d, 
						sql_cmp_type sc) const {
      return equal_list(d, " = ", mysql_quote, sc);
    }

    NAME##_cus_equal_list<quote_type0> equal_list(cchar *d, cchar *c,
                                                $cusparms1) const {
      return equal_list(d, c, mysql_quote, $cusparmsv);
    }
    NAME##_cus_equal_list<quote_type0> equal_list(cchar *d, cchar *c,
                                                $cusparms2) const {
      return equal_list(d, c, mysql_quote, $cusparmsv);
    }
    NAME##_cus_equal_list<quote_type0> equal_list(cchar *d, cchar *c,
						vector<bool> *i) const {
      return equal_list(d, c, mysql_quote, i);
    }
    NAME##_cus_equal_list<quote_type0> equal_list(cchar *d, cchar *c,
						sql_cmp_type sc) const {
      return equal_list(d, c, mysql_quote, sc);
    }

    template <class Manip>
    NAME##_cus_equal_list<Manip> equal_list(cchar *d, cchar *c, Manip m, 
					    $cusparms1) const; 
    template <class Manip>
    NAME##_cus_equal_list<Manip> equal_list(cchar *d, cchar *c, Manip m, 
					    $cusparms2) const; 
    template <class Manip>
    NAME##_cus_equal_list<Manip> equal_list(cchar *d, cchar *c, Manip m, 
					    vector<bool> *i) const;
    template <class Manip>
    NAME##_cus_equal_list<Manip> equal_list(cchar *d, cchar *c, Manip m, 
					    sql_cmp_type sc) const;

    NAME##_value_list<quote_type0> value_list() const {
      return value_list(",", mysql_quote);}
    NAME##_value_list<quote_type0> value_list(cchar *d) const {
      return value_list(d, mysql_quote);}
    template <class Manip> 
    NAME##_value_list<Manip> value_list(cchar *d, Manip m) const; 

    NAME##_field_list<do_nothing_type0> field_list() const {
      return field_list(",", mysql_do_nothing);}
    NAME##_field_list<do_nothing_type0> field_list(cchar *d) const {
      return field_list(d, mysql_do_nothing);}
    template <class Manip>
    NAME##_field_list<Manip> field_list(cchar *d, Manip m) const; 

    NAME##_equal_list<quote_type0> equal_list(cchar *d = ",", 
                                              cchar *c = " = ") const{
      return equal_list(d, c, mysql_quote);}
    template <class Manip>
    NAME##_equal_list<Manip> equal_list(cchar *d, cchar *c, Manip m) const; 
    
  }; 

  char *##NAME##::names[] = { 
$names 
  }; 
  char *##NAME##::_table = #NAME ;  

  template <class Manip>
  NAME##_cus_value_list<Manip>::NAME##_cus_value_list
  (const NAME *o, cchar *d, Manip m, $cusparms11) 
  { 
    delem = d;
    manip = m;
    del_vector = true;
    obj = o; 
    include = new vector<bool>($i, false);
$create_bool 
  } 

  template <class Manip>
  NAME##_cus_value_list<Manip>::NAME##_cus_value_list
  (const NAME *o, cchar *d, Manip m, $cusparms22) { 
    delem = d;
    manip = m;
    del_vector = true; 
    obj = o; 
    include = new vector<bool>($i, false); 
$create_list 
  }

  template <class Manip>
  NAME##_cus_field_list<Manip>::NAME##_cus_field_list
  (const NAME *o, cchar *d, Manip m, $cusparms11) {
    delem = d;
    manip = m;
    del_vector = true; 
    obj = o; 
    include = new vector<bool>($i, false); 
$create_bool 
  } 

  template <class Manip>
  NAME##_cus_field_list<Manip>::NAME##_cus_field_list
  (const NAME *o, cchar *d, Manip m, $cusparms22) { 
    delem = d;
    manip = m;
    del_vector = true; 
    obj = o; 
    include = new vector<bool>($i, false); 
$create_list 
  }

  template <class Manip>
  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list
  (const NAME *o, cchar *d, cchar *c, Manip m, $cusparms11) { 
    delem = d;
    comp = c;
    manip = m;
    del_vector = true; 
    obj = o; 
    include = new vector<bool>($i, false); 
$create_bool 
  } 

  template <class Manip>
  NAME##_cus_equal_list<Manip>::NAME##_cus_equal_list
  (const NAME *o, cchar *d, cchar *c, Manip m, $cusparms22) { 
    delem = d;
    comp = c;
    manip = m;
    del_vector = true; 
    obj = o; 
    include = new vector<bool>($i, false); 
$create_list 
  }

  template <class Manip>
  ostream& operator << (ostream& s, const NAME##_value_list<Manip>& obj) { 
$value_list; 
    return s; 
  } 

  template <class Manip>
  ostream& operator << (ostream& s, const NAME##_field_list<Manip>& obj) { 
$field_list; 
    return s; 
  } 

  template <class Manip>
  ostream& operator << (ostream& s, const NAME##_equal_list<Manip>& obj) { 
$equal_list; 
    return s; 
  } 

  template <class Manip>
  ostream& operator << (ostream& s, const NAME##_cus_value_list<Manip>& obj) { 
    bool before = false; 
$value_list_cus 
    return s; 
  } 

  template <class Manip>
  ostream& operator << (ostream& s, const NAME##_cus_field_list<Manip>& obj) { 
    bool before = false; 
$cus_field_list 
    return s; 
  } 

  template <class Manip>
  ostream& operator << (ostream& s, const NAME##_cus_equal_list<Manip>& obj) { 
    bool before = false; 
$cus_equal_list 
    return s; 
  } 

  template <class Manip>
  inline NAME##_value_list<Manip> NAME##::value_list(cchar *d, Manip m) const { 
    return NAME##_value_list<Manip> (this, d, m); 
  } 

  template <class Manip>
  inline NAME##_field_list<Manip> NAME##::field_list(cchar *d, Manip m) const { 
    return NAME##_field_list<Manip> (this, d, m); 
  } 

  template <class Manip>
  inline NAME##_equal_list<Manip> NAME##::equal_list(cchar *d, cchar *c, Manip m) const { 
    return NAME##_equal_list<Manip> (this, d, c, m); 
  } 
 
  template <class Manip>
  inline NAME##_cus_value_list<Manip> NAME##::value_list(cchar *d, Manip m,
						       $cusparms11) const {
    return NAME##_cus_value_list<Manip> (this, d, m, $cusparmsv); 
  } 

  template <class Manip>
  inline NAME##_cus_field_list<Manip> NAME##::field_list(cchar *d, Manip m,
							 $cusparms11) const { 
    return NAME##_cus_field_list<Manip> (this, d, m, $cusparmsv); 
  } 

  template <class Manip>
  inline NAME##_cus_equal_list<Manip> NAME##::equal_list(cchar *d, cchar *c, Manip m,
							 $cusparms11) const { 
    return NAME##_cus_equal_list<Manip> (this, d, c, m, $cusparmsv); 
  } 

  template <class Manip>
  inline NAME##_cus_value_list<Manip> NAME##::value_list(cchar *d, Manip m,
						       $cusparms22) const { 
    return NAME##_cus_value_list<Manip> (this, d, m, $cusparmsv); 
  } 

  template <class Manip>
  inline NAME##_cus_field_list<Manip> NAME##::field_list(cchar *d, Manip m,
							 $cusparms22) const {
    return NAME##_cus_field_list<Manip> (this, d, m, $cusparmsv); 
  } 

  template <class Manip>
  inline NAME##_cus_equal_list<Manip> NAME##::equal_list(cchar *d, cchar *c, Manip m, 
							 $cusparms22) const { 
    return NAME##_cus_equal_list<Manip> (this, d, c, m, $cusparmsv); 
  } 

  template <class Manip>
  inline NAME##_cus_value_list<Manip> 
  NAME##::value_list(cchar *d, Manip m, sql_cmp_type sc) const {
    sql_compare_type_def_##CMP (NAME, value, NUM);
  }

  template <class Manip>
  inline NAME##_cus_field_list<Manip> 
  NAME##::field_list(cchar *d, Manip m, sql_cmp_type sc) const {
    sql_compare_type_def_##CMP (NAME, field, NUM);
  }

  template <class Manip>
  inline NAME##_cus_equal_list<Manip> 
  NAME##::equal_list(cchar *d, cchar *c, Manip m, sql_cmp_type sc) const {
    sql_compare_type_defe_##CMP (NAME, equal, NUM);
  }

  template <sql_dummy_type dummy> 
  void populate_##NAME (NAME *s, const MysqlRow &row) { 
$popul
  } 

  inline NAME##::##NAME (const MysqlRow &row) 
                                        {populate_##NAME##<sql_dummy>(this, row);}
  inline void NAME##::set (const MysqlRow &row)
                                        {populate_##NAME##<sql_dummy>(this, row);}

  sql_COMPARE__##CMP##(NAME, $parmc )
---
print OUT &prepare($out);

#
# short cut defs
#

print OUT << "---";
#define sql_create_basic_$i(NAME, CMP, CONTR, $parm_simple_b) \\
  sql_create_basic_c_order_$i(NAME, CMP, CONTR, $parm_simple2c_b)

#define sql_create_$i(NAME, CMP, CONTR, $parm_simple) \\
  sql_create_complete_$i(NAME, CMP, CONTR, $parm_simple2c) \\

#define sql_create_c_order_$i(NAME, CMP, CONTR, $parm_order) \\
  sql_create_complete_$i(NAME, CMP, CONTR, $parm_order2c)

#define sql_create_c_names_$i(NAME, CMP, CONTR, $parm_names) \\
  sql_create_complete_$i(NAME, CMP, CONTR, $parm_names2c)

// ---------------------------------------------------
//                  End Create $i
// ---------------------------------------------------

---

}


sub prepare {
    local $_ = @_[0];
    s/\n+$//;
    s/\n[\n ]*\n/\n/g; 
    s/\n+/\\\n/g;
    $_ .= "\n\n";
    return $_;
}