x2j.go

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

     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  // x2j - For (mostly) backwards compatibility with legacy x2j package.
     6  // Wrappers for end-to-end XML to JSON transformation and value manipulation.
     7  package x2j
     8  
     9  import (
    10  	. "github.com/clbanning/mxj"
    11  	"io"
    12  )
    13  
    14  // FromXml() --> map[string]interface{}
    15  func XmlToMap(xmlVal []byte) (map[string]interface{}, error) {
    16  	m, err := NewMapXml(xmlVal)
    17  	if err != nil {
    18  		return nil, err
    19  	}
    20  	return map[string]interface{}(m), nil
    21  }
    22  
    23  // map[string]interface{} --> ToXml()
    24  func MapToXml(m map[string]interface{}) ([]byte, error) {
    25  	return Map(m).Xml()
    26  }
    27  
    28  // FromXml() --> ToJson().
    29  func XmlToJson(xmlVal []byte, safeEncoding ...bool) ([]byte, error) {
    30  	m, err := NewMapXml(xmlVal)
    31  	if err != nil {
    32  		return nil, err
    33  	}
    34  	return m.Json(safeEncoding...)
    35  }
    36  
    37  // FromXml() --> ToJsonWriterRaw().
    38  func XmlToJsonWriter(xmlVal []byte, jsonWriter io.Writer, safeEncoding ...bool) ([]byte, error) {
    39  	m, err := NewMapXml(xmlVal)
    40  	if err != nil {
    41  		return nil, err
    42  	}
    43  	return m.JsonWriterRaw(jsonWriter, safeEncoding...)
    44  }
    45  
    46  // FromXmlReaderRaw() --> ToJson().
    47  func XmlReaderToJson(xmlReader io.Reader, safeEncoding ...bool) ([]byte, []byte, error) {
    48  	m, xraw, err := NewMapXmlReaderRaw(xmlReader)
    49  	if err != nil {
    50  		return xraw, nil, err
    51  	}
    52  	j, jerr := m.Json(safeEncoding...)
    53  	return xraw, j, jerr
    54  }
    55  
    56  // FromXmlReader() --> ToJsonWriter().  Handy for bulk transformation of documents.
    57  func XmlReaderToJsonWriter(xmlReader io.Reader, jsonWriter io.Writer, safeEncoding ...bool) ([]byte, []byte, error) {
    58  	m, xraw, err := NewMapXmlReaderRaw(xmlReader)
    59  	if err != nil {
    60  		return xraw, nil, err
    61  	}
    62  	jraw, jerr := m.JsonWriterRaw(jsonWriter, safeEncoding...)
    63  	return xraw, jraw, jerr
    64  }
    65  
    66  // XML wrappers for Map methods implementing tag path and value functions.
    67  
    68  // Wrap PathsForKey for XML.
    69  func XmlPathsForTag(xmlVal []byte, tag string) ([]string, error) {
    70  	m, err := NewMapXml(xmlVal)
    71  	if err != nil {
    72  		return nil, err
    73  	}
    74  	paths := m.PathsForKey(tag)
    75  	return paths, nil
    76  }
    77  
    78  // Wrap PathForKeyShortest for XML.
    79  func XmlPathForTagShortest(xmlVal []byte, tag string) (string, error) {
    80  	m, err := NewMapXml(xmlVal)
    81  	if err != nil {
    82  		return "", err
    83  	}
    84  	path := m.PathForKeyShortest(tag)
    85  	return path, nil
    86  }
    87  
    88  // Wrap ValuesForKey for XML.
    89  // 'attrs' are key:value pairs for attributes, where key is attribute label prepended with a hypen, '-'.
    90  func XmlValuesForTag(xmlVal []byte, tag string, attrs ...string) ([]interface{}, error) {
    91  	m, err := NewMapXml(xmlVal)
    92  	if err != nil {
    93  		return nil, err
    94  	}
    95  	return m.ValuesForKey(tag, attrs...)
    96  }
    97  
    98  // Wrap ValuesForPath for XML.
    99  // 'attrs' are key:value pairs for attributes, where key is attribute label prepended with a hypen, '-'.
   100  func XmlValuesForPath(xmlVal []byte, path string, attrs ...string) ([]interface{}, error) {
   101  	m, err := NewMapXml(xmlVal)
   102  	if err != nil {
   103  		return nil, err
   104  	}
   105  	return m.ValuesForPath(path, attrs...)
   106  }
   107  
   108  // Wrap UpdateValuesForPath for XML
   109  //	'xmlVal' is XML value
   110  //	'newTagValue' is the value to replace an existing value at the end of 'path'
   111  //	'path' is the dot-notation path with the tag whose value is to be replaced at the end
   112  //	       (can include wildcard character, '*')
   113  //	'subkeys' are key:value pairs of tag:values that must match for the tag
   114  func XmlUpdateValsForPath(xmlVal []byte, newTagValue interface{}, path string, subkeys ...string) ([]byte, error) {
   115  	m, err := NewMapXml(xmlVal)
   116  	if err != nil {
   117  		return nil, err
   118  	}
   119  	_, err = m.UpdateValuesForPath(newTagValue, path, subkeys...)
   120  	if err != nil {
   121  		return nil, err
   122  	}
   123  	return m.Xml()
   124  }
   125  
   126  // Wrap NewMap for XML and return as XML
   127  // 'xmlVal' is an XML value
   128  // 'tagpairs' are "oldTag:newTag" values that conform to 'keypairs' in (Map)NewMap.
   129  func XmlNewXml(xmlVal []byte, tagpairs ...string) ([]byte, error) {
   130  	m, err := NewMapXml(xmlVal)
   131  	if err != nil {
   132  		return nil, err
   133  	}
   134  	n, err := m.NewMap(tagpairs...)
   135  	if err != nil {
   136  		return nil, err
   137  	}
   138  	return n.Xml()
   139  }
   140  
   141  // Wrap NewMap for XML and return as JSON
   142  // 'xmlVal' is an XML value
   143  // 'tagpairs' are "oldTag:newTag" values that conform to 'keypairs' in (Map)NewMap.
   144  func XmlNewJson(xmlVal []byte, tagpairs ...string) ([]byte, error) {
   145  	m, err := NewMapXml(xmlVal)
   146  	if err != nil {
   147  		return nil, err
   148  	}
   149  	n, err := m.NewMap(tagpairs...)
   150  	if err != nil {
   151  		return nil, err
   152  	}
   153  	return n.Json()
   154  }
   155  
   156  // Wrap LeafNodes for XML.
   157  // 'xmlVal' is an XML value
   158  func XmlLeafNodes(xmlVal []byte) ([]LeafNode, error) {
   159  	m, err := NewMapXml(xmlVal)
   160  	if err != nil {
   161  		return nil, err
   162  	}
   163  	return m.LeafNodes(), nil
   164  }
   165  
   166  // Wrap LeafValues for XML.
   167  // 'xmlVal' is an XML value
   168  func XmlLeafValues(xmlVal []byte) ([]interface{}, error) {
   169  	m, err := NewMapXml(xmlVal)
   170  	if err != nil {
   171  		return nil, err
   172  	}
   173  	return m.LeafValues(), nil
   174  }
   175  
   176  // Wrap LeafPath for XML.
   177  // 'xmlVal' is an XML value
   178  func XmlLeafPath(xmlVal []byte) ([]string, error) {
   179  	m, err := NewMapXml(xmlVal)
   180  	if err != nil {
   181  		return nil, err
   182  	}
   183  	return m.LeafPaths(), nil
   184  }
   185
View as plain text