/home/ug/devel/kombilo-py-dev/kombilo/libkombilo/search.h

Go to the documentation of this file.

#ifndef _SEARCH_H_
#define _SEARCH_H_

#include <vector>
#include <utility>
#include <stack>
#include <fstream>
#include "sqlite3.h"
#include "pstdint.h"
#include <boost/unordered_map.hpp>

#include "abstractboard.h"
#include "sgfparser.h"
#include "algos.h"

class ProcessOptions {
  public:
    bool processVariations;
    bool sgfInDB;
    std::string rootNodeTags; 
    int algos;           
    int algo_hash_full_maxNumStones;
    int algo_hash_corner_maxNumStones;
    int professional_tag;               

    std::string asString();
    void validate();
    std::vector<std::string>* SGFTagsAsStrings();

    ProcessOptions(); 
    ProcessOptions(std::string s);
};

class SearchOptions {
  public:
    int fixedColor;
    int nextMove; // 0 undetermined, 1 = next move must be black, 2 = next move must be white
    int moveLimit;
    bool trustHashFull;
    bool searchInVariations;
    int algos;

    SearchOptions();
    SearchOptions(int FIXEDCOLOR, int NEXTMOVE=0, int MOVELIMIT=10000);
    SearchOptions(SnapshotVector& snv);
    void to_snv(SnapshotVector& snv);
};

class GameListEntry {
  public:
    int id; // id within the concerning database
    std::string gameInfoStr;
    char winner;
    int date;
    std::vector<Hit* > * hits; // used for hits
    std::vector<Candidate* > * candidates; // used for candidates

    GameListEntry(int ID, char WINNER, std::string GAMEINFOSTR, int DATE);
    ~GameListEntry();

    void hits_from_snv(SnapshotVector& snv);
    void set_hits(vector<Hit* > * hts);
    void set_candidates(vector<Candidate* > * cands);
};

class VarInfo {
  public:
    Node* n;
    abstractBoard* b;
    int i;

    VarInfo(Node* N, abstractBoard* B, int I);
    VarInfo(const VarInfo& v);
    ~VarInfo();
};


const int CHECK_FOR_DUPLICATES = 1; 
const int CHECK_FOR_DUPLICATES_STRICT = 2; 
const int OMIT_DUPLICATES = 4; 
const int OMIT_GAMES_WITH_SGF_ERRORS = 8; 

const int UNACCEPTABLE_BOARDSIZE = 1; // (database not changed) 
const int SGF_ERROR = 2;
const int IS_DUPLICATE = 4;
const int NOT_INSERTED_INTO_DB = 8;
const int INDEX_OUT_OF_RANGE = 16;
class GameList {
  private:
    std::vector<std::pair<int,int> > * currentList; // pair<int,int>: (database id, position within all )
                                                    // (usually sorted w.r.t. second component)
    std::vector<std::pair<int,int> > * oldList;
  public:
    char* dbname;
    std::string orderby;
    std::string format1;
    std::string format2;
    int numColumns;
    int processVariations;

    int boardsize;
    std::vector<algo_p> algo_ps;
    std::vector<GameListEntry* > * all;
    int current;
    sqlite3* db;
    char* labels;
    vector<Continuation* > continuations;
    int num_hits;
    int num_switched;
    int Bwins;    
    int BwinsG;   
    int BwinsAll; 
    int Wwins;    
    int WwinsG;   
    int WwinsAll; 
    Pattern* mrs_pattern; 
    SearchOptions* searchOptions;
    vector<int> dates_all; 
    vector<int> dates_all_per_year; 
    vector<int> dates_current; 
    // ----------------------------------------------------------------------------
    // the following methods provide the user interface

    // ------- constructor --------------------------------------------------------
    GameList(
        const char* DBNAME, 
        std::string ORDERBY="",
        std::string FORMAT="",

        ProcessOptions* p_options=0, 
        int BOARDSIZE=19, 
        int cache=100 
          ) throw(DBError);
    ~GameList();


    int process(const char* sgf, const char* path, const char* fn, std::vector<GameList* > glists, const char* DBTREE = 0, int flags=0) throw(SGFError,DBError);

    int process_results(unsigned int i=0); // result for i-th processed game in most recently processed SGF collection

    void start_processing(int PROCESSVARIATIONS=-1) throw(DBError);
    void finalize_processing() throw(DBError);

    void search(Pattern& pattern, SearchOptions* options = 0) throw(DBError);
    char lookupLabel(char x, char y);
    void setLabel(char x, char y, char label);
    Continuation lookupContinuation(char x, char y);
    int numHits(); 


    void sigsearch(char* sig) throw(DBError);
    vector<int> sigsearchNC(char* sig) throw(DBError); // sig search in all; do not change currentList
    std::string getSignature(int i) throw(DBError);

    void gisearch(const char* sql, int complete=0) throw(DBError);
    
    vector<int>* gisearchNC(const char* sql, int complete=0) throw(DBError);

    void tagsearch(int tag) throw(DBError); 

    void tagsearchSQL(char* query) throw(DBError);
    void setTag(int tag, int start=0, int end=0) throw(DBError);


    void setTagID(int tag, int i) throw(DBError); 

    vector<int> getTagsID(int i, int tag=0) throw(DBError);

    void deleteTag(int tag, int i = -1) throw(DBError); 


    std::vector<int> getTags(unsigned int i, int tag=0) throw(DBError); // note the order of arguments!
    void export_tags(string tag_db_name, vector<int> which_tags);
    void import_tags(string tag_db_name);



    int snapshot() throw(DBError);
    void restore(int handle, bool del=false) throw(DBError);
    void delete_snapshot(int handle) throw(DBError);
    void delete_all_snapshots() throw(DBError);
    // ------- misc ---------------------------------------------------------------
    void reset(); 
    void resetFormat(std::string ORDERBY="", std::string FORMAT=""); 
    int size(); 
    int size_all(); 
    std::string get_resultsStr(unsigned int i);
    std::string resultsStr(GameListEntry* gle);
    int find_by_ID(int ID);



    std::string get_gameInfoStr(unsigned int i);
    pair<int, int> get_currentList_entry(unsigned int i);
    std::string currentEntryAsString(int i);
    std::vector<std::string> currentEntriesAsStrings(int start=0, int end=0);
    std::string getSGF(int i) throw(DBError);
    std::string getCurrentProperty(int i, std::string tag) throw (DBError);

    int plSize();
    std::string plEntry(int i);
    friend class Algo_finalpos;
    friend class Algo_movelist;
    friend class Algo_hash_full;
    friend class Algo_hash;
    friend class Algo_hash_corner;
    friend int gis_callback(void *gl, int argc, char **argv, char **azColName);
    friend int gis_callbackNC(void *pair_gl_CL, int argc, char **argv, char **azColName);

  private:
    void createGamesDB() throw(DBError);
    void open_db() throw(DBError);
    void readDB() throw(DBError);
    void addAlgos(bool NEW);
    int db_cache_size;
    int posDT; // used when parsing the DT, SZ, BR, WR, HA fields during processing
    int posSZ;
    int posBR;
    int posWR;
    int posHA;
    int SGFtagsSize;
    ProcessOptions* p_op;
    std::vector<std::string>* SGFtags;
    std::string sql_ins_rnp; // sql string to insert root node properties
    std::vector<std::string> pl; // list of all players
    void readPlayersList() throw(DBError);
    std::vector<std::vector<int> >* duplicates;
    std::vector<int> process_results_vector;

    int startO();
    int start();
    int next();
    int start_sorted();
    int end_sorted();
    void update_dates_current();
    int get_current_index(int id, int* start); // returns the index in oldList of the game with game id "id" 
                                               // (if available, otherwise returns -1),
                                               // use this between start_sorted and end_sorted
    int get_current_index_CL(int id, int start=0); // returns the index in currentList of the game with game id "id" 
                                                   // (if available, otherwise returns -1), requires currentList to
                                                   // be sorted wrt first component (see duplicates())
    char getCurrentWinner();
    int getCurrentDate();
    std::vector<Candidate* > *getCurrentCandidateList();
    void makeCurrentCandidate(std::vector<Candidate* > *candidates);
    void makeCurrentHit(std::vector<Hit* > *hits);
    void makeIndexCandidate(int index, std::vector<Candidate* > *candidates);
    void makeIndexHit(int index, std::vector<Hit* > *hits, vector<int>* CL = 0);
    
    void setCurrentFromIndex(int index);
    void readNumOfWins() throw(DBError);
};

// ------- duplicates ---------------------------------------------------------
std::map<std::string, std::vector<int> >  find_duplicates(std::vector<string> glists, bool strict=false, bool dupl_within_db=false) throw(DBError);



const int HANDI_TAG = 1;
const int PROFESSIONAL_TAG = 2;

#endif