change strValues's type to util.StringSet; rename Comparator to Opera…

…tor; small syntax fix

pkg/labels/selector.go

@@ -20,6 +20,8 @@ import (
 	"fmt"
 	"sort"
 	"strings"
+
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
 )
 
 // Selector represents a label selector.
@@ -105,48 +107,42 @@ func (t andTerm) String() string {
 	return strings.Join(terms, ",")
 }
 
-type Comparator int
+// Operator represents a key's relationship
+// to a set of values in a Requirement.
+// TODO: Should also represent key's existence.
+type Operator int
 
 const (
-	IN Comparator = iota + 1
+	IN Operator = iota + 1
 	NOT_IN
 )
 
-// only not named 'Selector' due to name
-// conflict until Selector is deprecated
+// LabelSelector only not named 'Selector' due
+// to name conflict until Selector is deprecated.
 type LabelSelector struct {
 	Requirements []Requirement
 }
 
 type Requirement struct {
-	key        string
-	comparator Comparator
-	strValues  []string
-}
-
-func (r *Requirement) containsStr(value string) bool {
-	for _, x := range r.strValues {
-		if value == x {
-			return true
-		}
-	}
-	return false
+	key       string
+	operator  Operator
+	strValues util.StringSet
 }
 
 func (r *Requirement) Matches(ls Labels) bool {
-	switch r.comparator {
+	switch r.operator {
 	case IN:
-		return r.containsStr(ls.Get(r.key))
+		return r.strValues.Has(ls.Get(r.key))
 	case NOT_IN:
-		return !r.containsStr(ls.Get(r.key))
+		return !r.strValues.Has(ls.Get(r.key))
 	default:
 		return false
 	}
 }
 
 func (sg *LabelSelector) Matches(ls Labels) bool {
 	for _, req := range sg.Requirements {
-		if sat := req.Matches(ls); !sat {
+		if !req.Matches(ls) {
 			return false
 		}
 	}

pkg/labels/selector_test.go

@@ -18,6 +18,8 @@ package labels
 
 import (
 	"testing"
+
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
 )
 
 func TestSelectorParse(t *testing.T) {
@@ -178,10 +180,10 @@ func expectNoMatchRequirement(t *testing.T, req Requirement, ls Set) {
 
 func TestRequirementMatches(t *testing.T) {
 	s := Set{"x": "foo", "y": "baz"}
-	a := Requirement{key: "x", comparator: IN, strValues: []string{"foo"}}
-	b := Requirement{key: "x", comparator: NOT_IN, strValues: []string{"beta"}}
-	c := Requirement{key: "y", comparator: IN, strValues: nil}
-	d := Requirement{key: "y", strValues: []string{"foo"}}
+	a := Requirement{key: "x", operator: IN, strValues: util.NewStringSet("foo")}
+	b := Requirement{key: "x", operator: NOT_IN, strValues: util.NewStringSet("beta")}
+	c := Requirement{key: "y", operator: IN, strValues: nil}
+	d := Requirement{key: "y", strValues: util.NewStringSet("foo")}
 	expectMatchRequirement(t, a, s)
 	expectMatchRequirement(t, b, s)
 	expectNoMatchRequirement(t, c, s)
@@ -204,14 +206,14 @@ func TestLabelSelectorMatches(t *testing.T) {
 	s := Set{"x": "foo", "y": "baz"}
 	allMatch := LabelSelector{
 		Requirements: []Requirement{
-			{key: "x", comparator: IN, strValues: []string{"foo"}},
-			{key: "y", comparator: NOT_IN, strValues: []string{"alpha"}},
+			{key: "x", operator: IN, strValues: util.NewStringSet("foo")},
+			{key: "y", operator: NOT_IN, strValues: util.NewStringSet("alpha")},
 		},
 	}
 	singleNonMatch := LabelSelector{
 		Requirements: []Requirement{
-			{key: "x", comparator: IN, strValues: []string{"foo"}},
-			{key: "y", comparator: IN, strValues: []string{"alpha"}},
+			{key: "x", operator: IN, strValues: util.NewStringSet("foo")},
+			{key: "y", operator: IN, strValues: util.NewStringSet("alpha")},
 		},
 	}
 	expectMatchLabSelector(t, allMatch, s)