Introduce generic type values.NullableValue and reimplement OptionalBool

modules/indexer/issues/db/options.go

@@ -11,6 +11,7 @@ import (
 	issue_model "code.gitea.io/gitea/models/issues"
 	"code.gitea.io/gitea/modules/container"
 	"code.gitea.io/gitea/modules/indexer/issues/internal"
+	"code.gitea.io/gitea/modules/util"
 )
 
 func ToDBOptions(ctx context.Context, options *internal.SearchOptions) (*issue_model.IssuesOptions, error) {
@@ -75,7 +76,7 @@ func ToDBOptions(ctx context.Context, options *internal.SearchOptions) (*issue_m
 		UpdatedAfterUnix:   convertInt64(options.UpdatedAfterUnix),
 		UpdatedBeforeUnix:  convertInt64(options.UpdatedBeforeUnix),
 		PriorityRepoID:     0,
-		IsArchived:         0,
+		IsArchived:         util.OptionalBoolNone,
 		Org:                nil,
 		Team:               nil,
 		User:               nil,

modules/util/util.go

@@ -12,36 +12,37 @@ import (
 	"strings"
 
 	"code.gitea.io/gitea/modules/optional"
+	"code.gitea.io/gitea/modules/values"
 
 	"golang.org/x/text/cases"
 	"golang.org/x/text/language"
 )
 
 // OptionalBool a boolean that can be "null"
-type OptionalBool byte
+type OptionalBool values.NullableValue[bool]
 
-const (
+var (
 	// OptionalBoolNone a "null" boolean value
-	OptionalBoolNone OptionalBool = iota
+	OptionalBoolNone = OptionalBool(values.None[bool]())
 	// OptionalBoolTrue a "true" boolean value
-	OptionalBoolTrue
+	OptionalBoolTrue = OptionalBool(values.Nullable(true))
 	// OptionalBoolFalse a "false" boolean value
-	OptionalBoolFalse
+	OptionalBoolFalse = OptionalBool(values.Nullable(false))
 )
 
 // IsTrue return true if equal to OptionalBoolTrue
 func (o OptionalBool) IsTrue() bool {
-	return o == OptionalBoolTrue
+	return values.NullableValue[bool](o).Equal(true)
 }
 
 // IsFalse return true if equal to OptionalBoolFalse
 func (o OptionalBool) IsFalse() bool {
-	return o == OptionalBoolFalse
+	return values.NullableValue[bool](o).Equal(false)
 }
 
 // IsNone return true if equal to OptionalBoolNone
 func (o OptionalBool) IsNone() bool {
-	return o == OptionalBoolNone
+	return values.NullableValue[bool](o).IsNone()
 }
 
 // ToGeneric converts OptionalBool to optional.Option[bool]
@@ -52,20 +53,9 @@ func (o OptionalBool) ToGeneric() optional.Option[bool] {
 	return optional.Some[bool](o.IsTrue())
 }
 
-// OptionalBoolFromGeneric converts optional.Option[bool] to OptionalBool
-func OptionalBoolFromGeneric(o optional.Option[bool]) OptionalBool {
-	if o.Has() {
-		return OptionalBoolOf(o.Value())
-	}
-	return OptionalBoolNone
-}
-
 // OptionalBoolOf get the corresponding OptionalBool of a bool
 func OptionalBoolOf(b bool) OptionalBool {
-	if b {
-		return OptionalBoolTrue
-	}
-	return OptionalBoolFalse
+	return OptionalBool(values.Nullable(b))
 }
 
 // OptionalBoolParse get the corresponding OptionalBool of a string using strconv.ParseBool

modules/values/nullable.go

@@ -0,0 +1,30 @@
+// Copyright 2024 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package values
+
+type NullableValue[T comparable] struct {
+	value *T
+	isNil bool
+}
+
+func (n NullableValue[T]) IsNone() bool {
+	return n.isNil
+}
+
+func (n NullableValue[T]) Value() T {
+	// check if the value IsNone first, otherwise panic
+	return *n.value
+}
+
+func (n NullableValue[T]) Equal(v T) bool {
+	return n.value != nil && *n.value == v
+}
+
+func None[T comparable]() NullableValue[T] {
+	return NullableValue[T]{nil, true}
+}
+
+func Nullable[T comparable](value T) NullableValue[T] {
+	return NullableValue[T]{&value, false}
+}

modules/values/nullable_test.go

@@ -0,0 +1,21 @@
+// Copyright 2024 The Gitea Authors. All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package values
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNullable(t *testing.T) {
+	boolV := Nullable(true)
+	assert.True(t, boolV.Value())
+	assert.True(t, boolV.IsSome())
+	assert.False(t, boolV.IsNone())
+
+	nilBool := None[bool]()
+	assert.False(t, nilBool.IsSome())
+	assert.True(t, nilBool.IsNone())
+}