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

     1  // Generated SBE (Simple Binary Encoding) message codec
     2  
     3  package codecs
     4  
     5  import (
     6  	"fmt"
     7  	"io"
     8  	"io/ioutil"
     9  	"math"
    10  )
    11  
    12  type AddPassiveMember struct {
    13  	CorrelationId   int64
    14  	MemberEndpoints []uint8
    15  }
    16  
    17  func (a *AddPassiveMember) Encode(_m *SbeGoMarshaller, _w io.Writer, doRangeCheck bool) error {
    18  	if doRangeCheck {
    19  		if err := a.RangeCheck(a.SbeSchemaVersion(), a.SbeSchemaVersion()); err != nil {
    20  			return err
    21  		}
    22  	}
    23  	if err := _m.WriteInt64(_w, a.CorrelationId); err != nil {
    24  		return err
    25  	}
    26  	if err := _m.WriteUint32(_w, uint32(len(a.MemberEndpoints))); err != nil {
    27  		return err
    28  	}
    29  	if err := _m.WriteBytes(_w, a.MemberEndpoints); err != nil {
    30  		return err
    31  	}
    32  	return nil
    33  }
    34  
    35  func (a *AddPassiveMember) Decode(_m *SbeGoMarshaller, _r io.Reader, actingVersion uint16, blockLength uint16, doRangeCheck bool) error {
    36  	if !a.CorrelationIdInActingVersion(actingVersion) {
    37  		a.CorrelationId = a.CorrelationIdNullValue()
    38  	} else {
    39  		if err := _m.ReadInt64(_r, &a.CorrelationId); err != nil {
    40  			return err
    41  		}
    42  	}
    43  	if actingVersion > a.SbeSchemaVersion() && blockLength > a.SbeBlockLength() {
    44  		io.CopyN(ioutil.Discard, _r, int64(blockLength-a.SbeBlockLength()))
    45  	}
    46  
    47  	if a.MemberEndpointsInActingVersion(actingVersion) {
    48  		var MemberEndpointsLength uint32
    49  		if err := _m.ReadUint32(_r, &MemberEndpointsLength); err != nil {
    50  			return err
    51  		}
    52  		if cap(a.MemberEndpoints) < int(MemberEndpointsLength) {
    53  			a.MemberEndpoints = make([]uint8, MemberEndpointsLength)
    54  		}
    55  		a.MemberEndpoints = a.MemberEndpoints[:MemberEndpointsLength]
    56  		if err := _m.ReadBytes(_r, a.MemberEndpoints); err != nil {
    57  			return err
    58  		}
    59  	}
    60  	if doRangeCheck {
    61  		if err := a.RangeCheck(actingVersion, a.SbeSchemaVersion()); err != nil {
    62  			return err
    63  		}
    64  	}
    65  	return nil
    66  }
    67  
    68  func (a *AddPassiveMember) RangeCheck(actingVersion uint16, schemaVersion uint16) error {
    69  	if a.CorrelationIdInActingVersion(actingVersion) {
    70  		if a.CorrelationId < a.CorrelationIdMinValue() || a.CorrelationId > a.CorrelationIdMaxValue() {
    71  			return fmt.Errorf("Range check failed on a.CorrelationId (%v < %v > %v)", a.CorrelationIdMinValue(), a.CorrelationId, a.CorrelationIdMaxValue())
    72  		}
    73  	}
    74  	for idx, ch := range a.MemberEndpoints {
    75  		if ch > 127 {
    76  			return fmt.Errorf("a.MemberEndpoints[%d]=%d failed ASCII validation", idx, ch)
    77  		}
    78  	}
    79  	return nil
    80  }
    81  
    82  func AddPassiveMemberInit(a *AddPassiveMember) {
    83  	return
    84  }
    85  
    86  func (*AddPassiveMember) SbeBlockLength() (blockLength uint16) {
    87  	return 8
    88  }
    89  
    90  func (*AddPassiveMember) SbeTemplateId() (templateId uint16) {
    91  	return 70
    92  }
    93  
    94  func (*AddPassiveMember) SbeSchemaId() (schemaId uint16) {
    95  	return 111
    96  }
    97  
    98  func (*AddPassiveMember) SbeSchemaVersion() (schemaVersion uint16) {
    99  	return 8
   100  }
   101  
   102  func (*AddPassiveMember) SbeSemanticType() (semanticType []byte) {
   103  	return []byte("")
   104  }
   105  
   106  func (*AddPassiveMember) CorrelationIdId() uint16 {
   107  	return 1
   108  }
   109  
   110  func (*AddPassiveMember) CorrelationIdSinceVersion() uint16 {
   111  	return 0
   112  }
   113  
   114  func (a *AddPassiveMember) CorrelationIdInActingVersion(actingVersion uint16) bool {
   115  	return actingVersion >= a.CorrelationIdSinceVersion()
   116  }
   117  
   118  func (*AddPassiveMember) CorrelationIdDeprecated() uint16 {
   119  	return 0
   120  }
   121  
   122  func (*AddPassiveMember) CorrelationIdMetaAttribute(meta int) string {
   123  	switch meta {
   124  	case 1:
   125  		return ""
   126  	case 2:
   127  		return ""
   128  	case 3:
   129  		return ""
   130  	case 4:
   131  		return "required"
   132  	}
   133  	return ""
   134  }
   135  
   136  func (*AddPassiveMember) CorrelationIdMinValue() int64 {
   137  	return math.MinInt64 + 1
   138  }
   139  
   140  func (*AddPassiveMember) CorrelationIdMaxValue() int64 {
   141  	return math.MaxInt64
   142  }
   143  
   144  func (*AddPassiveMember) CorrelationIdNullValue() int64 {
   145  	return math.MinInt64
   146  }
   147  
   148  func (*AddPassiveMember) MemberEndpointsMetaAttribute(meta int) string {
   149  	switch meta {
   150  	case 1:
   151  		return ""
   152  	case 2:
   153  		return ""
   154  	case 3:
   155  		return ""
   156  	case 4:
   157  		return "required"
   158  	}
   159  	return ""
   160  }
   161  
   162  func (*AddPassiveMember) MemberEndpointsSinceVersion() uint16 {
   163  	return 0
   164  }
   165  
   166  func (a *AddPassiveMember) MemberEndpointsInActingVersion(actingVersion uint16) bool {
   167  	return actingVersion >= a.MemberEndpointsSinceVersion()
   168  }
   169  
   170  func (*AddPassiveMember) MemberEndpointsDeprecated() uint16 {
   171  	return 0
   172  }
   173  
   174  func (AddPassiveMember) MemberEndpointsCharacterEncoding() string {
   175  	return "US-ASCII"
   176  }
   177  
   178  func (AddPassiveMember) MemberEndpointsHeaderLength() uint64 {
   179  	return 4
   180  }