Indent fix.

[remoteglot-book] / binlookup.cpp

diff --git a/binlookup.cpp b/binlookup.cpp
index 5b5fd40f6101cfd29634506294dc03b8ffc7d719..286e831ff02ada183f1901cc7d73b66f44b1b227 100644 (file)
--- a/binlookup.cpp
+++ b/binlookup.cpp
@@ -6,40 +6,109 @@
 #include <memory>
 #include <string>
 #include <string.h>
-#include "count.h"
+#include <farmhash.h>
+#include "count.pb.h"
+#include "merge_count.h"
+#include "hash.h"
 
 using namespace std;
 
-int main(int argc, char **argv)
+string read_hex_line(FILE *fp)
 {
-       const char *hex_prefix = argv[2];
-       const int prefix_len = strlen(hex_prefix) / 2;
-       uint8_t *prefix = new uint8_t[prefix_len];
+       char hex[256];
+       if (fgets(hex, sizeof(hex), fp) == NULL) {
+               return "";
+       }
+       char *ptr = strchr(hex, '\n');
+       if (ptr != NULL) {
+               *ptr = 0;
+       }
 
-       for (int i = 0; i < prefix_len; ++i) {
+       string ret;
+       ret.resize(strlen(hex) / 2);
+
+       for (size_t i = 0; i < ret.size(); ++i) {
                char x[3];
-               x[0] = hex_prefix[i * 2 + 0];
-               x[1] = hex_prefix[i * 2 + 1];
+               x[0] = hex[i * 2 + 0];
+               x[1] = hex[i * 2 + 1];
                x[2] = 0;
                int k;
                sscanf(x, "%02x", &k);
-               prefix[i] = k;
+               ret[i] = k;
+       }
+       return ret;
+}
+
+int main(int argc, char **argv)
+{
+       int num_buckets = atoi(argv[2]);
+       mtbl_reader** mtbls = new mtbl_reader*[num_buckets];
+       const mtbl_source** srcs = new const mtbl_source*[num_buckets];
+       for (int i = 0; i < num_buckets; ++i) {
+               mtbls[i] = NULL;
+               srcs[i] = NULL;
+       }
+
+       while (!feof(stdin)) {
+               string bpfen = read_hex_line(stdin);
+               if (bpfen.empty()) {
+                       break;
+               }
+               string prev_pos_hash = read_hex_line(stdin);
+
+               string searchkey = bpfen + prev_pos_hash;
+               int bucket = hash_key_to_bucket(searchkey.data(), searchkey.size(), num_buckets);
+               if (mtbls[bucket] == NULL) {
+                       char filename[256];
+                       snprintf(filename, sizeof(filename), "%s.part%04d", argv[1], bucket);
+
+                       mtbls[bucket] = mtbl_reader_init(filename, NULL);
+                       srcs[bucket] = mtbl_reader_source(mtbls[bucket]);
+               }
+
+               // Give back the hash of the position to be kind to the user
+               uint16_t board_hash = util::Hash32(bpfen.data(), bpfen.size());
+               printf("%d\n", board_hash);
+
+               mtbl_iter *it = mtbl_source_get_prefix(srcs[bucket], (const uint8_t *)searchkey.data(), searchkey.size());
+
+               const uint8_t *key, *val;
+               size_t len_key, len_val;
+
+               Count c;
+               bool has_c = false;
+               while (mtbl_iter_next(it, &key, &len_key, &val, &len_val)) {
+                       if (has_c) {
+                               Count tmpc;
+                               tmpc.ParseFromArray(val, len_val);
+                               c = merge_count(c, tmpc);
+                       } else {
+                               c.ParseFromArray(val, len_val);
+                               has_c = true;
+                       }
+               }
+
+               if (has_c) {
+                       printf("%d %d %d %d %u %ld %ld %d %ld %d %ld",
+                               c.white(), c.draw(), c.black(), c.computer(),
+                               c.opening_num(), c.sum_white_elo(), c.sum_black_elo(),
+                               c.num_elo(), c.first_timestamp(),
+                               c.pgn_file_num(),
+                               c.pgn_start_position());
+                       for (int j = 0; j < c.move_size(); ++j) {
+                               printf(" %s", c.move(j).c_str());
+                       }
+                       printf("\n");
+               } else {
+                       printf("-\n");
+               }
+               fflush(stdout);
+               mtbl_iter_destroy(&it);
        }
 
-       mtbl_reader* mtbl = mtbl_reader_init(argv[1], NULL);
-       const mtbl_source *src = mtbl_reader_source(mtbl);
-               mtbl_iter *it = mtbl_source_get_prefix(src, prefix, prefix_len);
-
-       const uint8_t *key, *val;
-       size_t len_key, len_val;
-
-       while (mtbl_iter_next(it, &key, &len_key, &val, &len_val)) {
-               string move((char *)(key + prefix_len), len_key - prefix_len);
-               const Count* c = (Count *)val;
-               printf("%s %d %d %d %d %f %f %d\n", move.c_str(),
-                       c->white, c->draw, c->black, c->opening_num,
-                       float(c->sum_white_elo) / c->num_elo,
-                       float(c->sum_black_elo) / c->num_elo,
-                       c->num_elo);
+       for (int i = 0; i < num_buckets; ++i) {
+               if (mtbls[i] != NULL) {
+                       mtbl_reader_destroy(&mtbls[i]);
+               }
        }
 }