zeroc-ice 3.6b1

data/ext/ice/cpp/src/Ice/IPEndpointI.h

@@ -0,0 +1,157 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 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_IP_ENDPOINT_I_H
+#define ICE_IP_ENDPOINT_I_H
+
+#include <IceUtil/Config.h>
+#include <IceUtil/Shared.h>
+#include <IceUtil/Thread.h>
+#include <IceUtil/Monitor.h>
+#include <Ice/IPEndpointIF.h>
+#include <Ice/EndpointI.h>
+#include <Ice/Network.h>
+#include <Ice/ProtocolInstanceF.h>
+#include <Ice/ObserverHelper.h>
+
+#ifndef ICE_OS_WINRT
+#   include <deque>
+#endif
+
+namespace IceInternal
+{
+
+class ICE_API IPEndpointInfoI : public Ice::IPEndpointInfo
+{
+public:
+
+    IPEndpointInfoI(const EndpointIPtr&);
+    virtual ~IPEndpointInfoI();
+
+    virtual Ice::Short type() const;
+    virtual bool datagram() const;
+    virtual bool secure() const;
+
+private:
+
+    const EndpointIPtr _endpoint;
+};
+
+class ICE_API IPEndpointI : public EndpointI
+{
+public:
+
+    virtual Ice::EndpointInfoPtr getInfo() const;
+    virtual Ice::Short type() const;
+    virtual const std::string& protocol() const;
+    virtual void streamWrite(BasicStream*) const;
+
+    virtual const std::string& connectionId() const;
+    virtual EndpointIPtr connectionId(const ::std::string&) const;
+
+    virtual void connectors_async(Ice::EndpointSelectionType, const EndpointI_connectorsPtr&) const;
+    virtual std::vector<EndpointIPtr> expand() const;
+    virtual bool equivalent(const EndpointIPtr&) const;
+    virtual ::Ice::Int hash() const;
+    virtual std::string options() const;
+
+    virtual bool operator==(const Ice::LocalObject&) const;
+    virtual bool operator<(const Ice::LocalObject&) const;
+
+    virtual std::vector<ConnectorPtr> connectors(const std::vector<Address>&, const NetworkProxyPtr&) const;
+    const std::string& host() const;
+    int port() const;
+
+    virtual void streamWriteImpl(BasicStream*) const;
+    virtual void hashInit(Ice::Int&) const;
+    virtual void fillEndpointInfo(Ice::IPEndpointInfo*) const;
+
+    using EndpointI::connectionId;
+
+    virtual void initWithOptions(std::vector<std::string>&, bool);
+
+protected:
+
+    friend class EndpointHostResolver;
+
+    virtual bool checkOption(const std::string&, const std::string&, const std::string&);
+
+    virtual ConnectorPtr createConnector(const Address& address, const NetworkProxyPtr&) const = 0;
+    virtual IPEndpointIPtr createEndpoint(const std::string&, int, const std::string&) const = 0;
+
+    IPEndpointI(const ProtocolInstancePtr&, const std::string&, int, const Address&, const std::string&);
+    IPEndpointI(const ProtocolInstancePtr&);
+    IPEndpointI(const ProtocolInstancePtr&, BasicStream*);
+
+    const ProtocolInstancePtr _instance;
+    const std::string _host;
+    const int _port;
+    const Address _sourceAddr;
+    const std::string _connectionId;
+
+private:
+
+    mutable bool _hashInitialized;
+    mutable Ice::Int _hashValue;
+};
+
+#ifndef ICE_OS_WINRT
+class ICE_API EndpointHostResolver : public IceUtil::Thread, public IceUtil::Monitor<IceUtil::Mutex>
+#else
+class ICE_API EndpointHostResolver : public IceUtil::Shared
+#endif
+{
+public:
+
+    EndpointHostResolver(const InstancePtr&);
+
+    void resolve(const std::string&, int, Ice::EndpointSelectionType, const IPEndpointIPtr&,
+                 const EndpointI_connectorsPtr&);
+    void destroy();
+
+    virtual void run();
+    void updateObserver();
+
+private:
+
+#ifndef ICE_OS_WINRT
+    struct ResolveEntry
+    {
+        std::string host;
+        int port;
+        Ice::EndpointSelectionType selType;
+        IPEndpointIPtr endpoint;
+        EndpointI_connectorsPtr callback;
+        Ice::Instrumentation::ObserverPtr observer;
+    };
+
+    const InstancePtr _instance;
+    const IceInternal::ProtocolSupport _protocol;
+    const bool _preferIPv6;
+    bool _destroyed;
+    std::deque<ResolveEntry> _queue;
+    ObserverHelperT<Ice::Instrumentation::ThreadObserver> _observer;
+#else
+    const InstancePtr _instance;
+#endif
+};
+
+inline bool operator==(const IPEndpointI& l, const IPEndpointI& r)
+{
+    return static_cast<const ::Ice::LocalObject&>(l) == static_cast<const ::Ice::LocalObject&>(r);
+}
+
+inline bool operator<(const IPEndpointI& l, const IPEndpointI& r)
+{
+    return static_cast<const ::Ice::LocalObject&>(l) < static_cast<const ::Ice::LocalObject&>(r);
+}
+
+}
+
+#endif

data/ext/ice/cpp/src/Ice/IPEndpointIF.h

@@ -0,0 +1,29 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 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_IP_ENDPOINT_I_F_H
+#define ICE_IP_ENDPOINT_I_F_H
+
+#include <IceUtil/Shared.h>
+#include <Ice/Handle.h>
+
+namespace IceInternal
+{
+
+class IPEndpointI;
+ICE_API IceUtil::Shared* upCast(IPEndpointI*);
+typedef Handle<IPEndpointI> IPEndpointIPtr;
+
+class EndpointHostResolver;
+ICE_API IceUtil::Shared* upCast(EndpointHostResolver*);
+typedef Handle<EndpointHostResolver> EndpointHostResolverPtr;
+
+}
+
+#endif

data/ext/ice/cpp/src/Ice/Identity.cpp

@@ -0,0 +1,42 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 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.
+//
+// **********************************************************************
+//
+// Ice version 3.6b
+//
+// <auto-generated>
+//
+// Generated from file `Identity.ice'
+//
+// Warning: do not edit this file.
+//
+// </auto-generated>
+//
+
+#ifndef ICE_API_EXPORTS
+#   define ICE_API_EXPORTS
+#endif
+#include <Ice/Identity.h>
+#include <IceUtil/PushDisableWarnings.h>
+#include <Ice/BasicStream.h>
+#include <IceUtil/Iterator.h>
+#include <IceUtil/PopDisableWarnings.h>
+
+#ifndef ICE_IGNORE_VERSION
+#   if ICE_INT_VERSION  != 30651
+#       error Ice version mismatch: an exact match is required for beta generated code
+#   endif
+#endif
+
+namespace Ice
+{
+#ifdef ICE_HAS_DECLSPEC_IMPORT_EXPORT
+template struct ICE_API StreamWriter< ::Ice::Identity, ::IceInternal::BasicStream>;
+template struct ICE_API StreamReader< ::Ice::Identity, ::IceInternal::BasicStream>;
+#endif
+}

data/ext/ice/cpp/src/Ice/ImplicitContext.cpp

@@ -0,0 +1,41 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 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.
+//
+// **********************************************************************
+//
+// Ice version 3.6b
+//
+// <auto-generated>
+//
+// Generated from file `ImplicitContext.ice'
+//
+// Warning: do not edit this file.
+//
+// </auto-generated>
+//
+
+#ifndef ICE_API_EXPORTS
+#   define ICE_API_EXPORTS
+#endif
+#include <Ice/ImplicitContext.h>
+#include <IceUtil/PushDisableWarnings.h>
+#include <Ice/BasicStream.h>
+#include <IceUtil/Iterator.h>
+#include <IceUtil/PopDisableWarnings.h>
+
+#ifndef ICE_IGNORE_VERSION
+#   if ICE_INT_VERSION  != 30651
+#       error Ice version mismatch: an exact match is required for beta generated code
+#   endif
+#endif
+
+namespace
+{
+
+}
+
+ICE_DECLSPEC_EXPORT ::Ice::LocalObject* Ice::upCast(::Ice::ImplicitContext* p) { return p; }

data/ext/ice/cpp/src/Ice/ImplicitContextF.cpp

@@ -0,0 +1,38 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 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.
+//
+// **********************************************************************
+//
+// Ice version 3.6b
+//
+// <auto-generated>
+//
+// Generated from file `ImplicitContextF.ice'
+//
+// Warning: do not edit this file.
+//
+// </auto-generated>
+//
+
+#ifndef ICE_API_EXPORTS
+#   define ICE_API_EXPORTS
+#endif
+#include <Ice/ImplicitContextF.h>
+#include <IceUtil/PushDisableWarnings.h>
+#include <IceUtil/Iterator.h>
+#include <IceUtil/PopDisableWarnings.h>
+
+#ifndef ICE_IGNORE_VERSION
+#   if ICE_INT_VERSION  != 30651
+#       error Ice version mismatch: an exact match is required for beta generated code
+#   endif
+#endif
+
+namespace
+{
+
+}

data/ext/ice/cpp/src/Ice/ImplicitContextI.cpp

@@ -0,0 +1,639 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 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.
+//
+// **********************************************************************
+
+#include <Ice/ImplicitContextI.h>
+#include <Ice/BasicStream.h>
+#include <Ice/Object.h>
+#include <IceUtil/Mutex.h>
+#include <IceUtil/MutexPtrLock.h>
+
+using namespace std;
+using namespace Ice;
+
+namespace
+{
+
+class SharedImplicitContext : public ImplicitContextI
+{
+public:
+    
+    virtual Context getContext() const;
+    virtual void setContext(const Context&);
+
+    virtual bool containsKey(const string&) const;
+    virtual string get(const string&) const;
+    virtual string put(const string&, const string&);
+    virtual string remove(const string&);
+
+    virtual void write(const Context&, ::IceInternal::BasicStream*) const;
+    virtual void combine(const Context&, Context&) const;
+
+private:
+    Context _context;
+    IceUtil::Mutex _mutex;
+};
+
+#ifndef ICE_OS_WINRT
+class PerThreadImplicitContext : public ImplicitContextI
+{
+public:
+    
+    PerThreadImplicitContext();
+    virtual ~PerThreadImplicitContext();
+
+    virtual Context getContext() const;
+    virtual void setContext(const Context&);
+
+    virtual bool containsKey(const string&) const;
+    virtual string get(const string&) const;
+    virtual string put(const string&, const string&);
+    virtual string remove(const string&);
+
+    virtual void write(const Context&, ::IceInternal::BasicStream*) const;
+    virtual void combine(const Context&, Context&) const;
+
+    struct Slot
+    {
+        Slot() :
+            context(0),
+            owner(-1) // just to avoid UMR; a random value would work as well
+        {
+        }
+
+        Context* context;
+        long owner;
+    };
+
+
+    //
+    // Each thread maintains a SlotVector. Each PerThreadImplicitContext instance
+    // is assigned a slot in this vector.
+    //
+    typedef std::vector<Slot> SlotVector;
+    
+    //
+    // We remember which slot-indices are in use (to be able to reuse indices)
+    //
+    typedef std::vector<bool> IndexInUse;
+    static IndexInUse* _indexInUse;
+    static IceUtil::Mutex* _mutex;
+
+    static long _nextId;
+
+#ifdef _WIN32
+    static DWORD _key;
+#else
+    static pthread_key_t _key;
+#endif    
+
+private:
+
+    Context* getThreadContext(bool) const;
+    void clearThreadContext() const;
+
+    size_t _index; // index in all SlotVector
+    long _id; // corresponds to owner in the Slot
+};
+#endif
+}
+
+extern "C" void iceImplicitContextThreadDestructor(void*);
+
+
+
+/*static*/ ImplicitContextI*
+ImplicitContextI::create(const std::string& kind)
+{
+    if(kind == "None" || kind == "")
+    {
+        return 0;
+    }
+    else if(kind == "Shared")
+    {
+        return new SharedImplicitContext;
+    }
+    else if(kind == "PerThread")
+    {
+#ifndef ICE_OS_WINRT
+        return new PerThreadImplicitContext;
+#else
+        throw InitializationException(__FILE__, __LINE__, 
+                                      "'PerThread' Ice.ImplicitContext isn't supported for WinRT.");
+        return 0; // Keep the compiler happy.
+#endif
+    }
+    else
+    {
+        throw Ice::InitializationException(
+            __FILE__, __LINE__,
+            "'" + kind + "' is not a valid value for Ice.ImplicitContext"); 
+        return 0; // Keep the compiler happy.
+    }
+}
+
+#if defined(_WIN32) && !defined(ICE_OS_WINRT)
+void
+ImplicitContextI::cleanupThread()
+{
+    if(PerThreadImplicitContext::_nextId > 0)
+    {
+        iceImplicitContextThreadDestructor(TlsGetValue(PerThreadImplicitContext::_key));
+    } 
+}
+#endif
+
+
+//
+// SharedImplicitContext implementation
+//
+
+Context
+SharedImplicitContext::getContext() const
+{
+    IceUtil::Mutex::Lock lock(_mutex);
+    return _context;
+}
+
+void
+SharedImplicitContext::setContext(const Context& newContext)
+{
+    IceUtil::Mutex::Lock lock(_mutex);
+    _context = newContext;
+}
+
+bool 
+SharedImplicitContext::containsKey(const string& k) const
+{
+    IceUtil::Mutex::Lock lock(_mutex);
+    Context::const_iterator p = _context.find(k);
+    return p != _context.end();
+}
+
+string 
+SharedImplicitContext::get(const string& k) const
+{
+    IceUtil::Mutex::Lock lock(_mutex);
+    Context::const_iterator p = _context.find(k);
+    if(p == _context.end())
+    {
+        return "";
+    }
+    return p->second;
+}
+
+
+string 
+SharedImplicitContext::put(const string& k, const string& v)
+{
+    IceUtil::Mutex::Lock lock(_mutex);
+    string& val = _context[k];
+    
+    string oldVal = val;
+    val = v;
+    return oldVal;
+}
+
+string
+SharedImplicitContext::remove(const string& k)
+{
+    IceUtil::Mutex::Lock lock(_mutex);
+    Context::iterator p = _context.find(k);
+    if(p == _context.end())
+    {
+        return "";
+    }
+    else
+    {
+        string oldVal = p->second;
+        _context.erase(p);
+        return oldVal;
+    }
+}
+
+void 
+SharedImplicitContext::write(const Context& proxyCtx, ::IceInternal::BasicStream* s) const
+{
+    IceUtil::Mutex::Lock lock(_mutex);
+    if(proxyCtx.size() == 0)
+    {
+        s->write(_context);
+    }
+    else if(_context.size() == 0)
+    {
+        lock.release();
+        s->write(proxyCtx);
+    }
+    else
+    {
+        Context combined = proxyCtx;
+        combined.insert(_context.begin(), _context.end());
+        lock.release();
+        s->write(combined);
+    }
+}
+
+void 
+SharedImplicitContext::combine(const Context& proxyCtx, Context& ctx) const
+{
+    IceUtil::Mutex::Lock lock(_mutex);
+    if(proxyCtx.size() == 0)
+    {
+        ctx = _context;
+    }
+    else if(_context.size() == 0)
+    {
+        ctx = proxyCtx;
+    }
+    else
+    {
+        ctx = proxyCtx;
+        ctx.insert(_context.begin(), _context.end());
+    }
+}
+
+//
+// PerThreadImplicitContext implementation
+//
+#ifndef ICE_OS_WINRT
+long PerThreadImplicitContext::_nextId;
+PerThreadImplicitContext::IndexInUse* PerThreadImplicitContext::_indexInUse;
+IceUtil::Mutex* PerThreadImplicitContext::_mutex = 0;
+
+namespace
+{
+
+class Init
+{
+public:
+
+    Init()
+    {
+        PerThreadImplicitContext::_mutex = new IceUtil::Mutex;
+    }
+
+    ~Init()
+    {
+        delete PerThreadImplicitContext::_mutex;
+        PerThreadImplicitContext::_mutex = 0;
+    }
+};
+
+Init init;
+
+}
+
+#   ifdef _WIN32
+DWORD PerThreadImplicitContext::_key;
+#   else
+pthread_key_t PerThreadImplicitContext::_key;
+#   endif
+
+PerThreadImplicitContext::PerThreadImplicitContext()
+{
+    IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(_mutex);
+    _id = _nextId++;
+    if(_id == 0)
+    {
+        //
+        // Initialize; note that we never dealloc this key (it would be
+        // complex, and since it's a static variable, it's not really a leak)
+        //
+#   ifdef _WIN32
+        _key = TlsAlloc();
+        if(_key == TLS_OUT_OF_INDEXES)
+        {
+            throw IceUtil::ThreadSyscallException(__FILE__, __LINE__, GetLastError());
+        }
+#   else
+        int err = pthread_key_create(&_key, &iceImplicitContextThreadDestructor);
+        if(err != 0)
+        {
+            throw IceUtil::ThreadSyscallException(__FILE__, __LINE__, err);
+        }
+#   endif
+    }
+    
+    //
+    // Now grabs an index
+    //
+    if(_indexInUse == 0)
+    {
+        _indexInUse = new IndexInUse(1);
+    }
+    size_t i = 0;
+    while(i < _indexInUse->size() && (*_indexInUse)[i])
+    {
+        i++;
+    }
+
+    if(i == _indexInUse->size())
+    {
+        _indexInUse->resize(i + 1);
+    }
+    (*_indexInUse)[i] = true;
+    _index = i;
+}
+
+PerThreadImplicitContext::~PerThreadImplicitContext()
+{
+    IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(_mutex);
+    (*_indexInUse)[_index] = false;
+
+    if(find(_indexInUse->begin(), _indexInUse->end(), true) == _indexInUse->end())
+    {
+        delete _indexInUse;
+        _indexInUse = 0;
+    }
+}
+
+Context*
+PerThreadImplicitContext::getThreadContext(bool allocate) const
+{
+#   ifdef _WIN32
+    SlotVector* sv = static_cast<SlotVector*>(TlsGetValue(_key));
+#   else
+    SlotVector* sv = static_cast<SlotVector*>(pthread_getspecific(_key));
+#   endif
+    if(sv == 0)
+    {
+        if(!allocate)
+        {
+            return 0;
+        }
+
+        sv = new SlotVector(_index + 1);
+#   ifdef _WIN32
+
+        if(TlsSetValue(_key, sv) == 0)
+        {
+            throw IceUtil::ThreadSyscallException(__FILE__, __LINE__, GetLastError());
+        }
+#   else
+        if(int err = pthread_setspecific(_key, sv))
+        {
+            throw IceUtil::ThreadSyscallException(__FILE__, __LINE__, err);
+        }
+#   endif
+    }
+    else
+    {
+        if(sv->size() <= _index)
+        {
+            if(!allocate)
+            {
+                return 0;
+            }
+            else
+            {
+                sv->resize(_index + 1);
+            }
+        }
+    }
+
+    Slot& slot = (*sv)[_index];
+    if(slot.context != 0)
+    {
+        if(slot.owner != _id)
+        {
+            //
+            // Reuse the slot from another (dead) communicator
+            //
+            slot.context->clear();
+            slot.owner = _id;
+        }
+        //
+        // else keep this slot.context
+        //
+    }
+    else
+    {
+        if(allocate)
+        {
+            slot.context = new Context;
+            slot.owner = _id;
+        }
+        //
+        // else keep null slot.context
+        //
+    }
+    return slot.context;
+}
+
+void
+PerThreadImplicitContext::clearThreadContext() const
+{
+#   ifdef _WIN32
+    SlotVector* sv = static_cast<SlotVector*>(TlsGetValue(_key));
+#   else
+    SlotVector* sv = static_cast<SlotVector*>(pthread_getspecific(_key));
+#   endif
+    if(sv != 0 && _index < sv->size())
+    {
+        delete (*sv)[_index].context;
+        (*sv)[_index].context = 0;
+
+        //
+        // Trim tailing empty contexts.
+        //
+        size_t i = sv->size();
+
+        bool clear = true;
+        while(i != 0) 
+        {
+            i--;
+            if((*sv)[i].context != 0)
+            {
+                clear = false;
+                break;
+            }
+        }
+
+        //
+        // If we did not find any contexts, delete the SlotVector.
+        //
+        if(clear)
+        {
+            delete sv;
+#   ifdef _WIN32
+            if(TlsSetValue(_key, 0) == 0)
+            {
+                IceUtil::ThreadSyscallException(__FILE__, __LINE__, GetLastError());
+            }
+#   else
+            if(int err = pthread_setspecific(_key, 0))
+            {
+                throw IceUtil::ThreadSyscallException(__FILE__, __LINE__, err);
+            }
+#   endif
+        }
+        else
+        {
+            sv->resize(i + 1);
+        }
+    }
+}
+
+
+Context
+PerThreadImplicitContext::getContext() const
+{
+    Context* ctx = getThreadContext(false);
+    if(ctx == 0)
+    {
+        return Context();
+    }
+    else
+    {
+        return *ctx;
+    }
+}
+
+void
+PerThreadImplicitContext::setContext(const Context& newContext)
+{
+    if(newContext.size() == 0)
+    {
+        clearThreadContext();
+    }
+    else
+    {
+        Context* ctx = getThreadContext(true);
+        assert(ctx != 0);
+        *ctx = newContext;
+    }
+}
+
+bool 
+PerThreadImplicitContext::containsKey(const string& k) const
+{
+    const Context* ctx = getThreadContext(false);
+    if(ctx == 0)
+    {
+        return false;
+    }
+    Context::const_iterator p = ctx->find(k);
+    return p != ctx->end();
+}
+
+string 
+PerThreadImplicitContext::get(const string& k) const
+{
+    const Context* ctx = getThreadContext(false);
+    if(ctx == 0)
+    {
+        return "";
+    }
+    Context::const_iterator p = ctx->find(k);
+    if(p == ctx->end())
+    {
+        return "";
+    }
+    return p->second;
+}
+
+string 
+PerThreadImplicitContext::put(const string& k, const string& v)
+{
+    Context* ctx = getThreadContext(true);
+
+    string& val = (*ctx)[k];
+    
+    string oldVal = val;
+    val = v;
+    return oldVal;
+}
+
+string
+PerThreadImplicitContext::remove(const string& k)
+{
+     Context* ctx = getThreadContext(false);
+     if(ctx == 0)
+     {
+         return "";
+     }
+     
+     Context::iterator p = ctx->find(k);
+     if(p == ctx->end())
+     {
+         return "";
+     }
+     else
+     {
+         string oldVal = p->second;
+         ctx->erase(p);
+
+         if(ctx->size() == 0)
+         {
+             clearThreadContext();
+         }
+         return oldVal;
+    }
+}
+
+void 
+PerThreadImplicitContext::write(const Context& proxyCtx, ::IceInternal::BasicStream* s) const
+{
+    const Context* threadCtx = getThreadContext(false);
+
+    if(threadCtx == 0 || threadCtx->size() == 0)
+    {
+        s->write(proxyCtx);
+    }
+    else if(proxyCtx.size() == 0)
+    {
+        s->write(*threadCtx);
+    }
+    else
+    {
+        Context combined = proxyCtx;
+        combined.insert(threadCtx->begin(), threadCtx->end());
+        s->write(combined);
+    }
+}
+
+void 
+PerThreadImplicitContext::combine(const Context& proxyCtx, Context& ctx) const
+{
+    const Context* threadCtx = getThreadContext(false);
+
+    if(threadCtx == 0 || threadCtx->size() == 0)
+    {
+        ctx = proxyCtx;
+    }
+    else if(proxyCtx.size() == 0)
+    {
+        ctx = *threadCtx;
+    }
+    else
+    {
+        ctx = proxyCtx;
+        ctx.insert(threadCtx->begin(), threadCtx->end());
+    }
+}
+
+extern "C" void iceImplicitContextThreadDestructor(void* v)
+{
+    PerThreadImplicitContext::SlotVector* sv = static_cast<PerThreadImplicitContext::SlotVector*>(v);
+    if(sv != 0)
+    {
+        //
+        // Cleanup each slot
+        //
+        for(PerThreadImplicitContext::SlotVector::iterator p = sv->begin(); p != sv->end(); ++p)
+        {
+            delete p->context;
+        }
+        //
+        // Then the vector
+        //
+        delete sv;
+    }
+}
+
+#endif