Changeset 2171

code/trunk

Property svn:mergeinfo changed
/code/branches/objecthierarchy merged: 2111-2115,2123,2132-2134,2143-2144,2153-2158,2160-2169

code/trunk/TODO

r2087	r2171
1	1	todo:
	2
	3	test network functionality with paketloss/delay: http://www.linuxfoundation.org/en/Net:Netem#Packet_loss
2	4
3	5	bidirectional

code/trunk/bin/run-script

r1735	r2171
8	8	fi
9	9
10		if [[ ~~-ne org~~e.cfg ]] ; then
	10	if [[ ! -f ogre.cfg ]] ; then
11	11	cp ogre.cfg-init ogre.cfg
12	12	fi

code/trunk/src/audio/AudioBuffer.cc

r2103	r2171
29	29	#include "AudioBuffer.h"
30	30
31		namespace ~~audio~~
	31	namespace orxonox
32	32	{
33	33	AudioBuffer::AudioBuffer(std::string filename)

code/trunk/src/audio/AudioBuffer.h

r2103	r2171
35	35	#include <AL/al.h>
36	36
37		namespace ~~audio~~
	37	namespace orxonox
38	38	{
39	39	class _AudioExport AudioBuffer

code/trunk/src/audio/AudioManager.cc

r1784	r2171
37	37	#include "AudioStream.h"
38	38
39		namespace ~~audio~~
	39	namespace orxonox
40	40	{
41	41	AudioManager::AudioManager()

code/trunk/src/audio/AudioManager.h

r1784	r2171
35	35	#include <string>
36	36
37		namespace ~~audio~~
	37	namespace orxonox
38	38	{
39	39	class _AudioExport AudioManager

code/trunk/src/audio/AudioPrereqs.h

r1505	r2171
60	60	// Forward declarations
61	61	//-----------------------------------------------------------------------
62		namespace ~~audio~~
	62	namespace orxonox
63	63	{
64	64	class AudioBuffer;

code/trunk/src/audio/AudioSource.cc

r1784	r2171
29	29	#include "AudioSource.h"
30	30
31		namespace ~~audio~~
	31	namespace orxonox
32	32	{
33	33	AudioSource::AudioSource()

code/trunk/src/audio/AudioSource.h

r1784	r2171
32	32	#include "AudioPrereqs.h"
33	33
34		namespace ~~audio~~
	34	namespace orxonox
35	35	{
36	36	class _AudioExport AudioSource

code/trunk/src/audio/AudioStream.cc

r1784	r2171
30	30	#include "util/Debug.h"
31	31
32		namespace ~~audio~~
	32	namespace orxonox
33	33	{
34	34	AudioStream::AudioStream(std::string path)

code/trunk/src/audio/AudioStream.h

r1784	r2171
39	39
40	40
41		namespace ~~audio~~
	41	namespace orxonox
42	42	{
43	43	const int BUFFER_SIZE = 4096 * 4;

code/trunk/src/core/BaseObject.cc

r2087	r2171
41	41	#include "Template.h"
42	42	#include "util/String.h"
	43	#include "util/mbool.h"
43	44
44	45	namespace orxonox

code/trunk/src/core/BaseObject.h

-                      r2087
+                      r2171
 /**
     @file BaseObject.h
+    @file
     @brief Definition of the BaseObject class.
 …
 #include "XMLIncludes.h"
 #include "Event.h"
+#include "util/mbool.h"
 namespace orxonox
 …
             /** @brief Sets the state of the objects activity. @param bActive True = active */
+            inline void setActive(bool bActive) { this->bActive_ = bActive; this->changedActivity(); }
+            inline void setActive(bool bActive)
+            {
+                if (this->bActive_ != bActive)
+                {
+                    this->bActive_ = bActive;
+                    this->changedActivity();
+                }
+            }
             /** @brief Returns the state of the objects activity. @return The state of the activity */
             inline bool isActive() const { return this->bActive_; }
+            inline const mbool& isActive() const { return this->bActive_; }
             /** @brief This function gets called if the activity of the object changes. */
             virtual void changedActivity() {}
             /** @brief Sets the state of the objects visibility. @param bVisible True = visible */
+            inline void setVisible(bool bVisible) { this->bVisible_ = bVisible; this->changedVisibility(); }
+            inline void setVisible(bool bVisible)
+            {
+                if (this->bVisible_ != bVisible)
+                {
+                    this->bVisible_ = bVisible;
+                    this->changedVisibility();
+                }
+            }
             /** @brief Returns the state of the objects visibility. @return The state of the visibility */
             inline bool isVisible() const { return this->bVisible_; }
+            inline const mbool& isVisible() const { return this->bVisible_; }
             /** @brief This function gets called if the visibility of the object changes. */
             virtual void changedVisibility() {}
 …
             std::string name_;                          //!< The name of the object
             std::string oldName_;                       //!< The old name of the object
             bool bActive_;                              //!< True = the object is active
             bool bVisible_;                             //!< True = the object is visible
+            mbool bActive_;                             //!< True = the object is active
+            mbool bVisible_;                            //!< True = the object is visible
         private:

code/trunk/src/core/ClassFactory.h

r2087	r2171
28	28
29	29	/**
30		@file ~~ClassFactory.h~~
	30	@file
31	31	@brief Definition and implementation of the ClassFactory class
32	32

code/trunk/src/core/ClassTreeMask.cc

r1757	r2171
28	28
29	29	/**
30		@file ~~ClassTreeMask.cc~~
	30	@file
31	31	@brief Implementation of the ClassTreeMask, ClassTreeMaskNode and ClassTreeMaskIterator classes.
32	32	*/

code/trunk/src/core/ClassTreeMask.h

r1759	r2171
28	28
29	29	/**
30		@file ~~ClassTreeMask.h~~
	30	@file
31	31	@brief Definition of the ClassTreeMask, ClassTreeMaskNode and ClassTreeMaskIterator classes.
32	32

code/trunk/src/core/Clock.h

r1755	r2171
28	28
29	29	/**
30		@file ~~Core.h~~
	30	@file
31	31	@brief Declaration of the Core class.
32	32

code/trunk/src/core/ConfigValueContainer.cc

r1887	r2171
28	28
29	29	/**
30		@file ~~ConfigValueContainer.cc~~
	30	@file
31	31	@brief Implementation of the ConfigValueContainer class.
32	32	*/

code/trunk/src/core/ConfigValueContainer.h

r2087	r2171
28	28
29	29	/**
30		@file ~~ConfigValueContainer.h~~
	30	@file
31	31	@brief Definition of the ConfigValueContainer class.
32	32

code/trunk/src/core/ConfigValueIncludes.h

r2103	r2171
28	28
29	29	/**
30		@file ~~ConfigValueIncludes.h~~
	30	@file
31	31	@brief Definition of macros for config-values.
32	32	*/

code/trunk/src/core/Core.cc

r2087	r2171
28	28
29	29	/**
30		@file ~~Core.cc~~
	30	@file
31	31	@brief Implementation of the Core class.
32	32	*/

code/trunk/src/core/Core.h

r2087	r2171
28	28
29	29	/**
30		@file ~~Core.h~~
	30	@file
31	31	@brief Declaration of the Core class.
32	32

code/trunk/src/core/CoreIncludes.h

r2103	r2171
28	28
29	29	/**
30		@file ~~CoreIncludes.h~~
	30	@file
31	31	@brief Definition of macros for Identifier and Factory.
32	32

code/trunk/src/core/Factory.cc

r2087	r2171
28	28
29	29	/**
30		@file ~~Factory.cc~~
	30	@file
31	31	@brief Implementation of the Factory class.
32	32	*/

code/trunk/src/core/Factory.h

r2087	r2171
28	28
29	29	/**
30		@file ~~Factory.h~~
	30	@file
31	31	@brief Definition of the Factory and the BaseFactory class.
32	32

code/trunk/src/core/Identifier.cc

r2087	r2171
28	28
29	29	/**
30		@file ~~Identifier.cc~~
	30	@file
31	31	@brief Implementation of the Identifier class.
32	32	*/

code/trunk/src/core/Identifier.h

r2103	r2171
28	28
29	29	/**
30		@file ~~Identifier.h~~
	30	@file
31	31	@brief Definition of the Identifier, ClassIdentifier and SubclassIdentifier classes, implementation of the ClassIdentifier and SubclassIdentifier classes.
32	32

code/trunk/src/core/Iterator.h

r1854	r2171
28	28
29	29	/**
30		@file ~~Iterator.h~~
	30	@file
31	31	@brief Definition and implementation of the Iterator class.
32	32

code/trunk/src/core/Language.cc

r2103	r2171
28	28
29	29	/**
30		@file ~~Language.cc~~
	30	@file
31	31	@brief Implementation of the Language and the LanguageEntry classes.
32	32	*/

code/trunk/src/core/Language.h

r2103	r2171
28	28
29	29	/**
30		@file ~~Language.h~~
	30	@file
31	31	@brief Definition of the Language and the LanguageEntry class.
32	32

code/trunk/src/core/Loader.cc

-                      r2087
+                      r2171
 #include "Namespace.h"
 #include "util/Debug.h"
+#include "util/Exception.h"
 #include "tinyxml/ticpp.h"
 …
             return true;
+        }
+        catch(ticpp::Exception& ex)
+        catch (ticpp::Exception& ex)
+        {
+            COUT(1) << std::endl;
+            COUT(1) << "An XML-error occurred in Loader.cc while loading " << file->getFilename() << ":" << std::endl;
+            COUT(1) << ex.what() << std::endl;
+            COUT(1) << "Loading aborted." << std::endl;
+            return false;
+        }
+        catch (Exception& ex)
+        {
+            COUT(1) << std::endl;
+            COUT(1) << "A loading-error occurred in Loader.cc while loading " << file->getFilename() << ":" << std::endl;
+            COUT(1) << ex.what() << std::endl;
+            COUT(1) << "Loading aborted." << std::endl;
+            return false;
+        }
+        catch (std::exception& ex)
+        {
             COUT(1) << std::endl;
             COUT(1) << "An error occurred in Loader.cc while loading " << file->getFilename() << ":" << std::endl;
             COUT(1) << ex.what() << std::endl;
+            COUT(1) << "Loading aborted." << std::endl;
+            return false;
+        }
+        catch (...)
+        {
+            COUT(1) << std::endl;
+            COUT(1) << "An unknown error occurred in Loader.cc while loading " << file->getFilename() << ":" << std::endl;
             COUT(1) << "Loading aborted." << std::endl;
             return false;

code/trunk/src/core/MetaObjectList.cc

r1747	r2171
28	28
29	29	/**
30		@file ~~MetaObjectList.cc~~
	30	@file
31	31	@brief Implementation of the MetaObjectList class.
32	32	*/

code/trunk/src/core/MetaObjectList.h

r1747	r2171
28	28
29	29	/**
30		@file ~~MetaObjectList.h~~
	30	@file
31	31	@brief Definition of the MetaObjectList class.
32	32

code/trunk/src/core/ObjectList.h

r1747	r2171
28	28
29	29	/**
30		@file ~~ObjectList.h~~
	30	@file
31	31	@brief Definition and implementation of the ObjectList class.
32	32

code/trunk/src/core/ObjectListBase.cc

r1747	r2171
28	28
29	29	/**
30		@file ~~ObjectListBase.cc~~
	30	@file
31	31	@brief Implementation of the ObjectListBase class.
32	32

code/trunk/src/core/ObjectListBase.h

r1854	r2171
28	28
29	29	/**
30		@file ~~ObjectListBase.h~~
	30	@file
31	31	@brief Definition of the ObjectListBase class.
32	32

code/trunk/src/core/OrxonoxClass.cc

r1747	r2171
28	28
29	29	/**
30		@file ~~OrxonoxClass.cc~~
	30	@file
31	31	@brief Implementation of the OrxonoxClass Class.
32	32	*/

code/trunk/src/core/OrxonoxClass.h

r1755	r2171
28	28
29	29	/**
30		@file ~~OrxonoxClass.h~~
	30	@file
31	31	@brief Declaration of the OrxonoxClass Class.
32	32

code/trunk/src/core/Super.h

r2087	r2171
28	28
29	29	/**
30		@file ~~Super.h~~
	30	@file
31	31	@brief Definition of all super-function related macros.
32	32

code/trunk/src/core/Template.cc

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/src/core/Template.h

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/src/core/XMLFile.h

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/src/core/XMLIncludes.h

Property svn:mergeinfo changed
/code/branches/objecthierarchy/src/core/XMLIncludes.h merged: 2114

r2103	r2171
28	28
29	29	/**
30		@file ~~XMLIncludes.h~~
	30	@file
31	31	@brief Forward declarations of some XML classes.
32	32	*/

code/trunk/src/core/XMLPort.h

-                      r2087
+                      r2171
 /**
     @file XMLPort.h
+    @file
     @brief Declaration of the XMLPort helper classes and macros.
 …
 #include "util/Debug.h"
+#include "util/Exception.h"
 #include "util/MultiType.h"
 #include "tinyxml/ticpp.h"
 …
                                             if (this->identifierIsIncludedInLoaderMask(identifier))
+                                            {
+                                                COUT(4) << ((BaseObject*)object)->getLoaderIndentation() << "fabricating " << child->Value() << "..." << std::endl;
+                                                BaseObject* newObject = identifier->fabricate((BaseObject*)object);
+                                                assert(newObject);
+                                                newObject->setLoaderIndentation(((BaseObject*)object)->getLoaderIndentation() + "  ");
+                                                O* castedObject = dynamic_cast<O*>(newObject);
+                                                assert(castedObject);
+                                                if (this->bLoadBefore_)
+                                                try
+                                                {
+                                                    newObject->XMLPort(*child, XMLPort::LoadObject);
+                                                    COUT(4) << ((BaseObject*)object)->getLoaderIndentation() << "assigning " << child->Value() << " (objectname " << newObject->getName() << ") to " << this->identifier_->getName() << " (objectname " << ((BaseObject*)object)->getName() << ")" << std::endl;
+                                                    COUT(4) << ((BaseObject*)object)->getLoaderIndentation() << "fabricating " << child->Value() << "..." << std::endl;
+                                                    BaseObject* newObject = identifier->fabricate((BaseObject*)object);
+                                                    assert(newObject);
+                                                    newObject->setLoaderIndentation(((BaseObject*)object)->getLoaderIndentation() + "  ");
+                                                    O* castedObject = dynamic_cast<O*>(newObject);
+                                                    assert(castedObject);
+                                                    if (this->bLoadBefore_)
+                                                    {
+                                                        newObject->XMLPort(*child, XMLPort::LoadObject);
+                                                        COUT(4) << ((BaseObject*)object)->getLoaderIndentation() << "assigning " << child->Value() << " (objectname " << newObject->getName() << ") to " << this->identifier_->getName() << " (objectname " << ((BaseObject*)object)->getName() << ")" << std::endl;
+                                                    }
+                                                    else
+                                                    {
+                                                        COUT(4) << ((BaseObject*)object)->getLoaderIndentation() << "assigning " << child->Value() << " (object not yet loaded) to " << this->identifier_->getName() << " (objectname " << ((BaseObject*)object)->getName() << ")" << std::endl;
+                                                    }
+                                                    COUT(5) << ((BaseObject*)object)->getLoaderIndentation();
+                                                    (*this->loadexecutor_)(object, castedObject);
+                                                    if (!this->bLoadBefore_)
+                                                        newObject->XMLPort(*child, XMLPort::LoadObject);
+                                                    COUT(5) << ((BaseObject*)object)->getLoaderIndentation() << "...fabricated " << child->Value() << " (objectname " << newObject->getName() << ")." << std::endl;
+                                                }
                                                 else
+                                                catch (AbortLoadingException& ex)
+                                                {
+                                                    COUT(4) << ((BaseObject*)object)->getLoaderIndentation() << "assigning " << child->Value() << " (object not yet loaded) to " << this->identifier_->getName() << " (objectname " << ((BaseObject*)object)->getName() << ")" << std::endl;
+                                                    COUT(1) << "An error occurred while loading object, abort loading..." << std::endl;
+                                                    throw ex;
+                                                }
+                                                COUT(5) << ((BaseObject*)object)->getLoaderIndentation();
+                                                (*this->loadexecutor_)(object, castedObject);
+                                                if (!this->bLoadBefore_)
+                                                    newObject->XMLPort(*child, XMLPort::LoadObject);
+                                                COUT(5) << ((BaseObject*)object)->getLoaderIndentation() << "...fabricated " << child->Value() << " (objectname " << newObject->getName() << ")." << std::endl;
+                                                catch (std::exception& ex)
+                                                {
+                                                    COUT(1) << "An error occurred while loading object:" << std::endl;
+                                                    COUT(1) << ex.what() << std::endl;
+                                                }
+                                                catch (...)
+                                                {
+                                                    COUT(1) << "An unknown error occurred while loading object." << std::endl;
+                                                }
+                                            }
+                                        }

code/trunk/src/network/ChatListener.cc

r2087	r2171
32	32	#include "core/Core.h"
33	33
34		namespace ~~network~~
	34	namespace orxonox
35	35	{
36	36	ChatListener::ChatListener()

code/trunk/src/network/ChatListener.h

r2087	r2171
35	35	#include "core/OrxonoxClass.h"
36	36
37		namespace ~~network~~
	37	namespace orxonox
38	38	{
39		class _NetworkExport ChatListener : virtual public ~~orxonox::~~OrxonoxClass
	39	class _NetworkExport ChatListener : virtual public OrxonoxClass
40	40	{
41	41	public:

code/trunk/src/network/Client.cc

r2087	r2171
49	49	// #include "packet/Acknowledgement.h"
50	50
51		namespace ~~network~~
	51	namespace orxonox
52	52	{
53	53	// SetConsoleCommandShortcut(Client, chat);

code/trunk/src/network/Client.h

-                      r2087
+                      r2171
 namespace network
+namespace orxonox
+{
   /**
   network::Client *client;
+  Client *client;
   * The network/Client class
   * This class implements all necessary function for the network communication

code/trunk/src/network/ClientConnection.cc

r2087	r2171
48	48	#include "util/Debug.h"
49	49
50		namespace ~~network~~
	50	namespace orxonox
51	51	{
52	52	//static boost::thread_group network_threads;

code/trunk/src/network/ClientConnection.h

r2087	r2171
50	50	namespace boost { class thread; }
51	51
52		namespace ~~network~~
	52	namespace orxonox
53	53	{
54	54

code/trunk/src/network/ClientConnectionListener.cc

-                      r2087
+                      r2171
 #include "core/Core.h"
 namespace network{
+namespace orxonox{
   ClientConnectionListener::ClientConnectionListener()
 …
   void ClientConnectionListener::getConnectedClients(){
     if(orxonox::Core::showsGraphics())
+    if(Core::showsGraphics())
       this->clientConnected(0); //server client id
     ClientInformation *client = ClientInformation::getBegin();

code/trunk/src/network/ClientConnectionListener.h

-                      r2087
+                      r2171
 #include "core/OrxonoxClass.h"
 namespace network{
+namespace orxonox{
   class _NetworkExport ClientConnectionListener : virtual public orxonox::OrxonoxClass
+  class _NetworkExport ClientConnectionListener : virtual public OrxonoxClass
+  {
     friend class Server;

code/trunk/src/network/ClientInformation.cc

r2087	r2171
43	43	#include <iostream> //debug
44	44
45		namespace ~~network~~
	45	namespace orxonox
46	46	{
47	47

code/trunk/src/network/ClientInformation.h

r2087	r2171
48	48	// WATCH OUT: THE CLIENTINFORMATION LIST IS NOT THREADSAFE ANYMORE
49	49
50		namespace ~~network~~
	50	namespace orxonox
51	51	{
52	52	static const unsigned int GAMESTATEID_INITIAL = (unsigned int)-1;

code/trunk/src/network/ConnectionManager.cc

-                      r2087
+                      r2171
+}
 namespace network
+namespace orxonox
+{
   //boost::thread_group network_threads;
 …
   bool ConnectionManager::addPacket(ENetPacket *packet, ENetPeer *peer) {
     boost::recursive_mutex::scoped_lock lock(instance_->enet_mutex);
+    boost::recursive_mutex::scoped_lock lock(ConnectionManager::enet_mutex);
     if(enet_peer_send(peer, NETWORK_DEFAULT_CHANNEL, packet)!=0)
       return false;
 …
     if(!instance_)
       return false;
     boost::recursive_mutex::scoped_lock lock(instance_->enet_mutex);
+    boost::recursive_mutex::scoped_lock lock(ConnectionManager::enet_mutex);
     for(ClientInformation *i=ClientInformation::getBegin()->next(); i!=0; i=i->next()){
       COUT(3) << "adding broadcast packet for client: " << i->getID() << std::endl;
 …
     if(server==NULL || !instance_)
       return false;
     boost::recursive_mutex::scoped_lock lock(enet_mutex);
+    boost::recursive_mutex::scoped_lock lock(ConnectionManager::enet_mutex);
     enet_host_flush(server);
     lock.unlock();
 …
     atexit(enet_deinitialize);
     { //scope of the mutex
       boost::recursive_mutex::scoped_lock lock(enet_mutex);
+      boost::recursive_mutex::scoped_lock lock(ConnectionManager::enet_mutex);
       enet_initialize();
       server = enet_host_create(&bindAddress, NETWORK_MAX_CONNECTIONS, 0, 0);
 …
     while(!quit){
       { //mutex scope
         boost::recursive_mutex::scoped_lock lock(enet_mutex);
+        boost::recursive_mutex::scoped_lock lock(ConnectionManager::enet_mutex);
         if(enet_host_service(server, event, NETWORK_WAIT_TIMEOUT)<0){
           // we should never reach this point
 …
     // if we're finishied, destroy server
+    {
       boost::recursive_mutex::scoped_lock lock(enet_mutex);
+      boost::recursive_mutex::scoped_lock lock(ConnectionManager::enet_mutex);
       enet_host_destroy(server);
       lock.unlock();
 …
     while(temp!=0){
+      {
         boost::recursive_mutex::scoped_lock lock(enet_mutex);
+        boost::recursive_mutex::scoped_lock lock(ConnectionManager::enet_mutex);
         enet_peer_disconnect(temp->getPeer(), 0);
         lock.unlock();
 …
     //bugfix: might be the reason why server crashes when clients disconnects
     temp = ClientInformation::getBegin()->next();
     boost::recursive_mutex::scoped_lock lock(enet_mutex);
+    boost::recursive_mutex::scoped_lock lock(ConnectionManager::enet_mutex);
     while( temp!=0 && enet_host_service(server, &event, NETWORK_WAIT_TIMEOUT) >= 0){
       switch (event.type)
 …
     unsigned int network_id=0, failures=0;
     std::string classname;
     orxonox::Identifier *id;
     std::map<std::string, orxonox::Identifier*>::const_iterator it = orxonox::Factory::getFactoryMapBegin();
     while(it != orxonox::Factory::getFactoryMapEnd()){
+    Identifier *id;
+    std::map<std::string, Identifier*>::const_iterator it = Factory::getFactoryMapBegin();
+    while(it != Factory::getFactoryMapEnd()){
       id = (*it).second;
       if(id == NULL)
 …
   void ConnectionManager::disconnectClient(ClientInformation *client){
+    {
       boost::recursive_mutex::scoped_lock lock(enet_mutex);
+      boost::recursive_mutex::scoped_lock lock(ConnectionManager::enet_mutex);
       enet_peer_disconnect(client->getPeer(), 0);
       lock.unlock();

code/trunk/src/network/ConnectionManager.h

r2087	r2171
59	59	}
60	60
61		namespace ~~network~~
	61	namespace orxonox
62	62	{
63	63	const int NETWORK_PORT = 55556;

code/trunk/src/network/GamestateClient.cc

-                      r2087
+                      r2171
 namespace network
+namespace orxonox
+{
   struct _NetworkExport GameStateItem{
 …
   * @return iterator pointing to the next object in the list
   */
   void GamestateClient::removeObject(orxonox::ObjectList<Synchronisable>::iterator &it) {
     orxonox::ObjectList<Synchronisable>::iterator temp=it;
+  void GamestateClient::removeObject(ObjectList<Synchronisable>::iterator &it) {
+    ObjectList<Synchronisable>::iterator temp=it;
     ++it;
     delete  *temp;

code/trunk/src/network/GamestateClient.h

-                      r2087
+                      r2171
 const unsigned int GAMESTATEID_INITIAL = (unsigned int)-1;
 namespace network
+namespace orxonox
+{
   class _NetworkExport GamestateClient: public GamestateHandler
 …
   private:
     packet::Gamestate *processGamestate(packet::Gamestate *gs);
     void removeObject(orxonox::ObjectListIterator<Synchronisable> &it);
+    void removeObject(ObjectListIterator<Synchronisable> &it);
     void printGamestateMap();
     bool sendAck(unsigned int gamestateID);

code/trunk/src/network/GamestateHandler.cc

-                      r1763
+                      r2171
 #include "packet/Packet.h"
 namespace network {
+namespace orxonox {
 GamestateHandler *GamestateHandler::instance_=0;
 …
 }//namespace network
+}//namespace orxonox

code/trunk/src/network/GamestateHandler.h

r2087	r2171
34	34	#include "packet/Chat.h"
35	35
36		namespace ~~network~~ {
	36	namespace orxonox {
37	37
38	38	/**

code/trunk/src/network/GamestateManager.cc

r2087	r2171
51	51	#include "Synchronisable.h"
52	52
53		namespace ~~network~~
	53	namespace orxonox
54	54	{
55	55	GamestateManager::GamestateManager() {

code/trunk/src/network/GamestateManager.h

r2087	r2171
47	47	#include "packet/Gamestate.h"
48	48
49		namespace ~~network~~
	49	namespace orxonox
50	50	{
51	51

code/trunk/src/network/Host.cc

-                      r2087
+                      r2171
 #include "ChatListener.h"
 namespace network {
+namespace orxonox {
 SetConsoleCommandShortcut(Host, Chat);
 …
 // }
 // bool Host::receiveChat(network::packet::Chat *message, unsigned int clientID){
+// bool Host::receiveChat(packet::Chat *message, unsigned int clientID){
 //   if(instance_)
 //     return instance_->processChat(message, clientID);
 …
 bool Host::incomingChat(const std::string& message, unsigned int playerID){
   for (orxonox::ObjectList<ChatListener>::iterator it = orxonox::ObjectList<ChatListener>::begin(); it != orxonox::ObjectList<ChatListener>::end(); ++it)
+  for (ObjectList<ChatListener>::iterator it = ObjectList<ChatListener>::begin(); it != ObjectList<ChatListener>::end(); ++it)
     it->incomingChat(message, playerID);
 …
+}
 }//namespace network
+}//namespace orxonox

code/trunk/src/network/Host.h

r2087	r2171
34	34	#include "packet/Chat.h"
35	35
36		namespace ~~network~~ {
	36	namespace orxonox {
37	37
38	38	/**

code/trunk/src/network/NetworkCallback.h

r2087	r2171
4	4	#include "NetworkPrereqs.h"
5	5
6		namespace ~~network~~{
	6	namespace orxonox{
7	7	class _NetworkExport NetworkCallbackBase
8	8	{

code/trunk/src/network/NetworkPrereqs.h

r2087	r2171
59	59	// Forward declarations
60	60	//-----------------------------------------------------------------------
61		namespace ~~network~~
	61	namespace orxonox
62	62	{
63	63	class Client;

code/trunk/src/network/PacketBuffer.cc

-                      r1505
+                      r2171
 #include <boost/thread/mutex.hpp>
 namespace network
+namespace orxonox
+{
    boost::recursive_mutex PacketBuffer::mutex_;
 …
+  }
 } // namespace network
+} // namespace orxonox

code/trunk/src/network/PacketBuffer.h

r2087	r2171
47	47	#include <boost/thread/recursive_mutex.hpp>
48	48
49		namespace ~~network~~
	49	namespace orxonox
50	50	{
51	51	struct _NetworkExport PacketEnvelope{

code/trunk/src/network/Server.cc

-                      r2087
+                      r2171
 #include "ChatListener.h"
 namespace network
+namespace orxonox
+{
   const unsigned int MAX_FAILURES = 20;
 …
     // inform all the listeners
     orxonox::ObjectList<ClientConnectionListener>::iterator listener = orxonox::ObjectList<ClientConnectionListener>::begin();
+    ObjectList<ClientConnectionListener>::iterator listener = ObjectList<ClientConnectionListener>::begin();
     while(listener){
       listener->clientConnected(newid);
 …
 // inform all the listeners
     orxonox::ObjectList<ClientConnectionListener>::iterator listener = orxonox::ObjectList<ClientConnectionListener>::begin();
+    ObjectList<ClientConnectionListener>::iterator listener = ObjectList<ClientConnectionListener>::begin();
     while(listener){
       listener->clientDisconnected(client->getID());
 …
+    }
 //    COUT(1) << "Player " << Host::getPlayerID() << ": " << message << std::endl;
     for (orxonox::ObjectList<ChatListener>::iterator it = orxonox::ObjectList<ChatListener>::begin(); it != orxonox::ObjectList<ChatListener>::end(); ++it)
+    for (ObjectList<ChatListener>::iterator it = ObjectList<ChatListener>::begin(); it != ObjectList<ChatListener>::end(); ++it)
       it->incomingChat(message, clientID);

code/trunk/src/network/Server.h

r2087	r2171
49	49	#include "GamestateManager.h"
50	50
51		namespace ~~network~~
	51	namespace orxonox
52	52	{
53	53	const int CLIENTID_SERVER = 0;

code/trunk/src/network/Synchronisable.cc

-                      r2087
+                      r2171
 // #include "core/Identifier.h"
+namespace network
+#include "Host.h"
+namespace orxonox
+{
 …
   std::queue<unsigned int> Synchronisable::deletedObjects_;
   int Synchronisable::state_=0x1; // detemines wheter we are server (default) or client
+  uint8_t Synchronisable::state_=0x1; // detemines wheter we are server (default) or client
   /**
 …
   * Initializes all Variables and sets the right objectID
   */
   Synchronisable::Synchronisable(orxonox::BaseObject* creator){
+  Synchronisable::Synchronisable(BaseObject* creator){
     RegisterRootObject(Synchronisable);
     static uint32_t idCounter=0;
     objectFrequency_=1;
     objectMode_=0x1; // by default do not send data to server
+    objectID=idCounter++;
+    if ( !Host::running() || ( Host::running() && Host::isServer() ) )
+    {
+      this->objectID = idCounter++; //this is only needed when running a server
+    //add synchronisable to the objectMap
+      objectMap_[this->objectID] = this;
+    }
+    else
+      objectID=OBJECTID_UNKNOWN;
     classID = (unsigned int)-1;
     syncList = new std::list<synchronisableVariable *>;
+#ifndef NDEBUG
+    ObjectList<Synchronisable>::iterator it;
+    for(it = ObjectList<Synchronisable>::begin(); it!=ObjectList<Synchronisable>::end(); ++it){
+      if( it->getObjectID()==this->objectID )
+        assert(*it==this || (it->objectID==OBJECTID_UNKNOWN && it->objectMode_==0x0));
+    }
+#endif
     this->creatorID = OBJECTID_UNKNOWN;
 …
   Synchronisable::~Synchronisable(){
     // delete callback function objects
     if(!orxonox::Identifier::isCreatingHierarchy()){
+    if(!Identifier::isCreatingHierarchy()){
       for(std::list<synchronisableVariable *>::iterator it = syncList->begin(); it!=syncList->end(); it++)
         delete (*it)->callback;
       if (this->objectMode_ != 0x0)
+      if (this->objectMode_ != 0x0 && (Host::running() && Host::isServer()))
         deletedObjects_.push(objectID);
 //       COUT(3) << "destruct synchronisable +++" << objectID << " | " << classID << std::endl;
 …
 //       objectMap_.erase(objectID);
+    }
+    std::map<unsigned int, Synchronisable*>::iterator it;
+    it = objectMap_.find(objectID);
+    if (it != objectMap_.end())
+      objectMap_.erase(it);
+  }
 …
    * @return pointer to the newly created synchronisable
    */
   Synchronisable *Synchronisable::fabricate(uint8_t*& mem, int mode)
+  Synchronisable *Synchronisable::fabricate(uint8_t*& mem, uint8_t mode)
+  {
     synchronisableHeader *header = (synchronisableHeader *)mem;
 …
       return 0;
+    }
     COUT(4) << "fabricating object with id: " << header->objectID << std::endl;
     orxonox::Identifier* id = ClassByID(header->classID);
+    Identifier* id = ClassByID(header->classID);
     assert(id);
     orxonox::BaseObject* creator = 0;
+    BaseObject* creator = 0;
     if (header->creatorID != OBJECTID_UNKNOWN)
+    {
 …
+      }
       else
+        creator = dynamic_cast<orxonox::BaseObject*>(synchronisable_creator);
+    }
+    orxonox::BaseObject *bo = id->fabricate(creator);
+        creator = dynamic_cast<BaseObject*>(synchronisable_creator);
+    }
+    assert(getSynchronisable(header->objectID)==0);   //make sure no object with this id exists
+    BaseObject *bo = id->fabricate(creator);
     assert(bo);
     Synchronisable *no = dynamic_cast<Synchronisable *>(bo);
 …
    */
   Synchronisable* Synchronisable::getSynchronisable(unsigned int objectID){
+    orxonox::ObjectList<Synchronisable>::iterator it;
+    for(it = orxonox::ObjectList<Synchronisable>::begin(); it; ++it){
+      if( it->getObjectID()==objectID )
+           return *it;
+    std::map<unsigned int, Synchronisable*>::iterator it1;
+    it1 = objectMap_.find(objectID);
+    if (it1 != objectMap_.end())
+      return it1->second;
+    ObjectList<Synchronisable>::iterator it;
+    for(it = ObjectList<Synchronisable>::begin(); it; ++it){
+      if( it->getObjectID()==objectID ){
+        objectMap_[objectID] = *it;
+        return *it;
+      }
+    }
     return NULL;
-//     std::map<unsigned int, Synchronisable *>::iterator i = objectMap_.find(objectID);
-//     if(i==objectMap_.end())
-//       return NULL;
-//     assert(i->second->objectID==objectID);
-//     return (*i).second;
+  }
 …
   * @param var pointer to the variable
   * @param size size of the datatype the variable consists of
   * @param t the type of the variable (network::DATA or network::STRING
+  * @param t the type of the variable (DATA or STRING
   * @param mode same as in getData
   * @param cb callback object that should get called, if the value of the variable changes
   */
   void Synchronisable::registerVar(void *var, int size, variableType t, int mode, NetworkCallbackBase *cb){
+  void Synchronisable::registerVariable(void *var, int size, variableType t, uint8_t mode, NetworkCallbackBase *cb){
     assert( mode==direction::toclient || mode==direction::toserver || mode==direction::serverMaster || mode==direction::clientMaster);
     // create temporary synch.Var struct
 …
     if( ( mode & direction::bidirectional ) )
+    {
+      temp->varBuffer = new uint8_t[size];
+      memcpy(temp->varBuffer, temp->var, size); //now fill the buffer for the first time
+      if(t!=STRING)
+      {
+        temp->varBuffer = new uint8_t[size];
+        memcpy(temp->varBuffer, temp->var, size); //now fill the buffer for the first time
+      }
+      else
+      {
+        temp->varBuffer=new std::string( *static_cast<std::string*>(var) );
+      }
       temp->varReference = 0;
+    }
 …
 #endif
+  }
+  void Synchronisable::unregisterVariable(void *var){
+    std::list<synchronisableVariable *>::iterator it = syncList->begin();
+    while(it!=syncList->end()){
+      if( (*it)->var == var ){
+        delete *it;
+        syncList->erase(it);
+        return;
+      }
+      else
+        it++;
+    }
+    bool unregistered_nonexistent_variable = false;
+    assert(unregistered_nonexistent_variable); //if we reach this point something went wrong:
+    // the variable has not been registered before
+  }
   /**
 …
    * @return true: if !doSync or if everything was successfully saved
    */
+  bool Synchronisable::getData(uint8_t*& mem, unsigned int id, int mode){
+  bool Synchronisable::getData(uint8_t*& mem, unsigned int id, uint8_t mode){
+    if(mode==0x0)
+      mode=state_;
     //if this tick is we dont synchronise, then abort now
     if(!doSync(id))
+    if(!doSync(id, mode))
       return true;
     //std::cout << "inside getData" << std::endl;
     unsigned int tempsize = 0;
-    if(mode==0x0)
-      mode=state_;
     if(classID==0)
       COUT(3) << "classid 0 " << this->getIdentifier()->getName() << std::endl;
 …
     header->classID = this->classID;
     header->dataAvailable = true;
     tempsize+=sizeof(synchronisableHeader);
     mem+=sizeof(synchronisableHeader);
+    tempsize += sizeof(synchronisableHeader);
+    mem += sizeof(synchronisableHeader);
     // end copy header
 …
         continue;  // this variable should only be received
+      }
+      // =========== start bidirectional stuff =============
       // if the variable gets synchronised bidirectional, then add the reference to the bytestream
       if( ( (*i)->mode & direction::bidirectional ) == direction::bidirectional )
+      {
+        if( ( ((*i)->mode == direction::serverMaster) && (mode == 0x1) ) || \
+            ( ((*i)->mode == direction::clientMaster) && (mode == 0x2) ) )
+        {
+          // MASTER
+          if((*i)->type==DATA){
+            if( memcmp((*i)->var,(*i)->varBuffer,(*i)->size) != 0 ) //check whether the variable changed during the last tick
+            {
+              ((*i)->varReference)++;   //the variable changed so increase the refnr
+              memcpy((*i)->varBuffer, (*i)->var, (*i)->size); //set the buffer to the new value
+            }
+          }
+          else //STRING
+          {
+            if( *static_cast<std::string*>((*i)->var) != *static_cast<std::string*>((*i)->varBuffer) ) //the string changed
+            {
+              ((*i)->varReference)++;   //the variable changed
+              *static_cast<std::string*>((*i)->varBuffer) = *static_cast<std::string*>((*i)->var);  //now set the buffer to the new value
+            }
+          }
+        }
+        // copy the reference number to the stream
         *(uint8_t*)mem = (*i)->varReference;
         mem += sizeof( (*i)->varReference );
         tempsize += sizeof( (*i)->varReference );
+      }
+      // ================== end bidirectional stuff
       switch((*i)->type){
         case DATA:
           memcpy( (void *)(mem), (void*)((*i)->var), (*i)->size);
           mem+=(*i)->size;
           tempsize+=(*i)->size;
+          mem += (*i)->size;
+          tempsize += (*i)->size;
           break;
         case STRING:
           memcpy( (void *)(mem), (void *)&((*i)->size), sizeof(size_t) );
           mem+=sizeof(size_t);
+          mem += sizeof(size_t);
           const char *data = ( ( *(std::string *) (*i)->var).c_str());
           memcpy( mem, (void*)data, (*i)->size);
           COUT(5) << "synchronisable: char: " << (const char *)(mem) << " data: " << data << " string: " << *(std::string *)((*i)->var) << std::endl;
           mem+=(*i)->size;
           tempsize+=(*i)->size + sizeof(size_t);
+          mem += (*i)->size;
+          tempsize += (*i)->size + sizeof(size_t);
           break;
+      }
 …
    * @return true/false
    */
   bool Synchronisable::updateData(uint8_t*& mem, int mode, bool forceCallback){
+  bool Synchronisable::updateData(uint8_t*& mem, uint8_t mode, bool forceCallback){
     if(mode==0x0)
       mode=state_;
     std::list<synchronisableVariable *>::iterator i;
+    //assert(objectMode_!=0x0);
+    //assert( (mode ^ objectMode_) != 0);
     if(syncList->empty()){
       COUT(4) << "Synchronisable::updateData syncList is empty" << std::endl;
 …
     synchronisableHeader *syncHeader = (synchronisableHeader *)mem;
     assert(syncHeader->objectID==this->objectID);
+//    assert(syncHeader->creatorID==this->creatorID);
+    assert(syncHeader->creatorID==this->creatorID);
+    assert(this->classID==syncHeader->classID); //TODO: fix this!!! maybe a problem with the identifier ?
     if(syncHeader->dataAvailable==false){
       mem+=syncHeader->size;
+      mem += syncHeader->size;
       return true;
+    }
     mem+=sizeof(synchronisableHeader);
+    mem += sizeof(synchronisableHeader);
     // stop extract header
-    assert(this->objectID==syncHeader->objectID);
-//    assert(this->classID==syncHeader->classID); //TODO: fix this!!! maybe a problem with the identifier ?
     COUT(5) << "Synchronisable: objectID " << syncHeader->objectID << ", classID " << syncHeader->classID << " size: " << syncHeader->size << " synchronising data" << std::endl;
 …
       if( ((*i)->mode ^ mode) == 0 ){
         COUT(5) << "synchronisable: not updating variable " << std::endl;
+        // if we have a forcecallback then do the callback
         continue;  // this variable should only be set
+      }
       COUT(5) << "Synchronisable: element size: " << (*i)->size << " type: " << (*i)->type << std::endl;
       bool callback=false;
+      bool master=false;
+      if( ( (*i)->mode & direction::bidirectional ) == direction::bidirectional )
+      {
+        uint8_t refNr = *(uint8_t *)mem;
+        if( ( ((*i)->mode == direction::serverMaster) && (mode == 0x1) ) || \
+            ( ((*i)->mode == direction::clientMaster) && (mode == 0x2) ) )
+        { // MASTER
+          master=true;
+          if( refNr != (*i)->varReference || ( memcmp((*i)->var, (*i)->varBuffer, (*i)->size) != 0 ) )
+          { // DISCARD data
+            if( (*i)->type == DATA )
+            {
+              mem += sizeof((*i)->varReference) + (*i)->size;
+            }
+            else //STRING
+            {
+              mem += sizeof(size_t) + *(size_t *)mem;
+            }
+            if( forceCallback && (*i)->callback)
+              (*i)->callback->call();
+            continue;
+          }//otherwise everything is ok and we update the value
+        }
+        else // SLAVE
+        {
+          if( (*i)->varReference == refNr ){
+            //discard data because it's outdated or not different to what we've got
+            if( (*i)->type == DATA )
+            {
+              mem += sizeof((*i)->varReference) + (*i)->size;
+            }
+            else //STRING
+            {
+              mem += sizeof(size_t) + *(size_t *)mem;
+            }
+            if( forceCallback && (*i)->callback)
+              (*i)->callback->call();
+            continue;
+          }
+          else
+            (*i)->varReference = refNr; //copy the reference value for this variable
+        }
+        mem += sizeof((*i)->varReference);
+      }
       switch((*i)->type){
         case DATA:
           if( ( (*i)->mode & direction::bidirectional ) == direction::bidirectional )
+          if((*i)->callback) // check whether this variable changed (but only if callback was set)
+          {
+            if( ( mode == 0x1 && (*i)->mode == direction::serverMaster ) || \
+                  ( mode == 0x2 && (*i)->mode == direction::clientMaster ) )    // if true we are master on this variable
+            {
+              uint8_t refNr = *(uint8_t *)mem;
+              if( refNr != (*i)->varReference )
+              {
+                mem += sizeof((*i)->varReference) + (*i)->size; // the reference for this variable is not recent, discard data
+                break;
+              }
+            }
+            else //we are slave for this variable
+            {
+              (*i)->varReference = *(uint8_t *)mem; //copy the reference value for this variable
+            }
+            mem += sizeof((*i)->varReference);
+            if(memcmp((*i)->var, mem, (*i)->size) != 0)
+              callback=true;
+          }
+          if((*i)->callback) // check whether this variable changed (but only if callback was set)
+            if(strncmp((char *)(*i)->var, (char *)mem, (*i)->size)!=0)
+              callback=true;
+          memcpy((void*)(*i)->var, mem, (*i)->size);
+          mem+=(*i)->size;
+          if( master )
+          {
+            if( callback || memcmp((*i)->var, mem, (*i)->size) != 0 )
+              //value changed, so set the buffer to the new value
+              memcpy((*i)->varBuffer, mem, (*i)->size);
+          }
+          memcpy((*i)->var, mem, (*i)->size);
+          mem += (*i)->size;
           break;
         case STRING:
+          if( ( (*i)->mode & direction::bidirectional ) == direction::bidirectional )
+          (*i)->size = *(size_t *)mem;
+          mem += sizeof(size_t);
+          if( (*i)->callback) // check whether this string changed
+            if( *static_cast<std::string*>((*i)->var) != std::string((char *)mem) )
+              callback=true;
+          if( master )
+          {
+            if( ( mode == 0x1 && (*i)->mode == direction::serverMaster ) || \
+                  ( mode == 0x2 && (*i)->mode == direction::clientMaster ) )    // if true we are master for this variable
+            {
+              uint8_t refNr = *(uint8_t *)mem;
+              mem += sizeof( (*i)->varReference );
+              if( refNr != (*i)->varReference ){
+                mem += sizeof(size_t) + *(size_t *)mem; // the reference for this variable is not recent, discard data
+                break;
+              }
+            }
+            else //we are slave for this variable
+            {
+              (*i)->varReference = *(uint8_t *)mem; //copy the reference value for this variable
+            }
+            mem += sizeof( (*i)->varReference );
+            if( callback || *static_cast<std::string*>((*i)->var) != std::string((char *)mem) )
+              //string changed. set the buffer to the new one
+              *static_cast<std::string*>((*i)->varBuffer)=*static_cast<std::string*>( (void*)(mem+sizeof(size_t)) );
+          }
+          (*i)->size = *(size_t *)mem;
+          COUT(5) << "string size: " << (*i)->size << std::endl;
+          mem += sizeof(size_t);
+          if((*i)->callback) // check whether this string changed
+            if( *(std::string *)((*i)->var) != std::string((char *)mem) )
+              callback=true;
           *((std::string *)((*i)->var)) = std::string((const char*)mem);
           COUT(5) << "synchronisable: char: " << (const char*)mem << " string: " << std::string((const char*)mem) << std::endl;
 …
         (*i)->callback->call();
+    }
+    assert(mem == data+syncHeader->size);
     return true;
+  }
 …
   * @return amount of bytes
   */
+  uint32_t Synchronisable::getSize(unsigned int id, int mode){
+    if(!doSync(id))
+      return 0;
+  uint32_t Synchronisable::getSize(unsigned int id, uint8_t mode){
     int tsize=sizeof(synchronisableHeader);
     if(mode==0x0)
       mode=state_;
+    if(!doSync(id, mode))
+      return 0;
     std::list<synchronisableVariable *>::iterator i;
     for(i=syncList->begin(); i!=syncList->end(); i++){
 …
    * @return true/false
    */
+  bool Synchronisable::doSync(unsigned int id){
+    return ( (objectMode_&state_)!=0 && (!syncList->empty() ) );
+  bool Synchronisable::doSync(unsigned int id, uint8_t mode){
+    if(mode==0x0)
+      mode=state_;
+    return ( (objectMode_&mode)!=0 && (!syncList->empty() ) );
+  }
   bool Synchronisable::doSelection(unsigned int id){
+    return ( id==0 || id%objectFrequency_==objectID%objectFrequency_ ) && ((objectMode_&state_)!=0);
+    return true; //TODO: change this
+    //return ( id==0 || id%objectFrequency_==objectID%objectFrequency_ ) && ((objectMode_&state_)!=0);
+  }
 …
   /**
    * This function sets the synchronisation mode of the object
+   * If set to 0x0 variables will not be synchronised at all
    * If set to 0x1 variables will only be synchronised to the client
    * If set to 0x2 variables will only be synchronised to the server
 …
    * @param mode same as in registerVar
    */
   void Synchronisable::setObjectMode(int mode){
+  void Synchronisable::setObjectMode(uint8_t mode){
     assert(mode==0x0 || mode==0x1 || mode==0x2 || mode==0x3);
     objectMode_=mode;

code/trunk/src/network/Synchronisable.h

-                      r2087
+                      r2171
 #define REGISTERDATA(varname, ...) \
     registerVar((void*)&varname, sizeof(varname), network::DATA, __VA_ARGS__)
+    registerVariable((void*)&varname, sizeof(varname), DATA, __VA_ARGS__)
 #define REGISTERSTRING(stringname, ...) \
     registerVar(&stringname, stringname.length()+1, network::STRING, __VA_ARGS__)
+    registerVariable(&stringname, stringname.length()+1, STRING, __VA_ARGS__)
 namespace network
+namespace orxonox
+{
   static const unsigned int OBJECTID_UNKNOWN = (unsigned int)-1;
 …
   namespace syncmode{
     enum mode{
       one=0,
+      once=0,
       always=1
     };
 …
   struct _NetworkExport synchronisableVariable{
     unsigned int size;
     int mode; // this determines in which direction the variable gets synchronised
+    size_t size;
+    uint8_t mode; // this determines in which direction the variable gets synchronised
     void *var;
     variableType type;
 …
   * @author Oliver Scheuss
   */
   class _NetworkExport Synchronisable : virtual public orxonox::OrxonoxClass{
+  class _NetworkExport Synchronisable : virtual public OrxonoxClass{
   public:
     friend class packet::Gamestate;
+    friend class GamestateClient;
+    friend class Server;
+//     friend class Server;
     virtual ~Synchronisable();
 …
     static void setClient(bool b);
     static Synchronisable *fabricate(uint8_t*& mem, int mode=0x0);
+    static Synchronisable *fabricate(uint8_t*& mem, uint8_t mode=0x0);
     static bool deleteObject(unsigned int objectID);
     static Synchronisable *getSynchronisable(unsigned int objectID);
 …
     inline unsigned int getClassID(){return classID;}
   protected:
+    Synchronisable(orxonox::BaseObject* creator);
+    void registerVar(void *var, int size, variableType t, int mode=1, NetworkCallbackBase *cb=0);
+    void setObjectMode(int mode);
+    Synchronisable(BaseObject* creator);
+    void registerVariable(void *var, int size, variableType t, uint8_t mode=0x1, NetworkCallbackBase *cb=0);
+    void unregisterVariable(void *var);
+    void setObjectMode(uint8_t mode);
     void setObjectFrequency(unsigned int freq){ objectFrequency_ = freq; }
   private:
     bool getData(uint8_t*& men, unsigned int id, int mode=0x0);
     uint32_t getSize(unsigned int id, int mode=0x0);
     bool updateData(uint8_t*& mem, int mode=0x0, bool forceCallback=false);
+    bool getData(uint8_t*& men, unsigned int id, uint8_t mode=0x0);
+    uint32_t getSize(unsigned int id, uint8_t mode=0x0);
+    bool updateData(uint8_t*& mem, uint8_t mode=0x0, bool forceCallback=false);
     bool isMyData(uint8_t* mem);
     bool doSelection(unsigned int id);
     bool doSync(unsigned int id);
+    bool doSync(unsigned int id, uint8_t mode=0x0);
     unsigned int objectID;
 …
     std::list<synchronisableVariable *> *syncList;
     static int state_; // detemines wheter we are server (default) or client
+    static uint8_t state_; // detemines wheter we are server (default) or client
     bool backsync_; // if true the variables with mode > 1 will be synchronised to server (client -> server)
     unsigned int objectFrequency_;

code/trunk/src/network/packet/Acknowledgement.cc

-                      r1907
+                      r2171
 #include "core/CoreIncludes.h"
 namespace network {
+namespace orxonox {
 namespace packet {
 #define PACKET_FLAGS_ACK    0
 #define _PACKETID           0
 #define _ACKID              _PACKETID + sizeof(network::packet::ENUM::Type)
+#define _ACKID              _PACKETID + sizeof(packet::ENUM::Type)
 Acknowledgement::Acknowledgement( unsigned int id, unsigned int clientID )
 …
 } //namespace packet
 } //namespace network
+} //namespace orxonox

code/trunk/src/network/packet/Acknowledgement.h

-                      r2087
+                      r2171
 namespace network {
+namespace orxonox {
 namespace packet {
 /**
 …
 } //namespace packet
 } //namespace network
+} //namespace orxonox
 #endif

code/trunk/src/network/packet/Chat.cc

-                      r1907
+                      r2171
 #include "network/Host.h"
 namespace network {
+namespace orxonox {
 namespace packet {
 …
 } //namespace packet
 } //namespace network
+} //namespace orxonox

code/trunk/src/network/packet/Chat.h

-                      r2087
+                      r2171
 #include "Packet.h"
 namespace network {
+namespace orxonox {
 namespace packet {
 /**
 …
 } //namespace packet
 } //namespace network
+} //namespace orxonox
 #endif

code/trunk/src/network/packet/ClassID.cc

-                      r1907
+                      r2171
 #include <assert.h>
 namespace network {
+namespace orxonox {
 namespace packet {
 …
 unsigned int ClassID::getSize() const{
   return sizeof(network::packet::ENUM::Type) + 2*sizeof(uint32_t) + classNameLength_;
+  return sizeof(packet::ENUM::Type) + 2*sizeof(uint32_t) + classNameLength_;
+}
 bool ClassID::process(){
   COUT(3) << "processing classid: " << getClassID() << " name: " << (const char*)(data_+_CLASSNAME) << std::endl;
   orxonox::Identifier *id=ClassByID( std::string((const char*)(data_+_CLASSNAME) ));
+  Identifier *id=ClassByID( std::string((const char*)(data_+_CLASSNAME) ));
   if(id==NULL)
     return false;
 …
 } //namespace packet
 }//namespace network
+}//namespace orxonox

code/trunk/src/network/packet/ClassID.h

-                      r2087
+                      r2171
 #include "Packet.h"
 namespace network {
+namespace orxonox {
 namespace packet {
 …
 } //namespace packet
 } //namespace network
+} //namespace orxonox
 #endif

code/trunk/src/network/packet/DeleteObjects.cc

-                      r1907
+                      r2171
 #include <assert.h>
 namespace network {
+namespace orxonox {
 namespace packet {
 …
 } //namespace packet
 } //namespace network
+} //namespace orxonox

code/trunk/src/network/packet/DeleteObjects.h

-                      r2087
+                      r2171
 namespace network {
+namespace orxonox {
 namespace packet {
 /**
 …
 } //namespace packet
 } //namespace network
+} //namespace orxonox
 #endif

code/trunk/src/network/packet/Gamestate.cc

-                      r2087
+                      r2171
 namespace network {
+namespace orxonox {
 namespace packet {
 …
+}
 bool Gamestate::collectData(int id, int mode)
+{
   int tempsize=0, currentsize=0;
+bool Gamestate::collectData(int id, uint8_t mode)
+{
+  unsigned int tempsize=0, currentsize=0;
   assert(data_==0);
   int size = calcGamestateSize(id, mode);
+  unsigned int size = calcGamestateSize(id, mode);
   COUT(4) << "G.ST.Man: producing gamestate with id: " << id << std::endl;
 …
+  }
-#ifndef NDEBUG
-  std::list<Synchronisable*> slist;
-  std::list<Synchronisable*>::iterator iit;
-#endif
   //start collect data synchronisable by synchronisable
   uint8_t *mem=data_;
   mem+=sizeof(GamestateHeader);
   orxonox::ObjectList<Synchronisable>::iterator it;
   for(it = orxonox::ObjectList<Synchronisable>::begin(); it; ++it){
+  ObjectList<Synchronisable>::iterator it;
+  for(it = ObjectList<Synchronisable>::begin(); it; ++it){
     tempsize=it->getSize(id, mode);
     if(currentsize+tempsize > size){
+      assert(0); // if we don't use multithreading this part shouldn't be neccessary
       // start allocate additional memory
       COUT(3) << "G.St.Man: need additional memory" << std::endl;
       orxonox::ObjectList<Synchronisable>::iterator temp = it;
+      ObjectList<Synchronisable>::iterator temp = it;
       int addsize=tempsize;
       while(++temp)
 …
     }// stop allocate additional memory
-#ifndef NDEBUG
-    for(iit=slist.begin(); iit!=slist.end(); iit++)
-      assert((*iit)!=*it);
-    slist.push_back(*it);
-#endif
     //if(it->doSelection(id))
 …
   //start write gamestate header
   HEADER->packetType = ENUM::Gamestate;
-  assert( *(ENUM::Type *)(data_) == ENUM::Gamestate);
   HEADER->datasize = currentsize;
   HEADER->id = id;
 …
+}
 bool Gamestate::spreadData(int mode)
+bool Gamestate::spreadData(uint8_t mode)
+{
   assert(data_);
 …
   uint8_t *mem=data_+sizeof(GamestateHeader);
     // get the start of the Synchronisable list
   //orxonox::ObjectList<Synchronisable>::iterator it=orxonox::ObjectList<Synchronisable>::begin();
+  //ObjectList<Synchronisable>::iterator it=ObjectList<Synchronisable>::begin();
   Synchronisable *s;
 …
       bool b = s->updateData(mem, mode);
       assert(b);
-      //if(!s->updateData(mem, mode))
-        //return false;
+    }
+  }
 …
     assert(it->second->objectID==oldobjectheader->objectID);
     *newobjectheader = *oldobjectheader;
     objectOffset=sizeof(uint8_t)+sizeof(bool); //skip the size and the availableData variables in the objectheader
+    objectOffset=sizeof(synchronisableHeader); //skip the size and the availableData variables in the objectheader
     if(it->second->doSelection(HEADER->id)){
+      newobjectheader->dataAvailable=true; //TODO: probably not neccessary
+      while(objectOffset<objectsize){
+        *(newdata + objectOffset)=*(origdata + objectOffset);    // copy the data
+        objectOffset++;
+      }
+      assert(newobjectheader->dataAvailable==true);
+      memcpy(newdata+objectOffset, origdata+objectOffset, objectsize-objectOffset);
     }else{
       newobjectheader->dataAvailable=false;
+      while(objectOffset<objectsize){
+        *(newdata+objectOffset)=0;    // set to 0
+        objectOffset++;
+      }
+      memset(newdata+objectOffset, 0, objectsize-objectOffset);
       assert(objectOffset==objectsize);
+    }
 …
 unsigned int Gamestate::calcGamestateSize(unsigned int id, int mode)
+{
   int size=0;
+unsigned int Gamestate::calcGamestateSize(unsigned int id, uint8_t mode)
+{
+  unsigned int size=0;
     // get the start of the Synchronisable list
   orxonox::ObjectList<Synchronisable>::iterator it;
+  ObjectList<Synchronisable>::iterator it;
     // get total size of gamestate
   for(it = orxonox::ObjectList<Synchronisable>::begin(); it; ++it)
+  for(it = ObjectList<Synchronisable>::begin(); it; ++it)
     size+=it->getSize(id, mode); // size of the actual data of the synchronisable
 //  size+=sizeof(GamestateHeader);
 …
  * @return iterator pointing to the next object in the list
  */
   void Gamestate::removeObject(orxonox::ObjectList<Synchronisable>::iterator &it) {
     orxonox::ObjectList<Synchronisable>::iterator temp=it;
+  void Gamestate::removeObject(ObjectList<Synchronisable>::iterator &it) {
+    ObjectList<Synchronisable>::iterator temp=it;
     ++it;
     delete  *temp;

code/trunk/src/network/packet/Gamestate.h

-                      r2087
+                      r2171
 #endif
 namespace network {
+namespace orxonox {
 namespace packet {
 …
     ~Gamestate();
     bool collectData(int id, int mode=0x0);
     bool spreadData(int mode=0x0);
+    bool collectData(int id, uint8_t mode=0x0);
+    bool spreadData( uint8_t mode=0x0);
     int getID();
     bool isDiffed();
 …
     bool operator ==(packet::Gamestate gs);
   private:
     unsigned int calcGamestateSize(unsigned int id, int mode=0x0);
     void removeObject(orxonox::ObjectListIterator<Synchronisable> &it);
+    unsigned int calcGamestateSize(unsigned int id, uint8_t mode=0x0);
+    void removeObject(ObjectListIterator<Synchronisable> &it);
     std::map<unsigned int, Synchronisable*> dataMap_;
 };

code/trunk/src/network/packet/Packet.cc

-                      r2087
+                      r2171
 #include "core/CoreIncludes.h"
 namespace network{
+namespace orxonox{
 namespace packet{
 …
 #define _PACKETID           0
+std::map<ENetPacket *, Packet *> Packet::packetMap_;
+std::map<size_t, Packet *> Packet::packetMap_;
+boost::recursive_mutex Packet::packetMap_mutex;
 Packet::Packet(){
 …
       return false;
+    }
+    // Assures we don't create a packet and destroy it right after in another thread
+    // without having a reference in the packetMap_
+    boost::recursive_mutex::scoped_lock lock(Packet::packetMap_mutex);
     // We deliver ENet the data address so that it doesn't memcpy everything again.
     // --> We have to delete data_ ourselves!
 …
     // Add the packet to a global list so we can access it again once enet calls our
     // deletePacket method. We can of course only give a one argument function to the ENet C library.
     packetMap_[enetPacket_] = this;
+    packetMap_[(size_t)(void*)enetPacket_] = this;
+  }
 #ifndef NDEBUG
 …
 //  ENetPacket *temp = enetPacket_;
 //  enetPacket_ = 0; // otherwise we have a double free because enet already handles the deallocation of the packet
   network::Host::addPacket( enetPacket_, clientID_);
+  Host::addPacket( enetPacket_, clientID_);
   return true;
+}
 …
 */
 void Packet::deletePacket(ENetPacket *enetPacket){
+  boost::recursive_mutex::scoped_lock lock(Packet::packetMap_mutex);
   // Get our Packet from a gloabal map with all Packets created in the send() method of Packet.
   std::map<ENetPacket*, Packet*>::iterator it = packetMap_.find(enetPacket);
+  std::map<size_t, Packet*>::iterator it = packetMap_.find((size_t)enetPacket);
   assert(it != packetMap_.end());
   // Make sure we don't delete it again in the destructor
   it->second->enetPacket_ = 0;
   delete it->second;
   //packetMap_.erase(it);
+  packetMap_.erase(it);
   COUT(4) << "PacketMap size: " << packetMap_.size() << std::endl;
+}
 …
 } // namespace packet
 } // namespace network
+} // namespace orxonox

code/trunk/src/network/packet/Packet.h

-                      r2087
+                      r2171
 #define NETWORKPACKET_H
 #include "../NetworkPrereqs.h"
+#include "network/NetworkPrereqs.h"
 #include <map>
 #include <enet/enet.h>
+#include <boost/thread/recursive_mutex.hpp>
 #include "util/Integers.h"
 namespace network {
+namespace orxonox {
 namespace packet{
 …
     bool bDataENetAllocated_;
   private:
+    static std::map<ENetPacket *, Packet *> packetMap_;
+    static std::map<size_t, Packet *> packetMap_;
+    //! Static mutex for any packetMap_ access
+    static boost::recursive_mutex packetMap_mutex;
     ENetPacket *enetPacket_;
 };
 …
 } //namespace packet
 } //namespace network
+} //namespace orxonox
 #endif

code/trunk/src/network/packet/Welcome.cc

-                      r1907
+                      r2171
 #include <assert.h>
 namespace network {
+namespace orxonox {
 namespace packet {
 …
 unsigned int Welcome::getSize() const{
   return sizeof(network::packet::ENUM::Type) + 2*sizeof(uint32_t);
+  return sizeof(packet::ENUM::Type) + 2*sizeof(uint32_t);
+}
 …
 } //namespace packet
 }//namespace network
+}//namespace orxonox

code/trunk/src/network/packet/Welcome.h

-                      r2087
+                      r2171
 #include "Packet.h"
 namespace network {
+namespace orxonox {
 namespace packet {
 …
 } //namespace packet
 } //namespace network
+} //namespace orxonox
 #endif

code/trunk/src/orxonox/CMakeLists.txt

r2130	r2171
4	4	LevelManager.cc
5	5	Main.cc
	6	PlayerManager.cc
6	7	Settings.cc
7	8

code/trunk/src/orxonox/CameraManager.cc

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/src/orxonox/CameraManager.h

Property svn:mergeinfo changed
/code/branches/objecthierarchy/src/orxonox/CameraManager.h merged: 2114

r2103	r2171
28	28
29	29	/**
30		@file ~~CameraManager.h~~
	30	@file
31	31	@brief Handles the instances of Camera class
32	32	@author Benjamin Knecht <beni_at_orxonox.net>

code/trunk/src/orxonox/LevelManager.cc

-                      r2087
+                      r2171
 #include "OrxonoxStableHeaders.h"
 #include "LevelManager.h"
+#include "core/CoreIncludes.h"
+#include "objects/infos/Level.h"
+#include "PlayerManager.h"
+#include "objects/Level.h"
 #include "objects/infos/HumanPlayer.h"
 …
     LevelManager::LevelManager()
+    {
-        RegisterRootObject(LevelManager);
         assert(singletonRef_s == 0);
         singletonRef_s = this;
-        this->getConnectedClients();
+    }
 …
+        {
             this->levels_s.front()->setActive(true);
             for (std::map<unsigned int, PlayerInfo*>::iterator it = this->clients_.begin(); it != this->clients_.end(); ++it)
+            for (std::map<unsigned int, PlayerInfo*>::const_iterator it = PlayerManager::getInstance().getClients().begin(); it != PlayerManager::getInstance().getClients().end(); ++it)
                 this->levels_s.front()->playerEntered(it->second);
+        }
+    }
-    void LevelManager::clientConnected(unsigned int clientID)
+    {
-        COUT(3) << "client connected" << std::endl;
-        // create new HumanPlayer instance
-        HumanPlayer* player = new HumanPlayer(0);
-        player->setClientID(clientID);
-        // add to clients-map
-        assert(!this->clients_[clientID]);
-        this->clients_[clientID] = player;
-        if (this->getActiveLevel())
-            this->getActiveLevel()->playerEntered(player);
+    }
-    void LevelManager::clientDisconnected(unsigned int clientID)
+    {
-        COUT(3) << "client disconnected" << std::endl;
-        // remove from clients-map
-        PlayerInfo* player = this->clients_[clientID];
-        this->clients_.erase(clientID);
-        if (this->getActiveLevel())
-            this->getActiveLevel()->playerLeft(player);
-        // delete PlayerInfo instance
-        if (player)
-            delete player;
+    }
-    PlayerInfo* LevelManager::getClient(unsigned int clientID) const
+    {
-        std::map<unsigned int, PlayerInfo*>::const_iterator it = this->clients_.find(clientID);
-        if (it != this->clients_.end())
-            return it->second;
-        else
-            return 0;
+    }
+}

code/trunk/src/orxonox/LevelManager.h

-                      r2087
+                      r2171
 #include <cassert>
-#include "network/ClientConnectionListener.h"
 namespace orxonox
+{
     class _OrxonoxExport LevelManager : public network::ClientConnectionListener
+    class _OrxonoxExport LevelManager
+    {
         public:
 …
             Level* getActiveLevel();
+            PlayerInfo* getClient(unsigned int clientID) const;
+            inline const std::map<unsigned int, PlayerInfo*>& getClients() const
+                { return this->clients_; }
+            static LevelManager* getInstancePtr() { return singletonRef_s; }
             static LevelManager& getInstance() { assert(singletonRef_s); return *singletonRef_s; }
 …
             LevelManager(const LevelManager&);
-            void clientConnected(unsigned int clientID);
-            void clientDisconnected(unsigned int clientID);
             void activateNextLevel();
             std::list<Level*> levels_s;
-            std::map<unsigned int, PlayerInfo*> clients_;
             static LevelManager* singletonRef_s;
     };

code/trunk/src/orxonox/OrxonoxPrereqs.h

-                      r2096
+                      r2171
     class CameraManager;
     class LevelManager;
+    class PlayerManager;
     // objects
+    class Level;
     class Scene;
 …
     class Info;
-    class Level;
     class PlayerInfo;
     class HumanPlayer;

code/trunk/src/orxonox/Settings.h

r2087	r2171
28	28
29	29	/**
30		@file ~~Core.h~~
	30	@file
31	31	@brief Declaration of the Settings class.
32	32

code/trunk/src/orxonox/gamestates/GSClient.cc

r2087	r2171
53	53	Core::setIsClient(true);
54	54
55		this->client_ = new ~~network::~~Client(CommandLine::getValue("ip").getString(), CommandLine::getValue("port"));
	55	this->client_ = new Client(CommandLine::getValue("ip").getString(), CommandLine::getValue("port"));
56	56
57	57	if(!client_->establishConnection())

code/trunk/src/orxonox/gamestates/GSClient.h

r2087	r2171
49	49	void ticked(const Clock& time);
50	50
51		~~network::~~Client* client_;
	51	Client* client_;
52	52	};
53	53	}

code/trunk/src/orxonox/gamestates/GSDedicated.cc

-                      r2087
+                      r2171
 #include "core/CommandLine.h"
 #include "core/Core.h"
+#include "core/Iterator.h"
 #include "network/Server.h"
+#include "objects/Tickable.h"
 namespace orxonox
 …
         Core::setHasServer(true);
         this->server_ = new network::Server(CommandLine::getValue("port"));
+        this->server_ = new Server(CommandLine::getValue("port"));
         COUT(0) << "Loading scene in server mode" << std::endl;

code/trunk/src/orxonox/gamestates/GSDedicated.h

r2087	r2171
48	48	void ticked(const Clock& time);
49	49
50		~~network::~~Server* server_;
	50	Server* server_;
51	51	};
52	52	}

code/trunk/src/orxonox/gamestates/GSGraphics.cc

-                      r2103
+                      r2171
 #include "gui/GUIManager.h"
 #include "tools/WindowEventListener.h"
-#include "objects/Tickable.h"
 #include "Settings.h"
 …
         this->tickChild(time);
-        /*** HACK *** HACK ***/
-        // Call the Tickable objects
-        for (ObjectList<Tickable>::iterator it = ObjectList<Tickable>::begin(); it; ++it)
-            it->tick(time.getDeltaTime());
-        /*** HACK *** HACK ***/
         if (this->bWindowEventListenerUpdateRequired_)
+        {

code/trunk/src/orxonox/gamestates/GSRoot.cc

-                      r2087
+                      r2171
 #include "core/TclThreadManager.h"
 #include "tools/Timer.h"
+#include "objects/Tickable.h"
 #include "Settings.h"
 …
             it->tick(time);
+        /*** HACK *** HACK ***/
+        // Call the Tickable objects
+        for (ObjectList<Tickable>::iterator it = ObjectList<Tickable>::begin(); it; ++it)
+            it->tick(time.getDeltaTime());
+        /*** HACK *** HACK ***/
         this->tickChild(time);
+    }

code/trunk/src/orxonox/gamestates/GSServer.cc

r2087	r2171
52	52	Core::setHasServer(true);
53	53
54		this->server_ = new ~~network::~~Server(CommandLine::getValue("port"));
	54	this->server_ = new Server(CommandLine::getValue("port"));
55	55	COUT(0) << "Loading scene in server mode" << std::endl;
56	56

code/trunk/src/orxonox/gamestates/GSServer.h

r2087	r2171
48	48	void ticked(const Clock& time);
49	49
50		~~network::~~Server* server_;
	50	Server* server_;
51	51	};
52	52	}

code/trunk/src/orxonox/objects/CMakeLists.txt

r2131	r2171
3	3	EventDispatcher.cc
4	4	EventTarget.cc
	5	Level.cc
5	6	Radar.cc
6	7	RadarListener.cc

code/trunk/src/orxonox/objects/Scene.cc

-                      r2087
+                      r2171
     CreateFactory(Scene);
     Scene::Scene(BaseObject* creator) : BaseObject(creator), network::Synchronisable(creator)
+    Scene::Scene(BaseObject* creator) : BaseObject(creator), Synchronisable(creator)
+    {
         RegisterObject(Scene);
 …
     void Scene::registerVariables()
+    {
         REGISTERSTRING(this->skybox_,     network::direction::toclient, new network::NetworkCallback<Scene>(this, &Scene::networkcallback_applySkybox));
         REGISTERDATA(this->ambientLight_, network::direction::toclient, new network::NetworkCallback<Scene>(this, &Scene::networkcallback_applyAmbientLight));
+        REGISTERSTRING(this->skybox_,     direction::toclient, new NetworkCallback<Scene>(this, &Scene::networkcallback_applySkybox));
+        REGISTERDATA(this->ambientLight_, direction::toclient, new NetworkCallback<Scene>(this, &Scene::networkcallback_applyAmbientLight));
+    }
 …
         return 0;
+    }
+    void Scene::tick(float dt)
+    {
+        if (!Core::showsGraphics())
+        {
+            // We need to update the scene nodes if we don't render
+            this->rootSceneNode_->_update(true, false);
+        }
+    }
+}

code/trunk/src/orxonox/objects/Scene.h

-                      r2087
+                      r2171
 #include "core/BaseObject.h"
 #include "util/Math.h"
+#include "objects/Tickable.h"
 namespace orxonox
+{
     class _OrxonoxExport Scene : public BaseObject, public network::Synchronisable
+    class _OrxonoxExport Scene : public BaseObject, public Synchronisable, public Tickable
+    {
         public:
 …
                 { return this->bShadows_; }
+            virtual void tick(float dt);
         private:
             void addObject(BaseObject* object);

code/trunk/src/orxonox/objects/Test.cc

-                      r2087
+                      r2171
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
+#include "core/ConsoleCommand.h"
 #include "Test.h"
 …
+{
         CreateFactory ( Test );
+  SetConsoleCommand(Test, printV1, true).accessLevel(AccessLevel::User);
+  SetConsoleCommand(Test, printV2, true).accessLevel(AccessLevel::User);
+  SetConsoleCommand(Test, printV3, true).accessLevel(AccessLevel::User);
+  SetConsoleCommand(Test, printV4, true).accessLevel(AccessLevel::User);
+  Test* Test::instance_ = 0;
         Test::Test(BaseObject* creator) : BaseObject(creator), network::Synchronisable(creator)
+        Test::Test(BaseObject* creator) : BaseObject(creator), Synchronisable(creator)
+        {
+    assert(instance_==0);
+    instance_=this;
                 RegisterObject ( Test );
                 setConfigValues();
                 registerVariables();
+    setConfigValues();
+    registerVariables();
                 setObjectMode(0x3);
+        }
 …
         Test::~Test()
+        {
+    instance_=0;
+        }
         void Test::setConfigValues()
+        {
+                SetConfigValue ( v1, 1 ).callback ( this, &Test::checkV1 );
+                SetConfigValue ( v2, 2 ).callback ( this, &Test::checkV2 );
+                SetConfigValue ( v3, 3 ).callback ( this, &Test::checkV3 );
+                SetConfigValue ( v1, 1 )/*.callback ( this, &Test::checkV1 )*/;
+    SetConfigValue ( v2, 2 )/*.callback ( this, &Test::checkV2 )*/;
+    SetConfigValue ( v3, 3 )/*.callback ( this, &Test::checkV3 )*/;
+    SetConfigValue ( v4, 4 )/*.callback ( this, &Test::checkV4 )*/;
+        }
 …
         void Test::registerVariables()
+        {
+                REGISTERDATA ( v1,network::direction::toclient, new network::NetworkCallback<Test> ( this, &Test::checkV1 ) );
+                REGISTERDATA ( v2,network::direction::toserver, new network::NetworkCallback<Test> ( this, &Test::checkV2 ) );
+                REGISTERDATA ( v3,network::direction::bidirectional, new network::NetworkCallback<Test> ( this, &Test::checkV3 ) );
+                REGISTERDATA ( v1,direction::toclient, new NetworkCallback<Test> ( this, &Test::checkV1 ) );
+    REGISTERDATA ( v2,direction::toserver, new NetworkCallback<Test> ( this, &Test::checkV2 ) );
+                REGISTERDATA ( v3,direction::serverMaster, new NetworkCallback<Test> ( this, &Test::checkV3 ) );
+    REGISTERDATA ( v4,direction::clientMaster, new NetworkCallback<Test> ( this, &Test::checkV4 ) );
+        }
         void Test::checkV1(){
                 COUT(1) << "V1 changed: " << v1 << std::endl;
+        }
+  void Test::checkV1(){
+    COUT(1) << "V1 changed: " << v1 << std::endl;
+  }
         void Test::checkV2(){
                 COUT(1) << "V2 changed: " << v2 << std::endl;
+        }
+  void Test::checkV2(){
+    COUT(1) << "V2 changed: " << v2 << std::endl;
+  }
+        void Test::checkV3(){
+                COUT(1) << "V3 changed: " << v3 << std::endl;
+        }
+  void Test::checkV3(){
+    COUT(1) << "V3 changed: " << v3 << std::endl;
+  }
+  void Test::checkV4(){
+    COUT(1) << "V4 changed: " << v4 << std::endl;
+  }

code/trunk/src/orxonox/objects/Test.h

-                      r2087
+                      r2171
 namespace orxonox
+{
   class _OrxonoxExport Test: public BaseObject, public network::Synchronisable
+  class _OrxonoxExport Test: public BaseObject, public Synchronisable
+  {
     public:
 …
       void setV2(unsigned int value){ v2 = value; }
       void setV3(unsigned int value){ v3 = value; }
+      void setV4(unsigned int value){ v4 = value; }
       void checkV1();
       void checkV2();
       void checkV3();
+      void checkV4();
+      void printV1(){ instance_->checkV1(); }
+      void printV2(){ instance_->checkV2(); }
+      void printV3(){ instance_->checkV3(); }
+      void printV4(){ instance_->checkV4(); }
     private:
 …
       unsigned int v2;
       unsigned int v3;
+      unsigned int v4;
+      static Test* instance_;
   };
+}

code/trunk/src/orxonox/objects/Tickable.h

r1790	r2171
28	28
29	29	/*!
30		@file ~~Tickable.h~~
	30	@file
31	31	@brief Declaration of the Tickable interface.
32	32

code/trunk/src/orxonox/objects/gametypes/Gametype.cc

r2087	r2171
67	67	if (!this->bStarted_)
68	68	this->checkStart();
	69	else
	70	this->spawnDeadPlayersIfRequested();
69	71
70	72	this->assignDefaultPawnsIfNeeded();
71		~~this->spawnDeadPlayersIfRequested();~~
72	73	}
73	74
…	…
88	89	void Gametype::playerEntered(PlayerInfo* player)
89	90	{
90		this->players_~~.insert(player)~~;
	91	this->players_[player] = PlayerState::Joined;
91	92
92	93	std::string message = player->getName() + " entered the game";
93	94	COUT(0) << message << std::endl;
94		~~network::~~Host::Broadcast(message);
	95	Host::Broadcast(message);
95	96	}
96	97
97	98	void Gametype::playerLeft(PlayerInfo* player)
98	99	{
99		std::set<PlayerInfo*>::iterator it = this->players_.find(player);
	100	std::map<PlayerInfo*, PlayerState::Enum>::iterator it = this->players_.find(player);
100	101	if (it != this->players_.end())
101	102	{
…	…
104	105	std::string message = player->getName() + " left the game";
105	106	COUT(0) << message << std::endl;
106		~~network::~~Host::Broadcast(message);
	107	Host::Broadcast(message);
107	108	}
108	109	}
…	…
124	125	std::string message = player->getOldName() + " changed name to " + player->getName();
125	126	COUT(0) << message << std::endl;
126		~~network::~~Host::Broadcast(message);
	127	Host::Broadcast(message);
127	128	}
128	129	}
…	…
165	166	}
166	167
167		void Gametype::assignDefaultPawnsIfNeeded() ~~const~~
168		{
169		for (std::~~set<PlayerInfo*>::const_~~iterator it = this->players_.begin(); it != this->players_.end(); ++it)
170		{
171		if (!~~(it)->getControllableEntity() && (!(it)~~->isReadyToSpawn() \|\| !this->bStarted_))
172		{
173		SpawnPoint* spawn = this->getBestSpawnPoint(*it);
	168	void Gametype::assignDefaultPawnsIfNeeded()
	169	{
	170	for (std::map<PlayerInfo*, PlayerState::Enum>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
	171	{
	172	if (!it->first->getControllableEntity() && (!it->first->isReadyToSpawn() \|\| !this->bStarted_))
	173	{
	174	SpawnPoint* spawn = this->getBestSpawnPoint(it->first);
174	175	if (spawn)
175	176	{
…	…
177	178	ControllableEntity* entity = this->defaultControllableEntity_.fabricate(spawn);
178	179	spawn->spawn(entity);
179		(*it)->startControl(entity);
	180	it->first->startControl(entity);
	181	it->second = PlayerState::Dead;
180	182	}
181	183	else
…	…
210	212	{
211	213	bool allplayersready = true;
212		for (std::set<PlayerInfo*>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
	214	for (std::map<PlayerInfo*, PlayerState::Enum>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
213	215	{
214		if (!~~(*it)~~->isReadyToSpawn())
	216	if (!it->first->isReadyToSpawn())
215	217	allplayersready = false;
216	218	}
…	…
227	229	void Gametype::spawnPlayersIfRequested()
228	230	{
229		for (std::set<PlayerInfo*>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
230		if (~~(*it)~~->isReadyToSpawn() \|\| this->bForceSpawn_)
231		this->spawnPlayer(*it);
	231	for (std::map<PlayerInfo*, PlayerState::Enum>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
	232	if (it->first->isReadyToSpawn() \|\| this->bForceSpawn_)
	233	this->spawnPlayer(it->first);
232	234	}
233	235
234	236	void Gametype::spawnDeadPlayersIfRequested()
235	237	{
236		for (std::set<PlayerInfo*>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
237		if (~~!(*it)->getControllableEntity()~~)
238		if (~~(*it)~~->isReadyToSpawn() \|\| this->bForceSpawn_)
239		this->spawnPlayer(*it);
	238	for (std::map<PlayerInfo*, PlayerState::Enum>::iterator it = this->players_.begin(); it != this->players_.end(); ++it)
	239	if (it->second == PlayerState::Dead)
	240	if (it->first->isReadyToSpawn() \|\| this->bForceSpawn_)
	241	this->spawnPlayer(it->first);
240	242	}
241	243
…	…
246	248	{
247	249	player->startControl(spawnpoint->spawn());
	250	this->players_[player] = PlayerState::Alive;
248	251	}
249	252	else

code/trunk/src/orxonox/objects/gametypes/Gametype.h

-                      r2087
+                      r2171
 namespace orxonox
+{
+    namespace PlayerState
+    {
+        enum Enum
+        {
+            Uninitialized,
+            Joined,
+            Alive,
+            Dead
+        };
+    }
     class _OrxonoxExport Gametype : public BaseObject, public Tickable
+    {
 …
             virtual void pawnPostSpawn(Pawn* pawn);
             inline const std::set<PlayerInfo*>& getPlayers() const
+            inline const std::map<PlayerInfo*, PlayerState::Enum>& getPlayers() const
                 { return this->players_; }
 …
             void removePlayer(PlayerInfo* player);
             void assignDefaultPawnsIfNeeded() const;
+            void assignDefaultPawnsIfNeeded();
             void checkStart();
             void spawnPlayer(PlayerInfo* player);
 …
             bool bStartCountdownRunning_;
             std::set<PlayerInfo*> players_;
+            std::map<PlayerInfo*, PlayerState::Enum> players_;
             std::set<SpawnPoint*> spawnpoints_;
             SubclassIdentifier<ControllableEntity> defaultControllableEntity_;

code/trunk/src/orxonox/objects/infos/CMakeLists.txt

r2131	r2171
1	1	SET( SRC_FILES
2	2	Info.cc
3		~~Level.cc~~
4	3	PlayerInfo.cc
5	4	HumanPlayer.cc

code/trunk/src/orxonox/objects/infos/HumanPlayer.cc

r2087	r2171
46	46	RegisterObject(HumanPlayer);
47	47
48		this->server_~~ready~~_ = Core::isMaster();
49		this->client_~~ready~~_ = false;
	48	this->server_initialized_ = Core::isMaster();
	49	this->client_initialized_ = false;
50	50
51	51	this->bHumanPlayer_ = true;
…	…
67	67	void HumanPlayer::registerVariables()
68	68	{
69		REGISTERSTRING(this->synchronize_nick_, ~~network::direction::toserver, new network::~~NetworkCallback<HumanPlayer>(this, &HumanPlayer::networkcallback_changednick));
	69	REGISTERSTRING(this->synchronize_nick_, direction::toserver, new NetworkCallback<HumanPlayer>(this, &HumanPlayer::networkcallback_changednick));
70	70
71		REGISTERDATA(this->clientID_, ~~network::direction::toclient, new network::~~NetworkCallback<HumanPlayer>(this, &HumanPlayer::networkcallback_clientIDchanged));
72		REGISTERDATA(this->server_~~ready_, network::direction::toclient, new network::NetworkCallback<HumanPlayer>(this, &HumanPlayer::networkcallback_server_ready~~));
73		REGISTERDATA(this->client_~~ready_, network::direction::toserver, new network::NetworkCallback<HumanPlayer>(this, &HumanPlayer::networkcallback_client_ready~~));
	71	REGISTERDATA(this->clientID_, direction::toclient, new NetworkCallback<HumanPlayer>(this, &HumanPlayer::networkcallback_clientIDchanged));
	72	REGISTERDATA(this->server_initialized_, direction::toclient, new NetworkCallback<HumanPlayer>(this, &HumanPlayer::networkcallback_server_initialized));
	73	REGISTERDATA(this->client_initialized_, direction::toserver, new NetworkCallback<HumanPlayer>(this, &HumanPlayer::networkcallback_client_initialized));
74	74	}
75	75
…	…
92	92	void HumanPlayer::networkcallback_clientIDchanged()
93	93	{
94		if (this->clientID_ == ~~network::~~Host::getPlayerID())
	94	if (this->clientID_ == Host::getPlayerID())
95	95	{
96	96	this->bLocalPlayer_ = true;
97	97	this->synchronize_nick_ = this->nick_;
98		this->client_~~ready~~_ = true;
	98	this->client_initialized_ = true;
99	99
100	100	if (!Core::isMaster())
101		this->setObjectMode(~~network::~~direction::bidirectional);
	101	this->setObjectMode(direction::bidirectional);
102	102	else
103	103	this->setName(this->nick_);
…	…
107	107	}
108	108
109		void HumanPlayer::networkcallback_server_~~ready~~()
	109	void HumanPlayer::networkcallback_server_initialized()
110	110	{
111		this->client_~~ready~~_ = true;
	111	this->client_initialized_ = true;
112	112	}
113	113
114		void HumanPlayer::networkcallback_client_~~ready~~()
	114	void HumanPlayer::networkcallback_client_initialized()
115	115	{
116	116	if (this->getGametype())
…	…
118	118	}
119	119
120		bool HumanPlayer::is~~Ready~~() const
	120	bool HumanPlayer::isInitialized() const
121	121	{
122		return (this->server_~~ready_ && this->client_ready~~_);
	122	return (this->server_initialized_ && this->client_initialized_);
123	123	}
124	124
125	125	float HumanPlayer::getPing() const
126	126	{
127		return ~~network::~~ClientInformation::findClient(this->getClientID())->getRTT();
	127	return ClientInformation::findClient(this->getClientID())->getRTT();
128	128	}
129	129
130	130	float HumanPlayer::getPacketLossRatio() const
131	131	{
132		return ~~network::~~ClientInformation::findClient(this->getClientID())->getPacketLoss();
	132	return ClientInformation::findClient(this->getClientID())->getPacketLoss();
133	133	}
134	134

code/trunk/src/orxonox/objects/infos/HumanPlayer.h

-                      r2087
+                      r2171
             void setConfigValues();
             bool isReady() const;
+            bool isInitialized() const;
             float getPing() const;
             float getPacketLossRatio() const;
 …
             void networkcallback_changednick();
             void networkcallback_clientIDchanged();
             void networkcallback_server_ready();
             void networkcallback_client_ready();
+            void networkcallback_server_initialized();
+            void networkcallback_client_initialized();
             std::string nick_;
             std::string synchronize_nick_;
             bool server_ready_;
             bool client_ready_;
+            bool server_initialized_;
+            bool client_initialized_;
     };
+}

code/trunk/src/orxonox/objects/infos/Info.cc

r2087	r2171
34	34	namespace orxonox
35	35	{
36		Info::Info(BaseObject* creator) : BaseObject(creator), ~~network::~~Synchronisable(creator)
	36	Info::Info(BaseObject* creator) : BaseObject(creator), Synchronisable(creator)
37	37	{
38	38	RegisterObject(Info);

code/trunk/src/orxonox/objects/infos/Info.h

r2087	r2171
37	37	namespace orxonox
38	38	{
39		class _OrxonoxExport Info : public BaseObject, public ~~network::~~Synchronisable
	39	class _OrxonoxExport Info : public BaseObject, public Synchronisable
40	40	{
41	41	public:

code/trunk/src/orxonox/objects/infos/PlayerInfo.cc

r2087	r2171
42	42	RegisterObject(PlayerInfo);
43	43
44		this->clientID_ = ~~network::~~CLIENTID_UNKNOWN;
	44	this->clientID_ = CLIENTID_UNKNOWN;
45	45	this->bHumanPlayer_ = false;
46	46	this->bLocalPlayer_ = false;
…	…
48	48	this->controller_ = 0;
49	49	this->controllableEntity_ = 0;
50		this->controllableEntityID_ = ~~network::~~CLIENTID_UNKNOWN;
	50	this->controllableEntityID_ = CLIENTID_UNKNOWN;
51	51
52	52	this->registerVariables();
…	…
55	55	PlayerInfo::~PlayerInfo()
56	56	{
57		if (this->isInitialized())
	57	if (this->BaseObject::isInitialized())
58	58	{
59	59	this->stopControl(this->controllableEntity_);
…	…
69	69	void PlayerInfo::registerVariables()
70	70	{
71		REGISTERSTRING(this->name_, ~~network::direction::toclient, new network::~~NetworkCallback<PlayerInfo>(this, &PlayerInfo::changedName));
72		REGISTERDATA (this->controllableEntityID_, ~~network::direction::toclient, new network::~~NetworkCallback<PlayerInfo>(this, &PlayerInfo::networkcallback_changedcontrollableentityID));
73		REGISTERDATA (this->bReadyToSpawn_, ~~network::~~direction::toserver);
	71	REGISTERSTRING(this->name_, direction::toclient, new NetworkCallback<PlayerInfo>(this, &PlayerInfo::changedName));
	72	REGISTERDATA (this->controllableEntityID_, direction::toclient, new NetworkCallback<PlayerInfo>(this, &PlayerInfo::networkcallback_changedcontrollableentityID));
	73	REGISTERDATA (this->bReadyToSpawn_, direction::toserver);
74	74	}
75	75
76	76	void PlayerInfo::changedName()
77	77	{
78		if (this->is~~Ready~~() && this->getGametype())
	78	if (this->isInitialized() && this->getGametype())
79	79	this->getGametype()->playerChangedName(this);
80	80	}
…	…
82	82	void PlayerInfo::changedGametype()
83	83	{
84		if (this->is~~Ready~~())
	84	if (this->isInitialized())
85	85	{
86	86	if (this->getOldGametype())
…	…
126	126	else
127	127	{
128		this->controllableEntityID_ = ~~network::~~OBJECTID_UNKNOWN;
	128	this->controllableEntityID_ = OBJECTID_UNKNOWN;
129	129	}
130	130
…	…
138	138	{
139	139	this->controllableEntity_ = 0;
140		this->controllableEntityID_ = ~~network::~~OBJECTID_UNKNOWN;
	140	this->controllableEntityID_ = OBJECTID_UNKNOWN;
141	141
142	142	if (this->controller_)
…	…
150	150	void PlayerInfo::networkcallback_changedcontrollableentityID()
151	151	{
152		if (this->controllableEntityID_ != ~~network::~~OBJECTID_UNKNOWN)
	152	if (this->controllableEntityID_ != OBJECTID_UNKNOWN)
153	153	{
154	154	Synchronisable* temp = Synchronisable::getSynchronisable(this->controllableEntityID_);

code/trunk/src/orxonox/objects/infos/PlayerInfo.h

-                      r2087
+                      r2171
             inline unsigned int getClientID() const
                 { return this->clientID_; }
-            inline bool isReadyToSpawn() const
-                { return this->bReadyToSpawn_; }
             virtual bool isReady() const = 0;
+            virtual bool isInitialized() const = 0;
             virtual float getPing() const = 0;
             virtual float getPacketLossRatio() const = 0;
 …
             inline void setReadyToSpawn(bool bReady)
                 { this->bReadyToSpawn_ = bReady; }
+            inline bool isReadyToSpawn() const
+                { return this->bReadyToSpawn_; }
             void startControl(ControllableEntity* entity);

code/trunk/src/orxonox/objects/weaponSystem/WeaponSystem.h

Property svn:mergeinfo changed
/code/branches/objecthierarchy/src/orxonox/objects/weaponSystem/WeaponSystem.h (added) merged: 2110-2169

code/trunk/src/orxonox/objects/worldentities/Backlight.cc

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/src/orxonox/objects/worldentities/Backlight.h

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/src/orxonox/objects/worldentities/Billboard.cc

r2087	r2171
64	64	void Billboard::registerVariables()
65	65	{
66		REGISTERSTRING(this->material_, ~~network::direction::toclient, new network::~~NetworkCallback<Billboard>(this, &Billboard::changedMaterial));
67		REGISTERDATA (this->colour_, ~~network::direction::toclient, new network::~~NetworkCallback<Billboard>(this, &Billboard::changedColour));
	66	REGISTERSTRING(this->material_, direction::toclient, new NetworkCallback<Billboard>(this, &Billboard::changedMaterial));
	67	REGISTERDATA (this->colour_, direction::toclient, new NetworkCallback<Billboard>(this, &Billboard::changedColour));
68	68	}
69	69
…	…
75	75	{
76	76	this->billboard_.setBillboardSet(this->getScene()->getSceneManager(), this->material_, this->colour_, 1);
77		this->getNode()->attachObject(this->billboard_.getBillboardSet());
	77	if (this->billboard_.getBillboardSet())
	78	this->getNode()->attachObject(this->billboard_.getBillboardSet());
78	79	this->billboard_.setVisible(this->isVisible());
79	80	}
…	…
90	91	{
91	92	this->billboard_.setBillboardSet(this->getScene()->getSceneManager(), this->material_, this->colour_, 1);
92		this->getNode()->attachObject(this->billboard_.getBillboardSet());
	93	if (this->billboard_.getBillboardSet())
	94	this->getNode()->attachObject(this->billboard_.getBillboardSet());
93	95	this->billboard_.setVisible(this->isVisible());
94	96	}

code/trunk/src/orxonox/objects/worldentities/BlinkingBillboard.cc

-                      r2087
+                      r2171
     void BlinkingBillboard::registerVariables()
+    {
 //        REGISTERDATA(this->amplitude_, network::direction::toclient);
 //        REGISTERDATA(this->frequency_, network::direction::toclient);
 //        REGISTERDATA(this->phase_,     network::direction::toclient);
+//        REGISTERDATA(this->amplitude_, direction::toclient);
+//        REGISTERDATA(this->frequency_, direction::toclient);
+//        REGISTERDATA(this->phase_,     direction::toclient);
+    }

code/trunk/src/orxonox/objects/worldentities/Camera.cc

Property svn:mergeinfo changed
/code/branches/objecthierarchy/src/orxonox/objects/worldentities/Camera.cc merged: 2161-2162

-                      r2103
+                      r2171
 #include <OgreViewport.h>
+#include "util/Exception.h"
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
 …
         RegisterObject(Camera);
         assert(this->getScene());
         assert(this->getScene()->getSceneManager());
+        if (!this->getScene() || !this->getScene()->getSceneManager())
+            ThrowException(AbortLoading, "Can't create Camera, no scene or no scene manager given.");
         this->camera_ = this->getScene()->getSceneManager()->createCamera(getUniqueNumberString());

code/trunk/src/orxonox/objects/worldentities/Camera.h

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/src/orxonox/objects/worldentities/ControllableEntity.cc

-                      r2087
+                      r2171
         this->client_overwrite_ = 0;
         this->player_ = 0;
         this->playerID_ = network::OBJECTID_UNKNOWN;
+        this->playerID_ = OBJECTID_UNKNOWN;
         this->hud_ = 0;
         this->camera_ = 0;
 …
                 this->client_overwrite_ = this->server_overwrite_;
 COUT(0) << "CE: bidirectional synchronization" << std::endl;
                 this->setObjectMode(network::direction::bidirectional);
+                this->setObjectMode(direction::bidirectional);
+            }
+        }
 …
         this->player_ = 0;
         this->playerID_ = network::OBJECTID_UNKNOWN;
+        this->playerID_ = OBJECTID_UNKNOWN;
         this->bControlled_ = false;
         this->setObjectMode(network::direction::toclient);
+        this->setObjectMode(direction::toclient);
         if (this->bDestroyWhenPlayerLeft_)
 …
+    {
         // just do this in case the entity wasn't yet synchronized when the corresponding PlayerInfo got our objectID
         if (this->playerID_ != network::OBJECTID_UNKNOWN)
+        {
             this->player_ = dynamic_cast<PlayerInfo*>(network::Synchronisable::getSynchronisable(this->playerID_));
+        if (this->playerID_ != OBJECTID_UNKNOWN)
+        {
+            this->player_ = dynamic_cast<PlayerInfo*>(Synchronisable::getSynchronisable(this->playerID_));
             if (this->player_ && (this->player_->getControllableEntity() != this))
                 this->player_->startControl(this);
 …
     void ControllableEntity::registerVariables()
+    {
         REGISTERSTRING(this->cameraPositionTemplate_, network::direction::toclient);
         REGISTERDATA(this->server_position_,    network::direction::toclient, new network::NetworkCallback<ControllableEntity>(this, &ControllableEntity::processServerPosition));
         REGISTERDATA(this->server_velocity_,    network::direction::toclient, new network::NetworkCallback<ControllableEntity>(this, &ControllableEntity::processServerVelocity));
         REGISTERDATA(this->server_orientation_, network::direction::toclient, new network::NetworkCallback<ControllableEntity>(this, &ControllableEntity::processServerOrientation));
         REGISTERDATA(this->server_overwrite_,   network::direction::toclient, new network::NetworkCallback<ControllableEntity>(this, &ControllableEntity::processOverwrite));
         REGISTERDATA(this->client_overwrite_,   network::direction::toserver);
         REGISTERDATA(this->client_position_,    network::direction::toserver, new network::NetworkCallback<ControllableEntity>(this, &ControllableEntity::processClientPosition));
         REGISTERDATA(this->client_velocity_,    network::direction::toserver, new network::NetworkCallback<ControllableEntity>(this, &ControllableEntity::processClientVelocity));
         REGISTERDATA(this->client_orientation_, network::direction::toserver, new network::NetworkCallback<ControllableEntity>(this, &ControllableEntity::processClientOrientation));
         REGISTERDATA(this->playerID_, network::direction::toclient, new network::NetworkCallback<ControllableEntity>(this, &ControllableEntity::networkcallback_changedplayerID));
+        REGISTERSTRING(this->cameraPositionTemplate_, direction::toclient);
+        REGISTERDATA(this->client_overwrite_,   direction::toserver);
+        REGISTERDATA(this->server_position_,    direction::toclient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processServerPosition));
+        REGISTERDATA(this->server_velocity_,    direction::toclient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processServerVelocity));
+        REGISTERDATA(this->server_orientation_, direction::toclient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processServerOrientation));
+        REGISTERDATA(this->server_overwrite_,   direction::toclient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processOverwrite));
+        REGISTERDATA(this->client_position_,    direction::toserver, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processClientPosition));
+        REGISTERDATA(this->client_velocity_,    direction::toserver, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processClientVelocity));
+        REGISTERDATA(this->client_orientation_, direction::toserver, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::processClientOrientation));
+        REGISTERDATA(this->playerID_, direction::toclient, new NetworkCallback<ControllableEntity>(this, &ControllableEntity::networkcallback_changedplayerID));
+    }

code/trunk/src/orxonox/objects/worldentities/Light.cc

-                      r2087
+                      r2171
     void Light::registerVariables()
+    {
         REGISTERDATA(this->type_, network::direction::toclient, new network::NetworkCallback<Light>(this, &Light::changedType));
         REGISTERDATA(this->light_->getDiffuseColour(), network::direction::toclient);
         REGISTERDATA(this->light_->getSpecularColour(), network::direction::toclient);
         REGISTERDATA(this->light_->getDirection(), network::direction::toclient);
+        REGISTERDATA(this->type_, direction::toclient, new NetworkCallback<Light>(this, &Light::changedType));
+        REGISTERDATA(this->light_->getDiffuseColour(), direction::toclient);
+        REGISTERDATA(this->light_->getSpecularColour(), direction::toclient);
+        REGISTERDATA(this->light_->getDirection(), direction::toclient);
+    }

code/trunk/src/orxonox/objects/worldentities/Model.cc

r2087	r2171
61	61	void Model::registerVariables()
62	62	{
63		REGISTERSTRING(this->meshSrc_, ~~network::direction::toclient, new network::~~NetworkCallback<Model>(this, &Model::changedMesh));
64		REGISTERDATA(this->bCastShadows_, ~~network::direction::toclient, new network::~~NetworkCallback<Model>(this, &Model::changedShadows));
	63	REGISTERSTRING(this->meshSrc_, direction::toclient, new NetworkCallback<Model>(this, &Model::changedMesh));
	64	REGISTERDATA(this->bCastShadows_, direction::toclient, new NetworkCallback<Model>(this, &Model::changedShadows));
65	65	}
66	66

code/trunk/src/orxonox/objects/worldentities/MovableEntity.cc

-                      r2087
+                      r2171
     void MovableEntity::registerVariables()
+    {
         REGISTERDATA(this->velocity_.x, network::direction::toclient);
         REGISTERDATA(this->velocity_.y, network::direction::toclient);
         REGISTERDATA(this->velocity_.z, network::direction::toclient);
+        REGISTERDATA(this->velocity_.x, direction::toclient);
+        REGISTERDATA(this->velocity_.y, direction::toclient);
+        REGISTERDATA(this->velocity_.z, direction::toclient);
         REGISTERDATA(this->rotationAxis_.x, network::direction::toclient);
         REGISTERDATA(this->rotationAxis_.y, network::direction::toclient);
         REGISTERDATA(this->rotationAxis_.z, network::direction::toclient);
+        REGISTERDATA(this->rotationAxis_.x, direction::toclient);
+        REGISTERDATA(this->rotationAxis_.y, direction::toclient);
+        REGISTERDATA(this->rotationAxis_.z, direction::toclient);
         REGISTERDATA(this->rotationRate_, network::direction::toclient);
+        REGISTERDATA(this->rotationRate_, direction::toclient);
         REGISTERDATA(this->overwrite_position_,    network::direction::toclient, new network::NetworkCallback<MovableEntity>(this, &MovableEntity::overwritePosition));
         REGISTERDATA(this->overwrite_orientation_, network::direction::toclient, new network::NetworkCallback<MovableEntity>(this, &MovableEntity::overwriteOrientation));
+        REGISTERDATA(this->overwrite_position_,    direction::toclient, new NetworkCallback<MovableEntity>(this, &MovableEntity::overwritePosition));
+        REGISTERDATA(this->overwrite_orientation_, direction::toclient, new NetworkCallback<MovableEntity>(this, &MovableEntity::overwriteOrientation));
+    }

code/trunk/src/orxonox/objects/worldentities/MovableEntity.h

r2087	r2171
38	38	namespace orxonox
39	39	{
40		class _OrxonoxExport MovableEntity : public WorldEntity, public Tickable, public ~~network::~~ClientConnectionListener
	40	class _OrxonoxExport MovableEntity : public WorldEntity, public Tickable, public ClientConnectionListener
41	41	{
42	42	public:

code/trunk/src/orxonox/objects/worldentities/ParticleEmitter.cc

-                      r2087
+                      r2171
 /**
 * @file ParticleInterface.cc
+* @file
 * @brief class to control praticle effects
 */
 …
 #include "tools/ParticleInterface.h"
+#include "util/Exception.h"
 #include "core/CoreIncludes.h"
 #include "core/XMLPort.h"
 …
         RegisterObject(ParticleEmitter);
         assert(this->getScene());
         assert(this->getScene()->getSceneManager());
+        if (!this->getScene() || !this->getScene()->getSceneManager())
+            ThrowException(AbortLoading, "Can't create Camera, no scene or no scene manager given.");
         this->particles_ = 0;
 …
     void ParticleEmitter::registerVariables()
+    {
         REGISTERSTRING(this->source_, network::direction::toclient, new network::NetworkCallback<ParticleEmitter>(this, &ParticleEmitter::sourceChanged));
         REGISTERDATA  (this->LOD_,    network::direction::toclient, new network::NetworkCallback<ParticleEmitter>(this, &ParticleEmitter::LODchanged));
+        REGISTERSTRING(this->source_, direction::toclient, new NetworkCallback<ParticleEmitter>(this, &ParticleEmitter::sourceChanged));
+        REGISTERDATA  (this->LOD_,    direction::toclient, new NetworkCallback<ParticleEmitter>(this, &ParticleEmitter::LODchanged));
+    }

code/trunk/src/orxonox/objects/worldentities/ParticleSpawner.cc

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/src/orxonox/objects/worldentities/ParticleSpawner.h

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/src/orxonox/objects/worldentities/PositionableEntity.cc

-                      r2087
+                      r2171
     void PositionableEntity::registerVariables()
+    {
         REGISTERDATA(this->getPosition().x, network::direction::toclient);
         REGISTERDATA(this->getPosition().y, network::direction::toclient);
         REGISTERDATA(this->getPosition().z, network::direction::toclient);
+        REGISTERDATA(this->getPosition().x, direction::toclient);
+        REGISTERDATA(this->getPosition().y, direction::toclient);
+        REGISTERDATA(this->getPosition().z, direction::toclient);
         REGISTERDATA(this->getOrientation().w, network::direction::toclient);
         REGISTERDATA(this->getOrientation().x, network::direction::toclient);
         REGISTERDATA(this->getOrientation().y, network::direction::toclient);
         REGISTERDATA(this->getOrientation().z, network::direction::toclient);
+        REGISTERDATA(this->getOrientation().w, direction::toclient);
+        REGISTERDATA(this->getOrientation().x, direction::toclient);
+        REGISTERDATA(this->getOrientation().y, direction::toclient);
+        REGISTERDATA(this->getOrientation().z, direction::toclient);
+    }
+}

code/trunk/src/orxonox/objects/worldentities/WorldEntity.cc

-                      r2087
+                      r2171
 #include "core/XMLPort.h"
 #include "util/Convert.h"
+#include "util/Exception.h"
 #include "objects/Scene.h"
 …
     const Vector3 WorldEntity::UP    = Vector3::UNIT_Y;
     WorldEntity::WorldEntity(BaseObject* creator) : BaseObject(creator), network::Synchronisable(creator)
+    WorldEntity::WorldEntity(BaseObject* creator) : BaseObject(creator), Synchronisable(creator)
+    {
         RegisterObject(WorldEntity);
         assert(this->getScene());
         assert(this->getScene()->getRootSceneNode());
+        if (!this->getScene() || !this->getScene()->getRootSceneNode())
+            ThrowException(AbortLoading, "Can't create WorldEntity, no scene or no root-scenenode given.");
         this->node_ = this->getScene()->getRootSceneNode()->createChildSceneNode();
         this->parent_ = 0;
         this->parentID_ = (unsigned int)-1;
+        this->parentID_ = OBJECTID_UNKNOWN;
         this->node_->setPosition(Vector3::ZERO);
 …
     void WorldEntity::registerVariables()
+    {
         REGISTERDATA(this->bActive_,  network::direction::toclient, new network::NetworkCallback<WorldEntity>(this, &WorldEntity::changedActivity));
         REGISTERDATA(this->bVisible_, network::direction::toclient, new network::NetworkCallback<WorldEntity>(this, &WorldEntity::changedVisibility));
+        REGISTERDATA(this->bActive_,  direction::toclient, new NetworkCallback<WorldEntity>(this, &WorldEntity::changedActivity));
+        REGISTERDATA(this->bVisible_, direction::toclient, new NetworkCallback<WorldEntity>(this, &WorldEntity::changedVisibility));
         REGISTERDATA(this->getScale3D().x, network::direction::toclient);
         REGISTERDATA(this->getScale3D().y, network::direction::toclient);
         REGISTERDATA(this->getScale3D().z, network::direction::toclient);
+        REGISTERDATA(this->getScale3D().x, direction::toclient);
+        REGISTERDATA(this->getScale3D().y, direction::toclient);
+        REGISTERDATA(this->getScale3D().z, direction::toclient);
         REGISTERDATA(this->parentID_, network::direction::toclient, new network::NetworkCallback<WorldEntity>(this, &WorldEntity::updateParent));
+        REGISTERDATA(this->parentID_, direction::toclient, new NetworkCallback<WorldEntity>(this, &WorldEntity::updateParent));
+    }
     void WorldEntity::updateParent()
+    {
+        WorldEntity* parent = dynamic_cast<WorldEntity*>(Synchronisable::getSynchronisable(this->parentID_));
+        if (parent)
+            this->attachToParent(parent);
+        if (this->parentID_ != OBJECTID_UNKNOWN)
+        {
+            WorldEntity* parent = dynamic_cast<WorldEntity*>(Synchronisable::getSynchronisable(this->parentID_));
+            if (parent)
+                this->attachToParent(parent);
+        }
+    }
 …
         this->children_.erase(object);
         object->parent_ = 0;
         object->parentID_ = (unsigned int)-1;
+        object->parentID_ = OBJECTID_UNKNOWN;
 //        this->getScene()->getRootSceneNode()->addChild(object->node_);

code/trunk/src/orxonox/objects/worldentities/WorldEntity.h

r2087	r2171
42	42	namespace orxonox
43	43	{
44		class _OrxonoxExport WorldEntity : public BaseObject, public ~~network::~~Synchronisable
	44	class _OrxonoxExport WorldEntity : public BaseObject, public Synchronisable
45	45	{
46	46	public:

code/trunk/src/orxonox/objects/worldentities/pawns/Pawn.cc

r2106	r2171
80	80	void Pawn::registerVariables()
81	81	{
82		REGISTERDATA(this->bAlive_, ~~network::~~direction::toclient);
83		REGISTERDATA(this->health_, ~~network::~~direction::toclient);
	82	REGISTERDATA(this->bAlive_, direction::toclient);
	83	REGISTERDATA(this->health_, direction::toclient);
84	84	}
85	85

code/trunk/src/orxonox/objects/worldentities/pawns/SpaceShip.cc

-                      r2087
+                      r2171
     void SpaceShip::registerVariables()
+    {
         REGISTERDATA(this->maxSpeed_,                network::direction::toclient);
         REGISTERDATA(this->maxSecondarySpeed_,       network::direction::toclient);
         REGISTERDATA(this->maxRotation_,             network::direction::toclient);
         REGISTERDATA(this->translationAcceleration_, network::direction::toclient);
         REGISTERDATA(this->rotationAcceleration_,    network::direction::toclient);
         REGISTERDATA(this->translationDamping_,      network::direction::toclient);
+        REGISTERDATA(this->maxSpeed_,                direction::toclient);
+        REGISTERDATA(this->maxSecondarySpeed_,       direction::toclient);
+        REGISTERDATA(this->maxRotation_,             direction::toclient);
+        REGISTERDATA(this->translationAcceleration_, direction::toclient);
+        REGISTERDATA(this->rotationAcceleration_,    direction::toclient);
+        REGISTERDATA(this->translationDamping_,      direction::toclient);
+    }

code/trunk/src/orxonox/objects/worldentities/pawns/Spectator.cc

-                      r2087
+                      r2171
         this->greetingFlare_ = new BillboardSet();
         this->greetingFlare_->setBillboardSet(this->getScene()->getSceneManager(), "Examples/Flare", ColourValue(1.0, 1.0, 0.8), Vector3(0, 20, 0), 1);
+        this->getNode()->attachObject(this->greetingFlare_->getBillboardSet());
+        if (this->greetingFlare_->getBillboardSet())
+            this->getNode()->attachObject(this->greetingFlare_->getBillboardSet());
         this->greetingFlare_->setVisible(false);
         this->bGreetingFlareVisible_ = false;
 …
             if (this->greetingFlare_)
+            {
+                this->getNode()->detachObject(this->greetingFlare_->getBillboardSet());
+                if (this->greetingFlare_->getBillboardSet())
+                    this->getNode()->detachObject(this->greetingFlare_->getBillboardSet());
                 delete this->greetingFlare_;
+            }
 …
     void Spectator::registerVariables()
+    {
         REGISTERDATA(this->bGreetingFlareVisible_, network::direction::toclient, new network::NetworkCallback<Spectator>(this, &Spectator::changedFlareVisibility));
         REGISTERDATA(this->bGreeting_,             network::direction::toserver, new network::NetworkCallback<Spectator>(this, &Spectator::changedGreeting));
         REGISTERDATA(this->hudmode_,               network::direction::toclient);
+        REGISTERDATA(this->bGreetingFlareVisible_, direction::toclient, new NetworkCallback<Spectator>(this, &Spectator::changedFlareVisibility));
+        REGISTERDATA(this->bGreeting_,             direction::toserver, new NetworkCallback<Spectator>(this, &Spectator::changedGreeting));
+        REGISTERDATA(this->hudmode_,               direction::toclient);
+    }
 …
         ControllableEntity::setPlayer(player);
 //        this->setObjectMode(network::direction::toclient);
+//        this->setObjectMode(direction::toclient);
+    }
 …
+                {
                     if (this->getGametype()->isStartCountdownRunning())
                         this->hudmode_ = 2 + 10*ceil(this->getGametype()->getStartCountdown());
+                        this->hudmode_ = 2 + 10*(int)ceil(this->getGametype()->getStartCountdown());
                     else
                         this->hudmode_ = 3;

code/trunk/src/orxonox/objects/worldentities/triggers/DistanceTrigger.cc

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/src/orxonox/objects/worldentities/triggers/DistanceTrigger.h

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/src/orxonox/objects/worldentities/triggers/Trigger.cc

Property svn:mergeinfo changed
/code/branches/objecthierarchy/src/orxonox/objects/worldentities/triggers/Trigger.cc merged: 2161

-                      r2103
+                      r2171
       this->debugBillboard_.setBillboardSet(this->getScene()->getSceneManager(), "Examples/Flare", ColourValue(1.0, 0.0, 0.0), 1);
       this->debugBillboard_.setVisible(false);
+    }
+    this->getNode()->attachObject(this->debugBillboard_.getBillboardSet());
+      if (this->debugBillboard_.getBillboardSet())
+        this->getNode()->attachObject(this->debugBillboard_.getBillboardSet());
+    }
     this->setObjectMode(0x0);
+  }
 …
   void Trigger::setBillboardColour(const ColourValue& colour)
+  {
     this->debugBillboard_.getBillboardSet()->getBillboard(0)->setColour(colour);
+    this->debugBillboard_.setColour(colour);
+  }

code/trunk/src/orxonox/objects/worldentities/triggers/Trigger.h

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/src/orxonox/overlays/OrxonoxOverlay.cc

-                      r2087
+                      r2171
 #include <OgrePanelOverlayElement.h>
 #include "util/Convert.h"
+#include "util/Exception.h"
 #include "util/String.h"
+#include "core/Core.h"
 #include "core/CoreIncludes.h"
 #include "core/XMLPort.h"
 …
+    {
         RegisterObject(OrxonoxOverlay);
+        if (!Core::showsGraphics())
+            ThrowException(NoGraphics, "Can't create OrxonoxOverlay, graphics engine not initialized");
         // add this overlay to the static map of OrxonoxOverlays

code/trunk/src/orxonox/overlays/hud/ChatOverlay.cc

-                      r2087
+                      r2171
 #include "network/ClientInformation.h"
 #include "LevelManager.h"
+#include "PlayerManager.h"
 #include "objects/infos/PlayerInfo.h"
 #include "overlays/console/InGameConsole.h"
 …
         std::string text;
         if (senderID != network::CLIENTID_UNKNOWN)
+        if (senderID != CLIENTID_UNKNOWN)
+        {
             std::string name = "unknown";
             PlayerInfo* player = LevelManager::getInstance().getClient(senderID);
+            PlayerInfo* player = PlayerManager::getInstance().getClient(senderID);
             if (player)
                 name = player->getName();

code/trunk/src/orxonox/overlays/hud/ChatOverlay.h

r2087	r2171
39	39	namespace orxonox
40	40	{
41		class _OrxonoxExport ChatOverlay : public OverlayText, public ~~network::~~ChatListener
	41	class _OrxonoxExport ChatOverlay : public OverlayText, public ChatListener
42	42	{
43	43	public:

code/trunk/src/orxonox/tools/BillboardSet.cc

-                      r2087
+                      r2171
 #include <OgreBillboard.h>
+#include "core/Core.h"
 #include "util/Convert.h"
 #include "util/String.h"
 …
         try
+        {
+            this->billboardSet_ = scenemanager->createBillboardSet("Billboard" + convertToString(BillboardSet::billboardSetCounter_s++), count);
+            this->billboardSet_->createBillboard(position);
+            this->billboardSet_->setMaterialName(file);
+            if (Core::showsGraphics())
+            {
+                this->billboardSet_ = scenemanager->createBillboardSet("Billboard" + convertToString(BillboardSet::billboardSetCounter_s++), count);
+                this->billboardSet_->createBillboard(position);
+                this->billboardSet_->setMaterialName(file);
+            }
+        }
         catch (...)
+        {
             COUT(1) << "Error: Couln't load billboard \"" << file << "\"" << std::endl;
+            this->billboardSet_ = 0;
+        }
 …
         try
+        {
+            this->billboardSet_ = scenemanager->createBillboardSet("Billboard" + convertToString(BillboardSet::billboardSetCounter_s++), count);
+            this->billboardSet_->createBillboard(position, colour);
+            this->billboardSet_->setMaterialName(file);
+            if (Core::showsGraphics())
+            {
+                this->billboardSet_ = scenemanager->createBillboardSet("Billboard" + convertToString(BillboardSet::billboardSetCounter_s++), count);
+                this->billboardSet_->createBillboard(position, colour);
+                this->billboardSet_->setMaterialName(file);
+            }
+        }
         catch (...)
+        {
             COUT(1) << "Error: Couln't load billboard \"" << file << "\"" << std::endl;
+            this->billboardSet_ = 0;
+        }
 …
         if (this->billboardSet_ && this->scenemanager_)
             this->scenemanager_->destroyBillboardSet(this->billboardSet_);
+        this->billboardSet_ = 0;
+    }

code/trunk/src/orxonox/tools/Mesh.cc

r2087	r2171
73	73	{
74	74	COUT(1) << "Error: Couln't load mesh \"" << meshsource << "\"" << std::endl;
	75	this->entity_ = 0;
75	76	}
76	77	}

code/trunk/src/orxonox/tools/ParticleInterface.cc

-                      r2087
+                      r2171
 /**
 * @file ParticleInterface.cc
+* @file
 * @brief class to control praticle effects
 */
 …
 #include "GraphicsEngine.h"
+#include "core/Core.h"
 #include "core/CoreIncludes.h"
 #include "util/Convert.h"
 …
         this->scenemanager_ = scenemanager;
         this->sceneNode_ = 0;
+        this->particleSystem_ = 0;
         this->bEnabled_ = true;
 …
         this->bAllowedByLOD_ = true;
+        this->particleSystem_ = this->scenemanager_->createParticleSystem("particles" + getConvertedValue<unsigned int, std::string>(ParticleInterface::counter_s++), templateName);
+        this->particleSystem_->setSpeedFactor(1.0f);
+        //this->particleSystem_->setSpeedFactor(Orxonox::getInstance().getTimeFactor());
+        if (Core::showsGraphics())
+        {
+            try
+            {
+                this->particleSystem_ = this->scenemanager_->createParticleSystem("particles" + getConvertedValue<unsigned int, std::string>(ParticleInterface::counter_s++), templateName);
+                this->particleSystem_->setSpeedFactor(1.0f);
+//                this->particleSystem_->setSpeedFactor(Orxonox::getInstance().getTimeFactor());
+            }
+            catch (...)
+            {
+                COUT(1) << "Error: Couln't load particle system \"" << templateName << "\"" << std::endl;
+                this->particleSystem_ = 0;
+            }
+        }
         this->setDetailLevel((unsigned int)detaillevel);
 …
     ParticleInterface::~ParticleInterface()
+    {
+        this->particleSystem_->removeAllEmitters();
+        this->detachFromSceneNode();
+        this->scenemanager_->destroyParticleSystem(particleSystem_);
+        if (this->particleSystem_)
+        {
+            this->particleSystem_->removeAllEmitters();
+            this->detachFromSceneNode();
+            this->scenemanager_->destroyParticleSystem(this->particleSystem_);
+        }
+    }
 …
             this->detachFromSceneNode();
+        this->sceneNode_ = sceneNode;
+        this->sceneNode_->attachObject(this->particleSystem_);
+        if (this->particleSystem_)
+        {
+            this->sceneNode_ = sceneNode;
+            this->sceneNode_->attachObject(this->particleSystem_);
+        }
+    }
 …
         if (this->sceneNode_)
+        {
+            this->sceneNode_->detachObject(this->particleSystem_);
+            if (this->particleSystem_)
+                this->sceneNode_->detachObject(this->particleSystem_);
             this->sceneNode_ = 0;
+        }
 …
     Ogre::ParticleEmitter* ParticleInterface::createNewEmitter()
+    {
         if (this->particleSystem_->getNumEmitters() > 0)
+        if (this->particleSystem_ && this->particleSystem_->getNumEmitters() > 0)
+        {
             Ogre::ParticleEmitter* newemitter = this->particleSystem_->addEmitter(this->particleSystem_->getEmitter(0)->getType());
 …
     Ogre::ParticleEmitter* ParticleInterface::getEmitter(unsigned int emitterNr) const
+    {
         if (emitterNr < this->particleSystem_->getNumEmitters())
+        if (this->particleSystem_ && (emitterNr < this->particleSystem_->getNumEmitters()))
             return this->particleSystem_->getEmitter(emitterNr);
         else
 …
     void ParticleInterface::removeEmitter(unsigned int emitterNr)
+    {
         if (emitterNr < this->particleSystem_->getNumEmitters())
+        if (this->particleSystem_ && (emitterNr < this->particleSystem_->getNumEmitters()))
             this->particleSystem_->removeEmitter(emitterNr);
+    }
     void ParticleInterface::removeAllEmitters()
+    {
+        this->particleSystem_->removeAllEmitters();
+        if (this->particleSystem_)
+            this->particleSystem_->removeAllEmitters();
+    }
     unsigned int ParticleInterface::getNumEmitters() const
+    {
+        return this->particleSystem_->getNumEmitters();
+        if (this->particleSystem_)
+            return this->particleSystem_->getNumEmitters();
+        else
+            return 0;
+    }
     Ogre::ParticleAffector* ParticleInterface::addAffector(const std::string& name)
+    {
+        return this->particleSystem_->addAffector(name);
+        if (this->particleSystem_)
+            return this->particleSystem_->addAffector(name);
+        else
+            return 0;
+    }
     Ogre::ParticleAffector* ParticleInterface::getAffector(unsigned int affectorNr) const
+    {
         if (affectorNr < this->particleSystem_->getNumAffectors())
+        if (this->particleSystem_ && (affectorNr < this->particleSystem_->getNumAffectors()))
             return this->particleSystem_->getAffector(affectorNr);
         else
 …
     void ParticleInterface::removeAffector(unsigned int affectorNr)
+    {
         if (affectorNr < this->particleSystem_->getNumAffectors())
+        if (this->particleSystem_ && (affectorNr < this->particleSystem_->getNumAffectors()))
             this->particleSystem_->removeAffector(affectorNr);
+    }
     void ParticleInterface::removeAllAffectors()
+    {
+        this->particleSystem_->removeAllAffectors();
+        if (this->particleSystem_)
+            this->particleSystem_->removeAllAffectors();
+    }
     unsigned int ParticleInterface::getNumAffectors() const
+    {
+        return this->particleSystem_->getNumAffectors();
+        if (this->particleSystem_)
+            return this->particleSystem_->getNumAffectors();
+        else
+            return 0;
+    }
 …
         this->bEnabled_ = enable;
+        for (unsigned int i = 0; i < this->particleSystem_->getNumEmitters(); i++)
+            this->particleSystem_->getEmitter(i)->setEnabled(this->bEnabled_ && this->bAllowedByLOD_);
+        if (this->particleSystem_)
+            for (unsigned int i = 0; i < this->particleSystem_->getNumEmitters(); i++)
+                this->particleSystem_->getEmitter(i)->setEnabled(this->bEnabled_ && this->bAllowedByLOD_);
+    }
 …
         this->bVisible_ = visible;
+        this->particleSystem_->setVisible(this->bVisible_ && this->bAllowedByLOD_);
+        if (this->particleSystem_)
+            this->particleSystem_->setVisible(this->bVisible_ && this->bAllowedByLOD_);
+    }
 …
+    {
         this->detaillevel_ = level;
+        this->detailLevelChanged(GraphicsEngine::getInstance().getDetailLevelParticle());
+        if (GraphicsEngine::getInstancePtr())
+            this->detailLevelChanged(GraphicsEngine::getInstance().getDetailLevelParticle());
+    }
 …
     void ParticleInterface::setSpeedFactor(float factor)
+    {
+        //this->particleSystem_->setSpeedFactor(Orxonox::getInstance().getTimeFactor() * factor);
+        this->particleSystem_->setSpeedFactor(1.0f * factor);
+        if (this->particleSystem_)
+        {
+//            this->particleSystem_->setSpeedFactor(Orxonox::getInstance().getTimeFactor() * factor);
+            this->particleSystem_->setSpeedFactor(1.0f * factor);
+        }
+    }
     float ParticleInterface::getSpeedFactor() const
+    {
+        //return (this->particleSystem_->getSpeedFactor() / Orxonox::getInstance().getTimeFactor());
+        return (this->particleSystem_->getSpeedFactor() / 1.0f);
+        if (this->particleSystem_)
+        {
+//            return (this->particleSystem_->getSpeedFactor() / Orxonox::getInstance().getTimeFactor());
+            return (this->particleSystem_->getSpeedFactor() / 1.0f);
+        }
+        else
+            return 1.0f;
+    }
     bool ParticleInterface::getKeepParticlesInLocalSpace() const
+    {
+        return this->particleSystem_->getKeepParticlesInLocalSpace();
+        if (this->particleSystem_)
+            return this->particleSystem_->getKeepParticlesInLocalSpace();
+        else
+            return false;
+    }
     void ParticleInterface::setKeepParticlesInLocalSpace(bool keep)
+    {
+        this->particleSystem_->setKeepParticlesInLocalSpace(keep);
+        if (this->particleSystem_)
+            this->particleSystem_->setKeepParticlesInLocalSpace(keep);
+    }
+}

code/trunk/src/orxonox/tools/Timer.h

r2087	r2171
28	28
29	29	/*!
30		@file ~~Timer.h~~
	30	@file
31	31	@brief Definition and Implementation of the Timer class.
32	32

code/trunk/src/tolua/tolua-5.1.pkg

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/src/util

Property svn:mergeinfo changed
/code/branches/objecthierarchy/src/util merged: 2111,2114,2123,2155,2158,2161-2162

code/trunk/src/util/CRC32.cc

-                      r1791
+                      r2171
 #include "CRC32.h"
+namespace orxonox
+{
+    void calcCRCBit(uint32_t &crc32, int bit)
+    {
+        int hbit = (crc32 & 0x80000000) ? 1 : 0;
+        if (hbit != bit)
+            crc32 = (crc32 << 1) ^ UTIL_CRC32POLY;
+        else
+            crc32 = crc32 << 1;
+      }
+void calcCRCBit(uint32_t &crc32, int bit){
+    int hbit;
+    uint32_t calcCRC(unsigned char *data, unsigned int dataLength)
+    {
+        uint32_t crc32 = 0;
+        for(unsigned int i = 0; i < dataLength; i++)
+        {
+            calcCRCBit(crc32, (data[i] & 0x1) >> 0); // 1st bit
+            calcCRCBit(crc32, (data[i] & 0x2) >> 1); // 2nd bit
+            calcCRCBit(crc32, (data[i] & 0x3) >> 2); // 3rd bit
+            calcCRCBit(crc32, (data[i] & 0x4) >> 3); // 4th bit
+            calcCRCBit(crc32, (data[i] & 0x5) >> 4); // 5th bit
+            calcCRCBit(crc32, (data[i] & 0x6) >> 5); // 6th bit
+            calcCRCBit(crc32, (data[i] & 0x7) >> 6); // 7th bit
+            calcCRCBit(crc32, (data[i] & 0x8) >> 7); // 8th bit
+        }
+        return crc32;
+    }
+}
-    hbit=(crc32 & 0x80000000) ? 1 : 0;
-    if (hbit != bit)
-      crc32=(crc32<<1) ^ UTIL_CRC32POLY;
-    else
-      crc32=crc32<<1;
+  }
-  uint32_t calcCRC(unsigned char *data, unsigned int dataLength){
-    uint32_t crc32=0;
-    for(unsigned int i=0; i<dataLength; i++){
-      calcCRCBit(crc32, (data[i]&0x1)>>0); // 1st bit
-      calcCRCBit(crc32, (data[i]&0x2)>>1); // 2nd bit
-      calcCRCBit(crc32, (data[i]&0x3)>>2); // 3rd bit
-      calcCRCBit(crc32, (data[i]&0x4)>>3); // 4th bit
-      calcCRCBit(crc32, (data[i]&0x5)>>4); // 5th bit
-      calcCRCBit(crc32, (data[i]&0x6)>>5); // 6th bit
-      calcCRCBit(crc32, (data[i]&0x7)>>6); // 7th bit
-      calcCRCBit(crc32, (data[i]&0x8)>>7); // 8th bit
+    }
-    return crc32;
+  }

code/trunk/src/util/CRC32.h

-                      r1791
+                      r2171
 #include "Integers.h"
+const unsigned int UTIL_CRC32POLY = 0x04C11DB7; /* CRC-32 Polynom */
+namespace orxonox
+{
+    const unsigned int UTIL_CRC32POLY = 0x04C11DB7; /* CRC-32 Polynom */
 _UtilExport void calcCRCBit(uint32_t &crc32, int bit);
+    _UtilExport void calcCRCBit(uint32_t &crc32, int bit);
 _UtilExport uint32_t calcCRC(unsigned char *data, unsigned int dataLength);
+    _UtilExport uint32_t calcCRC(unsigned char *data, unsigned int dataLength);
+}
 #endif /* _Util_CRC_H__ */

code/trunk/src/util/Clipboard.cc

-                      r1791
+                      r2171
 /**
     @file Clipboard.cc
+    @file
     @brief OS-specific implementations of the clipboard functions.
 */
 …
 #if ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32
+    /////////////
+    // Windows //
+    /////////////
+    #include <windows.h>
+    #include "Debug.h"
+/////////////
+// Windows //
+/////////////
+#include <windows.h>
+#include "Debug.h"
+namespace orxonox
+{
     /**
 …
         return "";
+    }
+#else
+    /////////////
+    // Default //
+    /////////////
+}
+#else /* ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32 */
+/////////////
+// Default //
+/////////////
+namespace orxonox
+{
     std::string clipboard = ""; //!< Keeps the text of our internal clipboard
 …
         return clipboard;
+    }
+#endif
+}
+#endif /* ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32 */

code/trunk/src/util/Clipboard.h

-                      r1791
+                      r2171
 /**
     @file Clipboard.h
+    @file
     @brief Some functions to exchange text between the OS clipboard and Orxonox.
 …
 #include <string>
+_UtilExport bool toClipboard(const std::string& text);
+_UtilExport std::string fromClipboard();
+namespace orxonox
+{
+    _UtilExport bool toClipboard(const std::string& text);
+    _UtilExport std::string fromClipboard();
+}
 #endif /* _Clipboard_H__ */

code/trunk/src/util/Convert.h

-                      r2087
+                      r2171
 #endif
+template <class FromType, class ToType>
+class ImplicitConversion
+{
+private:
+    ImplicitConversion(); ImplicitConversion(const ImplicitConversion&); ~ImplicitConversion();
+    // Gets chosen only if there is an implicit conversion from FromType to ToType.
+    static char test(ToType);
+    // Accepts any argument. Why do we not use a template? The reason is that with templates,
+    // the function above is only taken iff it is an exact type match. But since we want to
+    // check for implicit conversion, we have to use the ellipsis.
+    static long long test(...);
+    static FromType object; // helper object to handle private c'tor and d'tor
+public:
+    // test(object) only has 'long long' return type iff the compiler doesn't choose test(...)
+    enum { exists = (sizeof(test(object)) == sizeof(char)) };
+};
+namespace orxonox
+{
+    template <class FromType, class ToType>
+    class ImplicitConversion
+    {
+    private:
+        ImplicitConversion(); ImplicitConversion(const ImplicitConversion&); ~ImplicitConversion();
+        // Gets chosen only if there is an implicit conversion from FromType to ToType.
+        static char test(ToType);
+        // Accepts any argument. Why do we not use a template? The reason is that with templates,
+        // the function above is only taken iff it is an exact type match. But since we want to
+        // check for implicit conversion, we have to use the ellipsis.
+        static long long test(...);
+        static FromType object; // helper object to handle private c'tor and d'tor
+    public:
+        // test(object) only has 'long long' return type iff the compiler doesn't choose test(...)
+        enum { exists = (sizeof(test(object)) == sizeof(char)) };
+    };
+}
 #if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
 …
 */
+namespace
+{
+    //! Little template that maps integers to entire types (Alexandrescu 2001)
+    template <int I>
+    struct Int2Type { };
+namespace orxonox
+{
+    namespace
+    {
+        //! Little template that maps integers to entire types (Alexandrescu 2001)
+        template <int I>
+        struct Int2Type { };
+    }
+    ///////////////////
+    // No Conversion //
+    ///////////////////
+    // Default template. No conversion available at all.
+    template <class FromType, class ToType>
+    struct ConverterFallback
+    {
+        static bool convert(ToType* output, const FromType& input)
+        {
+            COUT(2) << "Could not convert value of type " << typeid(FromType).name()
+                    << " to type " << typeid(ToType).name() << std::endl;
+            return false;
+        }
+    };
+    // If all else fails, try a dynamic_cast for pointer types.
+    template <class FromType, class ToType>
+    struct ConverterFallback<FromType*, ToType*>
+    {
+        static bool convert(ToType** output, FromType* const input)
+        {
+            ToType* temp = dynamic_cast<ToType*>(input);
+            if (temp)
+            {
+                *output = temp;
+                return true;
+            }
+            else
+                return false;
+        }
+    };
+}
-///////////////////
-// No Conversion //
-///////////////////
-// Default template. No conversion available at all.
-template <class FromType, class ToType>
-struct ConverterFallback
+{
-    static bool convert(ToType* output, const FromType& input)
+    {
-        COUT(2) << "Could not convert value of type " << typeid(FromType).name()
-                << " to type " << typeid(ToType).name() << std::endl;
-        return false;
+    }
-};
-// If all else fails, try a dynamic_cast for pointer types.
-template <class FromType, class ToType>
-struct ConverterFallback<FromType*, ToType*>
+{
-    static bool convert(ToType** output, FromType* const input)
+    {
-        ToType* temp = dynamic_cast<ToType*>(input);
-        if (temp)
+        {
-            *output = temp;
-            return true;
+        }
-        else
-            return false;
+    }
-};
 …
     static bool convert(ToType* output, const FromType& input)
+    {
         return ConverterFallback<FromType, ToType>::convert(output, input);
+        return orxonox::ConverterFallback<FromType, ToType>::convert(output, input);
+    }
 };
 …
+    {
         std::string temp;
         if (ConverterFallback<FromType, std::string>::convert(&temp, input))
+        if (orxonox::ConverterFallback<FromType, std::string>::convert(&temp, input))
+        {
             std::operator <<(outstream, temp);
 …
     inline bool operator >>(std::istream& instream, ToType& output)
+    {
         return ConverterFallback<std::string, ToType>
+        return orxonox::ConverterFallback<std::string, ToType>
             ::convert(&output, static_cast<std::istringstream&>(instream).str());
+    }
 …
 };
+///////////////////
+// Implicit Cast //
+///////////////////
+// implicit cast not possible, try stringstream conversion next
+template <class FromType, class ToType>
+inline bool convertImplicitely(ToType* output, const FromType& input, ::Int2Type<false>)
+{
+    return ConverterStringStream<FromType, ToType>::convert(output, input);
+namespace orxonox
+{
+    ///////////////////
+    // Implicit Cast //
+    ///////////////////
+    // implicit cast not possible, try stringstream conversion next
+    template <class FromType, class ToType>
+    inline bool convertImplicitely(ToType* output, const FromType& input, orxonox::Int2Type<false>)
+    {
+        return ConverterStringStream<FromType, ToType>::convert(output, input);
+    }
+    // We can cast implicitely
+    template <class FromType, class ToType>
+    inline bool convertImplicitely(ToType* output, const FromType& input, orxonox::Int2Type<true>)
+    {
+        (*output) = static_cast<ToType>(input);
+        return true;
+    }
+    ////////////////////////////////
+    // ConverterExplicit Fallback //
+    ////////////////////////////////
+    // Default template if no specialisation is available
+    template <class FromType, class ToType>
+    struct ConverterExplicit
+    {
+        static bool convert(ToType* output, const FromType& input)
+        {
+            // Try implict cast and probe first. If a simple cast is not possible, it will not compile
+            // We therefore have to out source it into another template function
+            const bool probe = ImplicitConversion<FromType, ToType>::exists;
+            return convertImplicitely(output, input, orxonox::Int2Type<probe>());
+        }
+    };
+    //////////////////////
+    // Public Functions //
+    //////////////////////
+    /**
+    @brief
+        Converts any value to any other as long as there exists a conversion.
+        Otherwise, the conversion will generate a runtime warning and return false.
+        For information about the different conversion methods (user defined too), see the section
+        'Actual conversion sequence' in this file above.
+    */
+    template <class FromType, class ToType>
+    inline bool convertValue(ToType* output, const FromType& input)
+    {
+        return ConverterExplicit<FromType, ToType>::convert(output, input);
+    }
+    // For compatibility reasons. The same, but with capital ConvertValue
+    template<class FromType, class ToType>
+    inline bool ConvertValue(ToType* output, const FromType& input)
+    {
+        return convertValue(output, input);
+    }
+    // Calls convertValue and returns true if the conversion was successful.
+    // Otherwise the fallback is used.
+    /**
+    @brief
+        Converts any value to any other as long as there exists a conversion.
+        Otherwise, the conversion will generate a runtime warning and return false.
+        For information about the different conversion methods (user defined too), see the section
+        'Actual conversion sequence' in this file above.
+        If the conversion doesn't succeed, 'fallback' is written to '*output'.
+    @param fallback
+        A default value that gets written to '*output' if there is no conversion.
+    */
+    template<class FromType, class ToType>
+    inline bool convertValue(ToType* output, const FromType& input, const ToType& fallback)
+    {
+        if (convertValue(output, input))
+            return true;
+        else
+        {
+            (*output) = fallback;
+            return false;
+        }
+    }
+    // for compatibility reason. (capital 'c' in ConvertValue)
+    template<class FromType, class ToType>
+    inline bool ConvertValue(ToType* output, const FromType& input, const ToType& fallback)
+    {
+        return convertValue(output, input, fallback);
+    }
+    // Directly returns the converted value, even if the conversion was not successful.
+    template<class FromType, class ToType>
+    inline ToType getConvertedValue(const FromType& input)
+    {
+        ToType output;
+        convertValue(&output, input);
+        return output;
+    }
+    // Directly returns the converted value, but uses the fallback on failure.
+    template<class FromType, class ToType>
+    inline ToType getConvertedValue(const FromType& input, const ToType& fallback)
+    {
+        ToType output;
+        convertValue(&output, input, fallback);
+        return output;
+    }
+    // Like getConvertedValue, but the template argument order is in reverse.
+    // That means you can call it exactly like static_cast<ToType>(fromTypeValue).
+    template<class ToType, class FromType>
+    inline ToType omni_cast(const FromType& input)
+    {
+        ToType output;
+        convertValue(&output, input);
+        return output;
+    }
+    // convert to string Shortcut
+    template <class FromType>
+    inline std::string convertToString(FromType value)
+    {
+      return getConvertedValue<FromType, std::string>(value);
+    }
+    // convert from string Shortcut
+    template <class ToType>
+    inline ToType convertFromString(std::string str)
+    {
+      return getConvertedValue<std::string, ToType>(str);
+    }
+    ////////////////////////////////
+    // Special string conversions //
+    ////////////////////////////////
+    // Delegate conversion from const char* to std::string
+    template <class ToType>
+    struct ConverterExplicit<const char*, ToType>
+    {
+        static bool convert(ToType* output, const char* input)
+        {
+            return convertValue<std::string, ToType>(output, input);
+        }
+    };
+    // These conversions would exhibit ambiguous << or >> operators when using stringstream
+    template <>
+    struct ConverterExplicit<char, std::string>
+    {
+        static bool convert(std::string* output, const char input)
+        {
+            *output = std::string(1, input);
+            return true;
+        }
+    };
+    template <>
+    struct ConverterExplicit<unsigned char, std::string>
+    {
+        static bool convert(std::string* output, const unsigned char input)
+        {
+            *output = std::string(1, input);
+            return true;
+        }
+    };
+    template <>
+    struct ConverterExplicit<std::string, char>
+    {
+        static bool convert(char* output, const std::string input)
+        {
+            if (input != "")
+                *output = input[0];
+            else
+                *output = '\0';
+            return true;
+        }
+    };
+    template <>
+    struct ConverterExplicit<std::string, unsigned char>
+    {
+        static bool convert(unsigned char* output, const std::string input)
+        {
+            if (input != "")
+                *output = input[0];
+            else
+                *output = '\0';
+            return true;
+        }
+    };
+    // bool to std::string
+    template <>
+    struct ConverterExplicit<bool, std::string>
+    {
+        static bool convert(std::string* output, const bool& input)
+        {
+            if (input)
+              *output = "true";
+            else
+              *output = "false";
+            return false;
+        }
+    };
+    // std::string to bool
+    template <>
+    struct ConverterExplicit<std::string, bool>
+    {
+        static bool convert(bool* output, const std::string& input)
+        {
+            std::string stripped = getLowercase(removeTrailingWhitespaces(input));
+            if (stripped == "true" || stripped == "on" || stripped == "yes")
+            {
+              *output = true;
+              return true;
+            }
+            else if (stripped == "false" || stripped == "off" || stripped == "no")
+            {
+              *output = false;
+              return true;
+            }
+            std::istringstream iss(input);
+            if (iss >> (*output))
+                return true;
+            else
+                return false;
+        }
+    };
+}
-// We can cast implicitely
-template <class FromType, class ToType>
-inline bool convertImplicitely(ToType* output, const FromType& input, ::Int2Type<true>)
+{
-    (*output) = static_cast<ToType>(input);
-    return true;
+}
-////////////////////////////////
-// ConverterExplicit Fallback //
-////////////////////////////////
-// Default template if no specialisation is available
-template <class FromType, class ToType>
-struct ConverterExplicit
+{
-    static bool convert(ToType* output, const FromType& input)
+    {
-        // Try implict cast and probe first. If a simple cast is not possible, it will not compile
-        // We therefore have to out source it into another template function
-        const bool probe = ImplicitConversion<FromType, ToType>::exists;
-        return convertImplicitely(output, input, ::Int2Type<probe>());
+    }
-};
-//////////////////////
-// Public Functions //
-//////////////////////
-/**
-@brief
-    Converts any value to any other as long as there exists a conversion.
-    Otherwise, the conversion will generate a runtime warning and return false.
-    For information about the different conversion methods (user defined too), see the section
-    'Actual conversion sequence' in this file above.
-*/
-template <class FromType, class ToType>
-inline bool convertValue(ToType* output, const FromType& input)
+{
-    return ConverterExplicit<FromType, ToType>::convert(output, input);
+}
-// For compatibility reasons. The same, but with capital ConvertValue
-template<class FromType, class ToType>
-inline bool ConvertValue(ToType* output, const FromType& input)
+{
-    return convertValue(output, input);
+}
-// Calls convertValue and returns true if the conversion was successful.
-// Otherwise the fallback is used.
-/**
-@brief
-    Converts any value to any other as long as there exists a conversion.
-    Otherwise, the conversion will generate a runtime warning and return false.
-    For information about the different conversion methods (user defined too), see the section
-    'Actual conversion sequence' in this file above.
-    If the conversion doesn't succeed, 'fallback' is written to '*output'.
-@param fallback
-    A default value that gets written to '*output' if there is no conversion.
-*/
-template<class FromType, class ToType>
-inline bool convertValue(ToType* output, const FromType& input, const ToType& fallback)
+{
-    if (convertValue(output, input))
-        return true;
-    else
+    {
-        (*output) = fallback;
-        return false;
+    }
+}
-// for compatibility reason. (capital 'c' in ConvertValue)
-template<class FromType, class ToType>
-inline bool ConvertValue(ToType* output, const FromType& input, const ToType& fallback)
+{
-    return convertValue(output, input, fallback);
+}
-// Directly returns the converted value, even if the conversion was not successful.
-template<class FromType, class ToType>
-inline ToType getConvertedValue(const FromType& input)
+{
-    ToType output;
-    convertValue(&output, input);
-    return output;
+}
-// Directly returns the converted value, but uses the fallback on failure.
-template<class FromType, class ToType>
-inline ToType getConvertedValue(const FromType& input, const ToType& fallback)
+{
-    ToType output;
-    convertValue(&output, input, fallback);
-    return output;
+}
-// Like getConvertedValue, but the template argument order is in reverse.
-// That means you can call it exactly like static_cast<ToType>(fromTypeValue).
-template<class ToType, class FromType>
-inline ToType omni_cast(const FromType& input)
+{
-    ToType output;
-    convertValue(&output, input);
-    return output;
+}
-// convert to string Shortcut
-template <class FromType>
-inline std::string convertToString(FromType value)
+{
-  return getConvertedValue<FromType, std::string>(value);
+}
-// convert from string Shortcut
-template <class ToType>
-inline ToType convertFromString(std::string str)
+{
-  return getConvertedValue<std::string, ToType>(str);
+}
-////////////////////////////////
-// Special string conversions //
-////////////////////////////////
-// Delegate conversion from const char* to std::string
-template <class ToType>
-struct ConverterExplicit<const char*, ToType>
+{
-    static bool convert(ToType* output, const char* input)
+    {
-        return convertValue<std::string, ToType>(output, input);
+    }
-};
-// These conversions would exhibit ambiguous << or >> operators when using stringstream
-template <>
-struct ConverterExplicit<char, std::string>
+{
-    static bool convert(std::string* output, const char input)
+    {
-        *output = std::string(1, input);
-        return true;
+    }
-};
-template <>
-struct ConverterExplicit<unsigned char, std::string>
+{
-    static bool convert(std::string* output, const unsigned char input)
+    {
-        *output = std::string(1, input);
-        return true;
+    }
-};
-template <>
-struct ConverterExplicit<std::string, char>
+{
-    static bool convert(char* output, const std::string input)
+    {
-        if (input != "")
-            *output = input[0];
-        else
-            *output = '\0';
-        return true;
+    }
-};
-template <>
-struct ConverterExplicit<std::string, unsigned char>
+{
-    static bool convert(unsigned char* output, const std::string input)
+    {
-        if (input != "")
-            *output = input[0];
-        else
-            *output = '\0';
-        return true;
+    }
-};
-// bool to std::string
-template <>
-struct ConverterExplicit<bool, std::string>
+{
-    static bool convert(std::string* output, const bool& input)
+    {
-        if (input)
-          *output = "true";
-        else
-          *output = "false";
-        return false;
+    }
-};
-// std::string to bool
-template <>
-struct ConverterExplicit<std::string, bool>
+{
-    static bool convert(bool* output, const std::string& input)
+    {
-        std::string stripped = getLowercase(removeTrailingWhitespaces(input));
-        if (stripped == "true" || stripped == "on" || stripped == "yes")
+        {
-          *output = true;
-          return true;
+        }
-        else if (stripped == "false" || stripped == "off" || stripped == "no")
+        {
-          *output = false;
-          return true;
+        }
-        std::istringstream iss(input);
-        if (iss >> (*output))
-            return true;
-        else
-            return false;
+    }
-};
 #endif /* _Convert_H__ */

code/trunk/src/util/Debug.h

-                      r2087
+                      r2171
 /**
     @file Debug.h
+    @file
     @brief Handles different output-levels of errors, warnings, infos and debug informations.
 …
 #include "OutputHandler.h"
-/**
-    @brief Returns the soft debug level, stored in the only existing instance of the OutputHandler class, configured in the config-file.
-    @return The soft debug level
-*/
-static inline int getSoftDebugLevel()
+{
-    return orxonox::OutputHandler::getSoftDebugLevel();
+}
 namespace orxonox
+{
+    /**
+        @brief Returns the soft debug level, stored in the only existing instance of the OutputHandler class, configured in the config-file.
+        @return The soft debug level
+    */
+    static inline int getSoftDebugLevel()
+    {
+        return OutputHandler::getSoftDebugLevel();
+    }
     using std::endl;
+}
 …
   #if ORX_HARD_DEBUG_LEVEL >= ORX_NONE
    #define COUT0 \
     (getSoftDebugLevel() < ORX_NONE) ? COUT_EXEC(0) : COUT_EXEC(0)
+   (orxonox::getSoftDebugLevel() < ORX_NONE) ? COUT_EXEC(0) : COUT_EXEC(0)
   #else
    #define COUT0 \
 …
   #if ORX_HARD_DEBUG_LEVEL >= ORX_ERROR
    #define COUT1 \
     (getSoftDebugLevel() < ORX_ERROR) ? COUT_EXEC(1) : COUT_EXEC(1)
+    (orxonox::getSoftDebugLevel() < ORX_ERROR) ? COUT_EXEC(1) : COUT_EXEC(1)
   #else
    #define COUT1 \
 …
   #if ORX_HARD_DEBUG_LEVEL >= ORX_WARNING
    #define COUT2 \
     (getSoftDebugLevel() < ORX_WARNING) ? COUT_EXEC(2) : COUT_EXEC(2)
+    (orxonox::getSoftDebugLevel() < ORX_WARNING) ? COUT_EXEC(2) : COUT_EXEC(2)
   #else
    #define COUT2 \
 …
   #if ORX_HARD_DEBUG_LEVEL >= ORX_INFO
    #define COUT3 \
     (getSoftDebugLevel() < ORX_INFO) ? COUT_EXEC(3) : COUT_EXEC(3)
+    (orxonox::getSoftDebugLevel() < ORX_INFO) ? COUT_EXEC(3) : COUT_EXEC(3)
   #else
    #define COUT3 \
 …
   #if ORX_HARD_DEBUG_LEVEL >= ORX_DEBUG
    #define COUT4 \
     (getSoftDebugLevel() < ORX_DEBUG) ? COUT_EXEC(4) : COUT_EXEC(4)
+    (orxonox::getSoftDebugLevel() < ORX_DEBUG) ? COUT_EXEC(4) : COUT_EXEC(4)
   #else
    #define COUT4 \
 …
   #if ORX_HARD_DEBUG_LEVEL >= ORX_VERBOSE
    #define COUT5 \
     (getSoftDebugLevel() < ORX_VERBOSE) ? COUT_EXEC(5) : COUT_EXEC(5)
+    (orxonox::getSoftDebugLevel() < ORX_VERBOSE) ? COUT_EXEC(5) : COUT_EXEC(5)
   #else
    #define COUT5 \
 …
   #if ORX_HARD_DEBUG_LEVEL >= ORX_ULTRA
    #define COUT6 \
     (getSoftDebugLevel() < ORX_ULTRA) ? COUT_EXEC(6) : COUT_EXEC(6)
+    (orxonox::getSoftDebugLevel() < ORX_ULTRA) ? COUT_EXEC(6) : COUT_EXEC(6)
   #else
    #define COUT6 \
 …
   #if ORX_HARD_DEBUG_LEVEL >= ORX_NONE
    #define CCOUT0 \
     (getSoftDebugLevel() < ORX_NONE) ? COUT_EXEC(0) : CCOUT_EXEC(0)
+    (orxonox::getSoftDebugLevel() < ORX_NONE) ? COUT_EXEC(0) : CCOUT_EXEC(0)
   #else
    #define CCOUT0 \
 …
   #if ORX_HARD_DEBUG_LEVEL >= ORX_ERROR
    #define CCOUT1 \
     (getSoftDebugLevel() < ORX_ERROR) ? COUT_EXEC(1) : CCOUT_EXEC(1)
+    (orxonox::getSoftDebugLevel() < ORX_ERROR) ? COUT_EXEC(1) : CCOUT_EXEC(1)
   #else
    #define CCOUT1 \
 …
   #if ORX_HARD_DEBUG_LEVEL >= ORX_WARNING
    #define CCOUT2 \
     (getSoftDebugLevel() < ORX_WARNING) ? COUT_EXEC(2) : CCOUT_EXEC(2)
+    (orxonox::getSoftDebugLevel() < ORX_WARNING) ? COUT_EXEC(2) : CCOUT_EXEC(2)
   #else
    #define CCOUT2 \
 …
   #if ORX_HARD_DEBUG_LEVEL >= ORX_INFO
    #define CCOUT3 \
     (getSoftDebugLevel() < ORX_INFO) ? COUT_EXEC(3) : CCOUT_EXEC(3)
+    (orxonox::getSoftDebugLevel() < ORX_INFO) ? COUT_EXEC(3) : CCOUT_EXEC(3)
   #else
    #define CCOUT3 \
 …
   #if ORX_HARD_DEBUG_LEVEL >= ORX_DEBUG
    #define CCOUT4 \
     (getSoftDebugLevel() < ORX_DEBUG) ? COUT_EXEC(4) : CCOUT_EXEC(4)
+    (orxonox::getSoftDebugLevel() < ORX_DEBUG) ? COUT_EXEC(4) : CCOUT_EXEC(4)
   #else
    #define CCOUT4 \
 …
   #if ORX_HARD_DEBUG_LEVEL >= ORX_VERBOSE
    #define CCOUT5 \
     (getSoftDebugLevel() < ORX_VERBOSE) ? COUT_EXEC(5) : CCOUT_EXEC(5)
+    (orxonox::getSoftDebugLevel() < ORX_VERBOSE) ? COUT_EXEC(5) : CCOUT_EXEC(5)
   #else
    #define CCOUT5 \
 …
   #if ORX_HARD_DEBUG_LEVEL >= ORX_ULTRA
    #define CCOUT6 \
     (getSoftDebugLevel() < ORX_ULTRA) ? COUT_EXEC(6) : CCOUT_EXEC(6)
+    (orxonox::getSoftDebugLevel() < ORX_ULTRA) ? COUT_EXEC(6) : CCOUT_EXEC(6)
   #else
    #define CCOUT6 \

code/trunk/src/util/Exception.cc

Property svn:mergeinfo changed
/code/branches/objecthierarchy/src/util/Exception.cc merged: 2111

r2103	r2171
81	81	return fullDescription_;
82	82	}
83
84
85	83	}

code/trunk/src/util/Exception.h

Property svn:mergeinfo changed
/code/branches/objecthierarchy/src/util/Exception.h merged: 2111,2161-2162

-                      r2103
+                      r2171
 #include "Debug.h"
-// Define some ugly macros to make things more clear
-#define CREATE_ORXONOX_EXCEPTION(name) typedef SpecificException<Exception::name> name##Exception;
-#define RETURN_EXCEPTION_CODE(name) \
-    case Exception::name:           \
-        return #name;
 namespace orxonox
+{
 …
+    {
     public:
-        enum ExceptionType
+        {
-            General,
-            FileNotFound,
-            Argument,
-            PluginsNotFound,
-            InitialisationFailed,
-            NotImplemented,
-            GameState
-        };
         Exception(const std::string& description, int lineNumber,
 …
         virtual const std::string& getFullDescription() const;
-        virtual ExceptionType      getType()            const = 0;
         virtual std::string        getTypeName()        const = 0;
         virtual const std::string& getDescription()     const { return this->description_; }
 …
+    template <Exception::ExceptionType Type>
+    class SpecificException : public Exception
+    {
+    public:
+        SpecificException(const std::string& description, int lineNumber,
+                  const char* filename, const char* functionName)
+                  : Exception(description, lineNumber, filename, functionName)
+        {
+            // let the catcher decide whether to display the message below level 4
+            COUT(4) << this->getFullDescription() << std::endl;
+        }
+        SpecificException(const std::string& description)
+            : Exception(description)
+        {
+            // let the catcher decide whether to display the message below level 4
+            COUT(4) << this->getFullDescription() << std::endl;
+        }
+        ~SpecificException() throw() { }
+        ExceptionType getType() const { return Type; }
+        std::string getTypeName() const
+        {
+            // note: break is not necessary due to the return in the macros.
+            switch (Type)
+            {
+            RETURN_EXCEPTION_CODE(General)
+            RETURN_EXCEPTION_CODE(FileNotFound);
+            RETURN_EXCEPTION_CODE(Argument);
+            RETURN_EXCEPTION_CODE(PluginsNotFound);
+            RETURN_EXCEPTION_CODE(InitialisationFailed);
+            RETURN_EXCEPTION_CODE(NotImplemented);
+            RETURN_EXCEPTION_CODE(GameState);
+            default:
+                return "";
+            }
+        }
+#define CREATE_ORXONOX_EXCEPTION(ExceptionName)                                     \
+    class ExceptionName##Exception : public Exception                               \
+    {                                                                               \
+    public:                                                                         \
+        ExceptionName##Exception(const std::string& description, int lineNumber,    \
+                  const char* filename, const char* functionName)                   \
+                  : Exception(description, lineNumber, filename, functionName)      \
+        {                                                                           \
+            /* Let the catcher decide whether to display the message below level 4  \
+               Note: Don't place this code in Exception c'tor because getTypeName() \
+               is still pure virtual at that time. */                               \
+            COUT(4) << this->getFullDescription() << std::endl;                     \
+        }                                                                           \
+                                                                                    \
+        ExceptionName##Exception(const std::string& description)                    \
+                  : Exception(description)                                          \
+        { COUT(4) << this->getFullDescription() << std::endl; }                     \
+                                                                                    \
+        ~ExceptionName##Exception() throw() { }                                     \
+                                                                                    \
+        std::string getTypeName() const { return #ExceptionName; }                  \
     };
+    // define the template spcialisations
+    // Creates all possible exception types.
+    // If you want to add a new type, simply copy and adjust a new line here.
     CREATE_ORXONOX_EXCEPTION(General);
     CREATE_ORXONOX_EXCEPTION(FileNotFound);
 …
     CREATE_ORXONOX_EXCEPTION(NotImplemented);
     CREATE_ORXONOX_EXCEPTION(GameState);
+    CREATE_ORXONOX_EXCEPTION(NoGraphics);
+    CREATE_ORXONOX_EXCEPTION(AbortLoading);
+}
 #define ThrowException(type, description) \
     throw SpecificException<Exception::type>(description, __LINE__, __FILE__, __FUNCTIONNAME__)
+#define ThrowException(Type, Description) \
+    throw Type##Exception(Description, __LINE__, __FILE__, __FUNCTIONNAME__)
     // define an assert macro that can display a message
 #ifndef NDEBUG
 #define OrxAssert(assertion, errorMessage) \
     assertion ? ((void)0) : (void)(orxonox::OutputHandler::getOutStream().setOutputLevel(ORX_ERROR) << errorMessage << std::endl); \
     assert(assertion)
+#define OrxAssert(Assertion, ErrorMessage) \
+    Assertion ? ((void)0) : (void)(orxonox::OutputHandler::getOutStream().setOutputLevel(ORX_ERROR) << ErrorMessage << std::endl); \
+    assert(Assertion)
 #else
 #define OrxAssert(condition, errorMessage)  ((void)0)
 #endif
+}
 #endif /* _Exception_H__ */

code/trunk/src/util/ExprParser.cc

-                      r1894
+                      r2171
 #define PARSE_BLANKS while (*reading_stream == ' ') ++reading_stream
+ExprParser::ExprParser(const std::string& str)
+namespace orxonox
+{
+    this->failed_ = false;
+    this->reading_stream = str.c_str();
+    if (str.size() == 0 || *reading_stream == '\0')
+    {
+        this->failed_ = true;
+        this->result_ = 0.0;
+    }
+    else
+    {
+        this->result_ = parse_expr_8();
+        this->remains_ = reading_stream;
+    ExprParser::ExprParser(const std::string& str)
+    {
+        this->failed_ = false;
+        this->reading_stream = str.c_str();
+        if (str.size() == 0 || *reading_stream == '\0')
+        {
+            this->failed_ = true;
+            this->result_ = 0.0;
+        }
+        else
+        {
+            this->result_ = parse_expr_8();
+            this->remains_ = reading_stream;
+        }
+    }
+    //Private functions:
+    /******************/
+    double ExprParser::parse_argument()
+    {
+        double value = parse_expr_8();
+        if (*reading_stream == ',')
+        {
+            ++reading_stream;
+            return value;
+        }
+        else
+        {
+            this->failed_ = true;
+            return 0;
+        }
+    }
+    double ExprParser::parse_last_argument()
+    {
+        double value = parse_expr_8();
+        if (*reading_stream == ')')
+        {
+            ++reading_stream;
+            return value;
+        }
+        else
+        {
+            this->failed_ = true;
+            return 0;
+        }
+    }
+    double ExprParser::parse_expr_8()
+    {
+        double value = parse_expr_7();
+        for(;;)
+        {
+            switch (op)
+            {
+            case oder:
+                value = parse_expr_7() || value;
+                break;
+            default: return value;
+            }
+        };
+    }
+    double ExprParser::parse_expr_7()
+    {
+        double value = parse_expr_6();
+        for(;;)
+        {
+            switch (op)
+            {
+            case und:
+                value = value && parse_expr_6();
+                break;
+            default: return value;
+            }
+        };
+    }
+    double ExprParser::parse_expr_6()
+    {
+        double value = parse_expr_5();
+        for(;;)
+        {
+            switch (op)
+            {
+            case gleich:
+                value = (value == parse_expr_5());
+                break;
+            case ungleich:
+                value = (value != parse_expr_5());
+                break;
+            default:
+                return value;
+            }
+        };
+    }
+    double ExprParser::parse_expr_5()
+    {
+        double value = parse_expr_4();
+        for(;;)
+        {
+            switch (op)
+            {
+            case kleiner:
+                value = (value < parse_expr_4());
+                break;
+            case kleinergleich:
+                value = (value <= parse_expr_4());
+                break;
+            case groesser:
+                value = (value > parse_expr_4());
+                break;
+            case groessergleich:
+                value = (value >= parse_expr_4());
+                break;
+            default:
+                return value;
+            }
+        };
+    }
+    double ExprParser::parse_expr_4()
+    {
+        double value = parse_expr_3();
+        for(;;)
+        {
+            switch (op)
+            {
+            case b_plus:
+                value += parse_expr_3();
+                break;
+            case b_minus:
+                value -= parse_expr_3();
+                break;
+            default:
+                return value;
+            }
+        };
+    }
+    double ExprParser::parse_expr_3()
+    {
+        double value = parse_expr_2();
+        for(;;)
+        {
+            switch (op)
+            {
+            case mal:
+                value *= parse_expr_2();
+                break;
+            case durch:
+                value /= parse_expr_2();
+                break;
+            case modulo:
+                {
+                    double temp = parse_expr_2();
+                    value = value - floor(value/temp)*temp;
+                    break;
+                }
+            default:
+                return value;
+            }
+        };
+    }
+    double ExprParser::parse_expr_2()
+    {
+        double value = parse_expr_1();
+        while (*reading_stream != '\0')
+        {
+            op = parse_binary_operator();
+            switch (op)
+            {
+            case hoch:
+                value = pow(value,parse_expr_1());
+                break;
+            default:
+                return value;
+            }
+        };
+        op = undef;
+        return value;
+    }
+    double ExprParser::parse_expr_1()
+    {
+        PARSE_BLANKS;
+        double value;
+        unary_operator op = parse_unary_operator();
+        PARSE_BLANKS;
+        if (*reading_stream == '\0')
+        {
+            // end of string
+            this->failed_ = true;
+            return 0;
+        }
+        else if (*reading_stream > 47 && *reading_stream < 59 || *reading_stream == 46)
+        {  // number
+            value = strtod(reading_stream, const_cast<char**>(&reading_stream));
+        }
+        else if (*reading_stream > 64 && *reading_stream < 91 || *reading_stream > 96 && *reading_stream < 123 || *reading_stream == 46)
+        {  // variable or function
+            char* word = new char[256];
+            parse_word(word);
+            PARSE_BLANKS;
+            if (*reading_stream == '(')
+            {
+                ++reading_stream;
+#define SWITCH word
+                CASE_1("sin")
+                    value = sin(parse_last_argument());
+                CASE("asin")
+                    value = asin(parse_last_argument());
+                CASE("sinh")
+                    value = sinh(parse_last_argument());
+                CASE("asinh")
+                {
+                    value = parse_last_argument();
+                    value = log(sqrt(pow(value, 2) + 1) + value);
+                }
+                CASE("cos")
+                    value = cos(parse_last_argument());
+                CASE("acos")
+                    value = acos(parse_last_argument());
+                CASE("cosh")
+                    value = cosh(parse_last_argument());
+                CASE("acosh")
+                {
+                    value = parse_last_argument();
+                    value = log(sqrt(pow(value, 2) - 1) + value);
+                }
+                CASE("tan")
+                    value = tan(parse_last_argument());
+                CASE("atan")
+                    value = atan(parse_last_argument());
+                CASE("atan2")
+                    value = atan2(parse_argument(),parse_last_argument());
+                CASE("tanh")
+                    value = tanh(parse_last_argument());
+                CASE("atanh")
+                {
+                    value = parse_last_argument();
+                    value = 0.5*log((value + 1)/(value - 1));
+                }
+                CASE("int")
+                    value = floor(parse_last_argument());
+                CASE("floor")
+                    value = floor(parse_last_argument());
+                CASE("ceil")
+                    value = ceil(parse_last_argument());
+                CASE("abs")
+                    value = fabs(parse_last_argument());
+                CASE("exp")
+                    value = exp(parse_last_argument());
+                CASE("log")
+                    value = log10(parse_last_argument());
+                CASE("ln")
+                    value = log(parse_last_argument());
+                CASE("sign")
+                {
+                    value = parse_last_argument();
+                    value = (value>0 ? 1 : (value<0 ? -1 : 0));
+                }
+                CASE("sqrt")
+                    value = sqrt(parse_last_argument());
+                CASE("degrees")
+                    value = parse_last_argument()*180/3.1415926535897932;
+                CASE("radians")
+                    value = parse_last_argument()*3.1415926535897932/180;
+                CASE("mod")
+                {
+                    value = parse_argument();
+                    double value2 = parse_last_argument();
+                    value = value - floor(value/value2)*value2;
+                }
+                CASE("pow")
+                    value = pow(parse_argument(),parse_last_argument());
+                CASE("div")
+                    value = floor(parse_argument()/parse_last_argument());
+                CASE("max")
+                    value = std::max(parse_argument(),parse_last_argument());
+                CASE("min")
+                    value = std::min(parse_argument(),parse_last_argument());
+                CASE_ELSE
+                {
+                    this->failed_ = true;
+                    delete[] word;
+                    return 0;
+                }
+            }
+            else
+            {
+#define SWITCH word
+                CASE_1("pi")
+                    value = 3.1415926535897932;
+                CASE("e")
+                    value = 2.7182818284590452;
+                CASE_ELSE
+                {
+                    this->failed_ = true;
+                    delete[] word;
+                    return 0;
+                }
+            }
+            delete[] word;
+        }
+        else if (*reading_stream == 40)
+        {  // expresion in paranthesis
+            ++reading_stream;
+            value = parse_last_argument();
+        }
+        else
+        {
+            this->failed_ = true;
+            return 0;
+        }
+        PARSE_BLANKS;
+        switch (op)
+        {
+        case u_nicht: return !value;
+        case u_plus:  return  value;
+        case u_minus: return -value;
+        default:
+            this->failed_ = true;
+            return 0;
+        }
+    }
+    char* ExprParser::parse_word(char* str)
+    {
+        char* word = str;
+        int counter = 0;
+        while (*reading_stream > 47 && *reading_stream < 58 || *reading_stream > 64 && *reading_stream < 91 || *reading_stream > 96 && *reading_stream < 123 || *reading_stream == 46)
+        {
+            *word++ = *reading_stream++;
+            counter++;
+            if (counter > 255)
+            {
+                this->failed_ = true;
+                return '\0';
+            }
+        };
+        *word = '\0';
+        return str;
+    }
+    ExprParser::binary_operator ExprParser::parse_binary_operator()
+    {
+        binary_operator op;
+        switch (*reading_stream)
+        {
+        case '+': op = b_plus; break;
+        case '-': op = b_minus; break;
+        case '*': op = mal; break;
+        case '/': op = durch; break;
+        case '^': op = hoch; break;
+        case '%': op = modulo; break;
+        case '&': op = und; break;
+        case '|': op = oder; break;
+        case '=': op = gleich; break;
+        case '!': op = b_nicht; break;
+        case '<': op = kleiner; break;
+        case '>': op = groesser; break;
+        default: return undef;
+        }
+        if (*++reading_stream == '=')
+        {
+            if (op > 9)
+            {
+                ++reading_stream;
+                return (binary_operator)(op + 3);
+            }
+            else
+            {
+                --reading_stream;
+                return undef;
+            }
+        }
+        else
+            return op;
+    }
+    ExprParser::unary_operator ExprParser::parse_unary_operator()
+    {
+        switch (*reading_stream)
+        {
+        case '!':
+            ++reading_stream;
+            return u_nicht;
+        case '+':
+            ++reading_stream;
+            return u_plus;
+        case '-':
+            ++reading_stream;
+            return u_minus;
+        default :
+            return u_plus;
+        }
+    }
+}
-//Private functions:
-/******************/
-double ExprParser::parse_argument()
+{
-    double value = parse_expr_8();
-    if (*reading_stream == ',')
+    {
-        ++reading_stream;
-        return value;
+    }
-    else
+    {
-        this->failed_ = true;
-        return 0;
+    }
+}
-double ExprParser::parse_last_argument()
+{
-    double value = parse_expr_8();
-    if (*reading_stream == ')')
+    {
-        ++reading_stream;
-        return value;
+    }
-    else
+    {
-        this->failed_ = true;
-        return 0;
+    }
+}
-double ExprParser::parse_expr_8()
+{
-    double value = parse_expr_7();
-    for(;;)
+    {
-        switch (op)
+        {
-        case oder:
-            value = parse_expr_7() || value;
-            break;
-        default: return value;
+        }
-    };
+}
-double ExprParser::parse_expr_7()
+{
-    double value = parse_expr_6();
-    for(;;)
+    {
-        switch (op)
+        {
-        case und:
-            value = value && parse_expr_6();
-            break;
-        default: return value;
+        }
-    };
+}
-double ExprParser::parse_expr_6()
+{
-    double value = parse_expr_5();
-    for(;;)
+    {
-        switch (op)
+        {
-        case gleich:
-            value = (value == parse_expr_5());
-            break;
-        case ungleich:
-            value = (value != parse_expr_5());
-            break;
-        default:
-            return value;
+        }
-    };
+}
-double ExprParser::parse_expr_5()
+{
-    double value = parse_expr_4();
-    for(;;)
+    {
-        switch (op)
+        {
-        case kleiner:
-            value = (value < parse_expr_4());
-            break;
-        case kleinergleich:
-            value = (value <= parse_expr_4());
-            break;
-        case groesser:
-            value = (value > parse_expr_4());
-            break;
-        case groessergleich:
-            value = (value >= parse_expr_4());
-            break;
-        default:
-            return value;
+        }
-    };
+}
-double ExprParser::parse_expr_4()
+{
-    double value = parse_expr_3();
-    for(;;)
+    {
-        switch (op)
+        {
-        case b_plus:
-            value += parse_expr_3();
-            break;
-        case b_minus:
-            value -= parse_expr_3();
-            break;
-        default:
-            return value;
+        }
-    };
+}
-double ExprParser::parse_expr_3()
+{
-    double value = parse_expr_2();
-    for(;;)
+    {
-        switch (op)
+        {
-        case mal:
-            value *= parse_expr_2();
-            break;
-        case durch:
-            value /= parse_expr_2();
-            break;
-        case modulo:
+            {
-                double temp = parse_expr_2();
-                value = value - floor(value/temp)*temp;
-                break;
+            }
-        default:
-            return value;
+        }
-    };
+}
-double ExprParser::parse_expr_2()
+{
-    double value = parse_expr_1();
-    while (*reading_stream != '\0')
+    {
-        op = parse_binary_operator();
-        switch (op)
+        {
-        case hoch:
-            value = pow(value,parse_expr_1());
-            break;
-        default:
-            return value;
+        }
-    };
-    op = undef;
-    return value;
+}
-double ExprParser::parse_expr_1()
+{
-    PARSE_BLANKS;
-    double value;
-    unary_operator op = parse_unary_operator();
-    PARSE_BLANKS;
-    if (*reading_stream == '\0')
+    {
-        // end of string
-        this->failed_ = true;
-        return 0;
+    }
-    else if (*reading_stream > 47 && *reading_stream < 59 || *reading_stream == 46)
-    {  // number
-        value = strtod(reading_stream, const_cast<char**>(&reading_stream));
+    }
-    else if (*reading_stream > 64 && *reading_stream < 91 || *reading_stream > 96 && *reading_stream < 123 || *reading_stream == 46)
-    {  // variable or function
-        char* word = new char[256];
-        parse_word(word);
-        PARSE_BLANKS;
-        if (*reading_stream == '(')
+        {
-            ++reading_stream;
-#define SWITCH word
-            CASE_1("sin")
-                value = sin(parse_last_argument());
-            CASE("asin")
-                value = asin(parse_last_argument());
-            CASE("sinh")
-                value = sinh(parse_last_argument());
-            CASE("asinh")
+            {
-                value = parse_last_argument();
-                value = log(sqrt(pow(value, 2) + 1) + value);
+            }
-            CASE("cos")
-                value = cos(parse_last_argument());
-            CASE("acos")
-                value = acos(parse_last_argument());
-            CASE("cosh")
-                value = cosh(parse_last_argument());
-            CASE("acosh")
+            {
-                value = parse_last_argument();
-                value = log(sqrt(pow(value, 2) - 1) + value);
+            }
-            CASE("tan")
-                value = tan(parse_last_argument());
-            CASE("atan")
-                value = atan(parse_last_argument());
-            CASE("atan2")
-                value = atan2(parse_argument(),parse_last_argument());
-            CASE("tanh")
-                value = tanh(parse_last_argument());
-            CASE("atanh")
+            {
-                value = parse_last_argument();
-                value = 0.5*log((value + 1)/(value - 1));
+            }
-            CASE("int")
-                value = floor(parse_last_argument());
-            CASE("floor")
-                value = floor(parse_last_argument());
-            CASE("ceil")
-                value = ceil(parse_last_argument());
-            CASE("abs")
-                value = fabs(parse_last_argument());
-            CASE("exp")
-                value = exp(parse_last_argument());
-            CASE("log")
-                value = log10(parse_last_argument());
-            CASE("ln")
-                value = log(parse_last_argument());
-            CASE("sign")
+            {
-                value = parse_last_argument();
-                value = (value>0 ? 1 : (value<0 ? -1 : 0));
+            }
-            CASE("sqrt")
-                value = sqrt(parse_last_argument());
-            CASE("degrees")
-                value = parse_last_argument()*180/3.1415926535897932;
-            CASE("radians")
-                value = parse_last_argument()*3.1415926535897932/180;
-            CASE("mod")
+            {
-                value = parse_argument();
-                double value2 = parse_last_argument();
-                value = value - floor(value/value2)*value2;
+            }
-            CASE("pow")
-                value = pow(parse_argument(),parse_last_argument());
-            CASE("div")
-                value = floor(parse_argument()/parse_last_argument());
-            CASE("max")
-                value = std::max(parse_argument(),parse_last_argument());
-            CASE("min")
-                value = std::min(parse_argument(),parse_last_argument());
-            CASE_ELSE
+            {
-                this->failed_ = true;
-                delete[] word;
-                return 0;
+            }
+        }
-        else
+        {
-#define SWITCH word
-            CASE_1("pi")
-                value = 3.1415926535897932;
-            CASE("e")
-                value = 2.7182818284590452;
-            CASE_ELSE
+            {
-                this->failed_ = true;
-                delete[] word;
-                return 0;
+            }
+        }
-        delete[] word;
+    }
-    else if (*reading_stream == 40)
-    {  // expresion in paranthesis
-        ++reading_stream;
-        value = parse_last_argument();
+    }
-    else
+    {
-        this->failed_ = true;
-        return 0;
+    }
-    PARSE_BLANKS;
-    switch (op)
+    {
-    case u_nicht: return !value;
-    case u_plus:  return  value;
-    case u_minus: return -value;
-    default:
-        this->failed_ = true;
-        return 0;
+    }
+}
-char* ExprParser::parse_word(char* str)
+{
-    char* word = str;
-    int counter = 0;
-    while (*reading_stream > 47 && *reading_stream < 58 || *reading_stream > 64 && *reading_stream < 91 || *reading_stream > 96 && *reading_stream < 123 || *reading_stream == 46)
+    {
-        *word++ = *reading_stream++;
-        counter++;
-        if (counter > 255)
+        {
-            this->failed_ = true;
-            return '\0';
+        }
-    };
-    *word = '\0';
-    return str;
+}
-ExprParser::binary_operator ExprParser::parse_binary_operator()
+{
-    binary_operator op;
-    switch (*reading_stream)
+    {
-    case '+': op = b_plus; break;
-    case '-': op = b_minus; break;
-    case '*': op = mal; break;
-    case '/': op = durch; break;
-    case '^': op = hoch; break;
-    case '%': op = modulo; break;
-    case '&': op = und; break;
-    case '|': op = oder; break;
-    case '=': op = gleich; break;
-    case '!': op = b_nicht; break;
-    case '<': op = kleiner; break;
-    case '>': op = groesser; break;
-    default: return undef;
+    }
-    if (*++reading_stream == '=')
+    {
-        if (op > 9)
+        {
-            ++reading_stream;
-            return (binary_operator)(op + 3);
+        }
-        else
+        {
-            --reading_stream;
-            return undef;
+        }
+    }
-    else
-        return op;
+}
-ExprParser::unary_operator ExprParser::parse_unary_operator()
+{
-    switch (*reading_stream)
+    {
-    case '!':
-        ++reading_stream;
-        return u_nicht;
-    case '+':
-        ++reading_stream;
-        return u_plus;
-    case '-':
-        ++reading_stream;
-        return u_minus;
-    default :
-        return u_plus;
+    }
+}

code/trunk/src/util/ExprParser.h

-                      r1894
+                      r2171
 #include <string>
+class _UtilExport ExprParser
+namespace orxonox
+{
+public:
+    enum binary_operator
+    class _UtilExport ExprParser
+    {
+        b_plus,
+        b_minus,
+        mal,
+        durch,
+        modulo,
+        hoch,
+        undef,
+        oder,
+        und,
+        gleich,
+        b_nicht,
+        kleiner,
+        groesser,
+        ungleich,
+        kleinergleich,
+        groessergleich
+    public:
+        enum binary_operator
+        {
+            b_plus,
+            b_minus,
+            mal,
+            durch,
+            modulo,
+            hoch,
+            undef,
+            oder,
+            und,
+            gleich,
+            b_nicht,
+            kleiner,
+            groesser,
+            ungleich,
+            kleinergleich,
+            groessergleich
+        };
+        enum unary_operator
+        {
+            u_plus,
+            u_minus,
+            u_nicht
+        };
+        ExprParser(const std::string& str);
+        std::string& getRemains() { return  this->remains_; }
+        double       getResult()  { return  this->result_; }
+        bool         getSuccess() { return !this->failed_; }
+    private:
+        double parse_expr_1();
+        double parse_expr_2();
+        double parse_expr_3();
+        double parse_expr_4();
+        double parse_expr_5();
+        double parse_expr_6();
+        double parse_expr_7();
+        double parse_expr_8();
+        char* parse_word(char* str);
+        binary_operator parse_binary_operator();
+        unary_operator parse_unary_operator();
+        double parse_argument();
+        double parse_last_argument();
+        binary_operator op;
+        const char* reading_stream;
+        bool failed_;
+        double result_;
+        std::string remains_;
     };
+    enum unary_operator
+    {
+        u_plus,
+        u_minus,
+        u_nicht
+    };
+    ExprParser(const std::string& str);
+    std::string& getRemains() { return  this->remains_; }
+    double       getResult()  { return  this->result_; }
+    bool         getSuccess() { return !this->failed_; }
+private:
+    double parse_expr_1();
+    double parse_expr_2();
+    double parse_expr_3();
+    double parse_expr_4();
+    double parse_expr_5();
+    double parse_expr_6();
+    double parse_expr_7();
+    double parse_expr_8();
+    char* parse_word(char* str);
+    binary_operator parse_binary_operator();
+    unary_operator parse_unary_operator();
+    double parse_argument();
+    double parse_last_argument();
+    binary_operator op;
+    const char* reading_stream;
+    bool failed_;
+    double result_;
+    std::string remains_;
+};
+//Endzeichen für float expression: ')', '}', ']', ',', ';'
+_UtilExport bool parse_float(char* const, char**, double*);
+//Endzeichen angegeben
+_UtilExport bool parse_float(char* const, char**, char, double*);
+//Letzter Teil-float eines Vektors parsen (keine Vergleichs- und Logikoperationen)
+_UtilExport bool parse_vector_float(char* const, char**, bool, double*);
+    //Endzeichen für float expression: ')', '}', ']', ',', ';'
+    _UtilExport bool parse_float(char* const, char**, double*);
+    //Endzeichen angegeben
+    _UtilExport bool parse_float(char* const, char**, char, double*);
+    //Letzter Teil-float eines Vektors parsen (keine Vergleichs- und Logikoperationen)
+    _UtilExport bool parse_vector_float(char* const, char**, bool, double*);
+}
 #endif /* _FloatParser_H__ */

code/trunk/src/util/Math.cc

-                      r2087
+                      r2171
 #include "SubString.h"
 /**
+    @brief Function for writing a Radian to a stream.
+*/
+std::ostream& operator<<(std::ostream& out, const orxonox::Radian& radian)
+// Do not remove this include to avoid linker errors.
+#include "mbool.h"
+namespace orxonox
+{
+    out << radian.valueRadians();
+    return out;
+    /**
+        @brief Function for writing a Radian to a stream.
+    */
+    std::ostream& operator<<(std::ostream& out, const orxonox::Radian& radian)
+    {
+        out << radian.valueRadians();
+        return out;
+    }
+    /**
+        @brief Function for reading a Radian from a stream.
+    */
+    std::istream& operator>>(std::istream& in, orxonox::Radian& radian)
+    {
+        float temp;
+        in >> temp;
+        radian = temp;
+        return in;
+    }
+    /**
+        @brief Function for writing a Degree to a stream.
+    */
+    std::ostream& operator<<(std::ostream& out, const orxonox::Degree& degree)
+    {
+        out << degree.valueDegrees();
+        return out;
+    }
+    /**
+        @brief Function for reading a Degree from a stream.
+    */
+    std::istream& operator>>(std::istream& in, orxonox::Degree& degree)
+    {
+        float temp;
+        in >> temp;
+        degree = temp;
+        return in;
+    }
+    /**
+        @brief Gets the angle between my viewing direction and the direction to the position of the other object.
+        @param myposition My position
+        @param mydirection My viewing direction
+        @param otherposition The position of the other object
+        @return The angle
+        @example
+        If the other object is exactly in front of me, the function returns 0.
+        If the other object is exactly behind me, the function returns pi.
+        If the other object is exactly right/left to me (or above/below), the function returns pi/2.
+    */
+    float getAngle(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& otherposition)
+    {
+        orxonox::Vector3 distance = otherposition - myposition;
+        float distancelength = distance.length();
+        if (distancelength == 0)
+            return 0;
+        else
+            return acos(clamp<float>(mydirection.dotProduct(distance) / distancelength, -1, 1));
+    }
+    /**
+        @brief Gets the 2D viewing direction (up/down, left/right) to the position of the other object.
+        @param myposition My position
+        @param mydirection My viewing direction
+        @param myorthonormal My orthonormalvector (pointing upwards through my head)
+        @param otherposition The position of the other object
+        @return The viewing direction
+        @example
+        If the other object is exactly in front of me, the function returns Vector2(0, 0).
+        If the other object is exactly at my left, the function returns Vector2(-1, 0).
+        If the other object is exactly at my right, the function returns Vector2(1, 0).
+        If the other object is only a bit at my right, the function still returns Vector2(1, 0).
+        If the other object is exactly above me, the function returns Vector2(0, 1).
+    */
+    orxonox::Vector2 get2DViewdirection(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition)
+    {
+        orxonox::Vector3 distance = otherposition - myposition;
+        // project difference vector on our plane
+        orxonox::Vector3 projection = Ogre::Plane(mydirection, myposition).projectVector(distance);
+        float projectionlength = projection.length();
+        if (projectionlength == 0) return orxonox::Vector2(0, 0);
+        float angle = acos(clamp<float>(myorthonormal.dotProduct(projection) / projectionlength, -1, 1));
+        if ((mydirection.crossProduct(myorthonormal)).dotProduct(distance) > 0)
+            return orxonox::Vector2(sin(angle), cos(angle));
+        else
+            return orxonox::Vector2(-sin(angle), cos(angle));
+    }
+    /**
+        @brief Gets the 2D viewing direction (up/down, left/right) to the position of the other object, multiplied with the viewing distance to the object (0° = 0, 180° = 1).
+        @param myposition My position
+        @param mydirection My viewing direction
+        @param myorthonormal My orthonormalvector (pointing upwards through my head)
+        @param otherposition The position of the other object
+        @return The viewing direction
+        @example
+        If the other object is exactly in front of me, the function returns Vector2(0, 0).
+        If the other object is exactly at my left, the function returns Vector2(-0.5, 0).
+        If the other object is exactly at my right, the function returns Vector2(0.5, 0).
+        If the other object is only a bit at my right, the function still returns Vector2(0.01, 0).
+        If the other object is exactly above me, the function returns Vector2(0, 0.5).
+    */
+    orxonox::Vector2 get2DViewcoordinates(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition)
+    {
+        orxonox::Vector3 distance = otherposition - myposition;
+        // project difference vector on our plane
+        orxonox::Vector3 projection = Ogre::Plane(mydirection, myposition).projectVector(distance);
+        float projectionlength = projection.length();
+        if (projectionlength == 0) return orxonox::Vector2(0, 0);
+        float angle = acos(clamp<float>(myorthonormal.dotProduct(projection) / projectionlength, -1, 1));
+        float distancelength = distance.length();
+        if (distancelength == 0) return orxonox::Vector2(0, 0);
+        float radius = acos(clamp<float>(mydirection.dotProduct(distance) / distancelength, -1, 1)) / Ogre::Math::PI;
+        if ((mydirection.crossProduct(myorthonormal)).dotProduct(distance) > 0)
+            return orxonox::Vector2(sin(angle) * radius, cos(angle) * radius);
+        else
+            return orxonox::Vector2(-sin(angle) * radius, cos(angle) * radius);
+    }
+    /**
+        @brief Returns the predicted position I have to aim at, if I want to hit a moving target with a moving projectile.
+        @param myposition My position
+        @param projectilespeed The speed of my projectile
+        @param targetposition The position of my target
+        @param targetvelocity The velocity of my target
+        @return The predicted position
+        The function predicts the position based on a linear velocity of the target. If the target changes speed or direction, the projectile will miss.
+    */
+    orxonox::Vector3 getPredictedPosition(const orxonox::Vector3& myposition, float projectilespeed, const orxonox::Vector3& targetposition, const orxonox::Vector3& targetvelocity)
+    {
+        float squaredProjectilespeed = projectilespeed * projectilespeed;
+        orxonox::Vector3 distance = targetposition - myposition;
+        float a = distance.squaredLength();
+        float b = 2 * (distance.x + distance.y + distance.z) * (targetvelocity.x + targetvelocity.y + targetvelocity.z);
+        float c = targetvelocity.squaredLength();
+        float temp = 4*squaredProjectilespeed*c + a*a - 4*b*c;
+        if (temp < 0)
+            return orxonox::Vector3::ZERO;
+        temp = sqrt(temp);
+        float time = (temp + a) / (2 * (squaredProjectilespeed - b));
+        return (targetposition + targetvelocity * time);
+    }
+    unsigned long getUniqueNumber()
+    {
+        static unsigned long aNumber = 135;
+        return aNumber++;
+    }
+    //////////////////////////
+    // Conversion functions //
+    //////////////////////////
+    // std::string to Vector2
+    bool ConverterFallback<std::string, orxonox::Vector2>::convert(orxonox::Vector2* output, const std::string& input)
+    {
+        size_t opening_parenthesis, closing_parenthesis = input.find(')');
+        if ((opening_parenthesis = input.find('(')) == std::string::npos)
+            opening_parenthesis = 0;
+        else
+            opening_parenthesis++;
+        SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis),
+                         ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
+        if (tokens.size() >= 2)
+        {
+            if (!ConvertValue(&(output->x), tokens[0]))
+                return false;
+            if (!ConvertValue(&(output->y), tokens[1]))
+                return false;
+            return true;
+        }
+        return false;
+    }
+    // std::string to Vector3
+    bool ConverterFallback<std::string, orxonox::Vector3>::convert(orxonox::Vector3* output, const std::string& input)
+    {
+        size_t opening_parenthesis, closing_parenthesis = input.find(')');
+        if ((opening_parenthesis = input.find('(')) == std::string::npos)
+            opening_parenthesis = 0;
+        else
+            opening_parenthesis++;
+        SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis),
+                         ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
+        if (tokens.size() >= 3)
+        {
+            if (!ConvertValue(&(output->x), tokens[0]))
+                return false;
+            if (!ConvertValue(&(output->y), tokens[1]))
+                return false;
+            if (!ConvertValue(&(output->z), tokens[2]))
+                return false;
+            return true;
+        }
+        return false;
+    }
+    // std::string to Vector4
+    bool ConverterFallback<std::string, orxonox::Vector4>::convert(orxonox::Vector4* output, const std::string& input)
+    {
+        size_t opening_parenthesis, closing_parenthesis = input.find(')');
+        if ((opening_parenthesis = input.find('(')) == std::string::npos)
+            opening_parenthesis = 0;
+        else
+            opening_parenthesis++;
+        SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis),
+                         ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
+        if (tokens.size() >= 4)
+        {
+            if (!ConvertValue(&(output->x), tokens[0]))
+                return false;
+            if (!ConvertValue(&(output->y), tokens[1]))
+                return false;
+            if (!ConvertValue(&(output->z), tokens[2]))
+                return false;
+            if (!ConvertValue(&(output->w), tokens[3]))
+                return false;
+            return true;
+        }
+        return false;
+    }
+    // std::string to Quaternion
+    bool ConverterFallback<std::string, orxonox::Quaternion>::convert(orxonox::Quaternion* output, const std::string& input)
+    {
+        size_t opening_parenthesis, closing_parenthesis = input.find(')');
+        if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
+        SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
+        if (tokens.size() >= 4)
+        {
+            if (!ConvertValue(&(output->w), tokens[0]))
+                return false;
+            if (!ConvertValue(&(output->x), tokens[1]))
+                return false;
+            if (!ConvertValue(&(output->y), tokens[2]))
+                return false;
+            if (!ConvertValue(&(output->z), tokens[3]))
+                return false;
+            return true;
+        }
+        return false;
+    }
+    // std::string to ColourValue
+    bool ConverterFallback<std::string, orxonox::ColourValue>::convert(orxonox::ColourValue* output, const std::string& input)
+    {
+        size_t opening_parenthesis, closing_parenthesis = input.find(')');
+        if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
+        SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
+        if (tokens.size() >= 3)
+        {
+            if (!ConvertValue(&(output->r), tokens[0]))
+                return false;
+            if (!ConvertValue(&(output->g), tokens[1]))
+                return false;
+            if (!ConvertValue(&(output->b), tokens[2]))
+                return false;
+            if (tokens.size() >= 4)
+            {
+                if (!ConvertValue(&(output->a), tokens[3]))
+                    return false;
+            }
+            else
+                output->a = 1.0;
+            return true;
+        }
+        return false;
+    }
+}
-/**
-    @brief Function for reading a Radian from a stream.
-*/
-std::istream& operator>>(std::istream& in, orxonox::Radian& radian)
+{
-    float temp;
-    in >> temp;
-    radian = temp;
-    return in;
+}
-/**
-    @brief Function for writing a Degree to a stream.
-*/
-std::ostream& operator<<(std::ostream& out, const orxonox::Degree& degree)
+{
-    out << degree.valueDegrees();
-    return out;
+}
-/**
-    @brief Function for reading a Degree from a stream.
-*/
-std::istream& operator>>(std::istream& in, orxonox::Degree& degree)
+{
-    float temp;
-    in >> temp;
-    degree = temp;
-    return in;
+}
-/**
-    @brief Gets the angle between my viewing direction and the direction to the position of the other object.
-    @param myposition My position
-    @param mydirection My viewing direction
-    @param otherposition The position of the other object
-    @return The angle
-    @example
-    If the other object is exactly in front of me, the function returns 0.
-    If the other object is exactly behind me, the function returns pi.
-    If the other object is exactly right/left to me (or above/below), the function returns pi/2.
-*/
-float getAngle(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& otherposition)
+{
-    orxonox::Vector3 distance = otherposition - myposition;
-    float distancelength = distance.length();
-    if (distancelength == 0)
-        return 0;
-    else
-        return acos(clamp<float>(mydirection.dotProduct(distance) / distancelength, -1, 1));
+}
-/**
-    @brief Gets the 2D viewing direction (up/down, left/right) to the position of the other object.
-    @param myposition My position
-    @param mydirection My viewing direction
-    @param myorthonormal My orthonormalvector (pointing upwards through my head)
-    @param otherposition The position of the other object
-    @return The viewing direction
-    @example
-    If the other object is exactly in front of me, the function returns Vector2(0, 0).
-    If the other object is exactly at my left, the function returns Vector2(-1, 0).
-    If the other object is exactly at my right, the function returns Vector2(1, 0).
-    If the other object is only a bit at my right, the function still returns Vector2(1, 0).
-    If the other object is exactly above me, the function returns Vector2(0, 1).
-*/
-orxonox::Vector2 get2DViewdirection(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition)
+{
-    orxonox::Vector3 distance = otherposition - myposition;
-    // project difference vector on our plane
-    orxonox::Vector3 projection = Ogre::Plane(mydirection, myposition).projectVector(distance);
-    float projectionlength = projection.length();
-    if (projectionlength == 0) return orxonox::Vector2(0, 0);
-    float angle = acos(clamp<float>(myorthonormal.dotProduct(projection) / projectionlength, -1, 1));
-    if ((mydirection.crossProduct(myorthonormal)).dotProduct(distance) > 0)
-        return orxonox::Vector2(sin(angle), cos(angle));
-    else
-        return orxonox::Vector2(-sin(angle), cos(angle));
+}
-/**
-    @brief Gets the 2D viewing direction (up/down, left/right) to the position of the other object, multiplied with the viewing distance to the object (0° = 0, 180° = 1).
-    @param myposition My position
-    @param mydirection My viewing direction
-    @param myorthonormal My orthonormalvector (pointing upwards through my head)
-    @param otherposition The position of the other object
-    @return The viewing direction
-    @example
-    If the other object is exactly in front of me, the function returns Vector2(0, 0).
-    If the other object is exactly at my left, the function returns Vector2(-0.5, 0).
-    If the other object is exactly at my right, the function returns Vector2(0.5, 0).
-    If the other object is only a bit at my right, the function still returns Vector2(0.01, 0).
-    If the other object is exactly above me, the function returns Vector2(0, 0.5).
-*/
-orxonox::Vector2 get2DViewcoordinates(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition)
+{
-    orxonox::Vector3 distance = otherposition - myposition;
-    // project difference vector on our plane
-    orxonox::Vector3 projection = Ogre::Plane(mydirection, myposition).projectVector(distance);
-    float projectionlength = projection.length();
-    if (projectionlength == 0) return orxonox::Vector2(0, 0);
-    float angle = acos(clamp<float>(myorthonormal.dotProduct(projection) / projectionlength, -1, 1));
-    float distancelength = distance.length();
-    if (distancelength == 0) return orxonox::Vector2(0, 0);
-    float radius = acos(clamp<float>(mydirection.dotProduct(distance) / distancelength, -1, 1)) / Ogre::Math::PI;
-    if ((mydirection.crossProduct(myorthonormal)).dotProduct(distance) > 0)
-        return orxonox::Vector2(sin(angle) * radius, cos(angle) * radius);
-    else
-        return orxonox::Vector2(-sin(angle) * radius, cos(angle) * radius);
+}
-/**
-    @brief Returns the predicted position I have to aim at, if I want to hit a moving target with a moving projectile.
-    @param myposition My position
-    @param projectilespeed The speed of my projectile
-    @param targetposition The position of my target
-    @param targetvelocity The velocity of my target
-    @return The predicted position
-    The function predicts the position based on a linear velocity of the target. If the target changes speed or direction, the projectile will miss.
-*/
-orxonox::Vector3 getPredictedPosition(const orxonox::Vector3& myposition, float projectilespeed, const orxonox::Vector3& targetposition, const orxonox::Vector3& targetvelocity)
+{
-    float squaredProjectilespeed = projectilespeed * projectilespeed;
-    orxonox::Vector3 distance = targetposition - myposition;
-    float a = distance.squaredLength();
-    float b = 2 * (distance.x + distance.y + distance.z) * (targetvelocity.x + targetvelocity.y + targetvelocity.z);
-    float c = targetvelocity.squaredLength();
-    float temp = 4*squaredProjectilespeed*c + a*a - 4*b*c;
-    if (temp < 0)
-        return orxonox::Vector3::ZERO;
-    temp = sqrt(temp);
-    float time = (temp + a) / (2 * (squaredProjectilespeed - b));
-    return (targetposition + targetvelocity * time);
+}
-unsigned long getUniqueNumber()
+{
-    static unsigned long aNumber = 135;
-    return aNumber++;
+}
-//////////////////////////
-// Conversion functions //
-//////////////////////////
-// std::string to Vector2
-bool ConverterFallback<std::string, orxonox::Vector2>::convert(orxonox::Vector2* output, const std::string& input)
+{
-    size_t opening_parenthesis, closing_parenthesis = input.find(')');
-    if ((opening_parenthesis = input.find('(')) == std::string::npos)
-        opening_parenthesis = 0;
-    else
-        opening_parenthesis++;
-    SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis),
-                     ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
-    if (tokens.size() >= 2)
+    {
-        if (!ConvertValue(&(output->x), tokens[0]))
-            return false;
-        if (!ConvertValue(&(output->y), tokens[1]))
-            return false;
-        return true;
+    }
-    return false;
+}
-// std::string to Vector3
-bool ConverterFallback<std::string, orxonox::Vector3>::convert(orxonox::Vector3* output, const std::string& input)
+{
-    size_t opening_parenthesis, closing_parenthesis = input.find(')');
-    if ((opening_parenthesis = input.find('(')) == std::string::npos)
-        opening_parenthesis = 0;
-    else
-        opening_parenthesis++;
-    SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis),
-                     ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
-    if (tokens.size() >= 3)
+    {
-        if (!ConvertValue(&(output->x), tokens[0]))
-            return false;
-        if (!ConvertValue(&(output->y), tokens[1]))
-            return false;
-        if (!ConvertValue(&(output->z), tokens[2]))
-            return false;
-        return true;
+    }
-    return false;
+}
-// std::string to Vector4
-bool ConverterFallback<std::string, orxonox::Vector4>::convert(orxonox::Vector4* output, const std::string& input)
+{
-    size_t opening_parenthesis, closing_parenthesis = input.find(')');
-    if ((opening_parenthesis = input.find('(')) == std::string::npos)
-        opening_parenthesis = 0;
-    else
-        opening_parenthesis++;
-    SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis),
-                     ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
-    if (tokens.size() >= 4)
+    {
-        if (!ConvertValue(&(output->x), tokens[0]))
-            return false;
-        if (!ConvertValue(&(output->y), tokens[1]))
-            return false;
-        if (!ConvertValue(&(output->z), tokens[2]))
-            return false;
-        if (!ConvertValue(&(output->w), tokens[3]))
-            return false;
-        return true;
+    }
-    return false;
+}
-// std::string to Quaternion
-bool ConverterFallback<std::string, orxonox::Quaternion>::convert(orxonox::Quaternion* output, const std::string& input)
+{
-    size_t opening_parenthesis, closing_parenthesis = input.find(')');
-    if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
-    SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
-    if (tokens.size() >= 4)
+    {
-        if (!ConvertValue(&(output->w), tokens[0]))
-            return false;
-        if (!ConvertValue(&(output->x), tokens[1]))
-            return false;
-        if (!ConvertValue(&(output->y), tokens[2]))
-            return false;
-        if (!ConvertValue(&(output->z), tokens[3]))
-            return false;
-        return true;
+    }
-    return false;
+}
-// std::string to ColourValue
-bool ConverterFallback<std::string, orxonox::ColourValue>::convert(orxonox::ColourValue* output, const std::string& input)
+{
-    size_t opening_parenthesis, closing_parenthesis = input.find(')');
-    if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
-    SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
-    if (tokens.size() >= 3)
+    {
-        if (!ConvertValue(&(output->r), tokens[0]))
-            return false;
-        if (!ConvertValue(&(output->g), tokens[1]))
-            return false;
-        if (!ConvertValue(&(output->b), tokens[2]))
-            return false;
-        if (tokens.size() >= 4)
+        {
-            if (!ConvertValue(&(output->a), tokens[3]))
-                return false;
+        }
-        else
-            output->a = 1.0;
-        return true;
+    }
-    return false;
+}

code/trunk/src/util/Math.h

-                      r2087
+                      r2171
 /**
     @file Math.h
+    @file
     @brief Declaration and implementation of several math-functions, typedefs of some Ogre::Math classes to the orxonox namespace.
 */
 …
 #include <ostream>
 #include <string>
+#include <cmath>
 #include <boost/static_assert.hpp>
 …
 #include <OgreQuaternion.h>
 #include <OgreColourValue.h>
-namespace orxonox
+{
-  typedef Ogre::Radian Radian;
-  typedef Ogre::Degree Degree;
-  typedef Ogre::Vector2 Vector2;
-  typedef Ogre::Vector3 Vector3;
-  typedef Ogre::Vector4 Vector4;
-  typedef Ogre::Matrix3 Matrix3;
-  typedef Ogre::Matrix4 Matrix4;
-  typedef Ogre::Quaternion Quaternion;
-  typedef Ogre::ColourValue ColourValue;
+}
-_UtilExport std::ostream& operator<<(std::ostream& out, const orxonox::Radian& radian);
-_UtilExport std::istream& operator>>(std::istream& in, orxonox::Radian& radian);
-_UtilExport std::ostream& operator<<(std::ostream& out, const orxonox::Degree& degree);
-_UtilExport std::istream& operator>>(std::istream& in, orxonox::Degree& degree);
-_UtilExport float getAngle(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& otherposition);
-_UtilExport orxonox::Vector2 get2DViewdirection(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition);
-_UtilExport orxonox::Vector2 get2DViewcoordinates(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition);
-_UtilExport orxonox::Vector3 getPredictedPosition(const orxonox::Vector3& myposition, float projectilespeed, const orxonox::Vector3& targetposition, const orxonox::Vector3& targetvelocity);
 //Get around Windows hackery
 …
 #endif
+/**
+    @brief Returns the sign of the given value.
+    @param x The value
+    @return 1 if the value is positive or zero, -1 if the value is negative
+*/
+template <typename T>
+inline T sgn(T x)
+namespace orxonox
+{
+    return (x >= 0) ? 1 : -1;
+    typedef Ogre::Radian Radian;
+    typedef Ogre::Degree Degree;
+    typedef Ogre::Vector2 Vector2;
+    typedef Ogre::Vector3 Vector3;
+    typedef Ogre::Vector4 Vector4;
+    typedef Ogre::Matrix3 Matrix3;
+    typedef Ogre::Matrix4 Matrix4;
+    typedef Ogre::Quaternion Quaternion;
+    typedef Ogre::ColourValue ColourValue;
+    _UtilExport std::ostream& operator<<(std::ostream& out, const orxonox::Radian& radian);
+    _UtilExport std::istream& operator>>(std::istream& in, orxonox::Radian& radian);
+    _UtilExport std::ostream& operator<<(std::ostream& out, const orxonox::Degree& degree);
+    _UtilExport std::istream& operator>>(std::istream& in, orxonox::Degree& degree);
+    _UtilExport float getAngle(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& otherposition);
+    _UtilExport orxonox::Vector2 get2DViewdirection(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition);
+    _UtilExport orxonox::Vector2 get2DViewcoordinates(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition);
+    _UtilExport orxonox::Vector3 getPredictedPosition(const orxonox::Vector3& myposition, float projectilespeed, const orxonox::Vector3& targetposition, const orxonox::Vector3& targetvelocity);
+    /**
+        @brief Returns the sign of the given value.
+        @param x The value
+        @return 1 if the value is positive or zero, -1 if the value is negative
+    */
+    template <typename T>
+    inline T sgn(T x)
+    {
+        return (x >= 0) ? 1 : -1;
+    }
+    /**
+        @brief Returns the smaller of two values.
+    */
+    template <typename T>
+    inline T min(T a, T b)
+    {
+        return (a <= b) ? a : b;
+    }
+    /**
+        @brief Returns the greater of two values.
+    */
+    template <typename T>
+    inline T max(T a, T b)
+    {
+        return (a >= b) ? a : b;
+    }
+    /**
+        @brief Keeps a value between a lower and an upper limit.
+        @param x The value
+        @param min The lower limit
+        @param max The upper limit
+    */
+    template <typename T>
+    inline T clamp(T x, T min, T max)
+    {
+        if (x < min)
+            return min;
+        if (x > max)
+            return max;
+        return x;
+    }
+    /**
+        @brief Returns the square value (x^2).
+    */
+    template <typename T>
+    inline T square(T x)
+    {
+        return x*x;
+    }
+    /**
+        @brief Returns the cube value (x^3).
+    */
+    template <typename T>
+    inline T cube(T x)
+    {
+        return x*x*x;
+    }
+    /**
+        @brief Rounds the value.
+    */
+    template <typename T>
+    inline int round(T x)
+    {
+        return (int)(x + 0.5);
+    }
+    /**
+        @brief The modulo operation, enhanced to work properly with negative values.
+        @param x The value
+        @param max The operand
+    */
+    template <typename T>
+    inline int mod(T x, int max)
+    {
+        if (x >= 0)
+            return (x % max);
+        else
+            return ((x % max) + max);
+    }
+    template <typename T>
+    inline T zeroise()
+    {
+        BOOST_STATIC_ASSERT(sizeof(T) == 0);
+        return T();
+    }
+    template <> inline char                 zeroise<char>()                 { return 0; }
+    template <> inline unsigned char        zeroise<unsigned char>()        { return 0; }
+    template <> inline short                zeroise<short>()                { return 0; }
+    template <> inline unsigned short       zeroise<unsigned short>()       { return 0; }
+    template <> inline int                  zeroise<int>()                  { return 0; }
+    template <> inline unsigned int         zeroise<unsigned int>()         { return 0; }
+    template <> inline long                 zeroise<long>()                 { return 0; }
+    template <> inline unsigned long        zeroise<unsigned long>()        { return 0; }
+    template <> inline long long            zeroise<long long>()            { return 0; }
+    template <> inline unsigned long long   zeroise<unsigned long long>()   { return 0; }
+    template <> inline float                zeroise<float>()                { return 0; }
+    template <> inline double               zeroise<double>()               { return 0; }
+    template <> inline long double          zeroise<long double>()          { return 0; }
+    template <> inline bool                 zeroise<bool>()                 { return 0; }
+    template <> inline void*                zeroise<void*>()                { return 0; }
+    template <> inline std::string          zeroise<std::string>()          { return ""; }
+    template <> inline orxonox::Radian      zeroise<orxonox::Radian>()      { return orxonox::Radian(0.0f); }
+    template <> inline orxonox::Degree      zeroise<orxonox::Degree>()      { return orxonox::Degree(0.0f); }
+    template <> inline orxonox::Vector2     zeroise<orxonox::Vector2>()     { return orxonox::Vector2    (0, 0)      ; }
+    template <> inline orxonox::Vector3     zeroise<orxonox::Vector3>()     { return orxonox::Vector3    (0, 0, 0)   ; }
+    template <> inline orxonox::Vector4     zeroise<orxonox::Vector4>()     { return orxonox::Vector4    (0, 0, 0, 0); }
+    template <> inline orxonox::ColourValue zeroise<orxonox::ColourValue>() { return orxonox::ColourValue(0, 0, 0, 0); }
+    template <> inline orxonox::Quaternion  zeroise<orxonox::Quaternion>()  { return orxonox::Quaternion (0, 0, 0, 0); }
+    /**
+        @brief Interpolates between two values for a time between 0 and 1.
+        @param time The time is a value between 0 and 1 - the function returns start if time is 0 and end if time is 1 and interpolates if time is between 0 and 1.
+        @param start The value at time = 0
+        @param end The value at time = 1
+        @return The interpolation at a given time
+    */
+    template <typename T>
+    T interpolate(float time, const T& start, const T& end)
+    {
+        return time * (end - start) + start;
+    }
+    /**
+        @brief Interpolates smoothly between two values for a time between 0 and 1. The function starts slowly, increases faster and stops slowly again.
+        @param time The time is a value between 0 and 1 - the function returns start if time is 0 and end if time is 1 and interpolates if time is between 0 and 1.
+        @param start The value at time = 0
+        @param end The value at time = 1
+        @return The smoothed interpolation at a given time
+    */
+    template <typename T>
+    T interpolateSmooth(float time, const T& start, const T& end)
+    {
+        return (-2 * (end - start) * cube(time)) + (3 * (end - start) * square(time)) + start;
+    }
+    /**
+        @brief Returns a random number between 0 and almost 1: 0 <= rnd < 1.
+    */
+    inline float rnd()
+    {
+        return rand() / (RAND_MAX + 1.0);
+    }
+    /**
+        @brief Returns a random number between 0 and almost max: 0 <= rnd < max.
+        @param max The maximum
+    */
+    inline float rnd(float max)
+    {
+        return rnd() * max;
+    }
+    /**
+        @brief Returns a random number between min and almost max: min <= rnd < max.
+        @param min The minimum
+        @param max The maximum
+    */
+    inline float rnd(float min, float max)
+    {
+        return rnd(max - min) + min;
+    }
+    _UtilExport unsigned long getUniqueNumber();
+    class IntVector2
+    {
+    public:
+      IntVector2() : x(0), y(0) { }
+      IntVector2(int _x, int _y) : x(_x), y(_y) { }
+      int x;
+      int y;
+    };
+    class IntVector3
+    {
+    public:
+      IntVector3() : x(0), y(0), z(0) { }
+      IntVector3(int _x, int _y, int _z) : x(_x), y(_y), z(_z) { }
+      int x;
+      int y;
+      int z;
+    };
+}
-/**
-    @brief Returns the smaller of two values.
-*/
-template <typename T>
-inline T min(T a, T b)
+{
-    return (a <= b) ? a : b;
+}
-/**
-    @brief Returns the greater of two values.
-*/
-template <typename T>
-inline T max(T a, T b)
+{
-    return (a >= b) ? a : b;
+}
-/**
-    @brief Keeps a value between a lower and an upper limit.
-    @param x The value
-    @param min The lower limit
-    @param max The upper limit
-*/
-template <typename T>
-inline T clamp(T x, T min, T max)
+{
-    if (x < min)
-        return min;
-    if (x > max)
-        return max;
-    return x;
+}
-/**
-    @brief Returns the square value (x^2).
-*/
-template <typename T>
-inline T square(T x)
+{
-    return x*x;
+}
-/**
-    @brief Returns the cube value (x^3).
-*/
-template <typename T>
-inline T cube(T x)
+{
-    return x*x*x;
+}
-/**
-    @brief Rounds the value down.
-*/
-template <typename T>
-inline int floor(T x)
+{
-    return (int)(x);
+}
-/**
-    @brief Rounds the value up.
-*/
-template <typename T>
-inline int ceil(T x)
+{
-    int temp = floor(x);
-    return (temp != x) ? (temp + 1) : temp;
+}
-/**
-    @brief Rounds the value.
-*/
-template <typename T>
-inline int round(T x)
+{
-    return (int)(x + 0.5);
+}
-/**
-    @brief The modulo operation, enhanced to work properly with negative values.
-    @param x The value
-    @param max The operand
-*/
-template <typename T>
-inline int mod(T x, int max)
+{
-    if (x >= 0)
-        return (x % max);
-    else
-        return ((x % max) + max);
+}
-template <typename T>
-inline T zeroise()
+{
-    BOOST_STATIC_ASSERT(sizeof(T) == 0);
-    return T();
+}
-template <> inline char                 zeroise<char>()                 { return 0; }
-template <> inline unsigned char        zeroise<unsigned char>()        { return 0; }
-template <> inline short                zeroise<short>()                { return 0; }
-template <> inline unsigned short       zeroise<unsigned short>()       { return 0; }
-template <> inline int                  zeroise<int>()                  { return 0; }
-template <> inline unsigned int         zeroise<unsigned int>()         { return 0; }
-template <> inline long                 zeroise<long>()                 { return 0; }
-template <> inline unsigned long        zeroise<unsigned long>()        { return 0; }
-template <> inline long long            zeroise<long long>()            { return 0; }
-template <> inline unsigned long long   zeroise<unsigned long long>()   { return 0; }
-template <> inline float                zeroise<float>()                { return 0; }
-template <> inline double               zeroise<double>()               { return 0; }
-template <> inline long double          zeroise<long double>()          { return 0; }
-template <> inline bool                 zeroise<bool>()                 { return 0; }
-template <> inline void*                zeroise<void*>()                { return 0; }
-template <> inline std::string          zeroise<std::string>()          { return ""; }
-template <> inline orxonox::Radian      zeroise<orxonox::Radian>()      { return orxonox::Radian(0.0f); }
-template <> inline orxonox::Degree      zeroise<orxonox::Degree>()      { return orxonox::Degree(0.0f); }
-template <> inline orxonox::Vector2     zeroise<orxonox::Vector2>()     { return orxonox::Vector2    (0, 0)      ; }
-template <> inline orxonox::Vector3     zeroise<orxonox::Vector3>()     { return orxonox::Vector3    (0, 0, 0)   ; }
-template <> inline orxonox::Vector4     zeroise<orxonox::Vector4>()     { return orxonox::Vector4    (0, 0, 0, 0); }
-template <> inline orxonox::ColourValue zeroise<orxonox::ColourValue>() { return orxonox::ColourValue(0, 0, 0, 0); }
-template <> inline orxonox::Quaternion  zeroise<orxonox::Quaternion>()  { return orxonox::Quaternion (0, 0, 0, 0); }
-/**
-    @brief Interpolates between two values for a time between 0 and 1.
-    @param time The time is a value between 0 and 1 - the function returns start if time is 0 and end if time is 1 and interpolates if time is between 0 and 1.
-    @param start The value at time = 0
-    @param end The value at time = 1
-    @return The interpolation at a given time
-*/
-template <typename T>
-T interpolate(float time, const T& start, const T& end)
+{
-    return time * (end - start) + start;
+}
-/**
-    @brief Interpolates smoothly between two values for a time between 0 and 1. The function starts slowly, increases faster and stops slowly again.
-    @param time The time is a value between 0 and 1 - the function returns start if time is 0 and end if time is 1 and interpolates if time is between 0 and 1.
-    @param start The value at time = 0
-    @param end The value at time = 1
-    @return The smoothed interpolation at a given time
-*/
-template <typename T>
-T interpolateSmooth(float time, const T& start, const T& end)
+{
-    return (-2 * (end - start) * cube(time)) + (3 * (end - start) * square(time)) + start;
+}
-/**
-    @brief Returns a random number between 0 and almost 1: 0 <= rnd < 1.
-*/
-inline _UtilExport float rnd()
+{
-    return rand() / (RAND_MAX + 1.0);
+}
-/**
-    @brief Returns a random number between 0 and almost max: 0 <= rnd < max.
-    @param max The maximum
-*/
-inline _UtilExport float rnd(float max)
+{
-    return rnd() * max;
+}
-/**
-    @brief Returns a random number between min and almost max: min <= rnd < max.
-    @param min The minimum
-    @param max The maximum
-*/
-inline _UtilExport float rnd(float min, float max)
+{
-    return rnd(max - min) + min;
+}
-_UtilExport unsigned long getUniqueNumber();
-class _UtilExport IntVector2
+{
-public:
-  IntVector2() : x(0), y(0) { }
-  IntVector2(int _x, int _y) : x(_x), y(_y) { }
-  int x;
-  int y;
-};
-class _UtilExport IntVector3
+{
-public:
-  IntVector3() : x(0), y(0), z(0) { }
-  IntVector3(int _x, int _y, int _z) : x(_x), y(_y), z(_z) { }
-  int x;
-  int y;
-  int z;
-};
 #endif /* _Util_Math_H__ */

code/trunk/src/util/MathConvert.h

-                      r2087
+                      r2171
 #include "Convert.h"
+////////////////////
+// Math to string //
+////////////////////
+// Vector2 to std::string
+template <>
+struct ConverterExplicit<orxonox::Vector2, std::string>
+namespace orxonox
+{
+    static bool convert(std::string* output, const orxonox::Vector2& input)
+    {
+        std::ostringstream ostream;
+        if (ostream << input.x << "," << input.y)
+        {
+            (*output) = ostream.str();
+            return true;
+        }
+        return false;
+    }
+};
+// Vector3 to std::string
+template <>
+struct ConverterExplicit<orxonox::Vector3, std::string>
+{
+    static bool convert(std::string* output, const orxonox::Vector3& input)
+    {
+        std::ostringstream ostream;
+        if (ostream << input.x << "," << input.y << "," << input.z)
+        {
+            (*output) = ostream.str();
+            return true;
+        }
+        return false;
+    }
+};
+// Vector4 to std::string
+template <>
+struct ConverterExplicit<orxonox::Vector4, std::string>
+{
+    static bool convert(std::string* output, const orxonox::Vector4& input)
+    {
+        std::ostringstream ostream;
+        if (ostream << input.x << "," << input.y << "," << input.z << "," << input.w)
+        {
+            (*output) = ostream.str();
+            return true;
+        }
+        return false;
+    }
+};
+// Quaternion to std::string
+template <>
+struct ConverterExplicit<orxonox::Quaternion, std::string>
+{
+    static bool convert(std::string* output, const orxonox::Quaternion& input)
+    {
+        std::ostringstream ostream;
+        if (ostream << input.w << "," << input.x << "," << input.y << "," << input.z)
+        {
+            (*output) = ostream.str();
+            return true;
+        }
+        return false;
+    }
+};
+// ColourValue to std::string
+template <>
+struct ConverterExplicit<orxonox::ColourValue, std::string>
+{
+    static bool convert(std::string* output, const orxonox::ColourValue& input)
+    {
+        std::ostringstream ostream;
+        if (ostream << input.r << "," << input.g << "," << input.b << "," << input.a)
+        {
+            (*output) = ostream.str();
+            return true;
+        }
+        return false;
+    }
+};
+////////////////////
+// string to Math //
+////////////////////
+// std::string to Vector2
+template <> struct _UtilExport ConverterFallback<std::string, orxonox::Vector2>
+{ static bool convert(orxonox::Vector2*     output, const std::string& input); };
+// std::string to Vector3
+template <> struct _UtilExport ConverterFallback<std::string, orxonox::Vector3>
+{ static bool convert(orxonox::Vector3*     output, const std::string& input); };
+// std::string to Vector4
+template <> struct _UtilExport ConverterFallback<std::string, orxonox::Vector4>
+{ static bool convert(orxonox::Vector4*     output, const std::string& input); };
+// std::string to Quaternion
+template <> struct _UtilExport ConverterFallback<std::string, orxonox::Quaternion>
+{ static bool convert(orxonox::Quaternion*  output, const std::string& input); };
+// std::string to ColourValue
+template <> struct _UtilExport ConverterFallback<std::string, orxonox::ColourValue>
+{ static bool convert(orxonox::ColourValue* output, const std::string& input); };
+///////////////////////////////
+// From and to Radian/Degree //
+///////////////////////////////
+// From Radian
+template <class ToType>
+struct ConverterFallback<orxonox::Radian, ToType>
+{
+    static bool convert(ToType* output, const orxonox::Radian& input)
+    {
+        return convertValue<Ogre::Real, ToType>(output, input.valueRadians());
+    }
+};
+// From Degree
+template <class ToType>
+struct ConverterFallback<orxonox::Degree, ToType>
+{
+    static bool convert(ToType* output, const orxonox::Degree& input)
+    {
+        return convertValue<Ogre::Real, ToType>(output, input.valueDegrees());
+    }
+};
+// To Radian
+template <class FromType>
+struct ConverterFallback<FromType, orxonox::Radian>
+{
+    static bool convert(orxonox::Radian* output, const FromType& input)
+    {
+        float temp;
+        if (convertValue(&temp, input))
+        {
+            *output = temp;
+            return true;
+        }
+        else
+            return false;
+    }
+};
+// To Degree
+template <class FromType>
+struct ConverterFallback<FromType, orxonox::Degree>
+{
+    static bool convert(orxonox::Degree* output, const FromType& input)
+    {
+        float temp;
+        if (convertValue(&temp, input))
+        {
+            *output = temp;
+            return true;
+        }
+        else
+            return false;
+    }
+};
+    ////////////////////
+    // Math to string //
+    ////////////////////
+    // Vector2 to std::string
+    template <>
+    struct ConverterExplicit<orxonox::Vector2, std::string>
+    {
+        static bool convert(std::string* output, const orxonox::Vector2& input)
+        {
+            std::ostringstream ostream;
+            if (ostream << input.x << "," << input.y)
+            {
+                (*output) = ostream.str();
+                return true;
+            }
+            return false;
+        }
+    };
+    // Vector3 to std::string
+    template <>
+    struct ConverterExplicit<orxonox::Vector3, std::string>
+    {
+        static bool convert(std::string* output, const orxonox::Vector3& input)
+        {
+            std::ostringstream ostream;
+            if (ostream << input.x << "," << input.y << "," << input.z)
+            {
+                (*output) = ostream.str();
+                return true;
+            }
+            return false;
+        }
+    };
+    // Vector4 to std::string
+    template <>
+    struct ConverterExplicit<orxonox::Vector4, std::string>
+    {
+        static bool convert(std::string* output, const orxonox::Vector4& input)
+        {
+            std::ostringstream ostream;
+            if (ostream << input.x << "," << input.y << "," << input.z << "," << input.w)
+            {
+                (*output) = ostream.str();
+                return true;
+            }
+            return false;
+        }
+    };
+    // Quaternion to std::string
+    template <>
+    struct ConverterExplicit<orxonox::Quaternion, std::string>
+    {
+        static bool convert(std::string* output, const orxonox::Quaternion& input)
+        {
+            std::ostringstream ostream;
+            if (ostream << input.w << "," << input.x << "," << input.y << "," << input.z)
+            {
+                (*output) = ostream.str();
+                return true;
+            }
+            return false;
+        }
+    };
+    // ColourValue to std::string
+    template <>
+    struct ConverterExplicit<orxonox::ColourValue, std::string>
+    {
+        static bool convert(std::string* output, const orxonox::ColourValue& input)
+        {
+            std::ostringstream ostream;
+            if (ostream << input.r << "," << input.g << "," << input.b << "," << input.a)
+            {
+                (*output) = ostream.str();
+                return true;
+            }
+            return false;
+        }
+    };
+    ////////////////////
+    // string to Math //
+    ////////////////////
+    // std::string to Vector2
+    template <> struct _UtilExport ConverterFallback<std::string, orxonox::Vector2>
+    { static bool convert(orxonox::Vector2*     output, const std::string& input); };
+    // std::string to Vector3
+    template <> struct _UtilExport ConverterFallback<std::string, orxonox::Vector3>
+    { static bool convert(orxonox::Vector3*     output, const std::string& input); };
+    // std::string to Vector4
+    template <> struct _UtilExport ConverterFallback<std::string, orxonox::Vector4>
+    { static bool convert(orxonox::Vector4*     output, const std::string& input); };
+    // std::string to Quaternion
+    template <> struct _UtilExport ConverterFallback<std::string, orxonox::Quaternion>
+    { static bool convert(orxonox::Quaternion*  output, const std::string& input); };
+    // std::string to ColourValue
+    template <> struct _UtilExport ConverterFallback<std::string, orxonox::ColourValue>
+    { static bool convert(orxonox::ColourValue* output, const std::string& input); };
+    ///////////////////////////////
+    // From and to Radian/Degree //
+    ///////////////////////////////
+    // From Radian
+    template <class ToType>
+    struct ConverterFallback<orxonox::Radian, ToType>
+    {
+        static bool convert(ToType* output, const orxonox::Radian& input)
+        {
+            return convertValue<Ogre::Real, ToType>(output, input.valueRadians());
+        }
+    };
+    // From Degree
+    template <class ToType>
+    struct ConverterFallback<orxonox::Degree, ToType>
+    {
+        static bool convert(ToType* output, const orxonox::Degree& input)
+        {
+            return convertValue<Ogre::Real, ToType>(output, input.valueDegrees());
+        }
+    };
+    // To Radian
+    template <class FromType>
+    struct ConverterFallback<FromType, orxonox::Radian>
+    {
+        static bool convert(orxonox::Radian* output, const FromType& input)
+        {
+            float temp;
+            if (convertValue(&temp, input))
+            {
+                *output = temp;
+                return true;
+            }
+            else
+                return false;
+        }
+    };
+    // To Degree
+    template <class FromType>
+    struct ConverterFallback<FromType, orxonox::Degree>
+    {
+        static bool convert(orxonox::Degree* output, const FromType& input)
+        {
+            float temp;
+            if (convertValue(&temp, input))
+            {
+                *output = temp;
+                return true;
+            }
+            else
+                return false;
+        }
+    };
+}
 #endif /* _MathConvert_H__ */

code/trunk/src/util/MultiType.cc

-                      r2087
+                      r2171
 /**
     @file MultiType.cc
+    @file
     @brief Implementation of the MultiType.
 */
 …
 #include "MultiTypeValue.h"
+/**
+    @brief Converts the current value of the MultiType to a new type.
+    @param type The type
+*/
+bool MultiType::convert(MT_Type type)
+namespace orxonox
+{
+    switch (type)
+    /**
+        @brief Converts the current value of the MultiType to a new type.
+        @param type The type
+    */
+    bool MultiType::convert(MT_Type type)
+    {
+        case MT_char:
+            return this->convert<char>(); break;
+        case MT_uchar:
+            return this->convert<unsigned char>(); break;
+        case MT_short:
+            return this->convert<short>(); break;
+        case MT_ushort:
+            return this->convert<unsigned short>(); break;
+        case MT_int:
+            return this->convert<int>(); break;
+        case MT_uint:
+            return this->convert<unsigned int>(); break;
+        case MT_long:
+            return this->convert<long>(); break;
+        case MT_ulong:
+            return this->convert<unsigned long>(); break;
+        case MT_longlong:
+            return this->convert<long long>(); break;
+        case MT_ulonglong:
+            return this->convert<unsigned long long>(); break;
+        case MT_float:
+            return this->convert<float>(); break;
+        case MT_double:
+            return this->convert<double>(); break;
+        case MT_longdouble:
+            return this->convert<long double>(); break;
+        case MT_bool:
+            return this->convert<bool>(); break;
+        case MT_void:
+            return this->convert<void*>(); break;
+        case MT_string:
+            return this->convert<std::string>(); break;
+        case MT_vector2:
+            return this->convert<orxonox::Vector2>(); break;
+        case MT_vector3:
+            return this->convert<orxonox::Vector3>(); break;
+        case MT_vector4:
+            return this->convert<orxonox::Vector4>(); break;
+        case MT_colourvalue:
+            return this->convert<orxonox::ColourValue>(); break;
+        case MT_quaternion:
+            return this->convert<orxonox::Quaternion>(); break;
+        case MT_radian:
+            return this->convert<orxonox::Radian>(); break;
+        case MT_degree:
+            return this->convert<orxonox::Degree>(); break;
+        default:
+            this->reset(); return false; break;
+    };
+        switch (type)
+        {
+            case MT_char:
+                return this->convert<char>(); break;
+            case MT_uchar:
+                return this->convert<unsigned char>(); break;
+            case MT_short:
+                return this->convert<short>(); break;
+            case MT_ushort:
+                return this->convert<unsigned short>(); break;
+            case MT_int:
+                return this->convert<int>(); break;
+            case MT_uint:
+                return this->convert<unsigned int>(); break;
+            case MT_long:
+                return this->convert<long>(); break;
+            case MT_ulong:
+                return this->convert<unsigned long>(); break;
+            case MT_longlong:
+                return this->convert<long long>(); break;
+            case MT_ulonglong:
+                return this->convert<unsigned long long>(); break;
+            case MT_float:
+                return this->convert<float>(); break;
+            case MT_double:
+                return this->convert<double>(); break;
+            case MT_longdouble:
+                return this->convert<long double>(); break;
+            case MT_bool:
+                return this->convert<bool>(); break;
+            case MT_void:
+                return this->convert<void*>(); break;
+            case MT_string:
+                return this->convert<std::string>(); break;
+            case MT_vector2:
+                return this->convert<orxonox::Vector2>(); break;
+            case MT_vector3:
+                return this->convert<orxonox::Vector3>(); break;
+            case MT_vector4:
+                return this->convert<orxonox::Vector4>(); break;
+            case MT_colourvalue:
+                return this->convert<orxonox::ColourValue>(); break;
+            case MT_quaternion:
+                return this->convert<orxonox::Quaternion>(); break;
+            case MT_radian:
+                return this->convert<orxonox::Radian>(); break;
+            case MT_degree:
+                return this->convert<orxonox::Degree>(); break;
+            default:
+                this->reset(); return false; break;
+        };
+    }
+    /**
+        @brief Returns the name of the current type.
+        @return The name
+    */
+    std::string MultiType::getTypename() const
+    {
+        MT_Type type = (this->value_) ? this->value_->type_ : MT_null;
+        switch (type)
+        {
+            case MT_char:
+                return "char"; break;
+            case MT_uchar:
+                return "unsigned char"; break;
+            case MT_short:
+                return "short"; break;
+            case MT_ushort:
+                return "unsigned short"; break;
+            case MT_int:
+                return "int"; break;
+            case MT_uint:
+                return "unsigned int"; break;
+            case MT_long:
+                return "long"; break;
+            case MT_ulong:
+                return "unsigned long"; break;
+            case MT_longlong:
+                return "long long"; break;
+            case MT_ulonglong:
+                return "unsigned long long"; break;
+            case MT_float:
+                return "float"; break;
+            case MT_double:
+                return "double"; break;
+            case MT_longdouble:
+                return "long double"; break;
+            case MT_bool:
+                return "bool"; break;
+            case MT_void:
+                return "void*"; break;
+            case MT_string:
+                return "std::string"; break;
+            case MT_vector2:
+                return "orxonox::Vector2"; break;
+            case MT_vector3:
+                return "orxonox::Vector3"; break;
+            case MT_vector4:
+                return "orxonox::Vector4"; break;
+            case MT_colourvalue:
+                return "orxonox::ColourValue"; break;
+            case MT_quaternion:
+                return "orxonox::Quaternion"; break;
+            case MT_radian:
+                return "orxonox::Radian"; break;
+            case MT_degree:
+                return "orxonox::Degree"; break;
+            default:
+                return "unknown"; break;
+        };
+    }
+    MultiType::operator char()                 const { return (this->value_) ? ((this->value_->type_ == MT_char       ) ? ((MT_Value<char>                *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator unsigned char()        const { return (this->value_) ? ((this->value_->type_ == MT_uchar      ) ? ((MT_Value<unsigned char>       *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator short()                const { return (this->value_) ? ((this->value_->type_ == MT_short      ) ? ((MT_Value<short>               *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator unsigned short()       const { return (this->value_) ? ((this->value_->type_ == MT_ushort     ) ? ((MT_Value<unsigned short>      *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator int()                  const { return (this->value_) ? ((this->value_->type_ == MT_int        ) ? ((MT_Value<int>                 *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator unsigned int()         const { return (this->value_) ? ((this->value_->type_ == MT_uint       ) ? ((MT_Value<unsigned int>        *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator long()                 const { return (this->value_) ? ((this->value_->type_ == MT_long       ) ? ((MT_Value<long>                *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator unsigned long()        const { return (this->value_) ? ((this->value_->type_ == MT_ulong      ) ? ((MT_Value<unsigned long>       *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator long long()            const { return (this->value_) ? ((this->value_->type_ == MT_longlong   ) ? ((MT_Value<long long>           *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator unsigned long long()   const { return (this->value_) ? ((this->value_->type_ == MT_ulonglong  ) ? ((MT_Value<unsigned long long>  *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator float()                const { return (this->value_) ? ((this->value_->type_ == MT_float      ) ? ((MT_Value<float>               *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator double()               const { return (this->value_) ? ((this->value_->type_ == MT_double     ) ? ((MT_Value<double>              *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator long double()          const { return (this->value_) ? ((this->value_->type_ == MT_longdouble ) ? ((MT_Value<long double>         *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator bool()                 const { return (this->value_) ? ((this->value_->type_ == MT_bool       ) ? ((MT_Value<bool>                *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator void*()                const { return (this->value_) ? ((this->value_->type_ == MT_void       ) ? ((MT_Value<void*>               *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator std::string()          const { return (this->value_) ? ((this->value_->type_ == MT_string     ) ? ((MT_Value<std::string>         *)this->value_)->value_ : (*this->value_)) : zeroise<std::string>();          } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator orxonox::Vector2()     const { return (this->value_) ? ((this->value_->type_ == MT_vector2    ) ? ((MT_Value<orxonox::Vector2>    *)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::Vector2>();     } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator orxonox::Vector3()     const { return (this->value_) ? ((this->value_->type_ == MT_vector3    ) ? ((MT_Value<orxonox::Vector3>    *)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::Vector3>();     } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator orxonox::Vector4()     const { return (this->value_) ? ((this->value_->type_ == MT_vector4    ) ? ((MT_Value<orxonox::Vector4>    *)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::Vector4>();     } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator orxonox::ColourValue() const { return (this->value_) ? ((this->value_->type_ == MT_colourvalue) ? ((MT_Value<orxonox::ColourValue>*)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::ColourValue>(); } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator orxonox::Quaternion()  const { return (this->value_) ? ((this->value_->type_ == MT_quaternion ) ? ((MT_Value<orxonox::Quaternion> *)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::Quaternion>();  } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator orxonox::Radian()      const { return (this->value_) ? ((this->value_->type_ == MT_radian     ) ? ((MT_Value<orxonox::Radian>     *)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::Radian>();      } /** @brief Returns the current value, converted to the requested type. */
+    MultiType::operator orxonox::Degree()      const { return (this->value_) ? ((this->value_->type_ == MT_degree     ) ? ((MT_Value<orxonox::Degree>     *)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::Degree>();      } /** @brief Returns the current value, converted to the requested type. */
+    template <> void MultiType::createNewValueContainer(const char& value)                 { this->value_ = new MT_Value<char>                (value, MT_char       ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const unsigned char& value)        { this->value_ = new MT_Value<unsigned char>       (value, MT_uchar      ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const short& value)                { this->value_ = new MT_Value<short>               (value, MT_short      ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const unsigned short& value)       { this->value_ = new MT_Value<unsigned short>      (value, MT_ushort     ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const int& value)                  { this->value_ = new MT_Value<int>                 (value, MT_int        ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const unsigned int& value)         { this->value_ = new MT_Value<unsigned int>        (value, MT_uint       ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const long& value)                 { this->value_ = new MT_Value<long>                (value, MT_long       ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const unsigned long& value)        { this->value_ = new MT_Value<unsigned long>       (value, MT_ulong      ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const long long& value)            { this->value_ = new MT_Value<long long>           (value, MT_longlong   ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const unsigned long long& value)   { this->value_ = new MT_Value<unsigned long long>  (value, MT_ulonglong  ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const float& value)                { this->value_ = new MT_Value<float>               (value, MT_float      ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const double& value)               { this->value_ = new MT_Value<double>              (value, MT_double     ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const long double& value)          { this->value_ = new MT_Value<long double>         (value, MT_longdouble ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const bool& value)                 { this->value_ = new MT_Value<bool>                (value, MT_bool       ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(      void* const& value)          { this->value_ = new MT_Value<void*>               (value, MT_void       ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const std::string& value)          { this->value_ = new MT_Value<std::string>         (value, MT_string     ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const orxonox::Vector2& value)     { this->value_ = new MT_Value<orxonox::Vector2>    (value, MT_vector2    ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const orxonox::Vector3& value)     { this->value_ = new MT_Value<orxonox::Vector3>    (value, MT_vector3    ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const orxonox::Vector4& value)     { this->value_ = new MT_Value<orxonox::Vector4>    (value, MT_vector4    ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const orxonox::ColourValue& value) { this->value_ = new MT_Value<orxonox::ColourValue>(value, MT_colourvalue); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const orxonox::Quaternion& value)  { this->value_ = new MT_Value<orxonox::Quaternion> (value, MT_quaternion ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const orxonox::Radian& value)      { this->value_ = new MT_Value<orxonox::Radian>     (value, MT_radian     ); } /** @brief Creates a new value container for the given type. */
+    template <> void MultiType::createNewValueContainer(const orxonox::Degree& value)      { this->value_ = new MT_Value<orxonox::Degree>     (value, MT_degree     ); } /** @brief Creates a new value container for the given type. */
+}
-/**
-    @brief Returns the name of the current type.
-    @return The name
-*/
-std::string MultiType::getTypename() const
+{
-    MT_Type type = (this->value_) ? this->value_->type_ : MT_null;
-    switch (type)
+    {
-        case MT_char:
-            return "char"; break;
-        case MT_uchar:
-            return "unsigned char"; break;
-        case MT_short:
-            return "short"; break;
-        case MT_ushort:
-            return "unsigned short"; break;
-        case MT_int:
-            return "int"; break;
-        case MT_uint:
-            return "unsigned int"; break;
-        case MT_long:
-            return "long"; break;
-        case MT_ulong:
-            return "unsigned long"; break;
-        case MT_longlong:
-            return "long long"; break;
-        case MT_ulonglong:
-            return "unsigned long long"; break;
-        case MT_float:
-            return "float"; break;
-        case MT_double:
-            return "double"; break;
-        case MT_longdouble:
-            return "long double"; break;
-        case MT_bool:
-            return "bool"; break;
-        case MT_void:
-            return "void*"; break;
-        case MT_string:
-            return "std::string"; break;
-        case MT_vector2:
-            return "orxonox::Vector2"; break;
-        case MT_vector3:
-            return "orxonox::Vector3"; break;
-        case MT_vector4:
-            return "orxonox::Vector4"; break;
-        case MT_colourvalue:
-            return "orxonox::ColourValue"; break;
-        case MT_quaternion:
-            return "orxonox::Quaternion"; break;
-        case MT_radian:
-            return "orxonox::Radian"; break;
-        case MT_degree:
-            return "orxonox::Degree"; break;
-        default:
-            return "unknown"; break;
-    };
+}
-MultiType::operator char()                 const { return (this->value_) ? ((this->value_->type_ == MT_char       ) ? ((MT_Value<char>                *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator unsigned char()        const { return (this->value_) ? ((this->value_->type_ == MT_uchar      ) ? ((MT_Value<unsigned char>       *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator short()                const { return (this->value_) ? ((this->value_->type_ == MT_short      ) ? ((MT_Value<short>               *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator unsigned short()       const { return (this->value_) ? ((this->value_->type_ == MT_ushort     ) ? ((MT_Value<unsigned short>      *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator int()                  const { return (this->value_) ? ((this->value_->type_ == MT_int        ) ? ((MT_Value<int>                 *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator unsigned int()         const { return (this->value_) ? ((this->value_->type_ == MT_uint       ) ? ((MT_Value<unsigned int>        *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator long()                 const { return (this->value_) ? ((this->value_->type_ == MT_long       ) ? ((MT_Value<long>                *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator unsigned long()        const { return (this->value_) ? ((this->value_->type_ == MT_ulong      ) ? ((MT_Value<unsigned long>       *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator long long()            const { return (this->value_) ? ((this->value_->type_ == MT_longlong   ) ? ((MT_Value<long long>           *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator unsigned long long()   const { return (this->value_) ? ((this->value_->type_ == MT_ulonglong  ) ? ((MT_Value<unsigned long long>  *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator float()                const { return (this->value_) ? ((this->value_->type_ == MT_float      ) ? ((MT_Value<float>               *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator double()               const { return (this->value_) ? ((this->value_->type_ == MT_double     ) ? ((MT_Value<double>              *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator long double()          const { return (this->value_) ? ((this->value_->type_ == MT_longdouble ) ? ((MT_Value<long double>         *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator bool()                 const { return (this->value_) ? ((this->value_->type_ == MT_bool       ) ? ((MT_Value<bool>                *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator void*()                const { return (this->value_) ? ((this->value_->type_ == MT_void       ) ? ((MT_Value<void*>               *)this->value_)->value_ : (*this->value_)) : 0;                      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator std::string()          const { return (this->value_) ? ((this->value_->type_ == MT_string     ) ? ((MT_Value<std::string>         *)this->value_)->value_ : (*this->value_)) : zeroise<std::string>();          } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator orxonox::Vector2()     const { return (this->value_) ? ((this->value_->type_ == MT_vector2    ) ? ((MT_Value<orxonox::Vector2>    *)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::Vector2>();     } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator orxonox::Vector3()     const { return (this->value_) ? ((this->value_->type_ == MT_vector3    ) ? ((MT_Value<orxonox::Vector3>    *)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::Vector3>();     } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator orxonox::Vector4()     const { return (this->value_) ? ((this->value_->type_ == MT_vector4    ) ? ((MT_Value<orxonox::Vector4>    *)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::Vector4>();     } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator orxonox::ColourValue() const { return (this->value_) ? ((this->value_->type_ == MT_colourvalue) ? ((MT_Value<orxonox::ColourValue>*)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::ColourValue>(); } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator orxonox::Quaternion()  const { return (this->value_) ? ((this->value_->type_ == MT_quaternion ) ? ((MT_Value<orxonox::Quaternion> *)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::Quaternion>();  } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator orxonox::Radian()      const { return (this->value_) ? ((this->value_->type_ == MT_radian     ) ? ((MT_Value<orxonox::Radian>     *)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::Radian>();      } /** @brief Returns the current value, converted to the requested type. */
-MultiType::operator orxonox::Degree()      const { return (this->value_) ? ((this->value_->type_ == MT_degree     ) ? ((MT_Value<orxonox::Degree>     *)this->value_)->value_ : (*this->value_)) : zeroise<orxonox::Degree>();      } /** @brief Returns the current value, converted to the requested type. */
-template <> void MultiType::createNewValueContainer(const char& value)                 { this->value_ = new MT_Value<char>                (value, MT_char       ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const unsigned char& value)        { this->value_ = new MT_Value<unsigned char>       (value, MT_uchar      ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const short& value)                { this->value_ = new MT_Value<short>               (value, MT_short      ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const unsigned short& value)       { this->value_ = new MT_Value<unsigned short>      (value, MT_ushort     ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const int& value)                  { this->value_ = new MT_Value<int>                 (value, MT_int        ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const unsigned int& value)         { this->value_ = new MT_Value<unsigned int>        (value, MT_uint       ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const long& value)                 { this->value_ = new MT_Value<long>                (value, MT_long       ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const unsigned long& value)        { this->value_ = new MT_Value<unsigned long>       (value, MT_ulong      ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const long long& value)            { this->value_ = new MT_Value<long long>           (value, MT_longlong   ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const unsigned long long& value)   { this->value_ = new MT_Value<unsigned long long>  (value, MT_ulonglong  ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const float& value)                { this->value_ = new MT_Value<float>               (value, MT_float      ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const double& value)               { this->value_ = new MT_Value<double>              (value, MT_double     ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const long double& value)          { this->value_ = new MT_Value<long double>         (value, MT_longdouble ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const bool& value)                 { this->value_ = new MT_Value<bool>                (value, MT_bool       ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(      void* const& value)          { this->value_ = new MT_Value<void*>               (value, MT_void       ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const std::string& value)          { this->value_ = new MT_Value<std::string>         (value, MT_string     ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const orxonox::Vector2& value)     { this->value_ = new MT_Value<orxonox::Vector2>    (value, MT_vector2    ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const orxonox::Vector3& value)     { this->value_ = new MT_Value<orxonox::Vector3>    (value, MT_vector3    ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const orxonox::Vector4& value)     { this->value_ = new MT_Value<orxonox::Vector4>    (value, MT_vector4    ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const orxonox::ColourValue& value) { this->value_ = new MT_Value<orxonox::ColourValue>(value, MT_colourvalue); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const orxonox::Quaternion& value)  { this->value_ = new MT_Value<orxonox::Quaternion> (value, MT_quaternion ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const orxonox::Radian& value)      { this->value_ = new MT_Value<orxonox::Radian>     (value, MT_radian     ); } /** @brief Creates a new value container for the given type. */
-template <> void MultiType::createNewValueContainer(const orxonox::Degree& value)      { this->value_ = new MT_Value<orxonox::Degree>     (value, MT_degree     ); } /** @brief Creates a new value container for the given type. */

code/trunk/src/util/MultiType.h

-                      r2087
+                      r2171
 /**
     @file MultiType.h
+    @file
     @brief Declaration of the MultiType and some helper constructs.
 …
 #include "Math.h"
+/**
+    @brief Enum of all possible types of a MultiType.
+*/
+enum MT_Type
+namespace orxonox
+{
-    MT_null,
-    MT_char,
-    MT_uchar,
-    MT_short,
-    MT_ushort,
-    MT_int,
-    MT_uint,
-    MT_long,
-    MT_ulong,
-    MT_longlong,
-    MT_ulonglong,
-    MT_float,
-    MT_double,
-    MT_longdouble,
-    MT_bool,
-    MT_void,
-    MT_string,
-    MT_vector2,
-    MT_vector3,
-    MT_vector4,
-    MT_colourvalue,
-    MT_quaternion,
-    MT_radian,
-    MT_degree
-};
-/**
-    @brief The MultiType can hold a value of many possible types and convert them to other types.
-    The following types are supported by the MultiType:
-     - all primitves
-     - all pointers
-     - string
-     - Vector2, Vector3, Vector4
-     - Quaternion
-     - ColourValue
-     - Radian, Degree
-    The internal type of a MultiType is determined by the first assigned value, but can be
-    changed by using setType<T>(), convert<T>() or setValue<T>(value). If a value gets assigned
-    the normal way (operator=, setValue(value)), the value gets converted to the current internal
-    type of the MultiType.
-*/
-class _UtilExport MultiType
+{
-    _UtilExport friend std::ostream& operator<<(std::ostream& outstream, const MultiType& mt);
-    template <typename T> friend struct MT_Value;
     /**
+        @brief MT_ValueBase is an almost pure virtual baseclass of MT_Value<T>, which holds the value of the MultiType.
+        This class is only used within the MultiType.
+        @brief Enum of all possible types of a MultiType.
     */
     struct _UtilExport MT_ValueBase
+    enum MT_Type
+    {
+        MT_ValueBase(MT_Type type) : type_(type), bHasDefaultValue_(false) {}
+        virtual ~MT_ValueBase() {}
+        virtual MT_ValueBase* clone() const = 0;
+        virtual void reset() = 0;
+        virtual bool assimilate(const MultiType& other) = 0;
+        /** @brief Returns the type of the current value. */
+        const MT_Type& getType() const { return this->type_; }
+        /** @brief Checks whether the value is a default one. */
+        bool hasDefaultValue()   const { return this->bHasDefaultValue_; }
+        virtual bool setValue(const char& value)                 = 0;
+        virtual bool setValue(const unsigned char& value)        = 0;
+        virtual bool setValue(const short& value)                = 0;
+        virtual bool setValue(const unsigned short& value)       = 0;
+        virtual bool setValue(const int& value)                  = 0;
+        virtual bool setValue(const unsigned int& value)         = 0;
+        virtual bool setValue(const long& value)                 = 0;
+        virtual bool setValue(const unsigned long& value)        = 0;
+        virtual bool setValue(const long long& value)            = 0;
+        virtual bool setValue(const unsigned long long& value)   = 0;
+        virtual bool setValue(const float& value)                = 0;
+        virtual bool setValue(const double& value)               = 0;
+        virtual bool setValue(const long double& value)          = 0;
+        virtual bool setValue(const bool& value)                 = 0;
+        virtual bool setValue(      void* const& value)          = 0;
+        virtual bool setValue(const std::string& value)          = 0;
+        virtual bool setValue(const orxonox::Vector2& value)     = 0;
+        virtual bool setValue(const orxonox::Vector3& value)     = 0;
+        virtual bool setValue(const orxonox::Vector4& value)     = 0;
+        virtual bool setValue(const orxonox::ColourValue& value) = 0;
+        virtual bool setValue(const orxonox::Quaternion& value)  = 0;
+        virtual bool setValue(const orxonox::Radian& value)      = 0;
+        virtual bool setValue(const orxonox::Degree& value)      = 0;
+        virtual bool getValue(char*                 value) const = 0;
+        virtual bool getValue(unsigned char*        value) const = 0;
+        virtual bool getValue(short*                value) const = 0;
+        virtual bool getValue(unsigned short*       value) const = 0;
+        virtual bool getValue(int*                  value) const = 0;
+        virtual bool getValue(unsigned int*         value) const = 0;
+        virtual bool getValue(long*                 value) const = 0;
+        virtual bool getValue(unsigned long*        value) const = 0;
+        virtual bool getValue(long long*            value) const = 0;
+        virtual bool getValue(unsigned long long*   value) const = 0;
+        virtual bool getValue(float*                value) const = 0;
+        virtual bool getValue(double*               value) const = 0;
+        virtual bool getValue(long double*          value) const = 0;
+        virtual bool getValue(bool*                 value) const = 0;
+        virtual bool getValue(void**                value) const = 0;
+        virtual bool getValue(std::string*          value) const = 0;
+        virtual bool getValue(orxonox::Vector2*     value) const = 0;
+        virtual bool getValue(orxonox::Vector3*     value) const = 0;
+        virtual bool getValue(orxonox::Vector4*     value) const = 0;
+        virtual bool getValue(orxonox::ColourValue* value) const = 0;
+        virtual bool getValue(orxonox::Quaternion*  value) const = 0;
+        virtual bool getValue(orxonox::Radian*      value) const = 0;
+        virtual bool getValue(orxonox::Degree*      value) const = 0;
+        virtual operator char()                 const = 0;
+        virtual operator unsigned char()        const = 0;
+        virtual operator short()                const = 0;
+        virtual operator unsigned short()       const = 0;
+        virtual operator int()                  const = 0;
+        virtual operator unsigned int()         const = 0;
+        virtual operator long()                 const = 0;
+        virtual operator unsigned long()        const = 0;
+        virtual operator long long()            const = 0;
+        virtual operator unsigned long long()   const = 0;
+        virtual operator float()                const = 0;
+        virtual operator double()               const = 0;
+        virtual operator long double()          const = 0;
+        virtual operator bool()                 const = 0;
+        virtual operator void*()                const = 0;
+        virtual operator std::string()          const = 0;
+        virtual operator orxonox::Vector2()     const = 0;
+        virtual operator orxonox::Vector3()     const = 0;
+        virtual operator orxonox::Vector4()     const = 0;
+        virtual operator orxonox::ColourValue() const = 0;
+        virtual operator orxonox::Quaternion()  const = 0;
+        virtual operator orxonox::Radian()      const = 0;
+        virtual operator orxonox::Degree()      const = 0;
+        virtual void toString(std::ostream& outstream) const = 0;
+        MT_Type type_;          //!< The type of the current value
+        bool bHasDefaultValue_; //!< True if the last conversion wasn't successful
+        MT_null,
+        MT_char,
+        MT_uchar,
+        MT_short,
+        MT_ushort,
+        MT_int,
+        MT_uint,
+        MT_long,
+        MT_ulong,
+        MT_longlong,
+        MT_ulonglong,
+        MT_float,
+        MT_double,
+        MT_longdouble,
+        MT_bool,
+        MT_void,
+        MT_string,
+        MT_vector2,
+        MT_vector3,
+        MT_vector4,
+        MT_colourvalue,
+        MT_quaternion,
+        MT_radian,
+        MT_degree
     };
+    /**
+        @brief The MultiType can hold a value of many possible types and convert them to other types.
+        The following types are supported by the MultiType:
+         - all primitves
+         - all pointers
+         - string
+         - Vector2, Vector3, Vector4
+         - Quaternion
+         - ColourValue
+         - Radian, Degree
+        The internal type of a MultiType is determined by the first assigned value, but can be
+        changed by using setType<T>(), convert<T>() or setValue<T>(value). If a value gets assigned
+        the normal way (operator=, setValue(value)), the value gets converted to the current internal
+        type of the MultiType.
+    */
+    class _UtilExport MultiType
+    {
+        _UtilExport friend std::ostream& operator<<(std::ostream& outstream, const MultiType& mt);
+        template <typename T> friend class MT_Value;
     public:
+        inline MultiType()                                  : value_(0) {}                                      /** @brief Default constructor: Assigns no value and no type. The type will be determined by the first assignment of a value. */
+        inline MultiType(const char& value)                 : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+        inline MultiType(const unsigned char& value)        : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+        inline MultiType(const short& value)                : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+        inline MultiType(const unsigned short& value)       : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+        inline MultiType(const int& value)                  : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+        inline MultiType(const unsigned int& value)         : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+        inline MultiType(const long& value)                 : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+        inline MultiType(const unsigned long& value)        : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+        inline MultiType(const long long& value)            : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+        inline MultiType(const unsigned long long& value)   : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+        inline MultiType(const float& value)                : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+        inline MultiType(const double& value)               : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+        inline MultiType(const long double& value)          : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+        inline MultiType(const bool& value)                 : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+        inline MultiType(      void* const& value)          : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+        inline MultiType(const std::string& value)          : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+        inline MultiType(const orxonox::Vector2& value)     : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+        inline MultiType(const orxonox::Vector3& value)     : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+        inline MultiType(const orxonox::Vector4& value)     : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+        inline MultiType(const orxonox::ColourValue& value) : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+        inline MultiType(const orxonox::Quaternion& value)  : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+        inline MultiType(const orxonox::Radian& value)      : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+        inline MultiType(const orxonox::Degree& value)      : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+        inline MultiType(const char* value)                 : value_(0) { this->setValue(std::string(value)); } /** @brief Constructor: Converts the char array to a std::string, assigns the value and sets the type. */
+        inline MultiType(const MultiType& other)            : value_(0) { this->setValue(other); }              /** @brief Copyconstructor: Assigns value and type of the other MultiType. */
+        inline MultiType(MT_Type type)                      : value_(0) { this->setType(type); }                /** @brief Constructor: Sets the type, the next assignment will determine the value. */
+        /** @brief Destructor: Deletes the MT_Value. */
+        inline ~MultiType() { if (this->value_) { delete this->value_; } }
+        template <typename V> inline const MultiType& operator=(const V& value)         { this->setValue(value); return (*this); } /** @brief Assigns a new value. The value will be converted to the current type of the MultiType. */
+        template <typename V> inline const MultiType& operator=(V* value)               { this->setValue(value); return (*this); } /** @brief Assigns a pointer. */
+        inline                       const MultiType& operator=(const MultiType& other) { this->setValue(other); return (*this); } /** @brief Assigns the value of the other MultiType and converts it to the current type of the MultiType. */
+        inline                       const MultiType& operator=(MT_Type type)           { this->setType(type);   return (*this); } /** @brief Resets the value and changes the type. */
+        inline bool                                   setValue(const char& value);
+        inline bool                                   setValue(const unsigned char& value);
+        inline bool                                   setValue(const short& value);
+        inline bool                                   setValue(const unsigned short& value);
+        inline bool                                   setValue(const int& value);
+        inline bool                                   setValue(const unsigned int& value);
+        inline bool                                   setValue(const long& value);
+        inline bool                                   setValue(const unsigned long& value);
+        inline bool                                   setValue(const long long& value);
+        inline bool                                   setValue(const unsigned long long& value);
+        inline bool                                   setValue(const float& value);
+        inline bool                                   setValue(const double& value);
+        inline bool                                   setValue(const long double& value);
+        inline bool                                   setValue(const bool& value);
+        inline bool                                   setValue(      void* const& value);
+        inline bool                                   setValue(const std::string& value);
+        inline bool                                   setValue(const orxonox::Vector2& value);
+        inline bool                                   setValue(const orxonox::Vector3& value);
+        inline bool                                   setValue(const orxonox::Vector4& value);
+        inline bool                                   setValue(const orxonox::ColourValue& value);
+        inline bool                                   setValue(const orxonox::Quaternion& value);
+        inline bool                                   setValue(const orxonox::Radian& value);
+        inline bool                                   setValue(const orxonox::Degree& value);
+        inline bool                                   setValue(const char* value);
+        /** @brief Assigns a pointer. */
+        template <typename V> inline bool             setValue(V* value)               { if (this->value_) { return this->value_->setValue((void*)value); } else { return this->assignValue((void*)value); } }
+        /** @brief Assigns the value of the other MultiType and converts it to the current type. */
+        bool                                          setValue(const MultiType& other) { if (this->value_) { return this->value_->assimilate(other); } else { if (other.value_) { this->value_ = other.value_->clone(); } return true; } }
+        /** @brief Changes the type to T and assigns the new value (which might be of another type than T - it gets converted). */
+        template <typename T, typename V> inline bool setValue(const V& value) { this->setType<T>(); return this->setValue(value); }
+        /** @brief Copies the other MultiType by assigning value and type. */
+        inline void                       copy(const MultiType& other)    { if (this == &other) { return; } if (this->value_) { delete this->value_; } this->value_ = (other.value_) ? other.value_->clone() : 0; }
+        template <typename T> inline bool convert()                       { return this->setValue<T>((T)(*this));  } /** @brief Converts the current value to type T. */
+        inline bool                       convert(const MultiType& other) { return this->convert(other.getType()); } /** @brief Converts the current value to the type of the other MultiType. */
+        bool                              convert(MT_Type type);
+        /** @brief Current content gets deleted. New type is MT_null */
+        inline void                       reset()                         { if (this->value_) this->value_->reset(); }
+        template <typename T> inline void setType()                       { this->assignValue(T());                            } /** @brief Resets the value and changes the internal type to T. */
+        inline void                       setType(const MultiType& other) { this->setType(other.getType());                    } /** @brief Resets the value and changes the internal type to the type of the other MultiType. */
+        inline void                       setType(MT_Type type)           { this->reset(); this->convert(type); this->reset(); } /** @brief Resets the value and changes the internal type to the given type. */
+        /** @brief Returns the current type. */
+        inline MT_Type                    getType()                 const { return (this->value_) ? this->value_->type_ : MT_null; }
+        /** @brief Returns true if the current type equals the given type. */
+        inline bool                       isType(MT_Type type)      const { return (this->value_) ? (this->value_->type_ == type) : (type == MT_null); }
+        /** @brief Returns true if the current type is T. */
+        template <typename T> inline bool isType()                  const { return false; } // Only works for specialized values - see below
+        std::string                       getTypename()             const;
+        /** @brief Checks whether the value is a default one. */
+        bool                              hasDefaultValue()         const { return this->value_->hasDefaultValue(); }
+        operator char()                  const;
+        operator unsigned char()         const;
+        operator short()                 const;
+        operator unsigned short()        const;
+        operator int()                   const;
+        operator unsigned int()          const;
+        operator long()                  const;
+        operator unsigned long()         const;
+        operator long long()             const;
+        operator unsigned long long()    const;
+        operator float()                 const;
+        operator double()                const;
+        operator long double()           const;
+        operator bool()                  const;
+        operator void*()                 const;
+        operator std::string()           const;
+        operator orxonox::Vector2()      const;
+        operator orxonox::Vector3()      const;
+        operator orxonox::Vector4()      const;
+        operator orxonox::ColourValue()  const;
+        operator orxonox::Quaternion()   const;
+        operator orxonox::Radian()       const;
+        operator orxonox::Degree()       const;
+        /** @brief Returns the current value, converted to a T* pointer. */
+        template <class T> operator T*() const { return ((T*)this->operator void*()); }
+        inline bool getValue(char*                 value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(unsigned char*        value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(short*                value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(unsigned short*       value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(int*                  value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(unsigned int*         value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(long*                 value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(unsigned long*        value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(long long*            value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(unsigned long long*   value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(float*                value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(double*               value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(long double*          value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(bool*                 value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(void**                value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(std::string*          value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(orxonox::Vector2*     value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(orxonox::Vector3*     value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(orxonox::Vector4*     value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(orxonox::ColourValue* value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(orxonox::Quaternion*  value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(orxonox::Radian*      value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(orxonox::Degree*      value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline char                     getChar()             const { return this->operator char();                 } /** @brief Returns the current value, converted to the requested type. */
+        inline unsigned char            getUnsignedChar()     const { return this->operator unsigned char();        } /** @brief Returns the current value, converted to the requested type. */
+        inline short                    getShort()            const { return this->operator short();                } /** @brief Returns the current value, converted to the requested type. */
+        inline unsigned short           getUnsignedShort()    const { return this->operator unsigned short();       } /** @brief Returns the current value, converted to the requested type. */
+        inline int                      getInt()              const { return this->operator int();                  } /** @brief Returns the current value, converted to the requested type. */
+        inline unsigned int             getUnsignedInt()      const { return this->operator unsigned int();         } /** @brief Returns the current value, converted to the requested type. */
+        inline long                     getLong()             const { return this->operator long();                 } /** @brief Returns the current value, converted to the requested type. */
+        inline unsigned long            getUnsignedLong()     const { return this->operator unsigned long();        } /** @brief Returns the current value, converted to the requested type. */
+        inline long long                getLongLong()         const { return this->operator long long();            } /** @brief Returns the current value, converted to the requested type. */
+        inline unsigned long long       getUnsignedLongLong() const { return this->operator unsigned long long();   } /** @brief Returns the current value, converted to the requested type. */
+        inline float                    getFloat()            const { return this->operator float();                } /** @brief Returns the current value, converted to the requested type. */
+        inline double                   getDouble()           const { return this->operator double();               } /** @brief Returns the current value, converted to the requested type. */
+        inline long double              getLongDouble()       const { return this->operator long double();          } /** @brief Returns the current value, converted to the requested type. */
+        inline bool                     getBool()             const { return this->operator bool();                 } /** @brief Returns the current value, converted to the requested type. */
+        inline void*                    getVoid()             const { return this->operator void*();                } /** @brief Returns the current value, converted to the requested type. */
+        inline std::string              getString()           const { return this->operator std::string();          } /** @brief Returns the current value, converted to the requested type. */
+        inline orxonox::Vector2         getVector2()          const { return this->operator orxonox::Vector2();     } /** @brief Returns the current value, converted to the requested type. */
+        inline orxonox::Vector3         getVector3()          const { return this->operator orxonox::Vector3();     } /** @brief Returns the current value, converted to the requested type. */
+        inline orxonox::Vector4         getVector4()          const { return this->operator orxonox::Vector4();     } /** @brief Returns the current value, converted to the requested type. */
+        inline orxonox::ColourValue     getColourValue()      const { return this->operator orxonox::ColourValue(); } /** @brief Returns the current value, converted to the requested type. */
+        inline orxonox::Quaternion      getQuaternion()       const { return this->operator orxonox::Quaternion();  } /** @brief Returns the current value, converted to the requested type. */
+        inline orxonox::Radian          getRadian()           const { return this->operator orxonox::Radian();      } /** @brief Returns the current value, converted to the requested type. */
+        inline orxonox::Degree          getDegree()           const { return this->operator orxonox::Degree();      } /** @brief Returns the current value, converted to the requested type. */
+        template <typename T> inline T* getPointer()          const { return ((T*)this->getVoid());                 } /** @brief Returns the current value, converted to a T* pointer. */
+    private:
+        inline bool assignValue(const char& value)                 { if (this->value_ && this->value_->type_ == MT_char)        { return this->value_->setValue(value); } else { this->changeValueContainer<char>(value);                 return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const unsigned char& value)        { if (this->value_ && this->value_->type_ == MT_uchar)       { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned char>(value);        return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const short& value)                { if (this->value_ && this->value_->type_ == MT_short)       { return this->value_->setValue(value); } else { this->changeValueContainer<short>(value);                return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const unsigned short& value)       { if (this->value_ && this->value_->type_ == MT_ushort)      { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned short>(value);       return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const int& value)                  { if (this->value_ && this->value_->type_ == MT_int)         { return this->value_->setValue(value); } else { this->changeValueContainer<int>(value);                  return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const unsigned int& value)         { if (this->value_ && this->value_->type_ == MT_uint)        { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned int>(value);         return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const long& value)                 { if (this->value_ && this->value_->type_ == MT_long)        { return this->value_->setValue(value); } else { this->changeValueContainer<long>(value);                 return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const unsigned long& value)        { if (this->value_ && this->value_->type_ == MT_ulong)       { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned long>(value);        return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const long long& value)            { if (this->value_ && this->value_->type_ == MT_longlong)    { return this->value_->setValue(value); } else { this->changeValueContainer<long long>(value);            return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const unsigned long long& value)   { if (this->value_ && this->value_->type_ == MT_ulonglong)   { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned long long>(value);   return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const float& value)                { if (this->value_ && this->value_->type_ == MT_float)       { return this->value_->setValue(value); } else { this->changeValueContainer<float>(value);                return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const double& value)               { if (this->value_ && this->value_->type_ == MT_double)      { return this->value_->setValue(value); } else { this->changeValueContainer<double>(value);               return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const long double& value)          { if (this->value_ && this->value_->type_ == MT_longdouble)  { return this->value_->setValue(value); } else { this->changeValueContainer<long double>(value);          return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const bool& value)                 { if (this->value_ && this->value_->type_ == MT_bool)        { return this->value_->setValue(value); } else { this->changeValueContainer<bool>(value);                 return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(      void* const& value)          { if (this->value_ && this->value_->type_ == MT_void)        { return this->value_->setValue(value); } else { this->changeValueContainer<void*>(value);                return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const std::string& value)          { if (this->value_ && this->value_->type_ == MT_string)      { return this->value_->setValue(value); } else { this->changeValueContainer<std::string>(value);          return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const orxonox::Vector2& value)     { if (this->value_ && this->value_->type_ == MT_vector2)     { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector2>(value);     return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const orxonox::Vector3& value)     { if (this->value_ && this->value_->type_ == MT_vector3)     { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector3>(value);     return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const orxonox::Vector4& value)     { if (this->value_ && this->value_->type_ == MT_vector4)     { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector4>(value);     return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const orxonox::ColourValue& value) { if (this->value_ && this->value_->type_ == MT_colourvalue) { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::ColourValue>(value); return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const orxonox::Quaternion& value)  { if (this->value_ && this->value_->type_ == MT_quaternion)  { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Quaternion>(value);  return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const orxonox::Radian& value)      { if (this->value_ && this->value_->type_ == MT_radian)      { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Radian>(value);      return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        inline bool assignValue(const orxonox::Degree& value)      { if (this->value_ && this->value_->type_ == MT_degree)      { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Degree>(value);      return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+        /** @brief Changes the value container. */
+        template <typename T> inline void changeValueContainer(const T& value) { if (this->value_) { delete this->value_; } this->createNewValueContainer<T>(value); }
+        /** @brief Creates a new value container (works only with specialized types). */
+        template <typename T>        void createNewValueContainer(const T& value) { BOOST_STATIC_ASSERT(sizeof(T) == 0); return false; }
+        MT_ValueBase* value_; //!< A pointer to the value container
+};
+/** @brief Puts the MultiType on a stream by using the native << operator of the current type. */
+_UtilExport inline std::ostream& operator<<(std::ostream& outstream, const MultiType& mt) { if (mt.value_) { mt.value_->toString(outstream); } return outstream; }
+template <> inline bool MultiType::isType<char>()                 const { return (this->value_ && this->value_->type_ == MT_char);        } /** @brief Returns true if the current type equals the given type. */
+template <> inline bool MultiType::isType<unsigned char>()        const { return (this->value_ && this->value_->type_ == MT_uchar);       } /** @brief Returns true if the current type equals the given type. */
+template <> inline bool MultiType::isType<short>()                const { return (this->value_ && this->value_->type_ == MT_short);       } /** @brief Returns true if the current type equals the given type. */
+template <> inline bool MultiType::isType<unsigned short>()       const { return (this->value_ && this->value_->type_ == MT_ushort);      } /** @brief Returns true if the current type equals the given type. */
+template <> inline bool MultiType::isType<int>()                  const { return (this->value_ && this->value_->type_ == MT_int);         } /** @brief Returns true if the current type equals the given type. */
+template <> inline bool MultiType::isType<unsigned int>()         const { return (this->value_ && this->value_->type_ == MT_uint);        } /** @brief Returns true if the current type equals the given type. */
+template <> inline bool MultiType::isType<long>()                 const { return (this->value_ && this->value_->type_ == MT_long);        } /** @brief Returns true if the current type equals the given type. */
+template <> inline bool MultiType::isType<unsigned long>()        const { return (this->value_ && this->value_->type_ == MT_ulong);       } /** @brief Returns true if the current type equals the given type. */
+template <> inline bool MultiType::isType<long long>()            const { return (this->value_ && this->value_->type_ == MT_longlong);    } /** @brief Returns true if the current type equals the given type. */
+template <> inline bool MultiType::isType<unsigned long long>()   const { return (this->value_ && this->value_->type_ == MT_ulonglong);   } /** @brief Returns true if the current type equals the given type. */
+template <> inline bool MultiType::isType<float>()                const { return (this->value_ && this->value_->type_ == MT_float);       } /** @brief Returns true if the current type equals the given type. */
+template <> inline bool MultiType::isType<double>()               const { return (this->value_ && this->value_->type_ == MT_double);      } /** @brief Returns true if the current type equals the given type. */
+template <> inline bool MultiType::isType<long double>()          const { return (this->value_ && this->value_->type_ == MT_longdouble);  } /** @brief Returns true if the current type equals the given type. */
+template <> inline bool MultiType::isType<bool>()                 const { return (this->value_ && this->value_->type_ == MT_bool);        } /** @brief Returns true if the current type equals the given type. */
+template <> inline bool MultiType::isType<void*>()                const { return (this->value_ && this->value_->type_ == MT_void);        } /** @brief Returns true if the current type equals the given type. */
+template <> inline bool MultiType::isType<std::string>()          const { return (this->value_ && this->value_->type_ == MT_string);      } /** @brief Returns true if the current type equals the given type. */
+template <> inline bool MultiType::isType<orxonox::Vector2>()     const { return (this->value_ && this->value_->type_ == MT_vector2);     } /** @brief Returns true if the current type equals the given type. */
+template <> inline bool MultiType::isType<orxonox::Vector3>()     const { return (this->value_ && this->value_->type_ == MT_vector3);     } /** @brief Returns true if the current type equals the given type. */
+template <> inline bool MultiType::isType<orxonox::Vector4>()     const { return (this->value_ && this->value_->type_ == MT_vector4);     } /** @brief Returns true if the current type equals the given type. */
+template <> inline bool MultiType::isType<orxonox::ColourValue>() const { return (this->value_ && this->value_->type_ == MT_colourvalue); } /** @brief Returns true if the current type equals the given type. */
+template <> inline bool MultiType::isType<orxonox::Quaternion>()  const { return (this->value_ && this->value_->type_ == MT_quaternion);  } /** @brief Returns true if the current type equals the given type. */
+template <> inline bool MultiType::isType<orxonox::Radian>()      const { return (this->value_ && this->value_->type_ == MT_radian);      } /** @brief Returns true if the current type equals the given type. */
+template <> inline bool MultiType::isType<orxonox::Degree>()      const { return (this->value_ && this->value_->type_ == MT_degree);      } /** @brief Returns true if the current type equals the given type. */
+// Specialization to avoid ambiguities with the conversion operator
+template <> inline bool MultiType::convert<std::string>()          { return this->setValue<std::string>         (this->operator std::string());          } /** @brief Converts the current value to the given type. */
+template <> inline bool MultiType::convert<orxonox::Vector2>()     { return this->setValue<orxonox::Vector2>    (this->operator orxonox::Vector2());     } /** @brief Converts the current value to the given type. */
+template <> inline bool MultiType::convert<orxonox::Vector3>()     { return this->setValue<orxonox::Vector3>    (this->operator orxonox::Vector3());     } /** @brief Converts the current value to the given type. */
+template <> inline bool MultiType::convert<orxonox::Vector4>()     { return this->setValue<orxonox::Vector4>    (this->operator orxonox::Vector4());     } /** @brief Converts the current value to the given type. */
+template <> inline bool MultiType::convert<orxonox::ColourValue>() { return this->setValue<orxonox::ColourValue>(this->operator orxonox::ColourValue()); } /** @brief Converts the current value to the given type. */
+template <> inline bool MultiType::convert<orxonox::Quaternion>()  { return this->setValue<orxonox::Quaternion> (this->operator orxonox::Quaternion());  } /** @brief Converts the current value to the given type. */
+template <> inline bool MultiType::convert<orxonox::Radian>()      { return this->setValue<orxonox::Radian>     (this->operator orxonox::Radian());      } /** @brief Converts the current value to the given type. */
+template <> inline bool MultiType::convert<orxonox::Degree>()      { return this->setValue<orxonox::Degree>     (this->operator orxonox::Degree());      } /** @brief Converts the current value to the given type. */
+// Specialization to avoid ambiguities with the conversion operator
+template <> inline bool MultiType::convert<const std::string&>()          { return this->convert<std::string>();          } /** @brief Converts the current value to the given type. */
+template <> inline bool MultiType::convert<const orxonox::Vector2&>()     { return this->convert<orxonox::Vector2>();     } /** @brief Converts the current value to the given type. */
+template <> inline bool MultiType::convert<const orxonox::Vector3&>()     { return this->convert<orxonox::Vector3>();     } /** @brief Converts the current value to the given type. */
+template <> inline bool MultiType::convert<const orxonox::Vector4&>()     { return this->convert<orxonox::Vector4>();     } /** @brief Converts the current value to the given type. */
+template <> inline bool MultiType::convert<const orxonox::ColourValue&>() { return this->convert<orxonox::ColourValue>(); } /** @brief Converts the current value to the given type. */
+template <> inline bool MultiType::convert<const orxonox::Quaternion&>()  { return this->convert<orxonox::Quaternion>();  } /** @brief Converts the current value to the given type. */
+template <> inline bool MultiType::convert<const orxonox::Radian&>()      { return this->convert<orxonox::Radian>();      } /** @brief Converts the current value to the given type. */
+template <> inline bool MultiType::convert<const orxonox::Degree&>()      { return this->convert<orxonox::Degree>();      } /** @brief Converts the current value to the given type. */
+template <> void MultiType::createNewValueContainer(const char& value);
+template <> void MultiType::createNewValueContainer(const unsigned char& value);
+template <> void MultiType::createNewValueContainer(const short& value);
+template <> void MultiType::createNewValueContainer(const unsigned short& value);
+template <> void MultiType::createNewValueContainer(const int& value);
+template <> void MultiType::createNewValueContainer(const unsigned int& value);
+template <> void MultiType::createNewValueContainer(const long& value);
+template <> void MultiType::createNewValueContainer(const unsigned long& value);
+template <> void MultiType::createNewValueContainer(const long long& value);
+template <> void MultiType::createNewValueContainer(const unsigned long long& value);
+template <> void MultiType::createNewValueContainer(const float& value);
+template <> void MultiType::createNewValueContainer(const double& value);
+template <> void MultiType::createNewValueContainer(const bool& value);
+template <> void MultiType::createNewValueContainer(const long double& value);
+template <> void MultiType::createNewValueContainer(      void* const& value);
+template <> void MultiType::createNewValueContainer(const std::string& value);
+template <> void MultiType::createNewValueContainer(const orxonox::Vector2& value);
+template <> void MultiType::createNewValueContainer(const orxonox::Vector3& value);
+template <> void MultiType::createNewValueContainer(const orxonox::Vector4& value);
+template <> void MultiType::createNewValueContainer(const orxonox::ColourValue& value);
+template <> void MultiType::createNewValueContainer(const orxonox::Quaternion& value);
+template <> void MultiType::createNewValueContainer(const orxonox::Radian& value);
+template <> void MultiType::createNewValueContainer(const orxonox::Degree& value);
+inline bool MultiType::setValue(const char& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const unsigned char& value)         { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const short& value)                 { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const unsigned short& value)        { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const int& value)                   { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const unsigned int& value)          { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const long& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const unsigned long& value)         { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const long long& value)             { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const unsigned long long& value)    { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const float& value)                 { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const double& value)                { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const long double& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const bool& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(      void* const& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const std::string& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const orxonox::Vector2& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const orxonox::Vector3& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const orxonox::Vector4& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const orxonox::ColourValue& value)  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const orxonox::Quaternion& value)   { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const orxonox::Radian& value)       { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const orxonox::Degree& value)       { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+inline bool MultiType::setValue(const char* value)                  { if (this->value_) { return this->value_->setValue(std::string(value)); } else { return this->assignValue(std::string(value)); } }  /** @brief Assigns the given value and converts it to the current type. */
+        /**
+            @brief MT_ValueBase is an almost pure virtual baseclass of MT_Value<T>, which holds the value of the MultiType.
+            This class is only used within the MultiType.
+        */
+        class _UtilExport MT_ValueBase
+        {
+        public:
+            MT_ValueBase(MT_Type type) : type_(type), bHasDefaultValue_(false) {}
+            virtual ~MT_ValueBase() {}
+            virtual MT_ValueBase* clone() const = 0;
+            virtual void reset() = 0;
+            virtual bool assimilate(const MultiType& other) = 0;
+            /** @brief Returns the type of the current value. */
+            const MT_Type& getType() const { return this->type_; }
+            /** @brief Checks whether the value is a default one. */
+            bool hasDefaultValue()   const { return this->bHasDefaultValue_; }
+            virtual bool setValue(const char& value)                 = 0;
+            virtual bool setValue(const unsigned char& value)        = 0;
+            virtual bool setValue(const short& value)                = 0;
+            virtual bool setValue(const unsigned short& value)       = 0;
+            virtual bool setValue(const int& value)                  = 0;
+            virtual bool setValue(const unsigned int& value)         = 0;
+            virtual bool setValue(const long& value)                 = 0;
+            virtual bool setValue(const unsigned long& value)        = 0;
+            virtual bool setValue(const long long& value)            = 0;
+            virtual bool setValue(const unsigned long long& value)   = 0;
+            virtual bool setValue(const float& value)                = 0;
+            virtual bool setValue(const double& value)               = 0;
+            virtual bool setValue(const long double& value)          = 0;
+            virtual bool setValue(const bool& value)                 = 0;
+            virtual bool setValue(      void* const& value)          = 0;
+            virtual bool setValue(const std::string& value)          = 0;
+            virtual bool setValue(const orxonox::Vector2& value)     = 0;
+            virtual bool setValue(const orxonox::Vector3& value)     = 0;
+            virtual bool setValue(const orxonox::Vector4& value)     = 0;
+            virtual bool setValue(const orxonox::ColourValue& value) = 0;
+            virtual bool setValue(const orxonox::Quaternion& value)  = 0;
+            virtual bool setValue(const orxonox::Radian& value)      = 0;
+            virtual bool setValue(const orxonox::Degree& value)      = 0;
+            virtual bool getValue(char*                 value) const = 0;
+            virtual bool getValue(unsigned char*        value) const = 0;
+            virtual bool getValue(short*                value) const = 0;
+            virtual bool getValue(unsigned short*       value) const = 0;
+            virtual bool getValue(int*                  value) const = 0;
+            virtual bool getValue(unsigned int*         value) const = 0;
+            virtual bool getValue(long*                 value) const = 0;
+            virtual bool getValue(unsigned long*        value) const = 0;
+            virtual bool getValue(long long*            value) const = 0;
+            virtual bool getValue(unsigned long long*   value) const = 0;
+            virtual bool getValue(float*                value) const = 0;
+            virtual bool getValue(double*               value) const = 0;
+            virtual bool getValue(long double*          value) const = 0;
+            virtual bool getValue(bool*                 value) const = 0;
+            virtual bool getValue(void**                value) const = 0;
+            virtual bool getValue(std::string*          value) const = 0;
+            virtual bool getValue(orxonox::Vector2*     value) const = 0;
+            virtual bool getValue(orxonox::Vector3*     value) const = 0;
+            virtual bool getValue(orxonox::Vector4*     value) const = 0;
+            virtual bool getValue(orxonox::ColourValue* value) const = 0;
+            virtual bool getValue(orxonox::Quaternion*  value) const = 0;
+            virtual bool getValue(orxonox::Radian*      value) const = 0;
+            virtual bool getValue(orxonox::Degree*      value) const = 0;
+            virtual operator char()                 const = 0;
+            virtual operator unsigned char()        const = 0;
+            virtual operator short()                const = 0;
+            virtual operator unsigned short()       const = 0;
+            virtual operator int()                  const = 0;
+            virtual operator unsigned int()         const = 0;
+            virtual operator long()                 const = 0;
+            virtual operator unsigned long()        const = 0;
+            virtual operator long long()            const = 0;
+            virtual operator unsigned long long()   const = 0;
+            virtual operator float()                const = 0;
+            virtual operator double()               const = 0;
+            virtual operator long double()          const = 0;
+            virtual operator bool()                 const = 0;
+            virtual operator void*()                const = 0;
+            virtual operator std::string()          const = 0;
+            virtual operator orxonox::Vector2()     const = 0;
+            virtual operator orxonox::Vector3()     const = 0;
+            virtual operator orxonox::Vector4()     const = 0;
+            virtual operator orxonox::ColourValue() const = 0;
+            virtual operator orxonox::Quaternion()  const = 0;
+            virtual operator orxonox::Radian()      const = 0;
+            virtual operator orxonox::Degree()      const = 0;
+            virtual void toString(std::ostream& outstream) const = 0;
+            MT_Type type_;          //!< The type of the current value
+            bool bHasDefaultValue_; //!< True if the last conversion wasn't successful
+        };
+        public:
+            inline MultiType()                                  : value_(0) {}                                      /** @brief Default constructor: Assigns no value and no type. The type will be determined by the first assignment of a value. */
+            inline MultiType(const char& value)                 : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const unsigned char& value)        : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const short& value)                : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const unsigned short& value)       : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const int& value)                  : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const unsigned int& value)         : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const long& value)                 : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const unsigned long& value)        : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const long long& value)            : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const unsigned long long& value)   : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const float& value)                : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const double& value)               : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const long double& value)          : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const bool& value)                 : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(      void* const& value)          : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const std::string& value)          : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const orxonox::Vector2& value)     : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const orxonox::Vector3& value)     : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const orxonox::Vector4& value)     : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const orxonox::ColourValue& value) : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const orxonox::Quaternion& value)  : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const orxonox::Radian& value)      : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const orxonox::Degree& value)      : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
+            inline MultiType(const char* value)                 : value_(0) { this->setValue(std::string(value)); } /** @brief Constructor: Converts the char array to a std::string, assigns the value and sets the type. */
+            inline MultiType(const MultiType& other)            : value_(0) { this->setValue(other); }              /** @brief Copyconstructor: Assigns value and type of the other MultiType. */
+            inline MultiType(MT_Type type)                      : value_(0) { this->setType(type); }                /** @brief Constructor: Sets the type, the next assignment will determine the value. */
+            /** @brief Destructor: Deletes the MT_Value. */
+            inline ~MultiType() { if (this->value_) { delete this->value_; } }
+            template <typename V> inline const MultiType& operator=(const V& value)         { this->setValue(value); return (*this); } /** @brief Assigns a new value. The value will be converted to the current type of the MultiType. */
+            template <typename V> inline const MultiType& operator=(V* value)               { this->setValue(value); return (*this); } /** @brief Assigns a pointer. */
+            inline                       const MultiType& operator=(const MultiType& other) { this->setValue(other); return (*this); } /** @brief Assigns the value of the other MultiType and converts it to the current type of the MultiType. */
+            inline                       const MultiType& operator=(MT_Type type)           { this->setType(type);   return (*this); } /** @brief Resets the value and changes the type. */
+            inline bool                                   setValue(const char& value);
+            inline bool                                   setValue(const unsigned char& value);
+            inline bool                                   setValue(const short& value);
+            inline bool                                   setValue(const unsigned short& value);
+            inline bool                                   setValue(const int& value);
+            inline bool                                   setValue(const unsigned int& value);
+            inline bool                                   setValue(const long& value);
+            inline bool                                   setValue(const unsigned long& value);
+            inline bool                                   setValue(const long long& value);
+            inline bool                                   setValue(const unsigned long long& value);
+            inline bool                                   setValue(const float& value);
+            inline bool                                   setValue(const double& value);
+            inline bool                                   setValue(const long double& value);
+            inline bool                                   setValue(const bool& value);
+            inline bool                                   setValue(      void* const& value);
+            inline bool                                   setValue(const std::string& value);
+            inline bool                                   setValue(const orxonox::Vector2& value);
+            inline bool                                   setValue(const orxonox::Vector3& value);
+            inline bool                                   setValue(const orxonox::Vector4& value);
+            inline bool                                   setValue(const orxonox::ColourValue& value);
+            inline bool                                   setValue(const orxonox::Quaternion& value);
+            inline bool                                   setValue(const orxonox::Radian& value);
+            inline bool                                   setValue(const orxonox::Degree& value);
+            inline bool                                   setValue(const char* value);
+            /** @brief Assigns a pointer. */
+            template <typename V> inline bool             setValue(V* value)               { if (this->value_) { return this->value_->setValue((void*)value); } else { return this->assignValue((void*)value); } }
+            /** @brief Assigns the value of the other MultiType and converts it to the current type. */
+            bool                                          setValue(const MultiType& other) { if (this->value_) { return this->value_->assimilate(other); } else { if (other.value_) { this->value_ = other.value_->clone(); } return true; } }
+            /** @brief Changes the type to T and assigns the new value (which might be of another type than T - it gets converted). */
+            template <typename T, typename V> inline bool setValue(const V& value) { this->setType<T>(); return this->setValue(value); }
+            /** @brief Copies the other MultiType by assigning value and type. */
+            inline void                       copy(const MultiType& other)    { if (this == &other) { return; } if (this->value_) { delete this->value_; } this->value_ = (other.value_) ? other.value_->clone() : 0; }
+            template <typename T> inline bool convert()                       { return this->setValue<T>((T)(*this));  } /** @brief Converts the current value to type T. */
+            inline bool                       convert(const MultiType& other) { return this->convert(other.getType()); } /** @brief Converts the current value to the type of the other MultiType. */
+            bool                              convert(MT_Type type);
+            /** @brief Current content gets deleted. New type is MT_null */
+            inline void                       reset()                         { if (this->value_) this->value_->reset(); }
+            template <typename T> inline void setType()                       { this->assignValue(T());                            } /** @brief Resets the value and changes the internal type to T. */
+            inline void                       setType(const MultiType& other) { this->setType(other.getType());                    } /** @brief Resets the value and changes the internal type to the type of the other MultiType. */
+            inline void                       setType(MT_Type type)           { this->reset(); this->convert(type); this->reset(); } /** @brief Resets the value and changes the internal type to the given type. */
+            /** @brief Returns the current type. */
+            inline MT_Type                    getType()                 const { return (this->value_) ? this->value_->type_ : MT_null; }
+            /** @brief Returns true if the current type equals the given type. */
+            inline bool                       isType(MT_Type type)      const { return (this->value_) ? (this->value_->type_ == type) : (type == MT_null); }
+            /** @brief Returns true if the current type is T. */
+            template <typename T> inline bool isType()                  const { return false; } // Only works for specialized values - see below
+            std::string                       getTypename()             const;
+            /** @brief Checks whether the value is a default one. */
+            bool                              hasDefaultValue()         const { return this->value_->hasDefaultValue(); }
+            operator char()                  const;
+            operator unsigned char()         const;
+            operator short()                 const;
+            operator unsigned short()        const;
+            operator int()                   const;
+            operator unsigned int()          const;
+            operator long()                  const;
+            operator unsigned long()         const;
+            operator long long()             const;
+            operator unsigned long long()    const;
+            operator float()                 const;
+            operator double()                const;
+            operator long double()           const;
+            operator bool()                  const;
+            operator void*()                 const;
+            operator std::string()           const;
+            operator orxonox::Vector2()      const;
+            operator orxonox::Vector3()      const;
+            operator orxonox::Vector4()      const;
+            operator orxonox::ColourValue()  const;
+            operator orxonox::Quaternion()   const;
+            operator orxonox::Radian()       const;
+            operator orxonox::Degree()       const;
+            /** @brief Returns the current value, converted to a T* pointer. */
+            template <class T> operator T*() const { return ((T*)this->operator void*()); }
+            inline bool getValue(char*                 value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(unsigned char*        value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(short*                value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(unsigned short*       value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(int*                  value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(unsigned int*         value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(long*                 value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(unsigned long*        value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(long long*            value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(unsigned long long*   value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(float*                value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(double*               value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(long double*          value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(bool*                 value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(void**                value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(std::string*          value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(orxonox::Vector2*     value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(orxonox::Vector3*     value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(orxonox::Vector4*     value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(orxonox::ColourValue* value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(orxonox::Quaternion*  value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(orxonox::Radian*      value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline bool getValue(orxonox::Degree*      value) const { if (this->value_) { return this->value_->getValue(value); } return false; } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+            inline char                     getChar()             const { return this->operator char();                 } /** @brief Returns the current value, converted to the requested type. */
+            inline unsigned char            getUnsignedChar()     const { return this->operator unsigned char();        } /** @brief Returns the current value, converted to the requested type. */
+            inline short                    getShort()            const { return this->operator short();                } /** @brief Returns the current value, converted to the requested type. */
+            inline unsigned short           getUnsignedShort()    const { return this->operator unsigned short();       } /** @brief Returns the current value, converted to the requested type. */
+            inline int                      getInt()              const { return this->operator int();                  } /** @brief Returns the current value, converted to the requested type. */
+            inline unsigned int             getUnsignedInt()      const { return this->operator unsigned int();         } /** @brief Returns the current value, converted to the requested type. */
+            inline long                     getLong()             const { return this->operator long();                 } /** @brief Returns the current value, converted to the requested type. */
+            inline unsigned long            getUnsignedLong()     const { return this->operator unsigned long();        } /** @brief Returns the current value, converted to the requested type. */
+            inline long long                getLongLong()         const { return this->operator long long();            } /** @brief Returns the current value, converted to the requested type. */
+            inline unsigned long long       getUnsignedLongLong() const { return this->operator unsigned long long();   } /** @brief Returns the current value, converted to the requested type. */
+            inline float                    getFloat()            const { return this->operator float();                } /** @brief Returns the current value, converted to the requested type. */
+            inline double                   getDouble()           const { return this->operator double();               } /** @brief Returns the current value, converted to the requested type. */
+            inline long double              getLongDouble()       const { return this->operator long double();          } /** @brief Returns the current value, converted to the requested type. */
+            inline bool                     getBool()             const { return this->operator bool();                 } /** @brief Returns the current value, converted to the requested type. */
+            inline void*                    getVoid()             const { return this->operator void*();                } /** @brief Returns the current value, converted to the requested type. */
+            inline std::string              getString()           const { return this->operator std::string();          } /** @brief Returns the current value, converted to the requested type. */
+            inline orxonox::Vector2         getVector2()          const { return this->operator orxonox::Vector2();     } /** @brief Returns the current value, converted to the requested type. */
+            inline orxonox::Vector3         getVector3()          const { return this->operator orxonox::Vector3();     } /** @brief Returns the current value, converted to the requested type. */
+            inline orxonox::Vector4         getVector4()          const { return this->operator orxonox::Vector4();     } /** @brief Returns the current value, converted to the requested type. */
+            inline orxonox::ColourValue     getColourValue()      const { return this->operator orxonox::ColourValue(); } /** @brief Returns the current value, converted to the requested type. */
+            inline orxonox::Quaternion      getQuaternion()       const { return this->operator orxonox::Quaternion();  } /** @brief Returns the current value, converted to the requested type. */
+            inline orxonox::Radian          getRadian()           const { return this->operator orxonox::Radian();      } /** @brief Returns the current value, converted to the requested type. */
+            inline orxonox::Degree          getDegree()           const { return this->operator orxonox::Degree();      } /** @brief Returns the current value, converted to the requested type. */
+            template <typename T> inline T* getPointer()          const { return ((T*)this->getVoid());                 } /** @brief Returns the current value, converted to a T* pointer. */
+        private:
+            inline bool assignValue(const char& value)                 { if (this->value_ && this->value_->type_ == MT_char)        { return this->value_->setValue(value); } else { this->changeValueContainer<char>(value);                 return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const unsigned char& value)        { if (this->value_ && this->value_->type_ == MT_uchar)       { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned char>(value);        return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const short& value)                { if (this->value_ && this->value_->type_ == MT_short)       { return this->value_->setValue(value); } else { this->changeValueContainer<short>(value);                return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const unsigned short& value)       { if (this->value_ && this->value_->type_ == MT_ushort)      { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned short>(value);       return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const int& value)                  { if (this->value_ && this->value_->type_ == MT_int)         { return this->value_->setValue(value); } else { this->changeValueContainer<int>(value);                  return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const unsigned int& value)         { if (this->value_ && this->value_->type_ == MT_uint)        { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned int>(value);         return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const long& value)                 { if (this->value_ && this->value_->type_ == MT_long)        { return this->value_->setValue(value); } else { this->changeValueContainer<long>(value);                 return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const unsigned long& value)        { if (this->value_ && this->value_->type_ == MT_ulong)       { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned long>(value);        return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const long long& value)            { if (this->value_ && this->value_->type_ == MT_longlong)    { return this->value_->setValue(value); } else { this->changeValueContainer<long long>(value);            return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const unsigned long long& value)   { if (this->value_ && this->value_->type_ == MT_ulonglong)   { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned long long>(value);   return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const float& value)                { if (this->value_ && this->value_->type_ == MT_float)       { return this->value_->setValue(value); } else { this->changeValueContainer<float>(value);                return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const double& value)               { if (this->value_ && this->value_->type_ == MT_double)      { return this->value_->setValue(value); } else { this->changeValueContainer<double>(value);               return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const long double& value)          { if (this->value_ && this->value_->type_ == MT_longdouble)  { return this->value_->setValue(value); } else { this->changeValueContainer<long double>(value);          return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const bool& value)                 { if (this->value_ && this->value_->type_ == MT_bool)        { return this->value_->setValue(value); } else { this->changeValueContainer<bool>(value);                 return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(      void* const& value)          { if (this->value_ && this->value_->type_ == MT_void)        { return this->value_->setValue(value); } else { this->changeValueContainer<void*>(value);                return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const std::string& value)          { if (this->value_ && this->value_->type_ == MT_string)      { return this->value_->setValue(value); } else { this->changeValueContainer<std::string>(value);          return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const orxonox::Vector2& value)     { if (this->value_ && this->value_->type_ == MT_vector2)     { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector2>(value);     return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const orxonox::Vector3& value)     { if (this->value_ && this->value_->type_ == MT_vector3)     { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector3>(value);     return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const orxonox::Vector4& value)     { if (this->value_ && this->value_->type_ == MT_vector4)     { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector4>(value);     return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const orxonox::ColourValue& value) { if (this->value_ && this->value_->type_ == MT_colourvalue) { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::ColourValue>(value); return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const orxonox::Quaternion& value)  { if (this->value_ && this->value_->type_ == MT_quaternion)  { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Quaternion>(value);  return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const orxonox::Radian& value)      { if (this->value_ && this->value_->type_ == MT_radian)      { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Radian>(value);      return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            inline bool assignValue(const orxonox::Degree& value)      { if (this->value_ && this->value_->type_ == MT_degree)      { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Degree>(value);      return true; } } /** @brief Assigns a new value by changing type and creating a new container. */
+            /** @brief Changes the value container. */
+            template <typename T> inline void changeValueContainer(const T& value) { if (this->value_) { delete this->value_; } this->createNewValueContainer<T>(value); }
+            /** @brief Creates a new value container (works only with specialized types). */
+            template <typename T>        void createNewValueContainer(const T& value) { BOOST_STATIC_ASSERT(sizeof(T) == 0); return false; }
+            MT_ValueBase* value_; //!< A pointer to the value container
+    };
+    /** @brief Puts the MultiType on a stream by using the native << operator of the current type. */
+    _UtilExport inline std::ostream& operator<<(std::ostream& outstream, const MultiType& mt) { if (mt.value_) { mt.value_->toString(outstream); } return outstream; }
+    template <> inline bool MultiType::isType<char>()                 const { return (this->value_ && this->value_->type_ == MT_char);        } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<unsigned char>()        const { return (this->value_ && this->value_->type_ == MT_uchar);       } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<short>()                const { return (this->value_ && this->value_->type_ == MT_short);       } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<unsigned short>()       const { return (this->value_ && this->value_->type_ == MT_ushort);      } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<int>()                  const { return (this->value_ && this->value_->type_ == MT_int);         } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<unsigned int>()         const { return (this->value_ && this->value_->type_ == MT_uint);        } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<long>()                 const { return (this->value_ && this->value_->type_ == MT_long);        } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<unsigned long>()        const { return (this->value_ && this->value_->type_ == MT_ulong);       } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<long long>()            const { return (this->value_ && this->value_->type_ == MT_longlong);    } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<unsigned long long>()   const { return (this->value_ && this->value_->type_ == MT_ulonglong);   } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<float>()                const { return (this->value_ && this->value_->type_ == MT_float);       } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<double>()               const { return (this->value_ && this->value_->type_ == MT_double);      } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<long double>()          const { return (this->value_ && this->value_->type_ == MT_longdouble);  } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<bool>()                 const { return (this->value_ && this->value_->type_ == MT_bool);        } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<void*>()                const { return (this->value_ && this->value_->type_ == MT_void);        } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<std::string>()          const { return (this->value_ && this->value_->type_ == MT_string);      } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<orxonox::Vector2>()     const { return (this->value_ && this->value_->type_ == MT_vector2);     } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<orxonox::Vector3>()     const { return (this->value_ && this->value_->type_ == MT_vector3);     } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<orxonox::Vector4>()     const { return (this->value_ && this->value_->type_ == MT_vector4);     } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<orxonox::ColourValue>() const { return (this->value_ && this->value_->type_ == MT_colourvalue); } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<orxonox::Quaternion>()  const { return (this->value_ && this->value_->type_ == MT_quaternion);  } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<orxonox::Radian>()      const { return (this->value_ && this->value_->type_ == MT_radian);      } /** @brief Returns true if the current type equals the given type. */
+    template <> inline bool MultiType::isType<orxonox::Degree>()      const { return (this->value_ && this->value_->type_ == MT_degree);      } /** @brief Returns true if the current type equals the given type. */
+    // Specialization to avoid ambiguities with the conversion operator
+    template <> inline bool MultiType::convert<std::string>()          { return this->setValue<std::string>         (this->operator std::string());          } /** @brief Converts the current value to the given type. */
+    template <> inline bool MultiType::convert<orxonox::Vector2>()     { return this->setValue<orxonox::Vector2>    (this->operator orxonox::Vector2());     } /** @brief Converts the current value to the given type. */
+    template <> inline bool MultiType::convert<orxonox::Vector3>()     { return this->setValue<orxonox::Vector3>    (this->operator orxonox::Vector3());     } /** @brief Converts the current value to the given type. */
+    template <> inline bool MultiType::convert<orxonox::Vector4>()     { return this->setValue<orxonox::Vector4>    (this->operator orxonox::Vector4());     } /** @brief Converts the current value to the given type. */
+    template <> inline bool MultiType::convert<orxonox::ColourValue>() { return this->setValue<orxonox::ColourValue>(this->operator orxonox::ColourValue()); } /** @brief Converts the current value to the given type. */
+    template <> inline bool MultiType::convert<orxonox::Quaternion>()  { return this->setValue<orxonox::Quaternion> (this->operator orxonox::Quaternion());  } /** @brief Converts the current value to the given type. */
+    template <> inline bool MultiType::convert<orxonox::Radian>()      { return this->setValue<orxonox::Radian>     (this->operator orxonox::Radian());      } /** @brief Converts the current value to the given type. */
+    template <> inline bool MultiType::convert<orxonox::Degree>()      { return this->setValue<orxonox::Degree>     (this->operator orxonox::Degree());      } /** @brief Converts the current value to the given type. */
+    // Specialization to avoid ambiguities with the conversion operator
+    template <> inline bool MultiType::convert<const std::string&>()          { return this->convert<std::string>();          } /** @brief Converts the current value to the given type. */
+    template <> inline bool MultiType::convert<const orxonox::Vector2&>()     { return this->convert<orxonox::Vector2>();     } /** @brief Converts the current value to the given type. */
+    template <> inline bool MultiType::convert<const orxonox::Vector3&>()     { return this->convert<orxonox::Vector3>();     } /** @brief Converts the current value to the given type. */
+    template <> inline bool MultiType::convert<const orxonox::Vector4&>()     { return this->convert<orxonox::Vector4>();     } /** @brief Converts the current value to the given type. */
+    template <> inline bool MultiType::convert<const orxonox::ColourValue&>() { return this->convert<orxonox::ColourValue>(); } /** @brief Converts the current value to the given type. */
+    template <> inline bool MultiType::convert<const orxonox::Quaternion&>()  { return this->convert<orxonox::Quaternion>();  } /** @brief Converts the current value to the given type. */
+    template <> inline bool MultiType::convert<const orxonox::Radian&>()      { return this->convert<orxonox::Radian>();      } /** @brief Converts the current value to the given type. */
+    template <> inline bool MultiType::convert<const orxonox::Degree&>()      { return this->convert<orxonox::Degree>();      } /** @brief Converts the current value to the given type. */
+    template <> void MultiType::createNewValueContainer(const char& value);
+    template <> void MultiType::createNewValueContainer(const unsigned char& value);
+    template <> void MultiType::createNewValueContainer(const short& value);
+    template <> void MultiType::createNewValueContainer(const unsigned short& value);
+    template <> void MultiType::createNewValueContainer(const int& value);
+    template <> void MultiType::createNewValueContainer(const unsigned int& value);
+    template <> void MultiType::createNewValueContainer(const long& value);
+    template <> void MultiType::createNewValueContainer(const unsigned long& value);
+    template <> void MultiType::createNewValueContainer(const long long& value);
+    template <> void MultiType::createNewValueContainer(const unsigned long long& value);
+    template <> void MultiType::createNewValueContainer(const float& value);
+    template <> void MultiType::createNewValueContainer(const double& value);
+    template <> void MultiType::createNewValueContainer(const bool& value);
+    template <> void MultiType::createNewValueContainer(const long double& value);
+    template <> void MultiType::createNewValueContainer(      void* const& value);
+    template <> void MultiType::createNewValueContainer(const std::string& value);
+    template <> void MultiType::createNewValueContainer(const orxonox::Vector2& value);
+    template <> void MultiType::createNewValueContainer(const orxonox::Vector3& value);
+    template <> void MultiType::createNewValueContainer(const orxonox::Vector4& value);
+    template <> void MultiType::createNewValueContainer(const orxonox::ColourValue& value);
+    template <> void MultiType::createNewValueContainer(const orxonox::Quaternion& value);
+    template <> void MultiType::createNewValueContainer(const orxonox::Radian& value);
+    template <> void MultiType::createNewValueContainer(const orxonox::Degree& value);
+    inline bool MultiType::setValue(const char& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const unsigned char& value)         { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const short& value)                 { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const unsigned short& value)        { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const int& value)                   { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const unsigned int& value)          { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const long& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const unsigned long& value)         { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const long long& value)             { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const unsigned long long& value)    { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const float& value)                 { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const double& value)                { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const long double& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const bool& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(      void* const& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const std::string& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const orxonox::Vector2& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const orxonox::Vector3& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const orxonox::Vector4& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const orxonox::ColourValue& value)  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const orxonox::Quaternion& value)   { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const orxonox::Radian& value)       { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const orxonox::Degree& value)       { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } /** @brief Assigns the given value and converts it to the current type. */
+    inline bool MultiType::setValue(const char* value)                  { if (this->value_) { return this->value_->setValue(std::string(value)); } else { return this->assignValue(std::string(value)); } }  /** @brief Assigns the given value and converts it to the current type. */
+}
 #endif /* _MultiType_H__ */

code/trunk/src/util/MultiTypeValue.h

-                      r2087
+                      r2171
 /**
     @file MultiTypeValue.h
+    @file
     @brief Declaration and Implementation of the MT_Value<T> class.
 …
 #include "MultiType.h"
+/**
+    @brief The MT_Value<T> class is used to hold a value of type T within a MultiType.
+*/
+template <typename T>
+struct MT_Value : public MultiType::MT_ValueBase
+namespace orxonox
+{
+    /** @brief Constructor: Assigns the value and the type identifier. */
+    MT_Value(const T& value, MT_Type type) : MT_ValueBase(type), value_(value) {}
+    /**
+        @brief The MT_Value<T> class is used to hold a value of type T within a MultiType.
+    */
+    template <typename T>
+    class MT_Value : public MultiType::MT_ValueBase
+    {
+    public:
+        /** @brief Constructor: Assigns the value and the type identifier. */
+        MT_Value(const T& value, MT_Type type) : MT_ValueBase(type), value_(value) {}
     /** @brief Creates a copy of itself. */
     inline MT_ValueBase* clone() const { return new MT_Value<T>(this->value_, this->type_); }
+        /** @brief Creates a copy of itself. */
+        inline MT_ValueBase* clone() const { return new MT_Value<T>(this->value_, this->type_); }
     /** @brief Resets the current value to the default. */
     inline void reset() { this->value_ = zeroise<T>(); bHasDefaultValue_ = true; }
+        /** @brief Resets the current value to the default. */
+        inline void reset() { this->value_ = zeroise<T>(); bHasDefaultValue_ = true; }
+    /** @brief Assigns the value of the other MultiType, converted to T. @param other The other MultiType */
+    inline bool assimilate(const MultiType& other)
+    {
+        if (other.value_)
+        /** @brief Assigns the value of the other MultiType, converted to T. @param other The other MultiType */
+        inline bool assimilate(const MultiType& other)
+        {
+            return !(bHasDefaultValue_ = !other.value_->getValue(&value_));
+            if (other.value_)
+            {
+                return !(bHasDefaultValue_ = !other.value_->getValue(&value_));
+            }
+            else
+            {
+                this->value_ = zeroise<T>();
+                return !(bHasDefaultValue_ = true);
+            }
+        }
-        else
+        {
-            this->value_ = zeroise<T>();
-            return !(bHasDefaultValue_ = true);
+        }
+    }
     inline bool getValue(char*                 value) const { return ConvertValue<T, char                >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
     inline bool getValue(unsigned char*        value) const { return ConvertValue<T, unsigned char       >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
     inline bool getValue(short*                value) const { return ConvertValue<T, short               >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
     inline bool getValue(unsigned short*       value) const { return ConvertValue<T, unsigned short      >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
     inline bool getValue(int*                  value) const { return ConvertValue<T, int                 >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
     inline bool getValue(unsigned int*         value) const { return ConvertValue<T, unsigned int        >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
     inline bool getValue(long*                 value) const { return ConvertValue<T, long                >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
     inline bool getValue(unsigned long*        value) const { return ConvertValue<T, unsigned long       >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
     inline bool getValue(long long*            value) const { return ConvertValue<T, long long           >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
     inline bool getValue(unsigned long long*   value) const { return ConvertValue<T, unsigned long long  >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
     inline bool getValue(float*                value) const { return ConvertValue<T, float               >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
     inline bool getValue(double*               value) const { return ConvertValue<T, double              >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
     inline bool getValue(long double*          value) const { return ConvertValue<T, long double         >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
     inline bool getValue(bool*                 value) const { return ConvertValue<T, bool                >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
     inline bool getValue(void**                value) const { return ConvertValue<T, void*               >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
     inline bool getValue(std::string*          value) const { return ConvertValue<T, std::string         >(value, value_, zeroise<std::string>         ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
     inline bool getValue(orxonox::Vector2*     value) const { return ConvertValue<T, orxonox::Vector2    >(value, value_, zeroise<orxonox::Vector2>    ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
     inline bool getValue(orxonox::Vector3*     value) const { return ConvertValue<T, orxonox::Vector3    >(value, value_, zeroise<orxonox::Vector3>    ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
     inline bool getValue(orxonox::Vector4*     value) const { return ConvertValue<T, orxonox::Vector4    >(value, value_, zeroise<orxonox::Vector4>    ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
     inline bool getValue(orxonox::ColourValue* value) const { return ConvertValue<T, orxonox::ColourValue>(value, value_, zeroise<orxonox::ColourValue>()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
     inline bool getValue(orxonox::Quaternion*  value) const { return ConvertValue<T, orxonox::Quaternion >(value, value_, zeroise<orxonox::Quaternion> ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
     inline bool getValue(orxonox::Radian*      value) const { return ConvertValue<T, orxonox::Radian     >(value, value_, zeroise<orxonox::Radian>     ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
     inline bool getValue(orxonox::Degree*      value) const { return ConvertValue<T, orxonox::Degree     >(value, value_, zeroise<orxonox::Degree>     ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(char*                 value) const { return ConvertValue<T, char                >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(unsigned char*        value) const { return ConvertValue<T, unsigned char       >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(short*                value) const { return ConvertValue<T, short               >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(unsigned short*       value) const { return ConvertValue<T, unsigned short      >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(int*                  value) const { return ConvertValue<T, int                 >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(unsigned int*         value) const { return ConvertValue<T, unsigned int        >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(long*                 value) const { return ConvertValue<T, long                >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(unsigned long*        value) const { return ConvertValue<T, unsigned long       >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(long long*            value) const { return ConvertValue<T, long long           >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(unsigned long long*   value) const { return ConvertValue<T, unsigned long long  >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(float*                value) const { return ConvertValue<T, float               >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(double*               value) const { return ConvertValue<T, double              >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(long double*          value) const { return ConvertValue<T, long double         >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(bool*                 value) const { return ConvertValue<T, bool                >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(void**                value) const { return ConvertValue<T, void*               >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(std::string*          value) const { return ConvertValue<T, std::string         >(value, value_, zeroise<std::string>         ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(orxonox::Vector2*     value) const { return ConvertValue<T, orxonox::Vector2    >(value, value_, zeroise<orxonox::Vector2>    ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(orxonox::Vector3*     value) const { return ConvertValue<T, orxonox::Vector3    >(value, value_, zeroise<orxonox::Vector3>    ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(orxonox::Vector4*     value) const { return ConvertValue<T, orxonox::Vector4    >(value, value_, zeroise<orxonox::Vector4>    ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(orxonox::ColourValue* value) const { return ConvertValue<T, orxonox::ColourValue>(value, value_, zeroise<orxonox::ColourValue>()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(orxonox::Quaternion*  value) const { return ConvertValue<T, orxonox::Quaternion >(value, value_, zeroise<orxonox::Quaternion> ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(orxonox::Radian*      value) const { return ConvertValue<T, orxonox::Radian     >(value, value_, zeroise<orxonox::Radian>     ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
+        inline bool getValue(orxonox::Degree*      value) const { return ConvertValue<T, orxonox::Degree     >(value, value_, zeroise<orxonox::Degree>     ()); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
     inline bool setValue(const char& value)                 { return !(bHasDefaultValue_ = !ConvertValue<char                , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
     inline bool setValue(const unsigned char& value)        { return !(bHasDefaultValue_ = !ConvertValue<unsigned char       , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
     inline bool setValue(const short& value)                { return !(bHasDefaultValue_ = !ConvertValue<short               , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
     inline bool setValue(const unsigned short& value)       { return !(bHasDefaultValue_ = !ConvertValue<unsigned short      , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
     inline bool setValue(const int& value)                  { return !(bHasDefaultValue_ = !ConvertValue<int                 , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
     inline bool setValue(const unsigned int& value)         { return !(bHasDefaultValue_ = !ConvertValue<unsigned int        , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
     inline bool setValue(const long& value)                 { return !(bHasDefaultValue_ = !ConvertValue<long                , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
     inline bool setValue(const unsigned long& value)        { return !(bHasDefaultValue_ = !ConvertValue<unsigned long       , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
     inline bool setValue(const long long& value)            { return !(bHasDefaultValue_ = !ConvertValue<long long           , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
     inline bool setValue(const unsigned long long& value)   { return !(bHasDefaultValue_ = !ConvertValue<unsigned long long  , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
     inline bool setValue(const float& value)                { return !(bHasDefaultValue_ = !ConvertValue<float               , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
     inline bool setValue(const double& value)               { return !(bHasDefaultValue_ = !ConvertValue<double              , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
     inline bool setValue(const long double& value)          { return !(bHasDefaultValue_ = !ConvertValue<long double         , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
     inline bool setValue(const bool& value)                 { return !(bHasDefaultValue_ = !ConvertValue<bool                , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
     inline bool setValue(      void* const& value)          { return !(bHasDefaultValue_ = !ConvertValue<void*               , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
     inline bool setValue(const std::string& value)          { return !(bHasDefaultValue_ = !ConvertValue<std::string         , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
     inline bool setValue(const orxonox::Vector2& value)     { return !(bHasDefaultValue_ = !ConvertValue<orxonox::Vector2    , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
     inline bool setValue(const orxonox::Vector3& value)     { return !(bHasDefaultValue_ = !ConvertValue<orxonox::Vector3    , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
     inline bool setValue(const orxonox::Vector4& value)     { return !(bHasDefaultValue_ = !ConvertValue<orxonox::Vector4    , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
     inline bool setValue(const orxonox::ColourValue& value) { return !(bHasDefaultValue_ = !ConvertValue<orxonox::ColourValue, T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
     inline bool setValue(const orxonox::Quaternion& value)  { return !(bHasDefaultValue_ = !ConvertValue<orxonox::Quaternion , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
     inline bool setValue(const orxonox::Radian& value)      { return !(bHasDefaultValue_ = !ConvertValue<orxonox::Radian     , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
     inline bool setValue(const orxonox::Degree& value)      { return !(bHasDefaultValue_ = !ConvertValue<orxonox::Degree     , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const char& value)                 { return !(bHasDefaultValue_ = !ConvertValue<char                , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const unsigned char& value)        { return !(bHasDefaultValue_ = !ConvertValue<unsigned char       , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const short& value)                { return !(bHasDefaultValue_ = !ConvertValue<short               , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const unsigned short& value)       { return !(bHasDefaultValue_ = !ConvertValue<unsigned short      , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const int& value)                  { return !(bHasDefaultValue_ = !ConvertValue<int                 , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const unsigned int& value)         { return !(bHasDefaultValue_ = !ConvertValue<unsigned int        , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const long& value)                 { return !(bHasDefaultValue_ = !ConvertValue<long                , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const unsigned long& value)        { return !(bHasDefaultValue_ = !ConvertValue<unsigned long       , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const long long& value)            { return !(bHasDefaultValue_ = !ConvertValue<long long           , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const unsigned long long& value)   { return !(bHasDefaultValue_ = !ConvertValue<unsigned long long  , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const float& value)                { return !(bHasDefaultValue_ = !ConvertValue<float               , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const double& value)               { return !(bHasDefaultValue_ = !ConvertValue<double              , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const long double& value)          { return !(bHasDefaultValue_ = !ConvertValue<long double         , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const bool& value)                 { return !(bHasDefaultValue_ = !ConvertValue<bool                , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(      void* const& value)          { return !(bHasDefaultValue_ = !ConvertValue<void*               , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const std::string& value)          { return !(bHasDefaultValue_ = !ConvertValue<std::string         , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const orxonox::Vector2& value)     { return !(bHasDefaultValue_ = !ConvertValue<orxonox::Vector2    , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const orxonox::Vector3& value)     { return !(bHasDefaultValue_ = !ConvertValue<orxonox::Vector3    , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const orxonox::Vector4& value)     { return !(bHasDefaultValue_ = !ConvertValue<orxonox::Vector4    , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const orxonox::ColourValue& value) { return !(bHasDefaultValue_ = !ConvertValue<orxonox::ColourValue, T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const orxonox::Quaternion& value)  { return !(bHasDefaultValue_ = !ConvertValue<orxonox::Quaternion , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const orxonox::Radian& value)      { return !(bHasDefaultValue_ = !ConvertValue<orxonox::Radian     , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
+        inline bool setValue(const orxonox::Degree& value)      { return !(bHasDefaultValue_ = !ConvertValue<orxonox::Degree     , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
     inline operator char()                 const { return getConvertedValue<T, char>                (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
     inline operator unsigned char()        const { return getConvertedValue<T, unsigned char>       (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
     inline operator short()                const { return getConvertedValue<T, short>               (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
     inline operator unsigned short()       const { return getConvertedValue<T, unsigned short>      (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
     inline operator int()                  const { return getConvertedValue<T, int>                 (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
     inline operator unsigned int()         const { return getConvertedValue<T, unsigned int>        (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
     inline operator long()                 const { return getConvertedValue<T, long>                (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
     inline operator unsigned long()        const { return getConvertedValue<T, unsigned long>       (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
     inline operator long long()            const { return getConvertedValue<T, long long>           (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
     inline operator unsigned long long()   const { return getConvertedValue<T, unsigned long long>  (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
     inline operator float()                const { return getConvertedValue<T, float>               (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
     inline operator double()               const { return getConvertedValue<T, double>              (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
     inline operator long double()          const { return getConvertedValue<T, long double>         (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
     inline operator bool()                 const { return getConvertedValue<T, bool>                (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
     inline operator void*()                const { return getConvertedValue<T, void*>               (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
     inline operator std::string()          const { return getConvertedValue<T, std::string>         (this->value_, zeroise<std::string         >()); } /** @brief Returns the current value, converted to the requested type. */
     inline operator orxonox::Vector2()     const { return getConvertedValue<T, orxonox::Vector2>    (this->value_, zeroise<orxonox::Vector2    >()); } /** @brief Returns the current value, converted to the requested type. */
     inline operator orxonox::Vector3()     const { return getConvertedValue<T, orxonox::Vector3>    (this->value_, zeroise<orxonox::Vector3    >()); } /** @brief Returns the current value, converted to the requested type. */
     inline operator orxonox::Vector4()     const { return getConvertedValue<T, orxonox::Vector4>    (this->value_, zeroise<orxonox::Vector4    >()); } /** @brief Returns the current value, converted to the requested type. */
     inline operator orxonox::ColourValue() const { return getConvertedValue<T, orxonox::ColourValue>(this->value_, zeroise<orxonox::ColourValue>()); } /** @brief Returns the current value, converted to the requested type. */
     inline operator orxonox::Quaternion()  const { return getConvertedValue<T, orxonox::Quaternion> (this->value_, zeroise<orxonox::Quaternion >()); } /** @brief Returns the current value, converted to the requested type. */
     inline operator orxonox::Radian()      const { return getConvertedValue<T, orxonox::Radian>     (this->value_, zeroise<orxonox::Radian     >()); } /** @brief Returns the current value, converted to the requested type. */
     inline operator orxonox::Degree()      const { return getConvertedValue<T, orxonox::Degree>     (this->value_, zeroise<orxonox::Degree     >()); } /** @brief Returns the current value, converted to the requested type. */
+        inline operator char()                 const { return getConvertedValue<T, char>                (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
+        inline operator unsigned char()        const { return getConvertedValue<T, unsigned char>       (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
+        inline operator short()                const { return getConvertedValue<T, short>               (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
+        inline operator unsigned short()       const { return getConvertedValue<T, unsigned short>      (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
+        inline operator int()                  const { return getConvertedValue<T, int>                 (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
+        inline operator unsigned int()         const { return getConvertedValue<T, unsigned int>        (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
+        inline operator long()                 const { return getConvertedValue<T, long>                (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
+        inline operator unsigned long()        const { return getConvertedValue<T, unsigned long>       (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
+        inline operator long long()            const { return getConvertedValue<T, long long>           (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
+        inline operator unsigned long long()   const { return getConvertedValue<T, unsigned long long>  (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
+        inline operator float()                const { return getConvertedValue<T, float>               (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
+        inline operator double()               const { return getConvertedValue<T, double>              (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
+        inline operator long double()          const { return getConvertedValue<T, long double>         (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
+        inline operator bool()                 const { return getConvertedValue<T, bool>                (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
+        inline operator void*()                const { return getConvertedValue<T, void*>               (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
+        inline operator std::string()          const { return getConvertedValue<T, std::string>         (this->value_, zeroise<std::string         >()); } /** @brief Returns the current value, converted to the requested type. */
+        inline operator orxonox::Vector2()     const { return getConvertedValue<T, orxonox::Vector2>    (this->value_, zeroise<orxonox::Vector2    >()); } /** @brief Returns the current value, converted to the requested type. */
+        inline operator orxonox::Vector3()     const { return getConvertedValue<T, orxonox::Vector3>    (this->value_, zeroise<orxonox::Vector3    >()); } /** @brief Returns the current value, converted to the requested type. */
+        inline operator orxonox::Vector4()     const { return getConvertedValue<T, orxonox::Vector4>    (this->value_, zeroise<orxonox::Vector4    >()); } /** @brief Returns the current value, converted to the requested type. */
+        inline operator orxonox::ColourValue() const { return getConvertedValue<T, orxonox::ColourValue>(this->value_, zeroise<orxonox::ColourValue>()); } /** @brief Returns the current value, converted to the requested type. */
+        inline operator orxonox::Quaternion()  const { return getConvertedValue<T, orxonox::Quaternion> (this->value_, zeroise<orxonox::Quaternion >()); } /** @brief Returns the current value, converted to the requested type. */
+        inline operator orxonox::Radian()      const { return getConvertedValue<T, orxonox::Radian>     (this->value_, zeroise<orxonox::Radian     >()); } /** @brief Returns the current value, converted to the requested type. */
+        inline operator orxonox::Degree()      const { return getConvertedValue<T, orxonox::Degree>     (this->value_, zeroise<orxonox::Degree     >()); } /** @brief Returns the current value, converted to the requested type. */
     /** @brief Puts the current value on the stream */
     inline void toString(std::ostream& outstream) const { outstream << this->value_; }
+        /** @brief Puts the current value on the stream */
+        inline void toString(std::ostream& outstream) const { outstream << this->value_; }
+    T value_; //!< The stored value
+};
+        T value_; //!< The stored value
+    };
+}
 #endif /* _MultiTypeValue_H__ */

code/trunk/src/util/OutputBuffer.cc

r1791	r2171
28	28
29	29	/**
30		@file ~~OutputBuffer.cc~~
	30	@file
31	31	@brief Implementation of the OutputBuffer.
32	32	*/

code/trunk/src/util/OutputBuffer.h

-                      r1854
+                      r2171
 /**
     @file OutputBuffer.h
+    @file
     @brief Declaration of the OutputBuffer class.
 …
         an OutputBuffer and this buffer changes.
     */
     class _UtilExport OutputBufferListener
+    class OutputBufferListener
+    {
         friend class OutputBuffer;

code/trunk/src/util/OutputHandler.cc

r2087	r2171
28	28
29	29	/**
30		@file ~~OutputHandler.cc~~
	30	@file
31	31	@brief Implementation of the OutputHandler class.
32	32	*/

code/trunk/src/util/OutputHandler.h

r1791	r2171
28	28
29	29	/**
30		@file ~~OutputHandler.h~~
	30	@file
31	31	@brief Definition of the OutputHandler class.
32	32

code/trunk/src/util/SignalHandler.cc

Property svn:mergeinfo changed
/code/branches/objecthierarchy/src/util/SignalHandler.cc merged: 2111

-                      r2103
+                      r2171
 #include <cstring>
+SignalHandler * SignalHandler::singletonRef = NULL;
+namespace orxonox
+{
+    SignalHandler * SignalHandler::singletonRef = NULL;
+}
 #if ORXONOX_PLATFORM != ORXONOX_PLATFORM_WIN32
 …
 #include <X11/keysym.h>
+bool SignalHandler::bXAutoKeyRepeatOn_ = false;
+SignalHandler::SignalHandler()
+namespace orxonox
+{
+    bool SignalHandler::bXAutoKeyRepeatOn_ = false;
+    SignalHandler::SignalHandler()
+    {
+    }
+    /**
+     * register signal handlers for SIGSEGV and SIGABRT
+     * @param appName path to executable eg argv[0]
+     * @param filename filename to append backtrace to
+     */
+    void SignalHandler::doCatch( const std::string & appName, const std::string & filename )
+    {
+      this->appName = appName;
+      this->filename = filename;
+      // prepare for restoring XAutoKeyRepeat
+      Display* display;
+      if ((display = XOpenDisplay(0)))
+      {
+        XKeyboardState oldState;
+        XGetKeyboardControl(display, &oldState);
+        if (oldState.global_auto_repeat == AutoRepeatModeOn)
+          bXAutoKeyRepeatOn_ = true;
+        else
+          bXAutoKeyRepeatOn_ = false;
+        XCloseDisplay(display);
+      }
+      else
+      {
+        std::cout << "Warning: couldn't open X display to restore XAutoKeyRepeat." << std::endl;
+        bXAutoKeyRepeatOn_ = false;
+      }
+      // make sure doCatch is only called once without calling dontCatch
+      assert( sigRecList.size() == 0 );
+      catchSignal( SIGSEGV );
+      catchSignal( SIGABRT );
+      catchSignal( SIGILL );
+    }
+    /**
+     * restore previous signal handlers
+     */
+    void SignalHandler::dontCatch()
+    {
+      for ( SignalRecList::iterator it = sigRecList.begin(); it != sigRecList.end(); it++ )
+      {
+        signal( it->signal, it->handler );
+      }
+      sigRecList.clear();
+    }
+    /**
+     * catch signal sig
+     * @param sig signal to catch
+     */
+    void SignalHandler::catchSignal( int sig )
+    {
+      sig_t handler = signal( sig, SignalHandler::sigHandler );
+      assert( handler != SIG_ERR );
+      SignalRec rec;
+      rec.signal = sig;
+      rec.handler = handler;
+      sigRecList.push_front( rec );
+    }
+    /**
+     * sigHandler is called when receiving signals
+     * @param sig
+     */
+    void SignalHandler::sigHandler( int sig )
+    {
+      for ( SignalCallbackList::iterator it = SignalHandler::getInstance()->callbackList.begin(); it != SignalHandler::getInstance()->callbackList.end(); it++  )
+      {
+        (*(it->cb))( it->someData );
+      }
+      std::string sigName = "UNKNOWN";
+      switch ( sig )
+      {
+        case SIGSEGV:
+          sigName = "SIGSEGV";
+          break;
+        case SIGABRT:
+          sigName = "SIGABRT";
+          break;
+        case SIGILL:
+          sigName = "SIGILL";
+          break;
+      }
+      if (bXAutoKeyRepeatOn_)
+      {
+        std::cout << "Trying to restore XAutoKeyRepeat" << std::endl;
+        Display* display;
+        if ((display = XOpenDisplay(0)))
+        {
+          XAutoRepeatOn(display);
+          XCloseDisplay(display);
+        }
+      }
+      COUT(0) << "recieved signal " << sigName.c_str() << std::endl << "try to write backtrace to file orxonox.log" << std::endl;
+      int sigPipe[2];
+      if ( pipe(sigPipe) == -1 )
+      {
+        perror("pipe failed!\n");
+        exit(EXIT_FAILURE);
+      }
+      int sigPid = fork();
+      if ( sigPid == -1 )
+      {
+        perror("fork failed!\n");
+        exit(EXIT_FAILURE);
+      }
+      // gdb will be attached to this process
+      if ( sigPid == 0 )
+      {
+        getInstance()->dontCatch();
+        // wait for message from parent when it has attached gdb
+        int someData;
+        read( sigPipe[0], &someData, sizeof(someData) );
+        if ( someData != 0x12345678 )
+        {
+          COUT(0) << "something went wrong :(" << std::endl;
+        }
+        return;
+      }
+      int gdbIn[2];
+      int gdbOut[2];
+      int gdbErr[2];
+      if ( pipe(gdbIn) == -1 || pipe(gdbOut) == -1 || pipe(gdbErr) == -1 )
+      {
+        perror("pipe failed!\n");
+        kill( sigPid, SIGTERM );
+        waitpid( sigPid, NULL, 0 );
+        exit(EXIT_FAILURE);
+      }
+      int gdbPid = fork();
+      // this process will run gdb
+      if ( gdbPid == -1 )
+      {
+        perror("fork failed\n");
+        kill( sigPid, SIGTERM );
+        waitpid( sigPid, NULL, 0 );
+        exit(EXIT_FAILURE);
+      }
+      if ( gdbPid == 0 )
+      {
+        // start gdb
+        close(gdbIn[1]);
+        close(gdbOut[0]);
+        close(gdbErr[0]);
+        dup2( gdbIn[0], STDIN_FILENO );
+        dup2( gdbOut[1], STDOUT_FILENO );
+        dup2( gdbErr[1], STDERR_FILENO );
+        execlp( "sh", "sh", "-c", "gdb", (void*)NULL);
+      }
+      char cmd[256];
+      snprintf( cmd, 256, "file %s\nattach %d\nc\n", getInstance()->appName.c_str(), sigPid );
+      write( gdbIn[1], cmd, strlen(cmd) );
+      int charsFound = 0;
+      int promptFound = 0;
+      char byte;
+      while ( read( gdbOut[0], &byte, 1 ) == 1 )
+      {
+        if (
+          charsFound == 0 && byte == '(' ||
+          charsFound == 1 && byte == 'g' ||
+          charsFound == 2 && byte == 'd' ||
+          charsFound == 3 && byte == 'b' ||
+          charsFound == 4 && byte == ')' ||
+          charsFound == 5 && byte == ' '
+            )
+              charsFound++;
+        else
+          charsFound = 0;
+        if ( charsFound == 6 )
+        {
+          promptFound++;
+          charsFound = 0;
+        }
+        if ( promptFound == 3 )
+        {
+          break;
+        }
+      }
+      int someData = 0x12345678;
+      write( sigPipe[1], &someData, sizeof(someData) );
+      write( gdbIn[1], "bt\nk\nq\n", 7 );
+      charsFound = 0;
+      promptFound = 0;
+      std::string bt;
+      while ( read( gdbOut[0], &byte, 1 ) == 1 )
+      {
+        bt += std::string( &byte, 1 );
+        if (
+          charsFound == 0 && byte == '(' ||
+          charsFound == 1 && byte == 'g' ||
+          charsFound == 2 && byte == 'd' ||
+          charsFound == 3 && byte == 'b' ||
+          charsFound == 4 && byte == ')' ||
+          charsFound == 5 && byte == ' '
+            )
+              charsFound++;
+        else
+          charsFound = 0;
+        if ( charsFound == 6 )
+        {
+          promptFound++;
+          charsFound = 0;
+          bt += "\n";
+        }
+        if ( promptFound == 3 )
+        {
+          break;
+        }
+      }
+      waitpid( sigPid, NULL, 0 );
+      waitpid( gdbPid, NULL, 0 );
+      int wsRemoved = 0;
+      while ( wsRemoved < 2 && bt.length() > 0 )
+      {
+        if ( bt[1] == '\n' )
+          wsRemoved++;
+        bt.erase(0, 1);
+      }
+      if ( bt.length() > 0 )
+        bt.erase(0, 1);
+      time_t now = time(NULL);
+      std::string timeString = "\n\n\n\n"
+                         "=======================================================\n"
+                         "= time: " + std::string(ctime(&now)) +
+             "=======================================================\n";
+      bt.insert(0, timeString);
+      FILE * f = fopen( getInstance()->filename.c_str(), "a" );
+      if ( !f )
+      {
+        perror( ( std::string( "could not append to " ) + getInstance()->filename ).c_str() );
+        exit(EXIT_FAILURE);
+      }
+      if ( fwrite( bt.c_str(), 1, bt.length(), f ) != bt.length() )
+      {
+        COUT(0) << "could not write " << bt.length() << " byte to " << getInstance()->filename << std::endl;
+        exit(EXIT_FAILURE);
+      }
+      exit(EXIT_FAILURE);
+    }
+    void SignalHandler::registerCallback( SignalCallback cb, void * someData )
+    {
+      SignalCallbackRec rec;
+      rec.cb = cb;
+      rec.someData = someData;
+      callbackList.push_back(rec);
+    }
+}
-/**
- * register signal handlers for SIGSEGV and SIGABRT
- * @param appName path to executable eg argv[0]
- * @param filename filename to append backtrace to
- */
-void SignalHandler::doCatch( const std::string & appName, const std::string & filename )
+{
-  this->appName = appName;
-  this->filename = filename;
-  // prepare for restoring XAutoKeyRepeat
-  Display* display;
-  if ((display = XOpenDisplay(0)))
+  {
-    XKeyboardState oldState;
-    XGetKeyboardControl(display, &oldState);
-    if (oldState.global_auto_repeat == AutoRepeatModeOn)
-      bXAutoKeyRepeatOn_ = true;
-    else
-      bXAutoKeyRepeatOn_ = false;
-    XCloseDisplay(display);
+  }
-  else
+  {
-    std::cout << "Warning: couldn't open X display to restore XAutoKeyRepeat." << std::endl;
-    bXAutoKeyRepeatOn_ = false;
+  }
-  // make sure doCatch is only called once without calling dontCatch
-  assert( sigRecList.size() == 0 );
-  catchSignal( SIGSEGV );
-  catchSignal( SIGABRT );
-  catchSignal( SIGILL );
+}
-/**
- * restore previous signal handlers
- */
-void SignalHandler::dontCatch()
+{
-  for ( SignalRecList::iterator it = sigRecList.begin(); it != sigRecList.end(); it++ )
+  {
-    signal( it->signal, it->handler );
+  }
-  sigRecList.clear();
+}
-/**
- * catch signal sig
- * @param sig signal to catch
- */
-void SignalHandler::catchSignal( int sig )
+{
-  sig_t handler = signal( sig, SignalHandler::sigHandler );
-  assert( handler != SIG_ERR );
-  SignalRec rec;
-  rec.signal = sig;
-  rec.handler = handler;
-  sigRecList.push_front( rec );
+}
-/**
- * sigHandler is called when receiving signals
- * @param sig
- */
-void SignalHandler::sigHandler( int sig )
+{
-  for ( SignalCallbackList::iterator it = SignalHandler::getInstance()->callbackList.begin(); it != SignalHandler::getInstance()->callbackList.end(); it++  )
+  {
-    (*(it->cb))( it->someData );
+  }
-  std::string sigName = "UNKNOWN";
-  switch ( sig )
+  {
-    case SIGSEGV:
-      sigName = "SIGSEGV";
-      break;
-    case SIGABRT:
-      sigName = "SIGABRT";
-      break;
-    case SIGILL:
-      sigName = "SIGILL";
-      break;
+  }
-  if (bXAutoKeyRepeatOn_)
+  {
-    std::cout << "Trying to restore XAutoKeyRepeat" << std::endl;
-    Display* display;
-    if ((display = XOpenDisplay(0)))
+    {
-      XAutoRepeatOn(display);
-      XCloseDisplay(display);
+    }
+  }
-  COUT(0) << "recieved signal " << sigName.c_str() << std::endl << "try to write backtrace to file orxonox.log" << std::endl;
-  int sigPipe[2];
-  if ( pipe(sigPipe) == -1 )
+  {
-    perror("pipe failed!\n");
-    exit(EXIT_FAILURE);
+  }
-  int sigPid = fork();
-  if ( sigPid == -1 )
+  {
-    perror("fork failed!\n");
-    exit(EXIT_FAILURE);
+  }
-  // gdb will be attached to this process
-  if ( sigPid == 0 )
+  {
-    getInstance()->dontCatch();
-    // wait for message from parent when it has attached gdb
-    int someData;
-    read( sigPipe[0], &someData, sizeof(someData) );
-    if ( someData != 0x12345678 )
+    {
-      COUT(0) << "something went wrong :(" << std::endl;
+    }
-    return;
+  }
-  int gdbIn[2];
-  int gdbOut[2];
-  int gdbErr[2];
-  if ( pipe(gdbIn) == -1 || pipe(gdbOut) == -1 || pipe(gdbErr) == -1 )
+  {
-    perror("pipe failed!\n");
-    kill( sigPid, SIGTERM );
-    waitpid( sigPid, NULL, 0 );
-    exit(EXIT_FAILURE);
+  }
-  int gdbPid = fork();
-  // this process will run gdb
-  if ( gdbPid == -1 )
+  {
-    perror("fork failed\n");
-    kill( sigPid, SIGTERM );
-    waitpid( sigPid, NULL, 0 );
-    exit(EXIT_FAILURE);
+  }
-  if ( gdbPid == 0 )
+  {
-    // start gdb
-    close(gdbIn[1]);
-    close(gdbOut[0]);
-    close(gdbErr[0]);
-    dup2( gdbIn[0], STDIN_FILENO );
-    dup2( gdbOut[1], STDOUT_FILENO );
-    dup2( gdbErr[1], STDERR_FILENO );
-    execlp( "sh", "sh", "-c", "gdb", (void*)NULL);
+  }
-  char cmd[256];
-  snprintf( cmd, 256, "file %s\nattach %d\nc\n", getInstance()->appName.c_str(), sigPid );
-  write( gdbIn[1], cmd, strlen(cmd) );
-  int charsFound = 0;
-  int promptFound = 0;
-  char byte;
-  while ( read( gdbOut[0], &byte, 1 ) == 1 )
+  {
-    if (
-      charsFound == 0 && byte == '(' ||
-      charsFound == 1 && byte == 'g' ||
-      charsFound == 2 && byte == 'd' ||
-      charsFound == 3 && byte == 'b' ||
-      charsFound == 4 && byte == ')' ||
-      charsFound == 5 && byte == ' '
+        )
-          charsFound++;
-    else
-      charsFound = 0;
-    if ( charsFound == 6 )
+    {
-      promptFound++;
-      charsFound = 0;
+    }
-    if ( promptFound == 3 )
+    {
-      break;
+    }
+  }
-  int someData = 0x12345678;
-  write( sigPipe[1], &someData, sizeof(someData) );
-  write( gdbIn[1], "bt\nk\nq\n", 7 );
-  charsFound = 0;
-  promptFound = 0;
-  std::string bt;
-  while ( read( gdbOut[0], &byte, 1 ) == 1 )
+  {
-    bt += std::string( &byte, 1 );
-    if (
-      charsFound == 0 && byte == '(' ||
-      charsFound == 1 && byte == 'g' ||
-      charsFound == 2 && byte == 'd' ||
-      charsFound == 3 && byte == 'b' ||
-      charsFound == 4 && byte == ')' ||
-      charsFound == 5 && byte == ' '
+        )
-          charsFound++;
-    else
-      charsFound = 0;
-    if ( charsFound == 6 )
+    {
-      promptFound++;
-      charsFound = 0;
-      bt += "\n";
+    }
-    if ( promptFound == 3 )
+    {
-      break;
+    }
+  }
-  waitpid( sigPid, NULL, 0 );
-  waitpid( gdbPid, NULL, 0 );
-  int wsRemoved = 0;
-  while ( wsRemoved < 2 && bt.length() > 0 )
+  {
-    if ( bt[1] == '\n' )
-      wsRemoved++;
-    bt.erase(0, 1);
+  }
-  if ( bt.length() > 0 )
-    bt.erase(0, 1);
-  time_t now = time(NULL);
-  std::string timeString = "\n\n\n\n"
-                     "=======================================================\n"
-                     "= time: " + std::string(ctime(&now)) +
-         "=======================================================\n";
-  bt.insert(0, timeString);
-  FILE * f = fopen( getInstance()->filename.c_str(), "a" );
-  if ( !f )
+  {
-    perror( ( std::string( "could not append to " ) + getInstance()->filename ).c_str() );
-    exit(EXIT_FAILURE);
+  }
-  if ( fwrite( bt.c_str(), 1, bt.length(), f ) != bt.length() )
+  {
-    COUT(0) << "could not write " << bt.length() << " byte to " << getInstance()->filename << std::endl;
-    exit(EXIT_FAILURE);
+  }
-  exit(EXIT_FAILURE);
+}
-void SignalHandler::registerCallback( SignalCallback cb, void * someData )
+{
-  SignalCallbackRec rec;
-  rec.cb = cb;
-  rec.someData = someData;
-  callbackList.push_back(rec);
+}
 #endif /* ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32 */

code/trunk/src/util/SignalHandler.h

Property svn:mergeinfo changed
/code/branches/objecthierarchy/src/util/SignalHandler.h merged: 2111

-                      r2103
+                      r2171
 #include <string>
+typedef int (*SignalCallback)( void * someData );
+namespace orxonox
+{
+    typedef int (*SignalCallback)( void * someData );
+}
 #if ORXONOX_PLATFORM != ORXONOX_PLATFORM_WIN32
 #include <signal.h>
+struct SignalRec
+namespace orxonox
+{
+  int signal;
+  sig_t handler;
+};
+    struct SignalRec
+    {
+        int signal;
+        sig_t handler;
+    };
 struct SignalCallbackRec
+{
   SignalCallback cb;
   void * someData;
 };
+    struct SignalCallbackRec
+    {
+        SignalCallback cb;
+        void * someData;
+    };
 typedef std::list<SignalRec> SignalRecList;
 typedef std::list<SignalCallbackRec> SignalCallbackList;
+    typedef std::list<SignalRec> SignalRecList;
+    typedef std::list<SignalCallbackRec> SignalCallbackList;
 class SignalHandler
+{
   private:
     SignalHandler();
   public:
     inline static SignalHandler* getInstance() { if (!SignalHandler::singletonRef) SignalHandler::singletonRef = new SignalHandler(); return SignalHandler::singletonRef; }
     ~SignalHandler(){ SignalHandler::singletonRef = NULL; }
+    class SignalHandler
+    {
+    private:
+        SignalHandler();
+    public:
+        inline static SignalHandler* getInstance() { if (!SignalHandler::singletonRef) SignalHandler::singletonRef = new SignalHandler(); return SignalHandler::singletonRef; }
+        ~SignalHandler(){ SignalHandler::singletonRef = NULL; }
     void registerCallback( SignalCallback cb, void * someData );
+        void registerCallback( SignalCallback cb, void * someData );
     void doCatch( const std::string & appName, const std::string & filename );
     void dontCatch();
+        void doCatch( const std::string & appName, const std::string & filename );
+        void dontCatch();
   private:
     static void sigHandler( int sig );
+    private:
+        static void sigHandler( int sig );
     void catchSignal( int sig );
     SignalRecList sigRecList;
+        void catchSignal( int sig );
+        SignalRecList sigRecList;
     SignalCallbackList callbackList;
+        SignalCallbackList callbackList;
     static SignalHandler * singletonRef;
+        static SignalHandler * singletonRef;
     std::string appName;
     std::string filename;
+        std::string appName;
+        std::string filename;
+    // used to turn on KeyAutoRepeat if OIS crashes
+    static bool bXAutoKeyRepeatOn_;
+};
+        // used to turn on KeyAutoRepeat if OIS crashes
+        static bool bXAutoKeyRepeatOn_;
+    };
+}
 #else /* ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32 */
+class _UtilExport SignalHandler
+namespace orxonox
+{
+  public:
+    inline static SignalHandler* getInstance() { if (!SignalHandler::singletonRef) SignalHandler::singletonRef = new SignalHandler(); return SignalHandler::singletonRef; };
+    void doCatch( const std::string & appName, const std::string & filename ) {};
+    void dontCatch() {};
+    void registerCallback( SignalCallback cb, void * someData ) {};
+    class _UtilExport SignalHandler
+    {
+    public:
+        inline static SignalHandler* getInstance() { if (!SignalHandler::singletonRef) SignalHandler::singletonRef = new SignalHandler(); return SignalHandler::singletonRef; };
+        void doCatch( const std::string & appName, const std::string & filename ) {};
+        void dontCatch() {};
+        void registerCallback( SignalCallback cb, void * someData ) {};
+  private:
+    static SignalHandler * singletonRef;
+};
+    private:
+        static SignalHandler * singletonRef;
+    };
+}
 #endif /* ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32 */

code/trunk/src/util/Sleep.h

-                      r1841
+                      r2171
 #include <winbase.h>
+inline void usleep(DWORD dwMicroseconds)
+namespace orxonox
+{
+  Sleep(dwMicroseconds / 1000);
+}
+    inline void usleep(DWORD dwMicroseconds)
+    {
+        Sleep(dwMicroseconds / 1000);
+    }
 inline void msleep(DWORD dwMilliseconds)
+{
   Sleep(dwMilliseconds);
+}
+    inline void msleep(DWORD dwMilliseconds)
+    {
+        Sleep(dwMilliseconds);
+    }
+inline void sleep(DWORD dwSeconds)
+{
+  Sleep(dwSeconds * 1000);
+    inline void sleep(DWORD dwSeconds)
+    {
+        Sleep(dwSeconds * 1000);
+    }
+}
 …
 #include <unistd.h>
+inline void msleep(unsigned long msec)
+namespace orxonox
+{
+  usleep(msec * 1000);
+    inline void usleep(unsigned long usec)
+    {
+        ::usleep(usec);
+    }
+    inline void msleep(unsigned long msec)
+    {
+        ::usleep(msec * 1000);
+    }
+    inline void sleep(unsigned long sec)
+    {
+        ::usleep(sec * 1000000);
+    }
+}

code/trunk/src/util/String.cc

-                      r2087
+                      r2171
 /**
     @file String.cc
+    @file
     @brief Implementation of several string manipulation functions.
 */
 …
 #include "Math.h"
+std::string BLANKSTRING("");
+std::string getUniqueNumberString()
+namespace orxonox
+{
+    return convertToString(getUniqueNumber());
+    std::string BLANKSTRING("");
+    std::string getUniqueNumberString()
+    {
+        return convertToString(getUniqueNumber());
+    }
+    /**
+        @brief Removes all whitespaces from a string.
+        @param str The string to strip
+    */
+    void strip(std::string* str)
+    {
+        size_t pos;
+        while ((pos = (*str).find(" ")) < (*str).length())
+            (*str).erase(pos, 1);
+        while ((pos = (*str).find("\t")) < (*str).length())
+            (*str).erase(pos, 1);
+        while ((pos = (*str).find("\n")) < (*str).length())
+            (*str).erase(pos, 1);
+    }
+    /**
+        @brief Returns a copy of a string without whitespaces.
+        @param str The string to strip
+        @return The stripped line
+    */
+    std::string getStripped(const std::string& str)
+    {
+        std::string output = std::string(str);
+        strip(&output);
+        return output;
+    }
+    /**
+        @brief Returns a copy of a string without trailing whitespaces.
+        @param str The string
+        @return The modified copy
+    */
+    std::string removeTrailingWhitespaces(const std::string& str)
+    {
+        size_t pos1 = 0;
+        int pos2 = str.size() - 1;
+        for (; pos1 < str.size() && (str[pos1] == ' ' || str[pos1] == '\t' || str[pos1] == '\n'); pos1++);
+        for (; pos2 > 0         && (str[pos2] == ' ' || str[pos2] == '\t' || str[pos2] == '\n'); pos2--);
+        return str.substr(pos1, pos2 - pos1 + 1);
+    }
+    /**
+        @brief Returns the position of the next quote in the string, starting with start.
+        @param str The string
+        @param start The startposition
+        @return The position of the next quote (std::string::npos if there is no next quote)
+    */
+    size_t getNextQuote(const std::string& str, size_t start)
+    {
+        size_t quote = start - 1;
+        while ((quote = str.find('\"', quote + 1)) != std::string::npos)
+        {
+            size_t backslash = quote;
+            size_t numbackslashes = 0;
+            for (; backslash > 0; backslash--, numbackslashes++)
+                if (str[backslash - 1] != '\\')
+                    break;
+            if (numbackslashes % 2 == 0)
+                break;
+        }
+        return quote;
+    }
+    /**
+        @brief Returns true if pos is between two quotes.
+        @param str The string
+        @param pos The position to check
+        @return True if pos is between two quotes
+    */
+    bool isBetweenQuotes(const std::string& str, size_t pos)
+    {
+        if (pos == std::string::npos)
+            return false;
+        size_t quotecount = 0;
+        size_t quote = (size_t)-1;
+        while ((quote = getNextQuote(str, quote + 1)) < pos)
+        {
+            if (quote == pos)
+                return false;
+            quotecount++;
+        }
+        if (quote == std::string::npos)
+            return false;
+        return ((quotecount % 2) == 1);
+    }
+    /**
+        @brief Returns true if the string contains something like '..."between quotes"...'.
+        @param The string
+        @return True if there is something between quotes
+    */
+    bool hasStringBetweenQuotes(const std::string& str)
+    {
+        size_t pos1 = getNextQuote(str, 0);
+        size_t pos2 = getNextQuote(str, pos1 + 1);
+        return (pos1 != std::string::npos && pos2 != std::string::npos && pos2 > pos1 + 1);
+    }
+    /**
+        @brief If the string contains something like '..."between quotes"...' then 'between quotes' gets returned (without quotes).
+        @param The string
+        @param The string between the quotes
+    */
+    std::string getStringBetweenQuotes(const std::string& str)
+    {
+        size_t pos1 = getNextQuote(str, 0);
+        size_t pos2 = getNextQuote(str, pos1 + 1);
+        if (pos1 != std::string::npos && pos2 != std::string::npos)
+            return str.substr(pos1, pos2 - pos1 + 1);
+        else
+            return "";
+    }
+    /**
+        @brief Removes enclosing quotes if available (including whitespaces at the outside of the quotes).
+        @brief str The string to strip
+        @return The string with removed quotes
+    */
+    std::string stripEnclosingQuotes(const std::string& str)
+    {
+        size_t start = std::string::npos;
+        size_t end = 0;
+        for (size_t pos = 0; (pos < str.size()) && (pos < std::string::npos); pos++)
+        {
+            if (str[pos] == '"')
+            {
+                start = pos;
+                break;
+            }
+            if ((str[pos] != ' ') && (str[pos] != '\t') && (str[pos] != '\n'))
+                return str;
+        }
+        for (size_t pos = str.size() - 1; pos < std::string::npos; pos--)
+        {
+            if (str[pos] == '"')
+            {
+                end = pos;
+                break;
+            }
+            if ((str[pos] != ' ') && (str[pos] != '\t') && (str[pos] != '\n'))
+                return str;
+        }
+        if ((start != std::string::npos) && (end != 0))
+            return str.substr(start + 1, end - start - 1);
+        else
+            return str;
+    }
+    /**
+        @brief Removes enclosing {braces} (braces must be exactly on the beginning and the end of the string).
+        @param str The string to strip
+        @return The striped string
+    */
+    std::string stripEnclosingBraces(const std::string& str)
+    {
+        std::string output = str;
+        while (output.size() >= 2 && output[0] == '{' && output[output.size() - 1] == '}')
+            output = output.substr(1, output.size() - 2);
+        return output;
+    }
+    /**
+        @brief Determines if a string is a comment (starts with a comment-symbol).
+        @param str The string to check
+        @return True = it's a comment
+        A comment is defined by a leading '#', '%', ';' or '//'.
+    */
+    bool isComment(const std::string& str)
+    {
+        // Strip the line, whitespaces are disturbing
+        std::string teststring = getStripped(str);
+        // There are four possible comment-symbols:
+        //  1) #comment in script-language style
+        //  2) %comment in matlab style
+        //  3) ;comment in unreal tournament config-file style
+        //  4) //comment in code style
+        if (teststring.size() >= 2)
+        {
+            if (teststring[0] == '#' || teststring[0] == '%' || teststring[0] == ';' || (teststring[0] == '/' && teststring[1] == '/'))
+                return true;
+        }
+        else if (teststring.size() == 1)
+        {
+            if (teststring[0] == '#' || teststring[0] == '%' || teststring[0] == ';')
+                return true;
+        }
+        return false;
+    }
+    /**
+        @brief Determines if a string is empty (contains only whitespaces).
+        @param str The string to check
+        @return True = it's empty
+    */
+    bool isEmpty(const std::string& str)
+    {
+        std::string temp = getStripped(str);
+        return ((temp == "") || (temp.size() == 0));
+    }
+    /**
+        @brief Determines if a string contains only numbers and maximal one '.'.
+        @param str The string to check
+        @return True = it's a number
+    */
+    bool isNumeric(const std::string& str)
+    {
+        bool foundPoint = false;
+        for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
+        {
+            if (((*it) < '0' || (*it) > '9'))
+            {
+                if ((*it) != '.' && !foundPoint)
+                    foundPoint = true;
+                else
+                    return false;
+            }
+        }
+        return true;
+    }
+    /**
+        @brief Adds backslashes to the given string which makes special chars visible. Existing slashes will be doubled.
+        @param str The string to manipulate
+        @return The string with added slashes
+    */
+    std::string addSlashes(const std::string& str)
+    {
+        std::string output = str;
+        for (size_t pos = 0; (pos = output.find('\\', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\\\"); }
+        for (size_t pos = 0; (pos = output.find('\n', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\n"); }
+        for (size_t pos = 0; (pos = output.find('\t', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\t"); }
+        for (size_t pos = 0; (pos = output.find('\v', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\v"); }
+        for (size_t pos = 0; (pos = output.find('\b', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\b"); }
+        for (size_t pos = 0; (pos = output.find('\r', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\r"); }
+        for (size_t pos = 0; (pos = output.find('\f', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\f"); }
+        for (size_t pos = 0; (pos = output.find('\a', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\a"); }
+        for (size_t pos = 0; (pos = output.find('"', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\\""); }
+        for (size_t pos = 0; (pos = output.find('\0', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\0"); }
+        return output;
+    }
+    /**
+        @brief Removes backslashes from the given string. Double backslashes are interpreted as one backslash.
+        @param str The string to manipulate
+        @return The string with removed slashes
+    */
+    std::string removeSlashes(const std::string& str)
+    {
+        if (str.size() <= 1)
+            return str;
+        std::string output = "";
+        for (size_t pos = 0; pos < str.size() - 1; )
+        {
+            if (str[pos] == '\\')
+            {
+                if (str[pos + 1] == '\\') { output += '\\'; pos += 2; continue; }
+                else if (str[pos + 1] == 'n') { output += '\n'; pos += 2; continue; }
+                else if (str[pos + 1] == 't') { output += '\t'; pos += 2; continue; }
+                else if (str[pos + 1] == 'v') { output += '\v'; pos += 2; continue; }
+                else if (str[pos + 1] == 'b') { output += '\b'; pos += 2; continue; }
+                else if (str[pos + 1] == 'r') { output += '\r'; pos += 2; continue; }
+                else if (str[pos + 1] == 'f') { output += '\f'; pos += 2; continue; }
+                else if (str[pos + 1] == 'a') { output += '\a'; pos += 2; continue; }
+                else if (str[pos + 1] == '"') { output += '"'; pos += 2; continue; }
+                else if (str[pos + 1] == '0') { output += '\0'; pos += 2; continue; }
+            }
+            output += str[pos];
+            pos++;
+            if (pos == str.size() - 1)
+                output += str[pos];
+        }
+        return output;
+    }
+    /**
+        @brief Replaces each char between A and Z with its lowercase equivalent.
+        @param str The string to convert
+    */
+    void lowercase(std::string* str)
+    {
+        for (size_t i = 0; i < str->size(); ++i)
+        {
+            (*str)[i] = (char)tolower((*str)[i]);
+        }
+    }
+    /**
+        @brief Returns a copy of the given string without uppercase chars.
+        @param str The string
+        @return The copy
+    */
+    std::string getLowercase(const std::string& str)
+    {
+        std::string output = std::string(str);
+        lowercase(&output);
+        return output;
+    }
+    /**
+        @brief Replaces each char between a and z with its uppercase equivalent.
+        @param str The string to convert
+    */
+    void uppercase(std::string* str)
+    {
+        for (size_t i = 0; i < str->size(); ++i)
+        {
+            (*str)[i] = (char)toupper((*str)[i]);
+        }
+    }
+    /**
+        @brief Returns a copy of the given string without lowercase chars.
+        @param str The string
+        @return The copy
+    */
+    std::string getUppercase(const std::string& str)
+    {
+        std::string output = std::string(str);
+        uppercase(&output);
+        return output;
+    }
+    /**
+        @brief Compares two strings ignoring different casing.
+        @param s1 First string
+        @param s2 Second string
+    */
+    int nocaseCmp(const std::string& s1, const std::string& s2)
+    {
+        std::string::const_iterator it1=s1.begin();
+        std::string::const_iterator it2=s2.begin();
+        //stop when either string's end has been reached
+        while ( (it1!=s1.end()) && (it2!=s2.end()) )
+        {
+            if(::toupper(*it1) != ::toupper(*it2)) //letters differ?
+                // return -1 to indicate smaller than, 1 otherwise
+                return (::toupper(*it1)  < ::toupper(*it2)) ? -1 : 1;
+            //proceed to the next character in each string
+            ++it1;
+            ++it2;
+        }
+        size_t size1=s1.size(), size2=s2.size();// cache lengths
+        //return -1,0 or 1 according to strings' lengths
+        if (size1==size2)
+            return 0;
+        return (size1<size2) ? -1 : 1;
+    }
+    /**
+        @brief Compares the first 'len' chars of two strings ignoring different casing.
+        @param s1 First string
+        @param s2 Second string
+        @param len Maximal number of chars to compare
+    */
+    int nocaseCmp(const std::string& s1, const std::string& s2, size_t len)
+    {
+        if (len == 0)
+            return 0;
+        std::string::const_iterator it1=s1.begin();
+        std::string::const_iterator it2=s2.begin();
+        //stop when either string's end has been reached
+        while ( (it1!=s1.end()) && (it2!=s2.end()) && len-- > 0)
+        {
+            if(::toupper(*it1) != ::toupper(*it2)) //letters differ?
+                // return -1 to indicate smaller than, 1 otherwise
+                return (::toupper(*it1)  < ::toupper(*it2)) ? -1 : 1;
+            //proceed to the next character in each string
+            ++it1;
+            ++it2;
+        }
+        return 0;
+    }
+    /**
+        @brief Returns true if the string contains a comment, introduced by #, %, ; or //.
+        @param str The string
+        @return True if the string contains a comment
+    */
+    bool hasComment(const std::string& str)
+    {
+        return (getCommentPosition(str) != std::string::npos);
+    }
+    /**
+        @brief If the string contains a comment, the comment gets returned (including the comment symbol), an empty string otherwise.
+        @param str The string
+        @return The comment
+    */
+    std::string getComment(const std::string& str)
+    {
+        return str.substr(getCommentPosition(str));
+    }
+    /**
+        @brief If the string contains a comment, the position of the comment-symbol gets returned, std::string::npos otherwise.
+        @param str The string
+        @return The position
+    */
+    size_t getCommentPosition(const std::string& str)
+    {
+        return getNextCommentPosition(str, 0);
+    }
+    /**
+        @brief Returns the position of the next comment-symbol, starting with start.
+        @param str The string
+        @param start The startposition
+        @return The position
+    */
+    size_t getNextCommentPosition(const std::string& str, size_t start)
+    {
+        for (size_t i = start; i < str.size(); i++)
+            if (isComment(str.substr(i)))
+                return i;
+        return std::string::npos;
+    }
+}
-/**
-    @brief Removes all whitespaces from a string.
-    @param str The string to strip
-*/
-void strip(std::string* str)
+{
-    size_t pos;
-    while ((pos = (*str).find(" ")) < (*str).length())
-        (*str).erase(pos, 1);
-    while ((pos = (*str).find("\t")) < (*str).length())
-        (*str).erase(pos, 1);
-    while ((pos = (*str).find("\n")) < (*str).length())
-        (*str).erase(pos, 1);
+}
-/**
-    @brief Returns a copy of a string without whitespaces.
-    @param str The string to strip
-    @return The stripped line
-*/
-std::string getStripped(const std::string& str)
+{
-    std::string output = std::string(str);
-    strip(&output);
-    return output;
+}
-/**
-    @brief Returns a copy of a string without trailing whitespaces.
-    @param str The string
-    @return The modified copy
-*/
-std::string removeTrailingWhitespaces(const std::string& str)
+{
-    size_t pos1 = 0;
-    int pos2 = str.size() - 1;
-    for (; pos1 < str.size() && (str[pos1] == ' ' || str[pos1] == '\t' || str[pos1] == '\n'); pos1++);
-    for (; pos2 > 0         && (str[pos2] == ' ' || str[pos2] == '\t' || str[pos2] == '\n'); pos2--);
-    return str.substr(pos1, pos2 - pos1 + 1);
+}
-/**
-    @brief Returns the position of the next quote in the string, starting with start.
-    @param str The string
-    @param start The startposition
-    @return The position of the next quote (std::string::npos if there is no next quote)
-*/
-size_t getNextQuote(const std::string& str, size_t start)
+{
-    size_t quote = start - 1;
-    while ((quote = str.find('\"', quote + 1)) != std::string::npos)
+    {
-        size_t backslash = quote;
-        size_t numbackslashes = 0;
-        for (; backslash > 0; backslash--, numbackslashes++)
-            if (str[backslash - 1] != '\\')
-                break;
-        if (numbackslashes % 2 == 0)
-            break;
+    }
-    return quote;
+}
-/**
-    @brief Returns true if pos is between two quotes.
-    @param str The string
-    @param pos The position to check
-    @return True if pos is between two quotes
-*/
-bool isBetweenQuotes(const std::string& str, size_t pos)
+{
-    if (pos == std::string::npos)
-        return false;
-    size_t quotecount = 0;
-    size_t quote = (size_t)-1;
-    while ((quote = getNextQuote(str, quote + 1)) < pos)
+    {
-        if (quote == pos)
-            return false;
-        quotecount++;
+    }
-    if (quote == std::string::npos)
-        return false;
-    return ((quotecount % 2) == 1);
+}
-/**
-    @brief Returns true if the string contains something like '..."between quotes"...'.
-    @param The string
-    @return True if there is something between quotes
-*/
-bool hasStringBetweenQuotes(const std::string& str)
+{
-    size_t pos1 = getNextQuote(str, 0);
-    size_t pos2 = getNextQuote(str, pos1 + 1);
-    return (pos1 != std::string::npos && pos2 != std::string::npos && pos2 > pos1 + 1);
+}
-/**
-    @brief If the string contains something like '..."between quotes"...' then 'between quotes' gets returned (without quotes).
-    @param The string
-    @param The string between the quotes
-*/
-std::string getStringBetweenQuotes(const std::string& str)
+{
-    size_t pos1 = getNextQuote(str, 0);
-    size_t pos2 = getNextQuote(str, pos1 + 1);
-    if (pos1 != std::string::npos && pos2 != std::string::npos)
-        return str.substr(pos1, pos2 - pos1 + 1);
-    else
-        return "";
+}
-/**
-    @brief Removes enclosing quotes if available (including whitespaces at the outside of the quotes).
-    @brief str The string to strip
-    @return The string with removed quotes
-*/
-std::string stripEnclosingQuotes(const std::string& str)
+{
-    size_t start = std::string::npos;
-    size_t end = 0;
-    for (size_t pos = 0; (pos < str.size()) && (pos < std::string::npos); pos++)
+    {
-        if (str[pos] == '"')
+        {
-            start = pos;
-            break;
+        }
-        if ((str[pos] != ' ') && (str[pos] != '\t') && (str[pos] != '\n'))
-            return str;
+    }
-    for (size_t pos = str.size() - 1; pos < std::string::npos; pos--)
+    {
-        if (str[pos] == '"')
+        {
-            end = pos;
-            break;
+        }
-        if ((str[pos] != ' ') && (str[pos] != '\t') && (str[pos] != '\n'))
-            return str;
+    }
-    if ((start != std::string::npos) && (end != 0))
-        return str.substr(start + 1, end - start - 1);
-    else
-        return str;
+}
-/**
-    @brief Removes enclosing {braces} (braces must be exactly on the beginning and the end of the string).
-    @param str The string to strip
-    @return The striped string
-*/
-std::string stripEnclosingBraces(const std::string& str)
+{
-    std::string output = str;
-    while (output.size() >= 2 && output[0] == '{' && output[output.size() - 1] == '}')
-        output = output.substr(1, output.size() - 2);
-    return output;
+}
-/**
-    @brief Determines if a string is a comment (starts with a comment-symbol).
-    @param str The string to check
-    @return True = it's a comment
-    A comment is defined by a leading '#', '%', ';' or '//'.
-*/
-bool isComment(const std::string& str)
+{
-    // Strip the line, whitespaces are disturbing
-    std::string teststring = getStripped(str);
-    // There are four possible comment-symbols:
-    //  1) #comment in script-language style
-    //  2) %comment in matlab style
-    //  3) ;comment in unreal tournament config-file style
-    //  4) //comment in code style
-    if (teststring.size() >= 2)
+    {
-        if (teststring[0] == '#' || teststring[0] == '%' || teststring[0] == ';' || (teststring[0] == '/' && teststring[1] == '/'))
-            return true;
+    }
-    else if (teststring.size() == 1)
+    {
-        if (teststring[0] == '#' || teststring[0] == '%' || teststring[0] == ';')
-            return true;
+    }
-    return false;
+}
-/**
-    @brief Determines if a string is empty (contains only whitespaces).
-    @param str The string to check
-    @return True = it's empty
-*/
-bool isEmpty(const std::string& str)
+{
-    std::string temp = getStripped(str);
-    return ((temp == "") || (temp.size() == 0));
+}
-/**
-    @brief Determines if a string contains only numbers and maximal one '.'.
-    @param str The string to check
-    @return True = it's a number
-*/
-bool isNumeric(const std::string& str)
+{
-    bool foundPoint = false;
-    for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
+    {
-        if (((*it) < '0' || (*it) > '9'))
+        {
-            if ((*it) != '.' && !foundPoint)
-                foundPoint = true;
-            else
-                return false;
+        }
+    }
-    return true;
+}
-/**
-    @brief Adds backslashes to the given string which makes special chars visible. Existing slashes will be doubled.
-    @param str The string to manipulate
-    @return The string with added slashes
-*/
-std::string addSlashes(const std::string& str)
+{
-    std::string output = str;
-    for (size_t pos = 0; (pos = output.find('\\', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\\\"); }
-    for (size_t pos = 0; (pos = output.find('\n', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\n"); }
-    for (size_t pos = 0; (pos = output.find('\t', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\t"); }
-    for (size_t pos = 0; (pos = output.find('\v', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\v"); }
-    for (size_t pos = 0; (pos = output.find('\b', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\b"); }
-    for (size_t pos = 0; (pos = output.find('\r', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\r"); }
-    for (size_t pos = 0; (pos = output.find('\f', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\f"); }
-    for (size_t pos = 0; (pos = output.find('\a', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\a"); }
-    for (size_t pos = 0; (pos = output.find('"', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\\""); }
-    for (size_t pos = 0; (pos = output.find('\0', pos)) < std::string::npos; pos += 2) { output.replace(pos, 1, "\\0"); }
-    return output;
+}
-/**
-    @brief Removes backslashes from the given string. Double backslashes are interpreted as one backslash.
-    @param str The string to manipulate
-    @return The string with removed slashes
-*/
-std::string removeSlashes(const std::string& str)
+{
-    if (str.size() <= 1)
-        return str;
-    std::string output = "";
-    for (size_t pos = 0; pos < str.size() - 1; )
+    {
-        if (str[pos] == '\\')
+        {
-            if (str[pos + 1] == '\\') { output += '\\'; pos += 2; continue; }
-            else if (str[pos + 1] == 'n') { output += '\n'; pos += 2; continue; }
-            else if (str[pos + 1] == 't') { output += '\t'; pos += 2; continue; }
-            else if (str[pos + 1] == 'v') { output += '\v'; pos += 2; continue; }
-            else if (str[pos + 1] == 'b') { output += '\b'; pos += 2; continue; }
-            else if (str[pos + 1] == 'r') { output += '\r'; pos += 2; continue; }
-            else if (str[pos + 1] == 'f') { output += '\f'; pos += 2; continue; }
-            else if (str[pos + 1] == 'a') { output += '\a'; pos += 2; continue; }
-            else if (str[pos + 1] == '"') { output += '"'; pos += 2; continue; }
-            else if (str[pos + 1] == '0') { output += '\0'; pos += 2; continue; }
+        }
-        output += str[pos];
-        pos++;
-        if (pos == str.size() - 1)
-            output += str[pos];
+    }
-    return output;
+}
-/**
-    @brief Replaces each char between A and Z with its lowercase equivalent.
-    @param str The string to convert
-*/
-void lowercase(std::string* str)
+{
-    for (size_t i = 0; i < str->size(); ++i)
+    {
-        (*str)[i] = (char)tolower((*str)[i]);
+    }
+}
-/**
-    @brief Returns a copy of the given string without uppercase chars.
-    @param str The string
-    @return The copy
-*/
-std::string getLowercase(const std::string& str)
+{
-    std::string output = std::string(str);
-    lowercase(&output);
-    return output;
+}
-/**
-    @brief Replaces each char between a and z with its uppercase equivalent.
-    @param str The string to convert
-*/
-void uppercase(std::string* str)
+{
-    for (size_t i = 0; i < str->size(); ++i)
+    {
-        (*str)[i] = (char)toupper((*str)[i]);
+    }
+}
-/**
-    @brief Returns a copy of the given string without lowercase chars.
-    @param str The string
-    @return The copy
-*/
-std::string getUppercase(const std::string& str)
+{
-    std::string output = std::string(str);
-    uppercase(&output);
-    return output;
+}
-/**
-    @brief Compares two strings ignoring different casing.
-    @param s1 First string
-    @param s2 Second string
-*/
-int nocaseCmp(const std::string& s1, const std::string& s2)
+{
-    std::string::const_iterator it1=s1.begin();
-    std::string::const_iterator it2=s2.begin();
-    //stop when either string's end has been reached
-    while ( (it1!=s1.end()) && (it2!=s2.end()) )
+    {
-        if(::toupper(*it1) != ::toupper(*it2)) //letters differ?
-            // return -1 to indicate smaller than, 1 otherwise
-            return (::toupper(*it1)  < ::toupper(*it2)) ? -1 : 1;
-        //proceed to the next character in each string
-        ++it1;
-        ++it2;
+    }
-    size_t size1=s1.size(), size2=s2.size();// cache lengths
-    //return -1,0 or 1 according to strings' lengths
-    if (size1==size2)
-        return 0;
-    return (size1<size2) ? -1 : 1;
+}
-/**
-    @brief Compares the first 'len' chars of two strings ignoring different casing.
-    @param s1 First string
-    @param s2 Second string
-    @param len Maximal number of chars to compare
-*/
-int nocaseCmp(const std::string& s1, const std::string& s2, size_t len)
+{
-    if (len == 0)
-        return 0;
-    std::string::const_iterator it1=s1.begin();
-    std::string::const_iterator it2=s2.begin();
-    //stop when either string's end has been reached
-    while ( (it1!=s1.end()) && (it2!=s2.end()) && len-- > 0)
+    {
-        if(::toupper(*it1) != ::toupper(*it2)) //letters differ?
-            // return -1 to indicate smaller than, 1 otherwise
-            return (::toupper(*it1)  < ::toupper(*it2)) ? -1 : 1;
-        //proceed to the next character in each string
-        ++it1;
-        ++it2;
+    }
-    return 0;
+}
-/**
-    @brief Returns true if the string contains a comment, introduced by #, %, ; or //.
-    @param str The string
-    @return True if the string contains a comment
-*/
-bool hasComment(const std::string& str)
+{
-    return (getCommentPosition(str) != std::string::npos);
+}
-/**
-    @brief If the string contains a comment, the comment gets returned (including the comment symbol), an empty string otherwise.
-    @param str The string
-    @return The comment
-*/
-std::string getComment(const std::string& str)
+{
-    return str.substr(getCommentPosition(str));
+}
-/**
-    @brief If the string contains a comment, the position of the comment-symbol gets returned, std::string::npos otherwise.
-    @param str The string
-    @return The position
-*/
-size_t getCommentPosition(const std::string& str)
+{
-    return getNextCommentPosition(str, 0);
+}
-/**
-    @brief Returns the position of the next comment-symbol, starting with start.
-    @param str The string
-    @param start The startposition
-    @return The position
-*/
-size_t getNextCommentPosition(const std::string& str, size_t start)
+{
-    for (size_t i = start; i < str.size(); i++)
-        if (isComment(str.substr(i)))
-            return i;
-    return std::string::npos;
+}

code/trunk/src/util/String.h

-                      r2087
+                      r2171
 /**
     @file String.h
+    @file
     @brief Declaration of several string manipulation functions, used in many parts of the game.
 */
 …
 #include <sstream>
+extern _UtilExport std::string BLANKSTRING;
+_UtilExport std::string getUniqueNumberString();
+namespace orxonox
+{
+    extern _UtilExport std::string BLANKSTRING;
+    _UtilExport std::string getUniqueNumberString();
 _UtilExport void        strip(std::string* str);
 _UtilExport std::string getStripped(const std::string& str);
+    _UtilExport void        strip(std::string* str);
+    _UtilExport std::string getStripped(const std::string& str);
 _UtilExport std::string removeTrailingWhitespaces(const std::string& str);
+    _UtilExport std::string removeTrailingWhitespaces(const std::string& str);
 _UtilExport size_t      getNextQuote(const std::string& str, size_t start);
 _UtilExport bool        isBetweenQuotes(const std::string& str, size_t pos);
+    _UtilExport size_t      getNextQuote(const std::string& str, size_t start);
+    _UtilExport bool        isBetweenQuotes(const std::string& str, size_t pos);
 _UtilExport bool        hasStringBetweenQuotes(const std::string& str);
 _UtilExport std::string getStringBetweenQuotes(const std::string& str);
+    _UtilExport bool        hasStringBetweenQuotes(const std::string& str);
+    _UtilExport std::string getStringBetweenQuotes(const std::string& str);
 _UtilExport std::string stripEnclosingQuotes(const std::string& str);
 _UtilExport std::string stripEnclosingBraces(const std::string& str);
+    _UtilExport std::string stripEnclosingQuotes(const std::string& str);
+    _UtilExport std::string stripEnclosingBraces(const std::string& str);
 _UtilExport bool        isEmpty(const std::string& str);
 _UtilExport bool        isComment(const std::string& str);
 _UtilExport bool        isNumeric(const std::string& str);
+    _UtilExport bool        isEmpty(const std::string& str);
+    _UtilExport bool        isComment(const std::string& str);
+    _UtilExport bool        isNumeric(const std::string& str);
 _UtilExport std::string addSlashes(const std::string& str);
 _UtilExport std::string removeSlashes(const std::string& str);
+    _UtilExport std::string addSlashes(const std::string& str);
+    _UtilExport std::string removeSlashes(const std::string& str);
 _UtilExport void        lowercase(std::string* str);
 _UtilExport std::string getLowercase(const std::string& str);
+    _UtilExport void        lowercase(std::string* str);
+    _UtilExport std::string getLowercase(const std::string& str);
 _UtilExport void        uppercase(std::string* str);
 _UtilExport std::string getUppercase(const std::string& str);
+    _UtilExport void        uppercase(std::string* str);
+    _UtilExport std::string getUppercase(const std::string& str);
 _UtilExport int         nocaseCmp(const std::string& s1, const std::string& s2);
 _UtilExport int         nocaseCmp(const std::string& s1, const std::string& s2, size_t len);
+    _UtilExport int         nocaseCmp(const std::string& s1, const std::string& s2);
+    _UtilExport int         nocaseCmp(const std::string& s1, const std::string& s2, size_t len);
+_UtilExport bool        hasComment(const std::string& str);
+_UtilExport std::string getComment(const std::string& str);
+_UtilExport size_t      getCommentPosition(const std::string& str);
+_UtilExport size_t      getNextCommentPosition(const std::string& str, size_t start = 0);
+    _UtilExport bool        hasComment(const std::string& str);
+    _UtilExport std::string getComment(const std::string& str);
+    _UtilExport size_t      getCommentPosition(const std::string& str);
+    _UtilExport size_t      getNextCommentPosition(const std::string& str, size_t start = 0);
+}
 #endif /* _Util_String_H__ */

code/trunk/src/util/SubString.cc

-                      r1791
+                      r2171
 #include "SubString.h"
+/**
+ * @brief default constructor
+ */
+SubString::SubString()
+{}
+/**
+ * @brief create a SubString from
+ * @param string the String to Split
+ * @param delimiter the Character at which to split string (delimiter)
+ */
+SubString::SubString(const std::string& string, char delimiter)
+namespace orxonox
+{
+  this->split(string, delimiter);
+}
+/**
+ * @brief Splits a String into multiple splitters.
+ * @param string the String to split
+ * @param delimiters multiple set of characters at what to split. (delimiters)
+ * @param delimiterNeighbours neighbours of the delimiters, that will be erased only when near a delimiter.
+ * @param emptyEntries If empty entries should be allewed or removed.
+ * @param escapeChar The Escape Character that overrides splitters commends and so on...
+ * @param safemode_char within these characters splitting won't happen
+ * @param comment_char the Comment character.
+ */
+SubString::SubString(const std::string& string,
+                     const std::string& delimiters, const std::string& delimiterNeighbours, bool emptyEntries,
+                     char escapeChar, bool removeEscapeChar, char safemode_char, bool removeSafemodeChar,
+                     char openparenthesis_char, char closeparenthesis_char, bool removeParenthesisChars, char comment_char)
+{
+  SubString::splitLine(this->strings, this->bInSafemode, string, delimiters, delimiterNeighbours, emptyEntries, escapeChar, removeEscapeChar, safemode_char, removeSafemodeChar, openparenthesis_char, closeparenthesis_char, removeParenthesisChars, comment_char);
+}
+/**
+ * @brief creates a SubSet of a SubString.
+ * @param subString the SubString to take a set from.
+ * @param subSetBegin the beginning to the end
+ */
+SubString::SubString(const SubString& subString, unsigned int subSetBegin)
+{
+  for (unsigned int i = subSetBegin; i < subString.size(); i++)
+  {
+    this->strings.push_back(subString[i]);
+    this->bInSafemode.push_back(subString.isInSafemode(i));
+  }
+}
+/**
+ * @brief creates a SubSet of a SubString.
+ * @param subString the SubString to take a Set from
+ * @param subSetBegin the beginning to the end
+ * @param subSetEnd the end of the SubSet (max subString.size() will be checked internaly)
+ */
+SubString::SubString(const SubString& subString, unsigned int subSetBegin, unsigned int subSetEnd)
+{
+  for (unsigned int i = subSetBegin; i < subString.size() && i < subSetEnd; i++)
+  {
+    this->strings.push_back(subString[i]);
+    this->bInSafemode.push_back(subString.isInSafemode(i));
+  }
+}
+/**
+ * @brief creates a Substring from a count and values set.
+ * @param argc: the Arguments Count.
+ * @param argv: Argument Values.
+ */
+SubString::SubString(unsigned int argc, const char** argv)
+{
+  for(unsigned int i = 0; i < argc; ++i)
+  {
+    this->strings.push_back(std::string(argv[i]));
+    this->bInSafemode.push_back(false);
+  }
+}
+/**
+ * @brief removes the object from memory
+ */
+SubString::~SubString()
+{ }
+/** @brief An empty String */
+// const std::string SubString::emptyString = "";
+/** @brief Helper that gets you a String consisting of all White Spaces */
+const std::string SubString::WhiteSpaces = " \n\t";
+/** @brief Helper that gets you a String consisting of all WhiteSpaces and the Comma */
+const std::string SubString::WhiteSpacesWithComma = " \n\t,";
+/** An Empty SubString */
+const SubString SubString::NullSubString = SubString();
+/**
+ * @brief stores the Value of subString in this SubString
+ * @param subString will be copied into this String.
+ * @returns this SubString.
+ */
+SubString& SubString::operator=(const SubString& subString)
+{
+  this->strings = subString.strings;
+  this->bInSafemode = subString.bInSafemode;
+  return *this;
+}
+/**
+ * @brief comparator.
+ * @param subString the SubString to compare against this one.
+ * @returns true if the Stored Strings match
+ */
+bool SubString::operator==(const SubString& subString) const
+{
+  return ((this->strings == subString.strings) && (this->bInSafemode == subString.bInSafemode));
+}
+/**
+ * @brief comparator.
+ * @param subString the SubString to compare against this one.
+ * @returns true if the Stored Strings match
+ */
+bool SubString::compare(const SubString& subString) const
+{
+  return (*this == subString);
+}
+/**
+ * @brief comparator.
+ * @param subString the SubString to compare against this one.
+ * @param length how many entries to compare. (from 0 to length)
+ * @returns true if the Stored Strings match
+ */
+bool SubString::compare(const SubString& subString, unsigned int length) const
+{
+  if (length > this->size() || length > subString.size())
+    return false;
+  for (unsigned int i = 0; i < length; i++)
+    if ((this->strings[i] != subString.strings[i]) || (this->bInSafemode[i] != subString.bInSafemode[i]))
+      return false;
+  return true;
+}
+/**
+ * @brief append operator
+ * @param subString the String to append.
+ * @returns a SubString where this and subString are appended.
+ */
+SubString SubString::operator+(const SubString& subString) const
+{
+  return SubString(*this) += subString;
+}
+/**
+ * @brief append operator.
+ * @param subString append subString to this SubString.
+ * @returns this substring appended with subString
+ */
+SubString& SubString::operator+=(const SubString& subString)
+{
+  for (unsigned int i = 0; i < subString.size(); i++)
+  {
+    this->strings.push_back(subString[i]);
+    this->bInSafemode.push_back(subString.isInSafemode(i));
+  }
+  return *this;
+}
+/**
+ * @brief Split the String at
+ * @param string where to split
+ * @param splitter delimiter.
+ */
+unsigned int SubString::split(const std::string& string, char splitter)
+{
+  this->strings.clear();
+  this->bInSafemode.clear();
+  char split[2];
+  split[0] = splitter;
+  split[1] = '\0';
+  SubString::splitLine(this->strings, this->bInSafemode, string, split);
+  return strings.size();
+}
+/**
+ * @brief Splits a String into multiple splitters.
+ * @param string the String to split
+ * @param delimiters multiple set of characters at what to split. (delimiters)
+ * @param delimiterNeighbours: Neighbours to the Delimiters that will be erased too.
+ * @param emptyEntries: If empty entries are added to the List of SubStrings
+ * @param escapeChar The Escape Character that overrides splitters commends and so on...
+ * @param safemode_char within these characters splitting won't happen
+ * @param comment_char the Comment character.
+ */
+unsigned int SubString::split(const std::string& string,
+                              const std::string& delimiters, const std::string& delimiterNeighbours, bool emptyEntries,
+                              char escapeChar, bool removeExcapeChar, char safemode_char, bool removeSafemodeChar,
+                              char openparenthesis_char, char closeparenthesis_char, bool removeParenthesisChars, char comment_char)
+{
+  this->strings.clear();
+  this->bInSafemode.clear();
+  SubString::splitLine(this->strings, this->bInSafemode, string, delimiters, delimiterNeighbours, emptyEntries, escapeChar, removeExcapeChar, safemode_char, removeSafemodeChar, openparenthesis_char, closeparenthesis_char, removeParenthesisChars, comment_char);
+  return this->strings.size();
+}
+/**
+ * @brief joins together all Strings of this Substring.
+ * @param delimiter the String between the subStrings.
+ * @returns the joined String.
+ */
+std::string SubString::join(const std::string& delimiter) const
+{
+  if (!this->strings.empty())
+  {
+    std::string retVal = this->strings[0];
+    for (unsigned int i = 1; i < this->strings.size(); i++)
+      retVal += delimiter + this->strings[i];
+    return retVal;
+  }
+  else
+  {
+    static std::string empty;
+    return empty;
+  }
+}
+/**
+ * @brief creates a SubSet of a SubString.
+ * @param subSetBegin the beginning to the end
+ * @returns the SubSet
+ *
+ * This function is added for your convenience, and does the same as
+ * SubString::SubString(const SubString& subString, unsigned int subSetBegin)
+ */
+SubString SubString::subSet(unsigned int subSetBegin) const
+{
+  return SubString(*this, subSetBegin);
+}
+/**
+ * @brief creates a SubSet of a SubString.
+ * @param subSetBegin the beginning to
+ * @param subSetEnd the end of the SubSet to select (if bigger than subString.size() it will be downset.)
+ * @returns the SubSet
+ *
+ * This function is added for your convenience, and does the same as
+ * SubString::SubString(const SubString& subString, unsigned int subSetBegin)
+ */
+SubString SubString::subSet(unsigned int subSetBegin, unsigned int subSetEnd) const
+{
+  return SubString(*this, subSetBegin, subSetEnd);
+}
+/**
+ * @brief splits line into tokens and stores them in ret.
+ * @param ret the Array, where the Splitted strings will be stored in
+ * to the beginning of the current token is stored
+ * @param line the inputLine to split
+ * @param delimiters a String of Delimiters (here the input will be splitted)
+ * @param delimiterNeighbours Naighbours to the Delimitter, that will be removed if they are to the left or the right of a Delimiter.
+ * @param emptyEntries: if empty Strings are added to the List of Strings.
+ * @param escape_char: Escape carater (escapes splitters)
+ * @param safemode_char: the beginning of the safemode is marked with this
+ * @param removeSafemodeChar removes the safemode_char from the beginning and the ending of a token
+ * @param openparenthesis_char the beginning of a safemode is marked with this
+ * @param closeparenthesis_char the ending of a safemode is marked with this
+ * @param removeParenthesisChars removes the parenthesis from the beginning and the ending of a token
+ * @param comment_char: the beginning of a comment is marked with this: (until the end of a Line)
+ * @param start_state: the Initial state on how to parse the String.
+ * @return SPLIT_LINE_STATE the parser was in when returning
+ *
+ * This is the Actual Splitting Algorithm from Clemens Wacha
+ * Supports delimiters, escape characters,
+ * ignores special  characters between safemode_char and between comment_char and linend '\n'.
+ */
+SubString::SPLIT_LINE_STATE
+SubString::splitLine(std::vector<std::string>& ret,
+                     std::vector<bool>& bInSafemode,
+                     const std::string& line,
+                     const std::string& delimiters,
+                     const std::string& delimiterNeighbours,
+                     bool emptyEntries,
+                     char escape_char,
+                     bool removeExcapeChar,
+                     char safemode_char,
+                     bool removeSafemodeChar,
+                     char openparenthesis_char,
+                     char closeparenthesis_char,
+                     bool removeParenthesisChars,
+                     char comment_char,
+                     SPLIT_LINE_STATE start_state)
+{
+  SPLIT_LINE_STATE state = start_state;
+  unsigned int i = 0;
+  unsigned int fallBackNeighbours = 0;
+  std::string token;
+  bool inSafemode = false;
+  if(start_state != SL_NORMAL && ret.size() > 0)
+  {
+    token = ret[ret.size()-1];
+    ret.pop_back();
+  }
+  if(start_state != SL_NORMAL && bInSafemode.size() > 0)
+  {
+    inSafemode = bInSafemode[bInSafemode.size()-1];
+    bInSafemode.pop_back();
+  }
+  while(i < line.size())
+  {
+    switch(state)
+    {
+      case SL_NORMAL:
+        if(line[i] == escape_char)
+        {
+          state = SL_ESCAPE;
+          if (!removeExcapeChar)
+            token += line[i];
+        }
+        else if(line[i] == safemode_char)
+        {
+          state = SL_SAFEMODE;
+          inSafemode = true;
+          if (!removeSafemodeChar)
+            token += line[i];
+        }
+        else if(line[i] == openparenthesis_char)
+        {
+          state = SL_PARENTHESES;
+          inSafemode = true;
+          if (!removeParenthesisChars)
+            token += line[i];
+        }
+        else if(line[i] == comment_char)
+        {
+          if (fallBackNeighbours > 0)
+    /**
+     * @brief default constructor
+     */
+    SubString::SubString()
+    {}
+    /**
+     * @brief create a SubString from
+     * @param string the String to Split
+     * @param delimiter the Character at which to split string (delimiter)
+     */
+    SubString::SubString(const std::string& string, char delimiter)
+    {
+        this->split(string, delimiter);
+    }
+    /**
+     * @brief Splits a String into multiple splitters.
+     * @param string the String to split
+     * @param delimiters multiple set of characters at what to split. (delimiters)
+     * @param delimiterNeighbours neighbours of the delimiters, that will be erased only when near a delimiter.
+     * @param emptyEntries If empty entries should be allewed or removed.
+     * @param escapeChar The Escape Character that overrides splitters commends and so on...
+     * @param safemode_char within these characters splitting won't happen
+     * @param comment_char the Comment character.
+     */
+    SubString::SubString(const std::string& string,
+                         const std::string& delimiters, const std::string& delimiterNeighbours, bool emptyEntries,
+                         char escapeChar, bool removeEscapeChar, char safemode_char, bool removeSafemodeChar,
+                         char openparenthesis_char, char closeparenthesis_char, bool removeParenthesisChars, char comment_char)
+    {
+        SubString::splitLine(this->strings, this->bInSafemode, string, delimiters, delimiterNeighbours, emptyEntries, escapeChar, removeEscapeChar, safemode_char, removeSafemodeChar, openparenthesis_char, closeparenthesis_char, removeParenthesisChars, comment_char);
+    }
+    /**
+     * @brief creates a SubSet of a SubString.
+     * @param subString the SubString to take a set from.
+     * @param subSetBegin the beginning to the end
+     */
+    SubString::SubString(const SubString& subString, unsigned int subSetBegin)
+    {
+        for (unsigned int i = subSetBegin; i < subString.size(); i++)
+        {
+            this->strings.push_back(subString[i]);
+            this->bInSafemode.push_back(subString.isInSafemode(i));
+        }
+    }
+    /**
+     * @brief creates a SubSet of a SubString.
+     * @param subString the SubString to take a Set from
+     * @param subSetBegin the beginning to the end
+     * @param subSetEnd the end of the SubSet (max subString.size() will be checked internaly)
+     */
+    SubString::SubString(const SubString& subString, unsigned int subSetBegin, unsigned int subSetEnd)
+    {
+        for (unsigned int i = subSetBegin; i < subString.size() && i < subSetEnd; i++)
+        {
+            this->strings.push_back(subString[i]);
+            this->bInSafemode.push_back(subString.isInSafemode(i));
+        }
+    }
+    /**
+     * @brief creates a Substring from a count and values set.
+     * @param argc: the Arguments Count.
+     * @param argv: Argument Values.
+     */
+    SubString::SubString(unsigned int argc, const char** argv)
+    {
+        for(unsigned int i = 0; i < argc; ++i)
+        {
+            this->strings.push_back(std::string(argv[i]));
+            this->bInSafemode.push_back(false);
+        }
+    }
+    /**
+     * @brief removes the object from memory
+     */
+    SubString::~SubString()
+    { }
+    /** @brief An empty String */
+    // const std::string SubString::emptyString = "";
+    /** @brief Helper that gets you a String consisting of all White Spaces */
+    const std::string SubString::WhiteSpaces = " \n\t";
+    /** @brief Helper that gets you a String consisting of all WhiteSpaces and the Comma */
+    const std::string SubString::WhiteSpacesWithComma = " \n\t,";
+    /** An Empty SubString */
+    const SubString SubString::NullSubString = SubString();
+    /**
+     * @brief stores the Value of subString in this SubString
+     * @param subString will be copied into this String.
+     * @returns this SubString.
+     */
+    SubString& SubString::operator=(const SubString& subString)
+    {
+        this->strings = subString.strings;
+        this->bInSafemode = subString.bInSafemode;
+        return *this;
+    }
+    /**
+     * @brief comparator.
+     * @param subString the SubString to compare against this one.
+     * @returns true if the Stored Strings match
+     */
+    bool SubString::operator==(const SubString& subString) const
+    {
+        return ((this->strings == subString.strings) && (this->bInSafemode == subString.bInSafemode));
+    }
+    /**
+     * @brief comparator.
+     * @param subString the SubString to compare against this one.
+     * @returns true if the Stored Strings match
+     */
+    bool SubString::compare(const SubString& subString) const
+    {
+        return (*this == subString);
+    }
+    /**
+     * @brief comparator.
+     * @param subString the SubString to compare against this one.
+     * @param length how many entries to compare. (from 0 to length)
+     * @returns true if the Stored Strings match
+     */
+    bool SubString::compare(const SubString& subString, unsigned int length) const
+    {
+        if (length > this->size() || length > subString.size())
+            return false;
+        for (unsigned int i = 0; i < length; i++)
+            if ((this->strings[i] != subString.strings[i]) || (this->bInSafemode[i] != subString.bInSafemode[i]))
+                return false;
+        return true;
+    }
+    /**
+     * @brief append operator
+     * @param subString the String to append.
+     * @returns a SubString where this and subString are appended.
+     */
+    SubString SubString::operator+(const SubString& subString) const
+    {
+        return SubString(*this) += subString;
+    }
+    /**
+     * @brief append operator.
+     * @param subString append subString to this SubString.
+     * @returns this substring appended with subString
+     */
+    SubString& SubString::operator+=(const SubString& subString)
+    {
+        for (unsigned int i = 0; i < subString.size(); i++)
+        {
+            this->strings.push_back(subString[i]);
+            this->bInSafemode.push_back(subString.isInSafemode(i));
+        }
+        return *this;
+    }
+    /**
+     * @brief Split the String at
+     * @param string where to split
+     * @param splitter delimiter.
+     */
+    unsigned int SubString::split(const std::string& string, char splitter)
+    {
+        this->strings.clear();
+        this->bInSafemode.clear();
+        char split[2];
+        split[0] = splitter;
+        split[1] = '\0';
+        SubString::splitLine(this->strings, this->bInSafemode, string, split);
+        return strings.size();
+    }
+    /**
+     * @brief Splits a String into multiple splitters.
+     * @param string the String to split
+     * @param delimiters multiple set of characters at what to split. (delimiters)
+     * @param delimiterNeighbours: Neighbours to the Delimiters that will be erased too.
+     * @param emptyEntries: If empty entries are added to the List of SubStrings
+     * @param escapeChar The Escape Character that overrides splitters commends and so on...
+     * @param safemode_char within these characters splitting won't happen
+     * @param comment_char the Comment character.
+     */
+    unsigned int SubString::split(const std::string& string,
+                                  const std::string& delimiters, const std::string& delimiterNeighbours, bool emptyEntries,
+                                  char escapeChar, bool removeExcapeChar, char safemode_char, bool removeSafemodeChar,
+                                  char openparenthesis_char, char closeparenthesis_char, bool removeParenthesisChars, char comment_char)
+    {
+        this->strings.clear();
+        this->bInSafemode.clear();
+        SubString::splitLine(this->strings, this->bInSafemode, string, delimiters, delimiterNeighbours, emptyEntries, escapeChar, removeExcapeChar, safemode_char, removeSafemodeChar, openparenthesis_char, closeparenthesis_char, removeParenthesisChars, comment_char);
+        return this->strings.size();
+    }
+    /**
+     * @brief joins together all Strings of this Substring.
+     * @param delimiter the String between the subStrings.
+     * @returns the joined String.
+     */
+    std::string SubString::join(const std::string& delimiter) const
+    {
+        if (!this->strings.empty())
+        {
+            std::string retVal = this->strings[0];
+            for (unsigned int i = 1; i < this->strings.size(); i++)
+                retVal += delimiter + this->strings[i];
+            return retVal;
+        }
+        else
+        {
+            static std::string empty;
+            return empty;
+        }
+    }
+    /**
+     * @brief creates a SubSet of a SubString.
+     * @param subSetBegin the beginning to the end
+     * @returns the SubSet
+     *
+     * This function is added for your convenience, and does the same as
+     * SubString::SubString(const SubString& subString, unsigned int subSetBegin)
+     */
+    SubString SubString::subSet(unsigned int subSetBegin) const
+    {
+        return SubString(*this, subSetBegin);
+    }
+    /**
+     * @brief creates a SubSet of a SubString.
+     * @param subSetBegin the beginning to
+     * @param subSetEnd the end of the SubSet to select (if bigger than subString.size() it will be downset.)
+     * @returns the SubSet
+     *
+     * This function is added for your convenience, and does the same as
+     * SubString::SubString(const SubString& subString, unsigned int subSetBegin)
+     */
+    SubString SubString::subSet(unsigned int subSetBegin, unsigned int subSetEnd) const
+    {
+        return SubString(*this, subSetBegin, subSetEnd);
+    }
+    /**
+     * @brief splits line into tokens and stores them in ret.
+     * @param ret the Array, where the Splitted strings will be stored in
+     * to the beginning of the current token is stored
+     * @param line the inputLine to split
+     * @param delimiters a String of Delimiters (here the input will be splitted)
+     * @param delimiterNeighbours Naighbours to the Delimitter, that will be removed if they are to the left or the right of a Delimiter.
+     * @param emptyEntries: if empty Strings are added to the List of Strings.
+     * @param escape_char: Escape carater (escapes splitters)
+     * @param safemode_char: the beginning of the safemode is marked with this
+     * @param removeSafemodeChar removes the safemode_char from the beginning and the ending of a token
+     * @param openparenthesis_char the beginning of a safemode is marked with this
+     * @param closeparenthesis_char the ending of a safemode is marked with this
+     * @param removeParenthesisChars removes the parenthesis from the beginning and the ending of a token
+     * @param comment_char: the beginning of a comment is marked with this: (until the end of a Line)
+     * @param start_state: the Initial state on how to parse the String.
+     * @return SPLIT_LINE_STATE the parser was in when returning
+     *
+     * This is the Actual Splitting Algorithm from Clemens Wacha
+     * Supports delimiters, escape characters,
+     * ignores special  characters between safemode_char and between comment_char and linend '\n'.
+     */
+    SubString::SPLIT_LINE_STATE
+    SubString::splitLine(std::vector<std::string>& ret,
+                         std::vector<bool>& bInSafemode,
+                         const std::string& line,
+                         const std::string& delimiters,
+                         const std::string& delimiterNeighbours,
+                         bool emptyEntries,
+                         char escape_char,
+                         bool removeExcapeChar,
+                         char safemode_char,
+                         bool removeSafemodeChar,
+                         char openparenthesis_char,
+                         char closeparenthesis_char,
+                         bool removeParenthesisChars,
+                         char comment_char,
+                         SPLIT_LINE_STATE start_state)
+    {
+        SPLIT_LINE_STATE state = start_state;
+        unsigned int i = 0;
+        unsigned int fallBackNeighbours = 0;
+        std::string token;
+        bool inSafemode = false;
+        if(start_state != SL_NORMAL && ret.size() > 0)
+        {
+            token = ret[ret.size()-1];
+            ret.pop_back();
+        }
+        if(start_state != SL_NORMAL && bInSafemode.size() > 0)
+        {
+            inSafemode = bInSafemode[bInSafemode.size()-1];
+            bInSafemode.pop_back();
+        }
+        while(i < line.size())
+        {
+            switch(state)
+            {
+            case SL_NORMAL:
+                if(line[i] == escape_char)
+                {
+                    state = SL_ESCAPE;
+                    if (!removeExcapeChar)
+                        token += line[i];
+                }
+                else if(line[i] == safemode_char)
+                {
+                    state = SL_SAFEMODE;
+                    inSafemode = true;
+                    if (!removeSafemodeChar)
+                        token += line[i];
+                }
+                else if(line[i] == openparenthesis_char)
+                {
+                    state = SL_PARENTHESES;
+                    inSafemode = true;
+                    if (!removeParenthesisChars)
+                        token += line[i];
+                }
+                else if(line[i] == comment_char)
+                {
+                    if (fallBackNeighbours > 0)
+                        token = token.substr(0, token.size() - fallBackNeighbours);
+                    /// FINISH
+                    if(emptyEntries || token.size() > 0)
+                    {
+                        ret.push_back(token);
+                        token.clear();
+                        bInSafemode.push_back(inSafemode);
+                        inSafemode = false;
+                    }
+                    token += line[i];       // EAT
+                    state = SL_COMMENT;
+                }
+                else if(delimiters.find(line[i]) != std::string::npos)
+                {
+                    // line[i] is a delimiter
+                    if (fallBackNeighbours > 0)
+                        token = token.substr(0, token.size() - fallBackNeighbours);
+                    /// FINISH
+                    if(emptyEntries || token.size() > 0)
+                    {
+                        ret.push_back(token);
+                        token.clear();
+                        bInSafemode.push_back(inSafemode);
+                        inSafemode = false;
+                    }
+                    state = SL_NORMAL;
+                }
+                else
+                {
+                    if (delimiterNeighbours.find(line[i]) != std::string::npos)
+                    {
+                        if (token.size() > 0)
+                            ++fallBackNeighbours;
+                        else
+                        {
+                            i++;
+                            continue;
+                        }
+                    }
+                    else
+                        fallBackNeighbours = 0;
+                    token += line[i];       // EAT
+                }
+                break;
+            case SL_ESCAPE:
+                if (!removeSafemodeChar)
+                    token += line[i];
+                else
+                {
+                    if(line[i] == 'n') token += '\n';
+                    else if(line[i] == 't') token += '\t';
+                    else if(line[i] == 'v') token += '\v';
+                    else if(line[i] == 'b') token += '\b';
+                    else if(line[i] == 'r') token += '\r';
+                    else if(line[i] == 'f') token += '\f';
+                    else if(line[i] == 'a') token += '\a';
+                    else if(line[i] == '?') token += '\?';
+                    else token += line[i];  // EAT
+                }
+                state = SL_NORMAL;
+                break;
+            case SL_SAFEMODE:
+                if(line[i] == safemode_char)
+                {
+                    state = SL_NORMAL;
+                    if (!removeSafemodeChar)
+                        token += line[i];
+                }
+                else if(line[i] == escape_char)
+                {
+                    state = SL_SAFEESCAPE;
+                }
+                else
+                {
+                    token += line[i];       // EAT
+                }
+                break;
+            case SL_SAFEESCAPE:
+                if(line[i] == 'n') token += '\n';
+                else if(line[i] == 't') token += '\t';
+                else if(line[i] == 'v') token += '\v';
+                else if(line[i] == 'b') token += '\b';
+                else if(line[i] == 'r') token += '\r';
+                else if(line[i] == 'f') token += '\f';
+                else if(line[i] == 'a') token += '\a';
+                else if(line[i] == '?') token += '\?';
+                else token += line[i];  // EAT
+                state = SL_SAFEMODE;
+                break;
+            case SL_PARENTHESES:
+                if(line[i] == closeparenthesis_char)
+                {
+                    state = SL_NORMAL;
+                    if (!removeParenthesisChars)
+                        token += line[i];
+                }
+                else if(line[i] == escape_char)
+                {
+                    state = SL_PARENTHESESESCAPE;
+                }
+                else
+                {
+                    token += line[i];       // EAT
+                }
+                break;
+            case SL_PARENTHESESESCAPE:
+                if(line[i] == 'n') token += '\n';
+                else if(line[i] == 't') token += '\t';
+                else if(line[i] == 'v') token += '\v';
+                else if(line[i] == 'b') token += '\b';
+                else if(line[i] == 'r') token += '\r';
+                else if(line[i] == 'f') token += '\f';
+                else if(line[i] == 'a') token += '\a';
+                else if(line[i] == '?') token += '\?';
+                else token += line[i];  // EAT
+                state = SL_PARENTHESES;
+                break;
+            case SL_COMMENT:
+                if(line[i] == '\n')
+                {
+                    /// FINISH
+                    if(token.size() > 0)
+                    {
+                        ret.push_back(token);
+                        token.clear();
+                        bInSafemode.push_back(inSafemode);
+                        inSafemode = false;
+                    }
+                    state = SL_NORMAL;
+                }
+                else
+                {
+                    token += line[i];       // EAT
+                }
+                break;
+            default:
+                // nothing
+                break;
+            }
+            i++;
+        }
+        /// FINISH
+        if (fallBackNeighbours > 0)
             token = token.substr(0, token.size() - fallBackNeighbours);
+          /// FINISH
+          if(emptyEntries || token.size() > 0)
+          {
+        if(emptyEntries || token.size() > 0)
+        {
             ret.push_back(token);
             token.clear();
             bInSafemode.push_back(inSafemode);
             inSafemode = false;
+          }
+          token += line[i];       // EAT
+          state = SL_COMMENT;
+        }
+        else if(delimiters.find(line[i]) != std::string::npos)
+        {
+          // line[i] is a delimiter
+          if (fallBackNeighbours > 0)
+            token = token.substr(0, token.size() - fallBackNeighbours);
+          /// FINISH
+          if(emptyEntries || token.size() > 0)
+          {
+            ret.push_back(token);
+            token.clear();
+            bInSafemode.push_back(inSafemode);
+            inSafemode = false;
+          }
+          state = SL_NORMAL;
+        }
+        else
+        {
+          if (delimiterNeighbours.find(line[i]) != std::string::npos)
+          {
+            if (token.size() > 0)
+              ++fallBackNeighbours;
+            else
+            {
+              i++;
+              continue;
+            }
+          }
+          else
+            fallBackNeighbours = 0;
+          token += line[i];       // EAT
+        }
+        break;
+      case SL_ESCAPE:
+        if (!removeSafemodeChar)
+          token += line[i];
+        else
+        {
+          if(line[i] == 'n') token += '\n';
+          else if(line[i] == 't') token += '\t';
+          else if(line[i] == 'v') token += '\v';
+          else if(line[i] == 'b') token += '\b';
+          else if(line[i] == 'r') token += '\r';
+          else if(line[i] == 'f') token += '\f';
+          else if(line[i] == 'a') token += '\a';
+          else if(line[i] == '?') token += '\?';
+          else token += line[i];  // EAT
+        }
+        state = SL_NORMAL;
+        break;
+      case SL_SAFEMODE:
+        if(line[i] == safemode_char)
+        {
+          state = SL_NORMAL;
+          if (!removeSafemodeChar)
+            token += line[i];
+        }
+        else if(line[i] == escape_char)
+        {
+          state = SL_SAFEESCAPE;
+        }
+        else
+        {
+          token += line[i];       // EAT
+        }
+        break;
+      case SL_SAFEESCAPE:
+        if(line[i] == 'n') token += '\n';
+        else if(line[i] == 't') token += '\t';
+        else if(line[i] == 'v') token += '\v';
+        else if(line[i] == 'b') token += '\b';
+        else if(line[i] == 'r') token += '\r';
+        else if(line[i] == 'f') token += '\f';
+        else if(line[i] == 'a') token += '\a';
+        else if(line[i] == '?') token += '\?';
+        else token += line[i];  // EAT
+        state = SL_SAFEMODE;
+        break;
+      case SL_PARENTHESES:
+        if(line[i] == closeparenthesis_char)
+        {
+          state = SL_NORMAL;
+          if (!removeParenthesisChars)
+            token += line[i];
+        }
+        else if(line[i] == escape_char)
+        {
+          state = SL_PARENTHESESESCAPE;
+        }
+        else
+        {
+          token += line[i];       // EAT
+        }
+        break;
+      case SL_PARENTHESESESCAPE:
+        if(line[i] == 'n') token += '\n';
+        else if(line[i] == 't') token += '\t';
+        else if(line[i] == 'v') token += '\v';
+        else if(line[i] == 'b') token += '\b';
+        else if(line[i] == 'r') token += '\r';
+        else if(line[i] == 'f') token += '\f';
+        else if(line[i] == 'a') token += '\a';
+        else if(line[i] == '?') token += '\?';
+        else token += line[i];  // EAT
+        state = SL_PARENTHESES;
+        break;
+      case SL_COMMENT:
+        if(line[i] == '\n')
+        {
+          /// FINISH
+          if(token.size() > 0)
+          {
+            ret.push_back(token);
+            token.clear();
+            bInSafemode.push_back(inSafemode);
+            inSafemode = false;
+          }
+          state = SL_NORMAL;
+        }
+        else
+        {
+          token += line[i];       // EAT
+        }
+        break;
+      default:
+        // nothing
+        break;
+    }
+    i++;
+  }
+  /// FINISH
+  if (fallBackNeighbours > 0)
+    token = token.substr(0, token.size() - fallBackNeighbours);
+  if(emptyEntries || token.size() > 0)
+  {
+    ret.push_back(token);
+    token.clear();
+    bInSafemode.push_back(inSafemode);
+    inSafemode = false;
+  }
+  return(state);
+        }
+        return(state);
+    }
+    /**
+     * @brief Some nice debug information about this SubString
+     */
+    void SubString::debug() const
+    {
+        printf("Substring-information::count=%d ::", this->strings.size());
+        for (unsigned int i = 0; i < this->strings.size(); i++)
+            printf("s%d='%s'::", i, this->strings[i].c_str());
+        printf("\n");
+    }
+}
-/**
- * @brief Some nice debug information about this SubString
- */
-void SubString::debug() const
+{
-  printf("Substring-information::count=%d ::", this->strings.size());
-  for (unsigned int i = 0; i < this->strings.size(); i++)
-    printf("s%d='%s'::", i, this->strings[i].c_str());
-  printf("\n");
+}

code/trunk/src/util/SubString.h

-                      r1791
+                      r2171
  /*!
  * @file substring.h
+ * @file
  * @brief a small class to get the parts of a string separated by commas
+ *
 …
 #include <string>
+//! A class that can load one string and split it in multipe ones
+/**
+ * SubString is a very Powerfull way to create a SubSet from a String
+ * It can be used, to Split strings append them and join them again.
+ */
+class _UtilExport SubString
+namespace orxonox
+{
+public:
+  //! An enumerator for the State the Parser is in
+  typedef enum {
+    SL_NORMAL,            //!< Normal state
+    SL_ESCAPE,            //!< After an escape character
+    SL_SAFEMODE,          //!< In safe mode (between "" mostly).
+    SL_SAFEESCAPE,        //!< In safe mode with the internal escape character, that escapes even the savemode character.
+    SL_COMMENT,           //!< In Comment mode.
+    SL_PARENTHESES,       //!< Between parentheses (usually '(' and ')')
+    SL_PARENTHESESESCAPE, //!< Between parentheses with the internal escape character, that escapes even the closing paranthesis character.
+  } SPLIT_LINE_STATE;
+    //! A class that can load one string and split it in multipe ones
+    /**
+     * SubString is a very Powerfull way to create a SubSet from a String
+     * It can be used, to Split strings append them and join them again.
+     */
+    class _UtilExport SubString
+    {
+    public:
+        //! An enumerator for the State the Parser is in
+        typedef enum {
+            SL_NORMAL,            //!< Normal state
+            SL_ESCAPE,            //!< After an escape character
+            SL_SAFEMODE,          //!< In safe mode (between "" mostly).
+            SL_SAFEESCAPE,        //!< In safe mode with the internal escape character, that escapes even the savemode character.
+            SL_COMMENT,           //!< In Comment mode.
+            SL_PARENTHESES,       //!< Between parentheses (usually '(' and ')')
+            SL_PARENTHESESESCAPE, //!< Between parentheses with the internal escape character, that escapes even the closing paranthesis character.
+        } SPLIT_LINE_STATE;
 public:
   SubString();
   SubString(const std::string& string, char delimiter = ',');
   SubString(const std::string& string,
             const std::string& delimiters, const std::string& delimiterNeighbours = "", bool emptyEntries=false,
             char escapeChar ='\\', bool removeEscapeChar = true, char safemode_char = '"', bool removeSafemodeChar = true,
             char openparenthesis_char = '(', char closeparenthesis_char = ')',  bool removeParenthesisChars = true, char comment_char = '\0');
   SubString(unsigned int argc, const char** argv);
   /** @brief create a Substring as a copy of another one. @param subString the SubString to copy. */
   SubString(const SubString& subString) { *this = subString; };
   SubString(const SubString& subString, unsigned int subSetBegin);
   SubString(const SubString& subString, unsigned int subSetBegin, unsigned int subSetEnd);
   ~SubString();
+    public:
+        SubString();
+        SubString(const std::string& string, char delimiter = ',');
+        SubString(const std::string& string,
+                  const std::string& delimiters, const std::string& delimiterNeighbours = "", bool emptyEntries=false,
+                  char escapeChar ='\\', bool removeEscapeChar = true, char safemode_char = '"', bool removeSafemodeChar = true,
+                  char openparenthesis_char = '(', char closeparenthesis_char = ')',  bool removeParenthesisChars = true, char comment_char = '\0');
+        SubString(unsigned int argc, const char** argv);
+        /** @brief create a Substring as a copy of another one. @param subString the SubString to copy. */
+        SubString(const SubString& subString) { *this = subString; };
+        SubString(const SubString& subString, unsigned int subSetBegin);
+        SubString(const SubString& subString, unsigned int subSetBegin, unsigned int subSetEnd);
+        ~SubString();
   // operate on the SubString
   SubString& operator=(const SubString& subString);
   bool operator==(const SubString& subString) const;
   bool compare(const SubString& subString) const;
   bool compare(const SubString& subString, unsigned int length) const;
   SubString operator+(const SubString& subString) const;
   SubString& operator+=(const SubString& subString);
   /** @param subString the String to append @returns appended String. @brief added for convenience */
   SubString& append(const SubString subString) { return (*this += subString); };
+        // operate on the SubString
+        SubString& operator=(const SubString& subString);
+        bool operator==(const SubString& subString) const;
+        bool compare(const SubString& subString) const;
+        bool compare(const SubString& subString, unsigned int length) const;
+        SubString operator+(const SubString& subString) const;
+        SubString& operator+=(const SubString& subString);
+        /** @param subString the String to append @returns appended String. @brief added for convenience */
+        SubString& append(const SubString subString) { return (*this += subString); };
   /////////////////////////////////////////
   // Split and Join the any String. ///////
   unsigned int split(const std::string& string = "", char delimiter = ',');
   unsigned int split(const std::string& string,
                      const std::string& delimiters, const std::string& delimiterNeighbours = "", bool emptyEntries = false,
                      char escapeChar ='\\', bool removeExcapeChar = true, char safemode_char = '"', bool removeSafemodeChar = true,
                      char openparenthesis_char = '(', char closeparenthesis_char = ')',  bool removeParenthesisChars = true, char comment_char = '\0');
   std::string join(const std::string& delimiter = " ") const;
   ////////////////////////////////////////
+        /////////////////////////////////////////
+        // Split and Join the any String. ///////
+        unsigned int split(const std::string& string = "", char delimiter = ',');
+        unsigned int split(const std::string& string,
+                           const std::string& delimiters, const std::string& delimiterNeighbours = "", bool emptyEntries = false,
+                           char escapeChar ='\\', bool removeExcapeChar = true, char safemode_char = '"', bool removeSafemodeChar = true,
+                           char openparenthesis_char = '(', char closeparenthesis_char = ')',  bool removeParenthesisChars = true, char comment_char = '\0');
+        std::string join(const std::string& delimiter = " ") const;
+        ////////////////////////////////////////
   // retrieve a SubSet from the String
   SubString subSet(unsigned int subSetBegin) const;
   SubString subSet(unsigned int subSetBegin, unsigned int subSetEnd) const;
+        // retrieve a SubSet from the String
+        SubString subSet(unsigned int subSetBegin) const;
+        SubString subSet(unsigned int subSetBegin, unsigned int subSetEnd) const;
   // retrieve Information from within
   /** @brief Returns true if the SubString is empty */
   inline bool empty() const { return this->strings.empty(); };
   /** @brief Returns the count of Strings stored in this substring */
   inline unsigned int size() const { return this->strings.size(); };
   /** @brief Returns the i'th string from the subset of Strings @param i the i'th String */
   inline const std::string& operator[](unsigned int i) const { return this->strings[i]; };
   /** @brief Returns the i'th string from the subset of Strings @param i the i'th String */
   inline const std::string& getString(unsigned int i) const { return (*this)[i]; };
   /** @brief Returns all Strings as std::vector */
   inline const std::vector<std::string>& getAllStrings() const { return this->strings; }
   /** @brief Returns true if the token is in safemode. @param i the i'th token */
   inline bool isInSafemode(unsigned int i) const { return this->bInSafemode[i]; }
   /** @brief Returns the front of the StringList. */
   inline const std::string& front() const { return this->strings.front(); };
   /** @brief Returns the back of the StringList. */
   inline const std::string& back() const { return this->strings.back(); };
   /** @brief removes the back of the strings list. */
   inline void pop_back() { this->strings.pop_back(); this->bInSafemode.pop_back(); };
+        // retrieve Information from within
+        /** @brief Returns true if the SubString is empty */
+        inline bool empty() const { return this->strings.empty(); };
+        /** @brief Returns the count of Strings stored in this substring */
+        inline unsigned int size() const { return this->strings.size(); };
+        /** @brief Returns the i'th string from the subset of Strings @param i the i'th String */
+        inline const std::string& operator[](unsigned int i) const { return this->strings[i]; };
+        /** @brief Returns the i'th string from the subset of Strings @param i the i'th String */
+        inline const std::string& getString(unsigned int i) const { return (*this)[i]; };
+        /** @brief Returns all Strings as std::vector */
+        inline const std::vector<std::string>& getAllStrings() const { return this->strings; }
+        /** @brief Returns true if the token is in safemode. @param i the i'th token */
+        inline bool isInSafemode(unsigned int i) const { return this->bInSafemode[i]; }
+        /** @brief Returns the front of the StringList. */
+        inline const std::string& front() const { return this->strings.front(); };
+        /** @brief Returns the back of the StringList. */
+        inline const std::string& back() const { return this->strings.back(); };
+        /** @brief removes the back of the strings list. */
+        inline void pop_back() { this->strings.pop_back(); this->bInSafemode.pop_back(); };
   // the almighty algorithm.
   static SPLIT_LINE_STATE splitLine(std::vector<std::string>& ret,
                                     std::vector<bool>& bInSafemode,
                                     const std::string& line,
                                     const std::string& delimiters = SubString::WhiteSpaces,
                                     const std::string& delimiterNeighbours = "",
                                     bool emptyEntries = false,
                                     char escape_char = '\\',
                                     bool removeExcapeChar = true,
                                     char safemode_char = '"',
                                     bool removeSafemodeChar = true,
                                     char openparenthesis_char = '(',
                                     char closeparenthesis_char = ')',
                                     bool removeParenthesisChars = true,
                                     char comment_char = '\0',
                                     SPLIT_LINE_STATE start_state = SL_NORMAL);
   // debugging.
   void debug() const;
+        // the almighty algorithm.
+        static SPLIT_LINE_STATE splitLine(std::vector<std::string>& ret,
+                                          std::vector<bool>& bInSafemode,
+                                          const std::string& line,
+                                          const std::string& delimiters = SubString::WhiteSpaces,
+                                          const std::string& delimiterNeighbours = "",
+                                          bool emptyEntries = false,
+                                          char escape_char = '\\',
+                                          bool removeExcapeChar = true,
+                                          char safemode_char = '"',
+                                          bool removeSafemodeChar = true,
+                                          char openparenthesis_char = '(',
+                                          char closeparenthesis_char = ')',
+                                          bool removeParenthesisChars = true,
+                                          char comment_char = '\0',
+                                          SPLIT_LINE_STATE start_state = SL_NORMAL);
+        // debugging.
+        void debug() const;
 public:
   static const std::string WhiteSpaces;
   static const std::string WhiteSpacesWithComma;
   static const SubString   NullSubString;
+    public:
+        static const std::string WhiteSpaces;
+        static const std::string WhiteSpacesWithComma;
+        static const SubString   NullSubString;
+private:
+  std::vector<std::string>  strings;                      //!< strings produced from a single string splitted in multiple strings
+  std::vector<bool>         bInSafemode;
+};
+    private:
+        std::vector<std::string>  strings;                      //!< strings produced from a single string splitted in multiple strings
+        std::vector<bool>         bInSafemode;
+    };
+}
 #endif /* __SubString_H__ */

code/trunk/src/util/UtilPrereqs.h

-                      r1747
+                      r2171
 // Forward declarations
 //-----------------------------------------------------------------------
-class ArgReader;
-class Convert;
-class ExprParser;
-class MultiType;
-class SubString;
 namespace orxonox
+{
+    class Exception;
+    class ExprParser;
+    class IntVector2;
+    class IntVector3;
+    class MultiType;
     class OutputBuffer;
     class OutputBufferListener;
-    class Error;
     class OutputHandler;
+    class SignalHandler;
+    class SubString;
+}

code/trunk/visual_studio/vc8/audio.vsprops

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/visual_studio/vc8/base.vsprops

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/visual_studio/vc8/ceguilua.vsprops

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/visual_studio/vc8/core.vsprops

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/visual_studio/vc8/cpptcl.vsprops

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/visual_studio/vc8/debug.vsprops

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/visual_studio/vc8/directories.vsprops

Property svn:mergeinfo changed
/code/branches/objecthierarchy/visual_studio/vc8/directories.vsprops merged: 2114-2115

code/trunk/visual_studio/vc8/lua.vsprops

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/visual_studio/vc8/network.vsprops

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/visual_studio/vc8/orxonox.vcproj

-                      r2107
+                      r2171
                         </File>
                         <File
+                                RelativePath="..\..\src\orxonox\PlayerManager.cc"
+                                >
+                        </File>
+                        <File
                                 RelativePath="..\..\src\orxonox\PrecompiledHeaderFiles.cc"
+                                >
 …
                                 </File>
                                 <File
+                                        RelativePath="..\..\src\orxonox\objects\Level.cc"
+                                        >
+                                </File>
+                                <File
                                         RelativePath="..\..\src\orxonox\objects\Radar.cc"
+                                        >
 …
                                         <File
                                                 RelativePath="..\..\src\orxonox\objects\infos\Info.cc"
+                                                >
-                                        </File>
-                                        <File
-                                                RelativePath="..\..\src\orxonox\objects\infos\Level.cc"
+                                                >
                                         </File>
 …
                         </File>
                         <File
+                                RelativePath="..\..\src\orxonox\PlayerManager.h"
+                                >
+                        </File>
+                        <File
                                 RelativePath="..\..\src\orxonox\Settings.h"
+                                >
 …
                                 </File>
                                 <File
+                                        RelativePath="..\..\src\orxonox\objects\Level.h"
+                                        >
+                                </File>
+                                <File
                                         RelativePath="..\..\src\orxonox\objects\Radar.h"
+                                        >
 …
                                         <File
                                                 RelativePath="..\..\src\orxonox\objects\infos\Info.h"
+                                                >
-                                        </File>
-                                        <File
-                                                RelativePath="..\..\src\orxonox\objects\infos\Level.h"
+                                                >
                                         </File>

code/trunk/visual_studio/vc8/orxonox.vsprops

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/visual_studio/vc8/orxonox_vc8.sln

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/visual_studio/vc8/release.vsprops

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/visual_studio/vc8/tinyxml.vcproj

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/visual_studio/vc8/tinyxml.vsprops

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/visual_studio/vc8/tolua.vsprops

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/visual_studio/vc8/toluagen.vcproj

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/visual_studio/vc8/toluagen.vsprops

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/visual_studio/vc8/toluagen_orxonox.vcproj

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/visual_studio/vc8/toluagen_orxonox.vsprops

Property svn:mergeinfo changed (with no actual effect on merging)

code/trunk/visual_studio/vc8/util.vcproj

-                      r2087
+                      r2171
                         </File>
                         <File
+                                RelativePath="..\..\src\util\mbool.h"
+                                >
+                        </File>
+                        <File
                                 RelativePath="..\..\src\util\MultiType.h"
+                                >

code/trunk/visual_studio/vc8/util.vsprops

Property svn:mergeinfo changed (with no actual effect on merging)

Context Navigation

Legend: