spelling.h

/*
# Copyright (C) 2015 Fulvio Benini
 
* This file is part of Scid (Shane's Chess Information Database).
*
* Scid is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation.
*
* Scid is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Scid. If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef SCID_SPELLING_SPELLING_H
#define SCID_SPELLING_SPELLING_H
 
#include "scid/database/namebase.h"
#include "scid/core/date.h"
#include <deque>
#include <memory>
#include <string>
#include <vector>
#include <utility>
 
/*
* A "spelling" file contains the correct names for players, events, sites and rounds.
* Optionally it can provide further informations for players like elo, birthdate, etc..
* See the header of spelling.ssp for a more detailed description of the format.
*/
 
namespace scid::spelling {
 
class NameNormalizer {
    typedef std::vector< std::pair<std::string,std::string> > Cont;
    Cont prefix_;
    Cont infix_ ;
    Cont suffix_;
 
public:
    size_t normalize(std::string* name) const;
 
    scid::core::errorT addPrefix(const char* s);
    scid::core::errorT addInfix (const char* s);
    scid::core::errorT addSuffix(const char* s);
 
private:
    scid::core::errorT add(Cont& v, const char* s);
};
 
 
class PlayerElo {
    std::vector< std::pair<uint16_t, scid::core::ratingT> > elo_;
 
public:
    void addEloData(const char* str);
 
    scid::core::ratingT getElo (scid::core::dateT date) const;
 
#ifdef SCID_SPELLING_VALIDATE
    std::string isValid() const;
#endif
};
 
 
class PlayerInfo {
    const char* comment_;
    std::vector<const char*> bio_;
 
    friend class SpellingLoader;
    friend class SpellChecker;
 
public:
    PlayerInfo(const char* s) : comment_(s) {}
    const char* getTitle() const;
    std::string getLastCountry() const;
    scid::core::dateT getBirthdate() const;
    scid::core::dateT getDeathdate() const;
    scid::core::ratingT getPeakRating() const;
    const char* getComment() const;
};
 
 
class SpellChecker {
    struct Idx {
        std::string alias;
        int32_t idx;
 
        Idx();
        Idx(const std::string& a, int32_t i);
        bool operator<(const Idx& b) const;
        bool operator<(const std::string& b) const;
    };
    typedef std::vector<Idx>::const_iterator IdxIt;
 
    NameNormalizer general_[scid::database::NUM_NAME_TYPES];
    std::string excludeChars_[scid::database::NUM_NAME_TYPES];
    std::vector<Idx> idx_[scid::database::NUM_NAME_TYPES];
    std::vector<const char*> names_[scid::database::NUM_NAME_TYPES];
    std::vector<PlayerInfo> pInfo_;
    std::vector<PlayerElo>  pElo_;
    std::deque<std::string> strings_;
 
    friend class SpellingLoader;
 
public:
    static std::pair<scid::core::errorT, std::unique_ptr<SpellChecker>> create(
        const char* filename, const scid::database::Progress& progress);
 
    std::vector<const char*> find(const scid::database::nameT& nt, const char* name, scid::core::uint nMaxRes = 10) const;
 
    const NameNormalizer& getGeneralCorrections(const scid::database::nameT& nt) const;
 
    const PlayerInfo* getPlayerInfo(const char* name,
                                    std::vector<const char*>* bio = 0) const;
 
    const PlayerElo* getPlayerElo(const char* name) const;
 
    bool hasEloData() const;
 
    size_t numCorrectNames(const scid::database::nameT& nt) const;
 
private:
    SpellChecker() = default;
    SpellChecker(const SpellChecker&) = delete;
    SpellChecker& operator=(const SpellChecker&) = delete;
 
    scid::core::errorT read(const char* filename, const scid::database::Progress& progress);
 
    const char* storeString(const char* s);
 
    std::string normalizeAndTransform(const scid::database::nameT& nt, const char* s) const;
 
    std::pair<IdxIt, IdxIt> idxFind(const scid::database::nameT& nt, const char* prefix) const;
 
    std::pair<IdxIt, IdxIt> idxFindPlayer(const char* prefix) const;
 
    IdxIt idxFindPlayerUnambiguous(const char* name) const;
 
    class SpellingValidate;
 
};
 
 
} // namespace scid::spelling
 
#endif