typedef uint32_t hash_t;

template<typename Element> hash_t hash(const Element& elem);

template<typename Element, typename Hash>
class ProbabilisticSet {
    // Constructor for an initially empty set, with a specified
    // error margin for its operations and a maximum number of
    // elements we expecct.
    ProbabilisticSet(double error_margin, uint64_t max_size);

    // Inserts an element into the set.
    void insert(const Element& elem);

    // Returns the current size estimate.
    uint64_t size();

    // Returns the *k* most frequent elements, with their frequencies.
    // (Note: I'm sure in practice, we need to pass *k* to the
    // constructor. Similar note applies to other methods below.)
    list<pair<Element, uint64_t>> topK(int k);

    // Returns all elements with frequency larger than a threshold *t*.
    list<Element> largerThan(uint64_t t);

    // More general than *largerThan*: Returns all elements *e*
    // with *min <= freq(e) <= max*.
    list<Element> range(uint64_t min, uint64_t max);

    // Executes a callback when an element's frequency exceeds a
    // threshold *t*. (Specifics of the callback need to be figured
    // out).
    void frequencyThreshold(uint64_t t, Callback callback);

    // Returns true if the element is a member of the set.
    bool hasElement(const Element& elem);

    // Removes all elements from the set.
    void clear();

    // Merges another set into this one.
    void merge(const CardinalitySet& other);

    // Serializes the current set content into a
    // platform-independent binary representation that we can send
    // around over the network,
    void serialize(ostream& out);

    // Restores a set's content from the binary representantion
    // that serialize() returns.
    void unserialize(istream& in);

    // Reports the current memory usage of this set in bytes;
    mainly for statistical purposes.
    size_t memoryUsage();
};