zeroc-ice 3.6.5 → 3.7.0

data/ext/ice/cpp/include/{IceUtil → Ice}/IconvStringConverter.h

@@ -1,16 +1,24 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
 //
 // This copy of Ice is licensed to you under the terms described in the
 // ICE_LICENSE file included in this distribution.
 //
 // **********************************************************************
 
-#ifndef ICE_UTIL_ICONV_STRING_CONVERTER
-#define ICE_UTIL_ICONV_STRING_CONVERTER
+#ifndef ICE_ICONV_STRING_CONVERTER
+#define ICE_ICONV_STRING_CONVERTER
 
-#include <IceUtil/StringConverter.h>
+#include <Ice/Config.h>
+
+//
+// For all platforms except Windows
+//
+#ifndef _WIN32
+
+#include <Ice/StringConverter.h>
+#include <IceUtil/ThreadException.h>
 #include <IceUtil/UndefSysMacros.h>
 
 #include <algorithm>
@@ -19,13 +27,42 @@
 #include <string.h> // For strerror
 
 #if (defined(__APPLE__) && _LIBICONV_VERSION < 0x010B)
-    //
-    // See http://sourceware.org/bugzilla/show_bug.cgi?id=2962
-    //
+//
+// See http://sourceware.org/bugzilla/show_bug.cgi?id=2962
+//
 #   define ICE_CONST_ICONV_INBUF 1
 #endif
 
-namespace IceUtil
+namespace Ice
+{
+
+class ICE_API IconvInitializationException : public IceUtil::ExceptionHelper<IconvInitializationException>
+{
+public:
+
+    IconvInitializationException(const char*, int, const std::string&);
+
+#ifndef ICE_CPP11_COMPILER
+    virtual ~IconvInitializationException() throw();
+#endif
+
+    virtual std::string ice_id() const;
+    virtual void ice_print(std::ostream&) const;
+
+#ifndef ICE_CPP11_MAPPING
+    virtual IconvInitializationException* ice_clone() const;
+#endif
+
+    std::string reason() const;
+
+private:
+
+    std::string _reason;
+};
+
+}
+
+namespace IceInternal
 {
 
 //
@@ -36,18 +73,18 @@ namespace IceUtil
 //
 //
 template<typename charT>
-class IconvStringConverter : public BasicStringConverter<charT>
+class IconvStringConverter : public IceUtil::BasicStringConverter<charT>
 {
 public:
 
-    IconvStringConverter(const char* = nl_langinfo(CODESET));
+    IconvStringConverter(const std::string&);
 
     virtual ~IconvStringConverter();
 
-    virtual Byte* toUTF8(const charT*, const charT*, UTF8Buffer&) const;
-    
-    virtual void fromUTF8(const Byte*, const Byte*, std::basic_string<charT>&) const;
-    
+    virtual Ice::Byte* toUTF8(const charT*, const charT*, Ice::UTF8Buffer&) const;
+
+    virtual void fromUTF8(const Ice::Byte*, const Ice::Byte*, std::basic_string<charT>&) const;
+
 private:
 
     std::pair<iconv_t, iconv_t> createDescriptors() const;
@@ -72,7 +109,7 @@ extern "C"
 #endif
 
 template<typename charT>
-IconvStringConverter<charT>::IconvStringConverter(const char* internalCode) :
+IconvStringConverter<charT>::IconvStringConverter(const std::string& internalCode) :
     _internalCode(internalCode)
 {
     //
@@ -82,9 +119,9 @@ IconvStringConverter<charT>::IconvStringConverter(const char* internalCode) :
     {
         close(createDescriptors());
     }
-    catch(const IllegalConversionException& sce)
+    catch(const Ice::IllegalConversionException& sce)
     {
-        throw IconvInitializationException(__FILE__, __LINE__, sce.reason());
+        throw Ice::IconvInitializationException(__FILE__, __LINE__, sce.reason());
     }
 
     //
@@ -98,7 +135,7 @@ IconvStringConverter<charT>::IconvStringConverter(const char* internalCode) :
 
     if(rs != 0)
     {
-        throw ThreadSyscallException(__FILE__, __LINE__, rs);
+        throw IceUtil::ThreadSyscallException(__FILE__, __LINE__, rs);
     }
 }
 
@@ -128,16 +165,16 @@ IconvStringConverter<charT>::createDescriptors() const
     {
         std::ostringstream os;
         os << "iconv cannot convert from " << externalCode << " to " << _internalCode;
-        throw IllegalConversionException(__FILE__, __LINE__, os.str());
+        throw Ice::IllegalConversionException(__FILE__, __LINE__, os.str());
     }
-    
+
     cdp.second = iconv_open(externalCode, _internalCode.c_str());
     if(cdp.second == iconv_t(-1))
     {
         iconv_close(cdp.first);
         std::ostringstream os;
         os << "iconv cannot convert from " << _internalCode << " to " << externalCode;
-        throw IllegalConversionException(__FILE__, __LINE__, os.str());
+        throw Ice::IllegalConversionException(__FILE__, __LINE__, os.str());
     }
     return cdp;
 }
@@ -156,7 +193,7 @@ IconvStringConverter<charT>::getDescriptors() const
         int rs = pthread_setspecific(_key, new std::pair<iconv_t, iconv_t>(cdp));
         if(rs != 0)
         {
-            throw ThreadSyscallException(__FILE__, __LINE__, rs);
+            throw IceUtil::ThreadSyscallException(__FILE__, __LINE__, rs);
         }
         return cdp;
     }
@@ -185,12 +222,14 @@ IconvStringConverter<charT>::close(std::pair<iconv_t, iconv_t> cdp)
     iconv_close(cdp.second);
 #endif
 }
- 
-template<typename charT> Byte* 
-IconvStringConverter<charT>::toUTF8(const charT* sourceStart, const charT* sourceEnd, UTF8Buffer& buf) const
-{ 
+
+template<typename charT> Ice::Byte*
+IconvStringConverter<charT>::toUTF8(const charT* sourceStart,
+                                    const charT* sourceEnd,
+                                    Ice::UTF8Buffer& buf) const
+{
     iconv_t cd = getDescriptors().second;
-    
+
     //
     // Reset cd
     //
@@ -208,31 +247,34 @@ IconvStringConverter<charT>::toUTF8(const charT* sourceStart, const charT* sourc
 #endif
     size_t inbytesleft = (sourceEnd - sourceStart) * sizeof(charT);
     char* outbuf  = 0;
-  
-    size_t count = 0; 
+
+    size_t count = 0;
     //
     // Loop while we need more buffer space
     //
     do
     {
         size_t howMany = std::max(inbytesleft, size_t(4));
-        outbuf = reinterpret_cast<char*>(buf.getMoreBytes(howMany, reinterpret_cast<Byte*>(outbuf)));
+        outbuf = reinterpret_cast<char*>(buf.getMoreBytes(howMany,
+                                                          reinterpret_cast<Ice::Byte*>(outbuf)));
         count = iconv(cd, &inbuf, &inbytesleft, &outbuf, &howMany);
     } while(count == size_t(-1) && errno == E2BIG);
 
     if(count == size_t(-1))
     {
-        throw IllegalConversionException(__FILE__, __LINE__, errno != 0 ? strerror(errno) : "Unknown error");
+        throw Ice::IllegalConversionException(__FILE__,
+                                              __LINE__,
+                                              errno != 0 ? strerror(errno) : "Unknown error");
     }
-    return reinterpret_cast<Byte*>(outbuf);
+    return reinterpret_cast<Ice::Byte*>(outbuf);
 }
-  
+
 template<typename charT> void
-IconvStringConverter<charT>::fromUTF8(const Byte* sourceStart, const Byte* sourceEnd,
+IconvStringConverter<charT>::fromUTF8(const Ice::Byte* sourceStart, const Ice::Byte* sourceEnd,
                                       std::basic_string<charT>& target) const
 {
     iconv_t cd = getDescriptors().first;
-    
+
     //
     // Reset cd
     //
@@ -246,19 +288,12 @@ IconvStringConverter<charT>::fromUTF8(const Byte* sourceStart, const Byte* sourc
 #ifdef ICE_CONST_ICONV_INBUF
     const char* inbuf = reinterpret_cast<const char*>(sourceStart);
 #else
-    char* inbuf = reinterpret_cast<char*>(const_cast<Byte*>(sourceStart));
+    char* inbuf = reinterpret_cast<char*>(const_cast<Ice::Byte*>(sourceStart));
 #endif
     size_t inbytesleft = sourceEnd - sourceStart;
 
-    //
-    // Result buffer
-    //
-    char* buf = 0;
-    size_t bufsize = 0;
-
     char* outbuf = 0;
     size_t outbytesleft = 0;
-
     size_t count = 0;
 
     //
@@ -266,37 +301,48 @@ IconvStringConverter<charT>::fromUTF8(const Byte* sourceStart, const Byte* sourc
     //
     do
     {
-        size_t increment = std::max(inbytesleft * sizeof(wchar_t), size_t(8));
-        bufsize += increment;
-        char* newbuf = static_cast<char*>(realloc(buf, bufsize));
-
-        if(newbuf == 0)
+        size_t bytesused = 0;
+        if(outbuf != 0)
         {
-            free(buf);
-            throw IllegalConversionException(__FILE__, __LINE__, "Out of memory");
+            bytesused = outbuf - reinterpret_cast<const char*>(target.data());
         }
 
-        outbuf = newbuf + (outbuf - buf);
-        outbytesleft += increment;
+        const size_t increment = std::max<size_t>(inbytesleft, 4);
+        target.resize(target.size() + increment);
+        outbuf = const_cast<char*>(reinterpret_cast<const char*>(target.data())) + bytesused;
+        outbytesleft += increment * sizeof(charT);
 
-        buf = newbuf;
-        
         count = iconv(cd, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
+
     } while(count == size_t(-1) && errno == E2BIG);
 
     if(count == size_t(-1))
     {
-        free(buf);
-        throw IllegalConversionException(__FILE__, __LINE__, errno != 0 ? strerror(errno) : "Unknown error");
+        throw Ice::IllegalConversionException(__FILE__,
+                                              __LINE__,
+                                              errno != 0 ? strerror(errno) : "Unknown error");
     }
-    
-    size_t length = (bufsize - outbytesleft) / sizeof(charT);
-    
-    std::basic_string<charT> result(reinterpret_cast<charT*>(buf), length);
-    target.swap(result);
-    free(buf);
+
+    target.resize(target.size() - (outbytesleft / sizeof(charT)));
+}
 }
 
+namespace Ice
+{
+template<typename charT>
+ICE_HANDLE<IceUtil::BasicStringConverter<charT> >
+createIconvStringConverter(const std::string& internalCodeWithDefault = "")
+{
+    std::string internalCode = internalCodeWithDefault;
+
+    if(internalCode.empty())
+    {
+        internalCode = nl_langinfo(CODESET);
+    }
+
+    return ICE_MAKE_SHARED(IceInternal::IconvStringConverter<charT>, internalCode);
+}
 }
 
 #endif
+#endif

data/ext/ice/cpp/include/Ice/Incoming.h

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
 //
 // This copy of Ice is licensed to you under the terms described in the
 // ICE_LICENSE file included in this distribution.
@@ -14,7 +14,8 @@
 #include <Ice/ConnectionIF.h>
 #include <Ice/ServantLocatorF.h>
 #include <Ice/ServantManagerF.h>
-#include <Ice/BasicStream.h>
+#include <Ice/OutputStream.h>
+#include <Ice/InputStream.h>
 #include <Ice/Object.h>
 #include <Ice/Current.h>
 #include <Ice/IncomingAsyncF.h>
@@ -23,6 +24,31 @@
 
 #include <deque>
 
+#ifdef ICE_CPP11_MAPPING
+
+namespace Ice
+{
+
+class ICE_API MarshaledResult
+{
+public:
+
+    MarshaledResult(const Current&);
+
+    std::shared_ptr<OutputStream> getOutputStream() const
+    {
+        return ostr;
+    }
+
+protected:
+
+    std::shared_ptr<OutputStream> ostr;
+};
+
+}
+
+#endif
+
 namespace IceInternal
 {
 
@@ -30,37 +56,66 @@ class ICE_API IncomingBase : private IceUtil::noncopyable
 {
 public:
 
-    void __adopt(IncomingBase&);
+    Ice::OutputStream* startWriteParams();
+    void endWriteParams();
+    void writeEmptyParams();
+    void writeParamEncaps(const Ice::Byte*, Ice::Int, bool);
+
+#ifdef ICE_CPP11_MAPPING
+    void setMarshaledResult(const Ice::MarshaledResult&);
+#endif
 
-    BasicStream* __startWriteParams(Ice::FormatType);
-    void __endWriteParams(bool);
-    void __writeEmptyParams();
-    void __writeParamEncaps(const Ice::Byte*, Ice::Int, bool);
-    void __writeUserException(const Ice::UserException&, Ice::FormatType);
+    void response(bool);
+    void exception(const std::exception&, bool);
+    void exception(const std::string&, bool);
+#if defined(_MSC_VER) && (_MSC_VER == 1500)
+    //
+    // COMPILERFIX VC90 get confused with overloads above
+    // when passing a const char* as first argument.
+    //
+    void exception(const char* msg, bool amd)
+    {
+        exception(std::string(msg), amd);
+    }
+#endif
 
 protected:
 
-    IncomingBase(Instance*, ResponseHandler*, Ice::Connection*, const Ice::ObjectAdapterPtr&, bool, Ice::Byte, 
-                 Ice::Int);
-    IncomingBase(IncomingBase&); // Adopts the argument. It must not be used afterwards.
+    IncomingBase(Instance*, ResponseHandler*, Ice::Connection*, const Ice::ObjectAdapterPtr&, bool, Ice::Byte, Ice::Int);
+    IncomingBase(IncomingBase&);
 
-    void __warning(const Ice::Exception&) const;
-    void __warning(const std::string&) const;
+    void warning(const Ice::Exception&) const;
+    void warning(const std::string&) const;
 
-    bool __servantLocatorFinished(bool);
+    bool servantLocatorFinished(bool);
 
-    void __handleException(const std::exception&, bool);
-    void __handleException(bool);
+    void handleException(const std::exception&, bool);
+    void handleException(const std::string&, bool);
+
+#if defined(_MSC_VER) && (_MSC_VER == 1500)
+    //
+    // COMPILERFIX VC90 get confused with overloads above
+    // when passing a const char* as first argument.
+    //
+    void handleException(const char* msg, bool amd)
+    {
+        handleException(std::string(msg), amd);
+    }
+#endif
 
     Ice::Current _current;
     Ice::ObjectPtr _servant;
     Ice::ServantLocatorPtr _locator;
+#ifdef ICE_CPP11_MAPPING
+    ::std::shared_ptr<void> _cookie;
+#else
     Ice::LocalObjectPtr _cookie;
+#endif
     DispatchObserver _observer;
     bool _response;
     Ice::Byte _compress;
-
-    BasicStream _os;
+    Ice::FormatType _format;
+    Ice::OutputStream _os;
 
     //
     // Optimization. The request handler may not be deleted while a
@@ -68,7 +123,13 @@ protected:
     //
     ResponseHandler* _responseHandler;
 
-    std::deque<Ice::DispatchInterceptorAsyncCallbackPtr> _interceptorAsyncCallbackQueue;
+#ifdef ICE_CPP11_MAPPING
+    using DispatchInterceptorCallbacks = std::deque<std::pair<std::function<bool()>,
+                                                              std::function<bool(std::exception_ptr)>>>;
+#else
+    typedef std::deque<Ice::DispatchInterceptorAsyncCallbackPtr> DispatchInterceptorCallbacks;
+#endif
+    DispatchInterceptorCallbacks _interceptorCBs;
 };
 
 class ICE_API Incoming : public IncomingBase
@@ -82,48 +143,63 @@ public:
         return _current;
     }
 
+#ifdef ICE_CPP11_MAPPING
+    void push(std::function<bool()>, std::function<bool(std::exception_ptr)>);
+#else
     void push(const Ice::DispatchInterceptorAsyncCallbackPtr&);
+#endif
     void pop();
+
+    void setAsync(const IncomingAsyncPtr& in)
+    {
+        assert(!_inAsync);
+        _inAsync = in;
+    }
+
     void startOver();
-    void killAsync();
-    void setActive(IncomingAsync&);
-    
-    bool isRetriable()
+
+    void setFormat(Ice::FormatType format)
     {
-        return _inParamPos != 0;
+        _format = format;
     }
 
-    void invoke(const ServantManagerPtr&, BasicStream*);
+    void invoke(const ServantManagerPtr&, Ice::InputStream*);
 
     // Inlined for speed optimization.
-    BasicStream* startReadParams()
+    void skipReadParams()
+    {
+        _current.encoding = _is->skipEncapsulation();
+    }
+    Ice::InputStream* startReadParams()
     {
         //
         // Remember the encoding used by the input parameters, we'll
         // encode the response parameters with the same encoding.
         //
-        _current.encoding = _is->startReadEncaps();
+        _current.encoding = _is->startEncapsulation();
         return _is;
     }
     void endReadParams() const
     {
-        _is->endReadEncaps();
+        _is->endEncapsulation();
     }
     void readEmptyParams()
     {
-        _current.encoding = _is->skipEmptyEncaps();
+        _current.encoding = _is->skipEmptyEncapsulation();
     }
     void readParamEncaps(const Ice::Byte*& v, Ice::Int& sz)
     {
-        _current.encoding = _is->readEncaps(v, sz);
+        _current.encoding = _is->readEncapsulation(v, sz);
     }
 
 private:
 
-    BasicStream* _is;
-    
-    IncomingAsyncPtr _cb;
+    friend class IncomingAsync;
+
+    Ice::InputStream* _is;
     Ice::Byte* _inParamPos;
+
+    IncomingAsyncPtr _inAsync;
 };
 
 }