cpp/test/Ice/background/EndpointI.cpp

   1 // **********************************************************************
   2 //
   3 // Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
   4 //
   5 // This copy of Ice is licensed to you under the terms described in the
   6 // ICE_LICENSE file included in this distribution.
   7 //
   8 // **********************************************************************
   9
  10 #include <EndpointI.h>
  11 #include <Transceiver.h>
  12 #include <Connector.h>
  13 #include <Acceptor.h>
  14 #include <Ice/BasicStream.h>
  15
  16 using namespace std;
  17
  18 Ice::Short EndpointI::TYPE_BASE = 100;
  19
  20 EndpointI::EndpointI(const IceInternal::EndpointIPtr& endpoint) :
  21     _endpoint(endpoint),
  22     _configuration(Configuration::getInstance())
  23 {
  24 }
  25
  26 void
  27 EndpointI::streamWrite(IceInternal::BasicStream* s) const
  28 {
  29     s->write(type());
  30     _endpoint->streamWrite(s);
  31 }
  32
  33 Ice::Short
  34 EndpointI::type() const
  35 {
  36     return (Ice::Short)(TYPE_BASE + _endpoint->type());
  37 }
  38
  39 int
  40 EndpointI::timeout() const
  41 {
  42     return _endpoint->timeout();
  43 }
  44
  45 IceInternal::EndpointIPtr
  46 EndpointI::timeout(int timeout) const
  47 {
  48     IceInternal::EndpointIPtr endpoint = _endpoint->timeout(timeout);
  49     if(endpoint == _endpoint)
  50     {
  51         return const_cast<EndpointI*>(this);
  52     }
  53     else
  54     {
  55         return new EndpointI(endpoint);
  56     }
  57 }
  58
  59 IceInternal::EndpointIPtr
  60 EndpointI::connectionId(const string& connectionId) const
  61 {
  62     IceInternal::EndpointIPtr endpoint = _endpoint->connectionId(connectionId);
  63     if(endpoint == _endpoint)
  64     {
  65         return const_cast<EndpointI*>(this);
  66     }
  67     else
  68     {
  69         return new EndpointI(endpoint);
  70     }
  71 }
  72
  73 bool
  74 EndpointI::compress() const
  75 {
  76     return _endpoint->compress();
  77 }
  78
  79 IceInternal::EndpointIPtr
  80 EndpointI::compress(bool compress) const
  81 {
  82     IceInternal::EndpointIPtr endpoint = _endpoint->compress(compress);
  83     if(endpoint == _endpoint)
  84     {
  85         return const_cast<EndpointI*>(this);
  86     }
  87     else
  88     {
  89         return new EndpointI(endpoint);
  90     }
  91 }
  92
  93 bool
  94 EndpointI::datagram() const
  95 {
  96     return _endpoint->datagram();
  97 }
  98
  99 bool
 100 EndpointI::secure() const
 101 {
 102     return _endpoint->secure();
 103 }
 104
 105 IceInternal::TransceiverPtr
 106 EndpointI::transceiver(IceInternal::EndpointIPtr& endpoint) const
 107 {
 108     IceInternal::EndpointIPtr endpt = _endpoint;
 109     IceInternal::TransceiverPtr transceiver = _endpoint->transceiver(endpt);
 110     if(endpt == _endpoint)
 111     {
 112         endpoint = const_cast<EndpointI*>(this);
 113     }
 114     else
 115     {
 116         endpoint = new EndpointI(endpoint);
 117     }
 118
 119     if(transceiver)
 120     {
 121         return new Transceiver(transceiver);
 122     }
 123     else
 124     {
 125         return 0;
 126     }
 127 }
 128
 129 vector<IceInternal::ConnectorPtr>
 130 EndpointI::connectors() const
 131 {
 132     _configuration->checkConnectorsException();
 133     vector<IceInternal::ConnectorPtr> c = _endpoint->connectors();
 134     for(vector<IceInternal::ConnectorPtr>::iterator p = c.begin(); p != c.end(); ++p)
 135     {
 136         *p = new Connector(*p);
 137     }
 138     return c;
 139 }
 140
 141 void
 142 EndpointI::connectors_async(const IceInternal::EndpointI_connectorsPtr& cb) const
 143 {
 144     class Callback : public IceInternal::EndpointI_connectors
 145     {
 146     public:
 147
 148         Callback(const IceInternal::EndpointI_connectorsPtr& callback) : _callback(callback)
 149         {
 150         }
 151
 152         void
 153         connectors(const vector<IceInternal::ConnectorPtr>& connectors)
 154         {
 155             vector<IceInternal::ConnectorPtr> c;
 156             for(vector<IceInternal::ConnectorPtr>::const_iterator p = connectors.begin(); p != connectors.end(); ++p)
 157             {
 158                 c.push_back(new Connector(*p));
 159             }
 160             _callback->connectors(c);
 161         }
 162
 163         void
 164         exception(const Ice::LocalException& ex)
 165         {
 166             _callback->exception(ex);
 167         }
 168
 169     private:
 170
 171         IceInternal::EndpointI_connectorsPtr _callback;
 172     };
 173
 174     try
 175     {
 176         _configuration->checkConnectorsException();
 177         _endpoint->connectors_async(new Callback(cb));
 178     }
 179     catch(const Ice::LocalException& ex)
 180     {
 181         cb->exception(ex);
 182     }
 183 }
 184
 185 IceInternal::AcceptorPtr
 186 EndpointI::acceptor(IceInternal::EndpointIPtr& endpoint, const string& adapterName) const
 187 {
 188     IceInternal::AcceptorPtr p = new Acceptor(_endpoint->acceptor(endpoint, adapterName));
 189     endpoint = new EndpointI(endpoint);
 190     return p;
 191 }
 192
 193 vector<IceInternal::EndpointIPtr>
 194 EndpointI::expand() const
 195 {
 196     vector<IceInternal::EndpointIPtr> e = _endpoint->expand();
 197     for(vector<IceInternal::EndpointIPtr>::iterator p = e.begin(); p != e.end(); ++p)
 198     {
 199         *p = (*p == _endpoint) ? const_cast<EndpointI*>(this) : new EndpointI(*p);
 200     }
 201     return e;
 202 }
 203
 204 bool
 205 EndpointI::equivalent(const IceInternal::EndpointIPtr& endpoint) const
 206 {
 207     const EndpointI* testEndpointI = dynamic_cast<const EndpointI*>(endpoint.get());
 208     if(!testEndpointI)
 209     {
 210         return false;
 211     }
 212     return testEndpointI->_endpoint->equivalent(_endpoint);
 213 }
 214
 215 string
 216 EndpointI::toString() const
 217 {
 218     return "test-" + _endpoint->toString();
 219 }
 220
 221 Ice::EndpointInfoPtr
 222 EndpointI::getInfo() const
 223 {
 224     return _endpoint->getInfo();
 225 }
 226
 227 bool
 228 EndpointI::operator==(const Ice::LocalObject& r) const
 229 {
 230     const EndpointI* p = dynamic_cast<const EndpointI*>(&r);
 231     if(!p)
 232     {
 233         return false;
 234     }
 235
 236     if(this == p)
 237     {
 238         return true;
 239     }
 240
 241
 242     return *p->_endpoint == *_endpoint;
 243 }
 244
 245 bool
 246 EndpointI::operator<(const Ice::LocalObject& r) const
 247 {
 248     const EndpointI* p = dynamic_cast<const EndpointI*>(&r);
 249     if(!p)
 250     {
 251         const IceInternal::EndpointI* e = dynamic_cast<const IceInternal::EndpointI*>(&r);
 252         if(!e)
 253         {
 254             return false;
 255         }
 256         return type() < e->type();
 257     }
 258
 259     if(this == p)
 260     {
 261         return false;
 262     }
 263
 264     return *p->_endpoint < *_endpoint;
 265 }
 266
 267 Ice::Int
 268 EndpointI::hashInit() const
 269 {
 270     return _endpoint->ice_getHash();
 271 }