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.
7package j2x
8
9import (
10	. "github.com/clbanning/mxj"
11	"io"
12)
13
14// FromJson() --> map[string]interface{}
15func JsonToMap(jsonVal []byte) (map[string]interface{}, error) {
16	return NewMapJson(jsonVal)
17}
18
19// interface{} --> ToJson (w/o safe encoding, default) {
20func MapToJson(m map[string]interface{}, safeEncoding ...bool) ([]byte, error) {
21	return Map(m).Json()
22}
23
24// FromJson() --> ToXml().
25func 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().
34func JsonToXmlWriter(jsonVal []byte, xmlWriter io.Writer) ([]byte, error) {
35	m, err := NewMapJson(jsonVal)
36	if err != nil {
37		return nil, err
38	}
39	return m.XmlWriterRaw(xmlWriter)
40}
41
42// FromJsonReader() --> ToXml().
43func 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.
53func JsonReaderToXmlWriter(jsonReader io.Reader, xmlWriter io.Writer) ([]byte, []byte, error) {
54	m, jraw, err := NewMapJsonReaderRaw(jsonReader)
55	if err != nil {
56		return jraw, nil, err
57	}
58	xraw, xerr := m.XmlWriterRaw(xmlWriter)
59	return jraw, xraw, xerr
60}
61
62// JSON wrappers for Map methods implementing key path and value functions.
63
64// Wrap PathsForKey for JSON.
65func 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.
75func 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.
85func 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.
94func 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
108func 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.
123func 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.
138func 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
152func 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
162func 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
172func 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