Java Code Examples for com.tinkerpop.blueprints.Element#getPropertyKeys()

static void transform(Iterable<? extends Element> elements) {
  for (Element element: elements) {
    for (String key: element.getPropertyKeys()) {
      if (PROTECTED_PROPERTY_KEYS.contains(key)) {
        continue;
      } else {
        Object value = element.getProperty(key);
        if (value instanceof Iterable) {
          // Leave it
        } else if (value.getClass().isArray()) {
          element.setProperty(key, Arrays.asList(value));
        } else {
          element.setProperty(key, newArrayList(value));
        }
      }
    }
  }
}
 

static void copyProperties(Element source, Element target) {
  for (String key : source.getPropertyKeys()) {
    Object property = source.getProperty(key);
    if (property.getClass().isArray()) {
      List<Object> propertyList = new ArrayList<>();
      for (int i = 0; i < Array.getLength(property); i++) {
        propertyList.add(Array.get(property, i));
      }
      property = propertyList;
    }
    target.setProperty(key, property);
  }
}
 

/**
 * Returns {@link Element}'s properties as an immutable map.
 * 
 * @return An immutable map of the specified {@link Element} properties
 *         exlcuding the specified keys
 */
public static Map<String, Object> getPropertiesAsMap(Element element, Set<String> excludedKeys) {
    Builder<String, Object> props = ImmutableMap.builder();

    for (String key : element.getPropertyKeys()) {
        if ((excludedKeys != null) && excludedKeys.contains(key)) {
            continue;
        }

        props.put(key, element.getProperty(key));
    }

    return props.build();
}
 

/**
 * Copy properties from one element to another.
 * 
 * @param from element to copy properties from
 * @param to element to copy properties to
 * @param excludedKeys the keys that should be excluded from being copied.
 */
public static void copyProps(Element from, Element to, Set<String> excludedKeys) {
    for (String k : from.getPropertyKeys()) {
        if (excludedKeys != null && excludedKeys.contains(k)) {
            continue;
        }

        to.setProperty(k, from.getProperty(k));
    }
}
 

/**
 * Get the specified {@link Element} properties as a string.
 * 
 * @param withHeader if true the element's id will be printed in the first
 *        line.
 * @param e The element to get the properties string for
 * @return A formatted string containing the specified element's properties
 */
public static String getElementPropsAsString(Element e, boolean withHeader) {
    StringBuilder elementPropsStr = new StringBuilder();

    if (withHeader) {
        elementPropsStr.append(e);
    }
    for (String key : e.getPropertyKeys()) {
        elementPropsStr.append("\t").append(key).append("->").append(e.getProperty(key));
    }

    return elementPropsStr.toString();
}
 

/**
 * Determines whether two elements have the same properties.
 * To be true, both must have the same property keys and respective values must be equals().
 *
 * @param a an element
 * @param b an element
 * @return whether the two elements have equal properties
 */
public static boolean haveEqualProperties(final Element a, final Element b) {
    final Set<String> aKeys = a.getPropertyKeys();
    final Set<String> bKeys = b.getPropertyKeys();

    if (aKeys.containsAll(bKeys) && bKeys.containsAll(aKeys)) {
        for (String key : aKeys) {
            if (!a.getProperty(key).equals(b.getProperty(key)))
                return false;
        }
        return true;
    } else {
        return false;
    }
}
 

/**
 * Get a clone of the properties of the provided element.
 * In other words, a HashMap is created and filled with the key/values of the element's properties.
 *
 * @param element the element to get the properties of
 * @return a clone of the properties of the element
 */
public static Map<String, Object> getProperties(final Element element) {
    final Map<String, Object> properties = new HashMap<String, Object>();
    for (final String key : element.getPropertyKeys()) {
        properties.put(key, element.getProperty(key));
    }
    return properties;
}
 

public static void dumpProperties(Element container) {
  for (String key: container.getPropertyKeys()) {
    System.out.println(key + ": " + container.getProperty(key));
  }
}
 

/**
 * Copy the properties (key and value) from one element to another.
 * The properties are preserved on the from element.
 * ElementPropertiesRule that share the same key on the to element are overwritten.
 *
 * @param from the element to copy properties from
 * @param to   the element to copy properties to
 */
public static void copyProperties(final Element from, final Element to) {
    for (final String key : from.getPropertyKeys()) {
        to.setProperty(key, from.getProperty(key));
    }
}