Added debug waring flags

premake5.lua

@@ -36,6 +36,7 @@ project "bakatools"
         }
     
     filter "configurations:Debug"
+        buildoptions { "-Wall", "-Wextra" }
         defines 
         { 
             "BK_DEBUG",

src/bakatools/file_system/dir_entry.h

@@ -41,7 +41,6 @@ namespace Bk
             
             bool move(std::string path);
             bool rename(std::string name);
-            virtual int remove() { return (int)false; }
             virtual void copy(std::string path, CopyOption opt) {}
 
 

src/bakatools/file_system/directory.cpp

@@ -1,9 +1,10 @@
 #include "directory.h"
 
 namespace Bk {
-    bool Directory::create()
+    Directory Directory::create(std::string path)
     {
-        return std::filesystem::create_directory(ent.path());
+        std::filesystem::create_directory(path);
+        return Directory(path);
     }
 
     std::string Directory::current()
@@ -11,9 +12,10 @@ namespace Bk {
         return std::filesystem::current_path();
     }
 
-    int Directory::remove()
+    Directory Directory::remove()
     {
-        return std::filesystem::remove_all(ent.path());
+        std::filesystem::remove_all(ent.path());
+        return Directory(path());
     }
 
     void Directory::copy(std::string path, CopyOption opt)

src/bakatools/file_system/directory.h

@@ -15,8 +15,8 @@ namespace Bk {
 
             virtual ~Directory() {}
 
-            bool create();
+            static Directory create(std::string path);
-            int remove() override;
+            Directory remove();
             void copy(std::string path, CopyOption opt = CopyOption::recursive) override;
 
             std::vector<DirEntry> entries();

src/bakatools/file_system/file.h

@@ -17,7 +17,7 @@ namespace Bk {
 
             virtual ~File() {}
 
-            int remove() override;
+            int remove();
             void copy(std::string path, CopyOption opt = CopyOption::overwrite_existing) override;
 
             Type::DataStream read(int size);

src/bakatools/json/json_node.h

@@ -6,8 +6,9 @@ namespace Bk::Json
 {
     class Node;
     
-    using Object = std::map<std::string, std::shared_ptr<Node>>;
+    using Pointer = std::shared_ptr<Node>;
-    using List = std::vector<std::shared_ptr<Node>>;
+    using Object = std::map<std::string, Pointer>;
+    using List = std::vector<Pointer>;
 
     class Node 
     {

src/bakatools/json/json_parser.cpp

@@ -29,7 +29,7 @@ namespace Bk::Json
         lexer = Lexer(data);
     }
 
-    std::shared_ptr<Json::Node> Parser::parse() 
+    Pointer Parser::parse() 
     {
         Token token;
         while (lexer.has_more_tokens()) {
@@ -40,33 +40,33 @@ namespace Bk::Json
                 {
                     case TokenType::CURLY_OPEN: 
                     {
-                        std::shared_ptr<Json::Node> parsed_object = parse_object();
+                        Pointer parsed_object = parse_object();
                         root = parsed_object;
                         break;
                     }
                     case TokenType::ARRAY_OPEN: 
                     {
-                        std::shared_ptr<Json::Node> parsed_list = parse_list();
+                        Pointer parsed_list = parse_list();
                         root = parsed_list;
                         break;
                     }
 
                     case TokenType::STRING: 
                     {
-                        std::shared_ptr<Json::Node> parsed_string = parse_string();
+                        Pointer parsed_string = parse_string();
                         root = parsed_string;
                         break;
                     }
                     case TokenType::NUMBER: 
                     {
-                        std::shared_ptr<Json::Node> parsed_number = parse_number();
+                        Pointer parsed_number = parse_number();
                         root = parsed_number;
                         break;
                     }
                     
                     case TokenType::BOOLEAN: 
                     {
-                        std::shared_ptr<Json::Node> parsed_boolean = parse_boolean();
+                        Pointer parsed_boolean = parse_boolean();
                         break;
                     }
                 }
@@ -74,7 +74,7 @@ namespace Bk::Json
             catch(std::logic_error& e)
             {
                 BK_INFO(e.what());
-                auto node = std::shared_ptr<Json::Node>();
+                auto node = Pointer();
                 node->set_null();
                 root = node;
                 break;
@@ -83,9 +83,9 @@ namespace Bk::Json
         return root;
     }
 
-    std::shared_ptr<Json::Node> Parser::parse_list() 
+    Pointer Parser::parse_list() 
     {
-        std::shared_ptr<Json::Node> node = std::make_shared<Json::Node>();
+        Pointer node = Pointer();
         Json::List* list = new Json::List();
         bool has_completed = false;
         Token next_token;
@@ -103,7 +103,7 @@ namespace Bk::Json
                     has_completed = true;
                     break;
                 }
-                std::shared_ptr<Json::Node> node;
+                Pointer node;
                 switch (next_token.type) 
                 {
                     case TokenType::ARRAY_OPEN: 
@@ -143,10 +143,10 @@ namespace Bk::Json
         return node;
     }
 
-    std::shared_ptr<Json::Node> Parser::parse_object() 
+    Pointer Parser::parse_object() 
     {
         std::string key = "";
-        std::shared_ptr<Json::Node> node = std::make_shared<Json::Node>();
+        Pointer node = Pointer();
         Json::Object *key_object_map = new Json::Object();
         bool has_completed = false;
         bool no_key = true;
@@ -171,7 +171,7 @@ namespace Bk::Json
                 next_token = lexer.get_token();
                 if (next_token.type == TokenType::COLON || next_token.type == TokenType::COMMA)
                     continue;
-                std::shared_ptr<Json::Node> node;
+                Pointer node;
                 switch (next_token.type) 
                 {
                     case TokenType::STRING: 
@@ -223,36 +223,36 @@ namespace Bk::Json
         return node;    
     }
 
-    std::shared_ptr<Json::Node> Parser::parse_string() 
+    Pointer Parser::parse_string() 
     {
-        std::shared_ptr<Json::Node> node = std::make_shared<Json::Node>();
+        Pointer node = Pointer();
         Token token = lexer.roll_back_token();
         std::string *sValue = new std::string(token.value);
         node->set_string(sValue);
         return node;
     }
 
-    std::shared_ptr<Json::Node> Parser::parse_number() 
+    Pointer Parser::parse_number() 
     {
-        std::shared_ptr<Json::Node> node = std::make_shared<Json::Node>();
+        Pointer node = Pointer();
         Token token = lexer.roll_back_token();
         float fValue = std::stof(token.value);
         node->set_float(fValue);
         return node;
     }
 
-    std::shared_ptr<Json::Node> Parser::parse_boolean() 
+    Pointer Parser::parse_boolean() 
     {
-        std::shared_ptr<Json::Node> node = std::make_shared<Json::Node>();
+        Pointer node = Pointer();
         Token token = lexer.roll_back_token();
         bool bValue = token.value == "True" ? true : false;
         node->set_bool(bValue);
         return node;
     }
 
-    std::shared_ptr<Json::Node> Parser::parse_null() 
+    Pointer Parser::parse_null() 
     {
-        std::shared_ptr<Json::Node> node = std::make_shared<Json::Node>();
+        Pointer node = Pointer();
         Token token = lexer.roll_back_token();
         node->set_null();
         return node;

src/bakatools/json/json_parser.h

@@ -7,16 +7,16 @@ namespace Bk::Json
 {
     class Parser 
     {
-        std::shared_ptr<Json::Node> root;
+        Pointer root;
         std::unique_ptr<Json::Node> current;
         Lexer lexer;
         
-        std::shared_ptr<Json::Node> parse_object();
+        Pointer parse_object();
-        std::shared_ptr<Json::Node> parse_string();
+        Pointer parse_string();
-        std::shared_ptr<Json::Node> parse_number();
+        Pointer parse_number();
-        std::shared_ptr<Json::Node> parse_list();
+        Pointer parse_list();
-        std::shared_ptr<Json::Node> parse_boolean();
+        Pointer parse_boolean();
-        std::shared_ptr<Json::Node> parse_null();
+        Pointer parse_null();
 
         public:
             Parser(const Type::DataStream data)
@@ -25,6 +25,6 @@ namespace Bk::Json
             Parser(const char* data, int length);
             Parser(const std::string& str);
 
-            std::shared_ptr<Json::Node> parse();
+            Pointer parse();
     };
 }