zeroc-ice 3.6b1

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

@@ -0,0 +1,44 @@
+// **********************************************************************
+//
+// 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_ENDPOINT_FACTORY_H
+#define ICE_ENDPOINT_FACTORY_H
+
+#include <IceUtil/Shared.h>
+#include <Ice/EndpointIF.h>
+#include <Ice/EndpointFactoryF.h>
+#include <Ice/ProtocolInstanceF.h>
+
+namespace IceInternal
+{
+
+class BasicStream;
+
+class ICE_API EndpointFactory : public ::IceUtil::Shared
+{
+public:
+
+    virtual ~EndpointFactory();
+
+    virtual ::Ice::Short type() const = 0;
+    virtual ::std::string protocol() const = 0;
+    virtual EndpointIPtr create(std::vector<std::string>&, bool) const = 0;
+    virtual EndpointIPtr read(BasicStream*) const = 0;
+    virtual void destroy() = 0;
+
+    virtual EndpointFactoryPtr clone(const ProtocolInstancePtr&) const = 0;
+
+protected:
+
+    EndpointFactory();
+};
+
+}
+
+#endif

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

@@ -0,0 +1,26 @@
+// **********************************************************************
+//
+// 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_ENDPOINT_FACTORY_F_H
+#define ICE_ENDPOINT_FACTORY_F_H
+
+#include <IceUtil/Shared.h>
+
+#include <Ice/Handle.h>
+
+namespace IceInternal
+{
+
+class EndpointFactory;
+ICE_API IceUtil::Shared* upCast(EndpointFactory*);
+typedef Handle<EndpointFactory> EndpointFactoryPtr;
+
+}
+
+#endif

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

@@ -0,0 +1,208 @@
+// **********************************************************************
+//
+// 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/EndpointFactoryManager.h>
+#include <Ice/Endpoint.h>
+#include <Ice/OpaqueEndpointI.h>
+#include <Ice/BasicStream.h>
+#include <Ice/LocalException.h>
+#include <Ice/Instance.h>
+#include <Ice/Properties.h>
+#include <Ice/DefaultsAndOverrides.h>
+#include <IceUtil/StringUtil.h>
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+
+IceUtil::Shared* IceInternal::upCast(EndpointFactoryManager* p) { return p; }
+
+IceInternal::EndpointFactoryManager::EndpointFactoryManager(const InstancePtr& instance)
+    : _instance(instance)
+{
+}
+
+void
+IceInternal::EndpointFactoryManager::add(const EndpointFactoryPtr& factory)
+{
+    IceUtil::Mutex::Lock sync(*this); // TODO: Necessary?
+
+    //
+    // TODO: Optimize with a map?
+    //
+    for(vector<EndpointFactoryPtr>::size_type i = 0; i < _factories.size(); i++)
+    {
+        if(_factories[i]->type() == factory->type())
+        {
+            assert(false); // TODO: Exception?
+        }
+    }
+    _factories.push_back(factory);
+}
+
+EndpointFactoryPtr
+IceInternal::EndpointFactoryManager::get(Short type) const
+{
+    IceUtil::Mutex::Lock sync(*this); // TODO: Necessary?
+
+    //
+    // TODO: Optimize with a map?
+    //
+    for(vector<EndpointFactoryPtr>::size_type i = 0; i < _factories.size(); i++)
+    {
+        if(_factories[i]->type() == type)
+        {
+            return _factories[i];
+        }
+    }
+    return 0;
+}
+
+EndpointIPtr
+IceInternal::EndpointFactoryManager::create(const string& str, bool oaEndpoint) const
+{
+    vector<string> v;
+    bool b = IceUtilInternal::splitString(str, " \t\n\r", v);
+    if(!b)
+    {
+        EndpointParseException ex(__FILE__, __LINE__);
+        ex.str = "mismatched quote";
+        throw ex;
+    }
+
+    if(v.empty())
+    {
+        EndpointParseException ex(__FILE__, __LINE__);
+        ex.str = "value has no non-whitespace characters";
+        throw ex;
+    }
+
+    string protocol = v.front();
+    v.erase(v.begin());
+
+    if(protocol == "default")
+    {
+        protocol = _instance->defaultsAndOverrides()->defaultProtocol;
+    }
+
+    EndpointFactoryPtr factory;
+    {
+        IceUtil::Mutex::Lock sync(*this); // TODO: Necessary?
+
+        //
+        // TODO: Optimize with a map?
+        //
+        for(vector<EndpointFactoryPtr>::size_type i = 0; i < _factories.size(); i++)
+        {
+            if(_factories[i]->protocol() == protocol)
+            {
+                factory = _factories[i];
+            }
+        }
+    }
+
+    if(factory)
+    {
+#if 1
+        EndpointIPtr e = factory->create(v, oaEndpoint);
+        if(!v.empty())
+        {
+            EndpointParseException ex(__FILE__, __LINE__);
+            ex.str = "unrecognized argument `" + v.front() + "' in endpoint `" + str + "'";
+            throw ex;
+        }
+        return e;
+#else
+        // Code below left in place for debugging.
+
+        EndpointIPtr e = factory->create(str.substr(end), oaEndpoint);
+        BasicStream bs(_instance.get(), Ice::currentProtocolEncoding);
+        e->streamWrite(&bs);
+        bs.i = bs.b.begin();
+        short type;
+        bs.read(type);
+        EndpointIPtr ue = new IceInternal::OpaqueEndpointI(type, &bs);
+        cerr << "Normal: " << e->toString() << endl;
+        cerr << "Opaque: " << ue->toString() << endl;
+        return e;
+#endif
+    }
+
+    //
+    // If the stringified endpoint is opaque, create an unknown endpoint,
+    // then see whether the type matches one of the known endpoints.
+    //
+    if(protocol == "opaque")
+    {
+        EndpointIPtr ue = new OpaqueEndpointI(v);
+        if(!v.empty())
+        {
+            EndpointParseException ex(__FILE__, __LINE__);
+            ex.str = "unrecognized argument `" + v.front() + "' in endpoint `" + str + "'";
+            throw ex;
+        }
+        factory = get(ue->type());
+        if(factory)
+        {
+            //
+            // Make a temporary stream, write the opaque endpoint data into the stream,
+            // and ask the factory to read the endpoint data from that stream to create
+            // the actual endpoint.
+            //
+            BasicStream bs(_instance.get(), Ice::currentProtocolEncoding);
+            bs.write(ue->type());
+            ue->streamWrite(&bs);
+            bs.i = bs.b.begin();
+            short type;
+            bs.read(type);
+            bs.startReadEncaps();
+            EndpointIPtr e = factory->read(&bs);
+            bs.endReadEncaps();
+            return e;
+        }
+        return ue; // Endpoint is opaque, but we don't have a factory for its type.
+    }
+
+    return 0;
+}
+
+EndpointIPtr
+IceInternal::EndpointFactoryManager::read(BasicStream* s) const
+{
+    Short type;
+    s->read(type);
+
+    EndpointFactoryPtr factory = get(type);
+    EndpointIPtr e;
+
+    s->startReadEncaps();
+
+    if(factory)
+    {
+        e = factory->read(s);
+    }
+    else
+    {
+        e = new OpaqueEndpointI(type, s);
+    }
+
+    s->endReadEncaps();
+
+    return e;
+}
+
+void
+IceInternal::EndpointFactoryManager::destroy()
+{
+    for(vector<EndpointFactoryPtr>::size_type i = 0; i < _factories.size(); i++)
+    {
+        _factories[i]->destroy();
+    }
+    _factories.clear();
+}

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

@@ -0,0 +1,46 @@
+// **********************************************************************
+//
+// 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_ENDPOINT_FACTORY_MANAGER_H
+#define ICE_ENDPOINT_FACTORY_MANAGER_H
+
+#include <IceUtil/Shared.h>
+#include <IceUtil/Mutex.h>
+#include <Ice/InstanceF.h>
+#include <Ice/EndpointIF.h>
+#include <Ice/EndpointFactoryF.h>
+#include <Ice/EndpointFactoryManagerF.h>
+
+namespace IceInternal
+{
+
+class BasicStream;
+
+class EndpointFactoryManager : public ::IceUtil::Shared, public ::IceUtil::Mutex
+{
+public:
+
+    void add(const EndpointFactoryPtr&);
+    EndpointFactoryPtr get(::Ice::Short) const;
+    EndpointIPtr create(const std::string&, bool) const;
+    EndpointIPtr read(BasicStream*) const;
+
+private:
+
+    EndpointFactoryManager(const InstancePtr&);
+    void destroy();
+    friend class Instance;
+
+    InstancePtr _instance;
+    std::vector<EndpointFactoryPtr> _factories;
+};
+
+}
+
+#endif

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

@@ -0,0 +1,26 @@
+// **********************************************************************
+//
+// 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_ENDPOINT_FACTORY_MANAGER_F_H
+#define ICE_ENDPOINT_FACTORY_MANAGER_F_H
+
+#include <IceUtil/Shared.h>
+
+#include <Ice/Handle.h>
+
+namespace IceInternal
+{
+
+class EndpointFactoryManager;
+IceUtil::Shared* upCast(EndpointFactoryManager*);
+typedef Handle<EndpointFactoryManager> EndpointFactoryManagerPtr;
+
+}
+
+#endif

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

@@ -0,0 +1,87 @@
+// **********************************************************************
+//
+// 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/EndpointI.h>
+
+using namespace std;
+
+IceUtil::Shared* IceInternal::upCast(EndpointI* p) { return p; }
+IceUtil::Shared* IceInternal::upCast(EndpointI_connectors* p) { return p; }
+
+string
+IceInternal::EndpointI::toString() const
+{
+    //
+    // WARNING: Certain features, such as proxy validation in Glacier2,
+    // depend on the format of proxy strings. Changes to toString() and
+    // methods called to generate parts of the reference string could break
+    // these features. Please review for all features that depend on the
+    // format of proxyToString() before changing this and related code.
+    //
+    return protocol() + options();
+}
+
+void
+IceInternal::EndpointI::initWithOptions(vector<string>& args)
+{
+    vector<string> unknown;
+
+    ostringstream ostr;
+    ostr << '`' << protocol() << " ";
+    for(vector<string>::iterator p = args.begin(); p != args.end(); ++p)
+    {
+        if(p->find_first_of(" \t\n\r") != string::npos)
+        {
+            ostr << " \"" << *p << "\"";
+        }
+        else
+        {
+            ostr << " " << *p;
+        }
+    }
+    ostr << "'";
+    const string str = ostr.str();
+
+    for(vector<string>::size_type n = 0; n < args.size(); ++n)
+    {
+        string option = args[n];
+        if(option.length() < 2 || option[0] != '-')
+        {
+            unknown.push_back(option);
+            continue;
+        }
+
+        string argument;
+        if(n + 1 < args.size() && args[n + 1][0] != '-')
+        {
+            argument = args[++n];
+        }
+
+        if(!checkOption(option, argument, str))
+        {
+            unknown.push_back(option);
+            if(!argument.empty())
+            {
+                unknown.push_back(argument);
+            }
+        }
+    }
+
+    //
+    // Replace argument vector with only those we didn't recognize.
+    //
+    args = unknown;
+}
+
+bool
+IceInternal::EndpointI::checkOption(const string&, const string&, const string&)
+{
+    // Must be overriden to check for options.
+    return false;
+}

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

@@ -0,0 +1,165 @@
+// **********************************************************************
+//
+// 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_ENDPOINT_I_H
+#define ICE_ENDPOINT_I_H
+
+#include <Ice/EndpointIF.h>
+#include <Ice/Endpoint.h>
+#include <Ice/EndpointTypes.h>
+#include <Ice/TransceiverF.h>
+#include <Ice/ConnectorF.h>
+#include <Ice/AcceptorF.h>
+
+namespace IceInternal
+{
+
+class BasicStream;
+
+class ICE_API EndpointI_connectors : public virtual IceUtil::Shared
+{
+public:
+
+    virtual ~EndpointI_connectors() { }
+
+    virtual void connectors(const std::vector<ConnectorPtr>&) = 0;
+    virtual void exception(const Ice::LocalException&) = 0;
+};
+
+class ICE_API EndpointI : public Ice::Endpoint
+{
+public:
+
+    //
+    // Marshal the endpoint.
+    //
+    virtual void streamWrite(BasicStream*) const = 0;
+
+    //
+    // Return the endpoint type.
+    //
+    virtual Ice::Short type() const = 0;
+
+    //
+    // Return the protocol name
+    //
+    virtual const std::string& protocol() const = 0;
+
+    //
+    // Return the timeout for the endpoint in milliseconds. 0 means
+    // non-blocking, -1 means no timeout.
+    //
+    virtual Ice::Int timeout() const = 0;
+
+    //
+    // Return a new endpoint with a different timeout value, provided
+    // that timeouts are supported by the endpoint. Otherwise the same
+    // endpoint is returned.
+    //
+    virtual EndpointIPtr timeout(Ice::Int) const = 0;
+
+    //
+    // Returns the endpoint connection id.
+    //
+    virtual const std::string& connectionId() const = 0;
+
+    //
+    // Return a new endpoint with a different connection id.
+    //
+    virtual EndpointIPtr connectionId(const ::std::string&) const = 0;
+
+    //
+    // Return true if the endpoints support bzip2 compress, or false
+    // otherwise.
+    //
+    virtual bool compress() const = 0;
+
+    //
+    // Return a new endpoint with a different compression value,
+    // provided that compression is supported by the
+    // endpoint. Otherwise the same endpoint is returned.
+    //
+    virtual EndpointIPtr compress(bool) const = 0;
+
+    //
+    // Return true if the endpoint is datagram-based.
+    //
+    virtual bool datagram() const = 0;
+
+    //
+    // Return true if the endpoint is secure.
+    //
+    virtual bool secure() const = 0;
+
+    //
+    // Return a server side transceiver for this endpoint, or null if a
+    // transceiver can only be created by an acceptor.
+    //
+    virtual TransceiverPtr transceiver() const = 0;
+
+    //
+    // Return connectors for this endpoint, or empty vector if no
+    // connector is available. Implementation is responsible for
+    // returning connectors sorted according to the endpoint selection
+    // type.
+    //
+    virtual void connectors_async(Ice::EndpointSelectionType, const EndpointI_connectorsPtr&) const = 0;
+
+    //
+    // Return an acceptor for this endpoint, or null if no acceptors
+    // is available.
+    //
+    virtual AcceptorPtr acceptor(const std::string&) const = 0;
+
+    //
+    // Expand endpoint out in to separate endpoints for each local
+    // host if listening on INADDR_ANY on server side.
+    //
+    virtual std::vector<EndpointIPtr> expand() const = 0;
+
+    //
+    // Check whether the endpoint is equivalent to another one.
+    //
+    virtual bool equivalent(const EndpointIPtr&) const = 0;
+
+    //
+    // Compare endpoints for sorting purposes.
+    //
+    virtual bool operator==(const Ice::LocalObject&) const = 0;
+    virtual bool operator<(const Ice::LocalObject&) const = 0;
+
+    virtual ::Ice::Int hash() const = 0;
+
+    //
+    // Returns the stringified options
+    //
+    virtual std::string options() const = 0;
+
+    virtual std::string toString() const;
+    void initWithOptions(std::vector<std::string>&);
+
+protected:
+
+    virtual bool checkOption(const std::string&, const std::string&, const std::string&);
+
+};
+
+inline bool operator==(const EndpointI& l, const EndpointI& r)
+{
+    return static_cast<const ::Ice::LocalObject&>(l) == static_cast<const ::Ice::LocalObject&>(r);
+}
+
+inline bool operator<(const EndpointI& l, const EndpointI& r)
+{
+    return static_cast<const ::Ice::LocalObject&>(l) < static_cast<const ::Ice::LocalObject&>(r);
+}
+
+}
+
+#endif