rename gg.HalfEdge to gg.OpenEdge
This commit is contained in:
Brian Picciano
parent
11328fa76c
commit
cae3116424
90
gg/gg.go
90
gg/gg.go
@ -8,8 +8,6 @@ import (
|
||||
"hash"
|
||||
)
|
||||
|
||||
// TODO rename half-edge to open-edge
|
||||
|
||||
// Identifier is implemented by any value which can return a unique string for
|
||||
// itself via an Identify method
|
||||
type Identifier interface {
|
||||
@ -53,9 +51,9 @@ type Vertex struct {
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// HalfEdge is an un-realized Edge which can't be used for anything except
|
||||
// OpenEdge is an un-realized Edge which can't be used for anything except
|
||||
// constructing graphs. It has no meaning on its own.
|
||||
type HalfEdge struct {
|
||||
type OpenEdge struct {
|
||||
// fromV will be the source vertex as-if the vertex (and any sub-vertices of
|
||||
// it) doesn't already exist in the graph. If it or it's sub-vertices does
|
||||
// already that will need to be taken into account when persisting into the
|
||||
@ -65,19 +63,19 @@ type HalfEdge struct {
|
||||
}
|
||||
|
||||
// Identify implements the Identifier interface
|
||||
func (he HalfEdge) Identify(h hash.Hash) {
|
||||
fmt.Fprintln(h, "halfEdge")
|
||||
he.fromV.Identify(h)
|
||||
he.val.Identify(h)
|
||||
func (oe OpenEdge) Identify(h hash.Hash) {
|
||||
fmt.Fprintln(h, "openEdge")
|
||||
oe.fromV.Identify(h)
|
||||
oe.val.Identify(h)
|
||||
}
|
||||
|
||||
// vertex is a representation of a vertex in the graph. Each Graph contains a
|
||||
// set of all the Value vertex instances it knows about. Each of these contains
|
||||
// all the input HalfEdges which are known for it. So you can think of these
|
||||
// "top-level" Value vertex instances as root nodes in a tree, and each HalfEdge
|
||||
// all the input OpenEdges which are known for it. So you can think of these
|
||||
// "top-level" Value vertex instances as root nodes in a tree, and each OpenEdge
|
||||
// as a branch.
|
||||
//
|
||||
// If a HalfEdge contains a fromV which is a Value that vertex won't have its in
|
||||
// If a OpenEdge contains a fromV which is a Value that vertex won't have its in
|
||||
// slice populated no matter what. If fromV is a Junction it will be populated,
|
||||
// with any sub-Value's not being populated and so-on recursively
|
||||
//
|
||||
@ -86,7 +84,7 @@ func (he HalfEdge) Identify(h hash.Hash) {
|
||||
type vertex struct {
|
||||
VertexType
|
||||
val Identifier
|
||||
in []HalfEdge
|
||||
in []OpenEdge
|
||||
}
|
||||
|
||||
// A Value vertex is unique by the value it contains
|
||||
@ -108,25 +106,25 @@ func (v vertex) Identify(h hash.Hash) {
|
||||
|
||||
func (v vertex) cp() vertex {
|
||||
cp := v
|
||||
cp.in = make([]HalfEdge, len(v.in))
|
||||
cp.in = make([]OpenEdge, len(v.in))
|
||||
copy(cp.in, v.in)
|
||||
return cp
|
||||
}
|
||||
|
||||
func (v vertex) hasHalfEdge(he HalfEdge) bool {
|
||||
heID := identify(he)
|
||||
func (v vertex) hasOpenEdge(oe OpenEdge) bool {
|
||||
oeID := identify(oe)
|
||||
for _, in := range v.in {
|
||||
if identify(in) == heID {
|
||||
if identify(in) == oeID {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (v vertex) cpAndDelHalfEdge(he HalfEdge) (vertex, bool) {
|
||||
heID := identify(he)
|
||||
func (v vertex) cpAndDelOpenEdge(oe OpenEdge) (vertex, bool) {
|
||||
oeID := identify(oe)
|
||||
for i, in := range v.in {
|
||||
if identify(in) == heID {
|
||||
if identify(in) == oeID {
|
||||
v = v.cp()
|
||||
v.in = append(v.in[:i], v.in[i+1:]...)
|
||||
return v, true
|
||||
@ -162,15 +160,15 @@ func (g *Graph) cp() *Graph {
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Graph creation
|
||||
|
||||
// ValueOut creates a HalfEdge which, when used to construct a Graph, represents
|
||||
// ValueOut creates a OpenEdge which, when used to construct a Graph, represents
|
||||
// an edge (with edgeVal attached to it) leaving the Value Vertex containing
|
||||
// val.
|
||||
//
|
||||
// When constructing Graphs Value vertices are de-duplicated on their value. So
|
||||
// multiple ValueOut HalfEdges constructed with the same val will be leaving the
|
||||
// multiple ValueOut OpenEdges constructed with the same val will be leaving the
|
||||
// same Vertex instance in the constructed Graph.
|
||||
func ValueOut(val, edgeVal Identifier) HalfEdge {
|
||||
return HalfEdge{
|
||||
func ValueOut(val, edgeVal Identifier) OpenEdge {
|
||||
return OpenEdge{
|
||||
fromV: vertex{
|
||||
VertexType: Value,
|
||||
val: val,
|
||||
@ -179,15 +177,15 @@ func ValueOut(val, edgeVal Identifier) HalfEdge {
|
||||
}
|
||||
}
|
||||
|
||||
// JunctionOut creates a HalfEdge which, when used to construct a Graph,
|
||||
// JunctionOut creates a OpenEdge which, when used to construct a Graph,
|
||||
// represents an edge (with edgeVal attached to it) leaving the Junction Vertex
|
||||
// comprised of the given ordered-set of input edges.
|
||||
//
|
||||
// When constructing Graphs Junction vertices are de-duplicated on their input
|
||||
// edges. So multiple Junction HalfEdges constructed with the same set of input
|
||||
// edges. So multiple Junction OpenEdges constructed with the same set of input
|
||||
// edges will be leaving the same Junction instance in the constructed Graph.
|
||||
func JunctionOut(in []HalfEdge, edgeVal Identifier) HalfEdge {
|
||||
return HalfEdge{
|
||||
func JunctionOut(in []OpenEdge, edgeVal Identifier) OpenEdge {
|
||||
return OpenEdge{
|
||||
fromV: vertex{
|
||||
VertexType: Junction,
|
||||
in: in,
|
||||
@ -196,11 +194,11 @@ func JunctionOut(in []HalfEdge, edgeVal Identifier) HalfEdge {
|
||||
}
|
||||
}
|
||||
|
||||
// AddValueIn takes a HalfEdge and connects it to the Value Vertex containing
|
||||
// AddValueIn takes a OpenEdge and connects it to the Value Vertex containing
|
||||
// val, returning the new Graph which reflects that connection. Any Vertices
|
||||
// referenced within the HalfEdge which do not yet exist in the Graph will also
|
||||
// referenced within toe OpenEdge which do not yet exist in the Graph will also
|
||||
// be created in this step.
|
||||
func (g *Graph) AddValueIn(he HalfEdge, val Identifier) *Graph {
|
||||
func (g *Graph) AddValueIn(oe OpenEdge, val Identifier) *Graph {
|
||||
to := vertex{
|
||||
VertexType: Value,
|
||||
val: val,
|
||||
@ -214,12 +212,12 @@ func (g *Graph) AddValueIn(he HalfEdge, val Identifier) *Graph {
|
||||
}
|
||||
|
||||
// if the incoming edge already exists in to then there's nothing to do
|
||||
if to.hasHalfEdge(he) {
|
||||
if to.hasOpenEdge(oe) {
|
||||
return g
|
||||
}
|
||||
|
||||
to = to.cp()
|
||||
to.in = append(to.in, he)
|
||||
to.in = append(to.in, oe)
|
||||
g = g.cp()
|
||||
|
||||
// starting with to (which we always overwrite) go through vM and
|
||||
@ -246,12 +244,12 @@ func (g *Graph) AddValueIn(he HalfEdge, val Identifier) *Graph {
|
||||
return g
|
||||
}
|
||||
|
||||
// DelValueIn takes a HalfEdge and disconnects it from the Value Vertex
|
||||
// DelValueIn takes a OpenEdge and disconnects it from the Value Vertex
|
||||
// containing val, returning the new Graph which reflects the disconnection. If
|
||||
// the Value Vertex doesn't exist within the graph, or it doesn't have the given
|
||||
// HalfEdge, no changes are made. Any vertices referenced by the HalfEdge for
|
||||
// OpenEdge, no changes are made. Any vertices referenced by toe OpenEdge for
|
||||
// which that edge is their only outgoing edge will be removed from the Graph.
|
||||
func (g *Graph) DelValueIn(he HalfEdge, val Identifier) *Graph {
|
||||
func (g *Graph) DelValueIn(oe OpenEdge, val Identifier) *Graph {
|
||||
to := vertex{
|
||||
VertexType: Value,
|
||||
val: val,
|
||||
@ -266,7 +264,7 @@ func (g *Graph) DelValueIn(he HalfEdge, val Identifier) *Graph {
|
||||
|
||||
// get new copy of to without the half-edge, or return if the half-edge
|
||||
// wasn't even in to
|
||||
to, ok = to.cpAndDelHalfEdge(he)
|
||||
to, ok = to.cpAndDelOpenEdge(oe)
|
||||
if !ok {
|
||||
return g
|
||||
}
|
||||
@ -309,19 +307,19 @@ func (g *Graph) DelValueIn(he HalfEdge, val Identifier) *Graph {
|
||||
delete(g.vM, toID)
|
||||
}
|
||||
|
||||
// rmOrphaned descends down the given HalfEdge and removes any Value
|
||||
// rmOrphaned descends down the given OpenEdge and removes any Value
|
||||
// Vertices referenced in it which are now orphaned
|
||||
var rmOrphaned func(HalfEdge)
|
||||
rmOrphaned = func(he HalfEdge) {
|
||||
if he.fromV.VertexType == Value && isOrphaned(he.fromV) {
|
||||
delete(g.vM, identify(he.fromV))
|
||||
} else if he.fromV.VertexType == Junction {
|
||||
for _, juncHe := range he.fromV.in {
|
||||
var rmOrphaned func(OpenEdge)
|
||||
rmOrphaned = func(oe OpenEdge) {
|
||||
if oe.fromV.VertexType == Value && isOrphaned(oe.fromV) {
|
||||
delete(g.vM, identify(oe.fromV))
|
||||
} else if oe.fromV.VertexType == Junction {
|
||||
for _, juncHe := range oe.fromV.in {
|
||||
rmOrphaned(juncHe)
|
||||
}
|
||||
}
|
||||
}
|
||||
rmOrphaned(he)
|
||||
rmOrphaned(oe)
|
||||
|
||||
return g
|
||||
}
|
||||
@ -337,7 +335,7 @@ func (g *Graph) Union(g2 *Graph) *Graph {
|
||||
v = v2
|
||||
} else {
|
||||
for _, v2e := range v2.in {
|
||||
if !v.hasHalfEdge(v2e) {
|
||||
if !v.hasOpenEdge(v2e) {
|
||||
v.in = append(v.in, v2e)
|
||||
}
|
||||
}
|
||||
@ -432,7 +430,7 @@ func Equal(g1, g2 *Graph) bool {
|
||||
return false
|
||||
}
|
||||
for _, in := range v1.in {
|
||||
if !v2.hasHalfEdge(in) {
|
||||
if !v2.hasOpenEdge(in) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
@ -156,7 +156,7 @@ func TestGraph(t *T) {
|
||||
func() *Graph {
|
||||
e0 := ValueOut(id("v0"), id("e0"))
|
||||
e1 := ValueOut(id("v1"), id("e1"))
|
||||
ej0 := JunctionOut([]HalfEdge{e0, e1}, id("ej0"))
|
||||
ej0 := JunctionOut([]OpenEdge{e0, e1}, id("ej0"))
|
||||
return Null.AddValueIn(ej0, id("v2"))
|
||||
},
|
||||
value("v0"), value("v1"),
|
||||
@ -171,11 +171,11 @@ func TestGraph(t *T) {
|
||||
func() *Graph {
|
||||
e00 := ValueOut(id("v0"), id("e00"))
|
||||
e10 := ValueOut(id("v1"), id("e10"))
|
||||
ej0 := JunctionOut([]HalfEdge{e00, e10}, id("ej0"))
|
||||
ej0 := JunctionOut([]OpenEdge{e00, e10}, id("ej0"))
|
||||
e01 := ValueOut(id("v0"), id("e01"))
|
||||
e11 := ValueOut(id("v1"), id("e11"))
|
||||
ej1 := JunctionOut([]HalfEdge{e01, e11}, id("ej1"))
|
||||
ej2 := JunctionOut([]HalfEdge{ej0, ej1}, id("ej2"))
|
||||
ej1 := JunctionOut([]OpenEdge{e01, e11}, id("ej1"))
|
||||
ej2 := JunctionOut([]OpenEdge{ej0, ej1}, id("ej2"))
|
||||
return Null.AddValueIn(ej2, id("v2"))
|
||||
},
|
||||
value("v0"), value("v1"),
|
||||
@ -196,7 +196,7 @@ func TestGraph(t *T) {
|
||||
func() *Graph {
|
||||
e0 := ValueOut(id("v0"), id("e0"))
|
||||
e1 := ValueOut(id("v1"), id("e1"))
|
||||
ej0 := JunctionOut([]HalfEdge{e0, e1}, id("ej0"))
|
||||
ej0 := JunctionOut([]OpenEdge{e0, e1}, id("ej0"))
|
||||
g0 := Null.AddValueIn(ej0, id("v2"))
|
||||
e20 := ValueOut(id("v2"), id("e20"))
|
||||
g1 := g0.AddValueIn(e20, id("v0"))
|
||||
@ -275,27 +275,27 @@ func TestGraphDelValueIn(t *T) {
|
||||
}
|
||||
|
||||
{ // removing only edge
|
||||
he := ValueOut(id("v0"), id("e0"))
|
||||
g0 := Null.AddValueIn(he, id("v1"))
|
||||
g1 := g0.DelValueIn(he, id("v1"))
|
||||
oe := ValueOut(id("v0"), id("e0"))
|
||||
g0 := Null.AddValueIn(oe, id("v1"))
|
||||
g1 := g0.DelValueIn(oe, id("v1"))
|
||||
assert.True(t, Equal(Null, g1))
|
||||
}
|
||||
|
||||
{ // removing only edge (junction)
|
||||
he := JunctionOut([]HalfEdge{
|
||||
oe := JunctionOut([]OpenEdge{
|
||||
ValueOut(id("v0"), id("e0")),
|
||||
ValueOut(id("v1"), id("e1")),
|
||||
}, id("ej0"))
|
||||
g0 := Null.AddValueIn(he, id("v2"))
|
||||
g1 := g0.DelValueIn(he, id("v2"))
|
||||
g0 := Null.AddValueIn(oe, id("v2"))
|
||||
g1 := g0.DelValueIn(oe, id("v2"))
|
||||
assert.True(t, Equal(Null, g1))
|
||||
}
|
||||
|
||||
{ // removing one of two edges
|
||||
he := ValueOut(id("v1"), id("e0"))
|
||||
oe := ValueOut(id("v1"), id("e0"))
|
||||
g0 := Null.AddValueIn(ValueOut(id("v0"), id("e0")), id("v2"))
|
||||
g1 := g0.AddValueIn(he, id("v2"))
|
||||
g2 := g1.DelValueIn(he, id("v2"))
|
||||
g1 := g0.AddValueIn(oe, id("v2"))
|
||||
g2 := g1.DelValueIn(oe, id("v2"))
|
||||
assert.True(t, Equal(g0, g2))
|
||||
assert.NotNil(t, g2.Value(id("v0")))
|
||||
assert.Nil(t, g2.Value(id("v1")))
|
||||
@ -306,11 +306,11 @@ func TestGraphDelValueIn(t *T) {
|
||||
e0 := ValueOut(id("v0"), id("e0"))
|
||||
e1 := ValueOut(id("v1"), id("e1"))
|
||||
e2 := ValueOut(id("v2"), id("e2"))
|
||||
heA := JunctionOut([]HalfEdge{e0, e1}, id("heA"))
|
||||
heB := JunctionOut([]HalfEdge{e1, e2}, id("heB"))
|
||||
g0a := Null.AddValueIn(heA, id("v3"))
|
||||
g0b := Null.AddValueIn(heB, id("v3"))
|
||||
g1 := g0a.Union(g0b).DelValueIn(heA, id("v3"))
|
||||
oeA := JunctionOut([]OpenEdge{e0, e1}, id("oeA"))
|
||||
oeB := JunctionOut([]OpenEdge{e1, e2}, id("oeB"))
|
||||
g0a := Null.AddValueIn(oeA, id("v3"))
|
||||
g0b := Null.AddValueIn(oeB, id("v3"))
|
||||
g1 := g0a.Union(g0b).DelValueIn(oeA, id("v3"))
|
||||
assert.True(t, Equal(g1, g0b))
|
||||
assert.Nil(t, g1.Value(id("v0")))
|
||||
assert.NotNil(t, g1.Value(id("v1")))
|
||||
@ -329,7 +329,7 @@ func TestGraphDelValueIn(t *T) {
|
||||
}
|
||||
|
||||
{ // removing to's only edge, sub-nodes have edge to each other
|
||||
ej := JunctionOut([]HalfEdge{
|
||||
ej := JunctionOut([]OpenEdge{
|
||||
ValueOut(id("v0"), id("ej0")),
|
||||
ValueOut(id("v1"), id("ej0")),
|
||||
}, id("ej"))
|
||||
@ -370,11 +370,11 @@ func TestGraphUnion(t *T) {
|
||||
}
|
||||
|
||||
{ // Two disparate graphs with junctions
|
||||
ga := Null.AddValueIn(JunctionOut([]HalfEdge{
|
||||
ga := Null.AddValueIn(JunctionOut([]OpenEdge{
|
||||
ValueOut(id("va0"), id("ea0")),
|
||||
ValueOut(id("va1"), id("ea1")),
|
||||
}, id("eaj")), id("va2"))
|
||||
gb := Null.AddValueIn(JunctionOut([]HalfEdge{
|
||||
gb := Null.AddValueIn(JunctionOut([]OpenEdge{
|
||||
ValueOut(id("vb0"), id("eb0")),
|
||||
ValueOut(id("vb1"), id("eb1")),
|
||||
}, id("ebj")), id("vb2"))
|
||||
@ -413,11 +413,11 @@ func TestGraphUnion(t *T) {
|
||||
}
|
||||
|
||||
{ // two partially overlapping graphs with junctions
|
||||
g0 := Null.AddValueIn(JunctionOut([]HalfEdge{
|
||||
g0 := Null.AddValueIn(JunctionOut([]OpenEdge{
|
||||
ValueOut(id("v0"), id("e0")),
|
||||
ValueOut(id("v1"), id("e1")),
|
||||
}, id("ej0")), id("v2"))
|
||||
g1 := Null.AddValueIn(JunctionOut([]HalfEdge{
|
||||
g1 := Null.AddValueIn(JunctionOut([]OpenEdge{
|
||||
ValueOut(id("v0"), id("e0")),
|
||||
ValueOut(id("v1"), id("e1")),
|
||||
}, id("ej1")), id("v2"))
|
||||
@ -444,7 +444,7 @@ func TestGraphUnion(t *T) {
|
||||
}
|
||||
|
||||
{ // Two equal graphs with junctions
|
||||
g0 := Null.AddValueIn(JunctionOut([]HalfEdge{
|
||||
g0 := Null.AddValueIn(JunctionOut([]OpenEdge{
|
||||
ValueOut(id("v0"), id("e0")),
|
||||
ValueOut(id("v1"), id("e1")),
|
||||
}, id("ej0")), id("v2"))
|
||||
@ -500,8 +500,8 @@ func TestGraphEqual(t *T) {
|
||||
{ // junction basic test
|
||||
e0 := ValueOut(id("v0"), id("e0"))
|
||||
e1 := ValueOut(id("v1"), id("e1"))
|
||||
ga := Null.AddValueIn(JunctionOut([]HalfEdge{e0, e1}, id("ej")), id("v2"))
|
||||
gb := Null.AddValueIn(JunctionOut([]HalfEdge{e1, e0}, id("ej")), id("v2"))
|
||||
ga := Null.AddValueIn(JunctionOut([]OpenEdge{e0, e1}, id("ej")), id("v2"))
|
||||
gb := Null.AddValueIn(JunctionOut([]OpenEdge{e1, e0}, id("ej")), id("v2"))
|
||||
assertEqual(ga, ga)
|
||||
assertNotEqual(ga, gb)
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user