dictionary.hpp

#pragma once
 
#include "../core/sortedRefArray.hpp"
#include "../core/string.hpp"
#include "../core/timeout.hpp"
 
#include "../core/sortedRefArray.hpp"
#include "dictionary/dictRange.hpp"
 
namespace z {
namespace util {
class dictionary : public core::sortedRefArray<zstring *> {
private:
    bool caseSensitive;
    bool readingStream;
    int maxWordLen;
 
public:
    dictionary(bool caseSensitive = false) noexcept;

    dictionary(const dictionary &other) noexcept;

    ~dictionary() noexcept;

    void clear() noexcept;

    bool read(const zstring &filename, const core::timeout &time = -1, bool assumePresorted = false);

    void write(const zstring &filename);

    bool isWord(const zstring &word) const noexcept;

    void addWord(const zstring &word) noexcept;

    bool isCaseSensitive() const noexcept;

    void setCaseSensitive(bool caseSensitive) noexcept;

    dictRange range() const noexcept;

    bool narrow(dictRange *wordRange, uint32_t nextChar) const noexcept;

    int maxWordLength() const noexcept;

    dictionary filter(std::function<bool(const zstring &)> lambda) const;

    dictionary &operator=(dictionary &&other) noexcept;

    dictionary &operator=(const dictionary &other) noexcept;

    z::core::array<zstring> findPermutations(const zstring &scrambled) const noexcept;
 
#ifdef __has_include
#if __has_include(<cereal/cereal.hpp>)
    template <typename archive>
    void save(archive &ar) const {
        ar((CEREAL_SIZE_TYPE)length());
        for (int i = 0; i < length(); i++) {
            ar(*at(i));
        }
    }

    template <class archive>
    void load(archive &ar) {
        clear();
        CEREAL_SIZE_TYPE sz;
        ar(sz);
        increase(sz);
 
        for (CEREAL_SIZE_TYPE i = 0; i < sz; i++) {
            zstring *data = new zstring;
            ar(*data);
            append(data);
        }
    }
#endif
#endif
};
} // namespace util
} // namespace z