com.tinkerpop.blueprints.Index Java Examples

@Override
public void dropIndex(String indexName) {
  if (globals.getConfig().getIndexableGraphDisabled())
    throw new UnsupportedOperationException("IndexableGraph is disabled via the configuration");

  for (Index<? extends Element> index : getIndices()) {
    if (index.getIndexName().equals(indexName)) {
      globals.getIndexMetadataWrapper().clearIndexNameEntry(indexName, index.getIndexClass());

      try {
        globals.getConfig().getConnector().tableOperations().delete(globals.getConfig()
            .getNamedIndexTableName(indexName));
      } catch (Exception e) {
        throw new AccumuloGraphException(e);
      }

      return;
    }
  }

  throw new AccumuloGraphException("Index does not exist: "+indexName);
}
 

@SuppressWarnings("rawtypes")
@Override
public <T extends Element> Index<T> createIndex(String indexName,
    Class<T> indexClass, Parameter... indexParameters) {
  if (indexClass == null) {
    throw ExceptionFactory.classForElementCannotBeNull();
  }
  else if (globals.getConfig().getIndexableGraphDisabled()) {
    throw new UnsupportedOperationException("IndexableGraph is disabled via the configuration");
  }

  for (Index<?> index : globals.getIndexMetadataWrapper().getIndices()) {
    if (index.getIndexName().equals(indexName)) {
      throw ExceptionFactory.indexAlreadyExists(indexName);
    }
  }

  return globals.getIndexMetadataWrapper().createIndex(indexName, indexClass);
}
 

@SuppressWarnings({"rawtypes", "unchecked"})
public Iterable<Index<? extends Element>> getIndices() {
  List<Index<? extends Element>> indexes = new ArrayList<Index<? extends Element>>();

  IndexedItemsListParser parser = new IndexedItemsListParser();

  Scanner scan = null;
  try {
    scan = getScanner();
    scan.fetchColumnFamily(new Text(IndexMetadataEntryType.__INDEX_NAME__.name()));

    for (IndexedItem item : parser.parse(scan)) {
      indexes.add(new AccumuloIndex(globals,
          item.getKey(), item.getElementClass()));
    }

    return indexes;

  } finally {
    if (scan != null) {
      scan.close();
    }
  }
}
 

public Iterator<Index<T>> iterator() {
    return new Iterator<Index<T>>() {
        private final Iterator<Index<T>> itty = iterable.iterator();

        public void remove() {
            this.itty.remove();
        }

        public boolean hasNext() {
            return this.itty.hasNext();
        }

        public Index<T> next() {
            return new PartitionIndex<T>(this.itty.next(), graph);
        }
    };
}
 

public Iterator<Index<T>> iterator() {
    return new Iterator<Index<T>>() {
        private final Iterator<Index<T>> itty = iterable.iterator();

        public void remove() {
            this.itty.remove();
        }

        public Index<T> next() {
            return new EventIndex<T>(this.itty.next(), eventGraph);
        }

        public boolean hasNext() {
            return itty.hasNext();
        }
    };
}
 

public Iterator<Index<T>> iterator() {
    return new Iterator<Index<T>>() {
        private final Iterator<Index<T>> itty = iterable.iterator();

        public void remove() {
            throw new UnsupportedOperationException(ReadOnlyTokens.MUTATE_ERROR_MESSAGE);
        }

        public Index<T> next() {
            return new ReadOnlyIndex<T>(this.itty.next());
        }

        public boolean hasNext() {
            return this.itty.hasNext();
        }
    };
}
 

public Iterator<Index<T>> iterator() {
    return new Iterator<Index<T>>() {

        private final Iterator<Index<T>> itty = iterable.iterator();

        public void remove() {
            throw new UnsupportedOperationException();
        }

        public boolean hasNext() {
            return this.itty.hasNext();
        }

        public Index<T> next() {
            return new WrappedIndex<T>(this.itty.next());
        }
    };
}
 

@Override
public Iterator<Index<T>> iterator() {
    return new Iterator<Index<T>>() {
        private final Iterator<Index<T>> itty = iterable.iterator();

        @Override
        public void remove() {
            this.itty.remove();
        }

        @Override
        public Index<T> next() {
            return new ActiveVersionedIndex<T, V>(this.itty.next(), graph);
        }

        @Override
        public boolean hasNext() {
            return itty.hasNext();
        }
    };
}
 

public <T extends Element> Index<T> createIndex(final String indexName,
                                                final Class<T> indexClass,
                                                final Parameter... indexParameters) {
    verifyBaseGraphIsIndexableGraph();

    return isVertexClass(indexClass)
            ? (Index<T>) new IdVertexIndex((Index<Vertex>) ((IndexableGraph) baseGraph).createIndex(indexName, indexClass, indexParameters), this)
            : (Index<T>) new IdEdgeIndex((Index<Edge>) ((IndexableGraph) baseGraph).createIndex(indexName, indexClass, indexParameters), this);
}
 

public IdVertexIndex(final Index<Vertex> baseIndex, final IdGraph idGraph) {
    if (null == baseIndex) {
        throw new IllegalArgumentException("null base index");
    }
    this.idGraph = idGraph;
    this.baseIndex = baseIndex;
}
 

public <T extends Element> Index<T> getIndex(final String indexName, final Class<T> indexClass) {
    final Index<T> index = baseGraph.getIndex(indexName, indexClass);
    if (null == index)
        return null;
    else {
        return new PartitionIndex<T>(index, this);
    }
}
 

public IdEdgeIndex(final Index<Edge> baseIndex, final IdGraph idGraph) {
    if (null == baseIndex) {
        throw new IllegalArgumentException("null base index");
    }
    this.idGraph = idGraph;
    this.baseIndex = baseIndex;
}
 

public <T extends Element> Index<T> getIndex(final String indexName, final Class<T> indexClass) {
    final Index<T> index = this.baseGraph.getIndex(indexName, indexClass);
    if (null == index)
        return null;
    else
        return new EventIndex<T>(index, this);
}
 

@Override
public <T extends Element> Index<T> getIndex(String indexName, Class<T> indexClass) {
  if (indexClass == null) {
    throw ExceptionFactory.classForElementCannotBeNull();
  }
  else if (globals.getConfig().getIndexableGraphDisabled()) {
    throw new UnsupportedOperationException("IndexableGraph is disabled via the configuration");
  }

  return globals.getIndexMetadataWrapper().getIndex(indexName, indexClass);
}
 

@Override
public Iterable<Index<? extends Element>> getIndices() {
  if (globals.getConfig().getIndexableGraphDisabled()) {
    throw new UnsupportedOperationException("IndexableGraph is disabled via the configuration");
  }
  return globals.getIndexMetadataWrapper().getIndices();
}
 

/**
 * Clear out this graph. This drops and recreates the backing tables.
 */
public void clear() {
  shutdown();

  try {
    TableOperations tableOps = globals.getConfig()
        .getConnector().tableOperations();
    for (Index<? extends Element> index : getIndices()) {
      tableOps.delete(((AccumuloIndex<? extends Element>)
          index).getTableName());
    }

    for (String table : globals.getConfig().getTableNames()) {
      if (tableOps.exists(table)) {
        tableOps.delete(table);
        tableOps.create(table);

        SortedSet<Text> splits = globals.getConfig().getSplits();
        if (splits != null) {
          tableOps.addSplits(table, splits);
        }
      }
    }
  } catch (Exception e) {
    throw new AccumuloGraphException(e);
  }
}
 

@Override
    public <T extends Element> Index<T> getIndex(final String indexName, final Class<T> indexClass) {
//        final Index<T> index = getEventableGraph().getIndex(indexName, indexClass);
//        if (null == index) {
//            return null;
//        } else {
//            return new ActiveVersionedIndex<T, V>(index, this);
//        }
        throw new IllegalStateException("Currently not supported.");
    }
 

@Override
    public <T extends Element> Index<T> createIndex(final String indexName, final Class<T> indexClass,
            final Parameter... indexParameters) {
//        return new ActiveVersionedIndex<T, V>(getEventableGraph().createIndex(indexName, indexClass, indexParameters),
//                this);
        throw new IllegalStateException("Currently not supported.");
    }
 

public <T extends Element> Index<T> getIndex(String indexName,
    Class<T> indexClass) {
  IndexedItemsListParser parser = new IndexedItemsListParser();

  Scanner scan = null;
  try {
    scan = getScanner();
    scan.fetchColumnFamily(new Text(IndexMetadataEntryType.__INDEX_NAME__.name()));

    for (IndexedItem item : parser.parse(scan)) {
      if (item.getKey().equals(indexName)) {
        if (item.getElementClass().equals(indexClass)) {
          return new AccumuloIndex<T>(globals, indexName,
              indexClass);
        }
        else {
          throw ExceptionFactory.indexDoesNotSupportClass(indexName, indexClass);
        }
      }
    }
    return null;

  } finally {
    if (scan != null) {
      scan.close();
    }
  }
}
 

public <T extends Element> Index<T> getIndex(final String indexName, final Class<T> indexClass) {
    final Index<T> index = baseGraph.getIndex(indexName, indexClass);
    if (null == index)
        return null;
    else {
        return new WrappedIndex<T>(index);
    }
}
 

public <T extends Element> Index<T> createIndex(String indexName,
    Class<T> indexClass) {
  for (Index<?> index : getIndices()) {
    if (index.getIndexName().equals(indexName)) {
      throw ExceptionFactory.indexAlreadyExists(indexName);
    }
  }

  writeIndexNameEntry(indexName, indexClass);
  return new AccumuloIndex<T>(globals, indexName, indexClass);
}
 

public EventIndex(final Index<T> rawIndex, final EventGraph eventGraph) {
    this.rawIndex = rawIndex;
    this.eventGraph = eventGraph;
}
 

public IndexElementsPipe(final Index<E> index, final String key, final Object value) {
    super.setStarts(index.get(key, value).iterator());
}
 

public Iterable<Index<? extends Element>> getIndices() {
    throw new UnsupportedOperationException("sorry, you currently can't get a list of indexes through IdGraph");
}
 

public EventIndexIterable(final Iterable<Index<T>> iterable, final EventGraph eventGraph) {
    this.iterable = iterable;
    this.eventGraph = eventGraph;
}
 

public <T extends Element> Index<T> createIndex(final String indexName, final Class<T> indexClass, final Parameter... indexParameters) {
    return new EventIndex<T>(this.getBaseGraph().createIndex(indexName, indexClass, indexParameters), this);
}
 

public Iterable<Index<? extends Element>> getIndices() {
    return new EventIndexIterable(this.baseGraph.getIndices(), this);
}
 

public WrappedIndex(final Index<T> rawIndex) {
    this.rawIndex = rawIndex;
}
 

public WrappedIndexIterable(final Iterable<Index<T>> iterable) {
    this.iterable = iterable;
}
 

public <T extends Element> Index<T> createIndex(final String indexName, final Class<T> indexClass, final Parameter... indexParameters) {
    return new WrappedIndex<T>(baseGraph.createIndex(indexName, indexClass, indexParameters));
}