text:
package wpthrift_types

import (
	"bytes"
	"fmt"
	"git.apache.org/thrift.git/lib/go/thrift"
)

// (needed to ensure safety because of naive import list construction.)
var _ = thrift.ZERO
var _ = fmt.Printf
var _ = bytes.Equal

// Attributes:
//  - Message
type Error struct {
  Message string `thrift:"message,1" db:"message" json:"message"`
}

func NewError() *Error {
  return &Error{}
}

func (p *Error) GetMessage() string {
  return p.Message
}
func (p *Error) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }

  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if err := p.ReadField1(iprot); err != nil {
        return err
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *Error)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.Message = v
}
  return nil
}

func (p *Error) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("Error"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *Error) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("message", thrift.STRING, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:message: ", p), err) }
  if err := oprot.WriteString(string(p.Message)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.message (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:message: ", p), err) }
  return err
}

func (p *Error) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("Error(%+v)", *p)
}

func (p *Error) Error() string {
  return p.String()
}

// Attributes:
//  - ID
//  - Name
//  - Description
//  - Prices
type Service struct {
  ID int32 `thrift:"id,1" db:"id" json:"id"`
  Name string `thrift:"name,2" db:"name" json:"name"`
  Description string `thrift:"description,3" db:"description" json:"description"`
  Prices map[int32]*Price `thrift:"prices,4" db:"prices" json:"prices,omitempty"`
}

func NewService() *Service {
  return &Service{}
}

func (p *Service) GetID() int32 {
  return p.ID
}

func (p *Service) GetName() string {
  return p.Name
}

func (p *Service) GetDescription() string {
  return p.Description
}
var Service_Prices_DEFAULT map[int32]*Price

func (p *Service) GetPrices() map[int32]*Price {
  return p.Prices
}
func (p *Service) IsSetPrices() bool {
  return p.Prices != nil
}

func (p *Service) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }

  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if err := p.ReadField1(iprot); err != nil {
        return err
      }
    case 2:
      if err := p.ReadField2(iprot); err != nil {
        return err
      }
    case 3:
      if err := p.ReadField3(iprot); err != nil {
        return err
      }
    case 4:
      if err := p.ReadField4(iprot); err != nil {
        return err
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *Service)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.ID = v
}
  return nil
}

func (p *Service)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.Name = v
}
  return nil
}

func (p *Service)  ReadField3(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.Description = v
}
  return nil
}

func (p *Service)  ReadField4(iprot thrift.TProtocol) error {
  _, _, size, err := iprot.ReadMapBegin()
  if err != nil {
    return thrift.PrependError("error reading map begin: ", err)
  }
  tMap := make(map[int32]*Price, size)
  p.Prices =  tMap
  for i := 0; i < size; i ++ {
var _key0 int32
    if v, err := iprot.ReadI32(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    _key0 = v
}
    _val1 := &Price{}
    if err := _val1.Read(iprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _val1), err)
    }
    p.Prices[_key0] = _val1
  }
  if err := iprot.ReadMapEnd(); err != nil {
    return thrift.PrependError("error reading map end: ", err)
  }
  return nil
}

func (p *Service) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("Service"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
    if err := p.writeField3(oprot); err != nil { return err }
    if err := p.writeField4(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *Service) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("id", thrift.I32, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:id: ", p), err) }
  if err := oprot.WriteI32(int32(p.ID)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.id (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:id: ", p), err) }
  return err
}

func (p *Service) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("name", thrift.STRING, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:name: ", p), err) }
  if err := oprot.WriteString(string(p.Name)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.name (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:name: ", p), err) }
  return err
}

func (p *Service) writeField3(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("description", thrift.STRING, 3); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:description: ", p), err) }
  if err := oprot.WriteString(string(p.Description)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.description (3) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 3:description: ", p), err) }
  return err
}

func (p *Service) writeField4(oprot thrift.TProtocol) (err error) {
  if p.IsSetPrices() {
    if err := oprot.WriteFieldBegin("prices", thrift.MAP, 4); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:prices: ", p), err) }
    if err := oprot.WriteMapBegin(thrift.I32, thrift.STRUCT, len(p.Prices)); err != nil {
      return thrift.PrependError("error writing map begin: ", err)
    }
    for k, v := range p.Prices {
      if err := oprot.WriteI32(int32(k)); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
      if err := v.Write(oprot); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
      }
    }
    if err := oprot.WriteMapEnd(); err != nil {
      return thrift.PrependError("error writing map end: ", err)
    }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 4:prices: ", p), err) }
  }
  return err
}

func (p *Service) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("Service(%+v)", *p)
}

// Attributes:
//  - ID
//  - Description
//  - PricePerUnit
//  - UnitId
//  - UnitDescription
type Price struct {
  ID int32 `thrift:"id,1" db:"id" json:"id"`
  Description string `thrift:"description,2" db:"description" json:"description"`
  PricePerUnit *PricePerUnit `thrift:"pricePerUnit,3" db:"pricePerUnit" json:"pricePerUnit"`
  UnitId int32 `thrift:"unitId,4" db:"unitId" json:"unitId"`
  UnitDescription string `thrift:"unitDescription,5" db:"unitDescription" json:"unitDescription"`
}

func NewPrice() *Price {
  return &Price{}
}

func (p *Price) GetID() int32 {
  return p.ID
}

func (p *Price) GetDescription() string {
  return p.Description
}
var Price_PricePerUnit_DEFAULT *PricePerUnit
func (p *Price) GetPricePerUnit() *PricePerUnit {
  if !p.IsSetPricePerUnit() {
    return Price_PricePerUnit_DEFAULT
  }
return p.PricePerUnit
}

func (p *Price) GetUnitId() int32 {
  return p.UnitId
}

func (p *Price) GetUnitDescription() string {
  return p.UnitDescription
}
func (p *Price) IsSetPricePerUnit() bool {
  return p.PricePerUnit != nil
}

func (p *Price) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }

  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if err := p.ReadField1(iprot); err != nil {
        return err
      }
    case 2:
      if err := p.ReadField2(iprot); err != nil {
        return err
      }
    case 3:
      if err := p.ReadField3(iprot); err != nil {
        return err
      }
    case 4:
      if err := p.ReadField4(iprot); err != nil {
        return err
      }
    case 5:
      if err := p.ReadField5(iprot); err != nil {
        return err
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *Price)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.ID = v
}
  return nil
}

func (p *Price)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.Description = v
}
  return nil
}

func (p *Price)  ReadField3(iprot thrift.TProtocol) error {
  p.PricePerUnit = &PricePerUnit{}
  if err := p.PricePerUnit.Read(iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.PricePerUnit), err)
  }
  return nil
}

func (p *Price)  ReadField4(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 4: ", err)
} else {
  p.UnitId = v
}
  return nil
}

func (p *Price)  ReadField5(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 5: ", err)
} else {
  p.UnitDescription = v
}
  return nil
}

func (p *Price) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("Price"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
    if err := p.writeField3(oprot); err != nil { return err }
    if err := p.writeField4(oprot); err != nil { return err }
    if err := p.writeField5(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *Price) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("id", thrift.I32, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:id: ", p), err) }
  if err := oprot.WriteI32(int32(p.ID)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.id (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:id: ", p), err) }
  return err
}

func (p *Price) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("description", thrift.STRING, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:description: ", p), err) }
  if err := oprot.WriteString(string(p.Description)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.description (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:description: ", p), err) }
  return err
}

func (p *Price) writeField3(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("pricePerUnit", thrift.STRUCT, 3); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:pricePerUnit: ", p), err) }
  if err := p.PricePerUnit.Write(oprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.PricePerUnit), err)
  }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 3:pricePerUnit: ", p), err) }
  return err
}

func (p *Price) writeField4(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("unitId", thrift.I32, 4); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:unitId: ", p), err) }
  if err := oprot.WriteI32(int32(p.UnitId)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.unitId (4) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 4:unitId: ", p), err) }
  return err
}

func (p *Price) writeField5(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("unitDescription", thrift.STRING, 5); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 5:unitDescription: ", p), err) }
  if err := oprot.WriteString(string(p.UnitDescription)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.unitDescription (5) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 5:unitDescription: ", p), err) }
  return err
}

func (p *Price) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("Price(%+v)", *p)
}

// Attributes:
//  - Amount
//  - CurrencyCode
type PricePerUnit struct {
  Amount int32 `thrift:"amount,1" db:"amount" json:"amount"`
  CurrencyCode string `thrift:"currencyCode,2" db:"currencyCode" json:"currencyCode"`
}

func NewPricePerUnit() *PricePerUnit {
  return &PricePerUnit{}
}

func (p *PricePerUnit) GetAmount() int32 {
  return p.Amount
}

func (p *PricePerUnit) GetCurrencyCode() string {
  return p.CurrencyCode
}
func (p *PricePerUnit) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }

  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if err := p.ReadField1(iprot); err != nil {
        return err
      }
    case 2:
      if err := p.ReadField2(iprot); err != nil {
        return err
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *PricePerUnit)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.Amount = v
}
  return nil
}

func (p *PricePerUnit)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.CurrencyCode = v
}
  return nil
}

func (p *PricePerUnit) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("PricePerUnit"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *PricePerUnit) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("amount", thrift.I32, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:amount: ", p), err) }
  if err := oprot.WriteI32(int32(p.Amount)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.amount (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:amount: ", p), err) }
  return err
}

func (p *PricePerUnit) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("currencyCode", thrift.STRING, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:currencyCode: ", p), err) }
  if err := oprot.WriteString(string(p.CurrencyCode)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.currencyCode (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:currencyCode: ", p), err) }
  return err
}

func (p *PricePerUnit) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("PricePerUnit(%+v)", *p)
}

// Attributes:
//  - FirstName
//  - LastName
//  - ExpMonth
//  - ExpYear
//  - CardNumber
//  - Type
//  - Cvc
type HCECard struct {
  FirstName string `thrift:"FirstName,1" db:"FirstName" json:"FirstName"`
  LastName string `thrift:"LastName,2" db:"LastName" json:"LastName"`
  ExpMonth int32 `thrift:"ExpMonth,3" db:"ExpMonth" json:"ExpMonth"`
  ExpYear int32 `thrift:"ExpYear,4" db:"ExpYear" json:"ExpYear"`
  CardNumber string `thrift:"CardNumber,5" db:"CardNumber" json:"CardNumber"`
  Type string `thrift:"Type,6" db:"Type" json:"Type"`
  Cvc string `thrift:"Cvc,7" db:"Cvc" json:"Cvc"`
}

func NewHCECard() *HCECard {
  return &HCECard{}
}

func (p *HCECard) GetFirstName() string {
  return p.FirstName
}

func (p *HCECard) GetLastName() string {
  return p.LastName
}

func (p *HCECard) GetExpMonth() int32 {
  return p.ExpMonth
}

func (p *HCECard) GetExpYear() int32 {
  return p.ExpYear
}

func (p *HCECard) GetCardNumber() string {
  return p.CardNumber
}

func (p *HCECard) GetType() string {
  return p.Type
}

func (p *HCECard) GetCvc() string {
  return p.Cvc
}
func (p *HCECard) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }

  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if err := p.ReadField1(iprot); err != nil {
        return err
      }
    case 2:
      if err := p.ReadField2(iprot); err != nil {
        return err
      }
    case 3:
      if err := p.ReadField3(iprot); err != nil {
        return err
      }
    case 4:
      if err := p.ReadField4(iprot); err != nil {
        return err
      }
    case 5:
      if err := p.ReadField5(iprot); err != nil {
        return err
      }
    case 6:
      if err := p.ReadField6(iprot); err != nil {
        return err
      }
    case 7:
      if err := p.ReadField7(iprot); err != nil {
        return err
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *HCECard)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.FirstName = v
}
  return nil
}

func (p *HCECard)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.LastName = v
}
  return nil
}

func (p *HCECard)  ReadField3(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.ExpMonth = v
}
  return nil
}

func (p *HCECard)  ReadField4(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 4: ", err)
} else {
  p.ExpYear = v
}
  return nil
}

func (p *HCECard)  ReadField5(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 5: ", err)
} else {
  p.CardNumber = v
}
  return nil
}

func (p *HCECard)  ReadField6(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 6: ", err)
} else {
  p.Type = v
}
  return nil
}

func (p *HCECard)  ReadField7(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 7: ", err)
} else {
  p.Cvc = v
}
  return nil
}

func (p *HCECard) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("HCECard"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
    if err := p.writeField3(oprot); err != nil { return err }
    if err := p.writeField4(oprot); err != nil { return err }
    if err := p.writeField5(oprot); err != nil { return err }
    if err := p.writeField6(oprot); err != nil { return err }
    if err := p.writeField7(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *HCECard) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("FirstName", thrift.STRING, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:FirstName: ", p), err) }
  if err := oprot.WriteString(string(p.FirstName)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.FirstName (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:FirstName: ", p), err) }
  return err
}

func (p *HCECard) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("LastName", thrift.STRING, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:LastName: ", p), err) }
  if err := oprot.WriteString(string(p.LastName)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.LastName (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:LastName: ", p), err) }
  return err
}

func (p *HCECard) writeField3(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("ExpMonth", thrift.I32, 3); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:ExpMonth: ", p), err) }
  if err := oprot.WriteI32(int32(p.ExpMonth)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.ExpMonth (3) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 3:ExpMonth: ", p), err) }
  return err
}

func (p *HCECard) writeField4(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("ExpYear", thrift.I32, 4); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:ExpYear: ", p), err) }
  if err := oprot.WriteI32(int32(p.ExpYear)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.ExpYear (4) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 4:ExpYear: ", p), err) }
  return err
}

func (p *HCECard) writeField5(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("CardNumber", thrift.STRING, 5); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 5:CardNumber: ", p), err) }
  if err := oprot.WriteString(string(p.CardNumber)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.CardNumber (5) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 5:CardNumber: ", p), err) }
  return err
}

func (p *HCECard) writeField6(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("Type", thrift.STRING, 6); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 6:Type: ", p), err) }
  if err := oprot.WriteString(string(p.Type)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.Type (6) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 6:Type: ", p), err) }
  return err
}

func (p *HCECard) writeField7(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("Cvc", thrift.STRING, 7); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 7:Cvc: ", p), err) }
  if err := oprot.WriteString(string(p.Cvc)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.Cvc (7) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 7:Cvc: ", p), err) }
  return err
}

func (p *HCECard) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("HCECard(%+v)", *p)
}

// Attributes:
//  - UID
//  - Name
//  - Description
//  - Services
//  - Ipv4Address
//  - CurrencyCode
type Device struct {
  UID string `thrift:"uid,1" db:"uid" json:"uid"`
  Name string `thrift:"name,2" db:"name" json:"name"`
  Description string `thrift:"description,3" db:"description" json:"description"`
  Services map[int32]*Service `thrift:"services,4" db:"services" json:"services"`
  Ipv4Address string `thrift:"ipv4Address,5" db:"ipv4Address" json:"ipv4Address"`
  CurrencyCode string `thrift:"currencyCode,6" db:"currencyCode" json:"currencyCode"`
}

func NewDevice() *Device {
  return &Device{}
}

func (p *Device) GetUID() string {
  return p.UID
}

func (p *Device) GetName() string {
  return p.Name
}

func (p *Device) GetDescription() string {
  return p.Description
}

func (p *Device) GetServices() map[int32]*Service {
  return p.Services
}

func (p *Device) GetIpv4Address() string {
  return p.Ipv4Address
}

func (p *Device) GetCurrencyCode() string {
  return p.CurrencyCode
}
func (p *Device) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }

  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if err := p.ReadField1(iprot); err != nil {
        return err
      }
    case 2:
      if err := p.ReadField2(iprot); err != nil {
        return err
      }
    case 3:
      if err := p.ReadField3(iprot); err != nil {
        return err
      }
    case 4:
      if err := p.ReadField4(iprot); err != nil {
        return err
      }
    case 5:
      if err := p.ReadField5(iprot); err != nil {
        return err
      }
    case 6:
      if err := p.ReadField6(iprot); err != nil {
        return err
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *Device)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.UID = v
}
  return nil
}

func (p *Device)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.Name = v
}
  return nil
}

func (p *Device)  ReadField3(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.Description = v
}
  return nil
}

func (p *Device)  ReadField4(iprot thrift.TProtocol) error {
  _, _, size, err := iprot.ReadMapBegin()
  if err != nil {
    return thrift.PrependError("error reading map begin: ", err)
  }
  tMap := make(map[int32]*Service, size)
  p.Services =  tMap
  for i := 0; i < size; i ++ {
var _key2 int32
    if v, err := iprot.ReadI32(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    _key2 = v
}
    _val3 := &Service{}
    if err := _val3.Read(iprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _val3), err)
    }
    p.Services[_key2] = _val3
  }
  if err := iprot.ReadMapEnd(); err != nil {
    return thrift.PrependError("error reading map end: ", err)
  }
  return nil
}

func (p *Device)  ReadField5(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 5: ", err)
} else {
  p.Ipv4Address = v
}
  return nil
}

func (p *Device)  ReadField6(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 6: ", err)
} else {
  p.CurrencyCode = v
}
  return nil
}

func (p *Device) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("Device"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
    if err := p.writeField3(oprot); err != nil { return err }
    if err := p.writeField4(oprot); err != nil { return err }
    if err := p.writeField5(oprot); err != nil { return err }
    if err := p.writeField6(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *Device) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("uid", thrift.STRING, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:uid: ", p), err) }
  if err := oprot.WriteString(string(p.UID)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.uid (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:uid: ", p), err) }
  return err
}

func (p *Device) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("name", thrift.STRING, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:name: ", p), err) }
  if err := oprot.WriteString(string(p.Name)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.name (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:name: ", p), err) }
  return err
}

func (p *Device) writeField3(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("description", thrift.STRING, 3); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:description: ", p), err) }
  if err := oprot.WriteString(string(p.Description)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.description (3) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 3:description: ", p), err) }
  return err
}

func (p *Device) writeField4(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("services", thrift.MAP, 4); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:services: ", p), err) }
  if err := oprot.WriteMapBegin(thrift.I32, thrift.STRUCT, len(p.Services)); err != nil {
    return thrift.PrependError("error writing map begin: ", err)
  }
  for k, v := range p.Services {
    if err := oprot.WriteI32(int32(k)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
    if err := v.Write(oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
    }
  }
  if err := oprot.WriteMapEnd(); err != nil {
    return thrift.PrependError("error writing map end: ", err)
  }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 4:services: ", p), err) }
  return err
}

func (p *Device) writeField5(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("ipv4Address", thrift.STRING, 5); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 5:ipv4Address: ", p), err) }
  if err := oprot.WriteString(string(p.Ipv4Address)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.ipv4Address (5) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 5:ipv4Address: ", p), err) }
  return err
}

func (p *Device) writeField6(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("currencyCode", thrift.STRING, 6); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 6:currencyCode: ", p), err) }
  if err := oprot.WriteString(string(p.CurrencyCode)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.currencyCode (6) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 6:currencyCode: ", p), err) }
  return err
}

func (p *Device) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("Device(%+v)", *p)
}

// Attributes:
//  - DeviceDescription
//  - Hostname
//  - PortNumber
//  - ServerId
//  - UrlPrefix
//  - Scheme
type ServiceMessage struct {
  DeviceDescription string `thrift:"deviceDescription,1" db:"deviceDescription" json:"deviceDescription"`
  Hostname string `thrift:"hostname,2" db:"hostname" json:"hostname"`
  PortNumber int32 `thrift:"portNumber,3" db:"portNumber" json:"portNumber"`
  ServerId string `thrift:"serverId,4" db:"serverId" json:"serverId"`
  UrlPrefix string `thrift:"urlPrefix,5" db:"urlPrefix" json:"urlPrefix"`
  Scheme string `thrift:"scheme,6" db:"scheme" json:"scheme"`
}

func NewServiceMessage() *ServiceMessage {
  return &ServiceMessage{}
}

func (p *ServiceMessage) GetDeviceDescription() string {
  return p.DeviceDescription
}

func (p *ServiceMessage) GetHostname() string {
  return p.Hostname
}

func (p *ServiceMessage) GetPortNumber() int32 {
  return p.PortNumber
}

func (p *ServiceMessage) GetServerId() string {
  return p.ServerId
}

func (p *ServiceMessage) GetUrlPrefix() string {
  return p.UrlPrefix
}

func (p *ServiceMessage) GetScheme() string {
  return p.Scheme
}
func (p *ServiceMessage) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }

  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if err := p.ReadField1(iprot); err != nil {
        return err
      }
    case 2:
      if err := p.ReadField2(iprot); err != nil {
        return err
      }
    case 3:
      if err := p.ReadField3(iprot); err != nil {
        return err
      }
    case 4:
      if err := p.ReadField4(iprot); err != nil {
        return err
      }
    case 5:
      if err := p.ReadField5(iprot); err != nil {
        return err
      }
    case 6:
      if err := p.ReadField6(iprot); err != nil {
        return err
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ServiceMessage)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.DeviceDescription = v
}
  return nil
}

func (p *ServiceMessage)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.Hostname = v
}
  return nil
}

func (p *ServiceMessage)  ReadField3(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.PortNumber = v
}
  return nil
}

func (p *ServiceMessage)  ReadField4(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 4: ", err)
} else {
  p.ServerId = v
}
  return nil
}

func (p *ServiceMessage)  ReadField5(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 5: ", err)
} else {
  p.UrlPrefix = v
}
  return nil
}

func (p *ServiceMessage)  ReadField6(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 6: ", err)
} else {
  p.Scheme = v
}
  return nil
}

func (p *ServiceMessage) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("ServiceMessage"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
    if err := p.writeField3(oprot); err != nil { return err }
    if err := p.writeField4(oprot); err != nil { return err }
    if err := p.writeField5(oprot); err != nil { return err }
    if err := p.writeField6(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ServiceMessage) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("deviceDescription", thrift.STRING, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:deviceDescription: ", p), err) }
  if err := oprot.WriteString(string(p.DeviceDescription)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.deviceDescription (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:deviceDescription: ", p), err) }
  return err
}

func (p *ServiceMessage) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("hostname", thrift.STRING, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:hostname: ", p), err) }
  if err := oprot.WriteString(string(p.Hostname)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.hostname (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:hostname: ", p), err) }
  return err
}

func (p *ServiceMessage) writeField3(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("portNumber", thrift.I32, 3); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:portNumber: ", p), err) }
  if err := oprot.WriteI32(int32(p.PortNumber)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.portNumber (3) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 3:portNumber: ", p), err) }
  return err
}

func (p *ServiceMessage) writeField4(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("serverId", thrift.STRING, 4); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:serverId: ", p), err) }
  if err := oprot.WriteString(string(p.ServerId)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.serverId (4) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 4:serverId: ", p), err) }
  return err
}

func (p *ServiceMessage) writeField5(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("urlPrefix", thrift.STRING, 5); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 5:urlPrefix: ", p), err) }
  if err := oprot.WriteString(string(p.UrlPrefix)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.urlPrefix (5) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 5:urlPrefix: ", p), err) }
  return err
}

func (p *ServiceMessage) writeField6(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("scheme", thrift.STRING, 6); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 6:scheme: ", p), err) }
  if err := oprot.WriteString(string(p.Scheme)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.scheme (6) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 6:scheme: ", p), err) }
  return err
}

func (p *ServiceMessage) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ServiceMessage(%+v)", *p)
}

// Attributes:
//  - ServiceId
//  - ServiceDescription
type ServiceDetails struct {
  ServiceId int32 `thrift:"serviceId,1" db:"serviceId" json:"serviceId"`
  ServiceDescription string `thrift:"serviceDescription,2" db:"serviceDescription" json:"serviceDescription"`
}

func NewServiceDetails() *ServiceDetails {
  return &ServiceDetails{}
}

func (p *ServiceDetails) GetServiceId() int32 {
  return p.ServiceId
}

func (p *ServiceDetails) GetServiceDescription() string {
  return p.ServiceDescription
}
func (p *ServiceDetails) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }

  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if err := p.ReadField1(iprot); err != nil {
        return err
      }
    case 2:
      if err := p.ReadField2(iprot); err != nil {
        return err
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ServiceDetails)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.ServiceId = v
}
  return nil
}

func (p *ServiceDetails)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.ServiceDescription = v
}
  return nil
}

func (p *ServiceDetails) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("ServiceDetails"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ServiceDetails) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("serviceId", thrift.I32, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:serviceId: ", p), err) }
  if err := oprot.WriteI32(int32(p.ServiceId)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.serviceId (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:serviceId: ", p), err) }
  return err
}

func (p *ServiceDetails) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("serviceDescription", thrift.STRING, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:serviceDescription: ", p), err) }
  if err := oprot.WriteString(string(p.ServiceDescription)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.serviceDescription (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:serviceDescription: ", p), err) }
  return err
}

func (p *ServiceDetails) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ServiceDetails(%+v)", *p)
}

// Attributes:
//  - ServerId
//  - ClientId
//  - PriceId
//  - UnitsToSupply
//  - TotalPrice
//  - PaymentReferenceId
//  - MerchantClientKey
//  - CurrencyCode
type TotalPriceResponse struct {
  ServerId string `thrift:"serverId,1" db:"serverId" json:"serverId"`
  ClientId string `thrift:"clientId,2" db:"clientId" json:"clientId"`
  PriceId int32 `thrift:"priceId,3" db:"priceId" json:"priceId"`
  UnitsToSupply int32 `thrift:"unitsToSupply,4" db:"unitsToSupply" json:"unitsToSupply"`
  TotalPrice int32 `thrift:"totalPrice,5" db:"totalPrice" json:"totalPrice"`
  PaymentReferenceId string `thrift:"paymentReferenceId,6" db:"paymentReferenceId" json:"paymentReferenceId"`
  MerchantClientKey string `thrift:"merchantClientKey,7" db:"merchantClientKey" json:"merchantClientKey"`
  CurrencyCode string `thrift:"currencyCode,8" db:"currencyCode" json:"currencyCode"`
}

func NewTotalPriceResponse() *TotalPriceResponse {
  return &TotalPriceResponse{}
}

func (p *TotalPriceResponse) GetServerId() string {
  return p.ServerId
}

func (p *TotalPriceResponse) GetClientId() string {
  return p.ClientId
}

func (p *TotalPriceResponse) GetPriceId() int32 {
  return p.PriceId
}

func (p *TotalPriceResponse) GetUnitsToSupply() int32 {
  return p.UnitsToSupply
}

func (p *TotalPriceResponse) GetTotalPrice() int32 {
  return p.TotalPrice
}

func (p *TotalPriceResponse) GetPaymentReferenceId() string {
  return p.PaymentReferenceId
}

func (p *TotalPriceResponse) GetMerchantClientKey() string {
  return p.MerchantClientKey
}

func (p *TotalPriceResponse) GetCurrencyCode() string {
  return p.CurrencyCode
}
func (p *TotalPriceResponse) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }

  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if err := p.ReadField1(iprot); err != nil {
        return err
      }
    case 2:
      if err := p.ReadField2(iprot); err != nil {
        return err
      }
    case 3:
      if err := p.ReadField3(iprot); err != nil {
        return err
      }
    case 4:
      if err := p.ReadField4(iprot); err != nil {
        return err
      }
    case 5:
      if err := p.ReadField5(iprot); err != nil {
        return err
      }
    case 6:
      if err := p.ReadField6(iprot); err != nil {
        return err
      }
    case 7:
      if err := p.ReadField7(iprot); err != nil {
        return err
      }
    case 8:
      if err := p.ReadField8(iprot); err != nil {
        return err
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *TotalPriceResponse)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.ServerId = v
}
  return nil
}

func (p *TotalPriceResponse)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.ClientId = v
}
  return nil
}

func (p *TotalPriceResponse)  ReadField3(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.PriceId = v
}
  return nil
}

func (p *TotalPriceResponse)  ReadField4(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 4: ", err)
} else {
  p.UnitsToSupply = v
}
  return nil
}

func (p *TotalPriceResponse)  ReadField5(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 5: ", err)
} else {
  p.TotalPrice = v
}
  return nil
}

func (p *TotalPriceResponse)  ReadField6(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 6: ", err)
} else {
  p.PaymentReferenceId = v
}
  return nil
}

func (p *TotalPriceResponse)  ReadField7(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 7: ", err)
} else {
  p.MerchantClientKey = v
}
  return nil
}

func (p *TotalPriceResponse)  ReadField8(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 8: ", err)
} else {
  p.CurrencyCode = v
}
  return nil
}

func (p *TotalPriceResponse) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("TotalPriceResponse"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
    if err := p.writeField3(oprot); err != nil { return err }
    if err := p.writeField4(oprot); err != nil { return err }
    if err := p.writeField5(oprot); err != nil { return err }
    if err := p.writeField6(oprot); err != nil { return err }
    if err := p.writeField7(oprot); err != nil { return err }
    if err := p.writeField8(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *TotalPriceResponse) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("serverId", thrift.STRING, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:serverId: ", p), err) }
  if err := oprot.WriteString(string(p.ServerId)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.serverId (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:serverId: ", p), err) }
  return err
}

func (p *TotalPriceResponse) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("clientId", thrift.STRING, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:clientId: ", p), err) }
  if err := oprot.WriteString(string(p.ClientId)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.clientId (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:clientId: ", p), err) }
  return err
}

func (p *TotalPriceResponse) writeField3(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("priceId", thrift.I32, 3); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:priceId: ", p), err) }
  if err := oprot.WriteI32(int32(p.PriceId)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.priceId (3) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 3:priceId: ", p), err) }
  return err
}

func (p *TotalPriceResponse) writeField4(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("unitsToSupply", thrift.I32, 4); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:unitsToSupply: ", p), err) }
  if err := oprot.WriteI32(int32(p.UnitsToSupply)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.unitsToSupply (4) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 4:unitsToSupply: ", p), err) }
  return err
}

func (p *TotalPriceResponse) writeField5(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("totalPrice", thrift.I32, 5); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 5:totalPrice: ", p), err) }
  if err := oprot.WriteI32(int32(p.TotalPrice)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.totalPrice (5) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 5:totalPrice: ", p), err) }
  return err
}

func (p *TotalPriceResponse) writeField6(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("paymentReferenceId", thrift.STRING, 6); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 6:paymentReferenceId: ", p), err) }
  if err := oprot.WriteString(string(p.PaymentReferenceId)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.paymentReferenceId (6) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 6:paymentReferenceId: ", p), err) }
  return err
}

func (p *TotalPriceResponse) writeField7(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("merchantClientKey", thrift.STRING, 7); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 7:merchantClientKey: ", p), err) }
  if err := oprot.WriteString(string(p.MerchantClientKey)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.merchantClientKey (7) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 7:merchantClientKey: ", p), err) }
  return err
}

func (p *TotalPriceResponse) writeField8(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("currencyCode", thrift.STRING, 8); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 8:currencyCode: ", p), err) }
  if err := oprot.WriteString(string(p.CurrencyCode)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.currencyCode (8) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 8:currencyCode: ", p), err) }
  return err
}

func (p *TotalPriceResponse) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("TotalPriceResponse(%+v)", *p)
}

// Attributes:
//  - ServerId
//  - ClientId
//  - TotalPaid
//  - ServiceDeliveryToken
type PaymentResponse struct {
  ServerId string `thrift:"serverId,1" db:"serverId" json:"serverId"`
  ClientId string `thrift:"clientId,2" db:"clientId" json:"clientId"`
  TotalPaid int32 `thrift:"totalPaid,3" db:"totalPaid" json:"totalPaid"`
  ServiceDeliveryToken *ServiceDeliveryToken `thrift:"serviceDeliveryToken,4" db:"serviceDeliveryToken" json:"serviceDeliveryToken"`
}

func NewPaymentResponse() *PaymentResponse {
  return &PaymentResponse{}
}

func (p *PaymentResponse) GetServerId() string {
  return p.ServerId
}

func (p *PaymentResponse) GetClientId() string {
  return p.ClientId
}

func (p *PaymentResponse) GetTotalPaid() int32 {
  return p.TotalPaid
}
var PaymentResponse_ServiceDeliveryToken_DEFAULT *ServiceDeliveryToken
func (p *PaymentResponse) GetServiceDeliveryToken() *ServiceDeliveryToken {
  if !p.IsSetServiceDeliveryToken() {
    return PaymentResponse_ServiceDeliveryToken_DEFAULT
  }
return p.ServiceDeliveryToken
}
func (p *PaymentResponse) IsSetServiceDeliveryToken() bool {
  return p.ServiceDeliveryToken != nil
}

func (p *PaymentResponse) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }

  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if err := p.ReadField1(iprot); err != nil {
        return err
      }
    case 2:
      if err := p.ReadField2(iprot); err != nil {
        return err
      }
    case 3:
      if err := p.ReadField3(iprot); err != nil {
        return err
      }
    case 4:
      if err := p.ReadField4(iprot); err != nil {
        return err
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *PaymentResponse)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.ServerId = v
}
  return nil
}

func (p *PaymentResponse)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.ClientId = v
}
  return nil
}

func (p *PaymentResponse)  ReadField3(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.TotalPaid = v
}
  return nil
}

func (p *PaymentResponse)  ReadField4(iprot thrift.TProtocol) error {
  p.ServiceDeliveryToken = &ServiceDeliveryToken{}
  if err := p.ServiceDeliveryToken.Read(iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.ServiceDeliveryToken), err)
  }
  return nil
}

func (p *PaymentResponse) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("PaymentResponse"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
    if err := p.writeField3(oprot); err != nil { return err }
    if err := p.writeField4(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *PaymentResponse) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("serverId", thrift.STRING, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:serverId: ", p), err) }
  if err := oprot.WriteString(string(p.ServerId)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.serverId (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:serverId: ", p), err) }
  return err
}

func (p *PaymentResponse) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("clientId", thrift.STRING, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:clientId: ", p), err) }
  if err := oprot.WriteString(string(p.ClientId)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.clientId (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:clientId: ", p), err) }
  return err
}

func (p *PaymentResponse) writeField3(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("totalPaid", thrift.I32, 3); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:totalPaid: ", p), err) }
  if err := oprot.WriteI32(int32(p.TotalPaid)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.totalPaid (3) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 3:totalPaid: ", p), err) }
  return err
}

func (p *PaymentResponse) writeField4(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("serviceDeliveryToken", thrift.STRUCT, 4); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:serviceDeliveryToken: ", p), err) }
  if err := p.ServiceDeliveryToken.Write(oprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.ServiceDeliveryToken), err)
  }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 4:serviceDeliveryToken: ", p), err) }
  return err
}

func (p *PaymentResponse) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("PaymentResponse(%+v)", *p)
}

// Attributes:
//  - Key
//  - Issued
//  - Expiry
//  - RefundOnExpiry
//  - Signature
type ServiceDeliveryToken struct {
  Key string `thrift:"key,1" db:"key" json:"key"`
  Issued string `thrift:"issued,2" db:"issued" json:"issued"`
  Expiry string `thrift:"expiry,3" db:"expiry" json:"expiry"`
  RefundOnExpiry bool `thrift:"refundOnExpiry,4" db:"refundOnExpiry" json:"refundOnExpiry"`
  Signature []byte `thrift:"signature,5" db:"signature" json:"signature"`
}

func NewServiceDeliveryToken() *ServiceDeliveryToken {
  return &ServiceDeliveryToken{}
}

func (p *ServiceDeliveryToken) GetKey() string {
  return p.Key
}

func (p *ServiceDeliveryToken) GetIssued() string {
  return p.Issued
}

func (p *ServiceDeliveryToken) GetExpiry() string {
  return p.Expiry
}

func (p *ServiceDeliveryToken) GetRefundOnExpiry() bool {
  return p.RefundOnExpiry
}

func (p *ServiceDeliveryToken) GetSignature() []byte {
  return p.Signature
}
func (p *ServiceDeliveryToken) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }

  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if err := p.ReadField1(iprot); err != nil {
        return err
      }
    case 2:
      if err := p.ReadField2(iprot); err != nil {
        return err
      }
    case 3:
      if err := p.ReadField3(iprot); err != nil {
        return err
      }
    case 4:
      if err := p.ReadField4(iprot); err != nil {
        return err
      }
    case 5:
      if err := p.ReadField5(iprot); err != nil {
        return err
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *ServiceDeliveryToken)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.Key = v
}
  return nil
}

func (p *ServiceDeliveryToken)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.Issued = v
}
  return nil
}

func (p *ServiceDeliveryToken)  ReadField3(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.Expiry = v
}
  return nil
}

func (p *ServiceDeliveryToken)  ReadField4(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadBool(); err != nil {
  return thrift.PrependError("error reading field 4: ", err)
} else {
  p.RefundOnExpiry = v
}
  return nil
}

func (p *ServiceDeliveryToken)  ReadField5(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadBinary(); err != nil {
  return thrift.PrependError("error reading field 5: ", err)
} else {
  p.Signature = v
}
  return nil
}

func (p *ServiceDeliveryToken) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("ServiceDeliveryToken"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
    if err := p.writeField3(oprot); err != nil { return err }
    if err := p.writeField4(oprot); err != nil { return err }
    if err := p.writeField5(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *ServiceDeliveryToken) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("key", thrift.STRING, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:key: ", p), err) }
  if err := oprot.WriteString(string(p.Key)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.key (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:key: ", p), err) }
  return err
}

func (p *ServiceDeliveryToken) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("issued", thrift.STRING, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:issued: ", p), err) }
  if err := oprot.WriteString(string(p.Issued)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.issued (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:issued: ", p), err) }
  return err
}

func (p *ServiceDeliveryToken) writeField3(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("expiry", thrift.STRING, 3); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:expiry: ", p), err) }
  if err := oprot.WriteString(string(p.Expiry)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.expiry (3) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 3:expiry: ", p), err) }
  return err
}

func (p *ServiceDeliveryToken) writeField4(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("refundOnExpiry", thrift.BOOL, 4); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:refundOnExpiry: ", p), err) }
  if err := oprot.WriteBool(bool(p.RefundOnExpiry)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.refundOnExpiry (4) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 4:refundOnExpiry: ", p), err) }
  return err
}

func (p *ServiceDeliveryToken) writeField5(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("signature", thrift.STRING, 5); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 5:signature: ", p), err) }
  if err := oprot.WriteBinary(p.Signature); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.signature (5) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 5:signature: ", p), err) }
  return err
}

func (p *ServiceDeliveryToken) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("ServiceDeliveryToken(%+v)", *p)
}

redpajama_set_name: RedPajamaGithub


The definition of multicultural; welcoming Toronto is a microcosm of the world, a metropolis representing hundreds of nations. This cultural diversity translates to a foodie's fantasy. Cuisine from all over the world is represented: nosh on gnocchi in Little Italy, chow down in Chinatown, imbibe on local brews in the Distillery District, dine on delicious curries in Little India, or discover the international fares of lively Kensington and St. Lawrence markets, which serve as passports to your palate.
There's plenty of sightseeing to do throughout the year. Culture vultures can tour Toronto's many museums and galleries, like the impressive Royal Ontario Museum (ROM) and the Art Gallery of Ontario (AGO), as well as an eclectic mix of galleries scattered throughout the city. Toronto boasts the third largest theatre district in the English-speaking world, outside of London's West End and New York's Broadway. Toronto is a collage of colourful neighbourhoods worth exploring.
Toronto showcases many beautiful historic buildings amongst its modern skyscrapers. These create an impressive skyline over Lake Ontario, with the focal points being the CN Tower (which until recently was the world's tallest structure) and the domed Rogers Centre stadium. Ripley's Aquarium is situated at the base of the tower, home to an impressive collection of aquatic life in state-of-the-art surroundings. The Ontario Science Centre, Casa Loma and Black Creek Pioneer Village are also family-oriented attractions.
About an hour and a half drive outside the city are the famous Niagara Falls and scenic Niagara-on-the-Lake wine region. Head a few hours north and you're in beautiful cottage country, which offers a plethora of activities year round swimming and boating in crystal lakes, or snowshoeing, skiing and ice fishing in winter, to name a few.
The best time to visit Toronto is May to October. Springtime can be chilly but flowers are blooming, the humid heat has yet to arrive and tourist crowds are at bay. Autumn boasts beautiful fall colours, a dazzling display that starts in September. Toronto winters can be frigid, so summertime is when Toronto really comes alive. Torontonians awake from hibernation to enjoy biking, patio hopping or enjoying the many peaceful parks.
If you can't fit an around the world airfare into your budget, a trip to Toronto will let you experience a variety of nations instead! Call us today to book your Toronto getaway, today.


text:
Madeline Ella Searl (born 10 February 1994) is an Australian soccer player, who played for Newcastle Jets in the Australian W-League.

Club career
Searl played for Lake Macquarie. She joined Newcastle Jets and helped at an NNSW school soccer gala together with Ben Kennedy, Ben Kantarovski, and Tara Andrews. In December 2013, Searl suffered an anterior cruciate ligament injury, which followed previous problems of chronic fatigue, two broken ankles and a hamstring injury.

International career
In November 2008, Searl was called up to Australia's U-16 national team for the 2009 AFC U-16 Women's Championship qualification tournament. She scored twice in the campaign, once in a 17–0 victory over Singapore and once in a 20–0 victory over Philippines. A year later, she was selected for the 23-person squad for the tournament itself.

References

External links
 Profile at Newcastle Jets (archived)

1994 births
Living people
Australian women's soccer players
Newcastle Jets FC (A-League Women) players
Women's association football midfielders

redpajama_set_name: RedPajamaWikipedia


text:
Q: Local persistent storage I have a meteor react app and I need a way to save some info locally which will also be persistent. For example, if a user save a json, I want to use that same json even if the app is closed and reopen later. I tried groundDb but it requires server side as well. I need this feature to enable each user to save info such as game level. It will be great if I can use it on the web as well and not just for native versions. Thanks!

A: localForage
One  option, which we use, is the npm package localforage which provides an asynchronous storage wrapper for localStorage and allows you to save data of any type. You can configure your store, and create multiple instances of local storage.

You can store any type in localForage; you aren't limited to strings like in localStorage.

Setting up localforage is similar to using localStorage except you have to use asynchronous calls:
Using Promises (Note you can use callbacks if you are not using the ES6 API)
Store your data
localforage
  .setItem(
    'state', data
  )
  .catch(console.error.bind(console))

Retrieve your data
localforage.getItem('state')
  .then(data => /* ... */ )
  .catch(console.error.bind(console))

Name your store
localforage.config({
  name: 'myStore'
})

You can read more about localForage here.

A: To join the pedants, here's the proper explanation:
You should first convert your object literal into JSON using the global JSON object and its stringify method:
let data = {a: 'some', b: 'data', c: null};
let json = JSON.stringify(data);
localStorage.setItem('data', json);

When you want to retrieve the data and use it in your application, you'll need to parse the JSON back into an object literal:
let json = localStorage.getItem('data');
let data = JSON.parse(json);

A: It should be easy. Stringify the Object to make it a string then you save it.  Follow this:
var dataToStore = JSON.stringify(data);
localStorage.setItem('someData', dataToStore);

A: You serialize the JSON when saving to localStorage:
var serializedData = JSON.stringify(data);
localStorage.setItem('dataKey', serializedData);

And deserialize it when retrieving from localStorage:
var serializedData = localStorage.getItem('dataKey');
var data = JSON.parse(serializedData);

A: yup it is quite easy. take the object you want and stringify it and then store in the local storage. JSON objects are string objects and not string per say. so when you store it to local storage it can not be stored as the object but the need to convert it to a json string.
to add : localStorage.setItem();
to retrieve : localStorage.getItem();
another good practice can be to, retrieve the data on log in, store it in an array and then store back into localstorage. so you wont have any junk data and its always up to date.
to clear : localStorage.clear(); Note: this will clear the entire localstorage.
also note that there is a size limit on the localstorage. most browsers allow 5-10 mb.
if you have large amounts of data you can also indexedDB. its fairly new but better for large amounts of data to be stored in the browser. for now i think only IE has a good implementation.

A: Use standard localStorage: https://developer.mozilla.org/en/docs/Web/API/Window/localStorage
localStorage.setItem('xyz', JSON.stringify(object));

const object = JSON.parse(localStorage.getItem('xyz'));

redpajama_set_name: RedPajamaStackExchange


text:
Kennedy Center Honors, 'Encanto' at the Hollywood Bowl, Steve Hartman's Kindness Tour, TCM's Window Warnings
Matt Roush December 28, 2022
George Clooney, Gladys Knight and U2 are among the recipients of this year's Kennedy Center Honors during a gala tribute. The voice cast of the Oscar-winning Encanto performs the score in concert at the Hollywood Bowl. CBS correspondent Steve Hartman shares stories about kindness in a prime-time special. Turner Classic Movies asks you to lower your shades for a series of thrillers about crimes seen through neighbors' windows.
Always one of the classiest events of any year, the annual salute to cultural icons brings together an eclectic roster of honorees: TV-to-movie superstar George Clooney, R&B icon Gladys Knight, Irish rockers U2, contemporary Christian pop singer-songwriter Amy Grant and Cuban-born composer-conductor Tania León. Highlights include Garth Brooks, Mickey Guyton, Ariana DeBose and Patti LaBelle teaming for "That's What Friends Are For" in the Knight tribute; Julia Roberts, Matt Damon, Richard Kind, Don Cheadle and George's broadcaster dad Nick Clooney participating in the Clooney segment, with Dianne Reeves performing; Eddie Vedder, Hozier + Jamala + Brandi Carlile playing U2 classics; Sheryl Crow, The Highwomen and Bebe & CeCe Winans and Michael W Smith singing Grant's praises; and Anna Deavere Smith leading the León salute.
Jesse Grant/Getty Images for Disney
Fans will definitely be talking about this live-to-film concert event, reuniting the voice cast of Disney's Oscar-winning 2021 animated musical, introduced by composer Lin-Manuel Miranda (Hamilton, In the Heights). Stephanie Beatriz leads the cast as Mirabel in a lavish event at the iconic venue, featuring an 80-person orchestra and 50 dancers.
Disney/Brian Roedel
Justin Bartha from the National Treasure movies drops in on the Young Adult spinoff as computer expert Riley Poole, attending the wake of former FBI agent Peter Sadusky (Harvey Keitel) only to get caught with treasure hunter Jess (Lisette Olivera) in a breathtaking trap.
This month's weekly spotlight on "Neighbors" takes a sinister turn with a night of movies in which people witness horrible acts (or think they do) from their windows. Alfred Hitchcock's 1954 classic leads the way, with James Stewart as an injured photographer spying on his courtyard through his rear window when he suspects a man (Raymond Burr) across the way has committed murder. Followed by 1949's The Window (10/9c), starring little Bobby Driscoll as a boy who can't get anyone to believe that he witnessed his neighbors killing a drunken sailor in their apartment. In 1973's lurid Night Watch (11:30/10:30c), Elizabeth Taylor has similar trouble convincing anyone that she saw a murder across the street. (There's a wicked twist to that one.) The lineup climaxes with Brian DePalma's Hitchcock-inspired Sisters (1:15 am/12:15c) from 1972.
Inside Wednesday TV:
The Gift: Kindness Goes Viral with Steve Hartman (10/9c, CBS): You'd better have tissues handy as you watch these heartwarming vignettes from veteran CBS raconteur Steve Hartman, who travels the country to find uplifting stories about everyday people performing extraordinary acts of goodwill. Among those profiled: an Ohio family who created a foundation to help children who are losing their sight to experience visual wonders, and an Iowa woman who started a program in which the sale of donated clothing can help finance families' adoption fees.
Hillsong: A Megachurch Exposed (8/7c, TLC): The Discovery+ docuseries makes its linear debut, exposing the Hillsong Church's history of alleged trauma, abuse, financial and labor exploitation. A new fourth hour, Hillsong: The Newest Revelations, airs Thursday at 10/9c.
The Control Room (streaming on BritBox): Iain De Caestecker (Marvel's Agents of S.H.I.E.L.D.) stars in a three-part thriller as an emergency-call handler for a Scottish ambulance service who may need to call 999 himself after taking a desperate call from a woman who seems to know him.
This In Your Inbox Every Day
Subscribe to our Matt's Worth Watching newsletter:
The Gift: Kindness Goes Viral with Steve Hartman

redpajama_set_name: RedPajamaCommonCrawl


The mountains are waiting for you! Book a convenient luxury hotel from the 5-star category on 5staraustria.com. Austria offers great hotels for your ski trip, winter holiday, or outdoor vacation. Enjoy the beautyful mountains, astonishing views, fresh air and real Austrian hospitality.
Situated at an altitude of 1800 meters above sea level and located only 70 meters away from the ski lift this hotel is a must go for every ski-fanatic.


text:
Home Biography Who is Lucy Kafanov? Age, Height, Net Worth [2022], Husband, Wiki
Who is Lucy Kafanov? Age, Height, Net Worth [2022], Husband, Wiki
Lucy Kafanov is a well-known Journalist and Reporter who is best known for her different news channels including TODAY Show, Nightly News, and MSNBC.
She's also working as a news correspondent for the CNN news channel and she mostly covers international news and stories.
In this article, I will share the complete information about Lucy Kafanov Biographies such as her age, height, net worth, wiki, husband, and many more.
1 Who is Lucy Kafanov?
1.1 Lucy Kafanov Age
1.2 Lucy Kafanov Height, Weight
4 Family & Relations
4.1 Personal Information
5 Lucy Kafanov Career
6 Lucy Kafanov Net Worth
7 Favorite Things
8 Less Known Facts
9.1 Q1. How old is Lucy Kafanov?
9.2 Q2. How tall is Lucy Kafanov?
9.3 Q3. What is Lucy Kafanov's net worth?
Who is Lucy Kafanov?
Lucy Kafanov is a famous Russian-American Journalist and Reporter. She is famous for her different news channels including TODAY Show, Nightly News, CNN, and MSNBC.
She was born on 8 August 1982 in Moscow, Russia but she moved and was raised in the United States.
Lucy Kafanov's age is 40 years old as of 2022.
She holds American Nationality and has Russian-American ethnicity. Also, Kafanov follows the Christian religion.
Speaking about her educational background and qualification then,
She has completed her graduation from George Washington University.
Currently, she working as a National Correspondent for CNN based in the Denver bureau and she mostly covers international news and stories.
She also has decent followers on her Twitter account and other social platforms.
Currently, She has more than 25K followers on her Twitter account and 4.7K followers on her Instagram.
Lucy Kafanov Age
According to her date of birth, She was born on 8 August 1982 in Moscow, Russia, and Lucy Kafanov age is 40 years old in 2022.
Lucy Kafanov Height, Weight
Lucy Kafanov's height is around 5 feet 6 inches (1.67 m) and her weight is around 60 Kg (132 lbs) approximately.
However, the information about her physic is not accurate and may be changed over time.
Full Name Lucy Kafanov
Nick Name Lucy
Profession/Famous as Journalist and Reporter
Date of Birth 8 August 1982
Birthplace Moscow, Russia
Hometown United States
School High School, United States
College/University George Washington University
Hobbies Reading, Travelling
Height (approx.) 5 Feet 7 Inches
In Meters – 1.70 m
Body Measurement (approx.) 32-24-35
Skin Complexion White
Ethnicity Russian-American
Family & Relations
Father Vasily Kafanov
Mother Eteri Lobzhanidze
Boyfriend Not Known
Husband Not Known
Lucy Kafanov was born in Moscow, Russia, and raised in the United States.
Her father is a painter named Vasily Kafanov and her mother is named Eteri Lobzhanidze.
Speaking about her relationship status then,
She hasn't disclosed any information about her relationship or married status.
So, We're assuming She is unmarried. Lucy Kafanov's husband is not confirmed yet soon will be updated.
Lucy Kafanov Career
As of 2022, She has more than 25K followers on her Twitter account, 4.7K followers on her Instagram, and 7.5K followers on her Facebook page.
She graduated Magna Cum Laude and Phi Beta Kappa from George Washington University. Lucy is fluent in Russian and this work takes her around the world.
Currently, Lucy Kafanov working as a National Correspondent for CNN based in the Denver bureau where she mostly covers international news and stories.
In 2016, She joined NBC News as a foreign correspondent which was based in London, reporting for different shows including TODAY Show, Nightly News, and MSNBC.
In the same year 2016, Lucy was awarded an International Reporting Project (IRP) fellowship grant for an in-depth investigative reporting project in Myanmar, Which focuses on human rights abuses faced by Burma's minority religious communities.
Also Read – Jamie Wax Bio: Age, CBS News, Net Worth, Family, Wiki & More
Lucy Kafanov Net Worth
The estimated Net Worth of Lucy Kafanov is more than $2.3M – $5M approximately.
She mostly earns from her reporting job.
As per a survey, An average news reporter can easily earn from $100K – $300K from their job career.
Besides her career job, She has also earned from advertisements and Sponsorships as she is a popular face and is frequently watched on Television.
Favorite Journalist Nick Schifrin
Favorite Singer Lauren Mia
Favorite Digital Artist Marco Zagara
Favorite Musical Brand Golf Clap
Favorite Artist Mo Ganji
Also Read – Bill Melugin Model, Age, Fox News, Married, Wife, Net Worth, Salary & More
She travels all around the world due to her reporting job.
She has no tattoos on her body.
She likes traveling.
She's probably a non-vegetarian.
Q1. How old is Lucy Kafanov?
Ans:- Lucy was 39 years old in 2022, according to her date of birth 8 August 1982.
Q2. How tall is Lucy Kafanov?
Ans:- Lucy is 5 feet 7 inches (1.70 m) tall.
Q3. What is Lucy Kafanov's net worth?
Ans:- The estimated Net Worth of Lucy Kafanov is more than $2.3M – $5M approximately.
Tagged Inbiography Journalist News Anchor News Reporter
Top 10 Centers In The NBA Ranking of All Time
Gillian Turner Bio: Age, Height, Salary, Net Worth, Family, Wiki & More
Tyga Net Worth, Age, Height, Family, Wife, Biography, and More
Biography Singer
Tanner Fox Bio: Age, Height, Net Worth, Girlfriend, Wiki & Secret facts
Biography Internet Celebrity Youtuber
Lyna Perez Biography: Age, Height Net Worth, Wiki & Secret facts
Biography Model
Mark Anastasio Bio: Age, Height, Net Worth, Family, Wiki & Secret facts
Biography Social Media Influencer TikTok Star
Lyndsay Keith Bio: Age, Height, Net Worth, Salary, Wiki & More
Kendall Rae Bio: Net Worth 2022, Age, YouTube, Husband, Wiki & More
Biography Social Media Influencer Youtuber


To create a new context, call the function mmr_context_create(), passing the mm-renderer connection handle. The creation operation returns a context handle, which you use to manipulate the context, for example by attaching inputs and outputs, and issuing playback commands. You can create as many contexts as you need to, as long as your application manages potentially conflicting playback situations.
When a context is no longer needed, you can destroy it by passing the context handle to the mmr_context_destroy() function.
Depending on mm-renderer's configuration, client applications may be allowed to obtain additional handles to existing contexts. These additional handles are called secondary context handles, whereas the context handle obtained from the mmr_context_create() function is called the primary context handle. In addition, mm-renderer's configuration may allow a context to exist after its primary handle has been closed. This is called an orphan context. When orphan contexts are allowed, secondary handles are also allowed. Secondary handles may be allowed when orphan contexts aren't.


The studio of Joyce Bezusko is found on the shores of Vancouver Island, B.C. where her passion is fuelled by the ever-changing ocean, calming breezes, majestic mountains and lush greenery. It is there she creates her one-of-a-kind cuff bracelets, pendants, belt buckles, necklaces, statement earrings and wall pieces. Each piece is designed with that special individual in mind. Edgy, elegant, whimsical and over the top are specialties of Joyce's art form while enjoying the challenge of originality and custom creations in which she has been involved in the most interesting commission works. With a deep appreciation for retro and love affair with the "Old Hollywood" romance of vintage style & design, she is able to craft a unique and captivating blend of modern nostalgia.
Her work begins with collections of primary existing materials, from metals & chains to vintage & retro jewellery, even leather, searching the globe for objects with a certain flare, texture and flow.
She creates a vision which highlights and enhances the focal point. Line form and balance become the direction of her work, all the while creating a new life for these "past treasures." Once her composition has been slowly and methodically assembled, the process begins, involving drilling, grinding, resurfacing & wiring depending on the result she wishes to achieve.
Remembering that Joyce is an asymmetrical artist, she never really strives for an exact representation, but rather allows the viewer to fill in the blanks. By utilizing these former materials, she maintains her respect for lowering her carbon footprint, proving beautiful works of art and nature can co-exist.


text:
Salvaged artifacts auction in NYC includes staircase railings from Paris department store
Ula Ilnytzky, The Associated Press March 13, 2015
NEW YORK, N.Y. – Collectors, designers and developers looking for their next statement piece will get a chance to find one at a large auction of salvaged historical artifacts.
Urban Archaeology, a former salvage company that years ago switched to manufacturing tile, lighting and bathroom accessories based on iconic designs, is auctioning off approximately 6,000 artifacts March 27-28.
Walking into the company's factory in lower Manhattan is akin to walking inside a time capsule.
Decorative and architectural objects, from complete staircase railings that once adorned an Art Deco Paris mecca to wrought-iron gates from St. Patrick's Cathedral, crowd the vast ground floor of the six-story Tribeca building.
"I really think the world should see some of it. The things should be in public spaces," said company founder Gil Shapiro, who has collected artifacts from such institutions as the old hotel Astor, The Plaza and Yale University Library. His salvage collecting bug began as a teenager. Now 70, Shapiro said he's consolidating his warehouse and factory into one building.
There's a story behind nearly every piece. Like the gargantuan chandelier with 24 hand-blown glass globes.
Shapiro acquired the fixture from a dealer in 1985 based on a Polaroid that gave no clue to its massive scale. Citicorp Center — now called Citigroup Center — had purchased it only to discover it would not fit.
"It's almost like 'Alice in Wonderland,'" added Shapiro. "It's about 10 feet in diameter and needs a 26-foot ceiling." The presale estimate is $60,000 to $80,000.
His clients have included Paul Simon, Billy Joel, Ralph Lauren, Martha Stewart and Richard Gere. Some previous artifacts have made their way to movie sets.
"Almost all of the props in 'The Money Pit' with Tom Hanks came from us," Shapiro said. "They rented five bathtubs and blew up one."
In the 1980s, Shapiro also bought nearly all the decorative elements of the Bon Marche department store in Paris — an Art Deco gem featuring designs by Edgar Brandt and Emile-Jacques Ruhlmann.
There are many stars in the sale, but the brass wrought-iron railings of the store's central staircase shine brightest. Comprised of 14 rails, two newel posts and two connectors, they're estimated to bring $80,000 to $120,000. If they don't meet the minimum reserve, the pieces will be sold separately.
And as if one staircase wasn't unusual enough, the auction includes the balustrades of another, sweeping double grand staircase that once adorned a Southampton mansion. They're the work of Samuel Yellin, an early 20th-century Philadelphia metalworker whose projects included the Federal Reserve Bank of New York and the Washington National Cathedral. The staircase's delicate curved wrought-iron railings feature whimsical flora and fauna designs. If sold complete, it could fetch up to $120,000.
Michael Devonshire, a conservator at JHPA Inc., an architectural firm specializing in historic preservation work, said potential buyers could include museums or someone interested in a unique conversation piece.
"There's the sadness that the artifacts aren't in the original buildings," he said. "But then there's a gratification knowing that these pieces are still alive and circulating so they could be enjoyed by more people."
Shapiro was in junior high when he bid $100 on the contents of an old-fashioned drug store complete with an ice cream parlour in his Brooklyn neighbourhood. His weekly allowance was $3 so he sold his brother's bedroom furniture to the building superintendent while his brother was at work. To pay for the delivery truck, he sold his family's living room furniture.
His parents sent him to a mental health professional — but he was hooked. In 1978, he opened Urban Archaeology.
Other important historical objects in the sale include the original cast-iron fountain statues of a merman and mermaid from the Place de la Concorde in Paris, which were replaced with replicas during an early 20th-century renovation. They're expected to bring up to $150,000 each; Shapiro hopes they will return to Paris.
Also significant are the 15-foot Baptistry Gates from St. Patrick's Cathedral designed by Kenneth Lynch, a metalsmith whose other work included the stainless-steel eagles crowning the Chrysler Building.
But not all the stuff in the sale is huge. There's an array of mid-century modern lamps, display cases and other furniture that once adorned hotels, department stores and transportation depots.
Guernsey's will run the 700-lot auction at the company's premises.
Online: http://www.guernseys.com/v2/uarchaeology.html