GraphName.java

Go to the documentation of this file.

/*
 * Copyright (C) 2011 Google Inc.
 * 
 * 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.ros.namespace;

import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;

import org.ros.exception.RosRuntimeException;

import java.util.concurrent.atomic.AtomicInteger;
import java.util.regex.Pattern;

public class GraphName {

  @VisibleForTesting
  static final String ANONYMOUS_PREFIX = "anonymous_";

  private static final String ROOT = "/";
  private static final String SEPARATOR = "/";

  // TODO(damonkohler): Why make empty names valid?
  private static final Pattern VALID_GRAPH_NAME_PATTERN = Pattern
      .compile("^([\\~\\/A-Za-z][\\w_\\/]*)?$");

  private static AtomicInteger anonymousCounter = new AtomicInteger();

  private final String name;

  // TODO(damonkohler): This is not safe across multiple hosts/processes.
  // Instead, try to use the same algorithm as in cpp and Python.
  public static GraphName newAnonymous() {
    return new GraphName(ANONYMOUS_PREFIX + anonymousCounter.incrementAndGet());
  }

  public static GraphName root() {
    return new GraphName(ROOT);
  }

  public static GraphName empty() {
    return new GraphName("");
  }

  public static GraphName of(String name) {
    return new GraphName(canonicalize(name));
  }

  private GraphName(String name) {
    Preconditions.checkNotNull(name);
    this.name = name;
  }

  private static String canonicalize(String name) {
    if (!VALID_GRAPH_NAME_PATTERN.matcher(name).matches()) {
      throw new RosRuntimeException("Invalid graph name: " + name);
    }
    // Trim trailing slashes for canonical representation.
    while (!name.equals(GraphName.ROOT) && name.endsWith(SEPARATOR)) {
      name = name.substring(0, name.length() - 1);
    }
    if (name.startsWith("~/")) {
      name = "~" + name.substring(2);
    }
    return name;
  }

  public boolean isGlobal() {
    return !isEmpty() && name.charAt(0) == '/';
  }

  public boolean isRoot() {
    return name.equals(GraphName.ROOT);
  }

  public boolean isEmpty() {
    return name.isEmpty();
  }

  public boolean isPrivate() {
    return !isEmpty() && name.charAt(0) == '~';
  }

  public boolean isRelative() {
    return !isPrivate() && !isGlobal();
  }

  public GraphName getParent() {
    if (name.length() == 0) {
      return GraphName.empty();
    }
    if (name.equals(GraphName.ROOT)) {
      return GraphName.root();
    }
    int slashIdx = name.lastIndexOf('/');
    if (slashIdx > 1) {
      return new GraphName(name.substring(0, slashIdx));
    }
    if (isGlobal()) {
      return GraphName.root();
    }
    return GraphName.empty();
  }

  public GraphName getBasename() {
    int slashIdx = name.lastIndexOf('/');
    if (slashIdx > -1) {
      if (slashIdx + 1 < name.length()) {
        return new GraphName(name.substring(slashIdx + 1));
      }
      return GraphName.empty();
    }
    return this;
  }

  public GraphName toRelative() {
    if (isPrivate() || isGlobal()) {
      return new GraphName(name.substring(1));
    }
    return this;
  }

  public GraphName toGlobal() {
    if (isGlobal()) {
      return this;
    }
    if (isPrivate()) {
      return new GraphName(GraphName.ROOT + name.substring(1));
    }
    return new GraphName(GraphName.ROOT + name);
  }

  public GraphName join(GraphName other) {
    if (other.isGlobal() || isEmpty()) {
      return other;
    }
    if (isRoot()) {
      return other.toGlobal();
    }
    if (other.isEmpty()) {
      return this;
    }
    return new GraphName(toString() + SEPARATOR + other.toString());
  }

  public GraphName join(String other) {
    return join(GraphName.of(other));
  }

  @Override
  public String toString() {
    return name;
  }

  @Override
  public int hashCode() {
    return name.hashCode();
  }

  @Override
  public boolean equals(Object obj) {
    if (this == obj)
      return true;
    if (obj == null)
      return false;
    if (getClass() != obj.getClass())
      return false;
    GraphName other = (GraphName) obj;
    if (name == null) {
      if (other.name != null)
        return false;
    } else if (!name.equals(other.name))
      return false;
    return true;
  }
}