Returns the longitude contained in the specified {@link Object}.

A valid longitude must in the range [-180, 180].

@param o the {@link Object} containing the latitude
@return the longitude
321404
private static Double readLongitude(Object o) {
        if (o == null) {
            return null;
        }
        Double value;
        if (o instanceof Number) {
            value = ((Number) o).doubleValue();
        } else {
            try {
                value = Double.valueOf(o.toString());
            } catch (NumberFormatException e) {
                throw new IndexException("Unparseable longitude: {}", o);
            }
        }
        return GeospatialUtils.checkLongitude("longitude", value);
    }
107393
public static boolean isObjectAnObject(java.lang.Object o) {
    return o instanceof JavaScriptObject && isValueObject(wrap0(o));
  }
982367
public static Integer getInteger(Object object) {
        try {
            if(object instanceof Integer)
                return (Integer) object;

            if(object instanceof String)
                return Integer.valueOf((String) object);
        } catch(NumberFormatException  nfe) {
        }
        return null;
    }
751118
public int filterObject(E o) {

		int size = filters.size();
		int result = FILTER_ABORT;
		for (int i = 0; i < size; i++) {
			result = filters.get(i).filterObject(o);
			if (result == FILTER_ABORT) {
				break;
			} else if (result == FILTER_EXCLUDE) {
				break;
			}
		}
		return result;
	}
342285
@Override
    public int compareTo( GeoPt o ) {
        int latResult = ((Float) latitude).compareTo( o.latitude );
        if ( latResult != 0 ) {
            return latResult;
        }
        return ((Float) longitude).compareTo( o.longitude );
    }
99837
public Longitude parseLongitude(final String longitudeString)
    throws ParserException
  {
    try
    {
      final Longitude longitude = new Longitude(parseAngle(longitudeString));
      return longitude;
    }
    catch (final RuntimeException e)
    {
      throw new ParserException("Cannot parse longitude: " + longitudeString);
    }

  }
272310
public double distanceSquared(Vector o) {
        return NumberConversions.square(x - o.x) + NumberConversions.square(y - o.y) + NumberConversions.square(z - o.z);
    }
1170584
private Long getValue(final Object _object)
    {
        final Long ret;
        if (_object == null) {
            ret = null;
        } else if (_object instanceof Number) {
            ret = ((Number) _object).longValue();
        } else {
            ret = NumberUtils.toLong(_object.toString());
        }
        return ret;
    }
710116
protected int indexOf(final Object o) {
        final int size = dataModel.getSize();
        for (int i = 0; i < size; i++) {
            if (comparator == null) {
                if (o.equals(dataModel.getElementAt(i))) {
                    return i;
                }
            } else if (comparator.compare(o, dataModel.getElementAt(i)) == 0) {
                return i;
            }
        }

        return -1;
    }
720115
public static Double checkLatitude(String name, Double latitude) {
        if (latitude == null) {
            throw new IndexException("{} required", name);
        } else if (latitude < MIN_LATITUDE || latitude > MAX_LATITUDE) {
            throw new IndexException("{} must be in range [{}, {}], but found {}",
                                     name,
                                     MIN_LATITUDE,
                                     MAX_LATITUDE,
                                     latitude);
        }
        return latitude;
    }
1119827
public int getCount(Object o) {
    Integer count = (Integer) cset.get(o);   
    if ( count == null ) {
      return(0);
    }
    else {
      return(count.intValue());
    }
  }
110328
public static void checkLatLong(double lat, double lon) {
		checkArgument(lon <= 181.0, "longitude out of range " + lon);
		checkArgument(lon > -180.0, "longitude out of range " + lon);
		checkArgument(lat <= 91.0, "latitude out of range " + lat);
		checkArgument(lat > -90.0, "latitude out of range " + lat);
	}
861480
public static long addressOf(Object o) {
    Object[] array = new Object[] { o };
    long baseOffset = THE_UNSAFE.arrayBaseOffset(Object[].class);
    long objectAddress;
    switch (ADDRESS_SIZE) {
    case 4:
      objectAddress = THE_UNSAFE.getInt(array, baseOffset);
      break;
    case 8:
      objectAddress = THE_UNSAFE.getLong(array, baseOffset);
      break;
    default:
      throw new IllegalStateException("unsupported address size: " + ADDRESS_SIZE);
    }
    return objectAddress;
  }
235963
public Double getLatitudeOnGreatCircle(Position position, double longitudeDegrees) {
        double lonR = toRadians(longitudeDegrees);
        double lat1R = toRadians(lat);
        double lon1R = toRadians(lon);
        double lat2R = toRadians(position.getLat());
        double lon2R = toRadians(position.getLon());

        double sinDiffLon1RLon2R = sin(lon1R - lon2R);
        if (abs(sinDiffLon1RLon2R) < 0.00000001) {
            return null;
        } else {
            double cosLat1R = cos(lat1R);
            double cosLat2R = cos(lat2R);
            double numerator = sin(lat1R) * cosLat2R * sin(lonR - lon2R) - sin(lat2R) * cosLat1R
                    * sin(lonR - lon1R);
            double denominator = cosLat1R * cosLat2R * sinDiffLon1RLon2R;
            double radians = atan(numerator / denominator);
            return FastMath.toDegrees(radians);
        }
    }
466143
public int getAndSetLo(int lo) {
        while (true) {
            long encoded = get();
            long update = encodeLo(encoded, lo);
            if (compareAndSet(encoded, update))
                return getLo(encoded);
        }
    }
891341
public int compareTo(Object o)
		{
			final int rhs = o.hashCode();
			return hashCode() < rhs ? -1 : hashCode() > rhs ? 1 : 0;
		}
1297518
public static String encode(Object o) {
        Type type = typeOf(o);
        return type.encode(o);
    }