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