The e4_Vertex class provides the abstraction of a vertex originating from a node. A vertex is associated with a node, its originating node. The e4_Vertex class provides a method to obtain an instance of e4_Node that represents the originating node. Vertices can also be detached, in which case they are not associated with any originating node. A vertex may become detached as a result of some operation on its containing storage, such as detaching a vertex or a node. It is also possible to create detached vertices directly using the CreateDetachedVertex methods on class e4_Storage.

Vertices are identified by name and instance count or by rank within the originating node. Each vertex stores a value of a specific type, a node, an integer, a 64-bit floating point number, a NULL terminated string, or a binary uninterpreted value of variable size. It is usually orders of magnitude more efficient to manipulate the attributes of a vertex through an instance of e4_Vertex rather than indirectly through the instance of e4_Node that represents the node containing the vertex.

The underlying representation of vertices is reference counted. When the last instance of e4_Vertex referring to a vertex is deleted, the reference count for the underlying vertex representation reaches zero and its memory is freed automatically. Note that changes to the attributes of a vertex are written out to persistent storage only when the storage is committed.

Instances of e4_Vertex are not constructed directly by a user program. Instead, they are obtained as the output of various operations on other elements. For example:

e4_Node n;
e4_Vertex v;
...
if (!n.GetVertexRef("joe", 3, v)) {
    cerr << "Third vertex named \"joe\" not found.\n";
}
...
if (!n.GetVertexRefByRank(2, v)) {
    cerr << "This node does not have 2 vertices.\n";
}

The e4_Vertex class provides assignment and comparison operators. When one instance of e4_Vertex is assigned to another, they now refer to the same vertex. The comparison operators allow a user program to determine whether two instances of e4_Vertex refer to the same vertex:

e4_Node n;
e4_Vertex v1, v2, v3, v4;
...
if (!n.GetVertexRef("joe", 2, v1)) {
    cerr << "Second vertex named \"joe\" not found.\";
}
...
if (!n.GetVertexRefByRank(3, v2)) {
    cerr << "This node does not have 3 vertices.\n";
}
...
v3 = v1;
v4 = v2;
if (v1 == v2) {
    if (v3 != v4) {
        cerr << "Something fishy here!\n";
    }
}

e4_Node n;
e4_Vertex v;
...
if (!n.GetVertexRef("joe", 2, v)) {
    cerr << "Second vertex named \"joe\" not found.\n";
}
...
v = invalidVertex;
if (v.IsValid()) {
    cerr << "Something fishy here!\n";
}

A node may contain any number of vertices. A vertex is identified by a name and count pair or by a rank within the node containing it. More than one vertex with the same name can occur within a given node, hence the vertex can be addressed by a name and count pair. Rank is one-based, that is, the first vertex within a node is ranked one. A vertex stores a value of a specific type; supported types are node, integer, 64-bit floating point value, NULL terminated string and uninterpreted binary value of variable length. The e4_Vertex class provides a wide range of methods to manipulate the attributes of a vertex such as its name, type, value and rank. In the following example, a vertex named joe is renamed to barney and then its value is set to an integer value of 42. Next, the vertex's type is changed to 64-bit floating point and its value is changed to 3.14:

e4_Node n;
e4_Vertex v;
...
if (!n.GetVertexRef("joe", v)) {
    cerr << "First vertex named \"joe\" not found.\n";
}
...
if (!v.Rename("barney")) {
    cerr << "Couldn't rename vertex to \"barney\".\n";
}
if (!v.Set(42)) {
    cerr << "Couldn't set vertex value to int value 42.\n";
}
if (!v.Set((double) 3.14)) {
    cerr << "Couldn't set vertex value to double value 3.14.\n";
}

When setting a vertex value to a NULL terminated string, you can use NULL as the assigned value. If you use NULL, you may have to cast it as (const char *) to disambiguate the method. Similarly, when setting a vertex value to binary uninterpreted data, you can use NULL as the value and also pass zero as the length argument:

e4_Vertex v;
...
if (!v.Set((const char *) NULL)) {
    cerr << "Strange.\n";
}
if (!v.Set((const void *) NULL, 0)) {
    cerr << "Even stranger.\n";
}

e4_Node n;
e4_Vertex v;
int ii;
double dd;
...
if (!n.GetVertexRef("joe", v)) {
    cerr << "First vertex named \"joe\" not found.\n";
}
...
if (!v.Get(ii)) {
    cerr << "Could not retrieve int value of vertex.\n";
}
(void) v.Set((double) 3.14);
if (!v.Get(dd)) {
    cerr << "Strange!\n";
}