include/core/cmph_map.hpp

Go to the documentation of this file.

// cmph_map.hpp -*- C++ -*-
// Copyright (C) 2011 Martin Trenkmann
#ifndef AITOOLS_BIGHASHMAP_CORE_CMPH_MAP_HPP
#define AITOOLS_BIGHASHMAP_CORE_CMPH_MAP_HPP

#include <boost/utility.hpp>
#include <boost/type_traits.hpp>
#include <boost/filesystem.hpp>
#include <cmph.h>

#include "util/systemio.hpp"
#include "util/exception.hpp"

namespace bfs = boost::filesystem;

namespace aitools {
namespace bighashmap {
namespace core {

template <typename T>
class cmph_map : public boost::noncopyable {

public:

        typedef std::string key_type;
        typedef T           value_type;
        typedef uint32_t    checksum_type;

public:

        cmph_map(const bfs::path& mph_file)
        {
                // load the MPHF into memory
                FILE* mph_rfs(util::fopen(mph_file, "rb"));
                mphf_ = cmph_load(mph_rfs);
                if (mphf_ == NULL)
                {
                        util::throw_runtime_error("Cannot load MPHF from", mph_file);
                }
                util::fclose(mph_rfs);
        }

        virtual ~cmph_map()
        {
                cmph_destroy(mphf_);
        }

public:

        virtual bool
        find(const key_type& key, value_type& value) = 0;

        uint32_t
        size() const
        {
                return cmph_size(mphf_);
        }

protected:

        uint32_t
        hash(const std::string& key)
        {
                // Important: For unknown keys the returned hash value might be out of
                // the perfect range [0, size). Maybe a bug? Modulo operation applied.
                return cmph_search(mphf_, key.c_str(), key.size()) % size();
        }

private:

        cmph_t* mphf_;

};

} // namespace core
} // namespace bighashmap
} // namespace aitools

#endif // AITOOLS_BIGHASHMAP_CORE_CMPH_MAP_HPP

---