add OptionalBool type and use it for User.Anonymous (#32)

* add OptionalBool type and use it for User.Anonymous

* comment

lduser/user.go

@@ -57,7 +57,7 @@ type User struct {
 	lastName          ldvalue.OptionalString
 	avatar            ldvalue.OptionalString
 	name              ldvalue.OptionalString
-	anonymous         ldvalue.Value
+	anonymous         ldvalue.OptionalBool
 	custom            ldvalue.Value
 	privateAttributes map[UserAttribute]struct{}
 }
@@ -90,7 +90,7 @@ func (u User) GetAttribute(attribute UserAttribute) ldvalue.Value {
 	case NameAttribute:
 		return u.name.AsValue()
 	case AnonymousAttribute:
-		return u.anonymous
+		return u.anonymous.AsValue()
 	default:
 		value, _ := u.GetCustom(string(attribute))
 		return value
@@ -157,7 +157,7 @@ func (u User) GetAnonymous() bool {
 // GetAnonymousOptional returns the anonymous attribute of the user, with a second value indicating
 // whether that attribute was defined for the user or not.
 func (u User) GetAnonymousOptional() (bool, bool) {
-	return u.anonymous.BoolValue(), !u.anonymous.IsNull()
+	return u.anonymous.Get()
 }
 
 // GetCustom returns a custom attribute of the user by name. The boolean second return value indicates
@@ -207,7 +207,7 @@ func (u User) Equal(other User) bool {
 		u.lastName != other.lastName ||
 		u.avatar != other.avatar ||
 		u.name != other.name ||
-		!u.anonymous.Equal(other.anonymous) {
+		u.anonymous != other.anonymous {
 		return false
 	}
 	if !u.custom.Equal(other.custom) {

lduser/user_builder.go

@@ -9,7 +9,7 @@ func NewUser(key string) User {
 
 // NewAnonymousUser creates a new anonymous user identified by the given key.
 func NewAnonymousUser(key string) User {
-	return User{key: key, anonymous: ldvalue.Bool(true)}
+	return User{key: key, anonymous: ldvalue.NewOptionalBool(true)}
 }
 
 // UserBuilder is a mutable object that uses the Builder pattern to specify properties for a User.
@@ -150,7 +150,7 @@ type userBuilderImpl struct {
 	lastName                    ldvalue.OptionalString
 	avatar                      ldvalue.OptionalString
 	name                        ldvalue.OptionalString
-	anonymous                   ldvalue.Value
+	anonymous                   ldvalue.OptionalBool
 	custom                      ldvalue.ObjectBuilder
 	privateAttrs                map[UserAttribute]struct{}
 	lastAttributeCanMakePrivate UserAttribute
@@ -246,7 +246,7 @@ func (b *userBuilderImpl) Name(value string) UserBuilderCanMakeAttributePrivate
 }
 
 func (b *userBuilderImpl) Anonymous(value bool) UserBuilder {
-	b.anonymous = ldvalue.Bool(value)
+	b.anonymous = ldvalue.NewOptionalBool(value)
 	return b
 }
 
@@ -293,8 +293,11 @@ func (b *userBuilderImpl) SetAttribute(
 	case NameAttribute:
 		setOptString(&b.name)
 	case AnonymousAttribute:
-		if value.IsBool() || value.IsNull() {
-			b.anonymous = value
+		switch {
+		case value.IsNull():
+			b.anonymous = ldvalue.OptionalBool{}
+		case value.IsBool():
+			b.anonymous = ldvalue.NewOptionalBool(value.BoolValue())
 		}
 		okPrivate = false
 	default:

lduser/user_serialization.go

@@ -35,7 +35,7 @@ type userForDeserialization struct {
 	LastName              ldvalue.OptionalString `json:"lastName"`
 	Avatar                ldvalue.OptionalString `json:"avatar"`
 	Name                  ldvalue.OptionalString `json:"name"`
-	Anonymous             ldvalue.Value          `json:"anonymous"`
+	Anonymous             ldvalue.OptionalBool   `json:"anonymous"`
 	Custom                ldvalue.Value          `json:"custom"`
 	PrivateAttributeNames []UserAttribute        `json:"privateAttributeNames"`
 }
@@ -122,7 +122,7 @@ func (u User) WriteToJSONBuffer(j *jsonstream.JSONBuffer) {
 	maybeWriteStringProperty(j, "lastName", u.lastName)
 	maybeWriteStringProperty(j, "avatar", u.avatar)
 	maybeWriteStringProperty(j, "name", u.name)
-	if !u.anonymous.IsNull() {
+	if u.anonymous.IsDefined() {
 		j.WriteName("anonymous")
 		j.WriteBool(u.anonymous.BoolValue())
 	}

ldvalue/benchmark_data_test.go

@@ -1,6 +1,9 @@
 package ldvalue
 
 var (
+	benchmarkBoolValue          = true
+	benchmarkBoolPointer        = &benchmarkBoolValue
+	benchmarkOptBoolWithValue   = NewOptionalBool(benchmarkBoolValue)
 	benchmarkIntValue           = 3333
 	benchmarkIntPointer         = &benchmarkIntValue
 	benchmarkOptIntWithValue    = NewOptionalInt(benchmarkIntValue)
@@ -16,6 +19,7 @@ var (
 	benchmarkSerializeArrayValue  = ArrayOf(String("a"), String("b"), String("c"))
 	benchmarkSerializeObjectValue = ObjectBuild().Set("a", Int(1)).Set("b", Int(2)).Set("c", Int(3)).Build()
 
+	benchmarkOptBoolResult   OptionalBool
 	benchmarkOptIntResult    OptionalInt
 	benchmarkOptStringResult OptionalString
 	benchmarkStringResult    string

ldvalue/constants.go

@@ -2,7 +2,12 @@ package ldvalue
 
 // string literals should be defined here if they are referenced in multiple files
 
-const nullAsJSON = "null"
+const (
+	trueString      = "true"
+	falseString     = "false"
+	nullAsJSON      = "null"
+	noneDescription = "[none]"
+)
 
 // ValueType is defined in value_base.go
 

ldvalue/optional_bool.go

@@ -0,0 +1,163 @@
+package ldvalue
+
+import (
+	"errors"
+
+	"gopkg.in/launchdarkly/go-sdk-common.v2/jsonstream"
+)
+
+// OptionalBool represents a bool that may or may not have a value. This is similar to using a
+// bool pointer to distinguish between a false value and nil, but it is safer because it does not
+// expose a pointer to any mutable value.
+//
+// To create an instance with a bool value, use NewOptionalBool. There is no corresponding method
+// for creating an instance with no value; simply use the empty literal OptionalBool{}.
+//
+//     ob1 := NewOptionalBool(1)
+//     ob2 := NewOptionalBool(false) // this has a value which is false
+//     ob3 := OptionalBool{}         // this does not have a value
+//
+// This can also be used as a convenient way to construct a bool pointer within an expression.
+// For instance, this example causes myIntPointer to point to the bool value true:
+//
+//     var myBoolPointer *int = NewOptionalBool(true).AsPointer()
+//
+// This type is used in the Anonymous property of lduser.User, and for other similar fields in
+// the LaunchDarkly Go SDK where a bool value may or may not be defined.
+type OptionalBool struct {
+	value    bool
+	hasValue bool
+}
+
+// NewOptionalBool constructs an OptionalBool that has a bool value.
+//
+// There is no corresponding method for creating an OptionalBool with no value; simply use the
+// empty literal OptionalBool{}.
+func NewOptionalBool(value bool) OptionalBool {
+	return OptionalBool{value: value, hasValue: true}
+}
+
+// NewOptionalBoolFromPointer constructs an OptionalBool from a bool pointer. If the pointer is
+// non-nil, then the OptionalBool copies its value; otherwise the OptionalBool has no value.
+func NewOptionalBoolFromPointer(valuePointer *bool) OptionalBool {
+	if valuePointer == nil {
+		return OptionalBool{hasValue: false}
+	}
+	return OptionalBool{value: *valuePointer, hasValue: true}
+}
+
+// IsDefined returns true if the OptionalBool contains a bool value, or false if it has no value.
+func (o OptionalBool) IsDefined() bool {
+	return o.hasValue
+}
+
+// BoolValue returns the OptionalBool's value, or false if it has no value.
+func (o OptionalBool) BoolValue() bool {
+	return o.value
+}
+
+// Get is a combination of BoolValue and IsDefined. If the OptionalBool contains a bool value, it
+// returns that value and true; otherwise it returns false and false.
+func (o OptionalBool) Get() (bool, bool) {
+	return o.value, o.hasValue
+}
+
+// OrElse returns the OptionalBool's value if it has one, or else the specified fallback value.
+func (o OptionalBool) OrElse(valueIfEmpty bool) bool {
+	if o.hasValue {
+		return o.value
+	}
+	return valueIfEmpty
+}
+
+// AsPointer returns the OptionalBool's value as a bool pointer if it has a value, or nil
+// otherwise.
+//
+// The bool value, if any, is copied rather than returning to a pointer to the internal field.
+func (o OptionalBool) AsPointer() *bool {
+	if o.hasValue {
+		v := o.value
+		return &v
+	}
+	return nil
+}
+
+// AsValue converts the OptionalBool to a Value, which is either Null() or a boolean value.
+func (o OptionalBool) AsValue() Value {
+	if o.hasValue {
+		return Bool(o.value)
+	}
+	return Null()
+}
+
+// String is a debugging convenience method that returns a description of the OptionalBool. This
+// is either "true", "false, or "[none]" if it has no value.
+func (o OptionalBool) String() string {
+	if o.hasValue {
+		if o.value {
+			return trueString
+		}
+		return falseString
+	}
+	return noneDescription
+}
+
+// MarshalJSON converts the OptionalBool to its JSON representation.
+//
+// The output will be either a JSON boolean or null. Note that the "omitempty" tag for a struct
+// field will not cause an empty OptionalBool field to be omitted; it will be output as null.
+// If you want to completely omit a JSON property when there is no value, it must be a bool
+// pointer instead of an OptionalBool; use the AsPointer() method to get a pointer.
+func (o OptionalBool) MarshalJSON() ([]byte, error) {
+	return o.AsValue().MarshalJSON()
+}
+
+// UnmarshalJSON parses an OptionalBool from JSON.
+//
+// The input must be either a JSON number that is a boolean or null.
+func (o *OptionalBool) UnmarshalJSON(data []byte) error {
+	var v Value
+	if err := v.UnmarshalJSON(data); err != nil {
+		return err // COVERAGE: should not be possible, parser normally doesn't pass malformed content to UnmarshalJSON
+	}
+	switch {
+	case v.IsNull():
+		*o = OptionalBool{}
+	case v.IsBool():
+		*o = NewOptionalBool(v.BoolValue())
+	default:
+		*o = OptionalBool{}
+		return errors.New("expected boolean or null")
+	}
+	return nil
+}
+
+// WriteToJSONBuffer provides JSON serialization for OptionalBool with the jsonstream API.
+//
+// The JSON output format is identical to what is produced by json.Marshal, but this implementation is
+// more efficient when building output with JSONBuffer. See the jsonstream package for more details.
+func (o OptionalBool) WriteToJSONBuffer(j *jsonstream.JSONBuffer) {
+	o.AsValue().WriteToJSONBuffer(j)
+}
+
+// MarshalText implements the encoding.TextMarshaler interface.
+func (o OptionalBool) MarshalText() ([]byte, error) {
+	if o.hasValue {
+		if o.value {
+			return []byte(trueString), nil
+		}
+		return []byte(falseString), nil
+	}
+	return []byte(""), nil
+}
+
+// UnmarshalText implements the encoding.TextUnmarshaler interface.
+//
+// This allows OptionalBool to be used with packages that can parse text content, such as gcfg.
+func (o *OptionalBool) UnmarshalText(text []byte) error {
+	if len(text) == 0 {
+		*o = OptionalBool{}
+		return nil
+	}
+	return o.UnmarshalJSON(text)
+}

ldvalue/optional_bool_benchmark_test.go

@@ -0,0 +1,33 @@
+package ldvalue
+
+import "testing"
+
+func BenchmarkNewOptionalBoolNoAlloc(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		benchmarkOptBoolResult = NewOptionalBool(benchmarkBoolValue)
+	}
+}
+
+func BenchmarkNewOptionalBoolFromPointerNoAlloc(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		benchmarkOptBoolResult = NewOptionalBoolFromPointer(benchmarkBoolPointer)
+	}
+}
+
+func BenchmarkOptionalBoolValueNoAlloc(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		benchmarkBoolResult = benchmarkOptBoolWithValue.BoolValue()
+	}
+}
+
+func BenchmarkOptionalBoolGetNoAlloc(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		benchmarkBoolResult, _ = benchmarkOptBoolWithValue.Get()
+	}
+}
+
+func BenchmarkOptionalBoolAsValueNoAlloc(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		benchmarkValueResult = benchmarkOptBoolWithValue.AsValue()
+	}
+}