Add TimeFieldIndex

Author: hackerwins

index.go

@@ -8,6 +8,7 @@ import (
 	"reflect"
 	"strconv"
 	"strings"
+	"time"
 )
 
 // Indexer is an interface used for defining indexes. Indexes are used
@@ -670,6 +671,73 @@ func fromBoolArgs(args []interface{}) ([]byte, error) {
 	return []byte{0}, nil
 }
 
+// TimeFieldIndex is used to extract a time.Time field from an object using
+// reflection and builds an index on that field.
+type TimeFieldIndex struct {
+	Field string
+}
+
+func (u *TimeFieldIndex) FromObject(obj interface{}) (bool, []byte, error) {
+	v := reflect.ValueOf(obj)
+	v = reflect.Indirect(v) // Dereference the pointer if any
+
+	fv := v.FieldByName(u.Field)
+	if !fv.IsValid() {
+		return false, nil,
+			fmt.Errorf("field '%s' for %#v is invalid", u.Field, obj)
+	}
+
+	// Check the type
+	k := fv.Kind()
+
+	if ok := IsTimeType(k); !ok {
+		return false, nil, fmt.Errorf("field %q is of type %v; want a time."+
+			"Time", u.Field, k)
+	}
+
+	// Get the value and encode it
+	val := fv.Interface().(time.Time)
+	bufUnix := encodeInt(val.Unix(), 8)
+	bufNano := encodeInt(int64(val.Nanosecond()), 4)
+	buf := append(bufUnix, bufNano...)
+
+	return true, buf, nil
+}
+
+func (u *TimeFieldIndex) FromArgs(args ...interface{}) ([]byte, error) {
+	if len(args) != 1 {
+		return nil, fmt.Errorf("must provide only a single argument")
+	}
+
+	v := reflect.ValueOf(args[0])
+	if !v.IsValid() {
+		return nil, fmt.Errorf("%#v is invalid", args[0])
+	}
+
+	k := v.Kind()
+
+	if ok := IsTimeType(k); !ok {
+		return nil, fmt.Errorf("arg is of type %v; want a time.Time", k)
+	}
+
+	val := v.Interface().(time.Time)
+	bufUnix := encodeInt(val.Unix(), 8)
+	bufNano := encodeInt(int64(val.Nanosecond()), 4)
+	buf := append(bufUnix, bufNano...)
+
+	return buf, nil
+}
+
+// IsTimeType returns whether the passed type is a type of time.Time.
+func IsTimeType(k reflect.Kind) (okay bool) {
+	switch k {
+	case reflect.TypeOf(time.Time{}).Kind():
+		return true
+	default:
+		return false
+	}
+}
+
 // CompoundIndex is used to build an index using multiple sub-indexes
 // Prefix based iteration is supported as long as the appropriate prefix
 // of indexers support it. All sub-indexers are only assumed to expect

index_test.go

@@ -38,6 +38,7 @@ type TestObject struct {
 	Uint32   uint32
 	Uint64   uint64
 	Bool     bool
+	Time     time.Time
 }
 
 func String(s string) *string {
@@ -71,6 +72,7 @@ func testObj() *TestObject {
 		Uint32: uint32(1<<32 - 1),
 		Uint64: uint64(1<<64 - 1),
 		Bool:   false,
+		Time:   time.Unix(0, 0),
 	}
 	return obj
 }
@@ -1224,6 +1226,79 @@ func TestConditionalIndex_FromArgs(t *testing.T) {
 	}
 }
 
+func TestTimeFieldIndex_FromObject(t *testing.T) {
+	obj := testObj()
+	indexer := TimeFieldIndex{Field: "Time"}
+	obj.Time = time.Unix(0, 0)
+	ok, val, err := indexer.FromObject(obj)
+	if err != nil {
+		t.Fatalf("err: %v", err)
+	}
+	if !ok {
+		t.Fatalf("should be ok")
+	}
+
+	etime := make([]byte, 12)
+	binary.BigEndian.PutUint64(etime, 1<<63)
+	binary.BigEndian.PutUint32(etime[8:], 1<<31)
+	if !bytes.Equal(val, etime) {
+		t.Fatalf("bad: %#v %#v", val, etime)
+	}
+
+	// Change the object so it should return with 1 nano.
+	obj.Time = time.Unix(0, 1)
+	ok, val, err = indexer.FromObject(obj)
+	if err != nil {
+		t.Fatalf("err: %v", err)
+	}
+	if !ok {
+		t.Fatalf("should be ok")
+	}
+
+	binary.BigEndian.PutUint64(etime, 1<<63)
+	binary.BigEndian.PutUint32(etime[8:], 1<<31+1)
+	if !bytes.Equal(val, etime) {
+		t.Fatalf("bad: %#v %#v", val, etime)
+	}
+
+	// Pass an invalid type.
+	ok, val, err = indexer.FromObject(t)
+	if err == nil {
+		t.Fatalf("expected an error when passing invalid type")
+	}
+}
+
+func TestTimeFieldIndex_FromArgs(t *testing.T) {
+	indexer := TimeFieldIndex{"Foo"}
+	_, err := indexer.FromArgs()
+	if err == nil {
+		t.Fatalf("should get err")
+	}
+
+	_, err = indexer.FromArgs(int(1), int(2))
+	if err == nil {
+		t.Fatalf("should get err")
+	}
+
+	_, err = indexer.FromArgs("foo")
+	if err == nil {
+		t.Fatalf("should get err")
+	}
+
+	obj := testObj()
+	etime := make([]byte, 12)
+	binary.BigEndian.PutUint64(etime, 1<<63)
+	binary.BigEndian.PutUint32(etime[8:], 1<<31)
+
+	val, err := indexer.FromArgs(obj.Time)
+	if err != nil {
+		t.Fatalf("bad: %v", err)
+	}
+	if !bytes.Equal(val, etime) {
+		t.Fatalf("bad: %#v %#v", val, etime)
+	}
+}
+
 func TestCompoundIndex_FromObject(t *testing.T) {
 	obj := testObj()
 	indexer := &CompoundIndex{