Removed redundant 'Bloom' namespace from entire codebase

src/Application.cpp

@@ -20,11 +20,9 @@
 
 #include "src/Exceptions/InvalidConfig.hpp"
 
-namespace Bloom
+using namespace Exceptions;
-{
-    using namespace Exceptions;
 
-    Application::Application(std::vector<std::string>&& arguments)
+Application::Application(std::vector<std::string>&& arguments)
     : arguments(std::move(arguments))
     , qtApplication(
         (
@@ -40,9 +38,9 @@ namespace Bloom
 #endif
         )
     )
-    {}
+{}
 
-    int Application::run() {
+int Application::run() {
     try {
         this->setName("Bloom");
 
@@ -108,9 +106,9 @@ namespace Bloom
 
     this->shutdown();
     return EXIT_SUCCESS;
-    }
+}
 
-    std::map<std::string, std::function<int()>> Application::getCommandHandlersByCommandName() {
+std::map<std::string, std::function<int()>> Application::getCommandHandlersByCommandName() {
     return std::map<std::string, std::function<int()>> {
         {
             "--help",
@@ -137,9 +135,9 @@ namespace Bloom
             std::bind(&Application::initProject, this)
         },
     };
-    }
+}
 
-    void Application::startup() {
+void Application::startup() {
     auto& applicationEventListener = this->applicationEventListener;
     EventManager::registerListener(applicationEventListener);
     applicationEventListener->registerCallbackForEventType<Events::ShutdownApplication>(
@@ -183,9 +181,9 @@ namespace Bloom
     this->startDebugServer();
 
     Thread::threadState = ThreadState::READY;
-    }
+}
 
-    void Application::shutdown() {
+void Application::shutdown() {
     const auto appState = Thread::getThreadState();
     if (appState == ThreadState::STOPPED || appState == ThreadState::SHUTDOWN_INITIATED) {
         return;
@@ -206,9 +204,9 @@ namespace Bloom
     }
 
     Thread::threadState = ThreadState::STOPPED;
-    }
+}
 
-    void Application::triggerShutdown() {
+void Application::triggerShutdown() {
 #ifndef EXCLUDE_INSIGHT
     if (this->insight != nullptr) {
         this->insight->shutdown();
@@ -216,9 +214,9 @@ namespace Bloom
 #endif
 
     this->qtApplication.exit(EXIT_SUCCESS);
-    }
+}
 
-    void Application::loadProjectSettings() {
+void Application::loadProjectSettings() {
     const auto projectSettingsPath = Services::PathService::projectSettingsPath();
     auto jsonSettingsFile = QFile(QString::fromStdString(projectSettingsPath));
 
@@ -243,9 +241,9 @@ namespace Bloom
     }
 
     this->projectSettings = ProjectSettings();
-    }
+}
 
-    void Application::saveProjectSettings() {
+void Application::saveProjectSettings() {
     if (!this->projectSettings.has_value()) {
         return;
     }
@@ -274,9 +272,9 @@ namespace Bloom
             "Failed to save project settings -  " + exception.getMessage()
         );
     }
-    }
+}
 
-    void Application::loadProjectConfiguration() {
+void Application::loadProjectConfiguration() {
     auto configFile = QFile(QString::fromStdString(Services::PathService::projectConfigPath()));
 
     if (!configFile.exists()) {
@@ -333,9 +331,9 @@ namespace Bloom
     } else {
         throw InvalidConfig("Debug server configuration missing.");
     }
-    }
+}
 
-    int Application::presentHelpText() {
+int Application::presentHelpText() {
     /*
      * Silence all logging here, as we're just to display the help text and then exit the application. Any
      * further logging will just be noise.
@@ -356,9 +354,9 @@ namespace Bloom
     std::cout << "Bloom v" << Application::VERSION.toString() << "\n";
     std::cout << QTextStream(&helpFile).readAll().toUtf8().constData() << "\n";
     return EXIT_SUCCESS;
-    }
+}
 
-    int Application::presentVersionText() {
+int Application::presentVersionText() {
     Logger::silence();
 
     std::cout << "Bloom v" << Application::VERSION.toString() << "\n";
@@ -374,9 +372,9 @@ namespace Bloom
     std::cout << Services::PathService::homeDomainName() + "/\n";
     std::cout << "Nav Mohammed\n";
     return EXIT_SUCCESS;
-    }
+}
 
-    int Application::presentVersionMachineText() {
+int Application::presentVersionMachineText() {
     Logger::silence();
 
     auto insightAvailable = true;
@@ -395,9 +393,9 @@ namespace Bloom
     })).toJson().toStdString();
 
     return EXIT_SUCCESS;
-    }
+}
 
-    int Application::initProject() {
+int Application::initProject() {
     auto configFile = QFile(QString::fromStdString(Services::PathService::projectConfigPath()));
 
     if (configFile.exists()) {
@@ -432,13 +430,13 @@ namespace Bloom
 
     Logger::info("Bloom configuration file (bloom.yaml) created in working directory.");
     return EXIT_SUCCESS;
-    }
+}
 
-    void Application::startSignalHandler() {
+void Application::startSignalHandler() {
     this->signalHandlerThread = std::thread(&SignalHandler::run, std::ref(this->signalHandler));
-    }
+}
 
-    void Application::stopSignalHandler() {
+void Application::stopSignalHandler() {
     const auto shThreadState = this->signalHandler.getThreadState();
 
     if (shThreadState != ThreadState::STOPPED && shThreadState != ThreadState::UNINITIALISED) {
@@ -456,9 +454,9 @@ namespace Bloom
         this->signalHandlerThread.join();
         Logger::debug("SignalHandler thread joined");
     }
-    }
+}
 
-    void Application::startTargetController() {
+void Application::startTargetController() {
     this->targetController = std::make_unique<TargetController::TargetControllerComponent>(
         this->projectConfig.value(),
         this->environmentConfig.value()
@@ -476,9 +474,9 @@ namespace Bloom
     if (!tcStateChangeEvent.has_value() || tcStateChangeEvent->get()->getState() != ThreadState::READY) {
         throw Exception("TargetController failed to start up");
     }
-    }
+}
 
-    void Application::stopTargetController() {
+void Application::stopTargetController() {
     if (this->targetController == nullptr) {
         return;
     }
@@ -496,9 +494,9 @@ namespace Bloom
         this->targetControllerThread.join();
         Logger::debug("TargetController thread joined");
     }
-    }
+}
 
-    void Application::startDebugServer() {
+void Application::startDebugServer() {
     this->debugServer = std::make_unique<DebugServer::DebugServerComponent>(
         this->debugServerConfig.value()
     );
@@ -515,9 +513,9 @@ namespace Bloom
     if (!dsStateChangeEvent.has_value() || dsStateChangeEvent->get()->getState() != ThreadState::READY) {
         throw Exception("DebugServer failed to start up");
     }
-    }
+}
 
-    void Application::stopDebugServer() {
+void Application::stopDebugServer() {
     if (this->debugServer == nullptr) {
         return;
     }
@@ -535,13 +533,13 @@ namespace Bloom
         this->debugServerThread.join();
         Logger::debug("DebugServer thread joined");
     }
-    }
+}
 
-    void Application::dispatchEvents() {
+void Application::dispatchEvents() {
     this->applicationEventListener->dispatchCurrentEvents();
-    }
+}
 
-    void Application::checkBloomVersion() {
+void Application::checkBloomVersion() {
     const auto currentVersionNumber = Application::VERSION;
 
     auto* networkAccessManager = new QNetworkAccessManager(this);
@@ -569,10 +567,10 @@ namespace Bloom
     );
 
     networkAccessManager->get(QNetworkRequest(queryVersionEndpointUrl));
-    }
+}
 
 #ifndef EXCLUDE_INSIGHT
-    void Application::activateInsight() {
+void Application::activateInsight() {
     assert(!this->insight);
 
     this->insight = std::make_unique<Insight>(
@@ -583,9 +581,9 @@ namespace Bloom
         this->projectSettings.value().insightSettings,
         &(this->qtApplication)
     );
-    }
+}
 
-    void Application::onInsightActivationRequest(const Events::InsightActivationRequested&) {
+void Application::onInsightActivationRequest(const Events::InsightActivationRequested&) {
     if (this->insight) {
         // Insight has already been activated
         this->insight->activateMainWindow();
@@ -593,37 +591,36 @@ namespace Bloom
     }
 
     this->activateInsight();
-    }
+}
 
-    void Application::onInsightMainWindowClosed(const Events::InsightMainWindowClosed& event) {
+void Application::onInsightMainWindowClosed(const Events::InsightMainWindowClosed& event) {
     if (this->insightConfig->shutdownOnClose) {
         this->triggerShutdown();
     }
-    }
+}
 #endif
 
-    void Application::onShutdownApplicationRequest(const Events::ShutdownApplication&) {
+void Application::onShutdownApplicationRequest(const Events::ShutdownApplication&) {
     Logger::debug("ShutdownApplication event received.");
     this->triggerShutdown();
-    }
+}
 
-    void Application::onTargetControllerThreadStateChanged(const Events::TargetControllerThreadStateChanged& event) {
+void Application::onTargetControllerThreadStateChanged(const Events::TargetControllerThreadStateChanged& event) {
     if (event.getState() == ThreadState::STOPPED || event.getState() == ThreadState::SHUTDOWN_INITIATED) {
         // TargetController has unexpectedly shutdown.
         this->triggerShutdown();
     }
-    }
+}
 
-    void Application::onDebugServerThreadStateChanged(const Events::DebugServerThreadStateChanged& event) {
+void Application::onDebugServerThreadStateChanged(const Events::DebugServerThreadStateChanged& event) {
     if (event.getState() == ThreadState::STOPPED || event.getState() == ThreadState::SHUTDOWN_INITIATED) {
         // DebugServer has unexpectedly shutdown - it must have encountered a fatal error.
         this->triggerShutdown();
     }
-    }
+}
 
-    void Application::onDebugSessionFinished(const Events::DebugSessionFinished& event) {
+void Application::onDebugSessionFinished(const Events::DebugSessionFinished& event) {
     if (this->environmentConfig->shutdownPostDebugSession || Services::ProcessService::isManagedByClion()) {
         this->triggerShutdown();
     }
-    }
 }

src/Application.hpp

@@ -31,19 +31,18 @@
 
 #include "src/VersionNumber.hpp"
 
-namespace Bloom
+
-{
+/**
-    /**
  * Bloom - a debug interface for embedded systems development on Linux.
  *
  * This is the main entry-point of execution for the Bloom program. The methods within will run on the main
  * thread. If Insight is enabled, execution will be passed over to Insight::run() upon start up.
  */
-    class Application: public QObject, public Thread
+class Application: public QObject, public Thread
-    {
+{
     Q_OBJECT
 
-    public:
+public:
     static const inline VersionNumber VERSION = VersionNumber(std::string(BLOOM_VERSION));
 
     explicit Application(std::vector<std::string>&& arguments);
@@ -55,7 +54,7 @@ namespace Bloom
      */
     int run();
 
-    private:
+private:
     std::vector<std::string> arguments;
 
     std::string qtApplicationName = "Bloom";
@@ -317,5 +316,4 @@ namespace Bloom
      * @param event
      */
     void onDebugSessionFinished(const Events::DebugSessionFinished& event);
-    };
+};
-}

src/DebugServer/DebugServerComponent.cpp

@@ -8,9 +8,9 @@
 #include "src/Exceptions/InvalidConfig.hpp"
 #include "src/Logger/Logger.hpp"
 
-namespace Bloom::DebugServer
+namespace DebugServer
 {
-    using namespace Bloom::Events;
+    using namespace Events;
 
     DebugServerComponent::DebugServerComponent(const DebugServerConfig& debugServerConfig)
         : debugServerConfig(debugServerConfig)

src/DebugServer/DebugServerComponent.hpp

@@ -13,7 +13,7 @@
 
 #include "ServerInterface.hpp"
 
-namespace Bloom::DebugServer
+namespace DebugServer
 {
     /**
      * The DebugServer exposes the connected target to third-party debugging software such as IDEs.

src/DebugServer/Gdb/AvrGdb/AvrGdbRsp.cpp

@@ -11,12 +11,12 @@
 #include "CommandPackets/FlashWrite.hpp"
 #include "CommandPackets/FlashDone.hpp"
 
-namespace Bloom::DebugServer::Gdb::AvrGdb
+namespace DebugServer::Gdb::AvrGdb
 {
-    using namespace Bloom::Exceptions;
+    using namespace Exceptions;
 
-    using Bloom::Targets::TargetRegisterDescriptor;
+    using Targets::TargetRegisterDescriptor;
-    using Bloom::Targets::TargetRegisterType;
+    using Targets::TargetRegisterType;
 
     AvrGdbRsp::AvrGdbRsp(
         const DebugServerConfig& debugServerConfig,

src/DebugServer/Gdb/AvrGdb/AvrGdbRsp.hpp

@@ -6,7 +6,7 @@
 
 #include "src/DebugServer/Gdb/GdbRspDebugServer.hpp"
 
-namespace Bloom::DebugServer::Gdb::AvrGdb
+namespace DebugServer::Gdb::AvrGdb
 {
     class AvrGdbRsp: public GdbRspDebugServer
     {

src/DebugServer/Gdb/AvrGdb/CommandPackets/FlashDone.cpp

@@ -6,14 +6,14 @@
 #include "src/Logger/Logger.hpp"
 #include "src/Exceptions/Exception.hpp"
 
-namespace Bloom::DebugServer::Gdb::AvrGdb::CommandPackets
+namespace DebugServer::Gdb::AvrGdb::CommandPackets
 {
     using Services::TargetControllerService;
 
     using ResponsePackets::ErrorResponsePacket;
     using ResponsePackets::OkResponsePacket;
 
-    using namespace Bloom::Exceptions;
+    using namespace Exceptions;
 
     FlashDone::FlashDone(const RawPacket& rawPacket)
         : CommandPacket(rawPacket)

src/DebugServer/Gdb/AvrGdb/CommandPackets/FlashDone.hpp

@@ -8,7 +8,7 @@
 
 #include "src/Targets/TargetMemory.hpp"
 
-namespace Bloom::DebugServer::Gdb::AvrGdb::CommandPackets
+namespace DebugServer::Gdb::AvrGdb::CommandPackets
 {
     /**
      * The FlashDone class implements the structure for the "vFlashDone" packet.

src/DebugServer/Gdb/AvrGdb/CommandPackets/FlashErase.cpp

@@ -6,14 +6,14 @@
 #include "src/Logger/Logger.hpp"
 #include "src/Exceptions/Exception.hpp"
 
-namespace Bloom::DebugServer::Gdb::AvrGdb::CommandPackets
+namespace DebugServer::Gdb::AvrGdb::CommandPackets
 {
     using Services::TargetControllerService;
 
     using ResponsePackets::ErrorResponsePacket;
     using ResponsePackets::OkResponsePacket;
 
-    using namespace Bloom::Exceptions;
+    using namespace Exceptions;
 
     FlashErase::FlashErase(const RawPacket& rawPacket)
         : CommandPacket(rawPacket)

src/DebugServer/Gdb/AvrGdb/CommandPackets/FlashErase.hpp

@@ -8,7 +8,7 @@
 
 #include "src/Targets/TargetMemory.hpp"
 
-namespace Bloom::DebugServer::Gdb::AvrGdb::CommandPackets
+namespace DebugServer::Gdb::AvrGdb::CommandPackets
 {
     /**
      * The FlashErase class implements the structure for the "vFlashErase" packet. Upon receiving this packet, the

src/DebugServer/Gdb/AvrGdb/CommandPackets/FlashWrite.cpp

@@ -8,14 +8,14 @@
 #include "src/Logger/Logger.hpp"
 #include "src/Exceptions/Exception.hpp"
 
-namespace Bloom::DebugServer::Gdb::AvrGdb::CommandPackets
+namespace DebugServer::Gdb::AvrGdb::CommandPackets
 {
     using Services::TargetControllerService;
 
     using ResponsePackets::ErrorResponsePacket;
     using ResponsePackets::OkResponsePacket;
 
-    using namespace Bloom::Exceptions;
+    using namespace Exceptions;
 
     FlashWrite::FlashWrite(const RawPacket& rawPacket)
         : CommandPacket(rawPacket)

src/DebugServer/Gdb/AvrGdb/CommandPackets/FlashWrite.hpp

@@ -8,7 +8,7 @@
 
 #include "src/Targets/TargetMemory.hpp"
 
-namespace Bloom::DebugServer::Gdb::AvrGdb::CommandPackets
+namespace DebugServer::Gdb::AvrGdb::CommandPackets
 {
     /**
      * The FlashWrite class implements the structure for the "vFlashWrite" packet. Upon receiving this packet, the

src/DebugServer/Gdb/AvrGdb/CommandPackets/ReadMemory.cpp

@@ -8,7 +8,7 @@
 
 #include "src/Exceptions/Exception.hpp"
 
-namespace Bloom::DebugServer::Gdb::AvrGdb::CommandPackets
+namespace DebugServer::Gdb::AvrGdb::CommandPackets
 {
     using Services::TargetControllerService;
 

src/DebugServer/Gdb/AvrGdb/CommandPackets/ReadMemory.hpp

@@ -8,7 +8,7 @@
 
 #include "src/Targets/TargetMemory.hpp"
 
-namespace Bloom::DebugServer::Gdb::AvrGdb::CommandPackets
+namespace DebugServer::Gdb::AvrGdb::CommandPackets
 {
     /**
      * The ReadMemory class implements a structure for "m" packets. Upon receiving these packets, the server is

src/DebugServer/Gdb/AvrGdb/CommandPackets/ReadMemoryMap.cpp

@@ -4,7 +4,7 @@
 
 #include "src/Exceptions/Exception.hpp"
 
-namespace Bloom::DebugServer::Gdb::AvrGdb::CommandPackets
+namespace DebugServer::Gdb::AvrGdb::CommandPackets
 {
     using Services::TargetControllerService;
 

src/DebugServer/Gdb/AvrGdb/CommandPackets/ReadMemoryMap.hpp

@@ -4,7 +4,7 @@
 
 #include "src/DebugServer/Gdb/CommandPackets/CommandPacket.hpp"
 
-namespace Bloom::DebugServer::Gdb::AvrGdb::CommandPackets
+namespace DebugServer::Gdb::AvrGdb::CommandPackets
 {
     /**
      * The ReadMemoryMap class implements a structure for the "qXfer:memory-map:read::..." packet. Upon receiving this

src/DebugServer/Gdb/AvrGdb/CommandPackets/ReadRegister.cpp

@@ -10,7 +10,7 @@
 
 #include "src/Exceptions/Exception.hpp"
 
-namespace Bloom::DebugServer::Gdb::AvrGdb::CommandPackets
+namespace DebugServer::Gdb::AvrGdb::CommandPackets
 {
     using Services::TargetControllerService;
 

src/DebugServer/Gdb/AvrGdb/CommandPackets/ReadRegister.hpp

@@ -4,7 +4,7 @@
 
 #include "src/DebugServer/Gdb/RegisterDescriptor.hpp"
 
-namespace Bloom::DebugServer::Gdb::AvrGdb::CommandPackets
+namespace DebugServer::Gdb::AvrGdb::CommandPackets
 {
     /**
      * The ReadRegister class implements a structure for the "p" command packet. In response to this packet, the server

src/DebugServer/Gdb/AvrGdb/CommandPackets/ReadRegisters.cpp

@@ -11,7 +11,7 @@
 
 #include "src/Exceptions/Exception.hpp"
 
-namespace Bloom::DebugServer::Gdb::AvrGdb::CommandPackets
+namespace DebugServer::Gdb::AvrGdb::CommandPackets
 {
     using Services::TargetControllerService;
 

src/DebugServer/Gdb/AvrGdb/CommandPackets/ReadRegisters.hpp

@@ -6,7 +6,7 @@
 
 #include "src/DebugServer/Gdb/RegisterDescriptor.hpp"
 
-namespace Bloom::DebugServer::Gdb::AvrGdb::CommandPackets
+namespace DebugServer::Gdb::AvrGdb::CommandPackets
 {
     /**
      * The ReadRegisters class implements a structure for the "g" command packet. In response to this packet, the

src/DebugServer/Gdb/AvrGdb/CommandPackets/WriteMemory.cpp

@@ -6,14 +6,14 @@
 #include "src/Logger/Logger.hpp"
 #include "src/Exceptions/Exception.hpp"
 
-namespace Bloom::DebugServer::Gdb::AvrGdb::CommandPackets
+namespace DebugServer::Gdb::AvrGdb::CommandPackets
 {
     using Services::TargetControllerService;
 
     using ResponsePackets::ErrorResponsePacket;
     using ResponsePackets::OkResponsePacket;
 
-    using namespace Bloom::Exceptions;
+    using namespace Exceptions;
 
     WriteMemory::WriteMemory(const RawPacket& rawPacket, const TargetDescriptor& gdbTargetDescriptor)
         : CommandPacket(rawPacket)

src/DebugServer/Gdb/AvrGdb/CommandPackets/WriteMemory.hpp

@@ -8,7 +8,7 @@
 
 #include "src/Targets/TargetMemory.hpp"
 
-namespace Bloom::DebugServer::Gdb::AvrGdb::CommandPackets
+namespace DebugServer::Gdb::AvrGdb::CommandPackets
 {
     /**
      * The WriteMemory class implements the structure for "M" packets. Upon receiving this packet, the server is

src/DebugServer/Gdb/AvrGdb/CommandPackets/WriteRegister.cpp

@@ -8,7 +8,7 @@
 #include "src/Logger/Logger.hpp"
 #include "src/Exceptions/Exception.hpp"
 
-namespace Bloom::DebugServer::Gdb::AvrGdb::CommandPackets
+namespace DebugServer::Gdb::AvrGdb::CommandPackets
 {
     using Services::TargetControllerService;
 

src/DebugServer/Gdb/AvrGdb/CommandPackets/WriteRegister.hpp

@@ -7,7 +7,7 @@
 #include "src/Targets/TargetRegister.hpp"
 #include "src/Targets/TargetMemory.hpp"
 
-namespace Bloom::DebugServer::Gdb::AvrGdb::CommandPackets
+namespace DebugServer::Gdb::AvrGdb::CommandPackets
 {
     /**
      * The WriteRegister class implements the structure for "P" packets.

src/DebugServer/Gdb/AvrGdb/TargetDescriptor.cpp

@@ -5,14 +5,14 @@
 #include "src/Exceptions/Exception.hpp"
 #include "src/Logger/Logger.hpp"
 
-namespace Bloom::DebugServer::Gdb::AvrGdb
+namespace DebugServer::Gdb::AvrGdb
 {
-    using Bloom::Targets::TargetRegisterDescriptor;
+    using Targets::TargetRegisterDescriptor;
-    using Bloom::Targets::TargetRegisterType;
+    using Targets::TargetRegisterType;
 
-    using Bloom::Exceptions::Exception;
+    using Exceptions::Exception;
 
-    TargetDescriptor::TargetDescriptor(const Bloom::Targets::TargetDescriptor& targetDescriptor)
+    TargetDescriptor::TargetDescriptor(const Targets::TargetDescriptor& targetDescriptor)
         : DebugServer::Gdb::TargetDescriptor(
             targetDescriptor,
             {

src/DebugServer/Gdb/AvrGdb/TargetDescriptor.hpp

@@ -2,7 +2,7 @@
 
 #include "src/DebugServer/Gdb/TargetDescriptor.hpp"
 
-namespace Bloom::DebugServer::Gdb::AvrGdb
+namespace DebugServer::Gdb::AvrGdb
 {
     class TargetDescriptor: public DebugServer::Gdb::TargetDescriptor
     {

src/DebugServer/Gdb/BreakpointType.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-namespace Bloom::DebugServer::Gdb
+namespace DebugServer::Gdb
 {
     enum class BreakpointType: int
     {

src/DebugServer/Gdb/CommandPackets/ActivateInsight.cpp

@@ -10,13 +10,13 @@
 
 #include "src/Exceptions/Exception.hpp"
 
-namespace Bloom::DebugServer::Gdb::CommandPackets
+namespace DebugServer::Gdb::CommandPackets
 {
     using Services::TargetControllerService;
 
     using ResponsePackets::ResponsePacket;
     using ResponsePackets::ErrorResponsePacket;
-    using Bloom::Exceptions::Exception;
+    using ::Exceptions::Exception;
 
     ActivateInsight::ActivateInsight(Monitor&& monitorPacket)
         : Monitor(std::move(monitorPacket))

src/DebugServer/Gdb/CommandPackets/ActivateInsight.hpp

@@ -2,7 +2,7 @@
 
 #include "Monitor.hpp"
 
-namespace Bloom::DebugServer::Gdb::CommandPackets
+namespace DebugServer::Gdb::CommandPackets
 {
     /**
      * The ActivateInsight class implements a structure for the "monitor insight" GDB command.

src/DebugServer/Gdb/CommandPackets/BloomVersion.cpp

@@ -11,17 +11,13 @@
 #include "src/Services/StringService.hpp"
 #include "src/Logger/Logger.hpp"
 
-#include "src/Exceptions/Exception.hpp"
+namespace DebugServer::Gdb::CommandPackets
-
-namespace Bloom::DebugServer::Gdb::CommandPackets
 {
     using Services::TargetControllerService;
 
     using ResponsePackets::ErrorResponsePacket;
     using ResponsePackets::ResponsePacket;
 
-    using Exceptions::Exception;
-
     BloomVersion::BloomVersion(Monitor&& monitorPacket)
         : Monitor(std::move(monitorPacket))
     {}

src/DebugServer/Gdb/CommandPackets/BloomVersion.hpp

@@ -4,7 +4,7 @@
 
 #include "Monitor.hpp"
 
-namespace Bloom::DebugServer::Gdb::CommandPackets
+namespace DebugServer::Gdb::CommandPackets
 {
     /**
      * The BloomVersion class implements a structure for the "monitor version" GDB command.

src/DebugServer/Gdb/CommandPackets/BloomVersionMachine.cpp

@@ -11,16 +11,12 @@
 #include "src/Services/StringService.hpp"
 #include "src/Logger/Logger.hpp"
 
-#include "src/Exceptions/Exception.hpp"
+namespace DebugServer::Gdb::CommandPackets
-
-namespace Bloom::DebugServer::Gdb::CommandPackets
 {
     using Services::TargetControllerService;
 
     using ResponsePackets::ResponsePacket;
 
-    using Exceptions::Exception;
-
     BloomVersionMachine::BloomVersionMachine(Monitor&& monitorPacket)
         : Monitor(std::move(monitorPacket))
     {}

src/DebugServer/Gdb/CommandPackets/BloomVersionMachine.hpp

@@ -4,7 +4,7 @@
 
 #include "Monitor.hpp"
 
-namespace Bloom::DebugServer::Gdb::CommandPackets
+namespace DebugServer::Gdb::CommandPackets
 {
     /**
      * The BloomVersionMachine class implements a structure for the "monitor version machine" GDB command.

src/DebugServer/Gdb/CommandPackets/CommandPacket.cpp

@@ -9,9 +9,8 @@
 #include "src/DebugServer/Gdb/Signal.hpp"
 
 #include "src/Logger/Logger.hpp"
-#include "src/Exceptions/Exception.hpp"
 
-namespace Bloom::DebugServer::Gdb::CommandPackets
+namespace DebugServer::Gdb::CommandPackets
 {
     using Services::TargetControllerService;
 
@@ -21,8 +20,6 @@ namespace Bloom::DebugServer::Gdb::CommandPackets
     using ResponsePackets::EmptyResponsePacket;
     using ResponsePackets::ErrorResponsePacket;
 
-    using Exceptions::Exception;
-
     void CommandPacket::handle(DebugSession& debugSession, TargetControllerService& targetControllerService) {
         const auto packetString = std::string(this->data.begin(), this->data.end());
 

src/DebugServer/Gdb/CommandPackets/CommandPacket.hpp

@@ -8,7 +8,7 @@
 
 #include "src/Services/TargetControllerService.hpp"
 
-namespace Bloom::DebugServer::Gdb::CommandPackets
+namespace DebugServer::Gdb::CommandPackets
 {
     /**
      * GDB RSP command packets are sent to the server, from the GDB client. These packets carry instructions that the

src/DebugServer/Gdb/CommandPackets/ContinueExecution.cpp

@@ -5,12 +5,12 @@
 #include "src/Logger/Logger.hpp"
 #include "src/Exceptions/Exception.hpp"
 
-namespace Bloom::DebugServer::Gdb::CommandPackets
+namespace DebugServer::Gdb::CommandPackets
 {
     using Services::TargetControllerService;
 
     using ResponsePackets::ErrorResponsePacket;
-    using Exceptions::Exception;
+    using ::Exceptions::Exception;
 
     ContinueExecution::ContinueExecution(const RawPacket& rawPacket)
         : CommandPacket(rawPacket)

src/DebugServer/Gdb/CommandPackets/ContinueExecution.hpp

@@ -7,7 +7,7 @@
 
 #include "src/Targets/TargetMemory.hpp"
 
-namespace Bloom::DebugServer::Gdb::CommandPackets
+namespace DebugServer::Gdb::CommandPackets
 {
     /**
      * The ContinueExecution class implements a structure for "c" packets. These packets instruct the server

src/DebugServer/Gdb/CommandPackets/Detach.cpp

@@ -7,14 +7,14 @@
 
 #include "src/Logger/Logger.hpp"
 
-namespace Bloom::DebugServer::Gdb::CommandPackets
+namespace DebugServer::Gdb::CommandPackets
 {
     using Services::TargetControllerService;
 
     using ResponsePackets::OkResponsePacket;
     using ResponsePackets::ErrorResponsePacket;
 
-    using Exceptions::Exception;
+    using ::Exceptions::Exception;
 
     Detach::Detach(const RawPacket& rawPacket)
         : CommandPacket(rawPacket)

src/DebugServer/Gdb/CommandPackets/Detach.hpp

@@ -2,7 +2,7 @@
 
 #include "CommandPacket.hpp"
 
-namespace Bloom::DebugServer::Gdb::CommandPackets
+namespace DebugServer::Gdb::CommandPackets
 {
     class Detach: public CommandPacket
     {

src/DebugServer/Gdb/CommandPackets/EepromFill.cpp

@@ -12,13 +12,14 @@
 #include "src/DebugServer/Gdb/Exceptions/InvalidCommandOption.hpp"
 #include "src/Exceptions/Exception.hpp"
 
-namespace Bloom::DebugServer::Gdb::CommandPackets
+namespace DebugServer::Gdb::CommandPackets
 {
     using Services::TargetControllerService;
 
     using ResponsePackets::ResponsePacket;
     using ResponsePackets::ErrorResponsePacket;
-    using Bloom::Exceptions::Exception;
+
+    using ::Exceptions::Exception;
     using Exceptions::InvalidCommandOption;
 
     EepromFill::EepromFill(Monitor&& monitorPacket)

src/DebugServer/Gdb/CommandPackets/EepromFill.hpp

@@ -6,7 +6,7 @@
 
 #include "src/Targets/TargetMemory.hpp"
 
-namespace Bloom::DebugServer::Gdb::CommandPackets
+namespace DebugServer::Gdb::CommandPackets
 {
     /**
      * The EepromFill class implements a structure for the "monitor eeprom fill" GDB command.

src/DebugServer/Gdb/CommandPackets/GenerateSvd.cpp

@@ -15,13 +15,14 @@
 
 #include "src/Exceptions/Exception.hpp"
 
-namespace Bloom::DebugServer::Gdb::CommandPackets
+namespace DebugServer::Gdb::CommandPackets
 {
     using Services::TargetControllerService;
 
     using ResponsePackets::ResponsePacket;
     using ResponsePackets::ErrorResponsePacket;
-    using Exceptions::Exception;
+
+    using ::Exceptions::Exception;
 
     GenerateSvd::GenerateSvd(Monitor&& monitorPacket)
         : Monitor(std::move(monitorPacket))

src/DebugServer/Gdb/CommandPackets/GenerateSvd.hpp

@@ -6,7 +6,7 @@
 
 #include "src/Targets/TargetDescriptor.hpp"
 
-namespace Bloom::DebugServer::Gdb::CommandPackets
+namespace DebugServer::Gdb::CommandPackets
 {
     /**
      * The GenerateSvd class implements a structure for the "monitor svd" GDB command.

src/DebugServer/Gdb/CommandPackets/HelpMonitorInfo.cpp

@@ -12,14 +12,14 @@
 
 #include "src/Exceptions/Exception.hpp"
 
-namespace Bloom::DebugServer::Gdb::CommandPackets
+namespace DebugServer::Gdb::CommandPackets
 {
     using Services::TargetControllerService;
 
     using ResponsePackets::ErrorResponsePacket;
     using ResponsePackets::ResponsePacket;
 
-    using Exceptions::Exception;
+    using ::Exceptions::Exception;
 
     HelpMonitorInfo::HelpMonitorInfo(Monitor&& monitorPacket)
         : Monitor(std::move(monitorPacket))

src/DebugServer/Gdb/CommandPackets/HelpMonitorInfo.hpp

@@ -4,7 +4,7 @@
 
 #include "Monitor.hpp"
 
-namespace Bloom::DebugServer::Gdb::CommandPackets
+namespace DebugServer::Gdb::CommandPackets
 {
     /**
      * The HelpMonitorInfo class implements a structure for the "monitor help" GDB command.

src/DebugServer/Gdb/CommandPackets/InterruptExecution.cpp

@@ -7,13 +7,14 @@
 #include "src/Logger/Logger.hpp"
 #include "src/Exceptions/Exception.hpp"
 
-namespace Bloom::DebugServer::Gdb::CommandPackets
+namespace DebugServer::Gdb::CommandPackets
 {
     using Services::TargetControllerService;
 
     using ResponsePackets::TargetStopped;
     using ResponsePackets::ErrorResponsePacket;
-    using Exceptions::Exception;
+
+    using ::Exceptions::Exception;
 
     void InterruptExecution::handle(DebugSession& debugSession, TargetControllerService& targetControllerService) {
         Logger::info("Handling InterruptExecution packet");

src/DebugServer/Gdb/CommandPackets/InterruptExecution.hpp

@@ -2,7 +2,7 @@
 
 #include "CommandPacket.hpp"
 
-namespace Bloom::DebugServer::Gdb::CommandPackets
+namespace DebugServer::Gdb::CommandPackets
 {
     /**
      * The InterruptException class represents interrupt command packets. Upon receiving an interrupt packet, the

src/DebugServer/Gdb/CommandPackets/Monitor.cpp

@@ -4,7 +4,7 @@
 
 #include "src/Logger/Logger.hpp"
 
-namespace Bloom::DebugServer::Gdb::CommandPackets
+namespace DebugServer::Gdb::CommandPackets
 {
     using Services::TargetControllerService;
 

src/DebugServer/Gdb/CommandPackets/Monitor.hpp

@@ -7,7 +7,7 @@
 
 #include "CommandPacket.hpp"
 
-namespace Bloom::DebugServer::Gdb::CommandPackets
+namespace DebugServer::Gdb::CommandPackets
 {
     /**
      * This is a base class for 'qRcmd' packets - invoked by the GDB 'monitor' command.

src/DebugServer/Gdb/CommandPackets/RemoveBreakpoint.cpp

@@ -10,7 +10,7 @@
 #include "src/Logger/Logger.hpp"
 #include "src/Exceptions/Exception.hpp"
 
-namespace Bloom::DebugServer::Gdb::CommandPackets
+namespace DebugServer::Gdb::CommandPackets
 {
     using Services::TargetControllerService;
 
@@ -19,7 +19,7 @@ namespace Bloom::DebugServer::Gdb::CommandPackets
     using ResponsePackets::OkResponsePacket;
     using ResponsePackets::ErrorResponsePacket;
 
-    using Exceptions::Exception;
+    using ::Exceptions::Exception;
 
     RemoveBreakpoint::RemoveBreakpoint(const RawPacket& rawPacket)
         : CommandPacket(rawPacket)

src/DebugServer/Gdb/CommandPackets/RemoveBreakpoint.hpp

@@ -9,7 +9,7 @@
 
 #include "src/Targets/TargetMemory.hpp"
 
-namespace Bloom::DebugServer::Gdb::CommandPackets
+namespace DebugServer::Gdb::CommandPackets
 {
     /**
      * The RemoveBreakpoint class implements the structure for "z" command packets. Upon receiving this command, the

src/DebugServer/Gdb/CommandPackets/ResetTarget.cpp

@@ -8,14 +8,14 @@
 
 #include "src/Exceptions/Exception.hpp"
 
-namespace Bloom::DebugServer::Gdb::CommandPackets
+namespace DebugServer::Gdb::CommandPackets
 {
     using Services::TargetControllerService;
 
     using ResponsePackets::ErrorResponsePacket;
     using ResponsePackets::ResponsePacket;
 
-    using Exceptions::Exception;
+    using ::Exceptions::Exception;
 
     ResetTarget::ResetTarget(Monitor&& monitorPacket)
         : Monitor(std::move(monitorPacket))

src/DebugServer/Gdb/CommandPackets/ResetTarget.hpp

@@ -4,7 +4,7 @@
 
 #include "Monitor.hpp"
 
-namespace Bloom::DebugServer::Gdb::CommandPackets
+namespace DebugServer::Gdb::CommandPackets
 {
     /**
      * The ResetTarget class implements a structure for the custom reset command (triggered via the "monitor reset"

src/DebugServer/Gdb/CommandPackets/SetBreakpoint.cpp

@@ -11,7 +11,7 @@
 #include "src/Logger/Logger.hpp"
 #include "src/Exceptions/Exception.hpp"
 
-namespace Bloom::DebugServer::Gdb::CommandPackets
+namespace DebugServer::Gdb::CommandPackets
 {
     using Services::TargetControllerService;
 
@@ -21,7 +21,7 @@ namespace Bloom::DebugServer::Gdb::CommandPackets
     using ResponsePackets::ErrorResponsePacket;
     using ResponsePackets::EmptyResponsePacket;
 
-    using Exceptions::Exception;
+    using ::Exceptions::Exception;
 
     SetBreakpoint::SetBreakpoint(const RawPacket& rawPacket)
         : CommandPacket(rawPacket)

src/DebugServer/Gdb/CommandPackets/SetBreakpoint.hpp

@@ -9,7 +9,7 @@
 
 #include "src/Targets/TargetMemory.hpp"
 
-namespace Bloom::DebugServer::Gdb::CommandPackets
+namespace DebugServer::Gdb::CommandPackets
 {
     /**
      * The SetBreakpoint class implements the structure for "Z" command packets. Upon receiving this command, the

src/DebugServer/Gdb/CommandPackets/StepExecution.cpp

@@ -5,13 +5,13 @@
 #include "src/Logger/Logger.hpp"
 #include "src/Exceptions/Exception.hpp"
 
-namespace Bloom::DebugServer::Gdb::CommandPackets
+namespace DebugServer::Gdb::CommandPackets
 {
     using Services::TargetControllerService;
 
     using ResponsePackets::ErrorResponsePacket;
 
-    using Exceptions::Exception;
+    using ::Exceptions::Exception;
 
     StepExecution::StepExecution(const RawPacket& rawPacket)
         : CommandPacket(rawPacket)

src/DebugServer/Gdb/CommandPackets/StepExecution.hpp

@@ -7,7 +7,7 @@
 
 #include "src/Targets/TargetMemory.hpp"
 
-namespace Bloom::DebugServer::Gdb::CommandPackets
+namespace DebugServer::Gdb::CommandPackets
 {
     /**
      * The StepExecution class implements the structure for "s" command packets. Upon receiving this command, the

src/DebugServer/Gdb/CommandPackets/SupportedFeaturesQuery.cpp

@@ -8,18 +8,16 @@
 #include "src/DebugServer/Gdb/ResponsePackets/ErrorResponsePacket.hpp"
 
 #include "src/Logger/Logger.hpp"
-#include "src/Exceptions/Exception.hpp"
 #include "src/DebugServer/Gdb/Exceptions/ClientNotSupported.hpp"
 
-namespace Bloom::DebugServer::Gdb::CommandPackets
+namespace DebugServer::Gdb::CommandPackets
 {
     using Services::TargetControllerService;
 
     using ResponsePackets::SupportedFeaturesResponse;
     using ResponsePackets::ErrorResponsePacket;
 
-    using Bloom::Exceptions::Exception;
+    using Exceptions::ClientNotSupported;
-    using Gdb::Exceptions::ClientNotSupported;
 
     SupportedFeaturesQuery::SupportedFeaturesQuery(const RawPacket& rawPacket)
         : CommandPacket(rawPacket)

src/DebugServer/Gdb/CommandPackets/SupportedFeaturesQuery.hpp

@@ -6,7 +6,7 @@
 #include "CommandPacket.hpp"
 #include "../Feature.hpp"
 
-namespace Bloom::DebugServer::Gdb::CommandPackets
+namespace DebugServer::Gdb::CommandPackets
 {
     /**
      * The SupportedFeaturesQuery command packet is a query from the GDB client, requesting a list of GDB features

src/DebugServer/Gdb/Connection.cpp

@@ -15,10 +15,10 @@
 #include "src/Logger/Logger.hpp"
 #include "src/Services/StringService.hpp"
 
-namespace Bloom::DebugServer::Gdb
+namespace DebugServer::Gdb
 {
     using namespace Exceptions;
-    using namespace Bloom::Exceptions;
+    using namespace ::Exceptions;
 
     using ResponsePackets::ResponsePacket;
 

src/DebugServer/Gdb/Connection.hpp

@@ -16,7 +16,7 @@
 #include "src/DebugServer/Gdb/Packet.hpp"
 #include "src/DebugServer/Gdb/ResponsePackets/ResponsePacket.hpp"
 
-namespace Bloom::DebugServer::Gdb
+namespace DebugServer::Gdb
 {
     /**
      * The Connection class represents an active connection between the GDB RSP server and client.

src/DebugServer/Gdb/DebugSession.cpp

@@ -2,7 +2,7 @@
 
 #include "src/EventManager/EventManager.hpp"
 
-namespace Bloom::DebugServer::Gdb
+namespace DebugServer::Gdb
 {
     DebugSession::DebugSession(
         Connection&& connection,

src/DebugServer/Gdb/DebugSession.hpp

@@ -11,7 +11,7 @@
 
 #include "src/Targets/TargetMemory.hpp"
 
-namespace Bloom::DebugServer::Gdb
+namespace DebugServer::Gdb
 {
     class DebugSession
     {

src/DebugServer/Gdb/Exceptions/ClientCommunicationError.hpp

@@ -2,7 +2,7 @@
 
 #include "src/Exceptions/Exception.hpp"
 
-namespace Bloom::DebugServer::Gdb::Exceptions
+namespace DebugServer::Gdb::Exceptions
 {
     /**
      * In the event that communication between the GDB RSP client and Bloom fails, a ClientCommunicationFailure
@@ -10,15 +10,15 @@ namespace Bloom::DebugServer::Gdb::Exceptions
      *
      * See GdbRspDebugServer::serve() for handling code.
      */
-    class ClientCommunicationError: public Bloom::Exceptions::Exception
+    class ClientCommunicationError: public ::Exceptions::Exception
     {
     public:
         explicit ClientCommunicationError(const std::string& message)
-            : Bloom::Exceptions::Exception(message)
+            : ::Exceptions::Exception(message)
         {}
 
         explicit ClientCommunicationError(const char* message)
-            : Bloom::Exceptions::Exception(message)
+            : ::Exceptions::Exception(message)
         {}
 
         explicit ClientCommunicationError() = default;

src/DebugServer/Gdb/Exceptions/ClientDisconnected.hpp

@@ -2,7 +2,7 @@
 
 #include "src/Exceptions/Exception.hpp"
 
-namespace Bloom::DebugServer::Gdb::Exceptions
+namespace DebugServer::Gdb::Exceptions
 {
     /**
      * When a GDB RSP client unexpectedly drops the connection in the middle of an IO operation, a ClientDisconnected
@@ -11,7 +11,7 @@ namespace Bloom::DebugServer::Gdb::Exceptions
      *
      * See GdbRspDebugServer::serve() for handling code.
      */
-    class ClientDisconnected: public Bloom::Exceptions::Exception
+    class ClientDisconnected: public ::Exceptions::Exception
     {
     public:
         explicit ClientDisconnected() = default;

src/DebugServer/Gdb/Exceptions/ClientNotSupported.hpp

@@ -2,7 +2,7 @@
 
 #include "src/Exceptions/Exception.hpp"
 
-namespace Bloom::DebugServer::Gdb::Exceptions
+namespace DebugServer::Gdb::Exceptions
 {
     /**
      * In the event that the GDB debug server determines that the connected client cannot be served,
@@ -10,15 +10,15 @@ namespace Bloom::DebugServer::Gdb::Exceptions
      *
      * See GdbRspDebugServer::serve() for handling code.
      */
-    class ClientNotSupported: public Bloom::Exceptions::Exception
+    class ClientNotSupported: public ::Exceptions::Exception
     {
     public:
         explicit ClientNotSupported(const std::string& message)
-            : Bloom::Exceptions::Exception(message)
+            : ::Exceptions::Exception(message)
         {}
 
         explicit ClientNotSupported(const char* message)
-            : Bloom::Exceptions::Exception(message)
+            : ::Exceptions::Exception(message)
         {}
 
         explicit ClientNotSupported() = default;

src/DebugServer/Gdb/Exceptions/DebugServerInterrupted.hpp

@@ -2,7 +2,7 @@
 
 #include "src/Exceptions/Exception.hpp"
 
-namespace Bloom::DebugServer::Gdb::Exceptions
+namespace DebugServer::Gdb::Exceptions
 {
     /**
      * The GDB debug server spends most of its time in a blocking state, waiting for a new connection or for some data
@@ -13,7 +13,7 @@ namespace Bloom::DebugServer::Gdb::Exceptions
      * For more on how the GDB server implementation allows for interruptions, see the "Servicing events" section in
      * src/DebugServer/README.md.
      */
-    class DebugServerInterrupted: public Bloom::Exceptions::Exception
+    class DebugServerInterrupted: public ::Exceptions::Exception
     {
     public:
         explicit DebugServerInterrupted() = default;

src/DebugServer/Gdb/Exceptions/DebugSessionInitialisationFailure.hpp

@@ -2,7 +2,7 @@
 
 #include "src/Exceptions/Exception.hpp"
 
-namespace Bloom::DebugServer::Gdb::Exceptions
+namespace DebugServer::Gdb::Exceptions
 {
     /**
      * The GDB server may fail to prepare for a debug session, if an internal error occurs. One circumstance where
@@ -10,15 +10,15 @@ namespace Bloom::DebugServer::Gdb::Exceptions
      *
      * See GdbRspDebugServer::serve() for handling code.
      */
-    class DebugSessionInitialisationFailure: public Bloom::Exceptions::Exception
+    class DebugSessionInitialisationFailure: public ::Exceptions::Exception
     {
     public:
         explicit DebugSessionInitialisationFailure(const std::string& message)
-            : Bloom::Exceptions::Exception(message)
+            : ::Exceptions::Exception(message)
         {}
 
         explicit DebugSessionInitialisationFailure(const char* message)
-            : Bloom::Exceptions::Exception(message)
+            : ::Exceptions::Exception(message)
         {}
 
         explicit DebugSessionInitialisationFailure() = default;

src/DebugServer/Gdb/Exceptions/InvalidCommandOption.hpp

@@ -2,7 +2,7 @@
 
 #include "src/Exceptions/Exception.hpp"
 
-namespace Bloom::DebugServer::Gdb::Exceptions
+namespace DebugServer::Gdb::Exceptions
 {
     /**
      * For GDB monitor commands, each command can define a set of required/optional command options.
@@ -10,15 +10,15 @@ namespace Bloom::DebugServer::Gdb::Exceptions
      *
      * This exception is typically thrown and caught within the handling of monitor commands.
      */
-    class InvalidCommandOption: public Bloom::Exceptions::Exception
+    class InvalidCommandOption: public ::Exceptions::Exception
     {
     public:
         explicit InvalidCommandOption(const std::string& message)
-            : Bloom::Exceptions::Exception(message)
+            : ::Exceptions::Exception(message)
         {}
 
         explicit InvalidCommandOption(const char* message)
-            : Bloom::Exceptions::Exception(message)
+            : ::Exceptions::Exception(message)
         {}
 
         explicit InvalidCommandOption() = default;

src/DebugServer/Gdb/Feature.hpp

@@ -2,7 +2,7 @@
 
 #include "src/Helpers/BiMap.hpp"
 
-namespace Bloom::DebugServer::Gdb
+namespace DebugServer::Gdb
 {
     enum class Feature: int
     {

src/DebugServer/Gdb/GdbDebugServerConfig.cpp

@@ -3,7 +3,7 @@
 #include "src/Helpers/YamlUtilities.hpp"
 #include "src/Logger/Logger.hpp"
 
-namespace Bloom::DebugServer::Gdb
+namespace DebugServer::Gdb
 {
     GdbDebugServerConfig::GdbDebugServerConfig(const DebugServerConfig& debugServerConfig)
         : DebugServerConfig(debugServerConfig)

src/DebugServer/Gdb/GdbDebugServerConfig.hpp

@@ -2,7 +2,7 @@
 
 #include "src/ProjectConfig.hpp"
 
-namespace Bloom::DebugServer::Gdb
+namespace DebugServer::Gdb
 {
     /**
      * Extending the generic DebugServerConfig struct to accommodate GDB debug server configuration parameters.

src/DebugServer/Gdb/GdbRspDebugServer.cpp

@@ -41,10 +41,10 @@
 
 #include "src/Services/ProcessService.hpp"
 
-namespace Bloom::DebugServer::Gdb
+namespace DebugServer::Gdb
 {
     using namespace Exceptions;
-    using namespace Bloom::Exceptions;
+    using namespace ::Exceptions;
 
     using CommandPackets::CommandPacket;
 

src/DebugServer/Gdb/GdbRspDebugServer.hpp

@@ -26,7 +26,7 @@
 #include "src/EventManager/Events/TargetExecutionStopped.hpp"
 #include "src/EventManager/Events/TargetExecutionResumed.hpp"
 
-namespace Bloom::DebugServer::Gdb
+namespace DebugServer::Gdb
 {
     /**
      * The GdbRspDebugServer is an implementation of the GDB Remote Serial Protocol.

src/DebugServer/Gdb/Packet.hpp

@@ -7,7 +7,7 @@
 #include <sstream>
 #include <iomanip>
 
-namespace Bloom::DebugServer::Gdb
+namespace DebugServer::Gdb
 {
     using RawPacket = std::vector<unsigned char>;
 

src/DebugServer/Gdb/ProgrammingSession.hpp

@@ -2,7 +2,7 @@
 
 #include "src/Targets/TargetMemory.hpp"
 
-namespace Bloom::DebugServer::Gdb
+namespace DebugServer::Gdb
 {
     /**
      * A programming session is created upon receiving the first FlashWrite (vFlashWrite) packet from GDB.

src/DebugServer/Gdb/RegisterDescriptor.hpp

@@ -3,7 +3,7 @@
 #include <cstdint>
 #include <string>
 
-namespace Bloom::DebugServer::Gdb
+namespace DebugServer::Gdb
 {
     using GdbRegisterId = std::uint16_t;
 
@@ -60,10 +60,10 @@ namespace std
      * class).
      */
     template<>
-    class hash<Bloom::DebugServer::Gdb::RegisterDescriptor>
+    class hash<DebugServer::Gdb::RegisterDescriptor>
     {
     public:
-        std::size_t operator () (const Bloom::DebugServer::Gdb::RegisterDescriptor& descriptor) const {
+        std::size_t operator () (const DebugServer::Gdb::RegisterDescriptor& descriptor) const {
             // We use the GDB register number as the hash, as it is unique to the register.
             return static_cast<size_t>(descriptor.id);
         }

src/DebugServer/Gdb/ResponsePackets/EmptyResponsePacket.hpp

@@ -2,7 +2,7 @@
 
 #include "ResponsePacket.hpp"
 
-namespace Bloom::DebugServer::Gdb::ResponsePackets
+namespace DebugServer::Gdb::ResponsePackets
 {
     /**
      * Empty response packet expected by the GDB client, in response to certain commands.

src/DebugServer/Gdb/ResponsePackets/ErrorResponsePacket.hpp

@@ -2,7 +2,7 @@
 
 #include "ResponsePacket.hpp"
 
-namespace Bloom::DebugServer::Gdb::ResponsePackets
+namespace DebugServer::Gdb::ResponsePackets
 {
     /**
      * Error response packet expected by the GDB client, to indicate an error, in response to certain commands.

src/DebugServer/Gdb/ResponsePackets/OkResponsePacket.hpp

@@ -2,7 +2,7 @@
 
 #include "ResponsePacket.hpp"
 
-namespace Bloom::DebugServer::Gdb::ResponsePackets
+namespace DebugServer::Gdb::ResponsePackets
 {
     /**
      * OK response packet expected by the GDB client, in response to certain commands.

src/DebugServer/Gdb/ResponsePackets/ResponsePacket.hpp

@@ -5,7 +5,7 @@
 
 #include "src/DebugServer/Gdb/Packet.hpp"
 
-namespace Bloom::DebugServer::Gdb::ResponsePackets
+namespace DebugServer::Gdb::ResponsePackets
 {
     /**
      * Upon receiving a CommandPacket from the connected GDB RSP client, the server is expected to respond with a

src/DebugServer/Gdb/ResponsePackets/SupportedFeaturesResponse.cpp

@@ -1,6 +1,6 @@
 #include "SupportedFeaturesResponse.hpp"
 
-namespace Bloom::DebugServer::Gdb::ResponsePackets
+namespace DebugServer::Gdb::ResponsePackets
 {
     SupportedFeaturesResponse::SupportedFeaturesResponse(
         const std::set<std::pair<Feature, std::optional<std::string>>>& supportedFeatures

src/DebugServer/Gdb/ResponsePackets/SupportedFeaturesResponse.hpp

@@ -8,7 +8,7 @@
 
 #include "src/DebugServer/Gdb/Feature.hpp"
 
-namespace Bloom::DebugServer::Gdb::ResponsePackets
+namespace DebugServer::Gdb::ResponsePackets
 {
     /**
      * The SupportedFeaturesResponse class implements the response packet structure for the "qSupported" command.

src/DebugServer/Gdb/ResponsePackets/TargetStopped.hpp

@@ -9,7 +9,7 @@
 
 #include "src/Services/StringService.hpp"
 
-namespace Bloom::DebugServer::Gdb::ResponsePackets
+namespace DebugServer::Gdb::ResponsePackets
 {
     /**
      * The TargetStopped class implements the response packet structure for any commands that expect a "StopReply"

src/DebugServer/Gdb/Signal.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-namespace Bloom::DebugServer::Gdb
+namespace DebugServer::Gdb
 {
     enum class Signal: unsigned char
     {

src/DebugServer/Gdb/StopReason.hpp

@@ -2,7 +2,7 @@
 
 #include "src/Helpers/BiMap.hpp"
 
-namespace Bloom::DebugServer::Gdb
+namespace DebugServer::Gdb
 {
     enum class StopReason: int
     {

src/DebugServer/Gdb/TargetDescriptor.cpp

@@ -1,6 +1,6 @@
 #include "TargetDescriptor.hpp"
 
-namespace Bloom::DebugServer::Gdb
+namespace DebugServer::Gdb
 {
     TargetDescriptor::TargetDescriptor(
         const Targets::TargetDescriptor& targetDescriptor,

src/DebugServer/Gdb/TargetDescriptor.hpp

@@ -13,7 +13,7 @@
 
 #include "RegisterDescriptor.hpp"
 
-namespace Bloom::DebugServer::Gdb
+namespace DebugServer::Gdb
 {
     /**
      * GDB target descriptor.

src/DebugServer/ServerInterface.hpp

@@ -2,7 +2,7 @@
 
 #include <string>
 
-namespace Bloom::DebugServer
+namespace DebugServer
 {
     /**
      * Every debug server must implement this interface.

src/DebugToolDrivers/DebugTool.hpp

@@ -10,9 +10,7 @@
 
 #include "TargetInterfaces/Microchip/AVR/AvrIspInterface.hpp"
 
-namespace Bloom
+/**
-{
-    /**
  * A debug tool can be any device that provides access to the connected target. Debug tools are usually connected
  * to the host machine via USB.
  *
@@ -21,9 +19,9 @@ namespace Bloom
  * For an example, see the Avr8DebugInterface class and DebugTool::getAvr8DebugInterface(), for the family of AVR
  * 8-bit targets.
  */
-    class DebugTool
+class DebugTool
-    {
+{
-    public:
+public:
     DebugTool() = default;
     virtual ~DebugTool() = default;
 
@@ -101,12 +99,11 @@ namespace Bloom
         return this->initialised;
     }
 
-    protected:
+protected:
     void setInitialised(bool initialised) {
         this->initialised = initialised;
     }
 
-    private:
+private:
     bool initialised = false;
-    };
+};
-}

src/DebugToolDrivers/Microchip/AtmelICE/AtmelIce.cpp

@@ -1,6 +1,6 @@
 #include "AtmelIce.hpp"
 
-namespace Bloom::DebugToolDrivers
+namespace DebugToolDrivers
 {
     AtmelIce::AtmelIce()
         : EdbgDevice(

src/DebugToolDrivers/Microchip/AtmelICE/AtmelIce.hpp

@@ -5,7 +5,7 @@
 
 #include "src/DebugToolDrivers/Microchip/EdbgDevice.hpp"
 
-namespace Bloom::DebugToolDrivers
+namespace DebugToolDrivers
 {
     /**
      * The Atmel-ICE device is an EDBG (Embedded Debugger) device.

src/DebugToolDrivers/Microchip/CuriosityNano/CuriosityNano.cpp

@@ -1,6 +1,6 @@
 #include "CuriosityNano.hpp"
 
-namespace Bloom::DebugToolDrivers
+namespace DebugToolDrivers
 {
     CuriosityNano::CuriosityNano()
         : EdbgDevice(

src/DebugToolDrivers/Microchip/CuriosityNano/CuriosityNano.hpp

@@ -5,7 +5,7 @@
 
 #include "src/DebugToolDrivers/Microchip/EdbgDevice.hpp"
 
-namespace Bloom::DebugToolDrivers
+namespace DebugToolDrivers
 {
     /**
      * The Curiosity Nano is an evaluation board featuring an on-board debugger. The debugger is EDBG-based.

src/DebugToolDrivers/Microchip/EdbgDevice.cpp

@@ -6,10 +6,10 @@
 #include "src/TargetController/Exceptions/DeviceFailure.hpp"
 #include "src/TargetController/Exceptions/DeviceInitializationFailure.hpp"
 
-namespace Bloom::DebugToolDrivers
+namespace DebugToolDrivers
 {
     using namespace Protocols::CmsisDap::Edbg::Avr;
-    using namespace Bloom::Exceptions;
+    using namespace Exceptions;
 
     using Protocols::CmsisDap::Edbg::EdbgInterface;
     using Protocols::CmsisDap::Edbg::EdbgTargetPowerManagementInterface;

src/DebugToolDrivers/Microchip/EdbgDevice.hpp

@@ -12,7 +12,7 @@
 #include "src/DebugToolDrivers/Protocols/CMSIS-DAP/VendorSpecific/EDBG/AVR/EdbgAvrIspInterface.hpp"
 #include "src/DebugToolDrivers/Protocols/CMSIS-DAP/VendorSpecific/EDBG/EdbgTargetPowerManagementInterface.hpp"
 
-namespace Bloom::DebugToolDrivers
+namespace DebugToolDrivers
 {
     /**
      * Microchip EDBG (Embedded Debugger) devices implement the CMSIS-DAP interface. As well as the CMSIS-DAP protocol,

src/DebugToolDrivers/Microchip/JtagIce3/JtagIce3.cpp

@@ -1,6 +1,6 @@
 #include "JtagIce3.hpp"
 
-namespace Bloom::DebugToolDrivers
+namespace DebugToolDrivers
 {
     JtagIce3::JtagIce3()
         : EdbgDevice(

src/DebugToolDrivers/Microchip/JtagIce3/JtagIce3.hpp

@@ -5,7 +5,7 @@
 
 #include "src/DebugToolDrivers/Microchip/EdbgDevice.hpp"
 
-namespace Bloom::DebugToolDrivers
+namespace DebugToolDrivers
 {
     /**
      * The JTAGICE3, from firmware version 3.x+, is an EDBG device.

src/DebugToolDrivers/Microchip/MplabPickit4/MplabPickit4.cpp

@@ -3,7 +3,7 @@
 #include "src/TargetController/Exceptions/DeviceNotFound.hpp"
 #include "src/Services/PathService.hpp"
 
-namespace Bloom::DebugToolDrivers
+namespace DebugToolDrivers
 {
     MplabPickit4::MplabPickit4()
         : EdbgDevice(

src/DebugToolDrivers/Microchip/MplabPickit4/MplabPickit4.hpp

@@ -5,7 +5,7 @@
 
 #include "src/DebugToolDrivers/Microchip/EdbgDevice.hpp"
 
-namespace Bloom::DebugToolDrivers
+namespace DebugToolDrivers
 {
     /**
      * Like the MPLAB Snap, the PICkit 4 is a hybrid device. It can present itself as an EDBG (Embedded Debugger)