/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkGraph.h

  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/
/*-------------------------------------------------------------------------
  Copyright 2008 Sandia Corporation.
  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
  the U.S. Government retains certain rights in this software.
-------------------------------------------------------------------------*/
// .NAME vtkGraph - Base class for graph data types.
//
// .SECTION Description
// vtkGraph is the abstract base class that provides all read-only API for graph
// data types. A graph consists of a collection of vertices and a
// collection of edges connecting pairs of vertices. The vtkDirectedGraph
// subclass represents a graph whose edges have inherent order from source
// vertex to target vertex, while vtkUndirectedGraph is a graph whose edges
// have no inherent ordering.
//
// Graph vertices may be traversed in two ways. In the current implementation,
// all vertices are assigned consecutive ids starting at zero, so they may
// be traversed in a simple for loop from 0 to graph->GetNumberOfVertices() - 1.
// You may alternately create a vtkVertexListIterator and call graph->GetVertices(it).
// it->Next() will return the id of the next vertex, while it->HasNext() indicates
// whether there are more vertices in the graph.
// This is the preferred method, since in the future graphs may support filtering
// or subsetting where the vertex ids may not be contiguous.
//
// Graph edges must be traversed through iterators. To traverse all edges
// in a graph, create an instance of vtkEdgeListIterator and call graph->GetEdges(it).
// it->Next() returns lightweight vtkEdgeType structures, which contain the public
// fields Id, Source and Target. Id is the identifier for the edge, which may
// be used to look up values in assiciated edge data arrays. Source and Target
// store the ids of the source and target vertices of the edge. Note that the
// edge list iterator DOES NOT necessarily iterate over edges in order of ascending
// id. To traverse edges from wrapper code (Python, Tcl, Java), use
// it->NextGraphEdge() instead of it->Next().  This will return a heavyweight,
// wrappable vtkGraphEdge object, which has the same fields as vtkEdgeType
// accessible through getter methods.
//
// To traverse all edges outgoing from a vertex, create a vtkOutEdgeIterator and
// call graph->GetOutEdges(v, it). it->Next() returns a lightweight vtkOutEdgeType
// containing the fields Id and Target. The source of the edge is always the
// vertex that was passed as an argument to GetOutEdges().
// Incoming edges may be similarly traversed with vtkInEdgeIterator, which returns
// vtkInEdgeType structures with Id and Source fields.
// Both vtkOutEdgeIterator and vtkInEdgeIterator also provide the wrapper functions
// NextGraphEdge() which return vtkGraphEdge objects.
//
// An additional iterator, vtkAdjacentVertexIterator can traverse outgoing vertices
// directly, instead needing to parse through edges. Initialize the iterator by
// calling graph->GetAdjacentVertices(v, it).
//
// vtkGraph has two instances of vtkDataSetAttributes for associated
// vertex and edge data. It also has a vtkPoints instance which may store
// x,y,z locations for each vertex. This is populated by filters such as
// vtkGraphLayout and vtkAssignCoordinates.
//
// All graph types share the same implementation, so the structure of one
// may be shared among multiple graphs, even graphs of different types.
// Structures from vtkUndirectedGraph and vtkMutableUndirectedGraph may be
// shared directly.  Structures from vtkDirectedGraph, vtkMutableDirectedGraph,
// and vtkTree may be shared directly with the exception that setting a
// structure to a tree requires that a "is a tree" test passes.
//
// For graph types that are known to be compatible, calling ShallowCopy()
// or DeepCopy() will work as expected.  When the outcome of a conversion
// is unknown (i.e. setting a graph to a tree), CheckedShallowCopy() and
// CheckedDeepCopy() exist which are identical to ShallowCopy() and DeepCopy(),
// except that instead of emitting an error for an incompatible structure,
// the function returns false.  This allows you to programmatically check
// structure compatibility without causing error messages.
//
// To construct a graph, use vtkMutableDirectedGraph or
// vtkMutableUndirectedGraph. You may then use CheckedShallowCopy
// to set the contents of a mutable graph type into one of the non-mutable
// types vtkDirectedGraph, vtkUndirectedGraph.
// To construct a tree, use vtkMutableDirectedGraph, with directed edges
// which point from the parent to the child, then use CheckedShallowCopy
// to set the structure to a vtkTree.
//
// .SECTION Caveats
// All copy operations implement copy-on-write. The structures are initially
// shared, but if one of the graphs is modified, the structure is copied
// so that to the user they function as if they were deep copied. This means
// that care must be taken if different threads are accessing different graph
// instances that share the same structure. Race conditions may develop if
// one thread is modifying the graph at the same time that another graph is
// copying the structure.
//
// .SECTION Vertex pedigree IDs
// The vertices in a vtkGraph can be associated with pedigree IDs
// through GetVertexData()->SetPedigreeIds. In this case, there is a
// 1-1 mapping between pedigree Ids and vertices. One can query the
// vertex ID based on the pedigree ID using FindVertex, add new
// vertices by pedigree ID with AddVertex, and add edges based on the
// pedigree IDs of the source and target vertices. For example,
// AddEdge("Here", "There") will find (or add) vertices with pedigree
// ID "Here" and "There" and then introduce an edge from "Here" to
// "There".
//
// To configure the vtkGraph with a pedigree ID mapping, create a
// vtkDataArray that will store the pedigree IDs and set that array as
// the pedigree ID array for the vertices via
// GetVertexData()->SetPedigreeIds().
//
// .SECTION Distributed graphs
//
// vtkGraph instances can be distributed across multiple machines, to
// allow the construction and manipulation of graphs larger than a
// single machine could handle. A distributed graph will typically be
// distributed across many different nodes within a cluster, using the
// Message Passing Interface (MPI) to allow those cluster nodes to
// communicate.
//
// An empty vtkGraph can be made into a distributed graph by attaching
// an instance of a vtkDistributedGraphHelper via the
// SetDistributedGraphHelper() method. To determine whether a graph is
// distributed or not, call GetDistributedGraphHelper() and check
// whether the result is non-NULL. For a distributed graph, the number
// of processors across which the graph is distributed can be
// retrieved by extracting the value for the DATA_NUMBER_OF_PIECES key
// in the vtkInformation object (retrieved by GetInformation())
// associated with the graph. Similarly, the value corresponding to
// the DATA_PIECE_NUMBER key of the vtkInformation object describes
// which piece of the data this graph instance provides.
//
// Distributed graphs behave somewhat differently from non-distributed
// graphs, and will require special care. In a distributed graph, each
// of the processors will contain a subset of the vertices in the
// graph. That subset of vertices can be accessed via the
// vtkVertexListIterator produced by GetVertices().
// GetNumberOfVertices(), therefore, returns the number of vertices
// stored locally: it does not account for vertices stored on other
// processors. A vertex (or edge) is identified by both the rank of
// its owning processor and by its index within that processor, both
// of which are encoded within the vtkIdType value that describes that
// vertex (or edge). The owning processor is a value between 0 and
// P-1, where P is the number of processors across which the vtkGraph
// has been distributed. The local index will be a value between 0 and
// GetNumberOfVertices(), for vertices, or GetNumberOfEdges(), for
// edges, and can be used to access the local parts of distributed
// data arrays. When given a vtkIdType identifying a vertex, one can
// determine the owner of the vertex with
// vtkDistributedGraphHelper::GetVertexOwner() and the local index
// with vtkDistributedGraphHelper::GetVertexIndex(). With edges, the
// appropriate methods are vtkDistributedGraphHelper::GetEdgeOwner()
// and vtkDistributedGraphHelper::GetEdgeIndex(), respectively. To
// construct a vtkIdType representing either a vertex or edge given
// only its owner and local index, use
// vtkDistributedGraphHelper::MakeDistributedId().
//
// The edges in a distributed graph are always stored on the
// processors that own the vertices named by the edge. For example,
// given a directed edge (u, v), the edge will be stored in the
// out-edges list for vertex u on the processor that owns u, and in
// the in-edges list for vertex v on the processor that owns v. This
// "row-wise" decomposition of the graph means that, for any vertex
// that is local to a processor, that processor can look at all of the
// incoming and outgoing edges of the graph. Processors cannot,
// however, access the incoming or outgoing edge lists of vertex owned
// by other processors. Vertices owned by other processors will not be
// encountered when traversing the vertex list via GetVertices(), but
// may be encountered by traversing the in- and out-edge lists of
// local vertices or the edge list.
//
// Distributed graphs can have pedigree IDs for the vertices in the
// same way that non-distributed graphs can. In this case, the
// distribution of the vertices in the graph is based on pedigree
// ID. For example, a vertex with the pedigree ID "Here" might land on
// processor 0 while a vertex pedigree ID "There" would end up on
// processor 3. By default, the pedigree IDs themselves are hashed to
// give a random (and, hopefully, even) distribution of the
// vertices. However, one can provide a different vertex distribution
// function by calling
// vtkDistributedGraphHelper::SetVertexPedigreeIdDistribution.  Once a
// distributed graph has pedigree IDs, the no-argument AddVertex()
// method can no longer be used. Additionally, once a vertex has a
// pedigree ID, that pedigree ID should not be changed unless the user
// can guarantee that the vertex distribution will still map that
// vertex to the same processor where it already resides.

// .SECTION See Also
// vtkDirectedGraph vtkUndirectedGraph vtkMutableDirectedGraph
// vtkMutableUndirectedGraph vtkTree vtkDistributedGraphHelper
//
// .SECTION Thanks
// Thanks to Brian Wylie, Timothy Shead, Ken Moreland of Sandia National
// Laboratories and Douglas Gregor of Indiana University for designing these
// classes.

#ifndef __vtkGraph_h
#define __vtkGraph_h

#include "vtkDataObject.h"

class vtkAdjacentVertexIterator;
class vtkCellArray;
class vtkEdgeListIterator;
class vtkDataSetAttributes;
class vtkGraphEdge;
class vtkGraphEdgePoints;
class vtkDistributedGraphHelper;
class vtkGraphInternals;
class vtkIdTypeArray;
class vtkInEdgeIterator;
class vtkOutEdgeIterator;
class vtkPoints;
class vtkVertexListIterator;
class vtkVariant;
class vtkVariantArray;

//BTX
// Forward declare some boost stuff even if boost wrappers
// are turned off.
namespace boost
{
  class vtk_edge_iterator;
  class vtk_out_edge_pointer_iterator;
  class vtk_in_edge_pointer_iterator;
}

// Edge structures.
struct vtkEdgeBase
{
  vtkEdgeBase() { }
  vtkEdgeBase(vtkIdType id) :
    Id(id) { }
  vtkIdType Id;
};

struct vtkOutEdgeType : vtkEdgeBase
{
  vtkOutEdgeType() { }
  vtkOutEdgeType(vtkIdType t, vtkIdType id) :
    vtkEdgeBase(id),
    Target(t) { }
  vtkIdType Target;
};

struct vtkInEdgeType : vtkEdgeBase
{
  vtkInEdgeType() { }
  vtkInEdgeType(vtkIdType s, vtkIdType id) :
    vtkEdgeBase(id),
    Source(s) { }
  vtkIdType Source;
};

struct vtkEdgeType : vtkEdgeBase
{
  vtkEdgeType() { }
  vtkEdgeType(vtkIdType s, vtkIdType t, vtkIdType id) :
    vtkEdgeBase(id),
    Source(s),
    Target(t) { }
  vtkIdType Source;
  vtkIdType Target;
};
//ETX

class VTK_FILTERING_EXPORT vtkGraph : public vtkDataObject
{
public:
  vtkTypeMacro(vtkGraph, vtkDataObject);
  void PrintSelf(ostream& os, vtkIndent indent);

  // Description:
  // Get the vertex or edge data.
  vtkGetObjectMacro(VertexData, vtkDataSetAttributes);
  vtkGetObjectMacro(EdgeData, vtkDataSetAttributes);

  // Description:
  // Return what type of dataset this is.
  virtual int GetDataObjectType() {return VTK_GRAPH;}

  // Description:
  // Initialize to an empty graph.
  virtual void Initialize();

  // Description:
  // These methods return the point (0,0,0) until the points structure
  // is created, when it returns the actual point position. In a
  // distributed graph, only the points for local vertices can be
  // retrieved.
  double *GetPoint(vtkIdType ptId);
  void GetPoint(vtkIdType ptId, double x[3]);

  // Description:
  // Returns the points array for this graph.
  // If points is not yet constructed, generates and returns
  // a new points array filled with (0,0,0) coordinates. In a
  // distributed graph, only the points for local vertices can be
  // retrieved or modified.
  vtkPoints* GetPoints();
  virtual void SetPoints(vtkPoints *points);

  // Description:
  // Compute the bounds of the graph. In a distributed graph, this
  // computes the bounds around the local part of the graph.
  void ComputeBounds();

  // Description:
  // Return a pointer to the geometry bounding box in the form
  // (xmin,xmax, ymin,ymax, zmin,zmax). In a distributed graph, this
  // computes the bounds around the local part of the graph.
  double *GetBounds();
  void GetBounds(double bounds[6]);

  // Description:
  // The modified time of the graph.
  unsigned long int GetMTime();

  // Description:
  // Initializes the out edge iterator to iterate over
  // all outgoing edges of vertex v.  For an undirected graph,
  // returns all incident edges. In a distributed graph, the vertex
  // v must be local to this processor.
  virtual void GetOutEdges(vtkIdType v, vtkOutEdgeIterator *it);

  // Description:
  // The total of all incoming and outgoing vertices for vertex v.
  // For undirected graphs, this is simply the number of edges incident
  // to v. In a distributed graph, the vertex v must be local to this
  // processor.
  virtual vtkIdType GetDegree(vtkIdType v);

  // Description:
  // The number of outgoing edges from vertex v.
  // For undirected graphs, returns the same as GetDegree(). In a
  // distributed graph, the vertex v must be local to this processor.
  virtual vtkIdType GetOutDegree(vtkIdType v);

  //BTX
  // Description:
  // Random-access method for retrieving outgoing edges from vertex v.
  virtual vtkOutEdgeType GetOutEdge(vtkIdType v, vtkIdType index);
  //ETX

  // Description:
  // Random-access method for retrieving outgoing edges from vertex v.
  // The method fills the vtkGraphEdge instance with the id, source, and
  // target of the edge. This method is provided for wrappers,
  // GetOutEdge(vtkIdType, vtkIdType) is preferred.
  virtual void GetOutEdge(vtkIdType v, vtkIdType index, vtkGraphEdge* e);

  // Description:
  // Initializes the in edge iterator to iterate over
  // all incoming edges to vertex v.  For an undirected graph,
  // returns all incident edges. In a distributed graph, the vertex
  // v must be local to this processor.
  virtual void GetInEdges(vtkIdType v, vtkInEdgeIterator *it);

  // Description:
  // The number of incoming edges to vertex v.
  // For undirected graphs, returns the same as GetDegree(). In a
  // distributed graph, the vertex v must be local to this processor.
  virtual vtkIdType GetInDegree(vtkIdType v);

  //BTX
  // Description:
  // Random-access method for retrieving incoming edges to vertex v.
  virtual vtkInEdgeType GetInEdge(vtkIdType v, vtkIdType index);
  //ETX

  // Description:
  // Random-access method for retrieving incoming edges to vertex v.
  // The method fills the vtkGraphEdge instance with the id, source, and
  // target of the edge. This method is provided for wrappers,
  // GetInEdge(vtkIdType, vtkIdType) is preferred.
  virtual void GetInEdge(vtkIdType v, vtkIdType index, vtkGraphEdge* e);

  // Description:
  // Initializes the adjacent vertex iterator to iterate over
  // all outgoing vertices from vertex v.  For an undirected graph,
  // returns all adjacent vertices. In a distributed graph, the vertex
  // v must be local to this processor.
  virtual void GetAdjacentVertices(vtkIdType v, vtkAdjacentVertexIterator *it);

  // Description:
  // Initializes the edge list iterator to iterate over all
  // edges in the graph. Edges may not be traversed in order of
  // increasing edge id. In a distributed graph, this returns edges
  // that are stored locally.
  virtual void GetEdges(vtkEdgeListIterator *it);

  // Description:
  // The number of edges in the graph. In a distributed graph,
  // this returns the number of edges stored locally.
  virtual vtkIdType GetNumberOfEdges();

  // Description:
  // Initializes the vertex list iterator to iterate over all
  // vertices in the graph. In a distributed graph, the iterator
  // traverses all local vertices.
  virtual void GetVertices(vtkVertexListIterator *it);

  // Description:
  // The number of vertices in the graph. In a distributed graph,
  // returns the number of local vertices in the graph.
  virtual vtkIdType GetNumberOfVertices();

  // BTX
  // Description:
  // Sets the distributed graph helper of this graph, turning it into a
  // distributed graph. This operation can only be executed on an empty
  // graph.
  void SetDistributedGraphHelper(vtkDistributedGraphHelper *helper);

  // Description:
  // Retrieves the distributed graph helper for this graph
  vtkDistributedGraphHelper *GetDistributedGraphHelper();
  //ETX

  //BTX
  // Description:
  // Retrieve the vertex with the given pedigree ID. If successful,
  // returns the ID of the vertex. Otherwise, either the vertex data
  // does not have a pedigree ID array or there is no vertex with the
  // given pedigree ID, so this function returns -1.
  // If the graph is a distributed graph, this method will return the
  // Distributed-ID of the vertex.
  vtkIdType FindVertex(const vtkVariant& pedigreeID);
  //ETX

  // Description:
  // Shallow copies the data object into this graph.
  // If it is an incompatible graph, reports an error.
  virtual void ShallowCopy(vtkDataObject *obj);

  // Description:
  // Deep copies the data object into this graph.
  // If it is an incompatible graph, reports an error.
  virtual void DeepCopy(vtkDataObject *obj);

  // Description:
  // Does a shallow copy of the topological information,
  // but not the associated attributes.
  virtual void CopyStructure(vtkGraph *g);

  // Description:
  // Performs the same operation as ShallowCopy(),
  // but instead of reporting an error for an incompatible graph,
  // returns false.
  virtual bool CheckedShallowCopy(vtkGraph *g);

  // Description:
  // Performs the same operation as DeepCopy(),
  // but instead of reporting an error for an incompatible graph,
  // returns false.
  virtual bool CheckedDeepCopy(vtkGraph *g);

  // Decription:
  // Reclaim unused memory.
  virtual void Squeeze();

  //BTX
  // Description:
  // Retrieve a graph from an information vector.
  static vtkGraph *GetData(vtkInformation *info);
  static vtkGraph *GetData(vtkInformationVector *v, int i=0);
  //ETX

  // Description:
  // Reorder the outgoing vertices of a vertex.
  // The vertex list must have the same elements as the current out edge
  // list, just in a different order.
  // This method does not change the topology of the graph.
  // In a distributed graph, the vertex v must be local.
  void ReorderOutVertices(vtkIdType v, vtkIdTypeArray *vertices);

  // Description:
  // Returns true if both graphs point to the same adjacency structure.
  // Can be used to test the copy-on-write feature of the graph.
  bool IsSameStructure(vtkGraph *other);

  // Description:
  // Retrieve the source and target vertices for an edge id.
  // NOTE: The first time this is called, the graph will build
  // a mapping array from edge id to source/target that is the
  // same size as the number of edges in the graph. If you have
  // access to a vtkOutEdgeType, vtkInEdgeType, vtkEdgeType, or
  // vtkGraphEdge, you should directly use these structures
  // to look up the source or target instead of this method.
  vtkIdType GetSourceVertex(vtkIdType e);
  vtkIdType GetTargetVertex(vtkIdType e);

  //BTX
  // Description:
  // Get/Set the internal edge control points associated with each edge.
  // The size of the pts array is 3*npts, and holds the x,y,z
  // location of each edge control point.
  void SetEdgePoints(vtkIdType e, vtkIdType npts, double* pts);
  void GetEdgePoints(vtkIdType e, vtkIdType& npts, double*& pts);
  //ETX

  // Description:
  // Get the number of edge points associated with an edge.
  vtkIdType GetNumberOfEdgePoints(vtkIdType e);

  // Description:
  // Get the x,y,z location of a point along edge e.
  double* GetEdgePoint(vtkIdType e, vtkIdType i);

  // Description:
  // Clear all points associated with an edge.
  void ClearEdgePoints(vtkIdType e);

  // Description:
  // Set an x,y,z location of a point along an edge.
  // This assumes there is already a point at location i, and simply
  // overwrites it.
  void SetEdgePoint(vtkIdType e, vtkIdType i, double x[3]);
  void SetEdgePoint(vtkIdType e, vtkIdType i, double x, double y, double z)
    { double p[3] = {x, y, z}; this->SetEdgePoint(e, i, p); }

  // Description:
  // Adds a point to the end of the list of edge points for a certain edge.
  void AddEdgePoint(vtkIdType e, double x[3]);
  void AddEdgePoint(vtkIdType e, double x, double y, double z)
    { double p[3] = {x, y, z}; this->AddEdgePoint(e, p); }

  // Description:
  // Copy the internal edge point data from another graph into this graph.
  // Both graphs must have the same number of edges.
  void ShallowCopyEdgePoints(vtkGraph* g);
  void DeepCopyEdgePoints(vtkGraph* g);

  // Description:
  // Returns the internal representation of the graph. If modifying is
  // true, then the returned vtkGraphInternals object will be unique to
  // this vtkGraph object.
  vtkGraphInternals *GetGraphInternals(bool modifying);

  // Description:
  // Fills a list of edge indices with the edges contained in the induced
  // subgraph formed by the vertices in the vertex list.
  void GetInducedEdges(vtkIdTypeArray* verts, vtkIdTypeArray* edges);

  // Description:
  // Returns the attributes of the data object as a vtkFieldData.
  // This returns non-null values in all the same cases as GetAttributes,
  // in addition to the case of FIELD, which will return the field data
  // for any vtkDataObject subclass.
  virtual vtkFieldData* GetAttributesAsFieldData(int type);

  // Description:
  // Get the number of elements for a specific attribute type (VERTEX, EDGE, etc.).
  virtual vtkIdType GetNumberOfElements(int type);

  // Description:
  // Dump the contents of the graph to standard output.
  void Dump();

protected:
  //BTX
  vtkGraph();
  ~vtkGraph();

  // Description:
  // Protected method for adding vertices, optionally with properties,
  // used by mutable subclasses. If vertex is non-null, it will be set
  // to the newly-added (or found) vertex. Note that if propertyArr is
  // non-null and the vertex data contains pedigree IDs, a vertex will
  // only be added if there is no vertex with that pedigree ID.
  void AddVertexInternal(vtkVariantArray *propertyArr = 0,
                         vtkIdType *vertex = 0);

  // Description:
  // Adds a vertex with the given pedigree ID to the graph. If a vertex with
  // this pedigree ID already exists, no new vertex is added, but the vertex
  // argument is set to the ID of the existing vertex.  Otherwise, a
  // new vertex is added and its ID is provided.
  void AddVertexInternal(const vtkVariant& pedigree, vtkIdType *vertex);

  // Description:
  // Protected method for adding edges of a certain directedness used
  // by mutable subclasses. If propertyArr is non-null, it specifies
  // the properties to be attached to the newly-created edge. If
  // non-null, edge will receive the newly-added edge.
  void AddEdgeInternal(vtkIdType u, vtkIdType v, bool directed,
                       vtkVariantArray *propertyArr, vtkEdgeType *edge);
  void AddEdgeInternal(const vtkVariant& uPedigree, vtkIdType v, bool directed,
                       vtkVariantArray *propertyArr, vtkEdgeType *edge);
  void AddEdgeInternal(vtkIdType u, const vtkVariant& vPedigree, bool directed,
                       vtkVariantArray *propertyArr, vtkEdgeType *edge);
  void AddEdgeInternal(const vtkVariant& uPedigree, const vtkVariant& vPedigree,
                       bool directed, vtkVariantArray *propertyArr,
                       vtkEdgeType *edge);

  // Description:
  // Removes a vertex from the graph, along with any adjacent edges.
  // This invalidates the id of the last vertex, since it is reassigned to v.
  void RemoveVertexInternal(vtkIdType v, bool directed);

  // Description:
  // Removes an edge from the graph.
  // This invalidates the id of the last edge, since it is reassigned to e.
  void RemoveEdgeInternal(vtkIdType e, bool directed);

  // Description:
  // Removes a collection of vertices from the graph, along with any adjacent edges.
  void RemoveVerticesInternal(vtkIdTypeArray* arr, bool directed);

  // Description:
  // Removes a collection of edges from the graph.
  void RemoveEdgesInternal(vtkIdTypeArray* arr, bool directed);
  //ETX

  // Description:
  // Subclasses override this method to accept the structure
  // based on their requirements.
  virtual bool IsStructureValid(vtkGraph *g) = 0;

  // Description:
  // Copy internal data structure.
  virtual void CopyInternal(vtkGraph *g, bool deep);

  // Description:
  // The adjacency list internals of this graph.
  vtkGraphInternals *Internals;

  // Description:
  // The distributed graph helper. Only non-NULL for distributed graphs.
  vtkDistributedGraphHelper *DistributedHelper;

  // Description:
  // Private method for setting internals.
  void SetInternals(vtkGraphInternals* internals);

  // Description:
  // The structure for holding the edge points.
  vtkGraphEdgePoints *EdgePoints;

  // Description:
  // Private method for setting edge points.
  void SetEdgePoints(vtkGraphEdgePoints* edgePoints);

  // Description:
  // If this instance does not own its internals, it makes a copy of the
  // internals.  This is called before any write operation.
  void ForceOwnership();

  // Description:
  // Fast access functions for iterators.
  virtual void GetOutEdges(vtkIdType v, const vtkOutEdgeType *& edges, vtkIdType & nedges);
  virtual void GetInEdges(vtkIdType v, const vtkInEdgeType *& edges, vtkIdType & nedges);

  // Description:
  // Builds a mapping from edge id to source/target vertex id.
  void BuildEdgeList();

  // Description:
  // Friend iterator classes.
  //BTX
  friend class vtkAdjacentVertexIterator;
  friend class vtkEdgeListIterator;
  friend class vtkInEdgeIterator;
  friend class vtkOutEdgeIterator;
  friend class boost::vtk_edge_iterator;
  friend class boost::vtk_in_edge_pointer_iterator;
  friend class boost::vtk_out_edge_pointer_iterator;
  //ETX

  // Description:
  // The vertex and edge data.
  vtkDataSetAttributes *VertexData;
  vtkDataSetAttributes *EdgeData;

  // Description:
  // (xmin,xmax, ymin,ymax, zmin,zmax) geometric bounds.
  double Bounds[6];

  // Description:
  // Time at which bounds were computed.
  vtkTimeStamp ComputeTime;

  // Description:
  // The vertex locations.
  vtkPoints *Points;
  static double DefaultPoint[3];

  // Description:
  // The optional mapping from edge id to source/target ids.
  vtkGetObjectMacro(EdgeList, vtkIdTypeArray);
  virtual void SetEdgeList(vtkIdTypeArray* list);
  vtkIdTypeArray *EdgeList;
  //ETX
private:
  vtkGraph(const vtkGraph&);  // Not implemented.
  void operator=(const vtkGraph&);  // Not implemented.
};

//BTX
bool VTK_FILTERING_EXPORT operator==(vtkEdgeBase e1, vtkEdgeBase e2);
bool VTK_FILTERING_EXPORT operator!=(vtkEdgeBase e1, vtkEdgeBase e2);
VTK_FILTERING_EXPORT ostream& operator<<(ostream& out, vtkEdgeBase e);
//ETX

#endif
