Changeset 917 for code/branches/network/src

Timestamp:

Mar 21, 2008, 6:14:31 PM (16 years ago)

Author:

rgrieder

Message:

• merged all changes in the input branch into this one
• moved Tickable to core (would have created circular library dependencies)
• exported OrxListener to a separate file, soon to be deleted

changed

, &&, XOR back to or, and, xor because I found the necessary include file for VC++

• created abortRequest() in Orxonox.cc to call for a smooth end of the game (an alternative would be to make tick() return a boolean, like it is with frameStarted())

Location:

code/branches/network/src

Files:

• network/Client.h (modified) (1 diff)
• network/Server.cc (modified) (2 diffs)
• network/Server.h (modified) (1 diff)
• orxonox/Orxonox.cc (modified) (13 diffs)
• orxonox/Orxonox.h (modified) (4 diffs)
• orxonox/OrxonoxPlatform.h (modified) (3 diffs)
• orxonox/OrxonoxStableHeaders.h (modified) (3 diffs)
• orxonox/core/Identifier.h (modified) (1 diff)
• orxonox/core/Tickable.cc (added)
• orxonox/core/Tickable.h (added)
• orxonox/objects/Tickable.cc (deleted)
• orxonox/objects/Tickable.h (deleted)
• orxonox/objects/WorldEntity.h (modified) (1 diff)
• orxonox/objects/weapon/BulletManager.h (modified) (1 diff)
• orxonox/tools/OrxListener.cc (copied) (copied from code/branches/input/src/orxonox/tools/OrxListener.cc) (2 diffs)
• orxonox/tools/OrxListener.h (copied) (copied from code/branches/input/src/orxonox/tools/OrxListener.h) (3 diffs)
• orxonox/tools/Timer.cc (modified) (2 diffs)
• orxonox/tools/Timer.h (modified) (3 diffs)
• util/Math.h (modified) (1 diff)
• util/MultiTypeMath.h (modified) (1 diff)
• util/MultiTypePrimitive.h (modified) (1 diff)
• util/MultiTypeString.h (modified) (1 diff)
• util/Sleep.h (modified) (1 diff)
• util/XMLIncludes.h (modified) (1 diff)
• util/tinyxml/TinyXMLPrereqs.h (deleted)

code/branches/network/src/network/Client.h

@@ -16 +16 @@
 #include <string>
 
-#include "orxonox/objects/Tickable.h"
+#include "core/Tickable.h"
 
 #include "NetworkPrereqs.h"

code/branches/network/src/network/Server.cc

@@ -13 +13 @@
 #include <iostream>
 
+#include "util/Sleep.h"
 #include "ConnectionManager.h"
 #include "PacketTypes.h"
@@ -112 +113 @@
     processQueue();
     updateGamestate();
+
     sleep(1); // TODO remove
     return;

code/branches/network/src/network/Server.h

@@ -16 +16 @@
 #include <string>
 
-#include "orxonox/objects/Tickable.h"
+#include "core/Tickable.h"
 
 #include "PacketManager.h"

code/branches/network/src/orxonox/Orxonox.cc

@@ -44 +44 @@
 #include <OgreOverlay.h>
 #include <OgreOverlayManager.h>
+#include <OgreTimer.h>
+#include <OgreWindowEventUtilities.h>
 
 //****** OIS *******
@@ -56 +58 @@
 #include "util/Sleep.h"
 
-// loader and audio
-//#include "loader/LevelLoader.h"
+// audio
 #include "audio/AudioManager.h"
 
@@ -69 +70 @@
 
 // objects
-#include "objects/Tickable.h"
 #include "tools/Timer.h"
-#include "objects/NPC.h"
+#include "tools/OrxListener.h"
 #include "core/ArgReader.h"
+#include "core/Debug.h"
 #include "core/Factory.h"
-#include "core/Debug.h"
 #include "core/Loader.h"
+#include "core/Tickable.h"
 #include "hud/HUD.h"
 #include "objects/weapon/BulletManager.h"
@@ -84 +85 @@
 namespace orxonox
 {
-   // put this in a seperate Class or solve the problem in another fashion
-  class OrxListener : public Ogre::FrameListener
-  {
-    public:
-      OrxListener(OIS::Keyboard *keyboard, audio::AudioManager*  auMan, gameMode mode)
-      {
-        mKeyboard = keyboard;
-        mode_=mode;
-        auMan_ = auMan;
-      }
-
-      bool frameStarted(const Ogre::FrameEvent& evt)
-      {
-        auMan_->update();
-        updateAI();
-
-//         if(mode_ == SERVER)
-//           server_g->tick(evt.timeSinceLastFrame);
-//         else if(mode_ == CLIENT)
-//           client_g->tick(evt.timeSinceLastFrame);
-
-        usleep(10);
-
-        if(mode_!=CLIENT){
-        mKeyboard->capture();
-        return !mKeyboard->isKeyDown(OIS::KC_ESCAPE);
-        }else
-          return true;
-      }
-
-      void updateAI()
-      {
-        for(Iterator<NPC> it = ObjectList<NPC>::start(); it; ++it)
-        {
-          it->update();
-        }
-      }
-
-    private:
-      gameMode mode_;
-      OIS::Keyboard *mKeyboard;
-      audio::AudioManager*  auMan_;
-  };
-
-  // init static singleton reference of Orxonox
+  /// init static singleton reference of Orxonox
   Orxonox* Orxonox::singletonRef_ = NULL;
 
@@ -138 +95 @@
     this->ogre_ = new GraphicsEngine();
     this->dataPath_ = "";
-//    this->loader_ = 0;
     this->auMan_ = 0;
     this->singletonRef_ = 0;
@@ -146 +102 @@
     this->frameListener_ = 0;
     this->root_ = 0;
+    // turn frame smoothing on by setting a value different from 0
+    this->frameSmoothingTime_ = 0.0f;
+    this->bAbort_ = false;
   }
 
@@ -159 +118 @@
    * initialization of Orxonox object
    * @param argc argument counter
-   * @param argv list of arguments
+   * @param argv list of argumenst
    * @param path path to config (in home dir or something)
    */
@@ -281 +240 @@
     //TODO: destroy and destruct everything and print nice error msg
     delete this;
+  }
+
+  /**
+    Asks the mainloop nicely to abort.
+  */
+  void Orxonox::abortRequest()
+  {
+    bAbort_ = true;
   }
 
@@ -365 +332 @@
   }
 
-  /**
-   *
-   * @param
-   */
   void Orxonox::createScene(void)
   {
@@ -383 +346 @@
 
     Ogre::Overlay* hudOverlay = Ogre::OverlayManager::getSingleton().getByName("Orxonox/HUD1.2");
-    HUD* orxonoxHud;
-    orxonoxHud = new HUD();
-    orxonoxHud->setEnergyValue(20);
-    orxonoxHud->setEnergyDistr(20,20,60);
+    //HUD* orxonoxHud;
+    orxonoxHUD_ = new HUD();
+    orxonoxHUD_->setEnergyValue(20);
+    orxonoxHUD_->setEnergyDistr(20,20,60);
     hudOverlay->show();
 
@@ -398 +361 @@
 
 
-  /**
-   *
-   */
   void Orxonox::setupScene()
   {
@@ -451 +411 @@
   void Orxonox::createFrameListener()
   {
-    TickFrameListener* TickFL = new TickFrameListener();
-    ogre_->getRoot()->addFrameListener(TickFL);
-
-    TimerFrameListener* TimerFL = new TimerFrameListener();
-    ogre_->getRoot()->addFrameListener(TimerFL);
-
-    //if(mode_!=CLIENT) // FIXME just a hack ------- remove this in future
-      frameListener_ = new OrxListener(keyboard_, auMan_, mode_);
-    ogre_->getRoot()->addFrameListener(frameListener_);
+    frameListener_ = new OrxListener(keyboard_, auMan_, mode_);
   }
 
@@ -477 +429 @@
       ms.height = height;
     }
-    ogre_->getRoot()->startRendering();
+    mainLoop();
+  }
+
+  /**
+    Main loop of the orxonox game.
+    This is a new solution, using the ogre engine instead of beeing used by it.
+    An alternative solution would be to simply use the timer of the Root object,
+    but that implies using Ogre in any case. There would be no way to test
+    our code without the help of the root object.
+    There's even a chance that we can dispose of the root object entirely
+    in server mode.
+    About the loop: The design is almost exactly like the one in ogre, so that
+    if any part of ogre registers a framelisteners, it will still behave
+    correctly. Furthermore I have taken over the time smoothing feature from
+    ogre. If turned on (see orxonox constructor), it will calculate the dt_n by
+    means of the recent most dt_n-1, dt_n-2, etc.
+  */
+  void Orxonox::mainLoop()
+  {
+    // use the ogre timer class to measure time.
+    Ogre::Timer *timer = new Ogre::Timer();
+    timer->reset();
+
+    // Contains the times of recently fired events
+    std::deque<unsigned long> eventTimes[3];
+    // Clear event times
+    for (int i = 0; i < 3; ++i)
+      eventTimes[i].clear();
+
+          while (!bAbort_)
+          {
+                  // Pump messages in all registered RenderWindows
+      Ogre::WindowEventUtilities::messagePump();
+
+      // get current time
+      unsigned long now = timer->getMilliseconds();
+
+      // create an event to pass to the frameStarted method in ogre
+      Ogre::FrameEvent evt;
+      evt.timeSinceLastEvent = calculateEventTime(now, eventTimes[0]);
+      evt.timeSinceLastFrame = calculateEventTime(now, eventTimes[1]);
+
+      // show the current time in the HUD
+      orxonoxHUD_->setTime((int)now, 0);
+
+      // don't forget to call _fireFrameStarted in ogre to make sure
+      // everything goes smoothly
+      if (!ogre_->getRoot()->_fireFrameStarted(evt))
+        break;
+
+      // Iterate through all Tickables and call their tick(dt) function
+      for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; )
+        (it++)->tick((float)evt.timeSinceLastFrame);
+
+      if (mode_ != SERVER)
+      {
+        // only render in non-server mode
+        ogre_->getRoot()->_updateAllRenderTargets();
+      }
+
+      // get current time
+      now = timer->getMilliseconds();
+
+      // create an event to pass to the frameEnded method in ogre
+      evt.timeSinceLastEvent = calculateEventTime(now, eventTimes[0]);
+      evt.timeSinceLastFrame = calculateEventTime(now, eventTimes[2]);
+
+      // again, just to be sure ogre works fine
+      if (!ogre_->getRoot()->_fireFrameEnded(evt))
+        break;
+          }
+  }
+
+  /**
+    Method for calculating the average time between recently fired events.
+    Code directly taken from OgreRoot.cc
+    @param now The current time in ms.
+    @param type The type of event to be considered.
+  */
+  float Orxonox::calculateEventTime(unsigned long now, std::deque<unsigned long> &times)
+  {
+    // Calculate the average time passed between events of the given type
+    // during the last mFrameSmoothingTime seconds.
+
+    times.push_back(now);
+
+    if(times.size() == 1)
+      return 0;
+
+    // Times up to mFrameSmoothingTime seconds old should be kept
+    unsigned long discardThreshold =
+      static_cast<unsigned long>(frameSmoothingTime_ * 1000.0f);
+
+    // Find the oldest time to keep
+    std::deque<unsigned long>::iterator it = times.begin(),
+      end = times.end()-2; // We need at least two times
+    while(it != end)
+    {
+      if (now - *it > discardThreshold)
+        ++it;
+      else
+        break;
+    }
+
+    // Remove old times
+    times.erase(times.begin(), it);
+
+    return (float)(times.back() - times.front()) / ((times.size()-1) * 1000);
   }
 }

code/branches/network/src/orxonox/Orxonox.h

@@ -9 +9 @@
 
 #include <string>
+#include <deque>
 
 #include <OgrePrerequisites.h>
@@ -37 +38 @@
       // not sure if this should be private
       void die(/* some error code */);
+      void abortRequest();
       static Orxonox* getSingleton();
       inline Ogre::SceneManager* getSceneManager()         { return ogre_->getSceneManager(); };
@@ -65 +67 @@
       void createFrameListener();
       void startRenderLoop();
+      void mainLoop();
+      void updateTimers(float);
+      float calculateEventTime(unsigned long, std::deque<unsigned long>&);
 
     private:
@@ -78 +83 @@
       OrxListener*          frameListener_;
       Ogre::Root*           root_;
+      // TODO: make this a config-value by creating a config class for orxonox
+      float                 frameSmoothingTime_;
+      // little hack to actually show something dynamic in the HUD
+      HUD*                  orxonoxHUD_;
+      bool                  bAbort_;
 
       // this is used to identify the mode (server/client/...) we're in

code/branches/network/src/orxonox/OrxonoxPlatform.h

@@ -210 +210 @@
 //#   pragma warning (disable : 4503)
 
-// disable: "conversion from 'double' to 'float', possible loss of data
+// disable: conversion from 'double' to 'float', possible loss of data
+// disable: conversion from 'ogg_int64_t' to 'long', possible loss of data
+// This has been dealt with in base_properties of the solution since the
+// warning primarily occurs in library header files (which are mostly
+// included before OrxonoxPlatform.h is)
 //#   pragma warning (disable : 4244)
 
@@ -221 +225 @@
 // disable: "<type> needs to have dll-interface to be used by clients'
 // Happens on STL member variables which are not public therefore is ok
+// This has been dealt with in base_properties of the solution since the
+// warning primarily occurs in library header files (which are mostly
+// included before OrxonoxPlatform.h is)
 //#   pragma warning (disable : 4251)
+
+// disable: 'MultiTypeString' : multiple assignment operators specified
+// Used in MultiType and works fine so far
+#   pragma warning (disable : 4522)
 
 // disable: "non dll-interface class used as base for dll-interface class"
@@ -251 +262 @@
 #endif
 
+
+// Define the english written operators like and, or, xor
+#if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
+#  include <iso646.h>
+#endif
+
 } /* namespace orxonox */
 

code/branches/network/src/orxonox/OrxonoxStableHeaders.h

@@ -73 +73 @@
 //#include "audio/AudioManager.h"
 
-//#include "core/CoreIncludes.h"
+#include "core/CoreIncludes.h"
 #include "core/BaseObject.h"
 //#include "core/ArgReader.h"
 #include "core/Error.h"
+#include "core/Loader.h"
+#include "core/XMLPort.h"
+#include "core/Tickable.h"
 
 #include "network/Synchronisable.h"
@@ -87 +90 @@
 #include "util/String2Number.h"
 #include "util/Tokenizer.h"
+#include "util/Multitype.h"
+#include "util/MultiTypeMath.h"
+#include "util/MultiTypePrimitive.h"
+#include "util/MultiTypeString.h"
+#include "util/substring.h"
+#include "util/XMLIncludes.h"
+
 #include "util/tinyxml/ticpp.h"
 #include "util/tinyxml/tinyxml.h"
@@ -106 +116 @@
 //#include "objects/Skybox.h"
 //#include "objects/SpaceShipSteeringObject.h"
-#include "objects/Tickable.h"
 #include "objects/WorldEntity.h"
 //#include "particle/ParticleInterface.h"

code/branches/network/src/orxonox/core/Identifier.h

@@ -206 +206 @@
     };
 
-    std::ostream& operator<<(std::ostream& out, const std::list<const Identifier*>& list);
+    _CoreExport std::ostream& operator<<(std::ostream& out, const std::list<const Identifier*>& list);
 
 

code/branches/network/src/orxonox/objects/WorldEntity.h

@@ -12 +12 @@
 //#include "util/tinyxml/tinyxml.h"
 #include "core/BaseObject.h"
-#include "Tickable.h"
+#include "core/Tickable.h"
 #include "../tools/Mesh.h"
 

code/branches/network/src/orxonox/objects/weapon/BulletManager.h

@@ -39 +39 @@
 #include "util/tinyxml/tinyxml.h"
 #include "core/BaseObject.h"
-#include "../Tickable.h"
+#include "core/Tickable.h"
 
 namespace orxonox {

code/branches/network/src/orxonox/tools/OrxListener.cc

@@ -31 +31 @@
 #include "objects/NPC.h"
 #include "audio/AudioManager.h"
+#include "Orxonox.h"
 #include "OrxListener.h"
 
 namespace orxonox
 {
-  OrxListener::OrxListener(audio::AudioManager*  auMan, gameMode mode)
+  OrxListener::OrxListener(OIS::Keyboard *keyboard, audio::AudioManager*  auMan, gameMode mode)
   {
+    keyboard_ = keyboard;
     mode_=mode;
     auMan_ = auMan;
@@ -45 +47 @@
     auMan_->update();
     updateAI();
+
+    keyboard_->capture();
+    if (keyboard_->isKeyDown(OIS::KC_ESCAPE))
+      Orxonox::getSingleton()->abortRequest();
   }
 

code/branches/network/src/orxonox/tools/OrxListener.h

@@ -34 +34 @@
 #define _OrxListener_H__
 
+#include <OIS/OISPrereqs.h>
+
 #include "../OrxonoxPrereqs.h"
 #include "audio/AudioPrereqs.h"
 #include "Orxonox.h"
-#include "objects/Tickable.h"
+#include "core/Tickable.h"
 
 namespace orxonox
@@ -44 +46 @@
   {
     public:
-      OrxListener(audio::AudioManager*  auMan, gameMode mode);
+      OrxListener(OIS::Keyboard *keyboard, audio::AudioManager*  auMan, gameMode mode);
 
       void tick(float dt);
@@ -52 +54 @@
       gameMode mode_;
       audio::AudioManager* auMan_;
+      OIS::Keyboard *keyboard_;
   };
 }

code/branches/network/src/orxonox/tools/Timer.cc

@@ +1 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+#include "OrxonoxStableHeaders.h"
+
 #include "core/CoreIncludes.h"
 #include "Timer.h"
@@ -17 +46 @@
         this->time_ = 0;
     }
+
+    /**
+        @brief Updates the timer before the frames are rendered.
+    */
+    void TimerBase::tick(float dt)
+    {
+        if (this->bActive_)
+        {
+            // If active: Decrease the timer by the duration of the last frame
+            this->time_ -= dt;
+
+            if (this->time_ <= 0)
+            {
+                // It's time to call the function
+                if (this->bLoop_)
+                    // Q: Why '+=' and not '='? A: Think about it. It's more accurate like that. Seriously.
+                    this->time_ += this->interval_;
+                else
+                    this->stopTimer(); // Stop the timer if we don't want to loop
+
+                this->run();
+            }
+        }
+    }
+
 }

code/branches/network/src/orxonox/tools/Timer.h

@@ -58 +58 @@
 #define _Timer_H__
 
-#include <OgreFrameListener.h>
 #include "../OrxonoxPrereqs.h"
+#include "core/Tickable.h"
 
 namespace orxonox
 {
     //! TimerBase is the parent of the Timer class.
-    class _OrxonoxExport TimerBase : public OrxonoxClass
+    class _OrxonoxExport TimerBase : public Tickable
     {
-        friend class TimerFrameListener;
-
         public:
             TimerBase();
@@ -83 +81 @@
             /** @brief Returns true if the Timer is active (= not stoped, not paused). @return True = Time is active */
             inline bool isActive() const { return this->bActive_; }
+
+            void tick(float dt);
 
         protected:
@@ -145 +145 @@
     };
 
-    //! The TimerFrameListener manages all Timers in the game.
-    class TimerFrameListener : public Ogre::FrameListener
-    {
-        private:
-            /** @brief Gets called before a frame gets rendered. */
-            bool frameStarted(const Ogre::FrameEvent &evt)
-            {
-                // Iterate through all Timers
-                for (Iterator<TimerBase> it = ObjectList<TimerBase>::start(); it; )
-                {
-                    if (it->isActive())
-                    {
-                        // If active: Decrease the timer by the duration of the last frame
-                        it->time_ -= evt.timeSinceLastFrame;
-
-                        if (it->time_ <= 0)
-                        {
-                            // It's time to call the function
-                            if (it->bLoop_)
-                                it->time_ += it->interval_; // Q: Why '+=' and not '='? A: Think about it. It's more accurate like that. Seriously.
-                            else
-                                it->stopTimer(); // Stop the timer if we don't want to loop
-
-                            (it++)->run();
-                        }
-                        else
-                            ++it;
-                    }
-                    else
-                        ++it;
-                }
-
-                return FrameListener::frameStarted(evt);
-            }
-    };
 }
 

code/branches/network/src/util/Math.h

@@ -147 +147 @@
 
 #endif /* _Math_H__ */
+

code/branches/network/src/util/MultiTypeMath.h

@@ -153 +153 @@
 };
 
-std::ostream& operator<<(std::ostream& out, MultiTypeMath& mtm);
+_UtilExport std::ostream& operator<<(std::ostream& out, MultiTypeMath& mtm);
 
 #endif /* _MultiTypeMath_H__ */

code/branches/network/src/util/MultiTypePrimitive.h

@@ -175 +175 @@
 };
 
-std::ostream& operator<<(std::ostream& out, const MultiTypePrimitive& mtp);
+_UtilExport std::ostream& operator<<(std::ostream& out, const MultiTypePrimitive& mtp);
 
 #endif /* _MultiTypePrimitive_H__ */

code/branches/network/src/util/MultiTypeString.h

@@ -109 +109 @@
 };
 
-std::ostream& operator<<(std::ostream& out, MultiTypeString& mts);
+_UtilExport std::ostream& operator<<(std::ostream& out, MultiTypeString& mts);
 
 #endif /* _MultiTypeString_H__ */

code/branches/network/src/util/Sleep.h

@@ -1 @@
-// hack for the usleep/Sleep problem
-#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__)
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Reto Grieder
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+ @file  Sleep.h
+ @brief Macros for using sleep() and usleep() under windows
+ */
+
+#include "OrxonoxPlatform.h"
+
+#if ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32
 #  include <windows.h>
-#  define usleep(x) Sleep((x)/1000)
+#  define usleep(x) Sleep((x) / 1000)
+#  define msleep(x) Sleep(x)
+#  define  sleep(x) Sleep((x) * 1000)
 #else
 #  include <unistd.h>
+#  define msleep(x) uleep((x) * 1000)
 #endif

code/branches/network/src/util/XMLIncludes.h

@@ -1 @@
-#include "util/tinyxml/TinyXMLPrereqs.h"
+//-----------------------------------------------------------------------
+// Forward declarations
+//-----------------------------------------------------------------------
+
+class TiXmlString;
+class TiXmlOutStream;
+class TiXmlNode;
+class TiXmlHandle;
+class TiXmlDocument;
+class TiXmlElement;
+class TiXmlComment;
+class TiXmlUnknown;
+class TiXmlAttribute;
+class TiXmlText;
+class TiXmlDeclaration;
+class TiXmlParsingData;
+
+namespace ticpp
+{
+    class Document;
+    class Element;
+    class Declaration;
+    class StylesheetReference;
+    class Text;
+    class Comment;
+    class Attribute;
+}
 
 namespace orxonox