src/DAL/SavableManager.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2008 by Sverre Rabbelier                                *
 *   sverre@rabbelier.nl                                                   *
 *                                                                         *
 *   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, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#pragma once

#include "Types.h"

typedef std::map<KeyImpl*, value_type> KeyFieldMap;

typedef std::pair<FieldImpl*, std::string> TextFieldPair;

typedef std::map<KeyFieldMap, SavableManagerPtr> ByKeyCache;

typedef std::map<TextFieldPair, SavableManagerPtr> ByValueCache;

class SavableManager : public boost::enable_shared_from_this<SavableManager>
{
        public:         
                static SavableManagersPtr getmulti(ValuesPtr values);
                
                static SavableManagersPtr getmulti(ValuesPtr values, const Joins& joins);
                
                static SavableManagerPtr getnew(TableImplPtr table);
                
                static SavableManagerPtr bykey(KeyValuePtr key);
                
                static SavableManagerPtr bykeys(KeysPtr keys);
                
                static SavableManagerPtr byvalue(ValuePtr value);
                
                static KeysPtr lookupvalue(ValuePtr value);     
                
                static size_t count(SelectionMaskPtr mask);
                
                static size_t count(KeysPtr keys);

                
                void erase();
                
                void save();
                
                void discard();
                
                bool exists() const;
                
                bool lock();
                
                void unlock();

                
                void bindKeys(sqlite3* db, sqlite3_stmt* stmt, const int startpos = 1) const;
                
                void bindFields(sqlite3* db, sqlite3_stmt* stmt, const int startpos = 1) const;
                
                void bindUpdate(sqlite3* db, sqlite3_stmt* stmt) const;
                
                void bindLookup(sqlite3* db, sqlite3_stmt* stmt) const;
                
                
                void parseInsert(sqlite3* db);
                
                void parseSelect(sqlite3_stmt* stmt, const int startpos = 0);
                
                void parseLookup(sqlite3_stmt* stmt);


                TableImplPtr getTable() const;
                                                
                ValuePtr getValue(FieldImplPtr field) const;
                
                KeysPtr getKeys() const;
                
                size_t primaryKeySize() const;
                
                
                std::string toString();
                
                Strings fieldList() const;
                
                std::string getDiff() const;
                
                bool isDirty() const;
                
                
                void setKeys(KeysPtr keys);
                
                void setValue(ValuePtr value);
                
                void setValue(FieldImplPtr field, cstring value);
                
                void setValue(FieldImplPtr field, value_type value);
                
                void setValue(KeyImplPtr field, value_type value);

        private:
                SavableManager(TableImplPtr table);
                
                ~SavableManager();
                
                
                void cleanup();         
                                
                
                static void doFullCache(SavableManagerPtr manager);
                
                static void doUncache(SavableManagerPtr manager);
                
                static void doRecache(SavableManagerPtr manager);
                
                static KeyFieldMap constructMap(SavableManagerPtr keys);
                
                static KeyFieldMap constructMap(KeysPtr keys);
                
                static TextFieldPair constructPair(FieldValuePtr value);
                
                static std::string fromMap(const KeyFieldMap& map);
                
                                
                static ByKeyCache ms_byKeyCache; 
                static ByValueCache ms_byValueCache; 
                friend SmartPtrDelete(SavableManager);
                friend class SelectionMask;
                
                TableImplPtr m_table; 
                ValuePtr m_lookupvalue; 
                FieldValueMap m_fields; 
                FieldValueMap m_orig; 
                bool m_newentry; 
                bool m_locked; 
};

---