src/sql/wsqldatatype.h

Go to the documentation of this file.

/*
    WORM - a DAL/ORM code generation framework
    Copyright (C) 2011  Erik Winn <erikwinnmail@yahoo.com>

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

    This program 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 General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */


#ifndef WSQLDATATYPE_H
#define WSQLDATATYPE_H

#include <string>
#include <boost/algorithm/string.hpp>
#include <iostream>

namespace WSql {

    namespace WSqlDataType {
    
    
    enum Type {
        NOTYPE = 0,
        TINYINT,
        SMALLINT,
        MEDIUMINT,
        INT,
        BIGINT,
        FLOAT,
        DOUBLE,
        DECIMAL,
        DATE,
        DATETIME,
        YEAR,
        TIME,
        TIMESTAMP,
        TIMESTAMPTZ,
        CHAR,
        VARCHAR,
        NCHAR,
        NVARCHAR,
        TEXT,
        TINYTEXT,
        MEDIUMTEXT,
        LONGTEXT,
        ENUM,
        SET,
        BLOB
    };
    static const char * const TypeNames[] ={
        "NOTYPE",
        "TINYINT",
        "SMALLINT",
        "MEDIUMINT",
        "INT",
        "BIGINT",
        "FLOAT",
        "DOUBLE",
        "DECIMAL",
        "DATE",
        "DATETIME",
        "TIME",
        "YEAR",
        "TIMESTAMP",
        "TIMESTAMPTZ",
        "CHAR",
        "VARCHAR",
        "NCHAR",
        "NVARCHAR",
        "TEXT",
        "TINYTEXT",
        "MEDIUMTEXT",
        "LONGTEXT",
        "ENUM",
        "SET",
        "BLOB"
    };
    
    static const unsigned short number_of_datatypes = 26;
    
    static std::string toString(Type type)
    {
        std::string strToReturn;
        if (type < 0 || type > (number_of_datatypes - 1))
            strToReturn = "INVALID";
        else
            strToReturn = TypeNames[type]; //careful .. dont mess this up, add types and name in order.
        return strToReturn;
    }
    
    static Type toType(std::string name)
    {
        boost::to_upper(name);
        boost::trim(name);
        int i = 0;
        for ( ; i < number_of_datatypes; ++i)
            if ( name.compare(TypeNames[i]) == 0 )
                return static_cast<Type>(i);
        return static_cast<Type>(0);//NOTYPE
    }
    
    static std::string toSingular(const std::string& name)
    {
        std::string strToReturn = name;
        size_t size = strToReturn.size();
        if(!size)
            return strToReturn;
        if('s' == strToReturn[size-1] && 's' != strToReturn[size-2])//dont fix dress, address ..
        {
            strToReturn.erase(size-1);
            if('e' == strToReturn[size-2])
            {//eg. Cities to City ..
                if( 'i' == strToReturn[size-3])
                {
                    strToReturn.erase(size-3);
                    strToReturn.append("y");
                }else if( 'h' == strToReturn[size-3])//eg. bushes .. might need fixing ..
                    strToReturn.erase(size-2);                
            }
            return strToReturn;
        }
        return strToReturn;
    }
    
    static std::string toPlural(const std::string& name)
    {
        std::string strToReturn = name;
        size_t sz = name.size();
        if(sz && 's' == strToReturn[sz - 1])
            strToReturn.append("es");
        else if(sz > 2 && 'y' == strToReturn[sz - 1]
            && 'o' != strToReturn[sz - 2]
            && 'a' != strToReturn[sz - 2])
        {
                strToReturn.erase(sz - 1);
                strToReturn.append("ies");
        }
        else
            strToReturn.append("s");
        return strToReturn;
    }
    
    static std::string columnNameToVariable(const std::string& columnname)
    {
        std::string strToReturn = columnname;
        size_t pos = 0;
        pos = strToReturn.find('_');
        while(pos != std::string::npos)
        {
            strToReturn.erase(pos,1);
            if((pos + 1) < strToReturn.size())
                strToReturn[pos]= toupper(strToReturn[pos]);
            pos = strToReturn.find('_');
        }
        return strToReturn;
    }
    
    static std::string tableNameToClass(const std::string& tablename)
    {
        std::string strToReturn = toSingular(tablename);
        strToReturn[0] = toupper(strToReturn[0]);
        return columnNameToVariable(strToReturn);
    }

} //namespace WSqlDataType
    
}// namespace WSql

#endif // WSQLDATATYPE_H