dm-metamapper 0.0.0

data/.gitignore

@@ -0,0 +1,4 @@
+*~
+*.sw[p|o]
+.bundle/*
+.rvmrc

data/Gemfile

@@ -0,0 +1,16 @@
+source :rubygems
+
+gem "dm-core", :git => "git://github.com/datamapper/dm-core"
+
+group :test do
+  gem "rspec"
+  gem "dm-sqlite-adapter", :git => "git://github.com/datamapper/dm-sqlite-adapter"
+  gem "dm-mysql-adapter", :git => "git://github.com/datamapper/dm-mysql-adapter"
+  gem "dm-migrations", :git => "git://github.com/datamapper/dm-migrations"
+end
+
+group :deploy do
+  gem "jeweler"
+end
+
+# vim: set ft=ruby:

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/example/.gitignore

@@ -0,0 +1 @@
+example

data/example/Makefile

@@ -0,0 +1,4 @@
+all:
+	echo "generating code"
+	cd ..; 	bundle exec ruby -r example/example.rb -e "DataMapper::MetaMapper.generate(:cpp)"
+	g++ ../output/dmmm_utils.cpp ../output/dmmm_dbface.cpp example.cpp -I ../output -I /usr/include/mysql -I /usr/local/include/mysql++ -I /usr/local/mysql/include/mysql -lmysqlpp -lmysqlclient /usr/lib/libboost_thread-mt.so -L/usr/lib -L/usr/local/lib -Wall -o example

data/example/example.cpp

@@ -0,0 +1,74 @@
+#include <vector>
+#include "dmmm_dbface.h"
+#include "T_User.hpp"
+#include "T_Dog.hpp"
+#include "T_LittleFlea.hpp"
+
+using namespace std;
+using namespace DMMM;
+
+int main(int argc, char* argv[])
+{
+    string host("localhost");
+    string user("root");
+    string database("dmmm");
+    string password("");
+    DBFace dbFace(database, host, user, password);
+
+    T_Dog d;
+    T_User u;
+    d.erase();
+    u.erase();
+
+    O_User u1;
+    u1._name() = "omer";
+    u1._balance() = 5.3;
+    u1._weight() = 10;
+    u1.insert();
+    
+    O_Dog d1;
+    d1._user_id() = u1._id();
+    d1._name() = "spot";
+    d1._stinks() = true;
+    d1.insert();
+
+    d1 = d.select(d1._id()).first;
+
+    O_Dog d2(u1);
+    d2._name() = "rover";
+    d2._stinks() = false;
+    d2.insert();
+
+    O_User u2;
+    u2._name() = "jonah";
+    u2.insert();
+
+    O_Dog d3(u2._id());
+    d3._name() = "rover";
+    d3._stinks() = false;
+    d3.insert();
+
+    O_LittleFlea f1(d3);
+    f1.insert();
+    
+    vector<O_Dog> dogs;
+    d.select((d._stinks() == false) && (d._name() %= "\%over"), dogs);
+    for(size_t i = 0; i < dogs.size(); ++i){
+	dogs[i]._name() = string("good_") + dogs[i]._name();
+	dogs[i].update();
+	cout << dogs[i]._name() 
+	     << " belongs to " << dogs[i].user().first._name() 
+	     << endl;
+    }
+
+
+    T_Dog dconst(T_User(u._name() == "omer"));
+    dogs.clear();
+    dconst.select(d._stinks() == true, dogs);
+    cout << dogs.size() << " dogs meet criterion" << endl;
+    dconst.erase();
+
+    d.erase(d._user_id() == u2._id());
+
+    return 0;
+}

data/example/example.rb

@@ -0,0 +1,51 @@
+require "erb"
+require "rubygems"
+require "bundler"
+Bundler.setup(:default, :test)
+require "dm-core"
+require "lib/dm-metamapper.rb"
+require "dm-migrations"
+
+#DataMapper.setup(:default, "sqlite3::memory:")
+DataMapper.setup(:default, "mysql://root@localhost/dmmm")
+
+class User
+  include DataMapper::Resource
+  extend DataMapper::MetaMapper::Extension
+
+  generates :cpp
+
+  has n,    :dogs
+
+  property :id,           Serial
+  property :name,         String
+  property :balance,      Float
+  property :weight,       Integer
+end
+
+class Dog
+  include DataMapper::Resource
+  extend DataMapper::MetaMapper::Extension
+
+  generates :cpp
+
+  belongs_to :user
+  has n,     :little_fleas
+
+  property :id,       Serial
+  property :user_id,  Integer
+  property :name,     String
+  property :stinks,   Boolean
+end
+
+class LittleFlea
+  include DataMapper::Resource
+  extend DataMapper::MetaMapper::Extension
+
+  generates :cpp
+ 
+  belongs_to :dog
+
+  property :id,       Serial
+  property :dog_id,   Integer
+end

data/lib/dm-metamapper/extension.rb

@@ -0,0 +1,35 @@
+module DataMapper
+  module MetaMapper
+    module Extension
+      def generates(*layouts)
+        @_generation_formats = Array(layouts)
+      end
+
+      def generates?(format)
+        @_generation_formats.include?(format)
+      end
+
+      def generate(format)
+        DataMapper::MetaMapper.generate(format, self)
+      end
+
+      def generated_properties
+        @_generated_properties ||= properties.select {|prop|
+          !prop.options[:skip_generation]
+        }
+      end
+
+      def _get_binding
+        binding
+      end
+
+      def self.extended(base)
+        DataMapper::MetaMapper.register(base)
+        base.instance_variable_set(:@_generation_formats, [])
+        class <<base; attr_reader :_generation_formats end
+      end
+
+    end
+  end
+end
+

data/lib/dm-metamapper/generator.rb

@@ -0,0 +1,113 @@
+module DataMapper
+  module MetaMapper
+    class Generator
+      class GeneratedFile
+        def initialize(&blk)
+          instance_eval(&blk) if block_given?
+        end
+
+        attr_reader :template, :file_name_prefix, :file_name_suffix
+
+        def template_name(template)
+          @template = template
+        end
+
+        def prefix(str)
+          @file_name_prefix = str
+        end
+
+        def suffix(str)
+          @file_name_suffix = str
+        end
+      end
+
+      @subclasses = []
+
+      class << self
+        attr_reader :subclasses,
+                    :generated_model_files,
+                    :generated_global_files,
+                    :proxy_blk
+
+        def [](generator)
+          @subclasses.find {|klass| klass.generator_name == generator}
+        end
+
+        def generator_name(name=nil)
+          return @generator_name unless name
+          @generator_name = name
+        end
+
+        private
+
+        def generates_file(&blk)
+          @generated_model_files ||= []
+          @generated_model_files << GeneratedFile.new(&blk)
+        end
+
+        def generates_global_file(&blk)
+          @generated_global_files ||= []
+          @generated_global_files << GeneratedFile.new(&blk)
+        end
+
+        def proxy(&blk)
+          @proxy_blk = blk
+        end
+
+        def inherited(klass)
+          @subclasses ||= []
+          @subclasses << klass
+          klass.instance_variable_set(:@generator_name, @generator_name)
+        end
+      end
+    end
+  end
+end
+
+class DataMapper::MetaMapper::Proxy; end
+
+class CPPGenerator < DataMapper::MetaMapper::Generator
+  generator_name :cpp
+
+  generates_global_file{ template_name "dmmm_identifiers.hpp.erb" }
+  generates_global_file{ template_name "dmmm_comparators.hpp.erb" }
+  generates_global_file{ template_name "dmmm_fields.hpp.erb" }
+  generates_global_file{ template_name "dmmm_utils.hpp.erb" }
+  generates_global_file{ template_name "dmmm_utils.cpp.erb" }
+  generates_global_file{ template_name "dmmm_dbface.cpp.erb" }
+  generates_global_file{ template_name "dmmm_dbface.h.erb" }
+  generates_global_file{ template_name "dmmm_id.hpp.erb" }
+
+  proxy do
+    key_to_parent = {}
+    relationships.select{|r,m| m.class.name == 'DataMapper::Associations::ManyToOne::Relationship'}.each do |r|
+      key_to_parent[r[1].child_key.first.name.to_s] = r[0].to_const_string
+      puts "#{r[1].child_key.first.name.to_s} -> #{r[0].to_const_string}"
+    end
+
+    properties.each do |e| 
+      cpp_name = if e.serial?
+        "Field<I_#{e.model.name}>"
+      elsif !key_to_parent[e.name.to_s].nil?
+        "Field<I_#{key_to_parent[e.name.to_s]}>"
+      else           
+        "F_#{e.class.primitive}"
+      end
+
+      e.instance_variable_set(:@cpp_name, cpp_name)
+    end
+  end
+
+  generates_file do
+    suffix ".hpp"
+    prefix "O_"
+    template_name "instance.hpp.erb"
+  end
+
+  generates_file do
+    suffix".hpp"
+    prefix "T_"
+    template_name "class.hpp.erb"
+  end
+end
+

data/lib/dm-metamapper/metamapper.rb

@@ -0,0 +1,60 @@
+module DataMapper
+  module MetaMapper
+    class << self
+      attr_reader :models
+
+      def register(klass)
+        (@models ||= []) << klass
+      end
+
+      def generate(format, context=nil)
+        generator = Generator[format]
+
+        if context
+          context.instance_eval(&generator.proxy_blk) if generator.proxy_blk
+          type, _binding = :generated_model_files, context._get_binding
+        else
+          type, _binding = :generated_global_files, binding
+        end
+
+        generator.send(type).each do |generated_file|
+          temp_filename = [
+            File.dirname(__FILE__), 
+            "../templates", 
+            generator.generator_name, 
+            generated_file.template
+          ].join('/')
+
+          result_base_name = context ? context.name.to_s : generated_file.template.sub(/\.erb$/,'')
+
+          result_filename = File.join(
+            File.dirname(__FILE__), "../../output", [
+              generated_file.file_name_prefix,
+              result_base_name,
+              generated_file.file_name_suffix
+            ].join
+          )
+
+          if File.exists?(temp_filename)
+            STDOUT.puts "writing file " + result_filename
+            template = ERB.new(File.read(temp_filename))
+            result = template.result(_binding)
+            File.open(result_filename, 'w') { |f| f << result }
+          else
+            STDERR.puts "ERROR: " + temp_filename + " does not exist"
+          end
+        end
+
+        if !context
+          models.select {|model| 
+            model.generates?(format)
+          }.each {|model| 
+            model.generate(format)
+          } 
+        end
+
+      end
+    end
+  end
+end
+

data/lib/dm-metamapper/property.rb

@@ -0,0 +1,6 @@
+module DataMapper
+  class Property
+    accept_options :skip_generation
+  end
+end
+

data/lib/dm-metamapper.rb

@@ -0,0 +1,8 @@
+$:.push File.dirname(__FILE__)
+
+require 'dm-core'
+require 'dm-metamapper/property'
+require 'dm-metamapper/metamapper'
+require 'dm-metamapper/extension'
+require 'dm-metamapper/generator'
+

data/lib/templates/cpp/class.hpp.erb

@@ -0,0 +1,134 @@
+<% class_name = self.name %>
+<% all_caps_name = class_name.upcase %>
+#ifndef T_<%= all_caps_name %>
+#define T_<%= all_caps_name %>
+#include "O_<%= class_name %>.hpp"
+namespace DMMM {
+
+class T_<%= class_name %>{
+public:
+
+    struct Condition{
+        bool nil() const { return _cond.size() == 0; }
+        std::string _cond;
+    };
+
+    T_<%= class_name %>() 
+    {
+        _tables.push_back("<%= storage_name %>");
+    }
+    T_<%= class_name %>(const Condition& c) 
+        : _constraint(c)
+    {
+        _tables.push_back("<%= storage_name %>");
+    }
+    <% self.relationships.select{|r,m| m.class.name == 'DataMapper::Associations::ManyToOne::Relationship'}.each do |r| %> 
+    <% parent = r[0].to_const_string %>
+    T_<%= class_name %>(const T_<%= parent %>& parent)
+    {
+        _tables.push_back("<%= storage_name %>");
+        _tables.insert(_tables.end(), 
+	               parent._tables.begin(), parent._tables.end());
+        
+        _constraint._cond = "(<%= storage_name + "." + r[1].child_key.first.name.to_s %> = " + parent._tables[0] + ".<%= r[1].parent_key.first.name.to_s %>)";
+        if (!parent._constraint.nil())
+	_constraint._cond += " AND " + parent._constraint._cond;
+    } 
+
+    <% end %>
+    
+    <% generated_properties.each do |property| %>
+    struct E_<%= property.name %>{
+        E_<%= property.name %>() 
+        {  
+            _field = "<%= storage_name %>.<%= property.name.to_s %>";
+        }
+        std::string _field;
+        typedef T_<%= class_name %>::Condition ConditionType;
+        typedef <%= property.instance_variable_get(:@cpp_name) %>::Base ComparerType;
+    };
+
+    E_<%= property.name %> _<%= property.name %>(){ 
+        return E_<%= property.name %>();
+    }
+
+    <% end %>    
+
+    void getFields(std::vector<std::string>& rFields)
+    {
+        rFields.clear();
+        <% generated_properties.each do |property| %>
+        rFields.push_back("<%= property.name %>");
+        <% end %>
+    }
+
+    void select(const Condition& c, 
+                const std::string& additional,
+                std::vector<O_<%= class_name %>>& r)
+    {
+        Condition c1 = _constraint.nil() ? c : _constraint && c;
+        std::vector<std::string> fields;
+        getFields(fields);
+        QueryRes res;
+        DBFace::instance()->select(_tables, fields, c1._cond, 
+                                   additional, res);
+        r.resize(res.size());
+        for(size_t i = 0; i < res.size(); ++i){
+            <% generated_properties.each do |property| %>
+            r[i]._f_<%= property.name %>._base = 
+                fromString<<%= property.instance_variable_get(:@cpp_name) %>::Base>(res[i]["<%= property.name %>"]);
+            <% end %>
+        }
+    }
+
+    void erase(const Condition& c)
+    {
+        Condition c1 = _constraint.nil() ? c : _constraint && c;
+        DBFace::instance()->erase(_tables, c1._cond);
+    }
+    void erase()
+    {   
+        DBFace::instance()->erase(_tables, _constraint._cond);
+    }
+
+
+    void select(const Condition& c, 
+                std::vector<O_<%= class_name %>>& r)
+    {
+        Condition c1 = _constraint.nil() ? c : _constraint && c;
+        select(c1, "", r);
+    }
+    void select(std::vector<O_<%= class_name %>>& r)
+    {
+        select(_constraint, "", r);
+    }
+
+    std::pair<O_<%= class_name %>, bool> select(const I_<%= class_name %>& id){
+        return first(E_<%= serial.name %>() == id);
+    }
+
+    std::pair<O_<%= class_name %>, bool> first(const Condition& c)
+    {
+        Condition c1 = _constraint.nil() ? c : _constraint && c;
+        std::vector<O_<%= class_name %>> r;
+        select(c, "limit 1", r);
+        if(r.size() > 0)
+            return std::make_pair(r[0], true);
+        else
+            return std::make_pair(O_<%= class_name %>(), false);
+    }
+
+    std::pair<O_<%= class_name %>, bool> first(){
+        return first(_constraint);
+    }
+
+
+
+
+
+    Condition                 _constraint;    
+    std::vector<std::string>  _tables;
+};
+
+} //namespace DMMM
+#endif //T_<%= all_caps_name %>

data/lib/templates/cpp/dmmm_comparators.hpp.erb

@@ -0,0 +1,74 @@
+#ifndef DMMM_COMPARATORS_H
+#define DMMM_COMPARATORS_H
+
+#include <string>
+#include <sstream>
+
+namespace DMMM {
+template<class E>
+typename E::ConditionType operator== (E e, const typename E::ComparerType& x){
+    typename E::ConditionType c;
+    c._cond = e._field + " = '" + toString(x) + "'";
+    return c;
+}
+
+template<class E>
+typename E::ConditionType operator< (E e, const typename E::ComparerType& x){
+    typename E::ConditionType c;
+    c._cond = e._field + " < '" + toString(x) + "'";
+    return c;
+}
+
+template<class E>
+typename E::ConditionType operator<= (E e, const typename E::ComparerType& x){
+    typename E::ConditionType c;
+    c._cond = e._field + " <= '" + toString(x) + "'";
+    return c;
+}
+
+template<class E>
+typename E::ConditionType operator> (E e, const typename E::ComparerType& x){
+    typename E::ConditionType c;
+    c._cond = e._field + " > '" + toString(x) + "'";
+    return c;
+}
+
+template<class E>
+typename E::ConditionType operator>= (E e, const typename E::ComparerType& x){
+    typename E::ConditionType c;
+    c._cond = e._field + " >= '" + toString(x) + "'";
+    return c;
+}
+
+template<class E>
+typename E::ConditionType operator!= (E e, const typename E::ComparerType& x){
+    typename E::ConditionType c;
+    c._cond = e._field + " != '" + toString(x) + "'";
+    return c;
+}
+
+template<class E>
+typename E::ConditionType operator%= (E e, const typename E::ComparerType& x){
+    typename E::ConditionType c;
+    c._cond = e._field + " LIKE '" + toString(x) + "'";
+    return c;
+}
+
+template<class C>
+C operator&& (const C& c1, const C& c2){
+    C c;
+    c._cond = "(" + c1._cond + ") AND (" + c2._cond + ")";
+    return c;
+}
+
+template<class C>
+C operator|| (const C& c1, const C& c2){
+    C c;
+    c._cond = "(" + c1._cond + ") OR (" + c2._cond + ")";
+    return c;
+}
+
+
+} //namespace DMMM
+
+#endif //DMMM_COMPARATORS_H

data/lib/templates/cpp/dmmm_dbface.cpp.erb

@@ -0,0 +1,176 @@
+#include "dmmm_dbface.h"
+#include "dmmm_utils.hpp"
+using namespace mysqlpp;
+using namespace std;
+using namespace DMMM;
+
+DBFace* DBFace::_this = NULL;
+
+DBFace::DBFace(const string& database, const string& host, 
+	       const string& user, const string& password)
+{
+    _this = this;
+    if (!_connection.connect(database.c_str(), host.c_str(), 
+			     user.c_str(), password.c_str())){
+        cerr << "Could not connect to DB";
+        exit(-1);
+    }     
+}
+
+bool
+DBFace::select(const std::vector<std::string>& tables, 
+	       const std::vector<string>& columns,
+	       const std::string& where, 
+	       const std::string& additional, 
+	       QueryRes& rRes)
+{
+    boost::mutex::scoped_lock lock(_mutex);
+
+    Query q = _connection.query();
+    
+    q << "SELECT ";
+    for (size_t i = 0; i < columns.size(); ++i){
+	if (i > 0)
+	    q << ",";
+	q << tables[0] << "." << columns[i];
+    }
+    q << " FROM " << tables[0];
+    for (size_t i = 1; i < tables.size(); ++i)
+        q << ", " + tables[i];
+    if (where.size())
+	q << " WHERE " << where;
+    if (additional.size())
+	q << " " << additional;
+    cout << q << endl;
+    StoreQueryResult mysqlRes;
+    try{
+	mysqlRes = q.store();
+    }
+    catch (const mysqlpp::Exception& er) {
+        cerr << "Query failed: " << q << endl << er.what();
+        return false;
+    }
+    
+    for (size_t i = 0; i < mysqlRes.num_rows(); ++i){
+	rRes.resize(rRes.size() + 1);
+	for (size_t j = 0; j < columns.size(); ++j)
+	    rRes.back()[columns[j]] = toString(mysqlRes[i][columns[j].c_str()]);
+    }
+    return true;
+}
+
+
+bool 
+DBFace::erase(const std::vector<std::string>& tables, 
+   	      const std::string& where)
+{
+    Query q = _connection.query();
+    q << "DELETE FROM " << tables[0];
+    if (tables.size() > 1)
+        q << " USING " + tables[0] + " ";
+    for (size_t i = 1; i < tables.size(); ++i)
+        q << " INNER JOIN " + tables[i];
+    if (where.size())
+	q << " WHERE " << where;
+    cout << q << endl;
+    return executeQuery(q);
+    
+}
+
+
+bool
+DBFace::executeQuery(Query& q)
+{
+    boost::mutex::scoped_lock lock(_mutex);
+    try{
+        q.execute();
+    }
+    catch (const mysqlpp::Exception& er) {
+        cerr << "Query failed: " << q << endl << er.what();
+        return false;
+    }
+    return true;
+}
+
+bool
+DBFace::getLastInsertId(Query& rQuery, size_t& rId)
+{
+    try{
+        rId = rQuery.insert_id();
+        cout << "got last insert ID: " << rId << endl;
+    }
+    catch (const mysqlpp::Exception& er) {
+        return false;
+    }
+    return true;
+}
+
+bool 
+DBFace::insert(const string& table, 
+	       const map<string, string>& field2Val,
+	       size_t& rInsertId)
+{
+    if (field2Val.size() == 0)
+	return true;
+
+    Query q = _connection.query();
+    q << "INSERT INTO " << table << " (";
+    for (map<string, string>::const_iterator it = field2Val.begin(); 
+	 it != field2Val.end(); ++it)
+    {
+	if (it != field2Val.begin())
+	    q << ",";
+	q << it->first;
+    }
+    q << ")VALUES(";
+    for (map<string, string>::const_iterator it = field2Val.begin(); 
+	 it != field2Val.end(); ++it)
+    {
+	if (it != field2Val.begin())
+	    q << ",";
+	q << quote << it->second;
+    }
+    q << ")";
+    cout << q << endl;
+    bool ok = executeQuery(q);
+    ok = ok && getLastInsertId(q, rInsertId);
+    return ok;
+}
+
+bool
+DBFace::update(const string& table, 
+	       const map<string, string>& field2Val,
+	       const string& where)
+{
+    Query q = _connection.query();
+    
+    q << "UPDATE " << table << " SET ";
+    for (map<string, string>::const_iterator it = field2Val.begin();
+	 it != field2Val.end(); ++it)
+    {
+	if (it != field2Val.begin())
+	    q << ",";
+	q << it->first << "=" << quote << it->second;
+    }
+    if (where.size())
+	q << " WHERE " << where;
+    cout << q << endl;
+    return executeQuery(q);
+}
+
+string 
+DBFace::now()
+{
+    Query q = _connection.query();
+    
+    q << "SELECT NOW()";
+    StoreQueryResult mysqlRes;
+    try{
+	mysqlRes = q.store();
+    }
+    catch (const mysqlpp::Exception& er) {
+        cerr << "Query failed: " << q << endl << er.what();
+        return string();
+    }
+    return toString(mysqlRes[0]["now()"]);
+}

data/lib/templates/cpp/dmmm_dbface.h.erb

@@ -0,0 +1,47 @@
+#ifndef DMMM_DBFACE_H
+#define DMMM_DBFACE_H
+
+#include <map>
+#include <mysql++.h>
+#include <boost/thread/mutex.hpp>
+
+namespace DMMM {
+
+typedef std::vector<std::map<std::string, std::string> > QueryRes;
+
+class DBFace{
+public:
+    static DBFace* instance() { return _this; }
+    
+    DBFace(const std::string& database, const std::string& host, 
+	   const std::string& user, const std::string& password);
+    
+    bool insert(const std::string& table, 
+		const std::map<std::string, std::string>& field2Val,
+		size_t& rInsertId);
+    bool update(const std::string& table, 
+		const std::map<std::string, std::string>& field2Val,
+		const std::string& where);
+    bool select(const std::vector<std::string>& table, 
+		const std::vector<std::string>& columns,
+		const std::string& where,
+		const std::string& additional,		
+		QueryRes& rRes);
+    bool erase(const std::vector<std::string>& table, 
+	       const std::string& where);
+    
+    std::string now(); 
+    
+private:
+    bool getLastInsertId(mysqlpp::Query& rQuery, size_t& rId);
+    bool executeQuery(mysqlpp::Query& rQuery);
+    
+private:
+    mysqlpp::Connection                 _connection;
+    mutable boost::mutex                _mutex;
+    static DBFace*                      _this;		
+};
+
+} //namespace DMMM
+
+#endif //DB_H

data/lib/templates/cpp/dmmm_fields.hpp.erb

@@ -0,0 +1,28 @@
+#ifndef DMMM_FIELDS_H
+#define DMMM_FIELDS_H
+
+#include <string>
+
+#include <sstream>
+
+#include "dmmm_utils.hpp"
+
+namespace DMMM {
+
+template<class T>
+struct Field{
+    Field<T>() :_dirty(false) {}
+    Field<T>(const T& t) :_dirty(true), _base(t) {}
+    typedef T Base;
+    bool _dirty;
+    T _base;
+}; //class Field
+
+typedef Field<int> F_Integer;
+typedef Field<double> F_Float;
+typedef Field<std::string> F_String;
+typedef Field<bool> F_TrueClass;
+
+} //namespace DMMM
+
+#endif //DMMM_FIELDS_H

data/lib/templates/cpp/dmmm_id.hpp.erb

@@ -0,0 +1,78 @@
+#ifndef	_DMMM_ID_HPP
+#define	_DMMM_ID_HPP
+
+#include <iosfwd>
+#include <string>
+#include <sstream>
+
+namespace DMMM{
+template<class T>
+class Id {
+
+public:
+    explicit Id(size_t id) : _id(id) {}
+    Id() {}
+
+    inline Id operator++() { 
+	++_id; return *this; 
+    }
+    
+    inline Id operator++(int) { 
+	Id val=*this; 
+	++*this; 
+	return val; 
+    }
+
+    inline bool operator==(const Id& that) const { 
+	return _id == that._id; 
+    }
+    inline bool operator< (const Id& that) const { 
+	return _id <  that._id; 
+    }
+    inline bool operator<=(const Id& that) const { 
+	return _id <= that._id; 
+    }
+    inline bool operator> (const Id& that) const { 
+	return _id > that._id; 
+    }
+    inline bool operator>= (const Id& that) const { 
+	return _id >= that._id; 
+    }
+    inline bool operator!=(const Id& that) const { 
+	return ! (*this == that); 
+    }
+
+    std::string to_s() const {
+        std::ostringstream oss;
+	oss << _id;
+        return oss.str();
+    }
+
+
+    inline size_t& serialization() { return _id; }
+
+private:
+    size_t _id;
+
+};
+
+
+} //namespace DMMM
+
+template<class T>
+std::ostream& 
+operator<< (std::ostream& os, const DMMM::Id<T>& id)
+{ 
+    os << id.to_s(); 
+    return os;
+}
+
+template<class T>
+std::istream& 
+operator>> (std::istream& is, DMMM::Id<T>& id)
+{ 
+    is >> id.serialization(); 
+    return is;
+}
+
+#endif //_DMMM_ID_HPP

data/lib/templates/cpp/dmmm_identifiers.hpp.erb

@@ -0,0 +1,15 @@
+#ifndef DMMM_IDENTIFIERS_HPP
+#define DMMM_IDENTIFIERS_HPP
+
+#include "dmmm_id.hpp"
+
+namespace DMMM {
+
+<% models.each do |model| %>
+class DummyO_<%= model.name %>;
+typedef Id<DummyO_<%= model.name %>> I_<%= model.name %>;
+<% end %>
+
+
+} //namespace DMMM
+#endif //DMMM_IDENTIFIERS_HPP

data/lib/templates/cpp/dmmm_utils.cpp.erb

@@ -0,0 +1,11 @@
+#include "dmmm_utils.hpp"
+
+namespace DMMM {
+template<>
+std::string
+fromString<std::string>(const std::string& s)
+{
+    return s;
+}
+
+} //namespace DMMM

data/lib/templates/cpp/dmmm_utils.hpp.erb

@@ -0,0 +1,40 @@
+#ifndef DMMM_UTILS_HPP
+#define DMMM_UTILS_HPP
+
+#include <vector>
+#include <map>
+#include <sstream>
+#include <dmmm_id.hpp>
+
+namespace DMMM {
+
+template<class T>
+std::string
+toString(const T& t)
+{
+    std::ostringstream oss;
+    oss << t;
+    
+    return oss.str();
+}
+
+template<class T>
+T
+fromString(const std::string& s)
+{
+    std::istringstream iss;
+    iss.str(s);
+    
+    T ret;
+    iss >> ret;
+    
+    return ret;
+}
+
+template<>
+std::string
+fromString<std::string>(const std::string& s);
+
+} //namespace DMMM
+
+#endif //DMMM_UTILS_HPP

data/lib/templates/cpp/instance.hpp.erb

@@ -0,0 +1,102 @@
+<% class_name = self.name %>
+<% all_caps_name = class_name.upcase %>
+#ifndef O_<%= all_caps_name %>
+#define O_<%= all_caps_name %>
+
+#include <map>
+#include <string>
+#include "dmmm_utils.hpp"
+#include "dmmm_dbface.h"
+#include "dmmm_identifiers.hpp"
+#include "dmmm_fields.hpp"
+#include "dmmm_comparators.hpp"
+<% self.relationships.select{|r,m| m.class.name == 'DataMapper::Associations::ManyToOne::Relationship'}.each do |relative| %>
+#include "T_<%= relative[1].parent_model.to_s %>.hpp"
+<% end %>
+
+<%# self.relationships.select{|r,m| m.class.name == 'DataMapper::Associations::OneToMany::Relationship'}.each do |relative| %>
+<%# end %>
+namespace DMMM {
+
+class O_<%= class_name %>{
+public:
+
+    O_<%= class_name %>() {}
+    <% self.relationships.select{|r,m| m.class.name == 'DataMapper::Associations::ManyToOne::Relationship'}.each do |r| %> 
+    <% parent = r[0].to_const_string %>
+    O_<%= class_name %>(const O_<%= parent %>& parent) 
+        : _f_<%= r[1].child_key.first.name.to_s %>(parent._<%= r[1].parent_key.first.name.to_s %>())
+        {}
+    O_<%= class_name %>(const I_<%= parent %>& parent_id) 
+        : _f_<%= r[1].child_key.first.name.to_s %>(parent_id)
+        {}
+    <% end %>
+
+    <% generated_properties.each do |property| %>
+    const <%= property.instance_variable_get(:@cpp_name) %>::Base& _<%= property.name %>() const { 
+        return _f_<%= property.name %>._base; 
+    }
+    <%= property.instance_variable_get(:@cpp_name) %>::Base& _<%= property.name %>() { 
+        _f_<%= property.name %>._dirty = true; 
+        return _f_<%= property.name %>._base; 
+    }
+
+    <% end %>
+
+    <% if serial %>
+    bool update(){
+        std::map<std::string, std::string> field2Val;
+        <% generated_properties.each do |property| %>
+        if (_f_<%= property.name %>._dirty)
+            field2Val["<%= property.name %>"] = 
+                toString(_f_<%= property.name %>._base);
+        <% end %>
+        std::string where =
+	    "<%= serial.name %>=" + toString(_f_<%= serial.name %>._base);
+        return DBFace::instance()->update("<%= storage_name %>", 
+                                          field2Val, where);
+    }
+
+    <% end %>
+
+
+    bool insert(){
+        std::map<std::string, std::string> field2Val;
+        <% generated_properties.each do |property| %>
+        if (_f_<%= property.name %>._dirty)
+            field2Val["<%= property.name %>"] = 
+                toString(_f_<%= property.name %>._base);
+        <% end %>
+        <% if serial %>
+        return DBFace::instance()->
+            insert("<%= storage_name %>", field2Val,
+                   _f_<%= serial.name %>._base.serialization());
+	<% else %>
+        size_t id;
+        return DBFace::instance()->
+            insert("<%= storage_name %>", field2Val,
+                   id);
+        <% end %>
+ 				   
+    }
+
+    <% self.relationships.select{|r,m| m.class.name == 'DataMapper::Associations::ManyToOne::Relationship'}.each do |r| %> 
+    <% parent = r[0].to_const_string %>
+    std::pair<O_<%= parent %>, bool> <%= r[0] %>(){
+        T_<%= parent %> T(T_<%= parent %>::E_<%= r[1].parent_key.first.name.to_s %>() == _<%= r[1].child_key.first.name.to_s %>());
+	return T.first();
+    }
+    <% end %>
+
+
+private:
+    <% generated_properties.each do |property| %>
+    <%= property.instance_variable_get(:@cpp_name) %> _f_<%= property.name %>;
+    <% end %>
+
+
+    friend class T_<%= class_name %>;
+};
+
+} //namespace DMMM
+#endif //O_<%= all_caps_name %>

data/output/.gitignore

@@ -0,0 +1 @@
+*

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+$:.push(File.join(File.dirname(__FILE__), "../lib"))
+
+require 'rubygems'
+require 'bundler'
+Bundler.setup(:default, :test)
+require 'spec'
+
+require 'dm-metamapper'

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: dm-metamapper
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 0
+  version: 0.0.0
+platform: ruby
+authors: 
+- Jonah Honeyman
+- Omer Tamuz
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-08 00:00:00 +03:00
+default_executable: 
+dependencies: []
+
+description: C++ API for databases created with DM. Hard typing, compile time checked queries.
+email: jonah@honeyman.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- .gitignore
+- Gemfile
+- README.md
+- VERSION
+- example/.gitignore
+- example/Makefile
+- example/example.cpp
+- example/example.rb
+- lib/dm-metamapper.rb
+- lib/dm-metamapper/extension.rb
+- lib/dm-metamapper/generator.rb
+- lib/dm-metamapper/metamapper.rb
+- lib/dm-metamapper/property.rb
+- lib/templates/cpp/class.hpp.erb
+- lib/templates/cpp/dmmm_comparators.hpp.erb
+- lib/templates/cpp/dmmm_dbface.cpp.erb
+- lib/templates/cpp/dmmm_dbface.h.erb
+- lib/templates/cpp/dmmm_fields.hpp.erb
+- lib/templates/cpp/dmmm_id.hpp.erb
+- lib/templates/cpp/dmmm_identifiers.hpp.erb
+- lib/templates/cpp/dmmm_utils.cpp.erb
+- lib/templates/cpp/dmmm_utils.hpp.erb
+- lib/templates/cpp/instance.hpp.erb
+- output/.gitignore
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/jonuts/dm-metamapper
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Code generating C++ ORM
+test_files: 
+- spec/spec_helper.rb