1 // Copyright 2013 sigu-399 ( https://github.com/sigu-399 )
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
7 // http://www.apache.org/licenses/LICENSE-2.0
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
16 // author-github https://github.com/sigu-399
17 // author-mail sigu.399@gmail.com
19 // repository-name jsonpointer
20 // repository-desc An implementation of JSON Pointer - Go language
22 // description Main and unique file.
35 "github.com/go-openapi/swag"
40 pointerSeparator = `/`
42 invalidStart = `JSON pointer must be empty or start with a "` + pointerSeparator
45 var jsonPointableType = reflect.TypeOf(new(JSONPointable)).Elem()
46 var jsonSetableType = reflect.TypeOf(new(JSONSetable)).Elem()
48 // JSONPointable is an interface for structs to implement when they need to customize the
49 // json pointer process
50 type JSONPointable interface {
51 JSONLookup(string) (interface{}, error)
54 // JSONSetable is an interface for structs to implement when they need to customize the
55 // json pointer process
56 type JSONSetable interface {
57 JSONSet(string, interface{}) error
60 // New creates a new json pointer for the given string
61 func New(jsonPointerString string) (Pointer, error) {
64 err := p.parse(jsonPointerString)
69 // Pointer the json pointer reprsentation
71 referenceTokens []string
74 // "Constructor", parses the given string JSON pointer
75 func (p *Pointer) parse(jsonPointerString string) error {
79 if jsonPointerString != emptyPointer {
80 if !strings.HasPrefix(jsonPointerString, pointerSeparator) {
81 err = errors.New(invalidStart)
83 referenceTokens := strings.Split(jsonPointerString, pointerSeparator)
84 for _, referenceToken := range referenceTokens[1:] {
85 p.referenceTokens = append(p.referenceTokens, referenceToken)
93 // Get uses the pointer to retrieve a value from a JSON document
94 func (p *Pointer) Get(document interface{}) (interface{}, reflect.Kind, error) {
95 return p.get(document, swag.DefaultJSONNameProvider)
98 // Set uses the pointer to set a value from a JSON document
99 func (p *Pointer) Set(document interface{}, value interface{}) (interface{}, error) {
100 return document, p.set(document, value, swag.DefaultJSONNameProvider)
103 // GetForToken gets a value for a json pointer token 1 level deep
104 func GetForToken(document interface{}, decodedToken string) (interface{}, reflect.Kind, error) {
105 return getSingleImpl(document, decodedToken, swag.DefaultJSONNameProvider)
108 // SetForToken gets a value for a json pointer token 1 level deep
109 func SetForToken(document interface{}, decodedToken string, value interface{}) (interface{}, error) {
110 return document, setSingleImpl(document, value, decodedToken, swag.DefaultJSONNameProvider)
113 func getSingleImpl(node interface{}, decodedToken string, nameProvider *swag.NameProvider) (interface{}, reflect.Kind, error) {
114 rValue := reflect.Indirect(reflect.ValueOf(node))
115 kind := rValue.Kind()
120 if rValue.Type().Implements(jsonPointableType) {
121 r, err := node.(JSONPointable).JSONLookup(decodedToken)
123 return nil, kind, err
127 nm, ok := nameProvider.GetGoNameForType(rValue.Type(), decodedToken)
129 return nil, kind, fmt.Errorf("object has no field %q", decodedToken)
131 fld := rValue.FieldByName(nm)
132 return fld.Interface(), kind, nil
135 kv := reflect.ValueOf(decodedToken)
136 mv := rValue.MapIndex(kv)
138 if mv.IsValid() && !swag.IsZero(mv) {
139 return mv.Interface(), kind, nil
141 return nil, kind, fmt.Errorf("object has no key %q", decodedToken)
144 tokenIndex, err := strconv.Atoi(decodedToken)
146 return nil, kind, err
148 sLength := rValue.Len()
149 if tokenIndex < 0 || tokenIndex >= sLength {
150 return nil, kind, fmt.Errorf("index out of bounds array[0,%d] index '%d'", sLength-1, tokenIndex)
153 elem := rValue.Index(tokenIndex)
154 return elem.Interface(), kind, nil
157 return nil, kind, fmt.Errorf("invalid token reference %q", decodedToken)
162 func setSingleImpl(node, data interface{}, decodedToken string, nameProvider *swag.NameProvider) error {
163 rValue := reflect.Indirect(reflect.ValueOf(node))
164 switch rValue.Kind() {
167 if ns, ok := node.(JSONSetable); ok { // pointer impl
168 return ns.JSONSet(decodedToken, data)
171 if rValue.Type().Implements(jsonSetableType) {
172 return node.(JSONSetable).JSONSet(decodedToken, data)
175 nm, ok := nameProvider.GetGoNameForType(rValue.Type(), decodedToken)
177 return fmt.Errorf("object has no field %q", decodedToken)
179 fld := rValue.FieldByName(nm)
181 fld.Set(reflect.ValueOf(data))
186 kv := reflect.ValueOf(decodedToken)
187 rValue.SetMapIndex(kv, reflect.ValueOf(data))
191 tokenIndex, err := strconv.Atoi(decodedToken)
195 sLength := rValue.Len()
196 if tokenIndex < 0 || tokenIndex >= sLength {
197 return fmt.Errorf("index out of bounds array[0,%d] index '%d'", sLength, tokenIndex)
200 elem := rValue.Index(tokenIndex)
202 return fmt.Errorf("can't set slice index %s to %v", decodedToken, data)
204 elem.Set(reflect.ValueOf(data))
208 return fmt.Errorf("invalid token reference %q", decodedToken)
213 func (p *Pointer) get(node interface{}, nameProvider *swag.NameProvider) (interface{}, reflect.Kind, error) {
215 if nameProvider == nil {
216 nameProvider = swag.DefaultJSONNameProvider
219 kind := reflect.Invalid
221 // Full document when empty
222 if len(p.referenceTokens) == 0 {
223 return node, kind, nil
226 for _, token := range p.referenceTokens {
228 decodedToken := Unescape(token)
230 r, knd, err := getSingleImpl(node, decodedToken, nameProvider)
238 rValue := reflect.ValueOf(node)
241 return node, kind, nil
244 func (p *Pointer) set(node, data interface{}, nameProvider *swag.NameProvider) error {
245 knd := reflect.ValueOf(node).Kind()
247 if knd != reflect.Ptr && knd != reflect.Struct && knd != reflect.Map && knd != reflect.Slice && knd != reflect.Array {
248 return fmt.Errorf("only structs, pointers, maps and slices are supported for setting values")
251 if nameProvider == nil {
252 nameProvider = swag.DefaultJSONNameProvider
255 // Full document when empty
256 if len(p.referenceTokens) == 0 {
260 lastI := len(p.referenceTokens) - 1
261 for i, token := range p.referenceTokens {
262 isLastToken := i == lastI
263 decodedToken := Unescape(token)
267 return setSingleImpl(node, data, decodedToken, nameProvider)
270 rValue := reflect.Indirect(reflect.ValueOf(node))
271 kind := rValue.Kind()
276 if rValue.Type().Implements(jsonPointableType) {
277 r, err := node.(JSONPointable).JSONLookup(decodedToken)
281 fld := reflect.ValueOf(r)
282 if fld.CanAddr() && fld.Kind() != reflect.Interface && fld.Kind() != reflect.Map && fld.Kind() != reflect.Slice && fld.Kind() != reflect.Ptr {
283 node = fld.Addr().Interface()
289 nm, ok := nameProvider.GetGoNameForType(rValue.Type(), decodedToken)
291 return fmt.Errorf("object has no field %q", decodedToken)
293 fld := rValue.FieldByName(nm)
294 if fld.CanAddr() && fld.Kind() != reflect.Interface && fld.Kind() != reflect.Map && fld.Kind() != reflect.Slice && fld.Kind() != reflect.Ptr {
295 node = fld.Addr().Interface()
298 node = fld.Interface()
301 kv := reflect.ValueOf(decodedToken)
302 mv := rValue.MapIndex(kv)
305 return fmt.Errorf("object has no key %q", decodedToken)
307 if mv.CanAddr() && mv.Kind() != reflect.Interface && mv.Kind() != reflect.Map && mv.Kind() != reflect.Slice && mv.Kind() != reflect.Ptr {
308 node = mv.Addr().Interface()
311 node = mv.Interface()
314 tokenIndex, err := strconv.Atoi(decodedToken)
318 sLength := rValue.Len()
319 if tokenIndex < 0 || tokenIndex >= sLength {
320 return fmt.Errorf("index out of bounds array[0,%d] index '%d'", sLength, tokenIndex)
323 elem := rValue.Index(tokenIndex)
324 if elem.CanAddr() && elem.Kind() != reflect.Interface && elem.Kind() != reflect.Map && elem.Kind() != reflect.Slice && elem.Kind() != reflect.Ptr {
325 node = elem.Addr().Interface()
328 node = elem.Interface()
331 return fmt.Errorf("invalid token reference %q", decodedToken)
339 // DecodedTokens returns the decoded tokens
340 func (p *Pointer) DecodedTokens() []string {
341 result := make([]string, 0, len(p.referenceTokens))
342 for _, t := range p.referenceTokens {
343 result = append(result, Unescape(t))
348 // IsEmpty returns true if this is an empty json pointer
349 // this indicates that it points to the root document
350 func (p *Pointer) IsEmpty() bool {
351 return len(p.referenceTokens) == 0
354 // Pointer to string representation function
355 func (p *Pointer) String() string {
357 if len(p.referenceTokens) == 0 {
361 pointerString := pointerSeparator + strings.Join(p.referenceTokens, pointerSeparator)
366 // Specific JSON pointer encoding here
369 // ... and vice versa
378 // Unescape unescapes a json pointer reference token string to the original representation
379 func Unescape(token string) string {
380 step1 := strings.Replace(token, encRefTok1, decRefTok1, -1)
381 step2 := strings.Replace(step1, encRefTok0, decRefTok0, -1)
385 // Escape escapes a pointer reference token string
386 func Escape(token string) string {
387 step1 := strings.Replace(token, decRefTok0, encRefTok0, -1)
388 step2 := strings.Replace(step1, decRefTok1, encRefTok1, -1)