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,
}
}