Cleanup includes

Author: khalid-a-omar

src/book/book.cpp

@@ -6,22 +6,25 @@
 #include "ctg/ctg.h"
 #include "book.h"
 
-namespace Polyfish::Book
+namespace Polyfish
 {
-    /*static*/ Book* Book::create_book(const std::string& filename)
+    namespace Book
     {
-        size_t extIndex = filename.find_last_of('.');
-        if (extIndex == std::string::npos)
-            return nullptr;
+        /*static*/ Book* Book::create_book(const std::string& filename)
+        {
+            size_t extIndex = filename.find_last_of('.');
+            if (extIndex == std::string::npos)
+                return nullptr;
 
-        std::string ext = filename.substr(extIndex + 1);
+            std::string ext = filename.substr(extIndex + 1);
 
-        if (ext == "ctg" || ext == "cto" || ext == "ctb")
-            return new CTG::CtgBook();
-        else if (ext == "bin")
-            return new Polyglot::PolyglotBook();
-        else
-            return nullptr;
+            if (ext == "ctg" || ext == "cto" || ext == "ctb")
+                return new CTG::CtgBook();
+            else if (ext == "bin")
+                return new Polyglot::PolyglotBook();
+            else
+                return nullptr;
+        }
     }
 }
 

src/book/book.h

@@ -3,78 +3,83 @@
 #ifndef BOOK_H_INCLUDED
 #define BOOK_H_INCLUDED
 
-namespace Polyfish::Book
+namespace Polyfish
 {
-    namespace
-    {
-        static const union { uint32_t i; char c[4]; } Le = { 0x01020304 };
-        static const bool IsBigEndian = (Le.c[0] == 1);
-    }
+    class BookManager;
 
-    class BookUtil
+    namespace Book
     {
-    public:
-        template <typename IntType>
-        static IntType read_big_endian(const unsigned char* buffer, size_t& offset, size_t bufferLen)
+        namespace
         {
-            IntType result;
-            constexpr size_t typeSize = sizeof(IntType);
+            static const union { uint32_t i; char c[4]; } Le = { 0x01020304 };
+            static const bool IsBigEndian = (Le.c[0] == 1);
+        }
 
-            if (offset + typeSize > bufferLen)
+        class BookUtil
+        {
+        public:
+            template <typename IntType>
+            static IntType read_big_endian(const unsigned char* buffer, size_t& offset, size_t bufferLen)
             {
-                assert(false);
-                return IntType();
-            }
+                IntType result;
+                constexpr size_t typeSize = sizeof(IntType);
 
-            //Read the integer type and convert (if needed)
-            memcpy(&result, buffer + offset, typeSize);
+                if (offset + typeSize > bufferLen)
+                {
+                    assert(false);
+                    return IntType();
+                }
 
-            if (!IsBigEndian)
-            {
-                unsigned char u[typeSize];
-                typename std::make_unsigned<IntType>::type v = 0;
+                //Read the integer type and convert (if needed)
+                memcpy(&result, buffer + offset, typeSize);
+
+                if (!IsBigEndian)
+                {
+                    unsigned char u[typeSize];
+                    typename std::make_unsigned<IntType>::type v = 0;
+
+                    memcpy(&u, &result, typeSize);
+                    for (size_t i = 0; i < typeSize; ++i)
+                        v = (v << 8) | u[i];
 
-                memcpy(&u, &result, typeSize);
-                for (size_t i = 0; i < typeSize; ++i)
-                    v = (v << 8) | u[i];
+                    memcpy(&result, &v, typeSize);
+                }
 
-                memcpy(&result, &v, typeSize);
+                offset += typeSize;
+                return result;
             }
 
-            offset += typeSize;
-            return result;
-        }
+            template <typename IntType>
+            static IntType read_big_endian(const unsigned char* buffer, size_t bufferLen)
+            {
+                size_t offset = 0;
+                return read_big_endian<IntType>(buffer, offset, bufferLen);
+            }
+        };
 
-        template <typename IntType>
-        static IntType read_big_endian(const unsigned char* buffer, size_t bufferLen)
+        class Book
         {
-            size_t offset = 0;
-            return read_big_endian<IntType>(buffer, offset, bufferLen);
-        }
-    };
+            friend class Polyfish::BookManager;
 
-    class Book
-    {
-        friend class Polyfish::BookManager;
-
-    private:
-        static Book* create_book(const std::string& filename);
+        private:
+            static Book* create_book(const std::string& filename);
 
-    public:
-        Book() { }
-        virtual ~Book() { }
+        public:
+            Book() { }
+            virtual ~Book() { }
 
-        Book(const Book&) = delete;
-        Book& operator=(const Book&) = delete;
+            Book(const Book&) = delete;
+            Book& operator=(const Book&) = delete;
 
-        virtual std::string type() const = 0;
+            virtual std::string type() const = 0;
 
-        virtual bool open(const std::string& filename) = 0;
-        virtual void close() = 0;
+            virtual bool open(const std::string& filename) = 0;
+            virtual void close() = 0;
 
-        virtual Move probe(const Position& pos, size_t width, bool onlyGreen) const = 0;
-        virtual void show_moves(const Position& pos) const = 0;
-    };
+            virtual Move probe(const Position& pos, size_t width, bool onlyGreen) const = 0;
+            virtual void show_moves(const Position& pos) const = 0;
+        };
+    }
 }
 
 #endif

src/book/book_manager.cpp

@@ -1,6 +1,5 @@
 #if defined(POLYFISH)
 
-#include "../misc.h"
 #include "../uci.h"
 #include "polyglot/polyglot.h"
 #include "ctg/ctg.h"