Fixed bug 2176

3 files changed, 99 insertions, 99 deletions

diff --git a/cppe/include/IceE/BasicStream.h b/cppe/include/IceE/BasicStream.h
index 6f676e045b3..397164940a9 100644
--- a/cppe/include/IceE/BasicStream.h
+++ b/cppe/include/IceE/BasicStream.h
@@ -33,7 +33,7 @@ namespace IceInternal
 
 class Instance;
 
-class ICE_API BasicStream : public Buffer
+class BasicStream : public Buffer
 {
 public:
 
@@ -61,7 +61,7 @@ public:
 	}
     }
 
-    void clear();
+    ICE_API void clear();
 
     //
     // Must return Instance*, because we don't hold an InstancePtr for
@@ -69,7 +69,7 @@ public:
     //
     Instance* instance() const { return _instance; } // Inlined for performance reasons.
 
-    void swap(BasicStream&);
+    ICE_API void swap(BasicStream&);
 
     void resize(Container::size_type sz)
     {
@@ -87,7 +87,7 @@ public:
 	i = b.begin();
     }
 
-    void startSeq(int, int);
+    ICE_API void startSeq(int, int);
     void checkSeq()
     {
 	checkSeq(static_cast<int>(b.end() - i));
@@ -114,13 +114,13 @@ public:
 	    Ice::throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
 	}
     }
-    void checkFixedSeq(int, int); // For sequences of fixed-size types.
+    ICE_API void checkFixedSeq(int, int); // For sequences of fixed-size types.
     void endElement()
     {
 	assert(_seqDataStack);
 	--_seqDataStack->numElements;
     }
-    void endSeq(int);
+    ICE_API void endSeq(int);
 
     void startWriteEncaps()
     {
@@ -236,15 +236,15 @@ public:
 	    delete oldEncaps;
 	}
     }
-    Ice::Int getReadEncapsSize();
-    void skipEncaps();
+    ICE_API Ice::Int getReadEncapsSize();
+    ICE_API void skipEncaps();
 
-    void startWriteSlice();
-    void endWriteSlice();
+    ICE_API void startWriteSlice();
+    ICE_API void endWriteSlice();
 
-    void startReadSlice();
-    void endReadSlice();
-    void skipSlice();
+    ICE_API void startReadSlice();
+    ICE_API void endReadSlice();
+    ICE_API void skipSlice();
 
     void writeSize(Ice::Int v) // Inlined for performance reasons.
     {
@@ -306,8 +306,8 @@ public:
 	}
     }
 
-    void writeBlob(const std::vector<Ice::Byte>&);
-    void readBlob(std::vector<Ice::Byte>&, Ice::Int);
+    ICE_API void writeBlob(const std::vector<Ice::Byte>&);
+    ICE_API void readBlob(std::vector<Ice::Byte>&, Ice::Int);
 
     void writeBlob(const Ice::Byte* v, Container::size_type sz)
     {
@@ -349,15 +349,15 @@ public:
 	v = *i++;
     }
 
-    void write(const Ice::Byte*, const Ice::Byte*);
-    void read(std::pair<const Ice::Byte*, const Ice::Byte*>&);
+    ICE_API void write(const Ice::Byte*, const Ice::Byte*);
+    ICE_API void read(std::pair<const Ice::Byte*, const Ice::Byte*>&);
 
     void write(bool v) // Inlined for performance reasons.
     {
 	b.push_back(static_cast<Ice::Byte>(v));
     }
-    void write(const std::vector<bool>&);
-    void write(const bool*, const bool*);
+    ICE_API void write(const std::vector<bool>&);
+    ICE_API void write(const bool*, const bool*);
     void read(bool& v) // Inlined for performance reasons.
     {
 	if(i >= b.end())
@@ -366,14 +366,14 @@ public:
 	}
 	v = *i++;
     }
-    void read(std::vector<bool>&);
-    bool* read(std::pair<const bool*, const bool*>&);
+    ICE_API void read(std::vector<bool>&);
+    ICE_API bool* read(std::pair<const bool*, const bool*>&);
 
-    void write(Ice::Short);
-    void read(Ice::Short&);
-    void write(const Ice::Short*, const Ice::Short*);
-    void read(std::vector<Ice::Short>&);
-    Ice::Short* read(std::pair<const Ice::Short*, const Ice::Short*>&);
+    ICE_API void write(Ice::Short);
+    ICE_API void read(Ice::Short&);
+    ICE_API void write(const Ice::Short*, const Ice::Short*);
+    ICE_API void read(std::vector<Ice::Short>&);
+    ICE_API Ice::Short* read(std::pair<const Ice::Short*, const Ice::Short*>&);
 
     void
     write(Ice::Int v) // Inlined for performance reasons.
@@ -419,27 +419,27 @@ public:
 #endif
     }
 
-    void write(const Ice::Int*, const Ice::Int*);
-    void read(std::vector<Ice::Int>&);
-    Ice::Int* read(std::pair<const Ice::Int*, const Ice::Int*>&);
+    ICE_API void write(const Ice::Int*, const Ice::Int*);
+    ICE_API void read(std::vector<Ice::Int>&);
+    ICE_API Ice::Int* read(std::pair<const Ice::Int*, const Ice::Int*>&);
 
-    void write(Ice::Long);
-    void read(Ice::Long&);
-    void write(const Ice::Long*, const Ice::Long*);
-    void read(std::vector<Ice::Long>&);
-    Ice::Long* read(std::pair<const Ice::Long*, const Ice::Long*>&);
+    ICE_API void write(Ice::Long);
+    ICE_API void read(Ice::Long&);
+    ICE_API void write(const Ice::Long*, const Ice::Long*);
+    ICE_API void read(std::vector<Ice::Long>&);
+    ICE_API Ice::Long* read(std::pair<const Ice::Long*, const Ice::Long*>&);
 
-    void write(Ice::Float);
-    void read(Ice::Float&);
-    void write(const Ice::Float*, const Ice::Float*);
-    void read(std::vector<Ice::Float>&);
-    Ice::Float* read(std::pair<const Ice::Float*, const Ice::Float*>&);
+    ICE_API void write(Ice::Float);
+    ICE_API void read(Ice::Float&);
+    ICE_API void write(const Ice::Float*, const Ice::Float*);
+    ICE_API void read(std::vector<Ice::Float>&);
+    ICE_API Ice::Float* read(std::pair<const Ice::Float*, const Ice::Float*>&);
 
-    void write(Ice::Double);
-    void read(Ice::Double&);
-    void write(const Ice::Double*, const Ice::Double*);
-    void read(std::vector<Ice::Double>&);
-    Ice::Double* read(std::pair<const Ice::Double*, const Ice::Double*>&);
+    ICE_API void write(Ice::Double);
+    ICE_API void read(Ice::Double&);
+    ICE_API void write(const Ice::Double*, const Ice::Double*);
+    ICE_API void read(std::vector<Ice::Double>&);
+    ICE_API Ice::Double* read(std::pair<const Ice::Double*, const Ice::Double*>&);
 
     //
     // NOTE: This function is not implemented. It is declared here to
@@ -448,7 +448,7 @@ public:
     // will silently select a different overloading. A link error is the
     // intended result.
     //
-    void write(const char*);
+    ICE_API void write(const char*);
 
     void write(const std::string& v)
     {
@@ -461,7 +461,7 @@ public:
             memcpy(&b[pos], v.data(), sz);
         }
     }
-    void write(const std::string*, const std::string*);
+    ICE_API void write(const std::string*, const std::string*);
     void read(std::string& v)
     {
 	Ice::Int sz;
@@ -481,7 +481,7 @@ public:
 	    v.clear();
 	}
     }
-    void read(std::vector<std::string>&);
+    ICE_API void read(std::vector<std::string>&);
 
     void write(const std::wstring& v)
     {
@@ -495,7 +495,7 @@ public:
             memcpy(&b[pos], s.c_str(), sz);
         }
     }
-    void write(const std::wstring*, const std::wstring*);
+    ICE_API void write(const std::wstring*, const std::wstring*);
     void read(std::wstring& v)
     {
         Ice::Int sz;
@@ -515,13 +515,13 @@ public:
             v.clear();
         }
     }
-    void read(std::vector<std::wstring>&);
+    ICE_API void read(std::vector<std::wstring>&);
 
-    void write(const Ice::ObjectPrx&);
-    void read(Ice::ObjectPrx&);
+    ICE_API void write(const Ice::ObjectPrx&);
+    ICE_API void read(Ice::ObjectPrx&);
 
-    void write(const Ice::UserException&);
-    void throwException();
+    ICE_API void write(const Ice::UserException&);
+    ICE_API void throwException();
 
 private:
 
@@ -531,7 +531,7 @@ private:
     //
     Instance* _instance;
 
-    class ICE_API ReadEncaps : private ::IceUtil::noncopyable
+    class ReadEncaps : private ::IceUtil::noncopyable
     {
     public:
 
@@ -539,7 +539,7 @@ private:
 	~ReadEncaps() { } // Inlined for performance reasons.
 
 	void reset() { previous = 0; } // Inlined for performance reasons.
-	void swap(ReadEncaps&);
+	ICE_API void swap(ReadEncaps&);
 
 	Container::size_type start;
 	Ice::Int sz;
@@ -550,7 +550,7 @@ private:
 	ReadEncaps* previous;
     };
 
-    class ICE_API WriteEncaps : private ::IceUtil::noncopyable
+    class WriteEncaps : private ::IceUtil::noncopyable
     {
     public:
 
@@ -558,7 +558,7 @@ private:
 	~WriteEncaps() { } // Inlined for performance reasons.
 
 	void reset() { writeIndex = 0; previous = 0; } // Inlined for performance reasons.
-	void swap(WriteEncaps&);
+	ICE_API void swap(WriteEncaps&);
 
 	Container::size_type start;
 
diff --git a/cppe/include/IceE/Buffer.h b/cppe/include/IceE/Buffer.h
index 9cc50f5c75a..adc01563ff2 100644
--- a/cppe/include/IceE/Buffer.h
+++ b/cppe/include/IceE/Buffer.h
@@ -19,16 +19,16 @@
 namespace IceInternal
 {
 
-class ICE_API Buffer : private IceUtil::noncopyable
+class Buffer : private IceUtil::noncopyable
 {
 public:
 
     Buffer(size_t maxCapacity) : b(maxCapacity), i(b.begin()) { }
     virtual ~Buffer() { }
 
-    void swap(Buffer&);
+    ICE_API void swap(Buffer&);
 
-    class ICE_API Container : private IceUtil::noncopyable
+    class Container : private IceUtil::noncopyable
     {
     public:
 
@@ -105,9 +105,9 @@ public:
 	    return !_size;
 	}
 
-	void swap(Container&);
+	ICE_API void swap(Container&);
 	
-	void clear();
+	ICE_API void clear();
 
 	void resize(size_type n) // Inlined for performance reasons.
         {
@@ -165,9 +165,9 @@ public:
 
     private:
 
-	Container(const Container&);
-	void operator=(const Container&);
-	void reserve(size_type);
+	ICE_API Container(const Container&);
+	ICE_API void operator=(const Container&);
+	ICE_API void reserve(size_type);
 
 	pointer _buf;
 	size_type _size;
diff --git a/cppe/include/IceE/Proxy.h b/cppe/include/IceE/Proxy.h
index 8766926003d..e39e1f3d662 100644
--- a/cppe/include/IceE/Proxy.h
+++ b/cppe/include/IceE/Proxy.h
@@ -99,26 +99,26 @@ namespace IceProxy { namespace Ice
 typedef ::std::map< ::std::string, ::std::string> Context;
 #endif
 
-class ICE_API Object : public ::IceUtil::Shared, private ::IceUtil::Mutex
+class Object : public ::IceUtil::Shared, private ::IceUtil::Mutex
 {
 public:
 
-    bool operator==(const Object&) const;
-    bool operator<(const Object&) const;
+    ICE_API bool operator==(const Object&) const;
+    ICE_API bool operator<(const Object&) const;
 
     ICE_DEPRECATED_API ::Ice::Int ice_hash() const
     {
 	return ice_getHash();
     }
-    ::Ice::Int ice_getHash() const;
+    ICE_API ::Ice::Int ice_getHash() const;
 
     ICE_DEPRECATED_API ::Ice::CommunicatorPtr ice_communicator() const
     {
 	return ice_getCommunicator();
     }
-    ::Ice::CommunicatorPtr ice_getCommunicator() const;
+    ICE_API ::Ice::CommunicatorPtr ice_getCommunicator() const;
 
-    ::std::string ice_toString() const;
+    ICE_API ::std::string ice_toString() const;
 
     bool ice_isA(const ::std::string& typeId)
     {
@@ -156,64 +156,64 @@ public:
         return ice_id(&context);
     }
 
-    ::Ice::Identity ice_getIdentity() const;
+    ICE_API ::Ice::Identity ice_getIdentity() const;
     ICE_DEPRECATED_API ::Ice::ObjectPrx ice_newIdentity(const ::Ice::Identity& id) const
     {
 	return ice_identity(id);
     }
-    ::Ice::ObjectPrx ice_identity(const ::Ice::Identity&) const;
+    ICE_API ::Ice::ObjectPrx ice_identity(const ::Ice::Identity&) const;
     
-    ::Ice::Context ice_getContext() const;
+    ICE_API ::Ice::Context ice_getContext() const;
     ICE_DEPRECATED_API ::Ice::ObjectPrx ice_newContext(const ::Ice::Context& ctx) const
     {
 	return ice_context(ctx);
     }
-    ::Ice::ObjectPrx ice_context(const ::Ice::Context&) const;
+    ICE_API ::Ice::ObjectPrx ice_context(const ::Ice::Context&) const;
 
-    const ::std::string& ice_getFacet() const;
+    ICE_API const ::std::string& ice_getFacet() const;
     ICE_DEPRECATED_API ::Ice::ObjectPrx ice_newFacet(const ::std::string& facet) const
     {
 	return ice_facet(facet);
     }
-    ::Ice::ObjectPrx ice_facet(const ::std::string&) const;
+    ICE_API ::Ice::ObjectPrx ice_facet(const ::std::string&) const;
 
 #ifdef ICEE_HAS_ROUTER
-    ::Ice::ObjectPrx ice_router(const ::Ice::RouterPrx&) const;
-    ::Ice::RouterPrx ice_getRouter() const;
+    ICE_API ::Ice::ObjectPrx ice_router(const ::Ice::RouterPrx&) const;
+    ICE_API ::Ice::RouterPrx ice_getRouter() const;
 #endif
 #ifdef ICEE_HAS_LOCATOR
-    ::Ice::ObjectPrx ice_locator(const ::Ice::LocatorPrx&) const;
-    ::Ice::LocatorPrx ice_getLocator() const;
+    ICE_API ::Ice::ObjectPrx ice_locator(const ::Ice::LocatorPrx&) const;
+    ICE_API ::Ice::LocatorPrx ice_getLocator() const;
 #endif
 
-    ::Ice::ObjectPrx ice_twoway() const;
-    bool ice_isTwoway() const;
-    ::Ice::ObjectPrx ice_oneway() const;
-    bool ice_isOneway() const;
+    ICE_API ::Ice::ObjectPrx ice_twoway() const;
+    ICE_API bool ice_isTwoway() const;
+    ICE_API ::Ice::ObjectPrx ice_oneway() const;
+    ICE_API bool ice_isOneway() const;
 #ifdef ICEE_HAS_BATCH
-    ::Ice::ObjectPrx ice_batchOneway() const;
-    bool ice_isBatchOneway() const;
+    ICE_API ::Ice::ObjectPrx ice_batchOneway() const;
+    ICE_API bool ice_isBatchOneway() const;
 #endif
 
-    ::Ice::ObjectPrx ice_timeout(int) const;
+    ICE_API ::Ice::ObjectPrx ice_timeout(int) const;
 
     ICE_DEPRECATED_API ::Ice::ConnectionPtr ice_connection()
     {
 	return ice_getConnection();
     }
-    ::Ice::ConnectionPtr ice_getConnection();
-    ::Ice::ConnectionPtr ice_getCachedConnection() const;
+    ICE_API ::Ice::ConnectionPtr ice_getConnection();
+    ICE_API ::Ice::ConnectionPtr ice_getCachedConnection() const;
 
     ::IceInternal::ReferencePtr __reference() const
     {
 	return _reference;
     }
 
-    void __copyFrom(const ::Ice::ObjectPrx&);
-    void __handleException(const ::Ice::ConnectionPtr&, const ::Ice::LocalException&, int&);
-    void __handleExceptionWrapper(const ::Ice::ConnectionPtr&, const ::IceInternal::LocalExceptionWrapper&);
-    void __handleExceptionWrapperRelaxed(const ::Ice::ConnectionPtr&, const ::IceInternal::LocalExceptionWrapper&, int&);
-    void __checkTwowayOnly(const char*) const;
+    ICE_API void __copyFrom(const ::Ice::ObjectPrx&);
+    ICE_API void __handleException(const ::Ice::ConnectionPtr&, const ::Ice::LocalException&, int&);
+    ICE_API void __handleExceptionWrapper(const ::Ice::ConnectionPtr&, const ::IceInternal::LocalExceptionWrapper&);
+    ICE_API void __handleExceptionWrapperRelaxed(const ::Ice::ConnectionPtr&, const ::IceInternal::LocalExceptionWrapper&, int&);
+    ICE_API void __checkTwowayOnly(const char*) const;
 
 protected:
 
@@ -221,10 +221,10 @@ protected:
 
 private:
 
-    bool ice_isA(const ::std::string&, const ::Ice::Context*);
-    void ice_ping(const ::Ice::Context*);
-    ::std::vector< ::std::string> ice_ids(const ::Ice::Context*);
-    ::std::string ice_id(const ::Ice::Context*);
+    ICE_API bool ice_isA(const ::std::string&, const ::Ice::Context*);
+    ICE_API void ice_ping(const ::Ice::Context*);
+    ICE_API ::std::vector< ::std::string> ice_ids(const ::Ice::Context*);
+    ICE_API ::std::string ice_id(const ::Ice::Context*);
 
     void setup(const ::IceInternal::ReferencePtr& ref)
     {