github.com/lirm/aeron-go@v0.0.0-20230415210743-920325491dc4/archive/codecs/MessageHeader.go (about)

     1  // Generated SBE (Simple Binary Encoding) message codec
     2  
     3  package codecs
     4  
     5  import (
     6  	"fmt"
     7  	"io"
     8  	"math"
     9  )
    10  
    11  type MessageHeader struct {
    12  	BlockLength uint16
    13  	TemplateId  uint16
    14  	SchemaId    uint16
    15  	Version     uint16
    16  }
    17  
    18  func (m *MessageHeader) Encode(_m *SbeGoMarshaller, _w io.Writer) error {
    19  	if err := _m.WriteUint16(_w, m.BlockLength); err != nil {
    20  		return err
    21  	}
    22  	if err := _m.WriteUint16(_w, m.TemplateId); err != nil {
    23  		return err
    24  	}
    25  	if err := _m.WriteUint16(_w, m.SchemaId); err != nil {
    26  		return err
    27  	}
    28  	if err := _m.WriteUint16(_w, m.Version); err != nil {
    29  		return err
    30  	}
    31  	return nil
    32  }
    33  
    34  func (m *MessageHeader) Decode(_m *SbeGoMarshaller, _r io.Reader, actingVersion uint16) error {
    35  	if !m.BlockLengthInActingVersion(actingVersion) {
    36  		m.BlockLength = m.BlockLengthNullValue()
    37  	} else {
    38  		if err := _m.ReadUint16(_r, &m.BlockLength); err != nil {
    39  			return err
    40  		}
    41  	}
    42  	if !m.TemplateIdInActingVersion(actingVersion) {
    43  		m.TemplateId = m.TemplateIdNullValue()
    44  	} else {
    45  		if err := _m.ReadUint16(_r, &m.TemplateId); err != nil {
    46  			return err
    47  		}
    48  	}
    49  	if !m.SchemaIdInActingVersion(actingVersion) {
    50  		m.SchemaId = m.SchemaIdNullValue()
    51  	} else {
    52  		if err := _m.ReadUint16(_r, &m.SchemaId); err != nil {
    53  			return err
    54  		}
    55  	}
    56  	if !m.VersionInActingVersion(actingVersion) {
    57  		m.Version = m.VersionNullValue()
    58  	} else {
    59  		if err := _m.ReadUint16(_r, &m.Version); err != nil {
    60  			return err
    61  		}
    62  	}
    63  	return nil
    64  }
    65  
    66  func (m *MessageHeader) RangeCheck(actingVersion uint16, schemaVersion uint16) error {
    67  	if m.BlockLengthInActingVersion(actingVersion) {
    68  		if m.BlockLength < m.BlockLengthMinValue() || m.BlockLength > m.BlockLengthMaxValue() {
    69  			return fmt.Errorf("Range check failed on m.BlockLength (%v < %v > %v)", m.BlockLengthMinValue(), m.BlockLength, m.BlockLengthMaxValue())
    70  		}
    71  	}
    72  	if m.TemplateIdInActingVersion(actingVersion) {
    73  		if m.TemplateId < m.TemplateIdMinValue() || m.TemplateId > m.TemplateIdMaxValue() {
    74  			return fmt.Errorf("Range check failed on m.TemplateId (%v < %v > %v)", m.TemplateIdMinValue(), m.TemplateId, m.TemplateIdMaxValue())
    75  		}
    76  	}
    77  	if m.SchemaIdInActingVersion(actingVersion) {
    78  		if m.SchemaId < m.SchemaIdMinValue() || m.SchemaId > m.SchemaIdMaxValue() {
    79  			return fmt.Errorf("Range check failed on m.SchemaId (%v < %v > %v)", m.SchemaIdMinValue(), m.SchemaId, m.SchemaIdMaxValue())
    80  		}
    81  	}
    82  	if m.VersionInActingVersion(actingVersion) {
    83  		if m.Version < m.VersionMinValue() || m.Version > m.VersionMaxValue() {
    84  			return fmt.Errorf("Range check failed on m.Version (%v < %v > %v)", m.VersionMinValue(), m.Version, m.VersionMaxValue())
    85  		}
    86  	}
    87  	return nil
    88  }
    89  
    90  func MessageHeaderInit(m *MessageHeader) {
    91  	return
    92  }
    93  
    94  func (*MessageHeader) EncodedLength() int64 {
    95  	return 8
    96  }
    97  
    98  func (*MessageHeader) BlockLengthMinValue() uint16 {
    99  	return 0
   100  }
   101  
   102  func (*MessageHeader) BlockLengthMaxValue() uint16 {
   103  	return math.MaxUint16 - 1
   104  }
   105  
   106  func (*MessageHeader) BlockLengthNullValue() uint16 {
   107  	return math.MaxUint16
   108  }
   109  
   110  func (*MessageHeader) BlockLengthSinceVersion() uint16 {
   111  	return 0
   112  }
   113  
   114  func (m *MessageHeader) BlockLengthInActingVersion(actingVersion uint16) bool {
   115  	return actingVersion >= m.BlockLengthSinceVersion()
   116  }
   117  
   118  func (*MessageHeader) BlockLengthDeprecated() uint16 {
   119  	return 0
   120  }
   121  
   122  func (*MessageHeader) TemplateIdMinValue() uint16 {
   123  	return 0
   124  }
   125  
   126  func (*MessageHeader) TemplateIdMaxValue() uint16 {
   127  	return math.MaxUint16 - 1
   128  }
   129  
   130  func (*MessageHeader) TemplateIdNullValue() uint16 {
   131  	return math.MaxUint16
   132  }
   133  
   134  func (*MessageHeader) TemplateIdSinceVersion() uint16 {
   135  	return 0
   136  }
   137  
   138  func (m *MessageHeader) TemplateIdInActingVersion(actingVersion uint16) bool {
   139  	return actingVersion >= m.TemplateIdSinceVersion()
   140  }
   141  
   142  func (*MessageHeader) TemplateIdDeprecated() uint16 {
   143  	return 0
   144  }
   145  
   146  func (*MessageHeader) SchemaIdMinValue() uint16 {
   147  	return 0
   148  }
   149  
   150  func (*MessageHeader) SchemaIdMaxValue() uint16 {
   151  	return math.MaxUint16 - 1
   152  }
   153  
   154  func (*MessageHeader) SchemaIdNullValue() uint16 {
   155  	return math.MaxUint16
   156  }
   157  
   158  func (*MessageHeader) SchemaIdSinceVersion() uint16 {
   159  	return 0
   160  }
   161  
   162  func (m *MessageHeader) SchemaIdInActingVersion(actingVersion uint16) bool {
   163  	return actingVersion >= m.SchemaIdSinceVersion()
   164  }
   165  
   166  func (*MessageHeader) SchemaIdDeprecated() uint16 {
   167  	return 0
   168  }
   169  
   170  func (*MessageHeader) VersionMinValue() uint16 {
   171  	return 0
   172  }
   173  
   174  func (*MessageHeader) VersionMaxValue() uint16 {
   175  	return math.MaxUint16 - 1
   176  }
   177  
   178  func (*MessageHeader) VersionNullValue() uint16 {
   179  	return math.MaxUint16
   180  }
   181  
   182  func (*MessageHeader) VersionSinceVersion() uint16 {
   183  	return 0
   184  }
   185  
   186  func (m *MessageHeader) VersionInActingVersion(actingVersion uint16) bool {
   187  	return actingVersion >= m.VersionSinceVersion()
   188  }
   189  
   190  func (*MessageHeader) VersionDeprecated() uint16 {
   191  	return 0
   192  }