pinyinime.cpp

/*
 * SPDX-FileCopyrightText: 2017-2017 CSSlayer <wengxt@gmail.com>
 *
 * SPDX-License-Identifier: LGPL-2.1-or-later
 */
#include "pinyinime.h"
#include <cstddef>
#include <limits>
#include <memory>
#include <string>
#include <utility>
#include <fcitx-utils/connectableobject.h>
#include <fcitx-utils/macros.h>
#include "libime/core/decoder.h"
#include "libime/core/lattice.h"
#include "libime/core/userlanguagemodel.h"
#include "libime/pinyin/pinyincorrectionprofile.h"
#include "libime/pinyin/pinyindecoder.h"
#include "libime/pinyin/pinyindecoder_p.h"
#include "libime/pinyin/pinyinencoder.h"

namespace libime {

class PinyinIMEPrivate : fcitx::QPtrHolder<PinyinIME> {
public:
    PinyinIMEPrivate(PinyinIME *q, std::unique_ptr<PinyinDictionary> dict,
                     std::unique_ptr<UserLanguageModel> model)
        : fcitx::QPtrHolder<PinyinIME>(q), dict_(std::move(dict)),
          model_(std::move(model)),
          decoder_(std::make_unique<PinyinDecoder>(dict_.get(), model_.get())) {
        model_->setCodeExtractor([](const WordNode *node) -> std::string {
            if (const auto *pinyinNode =
                    dynamic_cast<const PinyinLatticeNode *>(node)) {
                return pinyinNode->encodedPinyin();
            }
            if (const auto *wordNode =
                    dynamic_cast<const PinyinWordNode *>(node)) {
                return wordNode->encodedPinyin();
            }
            return "";
        });
    }

    FCITX_DEFINE_SIGNAL_PRIVATE(PinyinIME, optionChanged);

    PinyinFuzzyFlags flags_;
    std::unique_ptr<PinyinDictionary> dict_;
    std::unique_ptr<UserLanguageModel> model_;
    std::unique_ptr<PinyinDecoder> decoder_;
    std::shared_ptr<const ShuangpinProfile> spProfile_;
    std::shared_ptr<const PinyinCorrectionProfile> correctionProfile_;
    size_t nbest_ = 1;
    size_t beamSize_ = Decoder::beamSizeDefault;
    size_t frameSize_ = Decoder::frameSizeDefault;
    size_t partialLongWordLimit_ = 0;
    size_t wordCandidateLimit_ = 15;
    float maxDistance_ = std::numeric_limits<float>::max();
    float minPath_ = -std::numeric_limits<float>::max();
    PinyinPreeditMode preeditMode_ = PinyinPreeditMode::RawText;
};

PinyinIME::PinyinIME(std::unique_ptr<PinyinDictionary> dict,
                     std::unique_ptr<UserLanguageModel> model)
    : d_ptr(std::make_unique<PinyinIMEPrivate>(this, std::move(dict),
                                               std::move(model))) {}

PinyinIME::~PinyinIME() {}

PinyinFuzzyFlags PinyinIME::fuzzyFlags() const {
    FCITX_D();
    return d->flags_;
}

void PinyinIME::setFuzzyFlags(PinyinFuzzyFlags flags) {
    FCITX_D();
    d->flags_ = flags;
    emit<PinyinIME::optionChanged>();
}

PinyinDictionary *PinyinIME::dict() {
    FCITX_D();
    return d->dict_.get();
}

const PinyinDictionary *PinyinIME::dict() const {
    FCITX_D();
    return d->dict_.get();
}

const PinyinDecoder *PinyinIME::decoder() const {
    FCITX_D();
    return d->decoder_.get();
}

UserLanguageModel *PinyinIME::model() {
    FCITX_D();
    return d->model_.get();
}

const UserLanguageModel *PinyinIME::model() const {
    FCITX_D();
    return d->model_.get();
}

size_t PinyinIME::nbest() const {
    FCITX_D();
    return d->nbest_;
}

void PinyinIME::setNBest(size_t n) {
    FCITX_D();
    if (d->nbest_ != n) {
        d->nbest_ = n;
        emit<PinyinIME::optionChanged>();
    }
}

size_t PinyinIME::beamSize() const {
    FCITX_D();
    return d->beamSize_;
}

void PinyinIME::setBeamSize(size_t n) {
    FCITX_D();
    if (d->beamSize_ != n) {
        d->beamSize_ = n;
        emit<PinyinIME::optionChanged>();
    }
}

size_t PinyinIME::frameSize() const {
    FCITX_D();
    return d->frameSize_;
}

void PinyinIME::setFrameSize(size_t n) {
    FCITX_D();
    if (d->frameSize_ != n) {
        d->frameSize_ = n;
        emit<PinyinIME::optionChanged>();
    }
}

size_t PinyinIME::partialLongWordLimit() const {
    FCITX_D();
    return d->partialLongWordLimit_;
}

void PinyinIME::setPartialLongWordLimit(size_t n) {
    FCITX_D();
    if (d->partialLongWordLimit_ != n) {
        d->partialLongWordLimit_ = n;
        emit<PinyinIME::optionChanged>();
    }
}

size_t PinyinIME::wordCandidateLimit() const {
    FCITX_D();
    return d->wordCandidateLimit_;
}

void PinyinIME::setWordCandidateLimit(size_t n) {
    FCITX_D();
    if (d->wordCandidateLimit_ != n) {
        d->wordCandidateLimit_ = n;
        emit<PinyinIME::optionChanged>();
    }
}

void PinyinIME::setPreeditMode(PinyinPreeditMode mode) {
    FCITX_D();
    if (d->preeditMode_ != mode) {
        d->preeditMode_ = mode;
        emit<PinyinIME::optionChanged>();
    }
}

PinyinPreeditMode PinyinIME::preeditMode() const {
    FCITX_D();
    return d->preeditMode_;
}

void PinyinIME::setScoreFilter(float maxDistance, float minPath) {
    FCITX_D();
    if (d->maxDistance_ != maxDistance || d->minPath_ != minPath) {
        d->maxDistance_ = maxDistance;
        d->minPath_ = minPath;
        emit<PinyinIME::optionChanged>();
    }
}

float PinyinIME::maxDistance() const {
    FCITX_D();
    return d->maxDistance_;
}

float PinyinIME::minPath() const {
    FCITX_D();
    return d->minPath_;
}

void PinyinIME::setShuangpinProfile(
    std::shared_ptr<const ShuangpinProfile> profile) {
    FCITX_D();
    if (d->spProfile_ != profile) {
        d->spProfile_ = std::move(profile);
        emit<PinyinIME::optionChanged>();
    }
}

std::shared_ptr<const ShuangpinProfile> PinyinIME::shuangpinProfile() const {
    FCITX_D();
    return d->spProfile_;
}

void PinyinIME::setCorrectionProfile(
    std::shared_ptr<const PinyinCorrectionProfile> profile) {
    FCITX_D();
    if (d->correctionProfile_ != profile) {
        d->correctionProfile_ = std::move(profile);
        emit<PinyinIME::optionChanged>();
    }
}

std::shared_ptr<const PinyinCorrectionProfile>
PinyinIME::correctionProfile() const {
    FCITX_D();
    return d->correctionProfile_;
}

} // namespace libime