maeqtt/mqtt/GeneratedProperties.go

package mqtt

// This code has been generated with the genProps.py script. Do not modify

import "bufio"

type PayloadFormatIndicator struct {
	value *byte
}

func (p PayloadFormatIndicator) id() int {
	return 1
}

func (p *PayloadFormatIndicator) parse(r *bufio.Reader) error {
	val, err := r.ReadByte()
	if err != nil {
		return err
	}
	p.value = &val
	return nil
}

type MessageExpiryInterval struct {
	value *uint32
}

func (p MessageExpiryInterval) id() int {
	return 2
}

func (p *MessageExpiryInterval) parse(r *bufio.Reader) error {
	val, err := decodeUint32(r)
	if err != nil {
		return err
	}
	p.value = &val
	return nil
}

type ContentType struct {
	value *string
}

func (p ContentType) id() int {
	return 3
}

func (p *ContentType) parse(r *bufio.Reader) error {
	val, err := decodeUTF8String(r)
	if err != nil {
		return err
	}
	p.value = &val
	return nil
}

type ResponseTopic struct {
	value *string
}

func (p ResponseTopic) id() int {
	return 8
}

func (p *ResponseTopic) parse(r *bufio.Reader) error {
	val, err := decodeUTF8String(r)
	if err != nil {
		return err
	}
	p.value = &val
	return nil
}

type CorrelationData struct {
	value *[]byte
}

func (p CorrelationData) id() int {
	return 9
}

func (p *CorrelationData) parse(r *bufio.Reader) error {
	val, err := decodeBinaryData(r)
	if err != nil {
		return err
	}
	p.value = &val
	return nil
}

type SubscriptionIdentifier struct {
	value *int
}

func (p SubscriptionIdentifier) id() int {
	return 11
}

func (p *SubscriptionIdentifier) parse(r *bufio.Reader) error {
	val, err := decodeVariableByteInt(r)
	if err != nil {
		return err
	}
	p.value = &val
	return nil
}

type SessionExpiryInterval struct {
	value *uint32
}

func (p SessionExpiryInterval) id() int {
	return 17
}

func (p *SessionExpiryInterval) parse(r *bufio.Reader) error {
	val, err := decodeUint32(r)
	if err != nil {
		return err
	}
	p.value = &val
	return nil
}

type AssignedClientIdentifier struct {
	value *string
}

func (p AssignedClientIdentifier) id() int {
	return 18
}

func (p *AssignedClientIdentifier) parse(r *bufio.Reader) error {
	val, err := decodeUTF8String(r)
	if err != nil {
		return err
	}
	p.value = &val
	return nil
}

type ServerKeepAlive struct {
	value *uint16
}

func (p ServerKeepAlive) id() int {
	return 19
}

func (p *ServerKeepAlive) parse(r *bufio.Reader) error {
	val, err := decodeUint16(r)
	if err != nil {
		return err
	}
	p.value = &val
	return nil
}

type AuthenticationMethod struct {
	value *string
}

func (p AuthenticationMethod) id() int {
	return 21
}

func (p *AuthenticationMethod) parse(r *bufio.Reader) error {
	val, err := decodeUTF8String(r)
	if err != nil {
		return err
	}
	p.value = &val
	return nil
}

type AuthenticationData struct {
	value *[]byte
}

func (p AuthenticationData) id() int {
	return 22
}

func (p *AuthenticationData) parse(r *bufio.Reader) error {
	val, err := decodeBinaryData(r)
	if err != nil {
		return err
	}
	p.value = &val
	return nil
}

type RequestProblemInformation struct {
	value *byte
}

func (p RequestProblemInformation) id() int {
	return 23
}

func (p *RequestProblemInformation) parse(r *bufio.Reader) error {
	val, err := r.ReadByte()
	if err != nil {
		return err
	}
	p.value = &val
	return nil
}

type WillDelayInterval struct {
	value *uint32
}

func (p WillDelayInterval) id() int {
	return 24
}

func (p *WillDelayInterval) parse(r *bufio.Reader) error {
	val, err := decodeUint32(r)
	if err != nil {
		return err
	}
	p.value = &val
	return nil
}

type RequestResponseInformation struct {
	value *byte
}

func (p RequestResponseInformation) id() int {
	return 25
}

func (p *RequestResponseInformation) parse(r *bufio.Reader) error {
	val, err := r.ReadByte()
	if err != nil {
		return err
	}
	p.value = &val
	return nil
}

type ResponseInformation struct {
	value *string
}

func (p ResponseInformation) id() int {
	return 26
}

func (p *ResponseInformation) parse(r *bufio.Reader) error {
	val, err := decodeUTF8String(r)
	if err != nil {
		return err
	}
	p.value = &val
	return nil
}

type ServerReference struct {
	value *string
}

func (p ServerReference) id() int {
	return 28
}

func (p *ServerReference) parse(r *bufio.Reader) error {
	val, err := decodeUTF8String(r)
	if err != nil {
		return err
	}
	p.value = &val
	return nil
}

type ReasonString struct {
	value *string
}

func (p ReasonString) id() int {
	return 31
}

func (p *ReasonString) parse(r *bufio.Reader) error {
	val, err := decodeUTF8String(r)
	if err != nil {
		return err
	}
	p.value = &val
	return nil
}

type ReceiveMaximum struct {
	value *uint16
}

func (p ReceiveMaximum) id() int {
	return 33
}

func (p *ReceiveMaximum) parse(r *bufio.Reader) error {
	val, err := decodeUint16(r)
	if err != nil {
		return err
	}
	p.value = &val
	return nil
}

type TopicAliasMaximum struct {
	value *uint16
}

func (p TopicAliasMaximum) id() int {
	return 34
}

func (p *TopicAliasMaximum) parse(r *bufio.Reader) error {
	val, err := decodeUint16(r)
	if err != nil {
		return err
	}
	p.value = &val
	return nil
}

type TopicAlias struct {
	value *uint16
}

func (p TopicAlias) id() int {
	return 35
}

func (p *TopicAlias) parse(r *bufio.Reader) error {
	val, err := decodeUint16(r)
	if err != nil {
		return err
	}
	p.value = &val
	return nil
}

type MaximumQoS struct {
	value *byte
}

func (p MaximumQoS) id() int {
	return 36
}

func (p *MaximumQoS) parse(r *bufio.Reader) error {
	val, err := r.ReadByte()
	if err != nil {
		return err
	}
	p.value = &val
	return nil
}

type RetainAvailable struct {
	value *byte
}

func (p RetainAvailable) id() int {
	return 37
}

func (p *RetainAvailable) parse(r *bufio.Reader) error {
	val, err := r.ReadByte()
	if err != nil {
		return err
	}
	p.value = &val
	return nil
}

type MaximumPacketSize struct {
	value *uint32
}

func (p MaximumPacketSize) id() int {
	return 39
}

func (p *MaximumPacketSize) parse(r *bufio.Reader) error {
	val, err := decodeUint32(r)
	if err != nil {
		return err
	}
	p.value = &val
	return nil
}

type WildcardSubscriptionAvailable struct {
	value *byte
}

func (p WildcardSubscriptionAvailable) id() int {
	return 40
}

func (p *WildcardSubscriptionAvailable) parse(r *bufio.Reader) error {
	val, err := r.ReadByte()
	if err != nil {
		return err
	}
	p.value = &val
	return nil
}

type SubscriptionIdentifierAvailable struct {
	value *byte
}

func (p SubscriptionIdentifierAvailable) id() int {
	return 41
}

func (p *SubscriptionIdentifierAvailable) parse(r *bufio.Reader) error {
	val, err := r.ReadByte()
	if err != nil {
		return err
	}
	p.value = &val
	return nil
}

type SharedSubscriptionAvailable struct {
	value *byte
}

func (p SharedSubscriptionAvailable) id() int {
	return 42
}

func (p *SharedSubscriptionAvailable) parse(r *bufio.Reader) error {
	val, err := r.ReadByte()
	if err != nil {
		return err
	}
	p.value = &val
	return nil
}

type PublishPacketProperties struct {
	PayloadFormatIndicator PayloadFormatIndicator
	MessageExpiryInterval  MessageExpiryInterval
	ContentType            ContentType
	ResponseTopic          ResponseTopic
	CorrelationData        CorrelationData
	SubscriptionIdentifier SubscriptionIdentifier
	TopicAlias             TopicAlias
	UserProperty           UserProperty
}

func (p *PublishPacketProperties) arrayOf() []Property {
	return []Property{
		&p.PayloadFormatIndicator,
		&p.MessageExpiryInterval,
		&p.ContentType,
		&p.ResponseTopic,
		&p.CorrelationData,
		&p.SubscriptionIdentifier,
		&p.TopicAlias,
		&p.UserProperty,
	}
}

type WillProperties struct {
	PayloadFormatIndicator PayloadFormatIndicator
	MessageExpiryInterval  MessageExpiryInterval
	ContentType            ContentType
	ResponseTopic          ResponseTopic
	CorrelationData        CorrelationData
	WillDelayInterval      WillDelayInterval
	UserProperty           UserProperty
}

func (p *WillProperties) arrayOf() []Property {
	return []Property{
		&p.PayloadFormatIndicator,
		&p.MessageExpiryInterval,
		&p.ContentType,
		&p.ResponseTopic,
		&p.CorrelationData,
		&p.WillDelayInterval,
		&p.UserProperty,
	}
}

type SubscribePacketProperties struct {
	SubscriptionIdentifier SubscriptionIdentifier
	UserProperty           UserProperty
}

func (p *SubscribePacketProperties) arrayOf() []Property {
	return []Property{
		&p.SubscriptionIdentifier,
		&p.UserProperty,
	}
}

type ConnectPacketProperties struct {
	SessionExpiryInterval      SessionExpiryInterval
	AuthenticationMethod       AuthenticationMethod
	AuthenticationData         AuthenticationData
	RequestProblemInformation  RequestProblemInformation
	RequestResponseInformation RequestResponseInformation
	ReceiveMaximum             ReceiveMaximum
	TopicAliasMaximum          TopicAliasMaximum
	UserProperty               UserProperty
	MaximumPacketSize          MaximumPacketSize
}

func (p *ConnectPacketProperties) arrayOf() []Property {
	return []Property{
		&p.SessionExpiryInterval,
		&p.AuthenticationMethod,
		&p.AuthenticationData,
		&p.RequestProblemInformation,
		&p.RequestResponseInformation,
		&p.ReceiveMaximum,
		&p.TopicAliasMaximum,
		&p.UserProperty,
		&p.MaximumPacketSize,
	}
}

type ConnackPacketProperties struct {
	SessionExpiryInterval           SessionExpiryInterval
	AssignedClientIdentifier        AssignedClientIdentifier
	ServerKeepAlive                 ServerKeepAlive
	AuthenticationMethod            AuthenticationMethod
	AuthenticationData              AuthenticationData
	ResponseInformation             ResponseInformation
	ServerReference                 ServerReference
	ReasonString                    ReasonString
	ReceiveMaximum                  ReceiveMaximum
	TopicAliasMaximum               TopicAliasMaximum
	MaximumQoS                      MaximumQoS
	RetainAvailable                 RetainAvailable
	UserProperty                    UserProperty
	MaximumPacketSize               MaximumPacketSize
	WildcardSubscriptionAvailable   WildcardSubscriptionAvailable
	SubscriptionIdentifierAvailable SubscriptionIdentifierAvailable
	SharedSubscriptionAvailable     SharedSubscriptionAvailable
}

func (p *ConnackPacketProperties) arrayOf() []Property {
	return []Property{
		&p.SessionExpiryInterval,
		&p.AssignedClientIdentifier,
		&p.ServerKeepAlive,
		&p.AuthenticationMethod,
		&p.AuthenticationData,
		&p.ResponseInformation,
		&p.ServerReference,
		&p.ReasonString,
		&p.ReceiveMaximum,
		&p.TopicAliasMaximum,
		&p.MaximumQoS,
		&p.RetainAvailable,
		&p.UserProperty,
		&p.MaximumPacketSize,
		&p.WildcardSubscriptionAvailable,
		&p.SubscriptionIdentifierAvailable,
		&p.SharedSubscriptionAvailable,
	}
}

type DisconnectPacketProperties struct {
	SessionExpiryInterval SessionExpiryInterval
	ServerReference       ServerReference
	ReasonString          ReasonString
	UserProperty          UserProperty
}

func (p *DisconnectPacketProperties) arrayOf() []Property {
	return []Property{
		&p.SessionExpiryInterval,
		&p.ServerReference,
		&p.ReasonString,
		&p.UserProperty,
	}
}

type AuthPacketProperties struct {
	AuthenticationMethod AuthenticationMethod
	AuthenticationData   AuthenticationData
	ReasonString         ReasonString
	UserProperty         UserProperty
}

func (p *AuthPacketProperties) arrayOf() []Property {
	return []Property{
		&p.AuthenticationMethod,
		&p.AuthenticationData,
		&p.ReasonString,
		&p.UserProperty,
	}
}

type PubackPacketProperties struct {
	ReasonString ReasonString
	UserProperty UserProperty
}

func (p *PubackPacketProperties) arrayOf() []Property {
	return []Property{
		&p.ReasonString,
		&p.UserProperty,
	}
}

type PubrecPacketProperties struct {
	ReasonString ReasonString
	UserProperty UserProperty
}

func (p *PubrecPacketProperties) arrayOf() []Property {
	return []Property{
		&p.ReasonString,
		&p.UserProperty,
	}
}

type PubrelPacketProperties struct {
	ReasonString ReasonString
	UserProperty UserProperty
}

func (p *PubrelPacketProperties) arrayOf() []Property {
	return []Property{
		&p.ReasonString,
		&p.UserProperty,
	}
}

type PubcompPacketProperties struct {
	ReasonString ReasonString
	UserProperty UserProperty
}

func (p *PubcompPacketProperties) arrayOf() []Property {
	return []Property{
		&p.ReasonString,
		&p.UserProperty,
	}
}

type SubackPacketProperties struct {
	ReasonString ReasonString
	UserProperty UserProperty
}

func (p *SubackPacketProperties) arrayOf() []Property {
	return []Property{
		&p.ReasonString,
		&p.UserProperty,
	}
}

type UnsubackPacketProperties struct {
	ReasonString ReasonString
	UserProperty UserProperty
}

func (p *UnsubackPacketProperties) arrayOf() []Property {
	return []Property{
		&p.ReasonString,
		&p.UserProperty,
	}
}

type UnsubscribePacketProperties struct {
	UserProperty UserProperty
}

func (p *UnsubscribePacketProperties) arrayOf() []Property {
	return []Property{
		&p.UserProperty,
	}
}