Changeset 239 for 06/libkombilo/search.h

Timestamp:

03/09/07 16:38:11 (22 months ago)

Author:

ug

Message:

Handling of duplicates within GameList, also during process.
Better access to processing results.

Files:

• 06/libkombilo/search.h (modified) (13 diffs)

06/libkombilo/search.h

@@ -201 +201 @@
     virtual void branchpoint_process();
     virtual void endOfVariation_process();
-    virtual void endgame_process();
+    virtual void endgame_process(bool commit=true);
     virtual void finalize_process();
     virtual int readDB(sqlite3* DB);
@@ -225 +225 @@
     void branchpoint_process();
     void endOfVariation_process();
-    void endgame_process() throw(DBError);
+    void endgame_process(bool commit=true) throw(DBError);
     void finalize_process();
 
     int counter;
     char* signature;
+    char* get_current_signature();
+    std::vector<int> search_signature(char* sig);
   private:
     bool main_variation;
@@ -248 +250 @@
     void branchpoint_process();
     void endOfVariation_process();
-    void endgame_process() throw(DBError);
+    void endgame_process(bool commit=true) throw(DBError);
     void finalize_process();
 
@@ -256 +258 @@
     int readDB(sqlite3* DB);
     int search(PatternList& patternList, GameList& gl, SearchOptions& options);
+
+    bool equal(unsigned int id1, unsigned int id2); // id1, id2 refer to id's in the database!
+    bool equals_current(unsigned int id1);
 };
 
@@ -317 +322 @@
     void branchpoint_process();
     void endOfVariation_process();
-    void endgame_process() throw(DBError);
+    void endgame_process(bool commit=true) throw(DBError);
     void finalize_process();
     int readDB(sqlite3* DB);
@@ -329 +334 @@
 };
 
+class HashFEntry {
+  public:
+    hashtype hashCode;
+    char* buf;
+    int length;
+
+    HashFEntry(hashtype HASHCODE, char* BUF, int LENGTH);
+    HashFEntry(const HashFEntry& hfe);
+    ~HashFEntry();
+};
 
 class HashhitF { // hashing hit for full board search
@@ -374 +389 @@
     void branchpoint_process();
     void endOfVariation_process() throw(DBError);
-    void endgame_process() throw(DBError);
+    void endgame_process(bool commit=true) throw(DBError);
     void finalize_process();
     int search(PatternList& patternList, GameList& gl, SearchOptions& options, sqlite3* db);
 
-    int insert_hash(hashtype hashCode, ExtendedMoveNumber& mn, Move* continuation);
     hashtype compute_hashkey(Pattern& pattern);
 
+    int maxNumStones;
+    int numStones;
+  private:
     hashtype currentHashCode;
     ExtendedMoveNumber* moveNumber;
     std::vector<std::pair<hashtype, ExtendedMoveNumber>* > *lfc; // hash code + move number, still looking for continuation
     std::stack<HashVarInfo>* branchpoints;
-    int maxNumStones;
-    int numStones;
+    int insert_hash(hashtype hashCode, ExtendedMoveNumber& mn, Move* continuation);
+    int insert_all_hashes();
+    std::vector<HashFEntry> hash_vector;
 };
 
@@ -439 +457 @@
     virtual void branchpoint_process();
     virtual void endOfVariation_process();
-    virtual void endgame_process();
+    virtual void endgame_process(bool commit=true);
     virtual void finalize_process();
     virtual int search(PatternList& patternList, GameList& gl, SearchOptions& options, sqlite3* db);
 
+    virtual std::pair<hashtype,int> compute_hashkey(PatternList& pl, int CS);
+    static const hashtype hashCodes[];
+    std::string dbnameext;
+    std::vector<HashInstance>* hi;
+    int maxNumStones;
+    std::vector<std::pair<hashtype, int> > hash_vector;
     virtual int insert_hash(hashtype hashCod, int pos);
-    virtual std::pair<hashtype,int> compute_hashkey(PatternList& pl, int CS);
-    std::vector<HashInstance>* hi;
-    std::string dbnameext;
-    int maxNumStones;
-
-    static const hashtype hashCodes[];
+    int insert_all_hashes();
 };
 
@@ -569 +588 @@
     ~VarInfo();
 };
+
+// process flags (used to determine the behavior for individual games - in contrast to
+// options which apply to the whole GameList and are given in ProcessOptions)
+const int CHECK_FOR_DUPLICATES = 1; // check for duplicates using the signature
+const int CHECK_FOR_DUPLICATES_STRICT = 2; // check for duplicates using the final position
+                                           // (if ALGO_FINAPOS is available)
+const int OMIT_DUPLICATES = 4;
+const int OMIT_GAMES_WITH_SGF_ERRORS = 8; 
+const int INDEX_OUT_OF_RANGE = 16;
+
+// process return values
+// 0:   SGF error occurred when parsing the "tree structure" (i.e. before parsing the individual nodes)
+//      database was not changed
+// n>0: n games were processed, use process_results to access the individual results 
+
+// flags used in process_results
+const int UNACCEPTABLE_BOARDSIZE = 1; // (database not changed) 
+const int SGF_ERROR = 2;
+    // SGF error occurred when playing through the game 
+    // (and the rest of the concerning variation was not used).
+    // Depending on OMIT_GAMES_WITH_SGF_ERRORS, everything before this node (and other variations, 
+    // if any) was inserted, or the database was not changed.
+const int IS_DUPLICATE = 4;
+const int NOT_INSERTED_INTO_DB = 8;
+
 
 class GameList {
@@ -606 +650 @@
     // ------- processing SGF games (to populate the db) --------------------------
     void start_processing(int PROCESSVARIATIONS=-1) throw(DBError);
-    int process(const char* sgf, const char* path, const char* fn, const char* DBTREE = 0) throw(SGFError,DBError);
+    int process(const char* sgf, const char* path, const char* fn,
+                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 finalize_processing() throw(DBError);
     
+    // int remove_game(int index); // TODO
+    // int remove_all_current_games();
+
     // ------- pattern search -----------------------------------------------------
     // options is copied in the search method (if != 0), so the caller has to free the pointer
@@ -629 +678 @@
     void deleteTag(int tag, int i = -1) throw(DBError);
     std::vector<int> getTags(int i, int tag=0) throw(DBError); // note the order of arguments!
+    
+    // ------- duplicates ---------------------------------------------------------
+    int find_duplicates(int bs, bool strict=false) throw(DBError); // return number of duplicate array
+    std::vector<int> retrieve_duplicates_VI(unsigned int i);
+    int* retrieve_duplicates_PI(unsigned int i); // same as above, but returns Pointer to Int 
+                                                 // (an array terminated by -1)
+                                                 // The caller must free the pointer himself
+                                                 // (before calling find_duplicates again).
 
     // ------- misc ---------------------------------------------------------------
@@ -659 +716 @@
     void makeIndexHit(int index, std::vector<Hit* > *hits);
     void setCurrentFromIndex(int index);
+    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())
 
   private:
@@ -678 +741 @@
     std::vector<std::string> pl; // list of all players
     void readPlayersList() throw(DBError);
+    std::vector<std::vector<int> >* duplicates;
+    void insert_duplicate(int i1, int i2, std::vector<std::vector<int> >* dupl);
+    std::vector<int> process_results_vector;
 };