Returns the far object that corresponds to the given near object.
@param nearObject The near object
@return The far object that corresponds to the given near object
@see BridgeFacets#getFarObject()
975966
public static FarObject<?> getFarObject(Object nearObject) {
        return nearObject == null ? null : getFacets(nearObject).getFarObject();
    }
739703
public Object getValue(Object object) throws IllegalAccessException, InvocationTargetException {
        Object result = null;
        if (getter != null) {
            result = getter.invoke(object);
        } else if (field != null) {
            if(!field.isAccessible()){
                field.setAccessible(true);
            }
            result = field.get(object);
        }
        return result;
    }
1230154
public InstantConverter getInstantConverter(Object object) {
        InstantConverter converter =
            (InstantConverter)iInstantConverters.select(object == null ? null : object.getClass());
        if (converter != null) {
            return converter;
        }
        throw new IllegalArgumentException("No instant converter found for type: " +
            (object == null ? "null" : object.getClass().getName()));
    }
211718
public final <T extends Freezable> T get(Class<T> fc) {
    T pojo = getFreezable();
    assert fc.isAssignableFrom(pojo.getClass());
    return pojo;
  }
67245
public <T> T getObject(int columnIndex, Class<T> type) throws SQLException {
	return (T) QueryUtil.getObject(this, columnIndex, type);
    }
1202832
public Frustum setToFrustum (
        double left, double right, double bottom, double top, double near, double far) {
        return setToProjection(left, right, bottom, top, near, far, Vector3.UNIT_Z, false, false);
    }
562088
public Object getRealObjectIfMaterialized(Object objectOrProxy)
    {
        if(isNormalOjbProxy(objectOrProxy))
        {
            String msg;

            try
            {
                IndirectionHandler handler = getIndirectionHandler(objectOrProxy);

                return handler.alreadyMaterialized() ? handler.getRealSubject() : null;
            }
            catch(ClassCastException e)
            {
                // shouldn't happen but still ...
                msg = "The InvocationHandler for the provided Proxy was not an instance of " + IndirectionHandler.class.getName();
                log.error(msg);
                throw new PersistenceBrokerException(msg, e);
            }
            catch(IllegalArgumentException e)
            {
                msg = "Could not retrieve real object for given Proxy: " + objectOrProxy;
                log.error(msg);
                throw new PersistenceBrokerException(msg, e);
            }
            catch(PersistenceBrokerException e)
            {
                log.error("Could not retrieve real object for given Proxy: " + objectOrProxy);
                throw e;
            }
        }
        else if(isVirtualOjbProxy(objectOrProxy))
        {
            try
            {
                VirtualProxy proxy = (VirtualProxy) objectOrProxy;

                return proxy.alreadyMaterialized() ? proxy.getRealSubject() : null;
            }
            catch(PersistenceBrokerException e)
            {
                log.error("Could not retrieve real object for VirtualProxy: " + objectOrProxy);
                throw e;
            }
        }
        else
        {
            return objectOrProxy;
        }
    }
1150797
public Object get(long currentRow, Object previous) throws IOException {
    seekToRow(currentRow);
    return next(previous);
  }
987564
public static ASN1Set getInstance(
        Object  obj)
    {
        if (obj == null || obj instanceof ASN1Set)
        {
            return (ASN1Set)obj;
        }

        throw new IllegalArgumentException("unknown object in getInstance");
    }
1032625
public E get(int i) {
    if (i < 0 || i >= objects.size())
      throw new ArrayIndexOutOfBoundsException("Index " + i + 
                                               " outside the bounds [0," + 
                                               size() + ")");
    return objects.get(i);
  }
667244
@Override
	public <T> T getObject(final int columnIndex, final Class<T> type) throws SQLException {
		String columnLabel = getWrapped().getMetaData().getColumnLabel(columnIndex);

		return getObject(columnLabel, type);
	}
248423
public static Object getObjectProp(Object obj, String property,
                                       Context cx, Scriptable scope)
    {
        Scriptable sobj = toObjectOrNull(cx, obj, scope);
        if (sobj == null) {
            throw undefReadError(obj, property);
        }
        return getObjectProp(sobj, property, cx);
    }
1090986
public int compareTo(Object object) {
        if (object == null) {
            return -1;
        }
        if(object instanceof RtfFont) {
            if(this.getFontName().compareTo(((RtfFont) object).getFontName()) != 0) {
                return 1;
            } else {
                return super.compareTo(object);
            }
        } else if(object instanceof Font) {
            return super.compareTo(object);
        } else {
            return -3;
        }
    }
286301
public int indexOf(T object) {
        synchronized (mLock) {
            if (mOriginalValues != null) {
                return mOriginalValues.indexOf(object);
            } else {
                return mObjects.indexOf(object);
            }
        }
    }
496271
@SuppressWarnings("unchecked")
    public BridgeFactory getBridgeFactory(Class<?> farType) {
        if (!farToNearType.containsKey(farType)) {
            throw new IllegalStateException("Far type not registered: " + (farType == null ? "null" : farType.getSimpleName()));
        }
        return farTypeToFactory.get(farType);
    }
91014
public <T> T getObject(int parameterIndex, Class<T> type) throws SQLException {
	// used reflection to make sure this work with Java 5 and 6
	try {
	    return (T) stat.getClass().getMethod("getObject", new Class[] { int.class, Class.class }).invoke(stat, new Object[] { parameterIndex, type });
	}
	catch (Throwable t) {
	    ExceptionUtil.rethrowIfNecessary(t);
	    if (t instanceof InvocationTargetException && ((InvocationTargetException) t).getTargetException() instanceof SQLException)
		throw (SQLException) ((InvocationTargetException) t).getTargetException();
	    throw new PageRuntimeException(Caster.toPageException(t));
	}
    }
382191
private static Object get(Object object, int index) {
        if (index < 0) {
            throw new IndexOutOfBoundsException("Index cannot be negative: "
                    + index);
        }
        if (object instanceof Map) {
            Map<?, ?> map = (Map<?, ?>) object;
            Iterator<?> iterator = map.entrySet().iterator();
            return get(iterator, index);
        } else if (object instanceof List) {
            return ((List<?>) object).get(index);
        } else if (object instanceof Object[]) {
            return ((Object[]) object)[index];
        } else if (object instanceof Iterator) {
            Iterator<?> it = (Iterator<?>) object;
            while (it.hasNext()) {
                index--;
                if (index == -1) {
                    return it.next();
                } else {
                    it.next();
                }
            }
            throw new IndexOutOfBoundsException("Entry does not exist: "
                    + index);
        } else if (object instanceof Collection) {
            Iterator<?> iterator = ((Collection<?>) object).iterator();
            return get(iterator, index);
        } else if (object instanceof Enumeration) {
            Enumeration<?> it = (Enumeration<?>) object;
            while (it.hasMoreElements()) {
                index--;
                if (index == -1) {
                    return it.nextElement();
                } else {
                    it.nextElement();
                }
            }
            throw new IndexOutOfBoundsException("Entry does not exist: "
                    + index);
        } else if (object == null) {
            throw new IllegalArgumentException("Unsupported object type: null");
        } else {
            try {
                return Array.get(object, index);
            } catch (IllegalArgumentException ex) {
                throw new IllegalArgumentException("Unsupported object type: "
                        + object.getClass().getName());
            }
        }
    }