dbfacade.h

Go to the documentation of this file.

// Copyright 2008 Marc Spoor, Axel Waggershauser
//
// This file is part of DB Facade.
//
// DB Facade 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.
//
// DB Facade 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 DB Facade. If not, see
// <http://www.gnu.org/licenses/>.

#ifndef DBFACADE_H
#define DBFACADE_H

#include <map>
#include <string>
#include <boost/extension/extension.hpp>
#include <boost/extension/factory.hpp>
#include <boost/extension/type_map.hpp>
#include <boost/shared_ptr.hpp>

namespace dbfacade
{

        class Exception
        {
                public:
                        Exception(
                                const std::string& message);
                        virtual std::string getMessage() const;

                private:
                        std::string message_;
        };

        class UniqueConstraintException
                : public Exception
        {
                public:
                        UniqueConstraintException(
                                const std::string& message);
        };

        class ForeignKeyConstraintException
                : public Exception
        {
                public:
                        ForeignKeyConstraintException(
                                const std::string& message);
        };

        class EmptyResultSetException
                : public Exception
        {
                public:
                        EmptyResultSetException(
                                const std::string& message);
        };

        class ResultRow
        {
                public:
                        virtual ~ResultRow();

                        virtual bool hasValueAt(
                                const int index) const throw() = 0;

                        virtual bool getBooleanAt(
                                const int index) const = 0;

                        virtual double getDoubleAt(
                                const int index) const = 0;

                        virtual int getIntAt(
                                const int index) const = 0;

                        virtual std::string getStringAt(
                                const int index) const = 0;
        };
        typedef boost::shared_ptr<ResultRow> RowPtr;

        class Result
        {
                public:
                        virtual ~Result();

                        virtual RowPtr getNextRow() = 0;
        };
        typedef boost::shared_ptr<Result> ResultPtr;

        class Database
        {
                public:
                        virtual ~Database();

                        static boost::shared_ptr<Database> getDatabase(
                                const std::string& identifier);

                        virtual void connect(
                                const std::string& server,
                                const std::string& username,
                                const std::string& password,
                                const std::string& dbname) = 0;

                        virtual void execute(
                                const std::string& statement) = 0;

                        virtual ResultPtr sqlSelect(
                                const std::string& statement,
                                const bool allAtOnce = true) = 0;

                        virtual int sqlInsert(
                                const std::string& statement) = 0;

                        virtual int sqlUpdate(
                                const std::string& statement) = 0;

                        virtual bool getFirstBoolean(
                                const std::string& statement);

                        virtual double getFirstDouble(
                                const std::string& statement);

                        virtual int getFirstInt(
                                const std::string& statement);

                        virtual std::string getFirstString(
                                const std::string& statement);

                        virtual std::string escape(
                                const char* unescaped,
                                const int size) const = 0;
        };
        typedef boost::shared_ptr<Database> DatabasePtr;

        typedef std::map<
                        std::string,
                        boost::extensions::factory<dbfacade::Database> >
                DatabaseFactoryMap;
};

#define REGISTER_PLUGIN(name, class) \
BOOST_EXTENSION_TYPE_MAP_FUNCTION \
{ types.get<dbfacade::DatabaseFactoryMap>()[name].set<class>(); }

#endif

---