litesql-gen-cpp.cpp

LiteSQL is a C++ library that integrates C++ objects tightly to relational database and thus provide

#include "litesql/split.hpp"
#include "litesql/types.hpp"
#include "litesql-gen-cpp.hpp"
#include "litesql-gen-main.hpp"
#include "cppgenerator.hpp"
#include "xmlobjects.hpp"
#include "md5.hpp"
#include <ctype.h>
#include <cstdio>
#include <map>
using namespace std;
using namespace gen;
using namespace litesql;



string quote(string s) {
    return "\"" + s + "\"";
}
string brackets(string s) {
    return "(" + s + ")";
}
static bool validID(string s) {
    static char* words[] = 
        {"asm","break","case","catch",
         "char","class","const","continue","default",
         "delete","do","double","else","enum","extern",
         "float","for","friend","goto","if","inline","int",
         "long","new","operator","private","protected",
         "public","register","return","short","signed",
         "sizeof","static","struct","switch","template",
         "this","throw","try","typedef","union","unsigned",
         "virtual","void","volatile","while",   
         // LiteSQL specific
         "initValues", "insert", "addUpdates", "addIDUpdates",
         "getFieldTypes", "delRecord", "delRelations",
         "update", "del", "typeIsCorrect", "upcast", "upcastCopy"
        };

    for (size_t i = 0; i < sizeof(words) / sizeof(words[0]); i++)
        if (s == words[i])
            return false;
    return true; 
}
static void sanityCheck(xml::Database& db,
                        vector<xml::Object>& objects,
                        vector<xml::Relation>& relations) {
    using namespace litesql;
    if (!validID(db.name)) 
        throw Except("invalid id: database.name : " + db.name);
    for (size_t i = 0; i < objects.size(); i++) {
        xml::Object& o = objects[i];
        if (!validID(o.name))
            throw Except("invalid id: object.name : " + o.name);
        for (size_t i2 = 0; i2 < o.fields.size(); i2++) {
            xml::Field& f = o.fields[i2];
            if (!validID(f.name))
                throw Except("invalid id: object.field.name : " + f.name);
        }
    }
    for (size_t i = 0; i < relations.size(); i++) {
        xml::Relation& r = relations[i];
        if (!validID(r.getName()))
            throw Except("invalid id: relation.name : " + r.getName());
        for (size_t i2 = 0; i2 < r.fields.size(); i2++) {
            xml::Field& f = r.fields[i2];
            if (!validID(f.name))
                throw Except("invalid id: relation.field.name : " + f.name);
        }
        for (size_t i2 = 0; i2 < r.related.size(); i2++) {
            xml::Relate& rel = r.related[i2];
            if (!validID(rel.handle) && !rel.handle.empty())
                throw Except("invalid id: relation.relate.handle : " + rel.handle);
        }
    }   
}
string makeTableName(string s) {
    if (s.size() > 31)
        return "_" + md5HexDigest(s);
    return s;
}

void writeStaticObjData(Class& cl, const xml::Object& o) {
    Variable type__("type__", "const std::string", quote(o.name));
    type__.static_();
    cl.variable(type__);

    Variable table__("table__", "const std::string", 
                     quote(makeTableName(o.getTable())));
    table__.static_();
    cl.variable(table__);

    if (!o.parentObject) {
        Variable sequence__("sequence__", "const std::string", 
                            quote(makeTableName(o.name + "_seq")));
        sequence__.static_();
        cl.variable(sequence__);
    }
}
void writeObjFields(Class & cl, const xml::Object & o) {
    Method init("initValues", "void");
    bool hasValues = false;
    init.static_();
    
    for (size_t i = 0; i < o.fields.size(); i++) {
        const xml::Field& fld = o.fields[i];
        string data = quote(fld.name + "_") + "," +
                      quote(fld.getSQLType()) + "," +
                      "table__";
        if (!fld.values.empty()) {
            data += "," + fld.name + "_values"; 
            Variable values(fld.name + "_values", 
                            "std::vector < std::pair< std::string, std::string > >");
            values.static_().protected_();
            cl.variable(values);
            hasValues = true;
            init.body(fld.name + "_values.clear();");
            for (size_t i2 = 0; i2 < fld.values.size(); i2++) {
                const xml::Value& val = fld.values[i2];
                init.body(fld.name + "_values.push_back(make_pair("
                          + quote(val.name) + "," + quote(val.value) + "));");    
            }
        }
        string ftypeClass ="const litesql::FieldType";
        if (!fld.values.empty()) {
            ftypeClass = fld.fieldTypeName + "Type";
            Class ftypeCl(ftypeClass, "litesql::FieldType");
            Method cons(ftypeClass);
	    ftypeClass = o.name + "::" + ftypeClass;
            cons.param(Variable("n", "const std::string&"))
                .param(Variable("t", "const std::string&"))
                .param(Variable("tbl", "const std::string&"))
                .param(Variable("vals", "const litesql::FieldType::Values&", "Values()"))
                .constructor("litesql::FieldType(n,t,tbl,vals)");
            
            ftypeCl.method(cons);
            for (size_t v = 0; v < fld.values.size(); v++) {
                const xml::Value& value = fld.values[v];
                string v;
                if (fld.getCPPType() == "std::string")
                    v = quote(value.value);
                else
                    v = value.value;
                Variable val(value.name, "const " + fld.getCPPType(), v);
                
                val.static_();
                ftypeCl.variable(val);
            }
            cl.class_(ftypeCl);
        }
	
        Variable ftype(fld.fieldTypeName, ftypeClass, data);
        ftype.static_();
        Variable field(fld.name, "litesql::Field<" + fld.getCPPType() + ">");
        cl.variable(ftype);
        cl.variable(field);
        if (fld.values.size() > 0) {
            Class valueHolder(xml::capitalize(fld.name));
            for (size_t v = 0; v < fld.values.size(); v++) {
                const xml::Value& value = fld.values[v];
                string v;
                if (fld.getCPPType() == "std::string")
                    v = quote(value.value);
                else
                    v = value.value;
                Variable val(value.name, "const " + fld.getCPPType(), v);

                val.static_();
                valueHolder.variable(val);
            }
            cl.class_(valueHolder);
        }
    }
    if (hasValues)
        cl.method(init);
}
void writeObjConstructors(Class& cl, const xml::Object& o) {
    Method defaults("defaults", "void");
    defaults.protected_();
    bool hasDefaults = false;
    for (size_t i = 0; i < o.fields.size(); i++) {
        const xml::Field& f = o.fields[i];
        if (!f.default_.empty() || !f.hasQuotedValues())
            defaults.body(f.name + " = " + f.getQuotedDefaultValue() + ";");
            hasDefaults = true;
    } 

    
    Method cons1(o.name); // Object(const Database &)
    string consParams = o.inherits + "(db)";
    string cons2Params = o.inherits + "(db, rec)";
    if (o.fields.size() > 0) {
        Split fieldInst;
        for (size_t i = 0; i < o.fields.size(); i++) {
            const xml::Field& f = o.fields[i];
            fieldInst.push_back(f.name + brackets(f.fieldTypeName));
        }
        consParams += ", " + fieldInst.join(", ");
        cons2Params += ", " + fieldInst.join(", ");

    }

    cons1.param(Variable("db", "const litesql::Database&"))
        .constructor(consParams);
    if (hasDefaults)
        cons1.body("defaults();");
    
    Method cons2(o.name); // Object(const Database &, const Record& row
    cons2.param(Variable("db", "const litesql::Database&"))
        .param(Variable("rec", "const litesql::Record&"))
        .constructor(cons2Params);
    if (hasDefaults) 
        cons2.body("defaults();");
    if (o.fields.size() > 0) {
        int last = o.getLastFieldOffset();
        cons2.body("size_t size = "
                   "(rec.size() > " + toString(last) + ")"
                   " ? " + toString(last) + " : rec.size();")
            .body("switch(size) {");

        for(int i = o.fields.size() - 1; i >= 0; i--) {
            int p = last - o.fields.size() + i;
            cons2.body("case " + toString(p+1) + ": " 
                       + o.fields[i].name + " = rec[" + toString(p) + "];");

        }
        cons2.body("}");
    }
    
    Method cons3(o.name); // Object(const Object& obj);
    string consParams3 = o.inherits + "(obj)";    
    if (o.fields.size() > 0) {
        Split fieldCopy;
        for (size_t i = 0; i < o.fields.size(); i++) {
            const xml::Field& f = o.fields[i];
            fieldCopy.push_back(f.name + brackets("obj." + f.name));
        }
        consParams3 += ", " + fieldCopy.join(", ");
    }
    cons3.param(Variable("obj", "const " + o.name + "&"))
        .constructor(consParams3);
    if (hasDefaults)
        cl.method(defaults);
    
    Method assign("operator=", "const " + o.name + "&");
    assign.param(Variable("obj", "const " + o.name + "&"));
    if (o.fields.size() > 0) {
        assign.body("if (this != &obj) {");
        for (size_t i = 0; i < o.fields.size(); i++) {
            const xml::Field& f = o.fields[i];
            assign.body("    " + f.name + " = obj." + f.name + ";");
        }
        assign.body("}");
    }
    assign.body(o.inherits + "::operator=(obj);");
    assign.body("return *this;");
    
    cl.method(cons1).method(cons2).method(cons3).method(assign);
    
}
void writeObjRelationHandles(Class& cl, xml::Object& o) {
    for (size_t i = 0; i < o.handles.size(); i++) {
        xml::RelationHandle& handle = o.handles[i];
        xml::Relation* rel = handle.relation;

        string className = xml::capitalize(handle.name) + "Handle";
        Class hcl(className,
                  "litesql::RelationHandle<" + o.name + ">");
        Method cons(className);
        cons.param(Variable("owner", "const " + o.name + "&")).
            constructor("litesql::RelationHandle<" + o.name + ">(owner)");
        
        Method link("link", "void");
        Method unlink("unlink", "void");
        Split params;
        params.push_back("owner->getDatabase()");
        params.resize(1 + rel->related.size());
        params[1 + handle.relate->paramPos] = "*owner";

        for (size_t i2 = 0; i2 < handle.destObjects.size(); i2++) {
            xml::Object* dest = handle.destObjects[i2].first;
            xml::Relate * relate = handle.destObjects[i2].second;
            Variable var("o" + toString(i2), "const " + dest->name + "&");
            link.param(var);
            unlink.param(var);
            params[1 + relate->paramPos] = "o" + toString(i2);
        }


        for (size_t i2 = 0; i2 < rel->fields.size(); i2++) {
            xml::Field& field = rel->fields[i2];
            // FIXME: default-arvoiset parametrit viimeiseksi

            link.param(Variable(field.name, field.getCPPType(), 
                                field.getQuotedDefaultValue()));
            unlink.param(Variable(field.name, field.getCPPType()));
            params.push_back(field.name);
        }
        link.body(rel->getName() + "::link(" + params.join(", ") + ");");
        unlink.body(rel->getName() + "::unlink(" + params.join(", ") + ");");
        Variable exprParam("expr", "const litesql::Expr&", "litesql::Expr()");
        Variable srcExprParam("srcExpr", "const litesql::Expr&", "litesql::Expr()");
        Method del("del", "void");
        params.clear();