mirror of
https://github.com/PretendoNetwork/nex-go.git
synced 2025-04-02 11:02:14 -04:00
122 lines
3.2 KiB
Go
122 lines
3.2 KiB
Go
package types
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
)
|
|
|
|
// ResultRange is an implementation of rdv::ResultRange.
|
|
// Holds information about how to make queries which may return large data.
|
|
type ResultRange struct {
|
|
Structure
|
|
Offset UInt32 `json:"offset" db:"offset" bson:"offset" xml:"Offset"` // * Offset into the dataset
|
|
Length UInt32 `json:"length" db:"length" bson:"length" xml:"Length"` // * Number of items to return
|
|
}
|
|
|
|
// WriteTo writes the ResultRange to the given writable
|
|
func (rr ResultRange) WriteTo(writable Writable) {
|
|
contentWritable := writable.CopyNew()
|
|
|
|
rr.Offset.WriteTo(contentWritable)
|
|
rr.Length.WriteTo(contentWritable)
|
|
|
|
content := contentWritable.Bytes()
|
|
|
|
rr.WriteHeaderTo(writable, uint32(len(content)))
|
|
|
|
writable.Write(content)
|
|
}
|
|
|
|
// ExtractFrom extracts the ResultRange from the given readable
|
|
func (rr *ResultRange) ExtractFrom(readable Readable) error {
|
|
var err error
|
|
|
|
if err = rr.ExtractHeaderFrom(readable); err != nil {
|
|
return fmt.Errorf("Failed to read ResultRange header. %s", err.Error())
|
|
}
|
|
|
|
err = rr.Offset.ExtractFrom(readable)
|
|
if err != nil {
|
|
return fmt.Errorf("Failed to read ResultRange.Offset. %s", err.Error())
|
|
}
|
|
|
|
err = rr.Length.ExtractFrom(readable)
|
|
if err != nil {
|
|
return fmt.Errorf("Failed to read ResultRange.Length. %s", err.Error())
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Copy returns a new copied instance of ResultRange
|
|
func (rr ResultRange) Copy() RVType {
|
|
copied := NewResultRange()
|
|
|
|
copied.StructureVersion = rr.StructureVersion
|
|
copied.Offset = rr.Offset.Copy().(UInt32)
|
|
copied.Length = rr.Length.Copy().(UInt32)
|
|
|
|
return copied
|
|
}
|
|
|
|
// Equals checks if the input is equal in value to the current instance
|
|
func (rr ResultRange) Equals(o RVType) bool {
|
|
if _, ok := o.(ResultRange); !ok {
|
|
return false
|
|
}
|
|
|
|
other := o.(ResultRange)
|
|
|
|
if rr.StructureVersion != other.StructureVersion {
|
|
return false
|
|
}
|
|
|
|
if !rr.Offset.Equals(&other.Offset) {
|
|
return false
|
|
}
|
|
|
|
return rr.Length.Equals(&other.Length)
|
|
}
|
|
|
|
// CopyRef copies the current value of the ResultRange
|
|
// and returns a pointer to the new copy
|
|
func (rr ResultRange) CopyRef() RVTypePtr {
|
|
copied := rr.Copy().(ResultRange)
|
|
return &copied
|
|
}
|
|
|
|
// Deref takes a pointer to the ResultRange
|
|
// and dereferences it to the raw value.
|
|
// Only useful when working with an instance of RVTypePtr
|
|
func (rr *ResultRange) Deref() RVType {
|
|
return *rr
|
|
}
|
|
|
|
// String returns a string representation of the struct
|
|
func (rr ResultRange) String() string {
|
|
return rr.FormatToString(0)
|
|
}
|
|
|
|
// FormatToString pretty-prints the struct data using the provided indentation level
|
|
func (rr ResultRange) FormatToString(indentationLevel int) string {
|
|
indentationValues := strings.Repeat("\t", indentationLevel+1)
|
|
indentationEnd := strings.Repeat("\t", indentationLevel)
|
|
|
|
var b strings.Builder
|
|
|
|
b.WriteString("ResultRange{\n")
|
|
b.WriteString(fmt.Sprintf("%sStructureVersion: %d,\n", indentationValues, rr.StructureVersion))
|
|
b.WriteString(fmt.Sprintf("%sOffset: %s,\n", indentationValues, rr.Offset))
|
|
b.WriteString(fmt.Sprintf("%sLength: %s\n", indentationValues, rr.Length))
|
|
b.WriteString(fmt.Sprintf("%s}", indentationEnd))
|
|
|
|
return b.String()
|
|
}
|
|
|
|
// NewResultRange returns a new ResultRange
|
|
func NewResultRange() ResultRange {
|
|
return ResultRange{
|
|
Offset: NewUInt32(0),
|
|
Length: NewUInt32(0),
|
|
}
|
|
}
|