114 lines
3.2 KiB
Go
114 lines
3.2 KiB
Go
/*
|
|
* Copyright 2020 The Dragonfly Authors
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package rangeutils
|
|
|
|
import (
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
const (
|
|
separator = "-"
|
|
)
|
|
|
|
type Range struct {
|
|
StartIndex uint64
|
|
EndIndex uint64
|
|
}
|
|
|
|
func (r Range) String() string {
|
|
return fmt.Sprintf("%d%s%d", r.StartIndex, separator, r.EndIndex)
|
|
}
|
|
|
|
// ParseRange parses Range according to range string.
|
|
// rangeStr: "start-end"
|
|
func ParseRange(rangeStr string) (r *Range, err error) {
|
|
ranges := strings.Split(rangeStr, separator)
|
|
if len(ranges) != 2 {
|
|
return nil, fmt.Errorf("range value(%s) is illegal which should be like 0-45535", rangeStr)
|
|
}
|
|
|
|
startIndex, err := strconv.ParseUint(ranges[0], 10, 64)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("range(%s) start is not a non-negative number", rangeStr)
|
|
}
|
|
endIndex, err := strconv.ParseUint(ranges[1], 10, 64)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("range(%s) end is not a non-negative number", rangeStr)
|
|
}
|
|
|
|
if endIndex < startIndex {
|
|
return nil, fmt.Errorf("range(%s) start is larger than end", rangeStr)
|
|
}
|
|
|
|
return &Range{
|
|
StartIndex: startIndex,
|
|
EndIndex: endIndex,
|
|
}, nil
|
|
}
|
|
|
|
// ParseRange parses Range according to range string.
|
|
// rangeStr: "bytes=start-end"
|
|
func ParseHTTPRange(rangeStr string) (r *Range, err error) {
|
|
prefix := "bytes="
|
|
if !strings.HasPrefix(rangeStr, prefix) || strings.Count(rangeStr, prefix) != 1 {
|
|
return nil, fmt.Errorf("rangeStr %s not start with bytes=", rangeStr)
|
|
}
|
|
rangeStr = strings.Replace(rangeStr, prefix, "", 1)
|
|
ranges := strings.Split(rangeStr, separator)
|
|
if len(ranges) != 2 {
|
|
return nil, fmt.Errorf("range value(%s) is illegal which should be like 0-45535", rangeStr)
|
|
}
|
|
|
|
startIndex, err := strconv.ParseUint(ranges[0], 10, 64)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("range(%s) start is not a non-negative number", rangeStr)
|
|
}
|
|
endIndex, err := strconv.ParseUint(ranges[1], 10, 64)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("range(%s) end is not a non-negative number", rangeStr)
|
|
}
|
|
|
|
if endIndex < startIndex {
|
|
return nil, fmt.Errorf("range(%s) start is larger than end", rangeStr)
|
|
}
|
|
|
|
return &Range{
|
|
StartIndex: startIndex,
|
|
EndIndex: endIndex,
|
|
}, nil
|
|
}
|
|
|
|
func GetBreakRange(breakPoint int64, sourceFileLength int64) (*Range, error) {
|
|
if breakPoint < 0 {
|
|
return nil, fmt.Errorf("breakPoint is illegal for value: %d", breakPoint)
|
|
}
|
|
if sourceFileLength < 0 {
|
|
return nil, fmt.Errorf("sourceFileLength is illegal for value: %d", sourceFileLength)
|
|
}
|
|
end := sourceFileLength - 1
|
|
if breakPoint > end {
|
|
return nil, fmt.Errorf("start: %d is larger than end: %d", breakPoint, end)
|
|
|
|
}
|
|
return &Range{
|
|
StartIndex: uint64(breakPoint),
|
|
EndIndex: uint64(end),
|
|
}, nil
|
|
}
|