bloom_filter_basic.h

#ifndef BLOOM_FILTER_BASIC_H
#define BLOOM_FILTER_BASIC_H

#include <iosfwd>
#include <vector>
#include "bloom_filter.h"
#include "core.h"
#include "detail/basic.h"
#include "detail/spectral.h"

namespace bf {

template <typename Core = core<>>
class basic : public bloom_filter<basic<Core>>
{
public:
    typedef Core core_type;

    static double k(double f)
    {
        return std::floor(- (std::log(f) / std::log(2)));
    }

    static double capacity(unsigned k, unsigned m)
    {
        return std::floor(m / k * std::log(2));
    }

    basic(core_type&& core)
      : core_(core)
    {
    }

    template <typename T>
    void add(const T& x)
    {
        detail::basic::add(x, core_);
    }

    template <typename T>
    void remove(const T& x)
    {
        detail::basic::remove(x, core_);
    }

    template <typename T>
    unsigned count(const T& x) const
    {
        auto pos = core_.positions(x);
        return detail::spectral::minimum(pos, core_.store);
    }

    void clear()
    {
        core_.store.reset();
    }

    std::string to_string() const
    {
        return core_.store.to_string();
    }

    unsigned k() const
    {
        return core_.hash.k();
    }

    const core_type& core() const
    {
        return core_;
    }

protected:
    core_type core_;
};

template <
    typename Elem,
    typename Traits,
    typename Core
>
std::basic_ostream<Elem, Traits>& operator<<(
        std::basic_ostream<Elem, Traits>& os, const bf::basic<Core>& b)
{
    os << b.to_string();
    return os;
}

} // namespace bf

#endif