kvstore.hpp

Go to the documentation of this file.

/*
 *  Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
 *
 *  Contact: Jan Olszak <j.olszak@samsung.com>
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License
 */

#ifndef CARGO_SQLITE_KVSTORE_HPP
#define CARGO_SQLITE_KVSTORE_HPP

#include "cargo-sqlite/sqlite3/connection.hpp"
#include "cargo-sqlite/sqlite3/statement.hpp"

#include <algorithm>
#include <initializer_list>
#include <memory>
#include <mutex>
#include <sstream>
#include <string>
#include <vector>
#include <atomic>
#include <utility>

namespace cargo {

class KVStore {

public:
    class Transaction {
    public:
        Transaction(KVStore& store);
        ~Transaction();

        Transaction(const Transaction&) = delete;
        Transaction& operator=(const Transaction&) = delete;

        void commit();
    private:
        std::unique_lock<std::recursive_mutex> mLock;
        KVStore& mKVStore;
        bool mIsOuter;
    };

    explicit KVStore(const std::string& path);
    ~KVStore();

    KVStore(const KVStore&) = delete;
    KVStore& operator=(const KVStore&) = delete;

    void clear();

    bool isEmpty();

    bool exists(const std::string& key);

    bool prefixExists(const std::string& key);

    void remove(const std::string& key);

    void set(const std::string& key, const std::string& value);

    std::string get(const std::string& key);

    std::vector<std::string> getKeys();

private:
    typedef std::lock_guard<std::recursive_mutex> Lock;

    std::recursive_mutex mMutex;
    size_t mTransactionDepth;
    bool mIsTransactionCommited;

    std::string mPath;
    sqlite3::Connection mConn;
    std::unique_ptr<sqlite3::Statement> mGetValueStmt;
    std::unique_ptr<sqlite3::Statement> mGetKeyExistsStmt;
    std::unique_ptr<sqlite3::Statement> mGetKeyPrefixExistsStmt;
    std::unique_ptr<sqlite3::Statement> mGetIsEmptyStmt;
    std::unique_ptr<sqlite3::Statement> mGetValueListStmt;
    std::unique_ptr<sqlite3::Statement> mSetValueStmt;
    std::unique_ptr<sqlite3::Statement> mRemoveValuesStmt;
    std::unique_ptr<sqlite3::Statement> mGetKeysStmt;

    void setupDb();
    void prepareStatements();
    void createFunctions();
};

} // namespace cargo

#endif // CARGO_SQLITE_KVSTORE_HPP