add vendoring with go dep

vendor/github.com/influxdata/influxdb/influxql/point.gen.go

@@ -0,0 +1,859 @@
+// Generated by tmpl
+// https://github.com/benbjohnson/tmpl
+//
+// DO NOT EDIT!
+// Source: point.gen.go.tmpl
+
+package influxql
+
+import (
+	"encoding/binary"
+	"io"
+
+	"github.com/gogo/protobuf/proto"
+	internal "github.com/influxdata/influxdb/influxql/internal"
+)
+
+// FloatPoint represents a point with a float64 value.
+// DO NOT ADD ADDITIONAL FIELDS TO THIS STRUCT.
+// See TestPoint_Fields in influxql/point_test.go for more details.
+type FloatPoint struct {
+	Name string
+	Tags Tags
+
+	Time  int64
+	Nil   bool
+	Value float64
+	Aux   []interface{}
+
+	// Total number of points that were combined into this point from an aggregate.
+	// If this is zero, the point is not the result of an aggregate function.
+	Aggregated uint32
+}
+
+func (v *FloatPoint) name() string { return v.Name }
+func (v *FloatPoint) tags() Tags   { return v.Tags }
+func (v *FloatPoint) time() int64  { return v.Time }
+func (v *FloatPoint) nil() bool    { return v.Nil }
+func (v *FloatPoint) value() interface{} {
+	if v.Nil {
+		return nil
+	}
+	return v.Value
+}
+func (v *FloatPoint) aux() []interface{} { return v.Aux }
+
+// Clone returns a copy of v.
+func (v *FloatPoint) Clone() *FloatPoint {
+	if v == nil {
+		return nil
+	}
+
+	other := *v
+	if v.Aux != nil {
+		other.Aux = make([]interface{}, len(v.Aux))
+		copy(other.Aux, v.Aux)
+	}
+
+	return &other
+}
+
+// CopyTo makes a deep copy into the point.
+func (v *FloatPoint) CopyTo(other *FloatPoint) {
+	*other = *v
+	if v.Aux != nil {
+		other.Aux = make([]interface{}, len(v.Aux))
+		copy(other.Aux, v.Aux)
+	}
+}
+
+func encodeFloatPoint(p *FloatPoint) *internal.Point {
+	return &internal.Point{
+		Name:       proto.String(p.Name),
+		Tags:       proto.String(p.Tags.ID()),
+		Time:       proto.Int64(p.Time),
+		Nil:        proto.Bool(p.Nil),
+		Aux:        encodeAux(p.Aux),
+		Aggregated: proto.Uint32(p.Aggregated),
+
+		FloatValue: proto.Float64(p.Value),
+	}
+}
+
+func decodeFloatPoint(pb *internal.Point) *FloatPoint {
+	return &FloatPoint{
+		Name:       pb.GetName(),
+		Tags:       newTagsID(pb.GetTags()),
+		Time:       pb.GetTime(),
+		Nil:        pb.GetNil(),
+		Aux:        decodeAux(pb.Aux),
+		Aggregated: pb.GetAggregated(),
+		Value:      pb.GetFloatValue(),
+	}
+}
+
+// floatPoints represents a slice of points sortable by value.
+type floatPoints []FloatPoint
+
+func (a floatPoints) Len() int { return len(a) }
+func (a floatPoints) Less(i, j int) bool {
+	if a[i].Time != a[j].Time {
+		return a[i].Time < a[j].Time
+	}
+	return a[i].Value < a[j].Value
+}
+func (a floatPoints) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
+
+// floatPointsByValue represents a slice of points sortable by value.
+type floatPointsByValue []FloatPoint
+
+func (a floatPointsByValue) Len() int { return len(a) }
+
+func (a floatPointsByValue) Less(i, j int) bool { return a[i].Value < a[j].Value }
+
+func (a floatPointsByValue) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
+
+// floatPointsByTime represents a slice of points sortable by value.
+type floatPointsByTime []FloatPoint
+
+func (a floatPointsByTime) Len() int           { return len(a) }
+func (a floatPointsByTime) Less(i, j int) bool { return a[i].Time < a[j].Time }
+func (a floatPointsByTime) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+
+// floatPointByFunc represents a slice of points sortable by a function.
+type floatPointsByFunc struct {
+	points []FloatPoint
+	cmp    func(a, b *FloatPoint) bool
+}
+
+func (a *floatPointsByFunc) Len() int           { return len(a.points) }
+func (a *floatPointsByFunc) Less(i, j int) bool { return a.cmp(&a.points[i], &a.points[j]) }
+func (a *floatPointsByFunc) Swap(i, j int)      { a.points[i], a.points[j] = a.points[j], a.points[i] }
+
+func (a *floatPointsByFunc) Push(x interface{}) {
+	a.points = append(a.points, x.(FloatPoint))
+}
+
+func (a *floatPointsByFunc) Pop() interface{} {
+	p := a.points[len(a.points)-1]
+	a.points = a.points[:len(a.points)-1]
+	return p
+}
+
+func floatPointsSortBy(points []FloatPoint, cmp func(a, b *FloatPoint) bool) *floatPointsByFunc {
+	return &floatPointsByFunc{
+		points: points,
+		cmp:    cmp,
+	}
+}
+
+// FloatPointEncoder encodes FloatPoint points to a writer.
+type FloatPointEncoder struct {
+	w io.Writer
+}
+
+// NewFloatPointEncoder returns a new instance of FloatPointEncoder that writes to w.
+func NewFloatPointEncoder(w io.Writer) *FloatPointEncoder {
+	return &FloatPointEncoder{w: w}
+}
+
+// EncodeFloatPoint marshals and writes p to the underlying writer.
+func (enc *FloatPointEncoder) EncodeFloatPoint(p *FloatPoint) error {
+	// Marshal to bytes.
+	buf, err := proto.Marshal(encodeFloatPoint(p))
+	if err != nil {
+		return err
+	}
+
+	// Write the length.
+	if err := binary.Write(enc.w, binary.BigEndian, uint32(len(buf))); err != nil {
+		return err
+	}
+
+	// Write the encoded point.
+	if _, err := enc.w.Write(buf); err != nil {
+		return err
+	}
+	return nil
+}
+
+// FloatPointDecoder decodes FloatPoint points from a reader.
+type FloatPointDecoder struct {
+	r     io.Reader
+	stats IteratorStats
+}
+
+// NewFloatPointDecoder returns a new instance of FloatPointDecoder that reads from r.
+func NewFloatPointDecoder(r io.Reader) *FloatPointDecoder {
+	return &FloatPointDecoder{r: r}
+}
+
+// Stats returns iterator stats embedded within the stream.
+func (dec *FloatPointDecoder) Stats() IteratorStats { return dec.stats }
+
+// DecodeFloatPoint reads from the underlying reader and unmarshals into p.
+func (dec *FloatPointDecoder) DecodeFloatPoint(p *FloatPoint) error {
+	for {
+		// Read length.
+		var sz uint32
+		if err := binary.Read(dec.r, binary.BigEndian, &sz); err != nil {
+			return err
+		}
+
+		// Read point data.
+		buf := make([]byte, sz)
+		if _, err := io.ReadFull(dec.r, buf); err != nil {
+			return err
+		}
+
+		// Unmarshal into point.
+		var pb internal.Point
+		if err := proto.Unmarshal(buf, &pb); err != nil {
+			return err
+		}
+
+		// If the point contains stats then read stats and retry.
+		if pb.Stats != nil {
+			dec.stats = decodeIteratorStats(pb.Stats)
+			continue
+		}
+
+		// Decode into point object.
+		*p = *decodeFloatPoint(&pb)
+
+		return nil
+	}
+}
+
+// IntegerPoint represents a point with a int64 value.
+// DO NOT ADD ADDITIONAL FIELDS TO THIS STRUCT.
+// See TestPoint_Fields in influxql/point_test.go for more details.
+type IntegerPoint struct {
+	Name string
+	Tags Tags
+
+	Time  int64
+	Nil   bool
+	Value int64
+	Aux   []interface{}
+
+	// Total number of points that were combined into this point from an aggregate.
+	// If this is zero, the point is not the result of an aggregate function.
+	Aggregated uint32
+}
+
+func (v *IntegerPoint) name() string { return v.Name }
+func (v *IntegerPoint) tags() Tags   { return v.Tags }
+func (v *IntegerPoint) time() int64  { return v.Time }
+func (v *IntegerPoint) nil() bool    { return v.Nil }
+func (v *IntegerPoint) value() interface{} {
+	if v.Nil {
+		return nil
+	}
+	return v.Value
+}
+func (v *IntegerPoint) aux() []interface{} { return v.Aux }
+
+// Clone returns a copy of v.
+func (v *IntegerPoint) Clone() *IntegerPoint {
+	if v == nil {
+		return nil
+	}
+
+	other := *v
+	if v.Aux != nil {
+		other.Aux = make([]interface{}, len(v.Aux))
+		copy(other.Aux, v.Aux)
+	}
+
+	return &other
+}
+
+// CopyTo makes a deep copy into the point.
+func (v *IntegerPoint) CopyTo(other *IntegerPoint) {
+	*other = *v
+	if v.Aux != nil {
+		other.Aux = make([]interface{}, len(v.Aux))
+		copy(other.Aux, v.Aux)
+	}
+}
+
+func encodeIntegerPoint(p *IntegerPoint) *internal.Point {
+	return &internal.Point{
+		Name:       proto.String(p.Name),
+		Tags:       proto.String(p.Tags.ID()),
+		Time:       proto.Int64(p.Time),
+		Nil:        proto.Bool(p.Nil),
+		Aux:        encodeAux(p.Aux),
+		Aggregated: proto.Uint32(p.Aggregated),
+
+		IntegerValue: proto.Int64(p.Value),
+	}
+}
+
+func decodeIntegerPoint(pb *internal.Point) *IntegerPoint {
+	return &IntegerPoint{
+		Name:       pb.GetName(),
+		Tags:       newTagsID(pb.GetTags()),
+		Time:       pb.GetTime(),
+		Nil:        pb.GetNil(),
+		Aux:        decodeAux(pb.Aux),
+		Aggregated: pb.GetAggregated(),
+		Value:      pb.GetIntegerValue(),
+	}
+}
+
+// integerPoints represents a slice of points sortable by value.
+type integerPoints []IntegerPoint
+
+func (a integerPoints) Len() int { return len(a) }
+func (a integerPoints) Less(i, j int) bool {
+	if a[i].Time != a[j].Time {
+		return a[i].Time < a[j].Time
+	}
+	return a[i].Value < a[j].Value
+}
+func (a integerPoints) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
+
+// integerPointsByValue represents a slice of points sortable by value.
+type integerPointsByValue []IntegerPoint
+
+func (a integerPointsByValue) Len() int { return len(a) }
+
+func (a integerPointsByValue) Less(i, j int) bool { return a[i].Value < a[j].Value }
+
+func (a integerPointsByValue) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
+
+// integerPointsByTime represents a slice of points sortable by value.
+type integerPointsByTime []IntegerPoint
+
+func (a integerPointsByTime) Len() int           { return len(a) }
+func (a integerPointsByTime) Less(i, j int) bool { return a[i].Time < a[j].Time }
+func (a integerPointsByTime) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+
+// integerPointByFunc represents a slice of points sortable by a function.
+type integerPointsByFunc struct {
+	points []IntegerPoint
+	cmp    func(a, b *IntegerPoint) bool
+}
+
+func (a *integerPointsByFunc) Len() int           { return len(a.points) }
+func (a *integerPointsByFunc) Less(i, j int) bool { return a.cmp(&a.points[i], &a.points[j]) }
+func (a *integerPointsByFunc) Swap(i, j int)      { a.points[i], a.points[j] = a.points[j], a.points[i] }
+
+func (a *integerPointsByFunc) Push(x interface{}) {
+	a.points = append(a.points, x.(IntegerPoint))
+}
+
+func (a *integerPointsByFunc) Pop() interface{} {
+	p := a.points[len(a.points)-1]
+	a.points = a.points[:len(a.points)-1]
+	return p
+}
+
+func integerPointsSortBy(points []IntegerPoint, cmp func(a, b *IntegerPoint) bool) *integerPointsByFunc {
+	return &integerPointsByFunc{
+		points: points,
+		cmp:    cmp,
+	}
+}
+
+// IntegerPointEncoder encodes IntegerPoint points to a writer.
+type IntegerPointEncoder struct {
+	w io.Writer
+}
+
+// NewIntegerPointEncoder returns a new instance of IntegerPointEncoder that writes to w.
+func NewIntegerPointEncoder(w io.Writer) *IntegerPointEncoder {
+	return &IntegerPointEncoder{w: w}
+}
+
+// EncodeIntegerPoint marshals and writes p to the underlying writer.
+func (enc *IntegerPointEncoder) EncodeIntegerPoint(p *IntegerPoint) error {
+	// Marshal to bytes.
+	buf, err := proto.Marshal(encodeIntegerPoint(p))
+	if err != nil {
+		return err
+	}
+
+	// Write the length.
+	if err := binary.Write(enc.w, binary.BigEndian, uint32(len(buf))); err != nil {
+		return err
+	}
+
+	// Write the encoded point.
+	if _, err := enc.w.Write(buf); err != nil {
+		return err
+	}
+	return nil
+}
+
+// IntegerPointDecoder decodes IntegerPoint points from a reader.
+type IntegerPointDecoder struct {
+	r     io.Reader
+	stats IteratorStats
+}
+
+// NewIntegerPointDecoder returns a new instance of IntegerPointDecoder that reads from r.
+func NewIntegerPointDecoder(r io.Reader) *IntegerPointDecoder {
+	return &IntegerPointDecoder{r: r}
+}
+
+// Stats returns iterator stats embedded within the stream.
+func (dec *IntegerPointDecoder) Stats() IteratorStats { return dec.stats }
+
+// DecodeIntegerPoint reads from the underlying reader and unmarshals into p.
+func (dec *IntegerPointDecoder) DecodeIntegerPoint(p *IntegerPoint) error {
+	for {
+		// Read length.
+		var sz uint32
+		if err := binary.Read(dec.r, binary.BigEndian, &sz); err != nil {
+			return err
+		}
+
+		// Read point data.
+		buf := make([]byte, sz)
+		if _, err := io.ReadFull(dec.r, buf); err != nil {
+			return err
+		}
+
+		// Unmarshal into point.
+		var pb internal.Point
+		if err := proto.Unmarshal(buf, &pb); err != nil {
+			return err
+		}
+
+		// If the point contains stats then read stats and retry.
+		if pb.Stats != nil {
+			dec.stats = decodeIteratorStats(pb.Stats)
+			continue
+		}
+
+		// Decode into point object.
+		*p = *decodeIntegerPoint(&pb)
+
+		return nil
+	}
+}
+
+// StringPoint represents a point with a string value.
+// DO NOT ADD ADDITIONAL FIELDS TO THIS STRUCT.
+// See TestPoint_Fields in influxql/point_test.go for more details.
+type StringPoint struct {
+	Name string
+	Tags Tags
+
+	Time  int64
+	Nil   bool
+	Value string
+	Aux   []interface{}
+
+	// Total number of points that were combined into this point from an aggregate.
+	// If this is zero, the point is not the result of an aggregate function.
+	Aggregated uint32
+}
+
+func (v *StringPoint) name() string { return v.Name }
+func (v *StringPoint) tags() Tags   { return v.Tags }
+func (v *StringPoint) time() int64  { return v.Time }
+func (v *StringPoint) nil() bool    { return v.Nil }
+func (v *StringPoint) value() interface{} {
+	if v.Nil {
+		return nil
+	}
+	return v.Value
+}
+func (v *StringPoint) aux() []interface{} { return v.Aux }
+
+// Clone returns a copy of v.
+func (v *StringPoint) Clone() *StringPoint {
+	if v == nil {
+		return nil
+	}
+
+	other := *v
+	if v.Aux != nil {
+		other.Aux = make([]interface{}, len(v.Aux))
+		copy(other.Aux, v.Aux)
+	}
+
+	return &other
+}
+
+// CopyTo makes a deep copy into the point.
+func (v *StringPoint) CopyTo(other *StringPoint) {
+	*other = *v
+	if v.Aux != nil {
+		other.Aux = make([]interface{}, len(v.Aux))
+		copy(other.Aux, v.Aux)
+	}
+}
+
+func encodeStringPoint(p *StringPoint) *internal.Point {
+	return &internal.Point{
+		Name:       proto.String(p.Name),
+		Tags:       proto.String(p.Tags.ID()),
+		Time:       proto.Int64(p.Time),
+		Nil:        proto.Bool(p.Nil),
+		Aux:        encodeAux(p.Aux),
+		Aggregated: proto.Uint32(p.Aggregated),
+
+		StringValue: proto.String(p.Value),
+	}
+}
+
+func decodeStringPoint(pb *internal.Point) *StringPoint {
+	return &StringPoint{
+		Name:       pb.GetName(),
+		Tags:       newTagsID(pb.GetTags()),
+		Time:       pb.GetTime(),
+		Nil:        pb.GetNil(),
+		Aux:        decodeAux(pb.Aux),
+		Aggregated: pb.GetAggregated(),
+		Value:      pb.GetStringValue(),
+	}
+}
+
+// stringPoints represents a slice of points sortable by value.
+type stringPoints []StringPoint
+
+func (a stringPoints) Len() int { return len(a) }
+func (a stringPoints) Less(i, j int) bool {
+	if a[i].Time != a[j].Time {
+		return a[i].Time < a[j].Time
+	}
+	return a[i].Value < a[j].Value
+}
+func (a stringPoints) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
+
+// stringPointsByValue represents a slice of points sortable by value.
+type stringPointsByValue []StringPoint
+
+func (a stringPointsByValue) Len() int { return len(a) }
+
+func (a stringPointsByValue) Less(i, j int) bool { return a[i].Value < a[j].Value }
+
+func (a stringPointsByValue) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
+
+// stringPointsByTime represents a slice of points sortable by value.
+type stringPointsByTime []StringPoint
+
+func (a stringPointsByTime) Len() int           { return len(a) }
+func (a stringPointsByTime) Less(i, j int) bool { return a[i].Time < a[j].Time }
+func (a stringPointsByTime) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+
+// stringPointByFunc represents a slice of points sortable by a function.
+type stringPointsByFunc struct {
+	points []StringPoint
+	cmp    func(a, b *StringPoint) bool
+}
+
+func (a *stringPointsByFunc) Len() int           { return len(a.points) }
+func (a *stringPointsByFunc) Less(i, j int) bool { return a.cmp(&a.points[i], &a.points[j]) }
+func (a *stringPointsByFunc) Swap(i, j int)      { a.points[i], a.points[j] = a.points[j], a.points[i] }
+
+func (a *stringPointsByFunc) Push(x interface{}) {
+	a.points = append(a.points, x.(StringPoint))
+}
+
+func (a *stringPointsByFunc) Pop() interface{} {
+	p := a.points[len(a.points)-1]
+	a.points = a.points[:len(a.points)-1]
+	return p
+}
+
+func stringPointsSortBy(points []StringPoint, cmp func(a, b *StringPoint) bool) *stringPointsByFunc {
+	return &stringPointsByFunc{
+		points: points,
+		cmp:    cmp,
+	}
+}
+
+// StringPointEncoder encodes StringPoint points to a writer.
+type StringPointEncoder struct {
+	w io.Writer
+}
+
+// NewStringPointEncoder returns a new instance of StringPointEncoder that writes to w.
+func NewStringPointEncoder(w io.Writer) *StringPointEncoder {
+	return &StringPointEncoder{w: w}
+}
+
+// EncodeStringPoint marshals and writes p to the underlying writer.
+func (enc *StringPointEncoder) EncodeStringPoint(p *StringPoint) error {
+	// Marshal to bytes.
+	buf, err := proto.Marshal(encodeStringPoint(p))
+	if err != nil {
+		return err
+	}
+
+	// Write the length.
+	if err := binary.Write(enc.w, binary.BigEndian, uint32(len(buf))); err != nil {
+		return err
+	}
+
+	// Write the encoded point.
+	if _, err := enc.w.Write(buf); err != nil {
+		return err
+	}
+	return nil
+}
+
+// StringPointDecoder decodes StringPoint points from a reader.
+type StringPointDecoder struct {
+	r     io.Reader
+	stats IteratorStats
+}
+
+// NewStringPointDecoder returns a new instance of StringPointDecoder that reads from r.
+func NewStringPointDecoder(r io.Reader) *StringPointDecoder {
+	return &StringPointDecoder{r: r}
+}
+
+// Stats returns iterator stats embedded within the stream.
+func (dec *StringPointDecoder) Stats() IteratorStats { return dec.stats }
+
+// DecodeStringPoint reads from the underlying reader and unmarshals into p.
+func (dec *StringPointDecoder) DecodeStringPoint(p *StringPoint) error {
+	for {
+		// Read length.
+		var sz uint32
+		if err := binary.Read(dec.r, binary.BigEndian, &sz); err != nil {
+			return err
+		}
+
+		// Read point data.
+		buf := make([]byte, sz)
+		if _, err := io.ReadFull(dec.r, buf); err != nil {
+			return err
+		}
+
+		// Unmarshal into point.
+		var pb internal.Point
+		if err := proto.Unmarshal(buf, &pb); err != nil {
+			return err
+		}
+
+		// If the point contains stats then read stats and retry.
+		if pb.Stats != nil {
+			dec.stats = decodeIteratorStats(pb.Stats)
+			continue
+		}
+
+		// Decode into point object.
+		*p = *decodeStringPoint(&pb)
+
+		return nil
+	}
+}
+
+// BooleanPoint represents a point with a bool value.
+// DO NOT ADD ADDITIONAL FIELDS TO THIS STRUCT.
+// See TestPoint_Fields in influxql/point_test.go for more details.
+type BooleanPoint struct {
+	Name string
+	Tags Tags
+
+	Time  int64
+	Nil   bool
+	Value bool
+	Aux   []interface{}
+
+	// Total number of points that were combined into this point from an aggregate.
+	// If this is zero, the point is not the result of an aggregate function.
+	Aggregated uint32
+}
+
+func (v *BooleanPoint) name() string { return v.Name }
+func (v *BooleanPoint) tags() Tags   { return v.Tags }
+func (v *BooleanPoint) time() int64  { return v.Time }
+func (v *BooleanPoint) nil() bool    { return v.Nil }
+func (v *BooleanPoint) value() interface{} {
+	if v.Nil {
+		return nil
+	}
+	return v.Value
+}
+func (v *BooleanPoint) aux() []interface{} { return v.Aux }
+
+// Clone returns a copy of v.
+func (v *BooleanPoint) Clone() *BooleanPoint {
+	if v == nil {
+		return nil
+	}
+
+	other := *v
+	if v.Aux != nil {
+		other.Aux = make([]interface{}, len(v.Aux))
+		copy(other.Aux, v.Aux)
+	}
+
+	return &other
+}
+
+// CopyTo makes a deep copy into the point.
+func (v *BooleanPoint) CopyTo(other *BooleanPoint) {
+	*other = *v
+	if v.Aux != nil {
+		other.Aux = make([]interface{}, len(v.Aux))
+		copy(other.Aux, v.Aux)
+	}
+}
+
+func encodeBooleanPoint(p *BooleanPoint) *internal.Point {
+	return &internal.Point{
+		Name:       proto.String(p.Name),
+		Tags:       proto.String(p.Tags.ID()),
+		Time:       proto.Int64(p.Time),
+		Nil:        proto.Bool(p.Nil),
+		Aux:        encodeAux(p.Aux),
+		Aggregated: proto.Uint32(p.Aggregated),
+
+		BooleanValue: proto.Bool(p.Value),
+	}
+}
+
+func decodeBooleanPoint(pb *internal.Point) *BooleanPoint {
+	return &BooleanPoint{
+		Name:       pb.GetName(),
+		Tags:       newTagsID(pb.GetTags()),
+		Time:       pb.GetTime(),
+		Nil:        pb.GetNil(),
+		Aux:        decodeAux(pb.Aux),
+		Aggregated: pb.GetAggregated(),
+		Value:      pb.GetBooleanValue(),
+	}
+}
+
+// booleanPoints represents a slice of points sortable by value.
+type booleanPoints []BooleanPoint
+
+func (a booleanPoints) Len() int { return len(a) }
+func (a booleanPoints) Less(i, j int) bool {
+	if a[i].Time != a[j].Time {
+		return a[i].Time < a[j].Time
+	}
+	return !a[i].Value
+}
+func (a booleanPoints) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
+
+// booleanPointsByValue represents a slice of points sortable by value.
+type booleanPointsByValue []BooleanPoint
+
+func (a booleanPointsByValue) Len() int { return len(a) }
+
+func (a booleanPointsByValue) Less(i, j int) bool { return !a[i].Value }
+
+func (a booleanPointsByValue) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
+
+// booleanPointsByTime represents a slice of points sortable by value.
+type booleanPointsByTime []BooleanPoint
+
+func (a booleanPointsByTime) Len() int           { return len(a) }
+func (a booleanPointsByTime) Less(i, j int) bool { return a[i].Time < a[j].Time }
+func (a booleanPointsByTime) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+
+// booleanPointByFunc represents a slice of points sortable by a function.
+type booleanPointsByFunc struct {
+	points []BooleanPoint
+	cmp    func(a, b *BooleanPoint) bool
+}
+
+func (a *booleanPointsByFunc) Len() int           { return len(a.points) }
+func (a *booleanPointsByFunc) Less(i, j int) bool { return a.cmp(&a.points[i], &a.points[j]) }
+func (a *booleanPointsByFunc) Swap(i, j int)      { a.points[i], a.points[j] = a.points[j], a.points[i] }
+
+func (a *booleanPointsByFunc) Push(x interface{}) {
+	a.points = append(a.points, x.(BooleanPoint))
+}
+
+func (a *booleanPointsByFunc) Pop() interface{} {
+	p := a.points[len(a.points)-1]
+	a.points = a.points[:len(a.points)-1]
+	return p
+}
+
+func booleanPointsSortBy(points []BooleanPoint, cmp func(a, b *BooleanPoint) bool) *booleanPointsByFunc {
+	return &booleanPointsByFunc{
+		points: points,
+		cmp:    cmp,
+	}
+}
+
+// BooleanPointEncoder encodes BooleanPoint points to a writer.
+type BooleanPointEncoder struct {
+	w io.Writer
+}
+
+// NewBooleanPointEncoder returns a new instance of BooleanPointEncoder that writes to w.
+func NewBooleanPointEncoder(w io.Writer) *BooleanPointEncoder {
+	return &BooleanPointEncoder{w: w}
+}
+
+// EncodeBooleanPoint marshals and writes p to the underlying writer.
+func (enc *BooleanPointEncoder) EncodeBooleanPoint(p *BooleanPoint) error {
+	// Marshal to bytes.
+	buf, err := proto.Marshal(encodeBooleanPoint(p))
+	if err != nil {
+		return err
+	}
+
+	// Write the length.
+	if err := binary.Write(enc.w, binary.BigEndian, uint32(len(buf))); err != nil {
+		return err
+	}
+
+	// Write the encoded point.
+	if _, err := enc.w.Write(buf); err != nil {
+		return err
+	}
+	return nil
+}
+
+// BooleanPointDecoder decodes BooleanPoint points from a reader.
+type BooleanPointDecoder struct {
+	r     io.Reader
+	stats IteratorStats
+}
+
+// NewBooleanPointDecoder returns a new instance of BooleanPointDecoder that reads from r.
+func NewBooleanPointDecoder(r io.Reader) *BooleanPointDecoder {
+	return &BooleanPointDecoder{r: r}
+}
+
+// Stats returns iterator stats embedded within the stream.
+func (dec *BooleanPointDecoder) Stats() IteratorStats { return dec.stats }
+
+// DecodeBooleanPoint reads from the underlying reader and unmarshals into p.
+func (dec *BooleanPointDecoder) DecodeBooleanPoint(p *BooleanPoint) error {
+	for {
+		// Read length.
+		var sz uint32
+		if err := binary.Read(dec.r, binary.BigEndian, &sz); err != nil {
+			return err
+		}
+
+		// Read point data.
+		buf := make([]byte, sz)
+		if _, err := io.ReadFull(dec.r, buf); err != nil {
+			return err
+		}
+
+		// Unmarshal into point.
+		var pb internal.Point
+		if err := proto.Unmarshal(buf, &pb); err != nil {
+			return err
+		}
+
+		// If the point contains stats then read stats and retry.
+		if pb.Stats != nil {
+			dec.stats = decodeIteratorStats(pb.Stats)
+			continue
+		}
+
+		// Decode into point object.
+		*p = *decodeBooleanPoint(&pb)
+
+		return nil
+	}
+}