Move all network namespace members into the openspace namespace

include/openspace/engine/openspaceengine.h

@@ -53,11 +53,11 @@ class WindowWrapper;
 class SettingsEngine;
 class TimeManager;
 class SyncEngine;
+class ParallelConnection;
 
 namespace interaction { class InteractionHandler; }
 namespace gui { class GUI; }
 //namespace scripting { class ScriptEngine; }
-namespace network { class ParallelConnection; }
 namespace properties { class PropertyOwner; }
 namespace scripting { struct LuaLibrary; }
 namespace scripting { class ScriptScheduler; }
@@ -86,7 +86,7 @@ public:
     NetworkEngine& networkEngine();
     LuaConsole& console();
     ModuleEngine& moduleEngine();
-    network::ParallelConnection& parallelConnection();
+    ParallelConnection& parallelConnection();
     properties::PropertyOwner& globalPropertyOwner();
     WindowWrapper& windowWrapper();
     ghoul::fontrendering::FontManager& fontManager();
@@ -158,7 +158,7 @@ private:
 #ifdef OPENSPACE_MODULE_ONSCREENGUI_ENABLED
     std::unique_ptr<gui::GUI> _gui;
 #endif
-    std::unique_ptr<network::ParallelConnection> _parallelConnection;
+    std::unique_ptr<ParallelConnection> _parallelConnection;
     std::unique_ptr<WindowWrapper> _windowWrapper;
     std::unique_ptr<ghoul::fontrendering::FontManager> _fontManager;
 

include/openspace/interaction/interactionhandler.h

@@ -67,7 +67,7 @@ public:
 
     void resetKeyBindings();
 
-    void addKeyframe(const network::datamessagestructures::CameraKeyframe &kf);
+    void addKeyframe(const datamessagestructures::CameraKeyframe &kf);
     void clearKeyframes();
 
     void bindKeyLocal(Key key, KeyModifier modifier, std::string lua);

include/openspace/interaction/interactionmode.h

@@ -56,7 +56,7 @@ namespace interaction {
         void mouseScrollWheelCallback(double mouseScrollDelta);
 
         // Mutators
-        void addKeyframe(const network::datamessagestructures::CameraKeyframe &kf);
+        void addKeyframe(const datamessagestructures::CameraKeyframe &kf);
         void clearKeyframes();
         void clearOldKeyframes();
 
@@ -65,7 +65,7 @@ namespace interaction {
         const std::list<MouseButton>& getPressedMouseButtons() const;
         glm::dvec2 getMousePosition() const;
         double getMouseScrollDelta() const;
-        const std::vector<network::datamessagestructures::CameraKeyframe>& keyframes() const;
+        const std::vector<datamessagestructures::CameraKeyframe>& keyframes() const;
 
         bool isKeyPressed(std::pair<Key, KeyModifier> keyModPair) const;
         bool isMouseButtonPressed(MouseButton mouseButton) const;
@@ -77,7 +77,7 @@ namespace interaction {
         double _mouseScrollDelta;
 
         // Remote input via keyframes
-        std::vector<network::datamessagestructures::CameraKeyframe> _keyframes;
+        std::vector<datamessagestructures::CameraKeyframe> _keyframes;
     };
 
 
@@ -168,7 +168,7 @@ public:
     virtual void updateCameraStateFromMouseStates(Camera& camera);
 
 private:
-    std::vector<network::datamessagestructures::CameraKeyframe> _keyframes;
+    std::vector<datamessagestructures::CameraKeyframe> _keyframes;
     double _currentKeyframeTime;
 };
 

include/openspace/interaction/luaconsole.h

@@ -60,7 +60,7 @@ public:
 
 
 private:
-    void parallelConnectionChanged(const network::ParallelConnection::Status& status);
+    void parallelConnectionChanged(const ParallelConnection::Status& status);
     void addToCommand(std::string c);
     std::string UnicodeToUTF8(unsigned int codepoint);
 

include/openspace/network/messagestructures.h

@@ -36,138 +36,132 @@
 #include <openspace/util/camera.h>
 
 namespace openspace{
-    
-    namespace network{
-        
-        namespace datamessagestructures {
-            enum class Type : uint32_t {
-                CameraData = 0,
-                TimeData,
-                ScriptData
-            };
+namespace datamessagestructures {
+enum class Type : uint32_t {
+    CameraData = 0,
+    TimeData,
+    ScriptData
+};
 
-            struct CameraKeyframe {
-                CameraKeyframe() {}
-                CameraKeyframe(const std::vector<char> &buffer) {
-                    deserialize(buffer);
-                }
+struct CameraKeyframe {
+    CameraKeyframe() {}
+    CameraKeyframe(const std::vector<char> &buffer) {
+        deserialize(buffer);
+    }
 
-                glm::dvec3 _position;
-                glm::dquat _rotation;
-                double _timestamp;
+    glm::dvec3 _position;
+    glm::dquat _rotation;
+    double _timestamp;
                 
-                void serialize(std::vector<char> &buffer){
-                    //add position
-                    buffer.insert(buffer.end(), reinterpret_cast<char*>(&_position), reinterpret_cast<char*>(&_position) + sizeof(_position));
+    void serialize(std::vector<char> &buffer){
+        //add position
+        buffer.insert(buffer.end(), reinterpret_cast<char*>(&_position), reinterpret_cast<char*>(&_position) + sizeof(_position));
                     
-                    //add orientation
-                    buffer.insert(buffer.end(), reinterpret_cast<char*>(&_rotation), reinterpret_cast<char*>(&_rotation) + sizeof(_rotation));
+        //add orientation
+        buffer.insert(buffer.end(), reinterpret_cast<char*>(&_rotation), reinterpret_cast<char*>(&_rotation) + sizeof(_rotation));
                     
-                    //add timestamp
-                    buffer.insert(buffer.end(), reinterpret_cast<char*>(&_timestamp), reinterpret_cast<char*>(&_timestamp) + sizeof(_timestamp));
-                };
+        //add timestamp
+        buffer.insert(buffer.end(), reinterpret_cast<char*>(&_timestamp), reinterpret_cast<char*>(&_timestamp) + sizeof(_timestamp));
+    };
                 
-                void deserialize(const std::vector<char> &buffer){
-                    int offset = 0;
-                    int size = 0;
+    void deserialize(const std::vector<char> &buffer){
+        int offset = 0;
+        int size = 0;
                     
-                    //position
-                    size = sizeof(_position);
-                    memcpy(&_position, buffer.data() + offset, size);
-                    offset += size;
+        //position
+        size = sizeof(_position);
+        memcpy(&_position, buffer.data() + offset, size);
+        offset += size;
                     
-                    //orientation
-                    size = sizeof(_rotation);
-                    memcpy(&_rotation, buffer.data() + offset, size);
-                    offset += size;
+        //orientation
+        size = sizeof(_rotation);
+        memcpy(&_rotation, buffer.data() + offset, size);
+        offset += size;
                     
-                    //timestamp
-                    size = sizeof(_timestamp);
-                    memcpy(&_timestamp, buffer.data() + offset, size);
-                };
-            };
+        //timestamp
+        size = sizeof(_timestamp);
+        memcpy(&_timestamp, buffer.data() + offset, size);
+    };
+};
             
-            struct TimeKeyframe {
-                TimeKeyframe() {}
-                TimeKeyframe(const std::vector<char> &buffer) {
-                    deserialize(buffer);
-                }
+struct TimeKeyframe {
+    TimeKeyframe() {}
+    TimeKeyframe(const std::vector<char> &buffer) {
+        deserialize(buffer);
+    }
 
-                double _time;
-                double _dt;
-                bool _paused;
-                bool _requiresTimeJump;
-                double _timestamp;
+    double _time;
+    double _dt;
+    bool _paused;
+    bool _requiresTimeJump;
+    double _timestamp;
                 
-                void serialize(std::vector<char> &buffer){
-                    //add current time
-                    buffer.insert(buffer.end(), reinterpret_cast<char*>(&_time), reinterpret_cast<char*>(&_time) + sizeof(_time));
+    void serialize(std::vector<char> &buffer){
+        //add current time
+        buffer.insert(buffer.end(), reinterpret_cast<char*>(&_time), reinterpret_cast<char*>(&_time) + sizeof(_time));
                     
-                    //add delta time
-                    buffer.insert(buffer.end(), reinterpret_cast<char*>(&_dt), reinterpret_cast<char*>(&_dt) + sizeof(_dt));
+        //add delta time
+        buffer.insert(buffer.end(), reinterpret_cast<char*>(&_dt), reinterpret_cast<char*>(&_dt) + sizeof(_dt));
                     
-                    //add wether time is paused or not
-                    buffer.insert(buffer.end(), reinterpret_cast<char*>(&_paused), reinterpret_cast<char*>(&_paused) + sizeof(_paused));
+        //add wether time is paused or not
+        buffer.insert(buffer.end(), reinterpret_cast<char*>(&_paused), reinterpret_cast<char*>(&_paused) + sizeof(_paused));
                     
-                    //add wether a time jump is necessary (recompute paths etc)
-                    buffer.insert(buffer.end(), reinterpret_cast<char*>(&_requiresTimeJump), reinterpret_cast<char*>(&_requiresTimeJump) + sizeof(_requiresTimeJump));
+        //add wether a time jump is necessary (recompute paths etc)
+        buffer.insert(buffer.end(), reinterpret_cast<char*>(&_requiresTimeJump), reinterpret_cast<char*>(&_requiresTimeJump) + sizeof(_requiresTimeJump));
 
-                    //add timestamp
-                    buffer.insert(buffer.end(), reinterpret_cast<char*>(&_timestamp), reinterpret_cast<char*>(&_timestamp) + sizeof(_timestamp));
-                };
+        //add timestamp
+        buffer.insert(buffer.end(), reinterpret_cast<char*>(&_timestamp), reinterpret_cast<char*>(&_timestamp) + sizeof(_timestamp));
+    };
                 
-                void deserialize(const std::vector<char> &buffer){
-                    int offset = 0;
-                    int size = 0;
+    void deserialize(const std::vector<char> &buffer){
+        int offset = 0;
+        int size = 0;
                     
-                    //current time
-                    size = sizeof(_time);
-                    memcpy(&_time, buffer.data() + offset, size);
-                    offset += size;
+        //current time
+        size = sizeof(_time);
+        memcpy(&_time, buffer.data() + offset, size);
+        offset += size;
                     
-                    //delta time
-                    size = sizeof(_dt);
-                    memcpy(&_dt, buffer.data() + offset, size);
-                    offset += size;
+        //delta time
+        size = sizeof(_dt);
+        memcpy(&_dt, buffer.data() + offset, size);
+        offset += size;
                     
-                    //is time paused?
-                    size = sizeof(_paused);
-                    memcpy(&_paused, buffer.data() + offset, size);
-                    offset += sizeof(_paused);
+        //is time paused?
+        size = sizeof(_paused);
+        memcpy(&_paused, buffer.data() + offset, size);
+        offset += sizeof(_paused);
     
-                    //is a time jump required?
-                    size = sizeof(_requiresTimeJump);
-                    memcpy(&_requiresTimeJump, buffer.data() + offset, size);
-                    offset += size;
+        //is a time jump required?
+        size = sizeof(_requiresTimeJump);
+        memcpy(&_requiresTimeJump, buffer.data() + offset, size);
+        offset += size;
 
-                    // timestamp
-                    size = sizeof(_timestamp);
-                    memcpy(&_timestamp, buffer.data() + offset, size);
-                    offset += size;
-                };
-            };
+        // timestamp
+        size = sizeof(_timestamp);
+        memcpy(&_timestamp, buffer.data() + offset, size);
+        offset += size;
+    };
+};
             
-            struct ScriptMessage {
-                ScriptMessage() {}
-                ScriptMessage(const std::vector<char> &buffer) {
-                    deserialize(buffer);
-                }
+struct ScriptMessage {
+    ScriptMessage() {}
+    ScriptMessage(const std::vector<char> &buffer) {
+        deserialize(buffer);
+    }
 
-                std::string _script;
+    std::string _script;
                 
-                void serialize(std::vector<char> &buffer){
-                    buffer.insert(buffer.end(), _script.begin(), _script.end());
-                };
+    void serialize(std::vector<char> &buffer){
+        buffer.insert(buffer.end(), _script.begin(), _script.end());
+    };
                 
-                void deserialize(const std::vector<char> &buffer){
-                    _script.assign(buffer.begin(), buffer.end());
-                };
-            };
+    void deserialize(const std::vector<char> &buffer){
+        _script.assign(buffer.begin(), buffer.end());
+    };
+};
             
-        } //namespace messagestructures
-
-    } // namespace network
-    
+} //namespace messagestructures
 } // namespace openspace
 
 #endif // __MESSAGESTRUCTURES_H__

include/openspace/network/parallelconnection.h

@@ -61,9 +61,8 @@ typedef int _SOCKET;
 #endif
 
 namespace openspace {
-namespace network {
 
-class ParallelConnection{
+class ParallelConnection {
     public:
     enum class Status : uint32_t {
         Disconnected = 0,
@@ -94,11 +93,11 @@ class ParallelConnection{
 
     struct DataMessage {
         DataMessage() {};
-        DataMessage(network::datamessagestructures::Type t, const std::vector<char>& c)
+        DataMessage(datamessagestructures::Type t, const std::vector<char>& c)
             : type(t)
             , content(c)
         {};
-        network::datamessagestructures::Type type;
+        datamessagestructures::Type type;
         std::vector<char> content;
     };
 
@@ -204,7 +203,6 @@ private:
     std::shared_ptr<ghoul::Event<>> _connectionEvent;
 };
 
-} // namespace network
 } // namespace openspace
 
 #endif // __OSPARALLELCONNECTION_H__

include/openspace/util/timemanager.h

@@ -33,15 +33,15 @@ namespace openspace {
 class TimeManager {
 public:
     void preSynchronization(double dt);
-    void addKeyframe(const network::datamessagestructures::TimeKeyframe& kf);
+    void addKeyframe(const datamessagestructures::TimeKeyframe& kf);
     void removeKeyframesBefore(double timestamp);
     void clearKeyframes();
 private:
     void consumeKeyframes(double dt);
-    std::deque<network::datamessagestructures::TimeKeyframe> _keyframes;
+    std::deque<datamessagestructures::TimeKeyframe> _keyframes;
     static bool compareKeyframeTimes(
-        const network::datamessagestructures::TimeKeyframe& a,
-        const network::datamessagestructures::TimeKeyframe& b);
+        const datamessagestructures::TimeKeyframe& a,
+        const datamessagestructures::TimeKeyframe& b);
     double _latestConsumedTimestamp;
 };
 

src/documentation/core_registration.cpp

@@ -74,7 +74,7 @@ void registerCoreClasses(scripting::ScriptEngine& engine) {
     engine.addLibrary(interaction::InteractionHandler::luaLibrary());
     engine.addLibrary(LuaConsole::luaLibrary());
     engine.addLibrary(gui::GUI::luaLibrary());
-    engine.addLibrary(network::ParallelConnection::luaLibrary());
+    engine.addLibrary(ParallelConnection::luaLibrary());
     engine.addLibrary(ModuleEngine::luaLibrary());
     engine.addLibrary(scripting::ScriptScheduler::luaLibrary());
     engine.addLibrary(WindowWrapper::luaLibrary());

src/engine/openspaceengine.cpp

@@ -146,7 +146,7 @@ OpenSpaceEngine::OpenSpaceEngine(std::string programName,
 #ifdef OPENSPACE_MODULE_ONSCREENGUI_ENABLED
     , _gui(new gui::GUI)
 #endif
-    , _parallelConnection(new network::ParallelConnection)
+    , _parallelConnection(new ParallelConnection)
     , _windowWrapper(std::move(windowWrapper))
     , _globalPropertyNamespace(new properties::PropertyOwner)
     , _isMaster(false)
@@ -1151,7 +1151,7 @@ gui::GUI& OpenSpaceEngine::gui() {
 }
 #endif
 
-network::ParallelConnection& OpenSpaceEngine::parallelConnection() {
+ParallelConnection& OpenSpaceEngine::parallelConnection() {
     ghoul_assert(_parallelConnection, "ParallelConnection must not be nullptr");
     return *_parallelConnection;
 }

src/interaction/interactionhandler.cpp

@@ -148,7 +148,7 @@ InteractionHandler::~InteractionHandler() {
 
 void InteractionHandler::initialize() {
     OsEng.parallelConnection().connectionEvent()->subscribe("interactionHandler", "statusChanged", [this]() {
-        if (OsEng.parallelConnection().status() == network::ParallelConnection::Status::ClientWithHost) {
+        if (OsEng.parallelConnection().status() == ParallelConnection::Status::ClientWithHost) {
             setInteractionMode("Keyframe");
         } else {
             auto keyframeModeIter = _interactionModes.find("Keyframe");
@@ -581,7 +581,7 @@ scripting::LuaLibrary InteractionHandler::luaLibrary() {
     };
 }
 
-void InteractionHandler::addKeyframe(const network::datamessagestructures::CameraKeyframe &kf) {
+void InteractionHandler::addKeyframe(const datamessagestructures::CameraKeyframe &kf) {
     _inputState->addKeyframe(kf);
 }
 

src/interaction/interactionmode.cpp

@@ -57,15 +57,15 @@ namespace interaction {
 
     }
 
-    const std::vector<network::datamessagestructures::CameraKeyframe>& InputState::keyframes() const {
+    const std::vector<datamessagestructures::CameraKeyframe>& InputState::keyframes() const {
         return _keyframes;
     }
 
-    void InputState::addKeyframe(const network::datamessagestructures::CameraKeyframe &kf) {
+    void InputState::addKeyframe(const datamessagestructures::CameraKeyframe &kf) {
         clearOldKeyframes();
 
-        auto compareTimestamps = [](const network::datamessagestructures::CameraKeyframe a,
-            network::datamessagestructures::CameraKeyframe b) {
+        auto compareTimestamps = [](const datamessagestructures::CameraKeyframe a,
+            datamessagestructures::CameraKeyframe b) {
             return a._timestamp < b._timestamp;
         };
 
@@ -77,7 +77,7 @@ namespace interaction {
 
     void InputState::clearOldKeyframes() {
         double now = OsEng.runTime();
-        auto isLater = [now](const network::datamessagestructures::CameraKeyframe kf) {
+        auto isLater = [now](const datamessagestructures::CameraKeyframe kf) {
             return kf._timestamp > now;
         };
 
@@ -201,7 +201,7 @@ void KeyframeInteractionMode::updateCameraStateFromMouseStates(Camera& camera) {
     }
 
     double now = OsEng.runTime();
-    auto isLater = [now](const network::datamessagestructures::CameraKeyframe kf) {
+    auto isLater = [now](const datamessagestructures::CameraKeyframe kf) {
         return kf._timestamp > now;
     };
 

src/interaction/luaconsole.cpp

@@ -94,7 +94,7 @@ void LuaConsole::initialize() {
 
     OsEng.parallelConnection().connectionEvent()->subscribe("luaConsole",
         "statusChanged", [this]() {
-        network::ParallelConnection::Status status = OsEng.parallelConnection().status();
+        ParallelConnection::Status status = OsEng.parallelConnection().status();
         parallelConnectionChanged(status);
     });
 
@@ -431,8 +431,8 @@ void LuaConsole::toggleMode() {
     }
 }
 
-void LuaConsole::parallelConnectionChanged(const network::ParallelConnection::Status& status) {
-    _remoteScripting = status == network::ParallelConnection::Status::Host;
+void LuaConsole::parallelConnectionChanged(const ParallelConnection::Status& status) {
+    _remoteScripting = status == ParallelConnection::Status::Host;
 }
 
 

src/network/parallelconnection.cpp

@@ -76,8 +76,6 @@ namespace {
 
 namespace openspace {
 
-namespace network {
-        
 ParallelConnection::ParallelConnection()
     : _passCode(0)
     , _port("20501")
@@ -525,25 +523,25 @@ void ParallelConnection::dataMessageReceived(const std::vector<char>& messageCon
     uint32_t type = *(reinterpret_cast<const uint32_t*>(messageContent.data()));   
     std::vector<char> buffer(messageContent.begin() + sizeof(uint32_t), messageContent.end());
  
-    switch(static_cast<network::datamessagestructures::Type>(type)) {
-        case network::datamessagestructures::Type::CameraData: {
+    switch(static_cast<datamessagestructures::Type>(type)) {
+        case datamessagestructures::Type::CameraData: {
 
-            network::datamessagestructures::CameraKeyframe kf(buffer);
+            datamessagestructures::CameraKeyframe kf(buffer);
             kf._timestamp = calculateBufferedKeyframeTime(kf._timestamp);
 
             OsEng.interactionHandler().addKeyframe(kf);
             break;
         }
-        case network::datamessagestructures::Type::TimeData: {
+        case datamessagestructures::Type::TimeData: {
 
-            network::datamessagestructures::TimeKeyframe kf(buffer);
+            datamessagestructures::TimeKeyframe kf(buffer);
             kf._timestamp = calculateBufferedKeyframeTime(kf._timestamp);
 
             OsEng.timeManager().addKeyframe(kf);
             break;
         }
-        case network::datamessagestructures::Type::ScriptData: {
-            network::datamessagestructures::ScriptMessage sm;
+        case datamessagestructures::Type::ScriptData: {
+            datamessagestructures::ScriptMessage sm;
             sm.deserialize(buffer);
             OsEng.scriptEngine().queueScript(sm._script, scripting::ScriptEngine::RemoteScripting::No);
             
@@ -638,7 +636,7 @@ void ParallelConnection::connectionStatusMessageReceived(const std::vector<char>
     }
     size_t pointer = 0;
     uint32_t statusIn = *(reinterpret_cast<const uint32_t*>(&message[pointer]));
-    network::ParallelConnection::Status status = static_cast<network::ParallelConnection::Status>(statusIn);
+    ParallelConnection::Status status = static_cast<ParallelConnection::Status>(statusIn);
     pointer += sizeof(uint32_t);
 
     size_t hostNameSize = *(reinterpret_cast<const uint32_t*>(&message[pointer]));
@@ -731,7 +729,7 @@ void ParallelConnection::nConnectionsMessageReceived(const std::vector<char>& me
             
     //serialize and encode all scripts into scriptbuffer
     std::vector<std::string>::iterator script_it;
-    network::datamessagestructures::ScriptMessage sm;
+    datamessagestructures::ScriptMessage sm;
     for(script_it = scripts.begin();
         script_it != scripts.end();
         ++script_it){
@@ -913,13 +911,13 @@ bool ParallelConnection::initNetworkAPI(){
 void ParallelConnection::sendScript(const std::string& script) {
     if (!isHost()) return;
 
-    network::datamessagestructures::ScriptMessage sm;
+    datamessagestructures::ScriptMessage sm;
     sm._script = script;
     
     std::vector<char> buffer;
     sm.serialize(buffer);
 
-    queueOutDataMessage(DataMessage(network::datamessagestructures::Type::ScriptData, buffer));
+    queueOutDataMessage(DataMessage(datamessagestructures::Type::ScriptData, buffer));
 }
 
 void ParallelConnection::preSynchronization(){
@@ -977,7 +975,7 @@ const std::string& ParallelConnection::hostName() {
 
 void ParallelConnection::sendCameraKeyframe() {
     //create a keyframe with current position and orientation of camera
-    network::datamessagestructures::CameraKeyframe kf;
+    datamessagestructures::CameraKeyframe kf;
     kf._position = OsEng.interactionHandler().camera()->positionVec3();
     kf._rotation = OsEng.interactionHandler().camera()->rotationQuaternion();
 
@@ -991,12 +989,12 @@ void ParallelConnection::sendCameraKeyframe() {
     kf.serialize(buffer);
 
     //send message
-    queueOutDataMessage(DataMessage(network::datamessagestructures::Type::CameraData, buffer));
+    queueOutDataMessage(DataMessage(datamessagestructures::Type::CameraData, buffer));
 }
 
 void ParallelConnection::sendTimeKeyframe() {
     //create a keyframe with current position and orientation of camera
-    network::datamessagestructures::TimeKeyframe kf;
+    datamessagestructures::TimeKeyframe kf;
     
     kf._dt = Time::ref().deltaTime();
     kf._paused = Time::ref().paused();
@@ -1013,7 +1011,7 @@ void ParallelConnection::sendTimeKeyframe() {
     kf.serialize(buffer);
 
     //send message
-    queueOutDataMessage(DataMessage(network::datamessagestructures::Type::TimeData, buffer));
+    queueOutDataMessage(DataMessage(datamessagestructures::Type::TimeData, buffer));
     _timeJumped = false;
 }
 
@@ -1107,7 +1105,5 @@ scripting::LuaLibrary ParallelConnection::luaLibrary() {
         }
     };
 }
-        
-} // namespace network
-    
+
 } // namespace openspace

src/rendering/renderengine.cpp

@@ -1328,28 +1328,28 @@ void RenderEngine::renderInformation() {
                     break;
             }
 
-        network::ParallelConnection::Status status = OsEng.parallelConnection().status();
+        ParallelConnection::Status status = OsEng.parallelConnection().status();
         size_t nConnections = OsEng.parallelConnection().nConnections();
         const std::string& hostName = OsEng.parallelConnection().hostName();
 
         std::string connectionInfo = "";
         int nClients = nConnections;
-        if (status == network::ParallelConnection::Status::Host) {
+        if (status == ParallelConnection::Status::Host) {
             nClients--;
             if (nClients == 1) {
                 connectionInfo = "Hosting session with 1 client";
             } else {
                 connectionInfo = "Hosting session with " + std::to_string(nClients) + " clients";
             }
-        } else if (status == network::ParallelConnection::Status::ClientWithHost) {
+        } else if (status == ParallelConnection::Status::ClientWithHost) {
             nClients--;
             connectionInfo = "Session hosted by '" + hostName + "'";
-        } else if (status == network::ParallelConnection::Status::ClientWithoutHost) {
+        } else if (status == ParallelConnection::Status::ClientWithoutHost) {
             connectionInfo = "Host is disconnected";
         }
 
-        if (status == network::ParallelConnection::Status::ClientWithHost ||
-            status == network::ParallelConnection::Status::ClientWithoutHost) {
+        if (status == ParallelConnection::Status::ClientWithHost ||
+            status == ParallelConnection::Status::ClientWithoutHost) {
             connectionInfo += "\n";
             if (nClients > 2) {
                 connectionInfo += "You and " + std::to_string(nClients - 1) + " more clients are tuned in";

src/util/timemanager.cpp

@@ -32,7 +32,7 @@ namespace {
 
 namespace openspace {
 
-using network::datamessagestructures::TimeKeyframe;
+using datamessagestructures::TimeKeyframe;
 
 void TimeManager::preSynchronization(double dt) {
     double now = OsEng.runTime();
@@ -135,7 +135,7 @@ void TimeManager::addKeyframe(const TimeKeyframe& kf) {
 
 
 void TimeManager::removeKeyframesBefore(double timestamp) {
-    network::datamessagestructures::TimeKeyframe kf;
+    datamessagestructures::TimeKeyframe kf;
     kf._timestamp = timestamp;
     auto iter = std::upper_bound(_keyframes.begin(), _keyframes.end(), kf, &TimeManager::compareKeyframeTimes);
     _keyframes.erase(_keyframes.begin(), iter);