| /* |
| * Copyright 2017-present Open Networking Laboratory |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| */ |
| |
| package org.onosproject.ui.topo; |
| |
| import com.google.common.base.Strings; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.List; |
| |
| import static com.google.common.base.MoreObjects.toStringHelper; |
| import static com.google.common.base.Preconditions.checkNotNull; |
| |
| /** |
| * Represents a "node location" on a UI layout. |
| */ |
| public final class LayoutLocation { |
| private static final double ZERO_THRESHOLD = Double.MIN_VALUE * 2.0; |
| private static final String COMMA = ","; |
| private static final String TILDE = "~"; |
| private static final String EMPTY = ""; |
| |
| private static final String E_BAD_COMPACT = "Badly formatted compact form: "; |
| private static final String E_EMPTY_ID = "id must be non-empty"; |
| private static final String E_BAD_DOUBLE = "unparsable double"; |
| |
| |
| /** |
| * Designates the type of location; either geographic or logical grid. |
| */ |
| public enum Type { |
| GEO, GRID; |
| |
| @Override |
| public String toString() { |
| return name().toLowerCase(); |
| } |
| } |
| |
| private final String id; |
| private final double latOrY; |
| private final double longOrX; |
| private final Type locType; |
| |
| private LayoutLocation(String id, Type locType, double latOrY, double longOrX) { |
| this.id = id; |
| this.latOrY = latOrY; |
| this.longOrX = longOrX; |
| this.locType = locType; |
| } |
| |
| private boolean doubleIsZero(double value) { |
| return value >= -ZERO_THRESHOLD && value <= ZERO_THRESHOLD; |
| } |
| |
| /** |
| * Returns true if the coordinates indicate the origin (0, 0) of the |
| * coordinate system; false otherwise. |
| * |
| * @return true if geo-coordinates are set; false otherwise |
| */ |
| public boolean isOrigin() { |
| return doubleIsZero(latOrY) && doubleIsZero(longOrX); |
| } |
| |
| /** |
| * Returns the identifier associated with this location. |
| * |
| * @return the identifier |
| */ |
| public String id() { |
| return id; |
| } |
| |
| /** |
| * Returns the location type (geo or grid), which indicates how the data |
| * is to be interpreted. |
| * |
| * @return location type |
| */ |
| public Type locType() { |
| return locType; |
| } |
| |
| /** |
| * Returns the latitude (geo) or y-coord (grid) data value. |
| * |
| * @return geo latitude or grid y-coord |
| */ |
| public double latOrY() { |
| return latOrY; |
| } |
| |
| /** |
| * Returns the longitude (geo) or x-coord (grid) data value. |
| * |
| * @return geo longitude or grid x-coord |
| */ |
| public double longOrX() { |
| return longOrX; |
| } |
| |
| @Override |
| public String toString() { |
| return toStringHelper(this) |
| .add("id", id) |
| .add("loc-type", locType) |
| .add("lat/Y", latOrY) |
| .add("long/X", longOrX) |
| .toString(); |
| } |
| |
| /** |
| * Produces a compact string representation of this instance. |
| * |
| * @return compact string rep |
| */ |
| public String toCompactListString() { |
| return id + COMMA + locType + COMMA + latOrY + COMMA + longOrX; |
| } |
| |
| /** |
| * Produces a layout location instance from a compact string representation. |
| * |
| * @param s the compact string |
| * @return a corresponding instance |
| */ |
| public static LayoutLocation fromCompactString(String s) { |
| String[] tokens = s.split(COMMA); |
| if (tokens.length != 4) { |
| throw new IllegalArgumentException(E_BAD_COMPACT + s); |
| } |
| String id = tokens[0]; |
| String type = tokens[1]; |
| String latY = tokens[2]; |
| String longX = tokens[3]; |
| |
| if (Strings.isNullOrEmpty(id)) { |
| throw new IllegalArgumentException(E_BAD_COMPACT + E_EMPTY_ID); |
| } |
| |
| double latOrY; |
| double longOrX; |
| try { |
| latOrY = Double.parseDouble(latY); |
| longOrX = Double.parseDouble(longX); |
| } catch (NumberFormatException nfe) { |
| throw new IllegalArgumentException(E_BAD_COMPACT + E_BAD_DOUBLE); |
| } |
| |
| return LayoutLocation.layoutLocation(id, type, latOrY, longOrX); |
| } |
| |
| /** |
| * Produces a compact encoding of a list of layout locations. |
| * |
| * @param locs array of layout location instances |
| * @return string encoding |
| */ |
| public static String toCompactListString(LayoutLocation... locs) { |
| if (locs == null || locs.length == 0) { |
| return EMPTY; |
| } |
| List<LayoutLocation> lls = Arrays.asList(locs); |
| return toCompactListString(lls); |
| } |
| |
| /** |
| * Produces a compact encoding of a list of layout locations. |
| * |
| * @param locs list of layout location instances |
| * @return string encoding |
| */ |
| public static String toCompactListString(List<LayoutLocation> locs) { |
| // note: locs may be empty |
| if (locs == null || locs.isEmpty()) { |
| return EMPTY; |
| } |
| |
| StringBuilder sb = new StringBuilder(); |
| for (LayoutLocation ll : locs) { |
| sb.append(ll.toCompactListString()).append(TILDE); |
| } |
| final int len = sb.length(); |
| sb.replace(len - 1, len, ""); |
| return sb.toString(); |
| } |
| |
| /** |
| * Returns a list of layout locations from a compact string representation. |
| * |
| * @param compactList string representation |
| * @return corresponding list of layout locations |
| */ |
| public static List<LayoutLocation> fromCompactListString(String compactList) { |
| List<LayoutLocation> locs = new ArrayList<>(); |
| if (!Strings.isNullOrEmpty(compactList)) { |
| String[] items = compactList.split(TILDE); |
| for (String s : items) { |
| locs.add(fromCompactString(s)); |
| } |
| } |
| return locs; |
| } |
| |
| |
| /** |
| * Creates an instance of a layout location. |
| * |
| * @param id an identifier for the item at this location |
| * @param locType the location type |
| * @param latOrY geo latitude / grid y-coord |
| * @param longOrX geo longitude / grid x-coord |
| * @return layout location instance |
| */ |
| public static LayoutLocation layoutLocation(String id, Type locType, |
| double latOrY, double longOrX) { |
| checkNotNull(id, "must supply an identifier"); |
| checkNotNull(locType, "must declare location type"); |
| return new LayoutLocation(id, locType, latOrY, longOrX); |
| } |
| |
| /** |
| * Creates an instance of a layout location. |
| * |
| * @param id an identifier for the item at this location |
| * @param locType the location type ("geo" or "grid") |
| * @param latOrY geo latitude / grid y-coord |
| * @param longOrX geo longitude / grid x-coord |
| * @return layout location instance |
| * @throws IllegalArgumentException if the type is not "geo" or "grid" |
| */ |
| public static LayoutLocation layoutLocation(String id, String locType, |
| double latOrY, double longOrX) { |
| Type t = Type.valueOf(locType.toUpperCase()); |
| return new LayoutLocation(id, t, latOrY, longOrX); |
| } |
| } |