From 1f476c9078d88dbfee32d7fff60f06f5b197dd0e Mon Sep 17 00:00:00 2001 From: Travis Turner Date: Mon, 4 Jun 2018 15:32:43 -0500 Subject: [PATCH] rename oField to bsiGroup --- api.go | 12 ++--- frame.go | 113 +++++++++++++++++++------------------- frame_internal_test.go | 120 ++++++++++++++++++++--------------------- 3 files changed, 122 insertions(+), 123 deletions(-) diff --git a/api.go b/api.go index c02aedbf2..9a50a3542 100644 --- a/api.go +++ b/api.go @@ -489,7 +489,7 @@ func (api *API) Schema(ctx context.Context) []*IndexInfo { } // CreateField creates a new BSI field in the given index and frame. -func (api *API) CreateField(ctx context.Context, indexName string, frameName string, field *oField) error { +func (api *API) CreateField(ctx context.Context, indexName string, frameName string, bsig *bsiGroup) error { if err := api.validate(apiCreateField); err != nil { return errors.Wrap(err, "validating api method") } @@ -500,17 +500,17 @@ func (api *API) CreateField(ctx context.Context, indexName string, frameName str return ErrFrameNotFound } - // Create new field. - if err := f.CreateField(field); err != nil { - return errors.Wrap(err, "creating field") + // Create new bsiGroup. + if err := f.CreateField(bsig); err != nil { + return errors.Wrap(err, "creating bsigroup") } - // Send the create field message to all nodes. + // Send the create bsigroup message to all nodes. err := api.Broadcaster.SendSync( &internal.CreateFieldMessage{ Index: indexName, Frame: frameName, - Field: encodeField(field), + Field: encodeField(bsig), }) if err != nil { api.Logger.Printf("problem sending CreateField message: %s", err) diff --git a/frame.go b/frame.go index ff20bddcc..4fa755e62 100644 --- a/frame.go +++ b/frame.go @@ -64,7 +64,7 @@ type Frame struct { // Frame options. options FrameOptions - fields []*oField + fields []*bsiGroup Logger Logger } @@ -325,19 +325,19 @@ func (f *Frame) applyOptions(opt FrameOptions) error { f.options.Max = opt.Max f.options.TimeQuantum = "" - // Create new field. - field := &oField{ + // Create new bsiGroup. + bsig := &bsiGroup{ Name: f.name, Type: FieldTypeInt, Min: opt.Min, Max: opt.Max, } - // Validate field. - if err := ValidateField(field); err != nil { + // Validate bsiGroup. + if err := ValidateField(bsig); err != nil { return err } - if err := f.CreateField(field); err != nil { - return errors.Wrap(err, "creating field") + if err := f.CreateField(bsig); err != nil { + return errors.Wrap(err, "creating bsigroup") } case FrameTypeTime: f.options.Type = opt.Type @@ -379,7 +379,7 @@ func (f *Frame) Close() error { } // Field returns a field by name. -func (f *Frame) Field(name string) *oField { +func (f *Frame) Field(name string) *bsiGroup { f.mu.RLock() defer f.mu.RUnlock() for _, field := range f.fields { @@ -401,12 +401,12 @@ func (f *Frame) hasField(name string) bool { } // CreateField creates a new field on the frame. -func (f *Frame) CreateField(field *oField) error { +func (f *Frame) CreateField(bsig *bsiGroup) error { f.mu.Lock() defer f.mu.Unlock() - // Append field. - if err := f.addField(field); err != nil { + // Append bsiGroup. + if err := f.addField(bsig); err != nil { return err } f.saveMeta() @@ -414,15 +414,15 @@ func (f *Frame) CreateField(field *oField) error { } // addField adds a single field to fields. -func (f *Frame) addField(field *oField) error { - if err := ValidateField(field); err != nil { - return errors.Wrap(err, "validating field") - } else if f.hasField(field.Name) { +func (f *Frame) addField(bsig *bsiGroup) error { + if err := ValidateField(bsig); err != nil { + return errors.Wrap(err, "validating bsigroup") + } else if f.hasField(bsig.Name) { return ErrFieldExists } - // Add field to list. - f.fields = append(f.fields, field) + // Add bsiGroup to list. + f.fields = append(f.fields, bsig) // Sort fields by name. sort.Slice(f.fields, func(i, j int) bool { @@ -1084,9 +1084,8 @@ func IsValidFieldType(v string) bool { } } -// TODO: finish unexporting this. also, rename it. -// oField represents a range field on a frame. -type oField struct { +// bsiGroup represents a range field on a frame. +type bsiGroup struct { Name string `json:"name,omitempty"` Type string `json:"type,omitempty"` Min int64 `json:"min,omitempty"` @@ -1094,9 +1093,9 @@ type oField struct { } // BitDepth returns the number of bits required to store a value between min & max. -func (f *oField) BitDepth() uint { +func (b *bsiGroup) BitDepth() uint { for i := uint(0); i < 63; i++ { - if f.Max-f.Min < (1 << i) { + if b.Max-b.Min < (1 << i) { return i } } @@ -1115,80 +1114,80 @@ func (f *oField) BitDepth() uint { // In order to make this work, we effectively need to change the operator to LTE. // Executor.executeFieldRangeSlice() takes this into account and returns // `frag.FieldNotNull(field.BitDepth())` in such instances. -func (f *oField) BaseValue(op pql.Token, value int64) (baseValue uint64, outOfRange bool) { +func (b *bsiGroup) BaseValue(op pql.Token, value int64) (baseValue uint64, outOfRange bool) { if op == pql.GT || op == pql.GTE { - if value > f.Max { + if value > b.Max { return baseValue, true - } else if value > f.Min { - baseValue = uint64(value - f.Min) + } else if value > b.Min { + baseValue = uint64(value - b.Min) } } else if op == pql.LT || op == pql.LTE { - if value < f.Min { + if value < b.Min { return baseValue, true - } else if value > f.Max { - baseValue = uint64(f.Max - f.Min) + } else if value > b.Max { + baseValue = uint64(b.Max - b.Min) } else { - baseValue = uint64(value - f.Min) + baseValue = uint64(value - b.Min) } } else if op == pql.EQ || op == pql.NEQ { - if value < f.Min || value > f.Max { + if value < b.Min || value > b.Max { return baseValue, true } - baseValue = uint64(value - f.Min) + baseValue = uint64(value - b.Min) } return baseValue, false } // BaseValueBetween adjusts the min/max value to align with the range for Field. -func (f *oField) BaseValueBetween(min, max int64) (baseValueMin, baseValueMax uint64, outOfRange bool) { - if max < f.Min || min > f.Max { +func (b *bsiGroup) BaseValueBetween(min, max int64) (baseValueMin, baseValueMax uint64, outOfRange bool) { + if max < b.Min || min > b.Max { return baseValueMin, baseValueMax, true } // Adjust min/max to range. - if min > f.Min { - baseValueMin = uint64(min - f.Min) + if min > b.Min { + baseValueMin = uint64(min - b.Min) } // Make sure the high value of the BETWEEN does not exceed BitDepth. - if max > f.Max { - baseValueMax = uint64(f.Max - f.Min) - } else if max > f.Min { - baseValueMax = uint64(max - f.Min) + if max > b.Max { + baseValueMax = uint64(b.Max - b.Min) + } else if max > b.Min { + baseValueMax = uint64(max - b.Min) } return baseValueMin, baseValueMax, false } -func ValidateField(f *oField) error { - if f.Name == "" { +func ValidateField(b *bsiGroup) error { + if b.Name == "" { return ErrFieldNameRequired - } else if !IsValidFieldType(f.Type) { + } else if !IsValidFieldType(b.Type) { return ErrInvalidFieldType - } else if f.Min > f.Max { + } else if b.Min > b.Max { return ErrInvalidFieldRange } return nil } -func encodeField(f *oField) *internal.Field { - if f == nil { +func encodeField(b *bsiGroup) *internal.Field { + if b == nil { return nil } return &internal.Field{ - Name: f.Name, - Type: f.Type, - Min: int64(f.Min), - Max: int64(f.Max), + Name: b.Name, + Type: b.Type, + Min: int64(b.Min), + Max: int64(b.Max), } } -func decodeField(f *internal.Field) *oField { - if f == nil { +func decodeField(b *internal.Field) *bsiGroup { + if b == nil { return nil } - return &oField{ - Name: f.Name, - Type: f.Type, - Min: f.Min, - Max: f.Max, + return &bsiGroup{ + Name: b.Name, + Type: b.Type, + Min: b.Min, + Max: b.Max, } } diff --git a/frame_internal_test.go b/frame_internal_test.go index f51ad95e9..c52b76658 100644 --- a/frame_internal_test.go +++ b/frame_internal_test.go @@ -23,21 +23,21 @@ import ( // Ensure a field can adjust to its baseValue. func TestField_BaseValue(t *testing.T) { - f0 := &oField{ - Name: "f0", + b0 := &bsiGroup{ + Name: "b0", Type: FieldTypeInt, Min: -100, Max: 900, } - f1 := &oField{ - Name: "f1", + b1 := &bsiGroup{ + Name: "b1", Type: FieldTypeInt, Min: 0, Max: 1000, } - f2 := &oField{ - Name: "f2", + b2 := &bsiGroup{ + Name: "b2", Type: FieldTypeInt, Min: 100, Max: 1100, @@ -46,60 +46,60 @@ func TestField_BaseValue(t *testing.T) { t.Run("Normal Condition", func(t *testing.T) { for _, tt := range []struct { - f *oField + f *bsiGroup op pql.Token val int64 expBaseValue uint64 expOutOfRange bool }{ // LT - {f0, pql.LT, 5, 105, false}, - {f0, pql.LT, -8, 92, false}, - {f0, pql.LT, -108, 0, true}, - {f0, pql.LT, 1005, 1000, false}, - {f0, pql.LT, 0, 100, false}, + {b0, pql.LT, 5, 105, false}, + {b0, pql.LT, -8, 92, false}, + {b0, pql.LT, -108, 0, true}, + {b0, pql.LT, 1005, 1000, false}, + {b0, pql.LT, 0, 100, false}, - {f1, pql.LT, 5, 5, false}, - {f1, pql.LT, -8, 0, true}, - {f1, pql.LT, 1005, 1000, false}, - {f1, pql.LT, 0, 0, false}, + {b1, pql.LT, 5, 5, false}, + {b1, pql.LT, -8, 0, true}, + {b1, pql.LT, 1005, 1000, false}, + {b1, pql.LT, 0, 0, false}, - {f2, pql.LT, 5, 0, true}, - {f2, pql.LT, -8, 0, true}, - {f2, pql.LT, 105, 5, false}, - {f2, pql.LT, 1105, 1000, false}, + {b2, pql.LT, 5, 0, true}, + {b2, pql.LT, -8, 0, true}, + {b2, pql.LT, 105, 5, false}, + {b2, pql.LT, 1105, 1000, false}, // GT - {f0, pql.GT, -105, 0, false}, - {f0, pql.GT, 5, 105, false}, - {f0, pql.GT, 905, 0, true}, - {f0, pql.GT, 0, 100, false}, + {b0, pql.GT, -105, 0, false}, + {b0, pql.GT, 5, 105, false}, + {b0, pql.GT, 905, 0, true}, + {b0, pql.GT, 0, 100, false}, - {f1, pql.GT, 5, 5, false}, - {f1, pql.GT, -8, 0, false}, - {f1, pql.GT, 1005, 0, true}, - {f1, pql.GT, 0, 0, false}, + {b1, pql.GT, 5, 5, false}, + {b1, pql.GT, -8, 0, false}, + {b1, pql.GT, 1005, 0, true}, + {b1, pql.GT, 0, 0, false}, - {f2, pql.GT, 5, 0, false}, - {f2, pql.GT, -8, 0, false}, - {f2, pql.GT, 105, 5, false}, - {f2, pql.GT, 1105, 0, true}, + {b2, pql.GT, 5, 0, false}, + {b2, pql.GT, -8, 0, false}, + {b2, pql.GT, 105, 5, false}, + {b2, pql.GT, 1105, 0, true}, // EQ - {f0, pql.EQ, -105, 0, true}, - {f0, pql.EQ, 5, 105, false}, - {f0, pql.EQ, 905, 0, true}, - {f0, pql.EQ, 0, 100, false}, + {b0, pql.EQ, -105, 0, true}, + {b0, pql.EQ, 5, 105, false}, + {b0, pql.EQ, 905, 0, true}, + {b0, pql.EQ, 0, 100, false}, - {f1, pql.EQ, 5, 5, false}, - {f1, pql.EQ, -8, 0, true}, - {f1, pql.EQ, 1005, 0, true}, - {f1, pql.EQ, 0, 0, false}, + {b1, pql.EQ, 5, 5, false}, + {b1, pql.EQ, -8, 0, true}, + {b1, pql.EQ, 1005, 0, true}, + {b1, pql.EQ, 0, 0, false}, - {f2, pql.EQ, 5, 0, true}, - {f2, pql.EQ, -8, 0, true}, - {f2, pql.EQ, 105, 5, false}, - {f2, pql.EQ, 1105, 0, true}, + {b2, pql.EQ, 5, 0, true}, + {b2, pql.EQ, -8, 0, true}, + {b2, pql.EQ, 105, 5, false}, + {b2, pql.EQ, 1105, 0, true}, } { bv, oor := tt.f.BaseValue(tt.op, tt.val) if oor != tt.expOutOfRange { @@ -112,7 +112,7 @@ func TestField_BaseValue(t *testing.T) { t.Run("Betwween Condition", func(t *testing.T) { for _, tt := range []struct { - f *oField + f *bsiGroup predMin int64 predMax int64 expBaseValueMin uint64 @@ -120,23 +120,23 @@ func TestField_BaseValue(t *testing.T) { expOutOfRange bool }{ - {f0, -205, -105, 0, 0, true}, - {f0, -105, 80, 0, 180, false}, - {f0, 5, 20, 105, 120, false}, - {f0, 20, 1005, 120, 1000, false}, - {f0, 1005, 2000, 0, 0, true}, + {b0, -205, -105, 0, 0, true}, + {b0, -105, 80, 0, 180, false}, + {b0, 5, 20, 105, 120, false}, + {b0, 20, 1005, 120, 1000, false}, + {b0, 1005, 2000, 0, 0, true}, - {f1, -105, -5, 0, 0, true}, - {f1, -5, 20, 0, 20, false}, - {f1, 5, 20, 5, 20, false}, - {f1, 20, 1005, 20, 1000, false}, - {f1, 1005, 2000, 0, 0, true}, + {b1, -105, -5, 0, 0, true}, + {b1, -5, 20, 0, 20, false}, + {b1, 5, 20, 5, 20, false}, + {b1, 20, 1005, 20, 1000, false}, + {b1, 1005, 2000, 0, 0, true}, - {f2, 5, 95, 0, 0, true}, - {f2, 95, 120, 0, 20, false}, - {f2, 105, 120, 5, 20, false}, - {f2, 120, 1105, 20, 1000, false}, - {f2, 1105, 2000, 0, 0, true}, + {b2, 5, 95, 0, 0, true}, + {b2, 95, 120, 0, 20, false}, + {b2, 105, 120, 5, 20, false}, + {b2, 120, 1105, 20, 1000, false}, + {b2, 1105, 2000, 0, 0, true}, } { min, max, oor := tt.f.BaseValueBetween(tt.predMin, tt.predMax) if oor != tt.expOutOfRange {