java/src/IceInternal/FixedReference.java

   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 package IceInternal;
  11
  12 public class FixedReference extends Reference
  13 {
  14     public
  15     FixedReference(Instance instance,
  16                    Ice.Communicator communicator,
  17                    Ice.Identity identity,
  18                    String facet,
  19                    int mode,
  20                    boolean secure,
  21                    Ice.ConnectionI connection)
  22     {
  23         super(instance, communicator, identity, facet, mode, secure);
  24         _fixedConnection = connection;
  25     }
  26
  27     public EndpointI[]
  28     getEndpoints()
  29     {
  30         return _emptyEndpoints;
  31     }
  32
  33     public String
  34     getAdapterId()
  35     {
  36         return "";
  37     }
  38
  39     public LocatorInfo
  40     getLocatorInfo()
  41     {
  42         return null;
  43     }
  44
  45     public RouterInfo
  46     getRouterInfo()
  47     {
  48         return null;
  49     }
  50
  51     public boolean
  52     getCollocationOptimized()
  53     {
  54         return false;
  55     }
  56
  57     public final boolean
  58     getCacheConnection()
  59     {
  60         return false;
  61     }
  62
  63     public boolean
  64     getPreferSecure()
  65     {
  66         return false;
  67     }
  68
  69     public final Ice.EndpointSelectionType
  70     getEndpointSelection()
  71     {
  72         return Ice.EndpointSelectionType.Random;
  73     }
  74
  75     public int
  76     getLocatorCacheTimeout()
  77     {
  78         return 0;
  79     }
  80
  81     public String
  82     getConnectionId()
  83     {
  84         return "";
  85     }
  86
  87     public Reference
  88     changeEndpoints(EndpointI[] newEndpoints)
  89     {
  90         throw new Ice.FixedProxyException();
  91     }
  92
  93     public Reference
  94     changeAdapterId(String newAdapterId)
  95     {
  96         throw new Ice.FixedProxyException();
  97     }
  98
  99     public Reference
 100     changeLocator(Ice.LocatorPrx newLocator)
 101     {
 102         throw new Ice.FixedProxyException();
 103     }
 104
 105     public Reference
 106     changeRouter(Ice.RouterPrx newRouter)
 107     {
 108         throw new Ice.FixedProxyException();
 109     }
 110
 111     public Reference
 112     changeCollocationOptimized(boolean newCollocationOptimized)
 113     {
 114         throw new Ice.FixedProxyException();
 115     }
 116
 117     public final Reference
 118     changeCacheConnection(boolean newCache)
 119     {
 120         throw new Ice.FixedProxyException();
 121     }
 122
 123     public Reference
 124     changePreferSecure(boolean prefSec)
 125     {
 126         throw new Ice.FixedProxyException();
 127     }
 128
 129     public final Reference
 130     changeEndpointSelection(Ice.EndpointSelectionType newType)
 131     {
 132         throw new Ice.FixedProxyException();
 133     }
 134
 135     public Reference
 136     changeLocatorCacheTimeout(int newTimeout)
 137     {
 138         throw new Ice.FixedProxyException();
 139     }
 140
 141     public Reference
 142     changeTimeout(int newTimeout)
 143     {
 144         throw new Ice.FixedProxyException();
 145     }
 146
 147     public Reference
 148     changeConnectionId(String connectionId)
 149     {
 150         throw new Ice.FixedProxyException();
 151     }
 152
 153     public boolean
 154     isIndirect()
 155     {
 156         return false;
 157     }
 158
 159     public boolean
 160     isWellKnown()
 161     {
 162         return false;
 163     }
 164
 165     public void
 166     streamWrite(BasicStream s)
 167         throws Ice.MarshalException
 168     {
 169         throw new Ice.FixedProxyException();
 170     }
 171
 172     public String
 173     toString()
 174         throws Ice.MarshalException
 175     {
 176         throw new Ice.FixedProxyException();
 177     }
 178
 179     public java.util.Map<String, String>
 180     toProperty(String prefix)
 181     {
 182         throw new Ice.FixedProxyException();
 183     }
 184
 185     public Ice.ConnectionI
 186     getConnection(Ice.BooleanHolder compress)
 187     {
 188         switch(getMode())
 189         {
 190             case Reference.ModeTwoway:
 191             case Reference.ModeOneway:
 192             case Reference.ModeBatchOneway:
 193             {
 194                 if(_fixedConnection.endpoint().datagram())
 195                 {
 196                     throw new Ice.NoEndpointException("");
 197                 }
 198                 break;
 199             }
 200
 201             case Reference.ModeDatagram:
 202             case Reference.ModeBatchDatagram:
 203             {
 204                 if(!_fixedConnection.endpoint().datagram())
 205                 {
 206                     throw new Ice.NoEndpointException("");
 207                 }
 208                 break;
 209             }
 210         }
 211
 212         //
 213         // If a secure connection is requested or secure overrides is set,
 214         // check if the connection is secure.
 215         //
 216         boolean secure;
 217         DefaultsAndOverrides defaultsAndOverrides = getInstance().defaultsAndOverrides();
 218         if(defaultsAndOverrides.overrideSecure)
 219         {
 220             secure = defaultsAndOverrides.overrideSecureValue;
 221         }
 222         else
 223         {
 224             secure = getSecure();
 225         }
 226         if(secure && !_fixedConnection.endpoint().secure())
 227         {
 228             throw new Ice.NoEndpointException("");
 229         }
 230
 231         _fixedConnection.throwException(); // Throw in case our connection is already destroyed.
 232
 233         if(defaultsAndOverrides.overrideCompress)
 234         {
 235             compress.value = defaultsAndOverrides.overrideCompressValue;
 236         }
 237         else if(_overrideCompress)
 238         {
 239             compress.value = _compress;
 240         }
 241         else
 242         {
 243             compress.value = _fixedConnection.endpoint().compress();
 244         }
 245         return _fixedConnection;
 246     }
 247
 248     public void
 249     getConnection(GetConnectionCallback callback)
 250     {
 251         try
 252         {
 253             Ice.BooleanHolder compress = new Ice.BooleanHolder();
 254             Ice.ConnectionI connection = getConnection(compress);
 255             callback.setConnection(connection, compress.value);
 256         }
 257         catch(Ice.LocalException ex)
 258         {
 259             callback.setException(ex);
 260         }
 261     }
 262
 263     public boolean
 264     equals(java.lang.Object obj)
 265     {
 266         if(this == obj)
 267         {
 268             return true;
 269         }
 270         if(!(obj instanceof FixedReference))
 271         {
 272             return false;
 273         }
 274         FixedReference rhs = (FixedReference)obj;
 275         if(!super.equals(rhs))
 276         {
 277             return false;
 278         }
 279         return _fixedConnection.equals(rhs._fixedConnection);
 280     }
 281
 282     public int
 283     hashCode()
 284     {
 285         return super.hashCode();
 286     }
 287
 288     private Ice.ConnectionI _fixedConnection;
 289     private static EndpointI[] _emptyEndpoints = new EndpointI[0];
 290 }