Index: src/client/c/hu/varadiistvan/xplra/MultiBuffer.cc
===================================================================
--- src/client/c/hu/varadiistvan/xplra/MultiBuffer.cc	(revision 66)
+++ src/client/c/hu/varadiistvan/xplra/MultiBuffer.cc	(revision 107)
@@ -54,5 +54,5 @@
 inline MultiBuffer::DataRef::DataRef(const string& name, uint8_t type,
                                      const DataRef* previous,
-                                     size_t length, size_t offset) throw() :
+                                     size_t length, size_t offset) noexcept :
     name(name),
     type(type),
@@ -71,5 +71,5 @@
 //------------------------------------------------------------------------------
 
-inline size_t MultiBuffer::DataRef::getSize() const throw()
+inline size_t MultiBuffer::DataRef::getSize() const noexcept
 {
     switch (type) {
@@ -93,5 +93,5 @@
 //------------------------------------------------------------------------------
 
-inline size_t MultiBuffer::DataRef::getAlignment() const throw()
+inline size_t MultiBuffer::DataRef::getAlignment() const noexcept
 {
     switch (type) {
@@ -112,5 +112,5 @@
 //------------------------------------------------------------------------------
 
-bool MultiBuffer::DataRef::isArray() const throw()
+bool MultiBuffer::DataRef::isArray() const noexcept
 {
     return
@@ -124,5 +124,5 @@
 inline size_t
 MultiBuffer::DataRef::getCopyLength(size_t userLength, size_t userOffset)
-    const throw()
+    const noexcept
 {
     size_t maxLength =
@@ -134,5 +134,5 @@
 //------------------------------------------------------------------------------
 
-inline void MultiBuffer::unfinalize() throw()
+inline void MultiBuffer::unfinalize() noexcept
 {
     delete data; data = 0;
@@ -141,5 +141,5 @@
 //------------------------------------------------------------------------------
 
-void MultiBuffer::forgetRegistration() throw()
+void MultiBuffer::forgetRegistration() noexcept
 {
     registeredID = -1;
@@ -148,5 +148,5 @@
 //------------------------------------------------------------------------------
 
-inline const MultiBuffer::DataRef* MultiBuffer::getLastDataRef() const throw()
+inline const MultiBuffer::DataRef* MultiBuffer::getLastDataRef() const noexcept
 {
     return dataRefs.empty() ? 0 : &(dataRefs.back());
@@ -156,5 +156,4 @@
 
 inline const MultiBuffer::DataRef& MultiBuffer::getDataRef(size_t id, uint8_t type) const
-    throw(InvalidIDException, TypeMismatchException)
 {
     if (id>=dataRefs.size()) throw InvalidIDException();
@@ -167,5 +166,4 @@
 
 inline void* MultiBuffer::getData(size_t id, uint8_t type)
-    throw(InvalidIDException, TypeMismatchException)
 {
     const DataRef& dataRef = getDataRef(id, type);
@@ -177,5 +175,4 @@
 
 inline const void* MultiBuffer::getData(size_t id, uint8_t type) const
-    throw(InvalidIDException, TypeMismatchException)
 {
     const DataRef& dataRef = getDataRef(id, type);
@@ -189,5 +186,4 @@
 inline MultiBuffer::setArray(size_t id, const T* value,
                              size_t length, size_t offset)
-    throw(InvalidIDException, TypeMismatchException)
 {
     const DataRef& dataRef = getDataRef(id, type);
@@ -209,5 +205,4 @@
 inline size_t MultiBuffer::getArray(size_t id, T* value,
                                     size_t length, size_t offset) const
-    throw(InvalidIDException, TypeMismatchException)
 {
     const DataRef& dataRef = getDataRef(id, type);
@@ -228,5 +223,4 @@
 template <typename T, uint8_t type>
 inline const T* MultiBuffer::getArray(size_t id, size_t offset) const
-    throw(InvalidIDException, TypeMismatchException)
 {
     const DataRef& dataRef = getDataRef(id, type);
@@ -240,5 +234,5 @@
 
 MultiBuffer::MultiBuffer(XPlane& xplane, uint8_t registerCommand,
-                         uint8_t unregisterCommand) throw() :
+                         uint8_t unregisterCommand) noexcept :
     data(0),
     xplane(xplane),
@@ -251,5 +245,5 @@
 //------------------------------------------------------------------------------
 
-MultiBuffer::~MultiBuffer() throw()
+MultiBuffer::~MultiBuffer() noexcept
 {
     unregisterSafelyFromXPlane();
@@ -259,5 +253,5 @@
 //------------------------------------------------------------------------------
 
-size_t MultiBuffer::addInt(const std::string& name) throw()
+size_t MultiBuffer::addInt(const std::string& name) noexcept
 {
     unfinalize();
@@ -268,5 +262,5 @@
 //------------------------------------------------------------------------------
 
-size_t MultiBuffer::addFloat(const std::string& name) throw()
+size_t MultiBuffer::addFloat(const std::string& name) noexcept
 {
     unfinalize();
@@ -277,5 +271,5 @@
 //------------------------------------------------------------------------------
 
-size_t MultiBuffer::addDouble(const std::string& name) throw()
+size_t MultiBuffer::addDouble(const std::string& name) noexcept
 {
     unfinalize();
@@ -287,5 +281,5 @@
 
 size_t MultiBuffer::addFloatArray(const std::string& name, size_t length,
-                                  size_t offset) throw()
+                                  size_t offset) noexcept
 {
     unfinalize();
@@ -298,5 +292,5 @@
 
 size_t MultiBuffer::addIntArray(const std::string& name, size_t length,
-                                size_t offset) throw()
+                                size_t offset) noexcept
 {
     unfinalize();
@@ -309,5 +303,5 @@
 
 size_t MultiBuffer::addByteArray(const std::string& name, size_t length,
-                                 size_t offset) throw()
+                                 size_t offset) noexcept
 {
     unfinalize();
@@ -334,5 +328,5 @@
 //------------------------------------------------------------------------------
 
-void MultiBuffer::registerInXPlane() throw(Exception)
+void MultiBuffer::registerInXPlane()
 {
     if (finalize() && registeredID<0) {
@@ -350,5 +344,5 @@
 //------------------------------------------------------------------------------
 
-void MultiBuffer::unregisterFromXPlane() throw(Exception)
+void MultiBuffer::unregisterFromXPlane()
 {
     if (registeredID>=0) {
@@ -363,5 +357,5 @@
 //------------------------------------------------------------------------------
 
-bool MultiBuffer::unregisterSafelyFromXPlane() throw()
+bool MultiBuffer::unregisterSafelyFromXPlane() noexcept
 {
     try {
@@ -376,5 +370,5 @@
 //------------------------------------------------------------------------------
 
-void MultiBuffer::execute() throw(Exception)
+void MultiBuffer::execute()
 {
     if (data==0 && registeredID>=0) {
@@ -395,5 +389,4 @@
 
 void MultiBuffer::setInt(size_t id, int value)
-    throw(InvalidIDException, TypeMismatchException)
 {
     *reinterpret_cast<int32_t*>(getData(id, Protocol::TYPE_INT)) = value;
@@ -403,5 +396,4 @@
 
 int MultiBuffer::getInt(size_t id) const
-    throw(InvalidIDException, TypeMismatchException)
 {
     return *reinterpret_cast<const int32_t*>(getData(id, Protocol::TYPE_INT));
@@ -411,5 +403,4 @@
 
 const int32_t& MultiBuffer::getIntRef(size_t id) const
-    throw(InvalidIDException, TypeMismatchException)
 {
     return *reinterpret_cast<const int32_t*>(getData(id, Protocol::TYPE_INT));
@@ -419,5 +410,4 @@
 
 int32_t& MultiBuffer::getIntRef(size_t id)
-    throw(InvalidIDException, TypeMismatchException)
 {
     return *reinterpret_cast<int32_t*>(getData(id, Protocol::TYPE_INT));
@@ -427,5 +417,4 @@
 
 void MultiBuffer::setFloat(size_t id, float value)
-    throw(InvalidIDException, TypeMismatchException)
 {
     *reinterpret_cast<float*>(getData(id, Protocol::TYPE_FLOAT)) = value;
@@ -435,5 +424,4 @@
 
 float MultiBuffer::getFloat(size_t id) const
-    throw(InvalidIDException, TypeMismatchException)
 {
     return *reinterpret_cast<const float*>(getData(id, Protocol::TYPE_FLOAT));
@@ -443,5 +431,4 @@
 
 const float& MultiBuffer::getFloatRef(size_t id) const
-    throw(InvalidIDException, TypeMismatchException)
 {
     return *reinterpret_cast<const float*>(getData(id, Protocol::TYPE_FLOAT));
@@ -451,5 +438,4 @@
 
 float& MultiBuffer::getFloatRef(size_t id)
-    throw(InvalidIDException, TypeMismatchException)
 {
     return *reinterpret_cast<float*>(getData(id, Protocol::TYPE_FLOAT));
@@ -459,5 +445,4 @@
 
 void MultiBuffer::setDouble(size_t id, double value)
-    throw(InvalidIDException, TypeMismatchException)
 {
     *reinterpret_cast<double*>(getData(id, Protocol::TYPE_DOUBLE)) = value;
@@ -467,5 +452,4 @@
 
 double MultiBuffer::getDouble(size_t id) const
-    throw(InvalidIDException, TypeMismatchException)
 {
     return *reinterpret_cast<const double*>(getData(id, Protocol::TYPE_DOUBLE));
@@ -475,5 +459,4 @@
 
 const double& MultiBuffer::getDoubleRef(size_t id) const
-    throw(InvalidIDException, TypeMismatchException)
 {
     return *reinterpret_cast<const double*>(getData(id, Protocol::TYPE_DOUBLE));
@@ -483,5 +466,4 @@
 
 double& MultiBuffer::getDoubleRef(size_t id)
-    throw(InvalidIDException, TypeMismatchException)
 {
     return *reinterpret_cast<double*>(getData(id, Protocol::TYPE_DOUBLE));
@@ -492,5 +474,4 @@
 size_t MultiBuffer::setFloatArray(size_t id, const float* value,
                                   size_t length, size_t offset)
-    throw(InvalidIDException, TypeMismatchException)
 {
     return setArray<float, Protocol::TYPE_FLOAT_ARRAY>(id, value, length, offset);
@@ -501,5 +482,4 @@
 size_t MultiBuffer::getFloatArray(size_t id, float* value,
                                   size_t length, size_t offset) const
-    throw(InvalidIDException, TypeMismatchException)
 {
     return getArray<float, Protocol::TYPE_FLOAT_ARRAY>(id, value, length, offset);
@@ -509,5 +489,4 @@
 
 const float* MultiBuffer::getFloatArray(size_t id, size_t offset) const
-    throw(InvalidIDException, TypeMismatchException)
 {
     return getArray<float, Protocol::TYPE_FLOAT_ARRAY>(id, offset);
@@ -518,5 +497,5 @@
 size_t MultiBuffer::setIntArray(size_t id, const int32_t* value,
                                 size_t length, size_t offset)
-    throw(InvalidIDException, TypeMismatchException)
+
 {
     return setArray<int32_t, Protocol::TYPE_INT_ARRAY>(id, value, length, offset);
@@ -527,5 +506,4 @@
 size_t MultiBuffer::getIntArray(size_t id, int32_t* value,
                                 size_t length, size_t offset) const
-    throw(InvalidIDException, TypeMismatchException)
 {
     return getArray<int32_t, Protocol::TYPE_INT_ARRAY>(id, value, length, offset);
@@ -535,5 +513,4 @@
 
 const int32_t* MultiBuffer::getIntArray(size_t id, size_t offset) const
-    throw(InvalidIDException, TypeMismatchException)
 {
     return getArray<int32_t, Protocol::TYPE_INT_ARRAY>(id, offset);
@@ -544,5 +521,4 @@
 size_t MultiBuffer::setByteArray(size_t id, const uint8_t* value,
                                 size_t length, size_t offset)
-    throw(InvalidIDException, TypeMismatchException)
 {
     return setArray<uint8_t, Protocol::TYPE_BYTE_ARRAY>(id, value, length, offset);
@@ -553,5 +529,4 @@
 size_t MultiBuffer::getByteArray(size_t id, uint8_t* value,
                                 size_t length, size_t offset) const
-    throw(InvalidIDException, TypeMismatchException)
 {
     return getArray<uint8_t, Protocol::TYPE_BYTE_ARRAY>(id, value, length, offset);
@@ -561,5 +536,4 @@
 
 const uint8_t* MultiBuffer::getByteArray(size_t id, size_t offset) const
-    throw(InvalidIDException, TypeMismatchException)
 {
     return getArray<uint8_t, Protocol::TYPE_BYTE_ARRAY>(id, offset);
@@ -570,5 +544,4 @@
 size_t MultiBuffer::setString(size_t id, const string& value,
                               size_t offset)
-    throw(InvalidIDException, TypeMismatchException)
 {
     return setByteArray(id, reinterpret_cast<const uint8_t*>(value.c_str()),
@@ -579,5 +552,4 @@
 
 string MultiBuffer::getString(size_t id, size_t offset) const
-    throw(InvalidIDException, TypeMismatchException)
 {
     const DataRef& dataRef = getDataRef(id, Protocol::TYPE_BYTE_ARRAY);
@@ -598,5 +570,4 @@
 
 const char* MultiBuffer::getStringPtr(size_t id, size_t offset) const
-        throw(InvalidIDException, TypeMismatchException)
 {
     return reinterpret_cast<const char*>(getByteArray(id, offset));
@@ -605,5 +576,5 @@
 //------------------------------------------------------------------------------
 
-void MultiBuffer::writeSpec(uint8_t command) const throw(Exception)
+void MultiBuffer::writeSpec(uint8_t command) const
 {
     xplane.stream->writeU8(command);
@@ -628,5 +599,5 @@
 //------------------------------------------------------------------------------
 
-void MultiBuffer::reregisterInXPlane() throw(Exception)
+void MultiBuffer::reregisterInXPlane()
 {
     if (registeredID>=0) {
Index: src/client/c/hu/varadiistvan/xplra/MultiBuffer.h
===================================================================
--- src/client/c/hu/varadiistvan/xplra/MultiBuffer.h	(revision 66)
+++ src/client/c/hu/varadiistvan/xplra/MultiBuffer.h	(revision 107)
@@ -92,10 +92,10 @@
         DataRef(const std::string& name, uint8_t type,
                 const DataRef* previous = 0,
-                size_t length = 0, size_t offset = 0) throw();
+                size_t length = 0, size_t offset = 0) noexcept;
 
         /**
          * Get the size of the data represented by this object.
          */
-        size_t getSize() const throw();
+        size_t getSize() const noexcept;
 
         /**
@@ -103,10 +103,10 @@
          * this dataref.
          */
-        size_t getAlignment() const throw();
+        size_t getAlignment() const noexcept;
 
         /**
          * Determine if the dataref is an array.
          */
-        bool isArray() const throw();
+        bool isArray() const noexcept;
 
         /**
@@ -114,5 +114,5 @@
          * user parameters.
          */
-        size_t getCopyLength(size_t userLength, size_t userOffset) const throw();
+        size_t getCopyLength(size_t userLength, size_t userOffset) const noexcept;
     };
 
@@ -153,5 +153,5 @@
      */
     MultiBuffer(XPlane& xplane, uint8_t registerCommand,
-                uint8_t unregisterCommand) throw();
+                uint8_t unregisterCommand) noexcept;
 
     /**
@@ -159,5 +159,5 @@
      * made to unregister it.
      */
-    virtual ~MultiBuffer() throw();
+    virtual ~MultiBuffer() noexcept;
 
 public:
@@ -165,5 +165,5 @@
      * Get the X-Plane object this buffer belongs to.
      */
-    XPlane& getXPlane() const throw();
+    XPlane& getXPlane() const noexcept;
 
     /**
@@ -173,5 +173,5 @@
      * get the value.
      */
-    size_t addInt(const std::string& name) throw();
+    size_t addInt(const std::string& name) noexcept;
 
     /**
@@ -181,5 +181,5 @@
      * get the value.
      */
-    size_t addFloat(const std::string& name) throw();
+    size_t addFloat(const std::string& name) noexcept;
 
     /**
@@ -189,5 +189,5 @@
      * get the value.
      */
-    size_t addDouble(const std::string& name) throw();
+    size_t addDouble(const std::string& name) noexcept;
 
     /**
@@ -198,5 +198,5 @@
      */
     size_t addFloatArray(const std::string& name, size_t length,
-                         size_t offset = 0) throw();
+                         size_t offset = 0) noexcept;
 
     /**
@@ -207,5 +207,5 @@
      */
     size_t addIntArray(const std::string& name, size_t length,
-                       size_t offset = 0) throw();
+                       size_t offset = 0) noexcept;
 
     /**
@@ -216,5 +216,5 @@
      */
     size_t addByteArray(const std::string& name, size_t length,
-                        size_t offset = 0) throw();
+                        size_t offset = 0) noexcept;
 
     /**
@@ -230,10 +230,10 @@
      * too.
      */
-    void registerInXPlane() throw(Exception);
+    void registerInXPlane();
 
     /**
      * Unregister this buffer from X-Plane.
      */
-    void unregisterFromXPlane() throw(Exception);
+    void unregisterFromXPlane();
 
     /**
@@ -244,5 +244,5 @@
      * @return whether unregistration succeeded.
      */
-    bool unregisterSafelyFromXPlane() throw();
+    bool unregisterSafelyFromXPlane() noexcept;
 
     /**
@@ -252,77 +252,65 @@
      * and it will be re-registered after finalizing.
      */
-    void execute() throw(Exception);
+    void execute();
 
     /**
      * Set the value of an integer dataref with the given ID.
      */
-    void setInt(size_t id, int value)
-        throw(InvalidIDException, TypeMismatchException);
+    void setInt(size_t id, int value);
 
     /**
      * Get the value of an integer dataref with the given ID.
      */
-    int getInt(size_t id) const
-        throw(InvalidIDException, TypeMismatchException);
+    int getInt(size_t id) const;
 
     /**
      * Get a reference to the integer dataref with the given ID
      */
-    const int32_t& getIntRef(size_t id) const
-        throw(InvalidIDException, TypeMismatchException);
+    const int32_t& getIntRef(size_t id) const;
 
     /**
      * Get a reference to the integer dataref with the given ID
      */
-    int32_t& getIntRef(size_t id)
-        throw(InvalidIDException, TypeMismatchException);
+    int32_t& getIntRef(size_t id);
 
     /**
      * Set the value of a float dataref with the given ID.
      */
-    void setFloat(size_t id, float value)
-        throw(InvalidIDException, TypeMismatchException);
+    void setFloat(size_t id, float value);
 
     /**
      * Get the value of a float dataref with the given ID.
      */
-    float getFloat(size_t id) const
-        throw(InvalidIDException, TypeMismatchException);
+    float getFloat(size_t id) const;
 
     /**
      * Get a reference to the float dataref with the given ID
      */
-    const float& getFloatRef(size_t id) const
-        throw(InvalidIDException, TypeMismatchException);
+    const float& getFloatRef(size_t id) const;
 
     /**
      * Get a reference to the integer dataref with the given ID
      */
-    float& getFloatRef(size_t id)
-        throw(InvalidIDException, TypeMismatchException);
+    float& getFloatRef(size_t id);
 
     /**
      * Set the value of a double dataref with the given ID.
      */
-    void setDouble(size_t id, double value)
-        throw(InvalidIDException, TypeMismatchException);
+    void setDouble(size_t id, double value);
 
     /**
      * Get the value of a double dataref with the given ID.
      */
-    double getDouble(size_t id) const
-        throw(InvalidIDException, TypeMismatchException);
+    double getDouble(size_t id) const;
 
     /**
      * Get a reference to the double dataref with the given ID
      */
-    const double& getDoubleRef(size_t id) const
-        throw(InvalidIDException, TypeMismatchException);
+    const double& getDoubleRef(size_t id) const;
 
     /**
      * Get a reference to the double dataref with the given ID
      */
-    double& getDoubleRef(size_t id)
-        throw(InvalidIDException, TypeMismatchException);
+    double& getDoubleRef(size_t id);
 
     /**
@@ -340,6 +328,5 @@
      */
     size_t setFloatArray(size_t id, const float* value,
-                         size_t length = 0, size_t offset = 0)
-        throw(InvalidIDException, TypeMismatchException);
+                         size_t length = 0, size_t offset = 0);
 
     /**
@@ -357,6 +344,5 @@
      */
     size_t getFloatArray(size_t id, float* value,
-                         size_t length = 0, size_t offset = 0) const
-        throw(InvalidIDException, TypeMismatchException);
+                         size_t length = 0, size_t offset = 0) const;
 
     /**
@@ -368,6 +354,5 @@
      * than the length of the buffer, 0 is returned.
      */
-    const float* getFloatArray(size_t id, size_t offset = 0) const
-        throw(InvalidIDException, TypeMismatchException);
+    const float* getFloatArray(size_t id, size_t offset = 0) const;
 
     /**
@@ -385,6 +370,5 @@
      */
     size_t setIntArray(size_t id, const int32_t* value,
-                       size_t length = 0, size_t offset = 0)
-        throw(InvalidIDException, TypeMismatchException);
+                       size_t length = 0, size_t offset = 0);
 
     /**
@@ -402,6 +386,5 @@
      */
     size_t getIntArray(size_t id, int32_t* value,
-                       size_t length = 0, size_t offset = 0) const
-        throw(InvalidIDException, TypeMismatchException);
+                       size_t length = 0, size_t offset = 0) const;
 
     /**
@@ -412,7 +395,5 @@
      * than the length of the buffer, 0 is returned.
      */
-    const int32_t* getIntArray(size_t id, size_t offset = 0) const
-        throw(InvalidIDException, TypeMismatchException);
-
+    const int32_t* getIntArray(size_t id, size_t offset = 0) const;
 
     /**
@@ -430,6 +411,5 @@
      */
     size_t setByteArray(size_t id, const uint8_t* value,
-                        size_t length = 0, size_t offset = 0)
-        throw(InvalidIDException, TypeMismatchException);
+                        size_t length = 0, size_t offset = 0);
 
     /**
@@ -447,6 +427,5 @@
      */
     size_t getByteArray(size_t id, uint8_t* value,
-                        size_t length = 0, size_t offset = 0) const
-        throw(InvalidIDException, TypeMismatchException);
+                        size_t length = 0, size_t offset = 0) const;
 
     /**
@@ -457,6 +436,5 @@
      * than the length of the buffer, 0 is returned.
      */
-    const uint8_t* getByteArray(size_t id, size_t offset = 0) const
-        throw(InvalidIDException, TypeMismatchException);
+    const uint8_t* getByteArray(size_t id, size_t offset = 0) const;
 
 
@@ -469,6 +447,5 @@
      */
     size_t setString(size_t id, const std::string& value,
-                     size_t offset = 0)
-        throw(InvalidIDException, TypeMismatchException);
+                     size_t offset = 0);
 
     /**
@@ -476,13 +453,11 @@
      * a string.
      */
-    std::string getString(size_t id, size_t offset = 0) const
-        throw(InvalidIDException, TypeMismatchException);
-
+    std::string getString(size_t id, size_t offset = 0) const;
+    
     /**
      * Get a string pointer to the value of the byte array dataref
      * with the given ID.
      */
-    const char* getStringPtr(size_t id, size_t offset = 0) const
-        throw(InvalidIDException, TypeMismatchException);
+    const char* getStringPtr(size_t id, size_t offset = 0) const;
 
 protected:
@@ -491,5 +466,5 @@
      * registered.
      */
-    virtual void doExecute() throw(Exception) = 0;
+    virtual void doExecute() = 0;
 
     /**
@@ -497,5 +472,5 @@
      * not registered.
      */
-    virtual void doExecuteUnregistered() throw(Exception) = 0;
+    virtual void doExecuteUnregistered() = 0;
 
     /**
@@ -503,5 +478,5 @@
      * checks the result
      */
-    void writeSpec(uint8_t command) const throw(Exception);
+    void writeSpec(uint8_t command) const;
 
     /**
@@ -516,5 +491,5 @@
      * again
      */
-    void reregisterInXPlane() throw(Exception);
+    void reregisterInXPlane();
 
 private:
@@ -522,5 +497,5 @@
      * Unfinalize the buffer, if it is finalized.
      */
-    void unfinalize() throw();
+    void unfinalize() noexcept;
 
     /**
@@ -530,10 +505,10 @@
      * multi-buffers.
      */
-    void forgetRegistration() throw();
+    void forgetRegistration() noexcept;
 
     /**
      * Get the last dataref, or 0 if there are not datarefs yet.
      */
-    const DataRef* getLastDataRef() const throw();
+    const DataRef* getLastDataRef() const noexcept;
 
     /**
@@ -541,6 +516,5 @@
      * type. Otherwise throw an exception.
      */
-    const DataRef& getDataRef(size_t id, uint8_t type) const
-        throw(InvalidIDException, TypeMismatchException);
+    const DataRef& getDataRef(size_t id, uint8_t type) const;
 
     /**
@@ -548,6 +522,5 @@
      * given type. If the buffer is not finalized yet, it will be.
      */
-    void* getData(size_t id, uint8_t type)
-        throw(InvalidIDException, TypeMismatchException);
+    void* getData(size_t id, uint8_t type);
 
     /**
@@ -555,6 +528,5 @@
      * given type. If the buffer is not finalized yet, it will be.
      */
-    const void* getData(size_t id, uint8_t type) const
-        throw(InvalidIDException, TypeMismatchException);
+    const void* getData(size_t id, uint8_t type) const;
 
     /**
@@ -562,6 +534,5 @@
      */
     template <typename T, uint8_t type> size_t
-    setArray(size_t id, const T* value, size_t length, size_t offset)
-        throw(InvalidIDException, TypeMismatchException);
+    setArray(size_t id, const T* value, size_t length, size_t offset);
 
     /**
@@ -570,6 +541,5 @@
      */
     template <typename T, uint8_t type> size_t
-    getArray(size_t id, T* value, size_t length, size_t offset) const
-        throw(InvalidIDException, TypeMismatchException);
+    getArray(size_t id, T* value, size_t length, size_t offset) const;
 
     /**
@@ -578,6 +548,5 @@
      */
     template <typename T, uint8_t type> const T*
-    getArray(size_t id, size_t offset) const
-        throw(InvalidIDException, TypeMismatchException);
+    getArray(size_t id, size_t offset) const;
 
     friend class XPlane;
@@ -588,5 +557,5 @@
 //------------------------------------------------------------------------------
 
-inline XPlane& MultiBuffer::getXPlane() const throw()
+inline XPlane& MultiBuffer::getXPlane() const noexcept
 {
     return xplane;
Index: src/client/c/hu/varadiistvan/xplra/MultiGetter.cc
===================================================================
--- src/client/c/hu/varadiistvan/xplra/MultiGetter.cc	(revision 40)
+++ src/client/c/hu/varadiistvan/xplra/MultiGetter.cc	(revision 107)
@@ -50,5 +50,5 @@
 //------------------------------------------------------------------------------
 
-MultiGetter::MultiGetter(XPlane& xplane) throw() :
+MultiGetter::MultiGetter(XPlane& xplane) noexcept :
     MultiBuffer(xplane, Protocol::COMMAND_REGISTER_GET_MULTI,
                 Protocol::COMMAND_UNREGISTER_GET_MULTI)
@@ -58,5 +58,5 @@
 //------------------------------------------------------------------------------
 
-inline void MultiGetter::read(const DataRef& dataRef) throw(Exception)
+inline void MultiGetter::read(const DataRef& dataRef)
 {
     switch (dataRef.type) {
@@ -91,5 +91,5 @@
 //------------------------------------------------------------------------------
 
-void MultiGetter::doExecute() throw(Exception)
+void MultiGetter::doExecute()
 {
     xplane.checkStream();
@@ -105,5 +105,5 @@
 //------------------------------------------------------------------------------
 
-void MultiGetter::doExecuteUnregistered() throw(Exception)
+void MultiGetter::doExecuteUnregistered()
 {
     writeSpec(Protocol::COMMAND_GET_MULTI);
@@ -114,5 +114,5 @@
 //------------------------------------------------------------------------------
 
-void MultiGetter::readValues() throw(Exception)
+void MultiGetter::readValues()
 {
     for(vector<DataRef>::const_iterator i = dataRefs.begin();
Index: src/client/c/hu/varadiistvan/xplra/MultiGetter.h
===================================================================
--- src/client/c/hu/varadiistvan/xplra/MultiGetter.h	(revision 33)
+++ src/client/c/hu/varadiistvan/xplra/MultiGetter.h	(revision 107)
@@ -48,5 +48,5 @@
      * Construct the object for the given XPlane instance.
      */
-    MultiGetter(XPlane& xplane) throw();
+    MultiGetter(XPlane& xplane) noexcept;
 
 protected:
@@ -54,10 +54,10 @@
      * @see MultiBuffer::doExecute
      */
-    virtual void doExecute() throw(Exception);
+    virtual void doExecute();
 
     /**
      * @see MultiBuffer::doExecuteUnregistered
      */
-    virtual void doExecuteUnregistered() throw(Exception);
+    virtual void doExecuteUnregistered();
 
 private:
@@ -66,10 +66,10 @@
      * buffer.
      */
-    void read(const DataRef& dataRef) throw(Exception);
+    void read(const DataRef& dataRef);
 
     /**
      * Read all the values.
      */
-    void readValues() throw(Exception);
+    void readValues();
 
     friend class XPlane;
Index: src/client/c/hu/varadiistvan/xplra/MultiSetter.cc
===================================================================
--- src/client/c/hu/varadiistvan/xplra/MultiSetter.cc	(revision 40)
+++ src/client/c/hu/varadiistvan/xplra/MultiSetter.cc	(revision 107)
@@ -48,5 +48,5 @@
 //------------------------------------------------------------------------------
 
-MultiSetter::MultiSetter(XPlane& xplane) throw() :
+MultiSetter::MultiSetter(XPlane& xplane) noexcept :
     MultiBuffer(xplane, Protocol::COMMAND_REGISTER_SET_MULTI,
                 Protocol::COMMAND_UNREGISTER_SET_MULTI)
@@ -56,5 +56,5 @@
 //------------------------------------------------------------------------------
 
-inline void MultiSetter::write(const DataRef& dataRef) const throw(Exception)
+inline void MultiSetter::write(const DataRef& dataRef) const
 {
     switch (dataRef.type) {
@@ -87,5 +87,5 @@
 //------------------------------------------------------------------------------
 
-void MultiSetter::doExecute() throw(Exception)
+void MultiSetter::doExecute()
 {
     xplane.checkStream();
@@ -104,5 +104,5 @@
 //------------------------------------------------------------------------------
 
-void MultiSetter::doExecuteUnregistered() throw(Exception)
+void MultiSetter::doExecuteUnregistered()
 {
     xplane.stream->writeU8(Protocol::COMMAND_SET_MULTI);
Index: src/client/c/hu/varadiistvan/xplra/MultiSetter.h
===================================================================
--- src/client/c/hu/varadiistvan/xplra/MultiSetter.h	(revision 26)
+++ src/client/c/hu/varadiistvan/xplra/MultiSetter.h	(revision 107)
@@ -48,5 +48,5 @@
      * Construct the object for the given XPlane instance.
      */
-    MultiSetter(XPlane& xplane) throw();
+    MultiSetter(XPlane& xplane) noexcept;
 
 protected:
@@ -54,10 +54,10 @@
      * @see MultiBuffer::doExecute
      */
-    virtual void doExecute() throw(Exception);
+    virtual void doExecute();
 
     /**
      * @see MultiBuffer::doExecuteUnregistered
      */
-    virtual void doExecuteUnregistered() throw(Exception);
+    virtual void doExecuteUnregistered();
 
 private:
@@ -66,5 +66,5 @@
      * stream.
      */
-    void write(const DataRef& dataRef) const throw(Exception);
+    void write(const DataRef& dataRef) const;
 
     friend class XPlane;
Index: src/client/c/hu/varadiistvan/xplra/XPlane.cc
===================================================================
--- src/client/c/hu/varadiistvan/xplra/XPlane.cc	(revision 92)
+++ src/client/c/hu/varadiistvan/xplra/XPlane.cc	(revision 107)
@@ -63,5 +63,5 @@
 //------------------------------------------------------------------------------
 
-void XPlane::checkStream() throw(NotConnectedException, IOException)
+void XPlane::checkStream()
 {
     if (stream==0) {
@@ -74,6 +74,5 @@
 //------------------------------------------------------------------------------
 
-void XPlane::checkResult(uint8_t result, bool hasParameter, long parameter)
-    throw(ProtocolException)
+void XPlane::checkResult(uint8_t result, bool hasParameter, long parameter)   
 {
     switch(result) {
@@ -113,5 +112,5 @@
 //------------------------------------------------------------------------------
 
-void XPlane::checkResult(bool multi) throw(ProtocolException, IOException)
+void XPlane::checkResult(bool multi)
 {
     uint8_t result = stream->readU8();
@@ -131,5 +130,5 @@
 //------------------------------------------------------------------------------
 
-XPlane::~XPlane() throw()
+XPlane::~XPlane() noexcept
 {
     disconnect();
@@ -145,5 +144,5 @@
 //------------------------------------------------------------------------------
 
-void XPlane::connect() throw(IOException)
+void XPlane::connect()
 {
     if (socket!=0) return;
@@ -180,5 +179,5 @@
 //------------------------------------------------------------------------------
 
-void XPlane::disconnect() throw()
+void XPlane::disconnect() noexcept
 {
     if (socket==0) return;
@@ -190,5 +189,5 @@
 //------------------------------------------------------------------------------
 
-MultiGetter& XPlane::createMultiGetter() throw()
+MultiGetter& XPlane::createMultiGetter() noexcept
 {
     MultiGetter* getter = new MultiGetter(*this);
@@ -199,5 +198,5 @@
 //------------------------------------------------------------------------------
 
-MultiSetter& XPlane::createMultiSetter() throw()
+MultiSetter& XPlane::createMultiSetter() noexcept
 {
     MultiSetter* setter = new MultiSetter(*this);
@@ -208,5 +207,5 @@
 //------------------------------------------------------------------------------
 
-bool XPlane::destroyMultiBuffer(MultiBuffer& buffer) throw(Exception)
+bool XPlane::destroyMultiBuffer(MultiBuffer& buffer)
 {
     multiBuffers_t::iterator i = multiBuffers.find(&buffer);
@@ -221,6 +220,5 @@
 //------------------------------------------------------------------------------
 
-void XPlane::getVersions(int& xplaneVersion, int& xplmVersion, int& xplraVersion)
-    throw(Exception)
+void XPlane::getVersions(int& xplaneVersion, int& xplmVersion, int& xplraVersion)   
 {
     stream->writeU8(Protocol::COMMAND_GET_VERSIONS);
@@ -237,5 +235,5 @@
 //------------------------------------------------------------------------------
 
-void XPlane::reloadPlugins() throw(Exception)
+void XPlane::reloadPlugins()
 {
     stream->writeU8(Protocol::COMMAND_RELOAD_PLUGINS);
@@ -246,5 +244,5 @@
 //------------------------------------------------------------------------------
 
-void XPlane::saveSituation(const char* path) throw(Exception)
+void XPlane::saveSituation(const char* path)
 {
     stream->writeU8(Protocol::COMMAND_SAVE_SITUATION);
@@ -256,5 +254,5 @@
 //------------------------------------------------------------------------------
 
-void XPlane::getScalar(const char* name, uint8_t type) throw(Exception)
+void XPlane::getScalar(const char* name, uint8_t type)
 {
     checkStream();
@@ -270,5 +268,5 @@
 //------------------------------------------------------------------------------
 
-int XPlane::getInt(const char* name) throw(Exception)
+int XPlane::getInt(const char* name)
 {
     getScalar(name, Protocol::TYPE_INT);
@@ -281,5 +279,5 @@
 //------------------------------------------------------------------------------
 
-float XPlane::getFloat(const char* name) throw(Exception)
+float XPlane::getFloat(const char* name)
 {
     getScalar(name, Protocol::TYPE_FLOAT);
@@ -292,5 +290,5 @@
 //------------------------------------------------------------------------------
 
-double XPlane::getDouble(const char* name) throw(Exception)
+double XPlane::getDouble(const char* name)
 {
     getScalar(name, Protocol::TYPE_DOUBLE);
@@ -304,5 +302,5 @@
 
 size_t XPlane::getArray(const char* name, uint8_t type,
-                        ssize_t length, size_t offset) throw(Exception)
+                        ssize_t length, size_t offset)
 {
     checkStream();
@@ -326,5 +324,5 @@
 
 size_t XPlane::getFloatArray(const char* name, float* dest,
-                             size_t length, size_t offset) throw(Exception)
+                             size_t length, size_t offset)
 {
     length = getArray(name, Protocol::TYPE_FLOAT_ARRAY, length, offset);
@@ -338,5 +336,5 @@
 
 float* XPlane::getFloatArray(const char* name, size_t& length,
-                             size_t offset) throw(Exception)
+                             size_t offset)
 {
     length = getArray(name, Protocol::TYPE_FLOAT_ARRAY, -1, offset);
@@ -350,5 +348,5 @@
 
 size_t XPlane::getIntArray(const char* name, int32_t* dest,
-                           size_t length, size_t offset) throw(Exception)
+                           size_t length, size_t offset)
 {
     length = getArray(name, Protocol::TYPE_INT_ARRAY, length, offset);
@@ -362,5 +360,5 @@
 
 int32_t* XPlane::getIntArray(const char* name, size_t& length,
-                             size_t offset) throw(Exception)
+                             size_t offset)
 {
     length = getArray(name, Protocol::TYPE_INT_ARRAY, -1, offset);
@@ -374,5 +372,5 @@
 
 size_t XPlane::getByteArray(const char* name, uint8_t* dest,
-                            size_t length, size_t offset) throw(Exception)
+                            size_t length, size_t offset)
 {
     length = getArray(name, Protocol::TYPE_BYTE_ARRAY, length, offset);
@@ -386,5 +384,5 @@
 
 uint8_t* XPlane::getByteArray(const char* name, size_t& length,
-                              size_t offset) throw(Exception)
+                              size_t offset)
 {
     length = getArray(name, Protocol::TYPE_BYTE_ARRAY, -1, offset);
@@ -397,5 +395,5 @@
 //------------------------------------------------------------------------------
 
-string XPlane::getString(const char* name, size_t offset) throw(Exception)
+string XPlane::getString(const char* name, size_t offset)
 {
     size_t length = 0;
@@ -406,5 +404,5 @@
 //------------------------------------------------------------------------------
 
-void XPlane::setScalar(const char* name, uint8_t type) throw(Exception)
+void XPlane::setScalar(const char* name, uint8_t type)
 {
     stream->writeU8(Protocol::COMMAND_SET_SINGLE);
@@ -415,5 +413,5 @@
 //------------------------------------------------------------------------------
 
-void XPlane::setInt(const char* name, int value) throw(Exception)
+void XPlane::setInt(const char* name, int value)
 {
     setScalar(name, Protocol::TYPE_INT);
@@ -425,5 +423,5 @@
 //------------------------------------------------------------------------------
 
-void XPlane::setFloat(const char* name, float value) throw(Exception)
+void XPlane::setFloat(const char* name, float value)
 {
     setScalar(name, Protocol::TYPE_FLOAT);
@@ -435,5 +433,5 @@
 //------------------------------------------------------------------------------
 
-void XPlane::setDouble(const char* name, double value) throw(Exception)
+void XPlane::setDouble(const char* name, double value)
 {
     setScalar(name, Protocol::TYPE_DOUBLE);
@@ -446,5 +444,5 @@
 
 void XPlane::setArray(const char* name, uint8_t type, size_t length,
-                      size_t offset) throw(Exception)
+                      size_t offset)
 {
     stream->writeU8(Protocol::COMMAND_SET_SINGLE);
@@ -458,5 +456,5 @@
 
 void XPlane::setFloatArray(const char* name, const float* values, size_t length,
-                           size_t offset) throw(Exception)
+                           size_t offset)
 {
     setArray(name, Protocol::TYPE_FLOAT_ARRAY, length, offset);
@@ -469,5 +467,5 @@
 
 void XPlane::setIntArray(const char* name, const int32_t* values, size_t length,
-                         size_t offset) throw(Exception)
+                         size_t offset)
 {
     setArray(name, Protocol::TYPE_INT_ARRAY, length, offset);
@@ -480,5 +478,5 @@
 
 void XPlane::setByteArray(const char* name, const uint8_t* values, size_t length,
-                          size_t offset) throw(Exception)
+                          size_t offset)
 {
     setArray(name, Protocol::TYPE_BYTE_ARRAY, length, offset);
@@ -491,5 +489,5 @@
 
 void XPlane::setString(const char* name, const char* value, size_t length,
-                       size_t offset) throw(Exception)
+                       size_t offset)
 {
     size_t valueLength = strlen(value);
@@ -507,5 +505,5 @@
 //------------------------------------------------------------------------------
 
-void XPlane::showMessage(const char* message, float duration) throw(Exception)
+void XPlane::showMessage(const char* message, float duration)
 {
     stream->writeU8(Protocol::COMMAND_SHOW_MESSAGE);
@@ -519,5 +517,5 @@
 
 void XPlane::registerHotkeys(const uint16_t* codes, size_t length)
-    throw(Exception)
+   
 {
     stream->writeU8(Protocol::COMMAND_REGISTER_HOTKEYS);
@@ -530,5 +528,5 @@
 //------------------------------------------------------------------------------
 
-void XPlane::queryHotkeys(uint8_t* states, size_t length) throw(Exception)
+void XPlane::queryHotkeys(uint8_t* states, size_t length)
 {
     stream->writeU8(Protocol::COMMAND_QUERY_HOTKEYS);
Index: src/client/c/hu/varadiistvan/xplra/XPlane.h
===================================================================
--- src/client/c/hu/varadiistvan/xplra/XPlane.h	(revision 87)
+++ src/client/c/hu/varadiistvan/xplra/XPlane.h	(revision 107)
@@ -98,5 +98,5 @@
      * yet.
      */
-    XPlane() throw();
+    XPlane() noexcept;
 
     /**
@@ -105,20 +105,20 @@
      * become invalid.
      */
-    ~XPlane() throw();
+    ~XPlane() noexcept;
 
     /**
      * Connect to the simulator.
      */
-    void connect() throw(IOException);
+    void connect();
 
     /**
      * Check if we are connected to the simulator.
      */
-    bool isConnected() const throw();
+    bool isConnected() const noexcept;
 
     /**
      * Disconnect from the simulator.
      */
-    void disconnect() throw();
+    void disconnect() noexcept;
 
     /**
@@ -126,5 +126,5 @@
      * to it.
      */
-    MultiGetter& createMultiGetter() throw();
+    MultiGetter& createMultiGetter() noexcept;
 
     /**
@@ -132,5 +132,5 @@
      * to it.
      */
-    MultiSetter& createMultiSetter() throw();
+    MultiSetter& createMultiSetter() noexcept;
 
     /**
@@ -142,10 +142,10 @@
      * @return if the buffer was found and could be destroyed
      */
-    bool destroyMultiBuffer(MultiBuffer& buffer) throw(Exception);
+    bool destroyMultiBuffer(MultiBuffer& buffer);
 
     /**
      * Get the versions of X-Plane, XPLM and the XPLRA plugin.
      */
-    void getVersions(int& xplaneVersion, int& xplmVersion, int& xplraVersion) throw(Exception);
+    void getVersions(int& xplaneVersion, int& xplmVersion, int& xplraVersion);
 
     /**
@@ -153,5 +153,5 @@
      * fails.
      */
-    void reloadPlugins() throw(Exception);
+    void reloadPlugins();
 
     /**
@@ -159,20 +159,20 @@
      * which is relative to the directory of X-Plane.
      */
-    void saveSituation(const char* path) throw(Exception);
+    void saveSituation(const char* path);
 
     /**
      * Get the integer value of the dataref with the given name.
      */
-    int getInt(const char* name) throw(Exception);
+    int getInt(const char* name);
 
     /**
      * Get a float value.
      */
-    float getFloat(const char* name) throw(Exception);
+    float getFloat(const char* name);
 
     /**
      * Get a double value.
      */
-    double getDouble(const char* name) throw(Exception);
+    double getDouble(const char* name);
 
     /**
@@ -187,5 +187,5 @@
      */
     size_t getFloatArray(const char* name, float* dest,
-                         size_t length, size_t offset = 0) throw(Exception);
+                         size_t length, size_t offset = 0);
 
     /**
@@ -198,5 +198,5 @@
      */
     float* getFloatArray(const char* name, size_t& length,
-                         size_t offset = 0) throw(Exception);
+                         size_t offset = 0);
 
     /**
@@ -211,5 +211,5 @@
      */
     size_t getIntArray(const char* name, int32_t* dest,
-                       size_t length, size_t offset = 0) throw(Exception);
+                       size_t length, size_t offset = 0);
 
     /**
@@ -222,5 +222,5 @@
      */
     int32_t* getIntArray(const char* name, size_t& length,
-                         size_t offset = 0) throw(Exception);
+                         size_t offset = 0);
 
     /**
@@ -235,5 +235,5 @@
      */
     size_t getByteArray(const char* name, uint8_t* dest,
-                        size_t length, size_t offset = 0) throw(Exception);
+                        size_t length, size_t offset = 0);
 
     /**
@@ -246,25 +246,25 @@
      */
     uint8_t* getByteArray(const char* name, size_t& length,
-                          size_t offset = 0) throw(Exception);
+                          size_t offset = 0);
 
     /**
      * Get a string. A string is a byte array.
      */
-    std::string getString(const char* name, size_t offset = 0) throw(Exception);
+    std::string getString(const char* name, size_t offset = 0);
 
     /**
      * Set the given dataref to the given integer value.
      */
-    void setInt(const char* name, int value) throw(Exception);
+    void setInt(const char* name, int value);
 
     /**
      * Set the given dataref to the given float value.
      */
-    void setFloat(const char* name, float value) throw(Exception);
+    void setFloat(const char* name, float value);
 
     /**
      * Set the given dataref to the given double value.
      */
-    void setDouble(const char* name, double value) throw(Exception);
+    void setDouble(const char* name, double value);
 
     /**
@@ -272,5 +272,5 @@
      */
     void setFloatArray(const char* name, const float* values, size_t length,
-                       size_t offset = 0) throw(Exception);
+                       size_t offset = 0);
 
     /**
@@ -278,5 +278,5 @@
      */
     void setIntArray(const char* name, const int32_t* values, size_t length,
-                     size_t offset = 0) throw(Exception);
+                     size_t offset = 0);
 
     /**
@@ -284,5 +284,5 @@
      */
     void setByteArray(const char* name, const uint8_t* values, size_t length,
-                      size_t offset = 0) throw(Exception);
+                      size_t offset = 0);
 
     /**
@@ -293,10 +293,10 @@
      */
     void setString(const char* name, const char* value, size_t length,
-                   size_t offset = 0) throw(Exception);
+                   size_t offset = 0);
 
     /**
      * Show a textual message for a certain duration.
      */
-    void showMessage(const char* message, float duration) throw(Exception);
+    void showMessage(const char* message, float duration);
 
     /**
@@ -304,10 +304,10 @@
      * existing set of hotkeys registered, those will be overwritten.
      */
-    void registerHotkeys(const uint16_t* codes, size_t length) throw(Exception);
+    void registerHotkeys(const uint16_t* codes, size_t length);
 
     /**
      * Query the registered hotkeys whether they were pressed.
      */
-    void queryHotkeys(uint8_t* states, size_t length) throw(Exception);
+    void queryHotkeys(uint8_t* states, size_t length);
 
     /**
@@ -320,5 +320,5 @@
      * Check if we have a stream and if it has not failed.
      */
-    void checkStream() throw(NotConnectedException, IOException);
+    void checkStream();
 
     /**
@@ -327,5 +327,5 @@
      */
     void checkResult(uint8_t result, bool hasParameter = false,
-                     long parameter = 0) throw(ProtocolException);
+                     long parameter = 0);
 
     /**
@@ -334,5 +334,5 @@
      * is some problem with the stream, an IOException is thrown.
      */
-    void checkResult(bool multi = false) throw(ProtocolException, IOException);
+    void checkResult(bool multi = false);
 
     /**
@@ -340,5 +340,5 @@
      * also checked, but the value should be read by the caller.
      */
-    void getScalar(const char* name, uint8_t type) throw(Exception);
+    void getScalar(const char* name, uint8_t type);
 
     /**
@@ -350,5 +350,5 @@
      */
     size_t getArray(const char* name, uint8_t type,
-                    ssize_t length, size_t offset) throw(Exception);
+                    ssize_t length, size_t offset);
 
 
@@ -356,5 +356,5 @@
      * Issue the command to set a scalar value of the given type.
      */
-    void setScalar(const char* name, uint8_t type) throw(Exception);
+    void setScalar(const char* name, uint8_t type);
 
     /**
@@ -362,5 +362,5 @@
      */
     void setArray(const char* name, uint8_t type, size_t length,
-                  size_t offset) throw(Exception);
+                  size_t offset);
 
     friend class MultiBuffer;
@@ -373,5 +373,5 @@
 //------------------------------------------------------------------------------
 
-inline XPlane::XPlane() throw() :
+inline XPlane::XPlane() noexcept :
     socket(0),
     stream(0)
@@ -381,5 +381,5 @@
 //------------------------------------------------------------------------------
 
-inline bool XPlane::isConnected() const throw()
+inline bool XPlane::isConnected() const noexcept
 {
     return socket!=0;
Index: src/client/c/hu/varadiistvan/xplra/xplra.cc
===================================================================
--- src/client/c/hu/varadiistvan/xplra/xplra.cc	(revision 92)
+++ src/client/c/hu/varadiistvan/xplra/xplra.cc	(revision 107)
@@ -90,15 +90,15 @@
      * @return the ID of the new value
      */
-    static int addValue(Value value) throw();
+    static int addValue(Value value) noexcept;
 
     /**
      * Get the value with the given ID.
      */
-    static Value getValue(int valueID) throw();
+    static Value getValue(int valueID) noexcept;
 
     /**
      * Clear the value with the given ID.
      */
-    static void clearValue(int valueID) throw();
+    static void clearValue(int valueID) noexcept;
 
 private:
@@ -119,5 +119,5 @@
      * Construct a slot with the given value
      */
-    Slot(Value value) throw();
+    Slot(Value value) noexcept;
 
     /**
@@ -125,5 +125,5 @@
      * should be called for a slot with no value.
      */
-    int setValue(Value value) throw();
+    int setValue(Value value) noexcept;
 
     /**
@@ -131,10 +131,10 @@
      * returned (converted to value).
      */
-    Value getValue() const throw();
+    Value getValue() const noexcept;
 
     /**
      * Clear the value and set the given next free index.
      */
-    void clear(int nextFreeIndex) throw();
+    void clear(int nextFreeIndex) noexcept;
 };
 
@@ -150,5 +150,5 @@
 
 template <class Value>
-inline Slot<Value>::Slot(Value value) throw() :
+inline Slot<Value>::Slot(Value value) noexcept :
     valid(true)
 {
@@ -159,5 +159,5 @@
 
 template <class Value>
-inline int Slot<Value>::setValue(Value value) throw()
+inline int Slot<Value>::setValue(Value value) noexcept
 {
     assert(!valid);
@@ -171,5 +171,5 @@
 
 template <class Value>
-inline Value Slot<Value>::getValue() const throw()
+inline Value Slot<Value>::getValue() const noexcept
 {
     return valid ? value : static_cast<Value>(0);
@@ -179,5 +179,5 @@
 
 template <class Value>
-inline void Slot<Value>::clear(int nextFreeIndex) throw()
+inline void Slot<Value>::clear(int nextFreeIndex) noexcept
 {
     assert(valid);
@@ -189,5 +189,5 @@
 
 template <class Value>
-int Slot<Value>::addValue(Value value) throw()
+int Slot<Value>::addValue(Value value) noexcept
 {
     int id = firstFree;
@@ -206,5 +206,5 @@
 
 template <class Value>
-Value Slot<Value>::getValue(int valueID) throw()
+Value Slot<Value>::getValue(int valueID) noexcept
 {
     size_t index = static_cast<size_t>(valueID);
@@ -216,5 +216,5 @@
 
 template <class Value>
-void Slot<Value>::clearValue(int valueID) throw()
+void Slot<Value>::clearValue(int valueID) noexcept
 {
     size_t index = static_cast<size_t>(valueID);
@@ -248,5 +248,5 @@
      * Get the connection for the given multi-dataref buffer.
      */
-    static Connection& get(const MultiBuffer& buffer) throw();
+    static Connection& get(const MultiBuffer& buffer) noexcept;
 
 private:
@@ -275,30 +275,30 @@
      * Construct the connection
      */
-    Connection() throw();
+    Connection() noexcept;
 
     /**
      * Destroy the connection.
      */
-    ~Connection() throw();
+    ~Connection() noexcept;
 
     /**
      * Handle the currently pending exception.
      */
-    void handleException() throw();
+    void handleException() noexcept;
 
     /**
      * Get the last error code.
      */
-    int getLastError(unsigned long* lastErrorSubCode) const throw();
+    int getLastError(unsigned long* lastErrorSubCode) const noexcept;
 
     /**
      * Get the string representation of the last error code.
      */
-    const char* getLastErrorString() const throw();
+    const char* getLastErrorString() const noexcept;
 
     /**
      * Clear the last error code.
      */
-    void clearLastError() throw();
+    void clearLastError() noexcept;
 
     /**
@@ -307,5 +307,5 @@
      * @return the ID of the new getter.
      */
-    int createMultiGetter() throw();
+    int createMultiGetter() noexcept;
 
     /**
@@ -314,5 +314,5 @@
      * @return the ID of the new setter.
      */
-    int createMultiSetter() throw();
+    int createMultiSetter() noexcept;
 
     /**
@@ -324,10 +324,10 @@
      * @return whether the buffer was found and could be destroyed.
      */
-    bool destroyMultiBuffer(int bufferID) throw(Exception);
+    bool destroyMultiBuffer(int bufferID);
 };
 
 //------------------------------------------------------------------------------
 
-inline Connection& Connection::get(const MultiBuffer& buffer) throw()
+inline Connection& Connection::get(const MultiBuffer& buffer) noexcept
 {
     return static_cast<Connection&>(buffer.getXPlane());
@@ -336,5 +336,5 @@
 //------------------------------------------------------------------------------
 
-inline Connection::Connection() throw() :
+inline Connection::Connection() noexcept :
     lastErrorCode(0),
     lastErrorSubCode(0)
@@ -344,5 +344,5 @@
 //------------------------------------------------------------------------------
 
-Connection::~Connection() throw()
+Connection::~Connection() noexcept
 {
     for(multiBufferIDs_t::iterator i = multiBufferIDs.begin();
@@ -355,5 +355,5 @@
 //------------------------------------------------------------------------------
 
-void Connection::handleException() throw()
+void Connection::handleException() noexcept
 {
     try {
@@ -393,5 +393,5 @@
 
 inline int Connection::getLastError(unsigned long* lastErrorSubCode)
-    const throw()
+    const noexcept
 {
     if (lastErrorSubCode!=0) *lastErrorSubCode = this->lastErrorSubCode;
@@ -401,5 +401,5 @@
 //------------------------------------------------------------------------------
 
-inline const char* Connection::getLastErrorString() const throw()
+inline const char* Connection::getLastErrorString() const noexcept
 {
     return (lastErrorCode==ERROR_NONE) ? 0 : lastErrorString.c_str();
@@ -408,5 +408,5 @@
 //------------------------------------------------------------------------------
 
-inline void Connection::clearLastError() throw()
+inline void Connection::clearLastError() noexcept
 {
     lastErrorCode = ERROR_NONE;
@@ -417,5 +417,5 @@
 //------------------------------------------------------------------------------
 
-inline int Connection::createMultiGetter() throw()
+inline int Connection::createMultiGetter() noexcept
 {
     MultiGetter& getter = XPlane::createMultiGetter();
@@ -425,5 +425,5 @@
 //------------------------------------------------------------------------------
 
-inline int Connection::createMultiSetter() throw()
+inline int Connection::createMultiSetter() noexcept
 {
     MultiSetter& setter = XPlane::createMultiSetter();
@@ -433,5 +433,5 @@
 //------------------------------------------------------------------------------
 
-bool Connection::destroyMultiBuffer(int bufferID) throw(Exception)
+bool Connection::destroyMultiBuffer(int bufferID)
 {
     MultiBuffer* buffer = MultiBufferSlot::getValue(bufferID);
