j2x.go

Documentation: github.com/clbanning/mxj/v2/j2x

     1  // Copyright 2012-2014 Charles Banning. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file
     4  
     5  // j2x.go - For (mostly) backwards compatibility with legacy j2x package.
     6  // Wrappers for end-to-end JSON to XML transformation and value manipulation.
     7  package j2x
     8  
     9  import (
    10  	. "github.com/clbanning/mxj"
    11  	"io"
    12  )
    13  
    14  // FromJson() --> map[string]interface{}
    15  func JsonToMap(jsonVal []byte) (map[string]interface{}, error) {
    16  	return NewMapJson(jsonVal)
    17  }
    18  
    19  // interface{} --> ToJson (w/o safe encoding, default) {
    20  func MapToJson(m map[string]interface{}, safeEncoding ...bool) ([]byte, error) {
    21  	return Map(m).Json()
    22  }
    23  
    24  // FromJson() --> ToXml().
    25  func JsonToXml(jsonVal []byte) ([]byte, error) {
    26  	m, err := NewMapJson(jsonVal)
    27  	if err != nil {
    28  		return nil, err
    29  	}
    30  	return m.Xml()
    31  }
    32  
    33  // FromJson() --> ToXmlWriter().
    34  func JsonToXmlWriter(jsonVal []byte, xmlWriter io.Writer) error {
    35  	m, err := NewMapJson(jsonVal)
    36  	if err != nil {
    37  		return err
    38  	}
    39  	return m.XmlWriter(xmlWriter)
    40  }
    41  
    42  // FromJsonReader() --> ToXml().
    43  func JsonReaderToXml(jsonReader io.Reader) ([]byte, []byte, error) {
    44  	m, jraw, err := NewMapJsonReaderRaw(jsonReader)
    45  	if err != nil {
    46  		return jraw, nil, err
    47  	}
    48  	x, xerr := m.Xml()
    49  	return jraw, x, xerr
    50  }
    51  
    52  // FromJsonReader() --> ToXmlWriter().  Handy for transforming bulk message sets.
    53  func JsonReaderToXmlWriter(jsonReader io.Reader, xmlWriter io.Writer) error {
    54  	m, err := NewMapJsonReader(jsonReader)
    55  	if err != nil {
    56  		return err
    57  	}
    58  	err = m.XmlWriter(xmlWriter)
    59  	return err
    60  }
    61  
    62  // JSON wrappers for Map methods implementing key path and value functions.
    63  
    64  // Wrap PathsForKey for JSON.
    65  func JsonPathsForKey(jsonVal []byte, key string) ([]string, error) {
    66  	m, err := NewMapJson(jsonVal)
    67  	if err != nil {
    68  		return nil, err
    69  	}
    70  	paths := m.PathsForKey(key)
    71  	return paths, nil
    72  }
    73  
    74  // Wrap PathForKeyShortest for JSON.
    75  func JsonPathForKeyShortest(jsonVal []byte, key string) (string, error) {
    76  	m, err := NewMapJson(jsonVal)
    77  	if err != nil {
    78  		return "", err
    79  	}
    80  	path := m.PathForKeyShortest(key)
    81  	return path, nil
    82  }
    83  
    84  // Wrap ValuesForKey for JSON.
    85  func JsonValuesForKey(jsonVal []byte, key string, subkeys ...string) ([]interface{}, error) {
    86  	m, err := NewMapJson(jsonVal)
    87  	if err != nil {
    88  		return nil, err
    89  	}
    90  	return m.ValuesForKey(key, subkeys...)
    91  }
    92  
    93  // Wrap ValuesForKeyPath for JSON.
    94  func JsonValuesForKeyPath(jsonVal []byte, path string, subkeys ...string) ([]interface{}, error) {
    95  	m, err := NewMapJson(jsonVal)
    96  	if err != nil {
    97  		return nil, err
    98  	}
    99  	return m.ValuesForPath(path, subkeys...)
   100  }
   101  
   102  // Wrap UpdateValuesForPath for JSON
   103  //	'jsonVal' is XML value
   104  //	'newKeyValue' is the value to replace an existing value at the end of 'path'
   105  //	'path' is the dot-notation path with the key whose value is to be replaced at the end
   106  //	       (can include wildcard character, '*')
   107  //	'subkeys' are key:value pairs of key:values that must match for the key
   108  func JsonUpdateValsForPath(jsonVal []byte, newKeyValue interface{}, path string, subkeys ...string) ([]byte, error) {
   109  	m, err := NewMapJson(jsonVal)
   110  	if err != nil {
   111  		return nil, err
   112  	}
   113  	_, err = m.UpdateValuesForPath(newKeyValue, path, subkeys...)
   114  	if err != nil {
   115  		return nil, err
   116  	}
   117  	return m.Json()
   118  }
   119  
   120  // Wrap NewMap for JSON and return as JSON
   121  // 'jsonVal' is an JSON value
   122  // 'keypairs' are "oldKey:newKey" values that conform to 'keypairs' in (Map)NewMap.
   123  func JsonNewJson(jsonVal []byte, keypairs ...string) ([]byte, error) {
   124  	m, err := NewMapJson(jsonVal)
   125  	if err != nil {
   126  		return nil, err
   127  	}
   128  	n, err := m.NewMap(keypairs...)
   129  	if err != nil {
   130  		return nil, err
   131  	}
   132  	return n.Json()
   133  }
   134  
   135  // Wrap NewMap for JSON and return as XML
   136  // 'jsonVal' is an JSON value
   137  // 'keypairs' are "oldKey:newKey" values that conform to 'keypairs' in (Map)NewMap.
   138  func JsonNewXml(jsonVal []byte, keypairs ...string) ([]byte, error) {
   139  	m, err := NewMapJson(jsonVal)
   140  	if err != nil {
   141  		return nil, err
   142  	}
   143  	n, err := m.NewMap(keypairs...)
   144  	if err != nil {
   145  		return nil, err
   146  	}
   147  	return n.Xml()
   148  }
   149  
   150  // Wrap LeafNodes for JSON.
   151  // 'jsonVal' is an JSON value
   152  func JsonLeafNodes(jsonVal []byte) ([]LeafNode, error) {
   153  	m, err := NewMapJson(jsonVal)
   154  	if err != nil {
   155  		return nil, err
   156  	}
   157  	return m.LeafNodes(), nil
   158  }
   159  
   160  // Wrap LeafValues for JSON.
   161  // 'jsonVal' is an JSON value
   162  func JsonLeafValues(jsonVal []byte) ([]interface{}, error) {
   163  	m, err := NewMapJson(jsonVal)
   164  	if err != nil {
   165  		return nil, err
   166  	}
   167  	return m.LeafValues(), nil
   168  }
   169  
   170  // Wrap LeafPath for JSON.
   171  // 'xmlVal' is an JSON value
   172  func JsonLeafPath(jsonVal []byte) ([]string, error) {
   173  	m, err := NewMapJson(jsonVal)
   174  	if err != nil {
   175  		return nil, err
   176  	}
   177  	return m.LeafPaths(), nil
   178  }
   179
View as plain text