mirror of
https://github.com/rclone/rclone.git
synced 2025-12-17 00:33:30 +00:00
Use a vendor directory for repeatable builds - fixes #816
This is using godep to manage the vendor directory.
This commit is contained in:
Nick Craig-Wood
303
vendor/github.com/stacktic/dropbox/datastores_parser.go
generated
vendored
Normal file
303
vendor/github.com/stacktic/dropbox/datastores_parser.go
generated
vendored
Normal file
@@ -0,0 +1,303 @@
|
||||
/*
|
||||
** Copyright (c) 2014 Arnaud Ysmal. All Rights Reserved.
|
||||
**
|
||||
** Redistribution and use in source and binary forms, with or without
|
||||
** modification, are permitted provided that the following conditions
|
||||
** are met:
|
||||
** 1. Redistributions of source code must retain the above copyright
|
||||
** notice, this list of conditions and the following disclaimer.
|
||||
** 2. Redistributions in binary form must reproduce the above copyright
|
||||
** notice, this list of conditions and the following disclaimer in the
|
||||
** documentation and/or other materials provided with the distribution.
|
||||
**
|
||||
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
|
||||
** OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
** DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
||||
** FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
** DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
||||
** SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
** HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
** LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
** OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
** SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
package dropbox
|
||||
|
||||
import (
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"math"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
type atom struct {
|
||||
Value interface{}
|
||||
}
|
||||
|
||||
func encodeDBase64(b []byte) string {
|
||||
return strings.TrimRight(base64.URLEncoding.EncodeToString(b), "=")
|
||||
}
|
||||
|
||||
func decodeDBase64(s string) ([]byte, error) {
|
||||
pad := 4 - len(s)%4
|
||||
if pad != 4 {
|
||||
s += strings.Repeat("=", pad)
|
||||
}
|
||||
return base64.URLEncoding.DecodeString(s)
|
||||
}
|
||||
|
||||
// MarshalJSON returns the JSON encoding of a.
|
||||
func (a atom) MarshalJSON() ([]byte, error) {
|
||||
switch v := a.Value.(type) {
|
||||
case bool, string:
|
||||
return json.Marshal(v)
|
||||
case float64:
|
||||
if math.IsNaN(v) {
|
||||
return []byte(`{"N": "nan"}`), nil
|
||||
} else if math.IsInf(v, 1) {
|
||||
return []byte(`{"N": "+inf"}`), nil
|
||||
} else if math.IsInf(v, -1) {
|
||||
return []byte(`{"N": "-inf"}`), nil
|
||||
}
|
||||
return json.Marshal(v)
|
||||
case time.Time:
|
||||
return []byte(fmt.Sprintf(`{"T": "%d"}`, v.UnixNano()/int64(time.Millisecond))), nil
|
||||
case int, int32, int64:
|
||||
return []byte(fmt.Sprintf(`{"I": "%d"}`, v)), nil
|
||||
case []byte:
|
||||
return []byte(fmt.Sprintf(`{"B": "%s"}`, encodeDBase64(v))), nil
|
||||
}
|
||||
return nil, fmt.Errorf("wrong format")
|
||||
}
|
||||
|
||||
// UnmarshalJSON parses the JSON-encoded data and stores the result in the value pointed to by a.
|
||||
func (a *atom) UnmarshalJSON(data []byte) error {
|
||||
var i interface{}
|
||||
var err error
|
||||
|
||||
if err = json.Unmarshal(data, &i); err != nil {
|
||||
return err
|
||||
}
|
||||
switch v := i.(type) {
|
||||
case bool, int, int32, int64, float32, float64, string:
|
||||
a.Value = v
|
||||
return nil
|
||||
case map[string]interface{}:
|
||||
for key, rval := range v {
|
||||
val, ok := rval.(string)
|
||||
if !ok {
|
||||
return fmt.Errorf("could not parse atom")
|
||||
}
|
||||
switch key {
|
||||
case "I":
|
||||
a.Value, err = strconv.ParseInt(val, 10, 64)
|
||||
return nil
|
||||
case "N":
|
||||
switch val {
|
||||
case "nan":
|
||||
a.Value = math.NaN()
|
||||
return nil
|
||||
case "+inf":
|
||||
a.Value = math.Inf(1)
|
||||
return nil
|
||||
case "-inf":
|
||||
a.Value = math.Inf(-1)
|
||||
return nil
|
||||
default:
|
||||
return fmt.Errorf("unknown special type %s", val)
|
||||
}
|
||||
case "T":
|
||||
t, err := strconv.ParseInt(val, 10, 64)
|
||||
if err != nil {
|
||||
return fmt.Errorf("could not parse atom")
|
||||
}
|
||||
a.Value = time.Unix(t/1000, (t%1000)*int64(time.Millisecond))
|
||||
return nil
|
||||
|
||||
case "B":
|
||||
a.Value, err = decodeDBase64(val)
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
return fmt.Errorf("could not parse atom")
|
||||
}
|
||||
|
||||
// MarshalJSON returns the JSON encoding of v.
|
||||
func (v value) MarshalJSON() ([]byte, error) {
|
||||
if v.isList {
|
||||
var a []atom
|
||||
|
||||
a = make([]atom, len(v.values))
|
||||
for i := range v.values {
|
||||
a[i].Value = v.values[i]
|
||||
}
|
||||
return json.Marshal(a)
|
||||
}
|
||||
return json.Marshal(atom{Value: v.values[0]})
|
||||
}
|
||||
|
||||
// UnmarshalJSON parses the JSON-encoded data and stores the result in the value pointed to by v.
|
||||
func (v *value) UnmarshalJSON(data []byte) error {
|
||||
var isArray bool
|
||||
var err error
|
||||
var a atom
|
||||
var as []atom
|
||||
|
||||
for _, d := range data {
|
||||
if d == ' ' {
|
||||
continue
|
||||
}
|
||||
if d == '[' {
|
||||
isArray = true
|
||||
}
|
||||
break
|
||||
}
|
||||
if isArray {
|
||||
if err = json.Unmarshal(data, &as); err != nil {
|
||||
return err
|
||||
}
|
||||
v.values = make([]interface{}, len(as))
|
||||
for i, at := range as {
|
||||
v.values[i] = at.Value
|
||||
}
|
||||
v.isList = true
|
||||
return nil
|
||||
}
|
||||
if err = json.Unmarshal(data, &a); err != nil {
|
||||
return err
|
||||
}
|
||||
v.values = make([]interface{}, 1)
|
||||
v.values[0] = a.Value
|
||||
return nil
|
||||
}
|
||||
|
||||
// UnmarshalJSON parses the JSON-encoded data and stores the result in the value pointed to by f.
|
||||
func (f *fieldOp) UnmarshalJSON(data []byte) error {
|
||||
var i []json.RawMessage
|
||||
var err error
|
||||
|
||||
if err = json.Unmarshal(data, &i); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if err = json.Unmarshal(i[0], &f.Op); err != nil {
|
||||
return err
|
||||
}
|
||||
switch f.Op {
|
||||
case fieldPut:
|
||||
if len(i) != 2 {
|
||||
return fmt.Errorf("wrong format")
|
||||
}
|
||||
return json.Unmarshal(i[1], &f.Data)
|
||||
case fieldDelete, listCreate:
|
||||
if len(i) != 1 {
|
||||
return fmt.Errorf("wrong format")
|
||||
}
|
||||
case listInsert, listPut:
|
||||
if len(i) != 3 {
|
||||
return fmt.Errorf("wrong format")
|
||||
}
|
||||
if err = json.Unmarshal(i[1], &f.Index); err != nil {
|
||||
return err
|
||||
}
|
||||
return json.Unmarshal(i[2], &f.Data)
|
||||
case listDelete:
|
||||
if len(i) != 2 {
|
||||
return fmt.Errorf("wrong format")
|
||||
}
|
||||
return json.Unmarshal(i[1], &f.Index)
|
||||
case listMove:
|
||||
if len(i) != 3 {
|
||||
return fmt.Errorf("wrong format")
|
||||
}
|
||||
if err = json.Unmarshal(i[1], &f.Index); err != nil {
|
||||
return err
|
||||
}
|
||||
return json.Unmarshal(i[2], &f.Index2)
|
||||
default:
|
||||
return fmt.Errorf("wrong format")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// MarshalJSON returns the JSON encoding of f.
|
||||
func (f fieldOp) MarshalJSON() ([]byte, error) {
|
||||
switch f.Op {
|
||||
case fieldPut:
|
||||
return json.Marshal([]interface{}{f.Op, f.Data})
|
||||
case fieldDelete, listCreate:
|
||||
return json.Marshal([]interface{}{f.Op})
|
||||
case listInsert, listPut:
|
||||
return json.Marshal([]interface{}{f.Op, f.Index, f.Data})
|
||||
case listDelete:
|
||||
return json.Marshal([]interface{}{f.Op, f.Index})
|
||||
case listMove:
|
||||
return json.Marshal([]interface{}{f.Op, f.Index, f.Index2})
|
||||
}
|
||||
return nil, fmt.Errorf("could not marshal Change type")
|
||||
}
|
||||
|
||||
// UnmarshalJSON parses the JSON-encoded data and stores the result in the value pointed to by c.
|
||||
func (c *change) UnmarshalJSON(data []byte) error {
|
||||
var i []json.RawMessage
|
||||
var err error
|
||||
|
||||
if err = json.Unmarshal(data, &i); err != nil {
|
||||
return err
|
||||
}
|
||||
if len(i) < 3 {
|
||||
return fmt.Errorf("wrong format")
|
||||
}
|
||||
|
||||
if err = json.Unmarshal(i[0], &c.Op); err != nil {
|
||||
return err
|
||||
}
|
||||
if err = json.Unmarshal(i[1], &c.TID); err != nil {
|
||||
return err
|
||||
}
|
||||
if err = json.Unmarshal(i[2], &c.RecordID); err != nil {
|
||||
return err
|
||||
}
|
||||
switch c.Op {
|
||||
case recordInsert:
|
||||
if len(i) != 4 {
|
||||
return fmt.Errorf("wrong format")
|
||||
}
|
||||
if err = json.Unmarshal(i[3], &c.Data); err != nil {
|
||||
return err
|
||||
}
|
||||
case recordUpdate:
|
||||
if len(i) != 4 {
|
||||
return fmt.Errorf("wrong format")
|
||||
}
|
||||
if err = json.Unmarshal(i[3], &c.Ops); err != nil {
|
||||
return err
|
||||
}
|
||||
case recordDelete:
|
||||
if len(i) != 3 {
|
||||
return fmt.Errorf("wrong format")
|
||||
}
|
||||
default:
|
||||
return fmt.Errorf("wrong format")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// MarshalJSON returns the JSON encoding of c.
|
||||
func (c change) MarshalJSON() ([]byte, error) {
|
||||
switch c.Op {
|
||||
case recordInsert:
|
||||
return json.Marshal([]interface{}{recordInsert, c.TID, c.RecordID, c.Data})
|
||||
case recordUpdate:
|
||||
return json.Marshal([]interface{}{recordUpdate, c.TID, c.RecordID, c.Ops})
|
||||
case recordDelete:
|
||||
return json.Marshal([]interface{}{recordDelete, c.TID, c.RecordID})
|
||||
}
|
||||
return nil, fmt.Errorf("could not marshal Change type")
|
||||
}
|
||||
Reference in New Issue
Block a user