refactor(solver): small naming changes and iterative search

Author: ecordell

pkg/controller/registry/resolver/solver/constraints.go

@@ -5,14 +5,57 @@ import (
 	"strings"
 )
 
+// constrainer is a reusable accumulator of constraint clause terms.
+type constrainer struct {
+	pos []Identifier
+	neg []Identifier
+}
+
+func (x *constrainer) Add(id Identifier) {
+	x.pos = append(x.pos, id)
+}
+
+func (x *constrainer) AddNot(id Identifier) {
+	x.neg = append(x.neg, id)
+}
+
+// Reset clears the receiver's internal state so that it can be
+// reused.
+func (x *constrainer) Reset() {
+	x.pos = x.pos[:0]
+	x.neg = x.neg[:0]
+}
+
+// Empty returns true if and only if the receiver has accumulated no
+// positive or negative terms.
+func (x *constrainer) Empty() bool {
+	return len(x.pos) == 0 && len(x.neg) == 0
+}
+
 // Constraint implementations limit the circumstances under which a
 // particular Installable can appear in a solution.
 type Constraint interface {
 	String(subject Identifier) string
-	apply(x constrainer, subject Identifier)
+	apply(x *constrainer, subject Identifier)
 	order() []Identifier
 }
 
+// zeroConstraint is returned by ConstraintOf in error cases.
+type zeroConstraint struct{}
+
+var _ Constraint = zeroConstraint{}
+
+func (zeroConstraint) String(subject Identifier) string {
+	return ""
+}
+
+func (zeroConstraint) apply(x *constrainer, subject Identifier) {
+}
+
+func (zeroConstraint) order() []Identifier {
+	return nil
+}
+
 // AppliedConstraint values compose a single Constraint with the
 // Installable it applies to.
 type AppliedConstraint struct {
@@ -26,25 +69,13 @@ func (a AppliedConstraint) String() string {
 	return a.Constraint.String(a.Installable.Identifier())
 }
 
-// constrainer is the set of operations available to Constraint
-// implementations.
-type constrainer interface {
-	// Add appends the Installable identified by the given
-	// Identifier to the clause representing a Constraint.
-	Add(Identifier)
-	// Add appends the negation of the Installable identified by
-	// the given Identifier to the clause representing a
-	// Constraint.
-	AddNot(Identifier)
-}
-
 type mandatory struct{}
 
 func (c mandatory) String(subject Identifier) string {
 	return fmt.Sprintf("%s is mandatory", subject)
 }
 
-func (c mandatory) apply(x constrainer, subject Identifier) {
+func (c mandatory) apply(x *constrainer, subject Identifier) {
 	x.Add(subject)
 }
 
@@ -64,7 +95,7 @@ func (c prohibited) String(subject Identifier) string {
 	return fmt.Sprintf("%s is prohibited", subject)
 }
 
-func (c prohibited) apply(x constrainer, subject Identifier) {
+func (c prohibited) apply(x *constrainer, subject Identifier) {
 	x.AddNot(subject)
 }
 
@@ -90,7 +121,7 @@ func (c dependency) String(subject Identifier) string {
 	return fmt.Sprintf("%s requires at least one of %s", subject, strings.Join(s, ", "))
 }
 
-func (c dependency) apply(x constrainer, subject Identifier) {
+func (c dependency) apply(x *constrainer, subject Identifier) {
 	if len(c) == 0 {
 		return
 	}
@@ -119,7 +150,7 @@ func (c conflict) String(subject Identifier) string {
 	return fmt.Sprintf("%s conflicts with %s", subject, c)
 }
 
-func (c conflict) apply(x constrainer, subject Identifier) {
+func (c conflict) apply(x *constrainer, subject Identifier) {
 	x.AddNot(subject)
 	x.AddNot(Identifier(c))
 }

pkg/controller/registry/resolver/solver/constraints_test.go

@@ -12,37 +12,37 @@ func TestConstraints(t *testing.T) {
 		Name       string
 		Constraint Constraint
 		Subject    Identifier
-		Expected   cstate
+		Expected   constrainer
 	}
 
 	for _, tt := range []tc{
 		{
 			Name:       "mandatory",
 			Constraint: Mandatory(),
 			Subject:    "a",
-			Expected: cstate{
+			Expected: constrainer{
 				pos: []Identifier{"a"},
 			},
 		},
 		{
 			Name:       "prohibited",
 			Constraint: Prohibited(),
 			Subject:    "a",
-			Expected: cstate{
+			Expected: constrainer{
 				neg: []Identifier{"a"},
 			},
 		},
 		{
 			Name:       "empty dependency",
 			Constraint: Dependency(),
 			Subject:    "a",
-			Expected:   cstate{},
+			Expected:   constrainer{},
 		},
 		{
 			Name:       "single dependency",
 			Constraint: Dependency("b"),
 			Subject:    "a",
-			Expected: cstate{
+			Expected: constrainer{
 				pos: []Identifier{"b"},
 				neg: []Identifier{"a"},
 			},
@@ -51,7 +51,7 @@ func TestConstraints(t *testing.T) {
 			Name:       "multiple dependency",
 			Constraint: Dependency("x", "y", "z"),
 			Subject:    "a",
-			Expected: cstate{
+			Expected: constrainer{
 				pos: []Identifier{"x", "y", "z"},
 				neg: []Identifier{"a"},
 			},
@@ -60,13 +60,13 @@ func TestConstraints(t *testing.T) {
 			Name:       "conflict",
 			Constraint: Conflict("b"),
 			Subject:    "a",
-			Expected: cstate{
+			Expected: constrainer{
 				neg: []Identifier{"a", "b"},
 			},
 		},
 	} {
 		t.Run(tt.Name, func(t *testing.T) {
-			var x cstate
+			var x constrainer
 			tt.Constraint.apply(&x, tt.Subject)
 
 			// Literals in lexically increasing order:

pkg/controller/registry/resolver/solver/installable.go

@@ -0,0 +1,34 @@
+package solver
+
+// Identifier values uniquely identify particular Installables within
+// the input to a single call to Solve.
+type Identifier string
+
+func (id Identifier) String() string {
+	return string(id)
+}
+
+// Installable values are the basic unit of problems and solutions
+// understood by this package.
+type Installable interface {
+	// Identifier returns the Identifier that uniquely identifies
+	// this Installable among all other Installables in a given
+	// problem.
+	Identifier() Identifier
+	// Constraints returns the set of constraints that apply to
+	// this Installable.
+	Constraints() []Constraint
+}
+
+// zeroInstallable is returned by InstallableOf in error cases.
+type zeroInstallable struct{}
+
+var _ Installable = zeroInstallable{}
+
+func (zeroInstallable) Identifier() Identifier {
+	return ""
+}
+
+func (zeroInstallable) Constraints() []Constraint {
+	return nil
+}