func (bagc BiddableAdGroupCriterion) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
start.Attr = append(
start.Attr,
xml.Attr{
xml.Name{"http://www.w3.org/2001/XMLSchema-instance", "type"},
"BiddableAdGroupCriterion",
},
)
e.EncodeToken(start)
e.EncodeElement(&bagc.AdGroupId, xml.StartElement{Name: xml.Name{"", "adGroupId"}})
criterionMarshalXML(bagc.Criterion, e)
if bagc.UserStatus != "" {
e.EncodeElement(&bagc.UserStatus, xml.StartElement{Name: xml.Name{"", "userStatus"}})
}
if bagc.DestinationUrl != "" {
e.EncodeElement(&bagc.DestinationUrl, xml.StartElement{Name: xml.Name{"", "destinationUrl"}})
}
e.EncodeElement(&bagc.BiddingStrategyConfiguration, xml.StartElement{Name: xml.Name{"", "biddingStrategyConfiguration"}})
if bagc.BidModifier != 0 {
e.EncodeElement(&bagc.BidModifier, xml.StartElement{Name: xml.Name{"", "bidModifier"}})
}
e.EncodeToken(start.End())
return nil
}
func writeResponse(w http.ResponseWriter, statusCode int, action string, data interface{}) {
responseBuffer := &bytes.Buffer{}
encoder := xml.NewEncoder(responseBuffer)
resultWrapper := xml.StartElement{Name: xml.Name{Local: action + "Result"}}
err := encoder.EncodeToken(resultWrapper)
if err != nil {
panic(err)
}
err = xmlutil.BuildXML(data, encoder)
if err != nil {
panic(err)
}
err = encoder.EncodeToken(resultWrapper.End())
if err != nil {
panic(err)
}
err = encoder.Flush()
if err != nil {
panic(err)
}
w.WriteHeader(statusCode)
_, err = w.Write(responseBuffer.Bytes())
if err != nil {
panic(err)
}
}
func (a *APITime) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
a.Time = time.Time{}
for {
t, _ := d.Token()
if t == nil {
return fmt.Errorf("couldn't find apitime end element, ran out of data!")
}
if t == start.End() {
break
}
if timeBytes, ok := t.(xml.CharData); ok {
var err error
a.Time, err = time.Parse(ApiDateTimeFormat, string(timeBytes))
if err != nil {
return err
}
}
}
if a.Time.IsZero() {
return fmt.Errorf("couldn't find a valid apitime.")
}
return nil
}
func encEle(n tree.Elem, e *xml.Encoder) error {
ele := xml.StartElement{
Name: n.GetToken().(xml.StartElement).Name,
}
attrs := n.GetAttrs()
ele.Attr = make([]xml.Attr, len(attrs))
for i := range attrs {
ele.Attr[i] = attrs[i].GetToken().(xml.Attr)
}
err := e.EncodeToken(ele)
if err != nil {
return err
}
if x, ok := n.(tree.Elem); ok {
for _, i := range x.GetChildren() {
err := encTok(i, e)
if err != nil {
return err
}
}
}
return e.EncodeToken(ele.End())
}
func (c ChoiceParser) ParseList(d *xml.Decoder, start xml.StartElement, containerPtr interface{}, typeofPtr interface{}, appenderType appender) error {
typeof := reflect.TypeOf(typeofPtr).Elem()
container := reflect.ValueOf(containerPtr).Elem()
token, err := d.Token()
for token != start.End() {
if err != nil {
return err
}
next, ok := token.(xml.StartElement)
if ok {
item, err := c.Parse(d, next)
if err != nil {
return err
}
val := reflect.ValueOf(item)
if !val.Type().Implements(typeof) {
return fmt.Errorf("Item is not a valid %v.", typeof.Name())
}
appendFn := appenders[appenderType]
appendFn(container, val)
}
token, err = d.Token()
}
return nil
}
func (x *XmlNode) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
x.Name = getName(start.Name)
x.Attrs = map[string]string{}
for _, attr := range start.Attr {
x.Attrs[getName(attr.Name)] = attr.Value
}
token, err := d.Token()
for token != start.End() {
if err != nil {
return err
}
next, ok := token.(xml.StartElement)
if ok {
child := XmlNode{}
err = child.UnmarshalXML(d, next)
if err != nil {
return err
}
x.Children = append(x.Children, child)
} else {
text, ok := token.(xml.CharData)
if ok {
x.Children = append(x.Children, TextNode(string([]byte(text))))
}
}
token, err = d.Token()
}
return nil
}
// MarshalXML implements the xml.Marshaller method to allow for the
// correct wrapper/start element case and attr data.
func (c Change) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
start.Name.Local = "osmChange"
start.Attr = []xml.Attr{
{Name: xml.Name{Local: "version"}, Value: "0.6"},
{Name: xml.Name{Local: "generator"}, Value: "go.osm"},
}
if err := e.EncodeToken(start); err != nil {
return err
}
if err := marshalInnerChange(e, "create", c.Create); err != nil {
return err
}
if err := marshalInnerChange(e, "modify", c.Modify); err != nil {
return err
}
if err := marshalInnerChange(e, "delete", c.Delete); err != nil {
return err
}
if err := e.EncodeToken(start.End()); err != nil {
return err
}
return nil
}
func (a1 AdGroupAds) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
a := a1[0]
e.EncodeToken(start)
switch a.(type) {
case TextAd:
ad := a.(TextAd)
e.EncodeElement(ad.AdGroupId, xml.StartElement{Name: xml.Name{"", "adGroupId"}})
e.EncodeElement(ad, xml.StartElement{
xml.Name{"", "ad"},
[]xml.Attr{
xml.Attr{xml.Name{"http://www.w3.org/2001/XMLSchema-instance", "type"}, "TextAd"},
},
})
e.EncodeElement(ad.Status, xml.StartElement{Name: xml.Name{"", "status"}})
e.EncodeElement(ad.Labels, xml.StartElement{Name: xml.Name{"", "labels"}})
case ImageAd:
return ERROR_NOT_YET_IMPLEMENTED
case TemplateAd:
return ERROR_NOT_YET_IMPLEMENTED
default:
return fmt.Errorf("unknown Ad type -> %#v", start)
}
e.EncodeToken(start.End())
return nil
}
func (p PList) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
start.Name = xml.Name{Local: "plist"}
start.Attr = []xml.Attr{xml.Attr{Name: xml.Name{Local: "version"}, Value: "1.0"}}
e.EncodeToken(start)
PDict(p).MarshalXML(e, xml.StartElement{})
e.EncodeToken(start.End())
return nil
}
func (self *Element) Encode(enc *xml.Encoder, sr SchemaRepository, ga GetAliaser, params map[string]interface{}, path ...string) (err error) {
if self.MinOccurs != "" && self.MinOccurs == "0" && !hasPrefix(params, MakePath(append(path, self.Name))) {
return
}
for hasPrefix(params, MakePath(append(path, self.Name))) {
start := xml.StartElement{
Name: xml.Name{
Space: ga.Namespace(),
Local: self.Name,
},
}
err = enc.EncodeToken(start)
if err != nil {
return
}
if self.Type != "" {
parts := strings.Split(self.Type, ":")
switch len(parts) {
case 1:
err = self.Encode(enc, sr, ga, params, append(path, self.Name)...)
if err != nil {
return
}
case 2:
var schema Schemaer
schema, err = sr.GetSchema(ga.GetAlias(parts[0]))
if err != nil {
return
}
err = schema.EncodeType(parts[1], enc, sr, params, append(path, self.Name)...)
if err != nil {
return
}
default:
err = fmt.Errorf("malformed type '%s' in path %q", self.Type, path)
return
}
} else if self.ComplexTypes != nil {
for _, e := range self.ComplexTypes.Sequence {
err = e.Encode(enc, sr, ga, params, append(path, self.Name)...)
if err != nil {
return
}
}
}
err = enc.EncodeToken(start.End())
if err != nil {
return
}
}
return
}
func (a AlfredOutput) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
start.Name = xml.Name{Local: "items"}
e.EncodeToken(start)
for _, item := range a {
e.EncodeElement(item, xml.StartElement{Name: xml.Name{Local: "item"}})
}
e.EncodeToken(start.End())
return nil
}
func (a PArray) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
start.Name = xml.Name{Local: "array"}
e.EncodeToken(start)
for _, el := range a {
el.(xml.Marshaler).MarshalXML(e, start)
}
e.EncodeToken(start.End())
return nil
}
func (d PDict) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
start.Name = xml.Name{Local: "dict"}
e.EncodeToken(start)
for k, v := range d {
e.EncodeElement(k, xml.StartElement{Name: xml.Name{Local: "key"}})
v.MarshalXML(e, start)
}
e.EncodeToken(start.End())
return nil
}
func (mmo MutateMembersOperand) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
mmo.encodeEmails()
e.EncodeToken(start)
e.EncodeElement(&mmo.UserListId, xml.StartElement{Name: xml.Name{baseRemarketingUrl, "userListId"}})
e.EncodeElement(&mmo.DataType, xml.StartElement{Name: xml.Name{baseRemarketingUrl, "dataType"}})
e.EncodeElement(&mmo.Members, xml.StartElement{Name: xml.Name{baseRemarketingUrl, "members"}})
e.EncodeToken(start.End())
return nil
}
// MarshalXML implements xml.Marshaler interface
func (c StreamErrorCondition) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
t := xml.StartElement{
Name: xml.Name{
"urn:ietf:params:xml:ns:xmpp-streams", string(c),
},
}
e.EncodeToken(t)
e.EncodeToken(t.End())
return nil
}
// MarshalXML is a custom XML marshaler for metadataMap, mapping each metadata name/value pair to a
// correspondingly named XML element with the pair's value as character data content.
func (m metadataMap) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
if err := e.EncodeToken(start); err != nil {
return err
}
for k, v := range m {
if err := e.EncodeElement(v, startLocalName(k)); err != nil {
return err
}
}
return e.EncodeToken(start.End())
}
func (nagc NegativeAdGroupCriterion) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
start.Attr = append(
start.Attr,
xml.Attr{
xml.Name{"http://www.w3.org/2001/XMLSchema-instance", "type"},
"NegativeAdGroupCriterion",
},
)
e.EncodeToken(start)
e.EncodeElement(&nagc.AdGroupId, xml.StartElement{Name: xml.Name{"", "adGroupId"}})
criterionMarshalXML(nagc.Criterion, e)
e.EncodeToken(start.End())
return nil
}
// MarshalXML is a custom XML marshaler for DataCenterInfo, writing either Metadata or AlternateMetadata
// depending on the type of data center indicated by the Name.
func (i DataCenterInfo) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
if err := e.EncodeToken(start); err != nil {
return err
}
if err := e.EncodeElement(i.Name, startName); err != nil {
return err
}
if err := e.EncodeElement(metadataValue(i), startMetadata); err != nil {
return err
}
return e.EncodeToken(start.End())
}
func (this *Pair) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
if err := e.EncodeToken(start); err != nil {
return err
}
if err := this.Left.marshalXML(e, start); err != nil {
return err
}
if err := this.Right.marshalXML(e, start); err != nil {
return err
}
if err := e.EncodeToken(start.End()); err != nil {
return err
}
return nil
}
func (ncc NegativeCampaignCriterion) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
isNegative := true
//fmt.Printf("processing -> %#v\n",ncc)
start.Attr = append(
start.Attr,
xml.Attr{
xml.Name{"http://www.w3.org/2001/XMLSchema-instance", "type"},
"NegativeCampaignCriterion",
},
)
e.EncodeToken(start)
e.EncodeElement(&ncc.CampaignId, xml.StartElement{Name: xml.Name{"", "campaignId"}})
e.EncodeElement(&isNegative, xml.StartElement{Name: xml.Name{"", "isNegative"}})
criterionMarshalXML(ncc.Criterion, e)
e.EncodeToken(start.End())
return nil
}
func (p *xmlPlistGenerator) generateDocument(pval *plistValue) {
io.WriteString(p.writer, xml.Header)
io.WriteString(p.writer, xmlDOCTYPE)
plistStartElement := xml.StartElement{
xml.Name{"", "plist"},
[]xml.Attr{
{xml.Name{"", "version"}, "1.0"},
},
}
p.xmlEncoder.EncodeToken(plistStartElement)
p.writePlistValue(pval)
p.xmlEncoder.EncodeToken(plistStartElement.End())
p.xmlEncoder.Flush()
}
func (e *XMLFormat) WriteRow(values map[string]interface{}) error {
row := xml.StartElement{Name: xml.Name{"", "row"}}
tokens := []xml.Token{row}
for key, value := range values {
var charData xml.CharData
t := xml.StartElement{Name: xml.Name{"", key}}
switch value := (value).(type) {
case string:
charData = xml.CharData(value)
case []byte:
charData = xml.CharData(string(value))
case int64:
charData = xml.CharData(fmt.Sprintf("%d", value))
case float64:
charData = xml.CharData(strconv.FormatFloat(value, 'f', -1, 64))
case time.Time:
charData = xml.CharData(value.Format(time.RFC3339))
case bool:
if value == true {
charData = xml.CharData("true")
} else {
charData = xml.CharData("false")
}
}
tokens = append(tokens, t, charData, t.End())
}
tokens = append(tokens, row.End())
for _, t := range tokens {
err := e.encoder.EncodeToken(t)
if err != nil {
return err
}
}
err := e.encoder.Flush()
if err != nil {
return err
}
return nil
}
func WrapList(e *xml.Encoder, listName xml.Name, list interface{}) error {
listVal := reflect.ValueOf(list)
token := xml.StartElement{
Name: listName,
}
err := e.EncodeToken(token)
if err != nil {
return err
}
count := listVal.Len()
for index := 0; index < count; index++ {
err = e.Encode(listVal.Index(index).Interface())
if err != nil {
return err
}
}
return e.EncodeToken(token.End())
}
// MarshalXML implements the xml.Marshaller method to exclude this
// whole element if the comments are empty.
func (csd ChangesetDiscussion) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
if len(csd.Comments) == 0 {
return nil
}
if err := e.EncodeToken(start); err != nil {
return err
}
t := xml.StartElement{Name: xml.Name{Local: "comment"}}
if err := e.EncodeElement(csd.Comments, t); err != nil {
return err
}
if err := e.EncodeToken(start.End()); err != nil {
return err
}
return nil
}
func (t *Tag) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
start.Name = t.Name
start.Attr = t.Attr
e.EncodeToken(start)
for _, v := range t.Children {
switch v.(type) {
case *Tag:
child := v.(*Tag)
if err := e.Encode(child); err != nil {
return err
}
case xml.CharData:
e.EncodeToken(v.(xml.CharData))
case xml.Comment:
e.EncodeToken(v.(xml.Comment))
}
}
e.EncodeToken(start.End())
return nil
}
func marshalInnerChange(e *xml.Encoder, name string, o *OSM) error {
if o == nil {
return nil
}
t := xml.StartElement{Name: xml.Name{Local: name}}
if err := e.EncodeToken(t); err != nil {
return err
}
if err := o.marshalInnerXML(e); err != nil {
return err
}
if err := e.EncodeToken(t.End()); err != nil {
return err
}
return nil
}
// MarshalXML implements the xml.Marshaller method to allow for the
// correct wrapper/start element case and attr data.
func (o OSM) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
start.Name.Local = "osm"
start.Attr = []xml.Attr{
{Name: xml.Name{Local: "version"}, Value: "0.6"},
{Name: xml.Name{Local: "generator"}, Value: "go.osm"},
}
if err := e.EncodeToken(start); err != nil {
return err
}
if err := o.marshalInnerXML(e); err != nil {
return err
}
if err := e.EncodeToken(start.End()); err != nil {
return err
}
return nil
}
func (fc *FeatureContainer) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
start = xml.StartElement{Name: xml.Name{Local: "stream:features"}}
if err := e.EncodeToken(start); err != nil {
return err
}
fs := make([]Feature, 0, len(fc.features))
for _, v := range fc.features {
fs = append(fs, v)
}
if err := e.Encode(fs); err != nil {
return err
}
if err := e.EncodeToken(start.End()); err != nil {
return err
}
return e.Flush()
}
func (x *domm) MarshalXML(e *xml.Encoder, start xml.StartElement) (err error) {
start.Name.Local = x.model.Name()
for k, v := range x.model.AttrAsMap() {
start.Attr = append(start.Attr, xml.Attr{Name: xml.Name{Local: k}, Value: v})
}
e.EncodeToken(start)
for _, _l := range x.model.Children() {
switch l := _l.(type) {
case dom.Element:
child := &domm{}
child.model = l
e.Encode(child)
case dom.Text:
e.EncodeToken(xml.CharData(l.Data()))
default:
halt.As(100, reflect.TypeOf(l))
}
}
e.EncodeToken(start.End())
return
}
func (cc CampaignCriterion) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
isNegative := false
//fmt.Printf("processing -> %#v\n",ncc)
start.Attr = append(
start.Attr,
xml.Attr{
xml.Name{"http://www.w3.org/2001/XMLSchema-instance", "type"},
"CampaignCriterion",
},
)
e.EncodeToken(start)
e.EncodeElement(&cc.CampaignId, xml.StartElement{Name: xml.Name{"", "campaignId"}})
e.EncodeElement(&isNegative, xml.StartElement{Name: xml.Name{"", "isNegative"}})
if err := criterionMarshalXML(cc.Criterion, e); err != nil {
return err
}
if cc.BidModifier != nil {
e.EncodeElement(&cc.BidModifier, xml.StartElement{Name: xml.Name{"", "bidModifier"}})
}
e.EncodeToken(start.End())
return nil
}