aboutsummaryrefslogtreecommitdiff
path: root/nexgb/auto_sync.go
diff options
context:
space:
mode:
Diffstat (limited to 'nexgb/auto_sync.go')
-rw-r--r--nexgb/auto_sync.go1899
1 files changed, 1899 insertions, 0 deletions
diff --git a/nexgb/auto_sync.go b/nexgb/auto_sync.go
new file mode 100644
index 0000000..e87c488
--- /dev/null
+++ b/nexgb/auto_sync.go
@@ -0,0 +1,1899 @@
+package xgb
+
+/*
+ This file was generated by sync.xml on May 6 2012 3:00:44am EDT.
+ This file is automatically generated. Edit at your peril!
+*/
+
+// Imports are not necessary for XGB because everything is
+// in one package. They are still listed here for reference.
+// import "xproto"
+
+// Skipping definition for base type 'Float'
+
+// Skipping definition for base type 'Id'
+
+// Skipping definition for base type 'Card8'
+
+// Skipping definition for base type 'Int16'
+
+// Skipping definition for base type 'Int32'
+
+// Skipping definition for base type 'Void'
+
+// Skipping definition for base type 'Byte'
+
+// Skipping definition for base type 'Int8'
+
+// Skipping definition for base type 'Card16'
+
+// Skipping definition for base type 'Char'
+
+// Skipping definition for base type 'Card32'
+
+// Skipping definition for base type 'Double'
+
+// Skipping definition for base type 'Bool'
+
+const (
+ SyncAlarmstateActive = 0
+ SyncAlarmstateInactive = 1
+ SyncAlarmstateDestroyed = 2
+)
+
+const (
+ SyncTesttypePositiveTransition = 0
+ SyncTesttypeNegativeTransition = 1
+ SyncTesttypePositiveComparison = 2
+ SyncTesttypeNegativeComparison = 3
+)
+
+const (
+ SyncValuetypeAbsolute = 0
+ SyncValuetypeRelative = 1
+)
+
+const (
+ SyncCaCounter = 1
+ SyncCaValueType = 2
+ SyncCaValue = 4
+ SyncCaTestType = 8
+ SyncCaDelta = 16
+ SyncCaEvents = 32
+)
+
+// Skipping resource definition of 'Alarm'
+
+// Skipping resource definition of 'Counter'
+
+// Skipping resource definition of 'Fence'
+
+// 'SyncInt64' struct definition
+// Size: 8
+type SyncInt64 struct {
+ Hi int32
+ Lo uint32
+}
+
+// Struct read SyncInt64
+func ReadSyncInt64(buf []byte, v *SyncInt64) int {
+ b := 0
+
+ v.Hi = int32(Get32(buf[b:]))
+ b += 4
+
+ v.Lo = Get32(buf[b:])
+ b += 4
+
+ return b
+}
+
+// Struct list read SyncInt64
+func ReadSyncInt64List(buf []byte, dest []SyncInt64) int {
+ b := 0
+ for i := 0; i < len(dest); i++ {
+ dest[i] = SyncInt64{}
+ b += ReadSyncInt64(buf[b:], &dest[i])
+ }
+ return pad(b)
+}
+
+// Struct write SyncInt64
+func (v SyncInt64) Bytes() []byte {
+ buf := make([]byte, 8)
+ b := 0
+
+ Put32(buf[b:], uint32(v.Hi))
+ b += 4
+
+ Put32(buf[b:], v.Lo)
+ b += 4
+
+ return buf
+}
+
+// Write struct list SyncInt64
+func SyncInt64ListBytes(buf []byte, list []SyncInt64) int {
+ b := 0
+ var structBytes []byte
+ for _, item := range list {
+ structBytes = item.Bytes()
+ copy(buf[b:], structBytes)
+ b += pad(len(structBytes))
+ }
+ return b
+}
+
+// 'SyncSystemcounter' struct definition
+// Size: (14 + pad((int(NameLen) * 1)))
+type SyncSystemcounter struct {
+ Counter Id
+ Resolution SyncInt64
+ NameLen uint16
+ Name string // size: pad((int(NameLen) * 1))
+}
+
+// Struct read SyncSystemcounter
+func ReadSyncSystemcounter(buf []byte, v *SyncSystemcounter) int {
+ b := 0
+
+ v.Counter = Id(Get32(buf[b:]))
+ b += 4
+
+ v.Resolution = SyncInt64{}
+ b += ReadSyncInt64(buf[b:], &v.Resolution)
+
+ v.NameLen = Get16(buf[b:])
+ b += 2
+
+ {
+ byteString := make([]byte, v.NameLen)
+ copy(byteString[:v.NameLen], buf[b:])
+ v.Name = string(byteString)
+ b += pad(int(v.NameLen))
+ }
+
+ return b
+}
+
+// Struct list read SyncSystemcounter
+func ReadSyncSystemcounterList(buf []byte, dest []SyncSystemcounter) int {
+ b := 0
+ for i := 0; i < len(dest); i++ {
+ dest[i] = SyncSystemcounter{}
+ b += ReadSyncSystemcounter(buf[b:], &dest[i])
+ }
+ return pad(b)
+}
+
+// Struct write SyncSystemcounter
+func (v SyncSystemcounter) Bytes() []byte {
+ buf := make([]byte, (14 + pad((int(v.NameLen) * 1))))
+ b := 0
+
+ Put32(buf[b:], uint32(v.Counter))
+ b += 4
+
+ {
+ structBytes := v.Resolution.Bytes()
+ copy(buf[b:], structBytes)
+ b += pad(len(structBytes))
+ }
+
+ Put16(buf[b:], v.NameLen)
+ b += 2
+
+ copy(buf[b:], v.Name[:v.NameLen])
+ b += pad(int(v.NameLen))
+
+ return buf
+}
+
+// Write struct list SyncSystemcounter
+func SyncSystemcounterListBytes(buf []byte, list []SyncSystemcounter) int {
+ b := 0
+ var structBytes []byte
+ for _, item := range list {
+ structBytes = item.Bytes()
+ copy(buf[b:], structBytes)
+ b += pad(len(structBytes))
+ }
+ return b
+}
+
+// Struct list size SyncSystemcounter
+func SyncSystemcounterListSize(list []SyncSystemcounter) int {
+ size := 0
+ for _, item := range list {
+ size += (14 + pad((int(item.NameLen) * 1)))
+ }
+ return size
+}
+
+// 'SyncTrigger' struct definition
+// Size: 20
+type SyncTrigger struct {
+ Counter Id
+ WaitType uint32
+ WaitValue SyncInt64
+ TestType uint32
+}
+
+// Struct read SyncTrigger
+func ReadSyncTrigger(buf []byte, v *SyncTrigger) int {
+ b := 0
+
+ v.Counter = Id(Get32(buf[b:]))
+ b += 4
+
+ v.WaitType = Get32(buf[b:])
+ b += 4
+
+ v.WaitValue = SyncInt64{}
+ b += ReadSyncInt64(buf[b:], &v.WaitValue)
+
+ v.TestType = Get32(buf[b:])
+ b += 4
+
+ return b
+}
+
+// Struct list read SyncTrigger
+func ReadSyncTriggerList(buf []byte, dest []SyncTrigger) int {
+ b := 0
+ for i := 0; i < len(dest); i++ {
+ dest[i] = SyncTrigger{}
+ b += ReadSyncTrigger(buf[b:], &dest[i])
+ }
+ return pad(b)
+}
+
+// Struct write SyncTrigger
+func (v SyncTrigger) Bytes() []byte {
+ buf := make([]byte, 20)
+ b := 0
+
+ Put32(buf[b:], uint32(v.Counter))
+ b += 4
+
+ Put32(buf[b:], v.WaitType)
+ b += 4
+
+ {
+ structBytes := v.WaitValue.Bytes()
+ copy(buf[b:], structBytes)
+ b += pad(len(structBytes))
+ }
+
+ Put32(buf[b:], v.TestType)
+ b += 4
+
+ return buf
+}
+
+// Write struct list SyncTrigger
+func SyncTriggerListBytes(buf []byte, list []SyncTrigger) int {
+ b := 0
+ var structBytes []byte
+ for _, item := range list {
+ structBytes = item.Bytes()
+ copy(buf[b:], structBytes)
+ b += pad(len(structBytes))
+ }
+ return b
+}
+
+// 'SyncWaitcondition' struct definition
+// Size: 28
+type SyncWaitcondition struct {
+ Trigger SyncTrigger
+ EventThreshold SyncInt64
+}
+
+// Struct read SyncWaitcondition
+func ReadSyncWaitcondition(buf []byte, v *SyncWaitcondition) int {
+ b := 0
+
+ v.Trigger = SyncTrigger{}
+ b += ReadSyncTrigger(buf[b:], &v.Trigger)
+
+ v.EventThreshold = SyncInt64{}
+ b += ReadSyncInt64(buf[b:], &v.EventThreshold)
+
+ return b
+}
+
+// Struct list read SyncWaitcondition
+func ReadSyncWaitconditionList(buf []byte, dest []SyncWaitcondition) int {
+ b := 0
+ for i := 0; i < len(dest); i++ {
+ dest[i] = SyncWaitcondition{}
+ b += ReadSyncWaitcondition(buf[b:], &dest[i])
+ }
+ return pad(b)
+}
+
+// Struct write SyncWaitcondition
+func (v SyncWaitcondition) Bytes() []byte {
+ buf := make([]byte, 28)
+ b := 0
+
+ {
+ structBytes := v.Trigger.Bytes()
+ copy(buf[b:], structBytes)
+ b += pad(len(structBytes))
+ }
+
+ {
+ structBytes := v.EventThreshold.Bytes()
+ copy(buf[b:], structBytes)
+ b += pad(len(structBytes))
+ }
+
+ return buf
+}
+
+// Write struct list SyncWaitcondition
+func SyncWaitconditionListBytes(buf []byte, list []SyncWaitcondition) int {
+ b := 0
+ var structBytes []byte
+ for _, item := range list {
+ structBytes = item.Bytes()
+ copy(buf[b:], structBytes)
+ b += pad(len(structBytes))
+ }
+ return b
+}
+
+// Event definition SyncCounterNotify (0)
+// Size: 32
+
+const SyncCounterNotify = 0
+
+type SyncCounterNotifyEvent struct {
+ Sequence uint16
+ Kind byte
+ Counter Id
+ WaitValue SyncInt64
+ CounterValue SyncInt64
+ Timestamp Timestamp
+ Count uint16
+ Destroyed bool
+ // padding: 1 bytes
+}
+
+// Event read SyncCounterNotify
+func NewSyncCounterNotifyEvent(buf []byte) Event {
+ v := SyncCounterNotifyEvent{}
+ b := 1 // don't read event number
+
+ v.Kind = buf[b]
+ b += 1
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Counter = Id(Get32(buf[b:]))
+ b += 4
+
+ v.WaitValue = SyncInt64{}
+ b += ReadSyncInt64(buf[b:], &v.WaitValue)
+
+ v.CounterValue = SyncInt64{}
+ b += ReadSyncInt64(buf[b:], &v.CounterValue)
+
+ v.Timestamp = Timestamp(Get32(buf[b:]))
+ b += 4
+
+ v.Count = Get16(buf[b:])
+ b += 2
+
+ if buf[b] == 1 {
+ v.Destroyed = true
+ } else {
+ v.Destroyed = false
+ }
+ b += 1
+
+ b += 1 // padding
+
+ return v
+}
+
+// Event write SyncCounterNotify
+func (v SyncCounterNotifyEvent) Bytes() []byte {
+ buf := make([]byte, 32)
+ b := 0
+
+ // write event number
+ buf[b] = 0
+ b += 1
+
+ buf[b] = v.Kind
+ b += 1
+
+ b += 2 // skip sequence number
+
+ Put32(buf[b:], uint32(v.Counter))
+ b += 4
+
+ {
+ structBytes := v.WaitValue.Bytes()
+ copy(buf[b:], structBytes)
+ b += pad(len(structBytes))
+ }
+
+ {
+ structBytes := v.CounterValue.Bytes()
+ copy(buf[b:], structBytes)
+ b += pad(len(structBytes))
+ }
+
+ Put32(buf[b:], uint32(v.Timestamp))
+ b += 4
+
+ Put16(buf[b:], v.Count)
+ b += 2
+
+ if v.Destroyed {
+ buf[b] = 1
+ } else {
+ buf[b] = 0
+ }
+ b += 1
+
+ b += 1 // padding
+
+ return buf
+}
+
+func (v SyncCounterNotifyEvent) ImplementsEvent() {}
+
+func (v SyncCounterNotifyEvent) SequenceId() uint16 {
+ return v.Sequence
+}
+
+func (v SyncCounterNotifyEvent) String() string {
+ fieldVals := make([]string, 0, 8)
+ fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+ fieldVals = append(fieldVals, sprintf("Kind: %d", v.Kind))
+ fieldVals = append(fieldVals, sprintf("Counter: %d", v.Counter))
+ fieldVals = append(fieldVals, sprintf("Timestamp: %d", v.Timestamp))
+ fieldVals = append(fieldVals, sprintf("Count: %d", v.Count))
+ fieldVals = append(fieldVals, sprintf("Destroyed: %t", v.Destroyed))
+ return "SyncCounterNotify {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+ newEventFuncs[0] = NewSyncCounterNotifyEvent
+}
+
+// Event definition SyncAlarmNotify (1)
+// Size: 32
+
+const SyncAlarmNotify = 1
+
+type SyncAlarmNotifyEvent struct {
+ Sequence uint16
+ Kind byte
+ Alarm Id
+ CounterValue SyncInt64
+ AlarmValue SyncInt64
+ Timestamp Timestamp
+ State byte
+ // padding: 3 bytes
+}
+
+// Event read SyncAlarmNotify
+func NewSyncAlarmNotifyEvent(buf []byte) Event {
+ v := SyncAlarmNotifyEvent{}
+ b := 1 // don't read event number
+
+ v.Kind = buf[b]
+ b += 1
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Alarm = Id(Get32(buf[b:]))
+ b += 4
+
+ v.CounterValue = SyncInt64{}
+ b += ReadSyncInt64(buf[b:], &v.CounterValue)
+
+ v.AlarmValue = SyncInt64{}
+ b += ReadSyncInt64(buf[b:], &v.AlarmValue)
+
+ v.Timestamp = Timestamp(Get32(buf[b:]))
+ b += 4
+
+ v.State = buf[b]
+ b += 1
+
+ b += 3 // padding
+
+ return v
+}
+
+// Event write SyncAlarmNotify
+func (v SyncAlarmNotifyEvent) Bytes() []byte {
+ buf := make([]byte, 32)
+ b := 0
+
+ // write event number
+ buf[b] = 1
+ b += 1
+
+ buf[b] = v.Kind
+ b += 1
+
+ b += 2 // skip sequence number
+
+ Put32(buf[b:], uint32(v.Alarm))
+ b += 4
+
+ {
+ structBytes := v.CounterValue.Bytes()
+ copy(buf[b:], structBytes)
+ b += pad(len(structBytes))
+ }
+
+ {
+ structBytes := v.AlarmValue.Bytes()
+ copy(buf[b:], structBytes)
+ b += pad(len(structBytes))
+ }
+
+ Put32(buf[b:], uint32(v.Timestamp))
+ b += 4
+
+ buf[b] = v.State
+ b += 1
+
+ b += 3 // padding
+
+ return buf
+}
+
+func (v SyncAlarmNotifyEvent) ImplementsEvent() {}
+
+func (v SyncAlarmNotifyEvent) SequenceId() uint16 {
+ return v.Sequence
+}
+
+func (v SyncAlarmNotifyEvent) String() string {
+ fieldVals := make([]string, 0, 7)
+ fieldVals = append(fieldVals, sprintf("Sequence: %d", v.Sequence))
+ fieldVals = append(fieldVals, sprintf("Kind: %d", v.Kind))
+ fieldVals = append(fieldVals, sprintf("Alarm: %d", v.Alarm))
+ fieldVals = append(fieldVals, sprintf("Timestamp: %d", v.Timestamp))
+ fieldVals = append(fieldVals, sprintf("State: %d", v.State))
+ return "SyncAlarmNotify {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+ newEventFuncs[1] = NewSyncAlarmNotifyEvent
+}
+
+// Error definition SyncCounter (0)
+// Size: 32
+
+const BadSyncCounter = 0
+
+type SyncCounterError struct {
+ Sequence uint16
+ NiceName string
+ BadCounter uint32
+ MinorOpcode uint16
+ MajorOpcode byte
+}
+
+// Error read SyncCounter
+func NewSyncCounterError(buf []byte) Error {
+ v := SyncCounterError{}
+ v.NiceName = "SyncCounter"
+
+ b := 1 // skip error determinant
+ b += 1 // don't read error number
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.BadCounter = Get32(buf[b:])
+ b += 4
+
+ v.MinorOpcode = Get16(buf[b:])
+ b += 2
+
+ v.MajorOpcode = buf[b]
+ b += 1
+
+ return v
+}
+
+func (err SyncCounterError) ImplementsError() {}
+
+func (err SyncCounterError) SequenceId() uint16 {
+ return err.Sequence
+}
+
+func (err SyncCounterError) BadId() Id {
+ return 0
+}
+
+func (err SyncCounterError) Error() string {
+ fieldVals := make([]string, 0, 3)
+ fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+ fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+ fieldVals = append(fieldVals, sprintf("BadCounter: %d", err.BadCounter))
+ fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+ fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+ return "BadSyncCounter {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+ newErrorFuncs[0] = NewSyncCounterError
+}
+
+// Error definition SyncAlarm (1)
+// Size: 32
+
+const BadSyncAlarm = 1
+
+type SyncAlarmError struct {
+ Sequence uint16
+ NiceName string
+ BadAlarm uint32
+ MinorOpcode uint16
+ MajorOpcode byte
+}
+
+// Error read SyncAlarm
+func NewSyncAlarmError(buf []byte) Error {
+ v := SyncAlarmError{}
+ v.NiceName = "SyncAlarm"
+
+ b := 1 // skip error determinant
+ b += 1 // don't read error number
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.BadAlarm = Get32(buf[b:])
+ b += 4
+
+ v.MinorOpcode = Get16(buf[b:])
+ b += 2
+
+ v.MajorOpcode = buf[b]
+ b += 1
+
+ return v
+}
+
+func (err SyncAlarmError) ImplementsError() {}
+
+func (err SyncAlarmError) SequenceId() uint16 {
+ return err.Sequence
+}
+
+func (err SyncAlarmError) BadId() Id {
+ return 0
+}
+
+func (err SyncAlarmError) Error() string {
+ fieldVals := make([]string, 0, 3)
+ fieldVals = append(fieldVals, "NiceName: "+err.NiceName)
+ fieldVals = append(fieldVals, sprintf("Sequence: %d", err.Sequence))
+ fieldVals = append(fieldVals, sprintf("BadAlarm: %d", err.BadAlarm))
+ fieldVals = append(fieldVals, sprintf("MinorOpcode: %d", err.MinorOpcode))
+ fieldVals = append(fieldVals, sprintf("MajorOpcode: %d", err.MajorOpcode))
+ return "BadSyncAlarm {" + stringsJoin(fieldVals, ", ") + "}"
+}
+
+func init() {
+ newErrorFuncs[1] = NewSyncAlarmError
+}
+
+// Request SyncInitialize
+// size: 8
+type SyncInitializeCookie struct {
+ *cookie
+}
+
+func (c *Conn) SyncInitialize(DesiredMajorVersion byte, DesiredMinorVersion byte) SyncInitializeCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.syncInitializeRequest(DesiredMajorVersion, DesiredMinorVersion), cookie)
+ return SyncInitializeCookie{cookie}
+}
+
+func (c *Conn) SyncInitializeUnchecked(DesiredMajorVersion byte, DesiredMinorVersion byte) SyncInitializeCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.syncInitializeRequest(DesiredMajorVersion, DesiredMinorVersion), cookie)
+ return SyncInitializeCookie{cookie}
+}
+
+// Request reply for SyncInitialize
+// size: 32
+type SyncInitializeReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ MajorVersion byte
+ MinorVersion byte
+ // padding: 22 bytes
+}
+
+// Waits and reads reply data from request SyncInitialize
+func (cook SyncInitializeCookie) Reply() (*SyncInitializeReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return syncInitializeReply(buf), nil
+}
+
+// Read reply into structure from buffer for SyncInitialize
+func syncInitializeReply(buf []byte) *SyncInitializeReply {
+ v := new(SyncInitializeReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ v.MajorVersion = buf[b]
+ b += 1
+
+ v.MinorVersion = buf[b]
+ b += 1
+
+ b += 22 // padding
+
+ return v
+}
+
+func (cook SyncInitializeCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for SyncInitialize
+func (c *Conn) syncInitializeRequest(DesiredMajorVersion byte, DesiredMinorVersion byte) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["SYNC"]
+ b += 1
+
+ buf[b] = 0 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ buf[b] = DesiredMajorVersion
+ b += 1
+
+ buf[b] = DesiredMinorVersion
+ b += 1
+
+ return buf
+}
+
+// Request SyncListSystemCounters
+// size: 4
+type SyncListSystemCountersCookie struct {
+ *cookie
+}
+
+func (c *Conn) SyncListSystemCounters() SyncListSystemCountersCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.syncListSystemCountersRequest(), cookie)
+ return SyncListSystemCountersCookie{cookie}
+}
+
+func (c *Conn) SyncListSystemCountersUnchecked() SyncListSystemCountersCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.syncListSystemCountersRequest(), cookie)
+ return SyncListSystemCountersCookie{cookie}
+}
+
+// Request reply for SyncListSystemCounters
+// size: (32 + SyncSystemcounterListSize(Counters))
+type SyncListSystemCountersReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ CountersLen uint32
+ // padding: 20 bytes
+ Counters []SyncSystemcounter // size: SyncSystemcounterListSize(Counters)
+}
+
+// Waits and reads reply data from request SyncListSystemCounters
+func (cook SyncListSystemCountersCookie) Reply() (*SyncListSystemCountersReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return syncListSystemCountersReply(buf), nil
+}
+
+// Read reply into structure from buffer for SyncListSystemCounters
+func syncListSystemCountersReply(buf []byte) *SyncListSystemCountersReply {
+ v := new(SyncListSystemCountersReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ v.CountersLen = Get32(buf[b:])
+ b += 4
+
+ b += 20 // padding
+
+ v.Counters = make([]SyncSystemcounter, v.CountersLen)
+ b += ReadSyncSystemcounterList(buf[b:], v.Counters)
+
+ return v
+}
+
+func (cook SyncListSystemCountersCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for SyncListSystemCounters
+func (c *Conn) syncListSystemCountersRequest() []byte {
+ size := 4
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["SYNC"]
+ b += 1
+
+ buf[b] = 1 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ return buf
+}
+
+// Request SyncCreateCounter
+// size: 16
+type SyncCreateCounterCookie struct {
+ *cookie
+}
+
+// Write request to wire for SyncCreateCounter
+func (c *Conn) SyncCreateCounter(Id Id, InitialValue SyncInt64) SyncCreateCounterCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.syncCreateCounterRequest(Id, InitialValue), cookie)
+ return SyncCreateCounterCookie{cookie}
+}
+
+func (c *Conn) SyncCreateCounterChecked(Id Id, InitialValue SyncInt64) SyncCreateCounterCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.syncCreateCounterRequest(Id, InitialValue), cookie)
+ return SyncCreateCounterCookie{cookie}
+}
+
+func (cook SyncCreateCounterCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for SyncCreateCounter
+func (c *Conn) syncCreateCounterRequest(Id Id, InitialValue SyncInt64) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["SYNC"]
+ b += 1
+
+ buf[b] = 2 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(Id))
+ b += 4
+
+ {
+ structBytes := InitialValue.Bytes()
+ copy(buf[b:], structBytes)
+ b += pad(len(structBytes))
+ }
+
+ return buf
+}
+
+// Request SyncDestroyCounter
+// size: 8
+type SyncDestroyCounterCookie struct {
+ *cookie
+}
+
+// Write request to wire for SyncDestroyCounter
+func (c *Conn) SyncDestroyCounter(Counter Id) SyncDestroyCounterCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.syncDestroyCounterRequest(Counter), cookie)
+ return SyncDestroyCounterCookie{cookie}
+}
+
+func (c *Conn) SyncDestroyCounterChecked(Counter Id) SyncDestroyCounterCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.syncDestroyCounterRequest(Counter), cookie)
+ return SyncDestroyCounterCookie{cookie}
+}
+
+func (cook SyncDestroyCounterCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for SyncDestroyCounter
+func (c *Conn) syncDestroyCounterRequest(Counter Id) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["SYNC"]
+ b += 1
+
+ buf[b] = 6 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(Counter))
+ b += 4
+
+ return buf
+}
+
+// Request SyncQueryCounter
+// size: 8
+type SyncQueryCounterCookie struct {
+ *cookie
+}
+
+func (c *Conn) SyncQueryCounter(Counter Id) SyncQueryCounterCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.syncQueryCounterRequest(Counter), cookie)
+ return SyncQueryCounterCookie{cookie}
+}
+
+func (c *Conn) SyncQueryCounterUnchecked(Counter Id) SyncQueryCounterCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.syncQueryCounterRequest(Counter), cookie)
+ return SyncQueryCounterCookie{cookie}
+}
+
+// Request reply for SyncQueryCounter
+// size: 16
+type SyncQueryCounterReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ CounterValue SyncInt64
+}
+
+// Waits and reads reply data from request SyncQueryCounter
+func (cook SyncQueryCounterCookie) Reply() (*SyncQueryCounterReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return syncQueryCounterReply(buf), nil
+}
+
+// Read reply into structure from buffer for SyncQueryCounter
+func syncQueryCounterReply(buf []byte) *SyncQueryCounterReply {
+ v := new(SyncQueryCounterReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ v.CounterValue = SyncInt64{}
+ b += ReadSyncInt64(buf[b:], &v.CounterValue)
+
+ return v
+}
+
+func (cook SyncQueryCounterCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for SyncQueryCounter
+func (c *Conn) syncQueryCounterRequest(Counter Id) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["SYNC"]
+ b += 1
+
+ buf[b] = 5 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(Counter))
+ b += 4
+
+ return buf
+}
+
+// Request SyncAwait
+// size: pad((4 + pad((len(WaitList) * 28))))
+type SyncAwaitCookie struct {
+ *cookie
+}
+
+// Write request to wire for SyncAwait
+func (c *Conn) SyncAwait(WaitList []SyncWaitcondition) SyncAwaitCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.syncAwaitRequest(WaitList), cookie)
+ return SyncAwaitCookie{cookie}
+}
+
+func (c *Conn) SyncAwaitChecked(WaitList []SyncWaitcondition) SyncAwaitCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.syncAwaitRequest(WaitList), cookie)
+ return SyncAwaitCookie{cookie}
+}
+
+func (cook SyncAwaitCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for SyncAwait
+func (c *Conn) syncAwaitRequest(WaitList []SyncWaitcondition) []byte {
+ size := pad((4 + pad((len(WaitList) * 28))))
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["SYNC"]
+ b += 1
+
+ buf[b] = 7 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ b += SyncWaitconditionListBytes(buf[b:], WaitList)
+
+ return buf
+}
+
+// Request SyncChangeCounter
+// size: 16
+type SyncChangeCounterCookie struct {
+ *cookie
+}
+
+// Write request to wire for SyncChangeCounter
+func (c *Conn) SyncChangeCounter(Counter Id, Amount SyncInt64) SyncChangeCounterCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.syncChangeCounterRequest(Counter, Amount), cookie)
+ return SyncChangeCounterCookie{cookie}
+}
+
+func (c *Conn) SyncChangeCounterChecked(Counter Id, Amount SyncInt64) SyncChangeCounterCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.syncChangeCounterRequest(Counter, Amount), cookie)
+ return SyncChangeCounterCookie{cookie}
+}
+
+func (cook SyncChangeCounterCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for SyncChangeCounter
+func (c *Conn) syncChangeCounterRequest(Counter Id, Amount SyncInt64) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["SYNC"]
+ b += 1
+
+ buf[b] = 4 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(Counter))
+ b += 4
+
+ {
+ structBytes := Amount.Bytes()
+ copy(buf[b:], structBytes)
+ b += pad(len(structBytes))
+ }
+
+ return buf
+}
+
+// Request SyncSetCounter
+// size: 16
+type SyncSetCounterCookie struct {
+ *cookie
+}
+
+// Write request to wire for SyncSetCounter
+func (c *Conn) SyncSetCounter(Counter Id, Value SyncInt64) SyncSetCounterCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.syncSetCounterRequest(Counter, Value), cookie)
+ return SyncSetCounterCookie{cookie}
+}
+
+func (c *Conn) SyncSetCounterChecked(Counter Id, Value SyncInt64) SyncSetCounterCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.syncSetCounterRequest(Counter, Value), cookie)
+ return SyncSetCounterCookie{cookie}
+}
+
+func (cook SyncSetCounterCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for SyncSetCounter
+func (c *Conn) syncSetCounterRequest(Counter Id, Value SyncInt64) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["SYNC"]
+ b += 1
+
+ buf[b] = 3 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(Counter))
+ b += 4
+
+ {
+ structBytes := Value.Bytes()
+ copy(buf[b:], structBytes)
+ b += pad(len(structBytes))
+ }
+
+ return buf
+}
+
+// Request SyncCreateAlarm
+// size: pad((8 + (4 + pad((4 * popCount(int(ValueMask)))))))
+type SyncCreateAlarmCookie struct {
+ *cookie
+}
+
+// Write request to wire for SyncCreateAlarm
+func (c *Conn) SyncCreateAlarm(Id Id, ValueMask uint32, ValueList []uint32) SyncCreateAlarmCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.syncCreateAlarmRequest(Id, ValueMask, ValueList), cookie)
+ return SyncCreateAlarmCookie{cookie}
+}
+
+func (c *Conn) SyncCreateAlarmChecked(Id Id, ValueMask uint32, ValueList []uint32) SyncCreateAlarmCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.syncCreateAlarmRequest(Id, ValueMask, ValueList), cookie)
+ return SyncCreateAlarmCookie{cookie}
+}
+
+func (cook SyncCreateAlarmCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for SyncCreateAlarm
+func (c *Conn) syncCreateAlarmRequest(Id Id, ValueMask uint32, ValueList []uint32) []byte {
+ size := pad((8 + (4 + pad((4 * popCount(int(ValueMask)))))))
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["SYNC"]
+ b += 1
+
+ buf[b] = 8 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(Id))
+ b += 4
+
+ Put32(buf[b:], ValueMask)
+ b += 4
+ for i := 0; i < popCount(int(ValueMask)); i++ {
+ Put32(buf[b:], ValueList[i])
+ b += 4
+ }
+ b = pad(b)
+
+ return buf
+}
+
+// Request SyncChangeAlarm
+// size: pad((8 + (4 + pad((4 * popCount(int(ValueMask)))))))
+type SyncChangeAlarmCookie struct {
+ *cookie
+}
+
+// Write request to wire for SyncChangeAlarm
+func (c *Conn) SyncChangeAlarm(Id Id, ValueMask uint32, ValueList []uint32) SyncChangeAlarmCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.syncChangeAlarmRequest(Id, ValueMask, ValueList), cookie)
+ return SyncChangeAlarmCookie{cookie}
+}
+
+func (c *Conn) SyncChangeAlarmChecked(Id Id, ValueMask uint32, ValueList []uint32) SyncChangeAlarmCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.syncChangeAlarmRequest(Id, ValueMask, ValueList), cookie)
+ return SyncChangeAlarmCookie{cookie}
+}
+
+func (cook SyncChangeAlarmCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for SyncChangeAlarm
+func (c *Conn) syncChangeAlarmRequest(Id Id, ValueMask uint32, ValueList []uint32) []byte {
+ size := pad((8 + (4 + pad((4 * popCount(int(ValueMask)))))))
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["SYNC"]
+ b += 1
+
+ buf[b] = 9 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(Id))
+ b += 4
+
+ Put32(buf[b:], ValueMask)
+ b += 4
+ for i := 0; i < popCount(int(ValueMask)); i++ {
+ Put32(buf[b:], ValueList[i])
+ b += 4
+ }
+ b = pad(b)
+
+ return buf
+}
+
+// Request SyncDestroyAlarm
+// size: 8
+type SyncDestroyAlarmCookie struct {
+ *cookie
+}
+
+// Write request to wire for SyncDestroyAlarm
+func (c *Conn) SyncDestroyAlarm(Alarm Id) SyncDestroyAlarmCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.syncDestroyAlarmRequest(Alarm), cookie)
+ return SyncDestroyAlarmCookie{cookie}
+}
+
+func (c *Conn) SyncDestroyAlarmChecked(Alarm Id) SyncDestroyAlarmCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.syncDestroyAlarmRequest(Alarm), cookie)
+ return SyncDestroyAlarmCookie{cookie}
+}
+
+func (cook SyncDestroyAlarmCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for SyncDestroyAlarm
+func (c *Conn) syncDestroyAlarmRequest(Alarm Id) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["SYNC"]
+ b += 1
+
+ buf[b] = 11 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(Alarm))
+ b += 4
+
+ return buf
+}
+
+// Request SyncQueryAlarm
+// size: 8
+type SyncQueryAlarmCookie struct {
+ *cookie
+}
+
+func (c *Conn) SyncQueryAlarm(Alarm Id) SyncQueryAlarmCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.syncQueryAlarmRequest(Alarm), cookie)
+ return SyncQueryAlarmCookie{cookie}
+}
+
+func (c *Conn) SyncQueryAlarmUnchecked(Alarm Id) SyncQueryAlarmCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.syncQueryAlarmRequest(Alarm), cookie)
+ return SyncQueryAlarmCookie{cookie}
+}
+
+// Request reply for SyncQueryAlarm
+// size: 40
+type SyncQueryAlarmReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ Trigger SyncTrigger
+ Delta SyncInt64
+ Events bool
+ State byte
+ // padding: 2 bytes
+}
+
+// Waits and reads reply data from request SyncQueryAlarm
+func (cook SyncQueryAlarmCookie) Reply() (*SyncQueryAlarmReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return syncQueryAlarmReply(buf), nil
+}
+
+// Read reply into structure from buffer for SyncQueryAlarm
+func syncQueryAlarmReply(buf []byte) *SyncQueryAlarmReply {
+ v := new(SyncQueryAlarmReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ v.Trigger = SyncTrigger{}
+ b += ReadSyncTrigger(buf[b:], &v.Trigger)
+
+ v.Delta = SyncInt64{}
+ b += ReadSyncInt64(buf[b:], &v.Delta)
+
+ if buf[b] == 1 {
+ v.Events = true
+ } else {
+ v.Events = false
+ }
+ b += 1
+
+ v.State = buf[b]
+ b += 1
+
+ b += 2 // padding
+
+ return v
+}
+
+func (cook SyncQueryAlarmCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for SyncQueryAlarm
+func (c *Conn) syncQueryAlarmRequest(Alarm Id) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["SYNC"]
+ b += 1
+
+ buf[b] = 10 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(Alarm))
+ b += 4
+
+ return buf
+}
+
+// Request SyncSetPriority
+// size: 12
+type SyncSetPriorityCookie struct {
+ *cookie
+}
+
+// Write request to wire for SyncSetPriority
+func (c *Conn) SyncSetPriority(Id uint32, Priority int32) SyncSetPriorityCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.syncSetPriorityRequest(Id, Priority), cookie)
+ return SyncSetPriorityCookie{cookie}
+}
+
+func (c *Conn) SyncSetPriorityChecked(Id uint32, Priority int32) SyncSetPriorityCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.syncSetPriorityRequest(Id, Priority), cookie)
+ return SyncSetPriorityCookie{cookie}
+}
+
+func (cook SyncSetPriorityCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for SyncSetPriority
+func (c *Conn) syncSetPriorityRequest(Id uint32, Priority int32) []byte {
+ size := 12
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["SYNC"]
+ b += 1
+
+ buf[b] = 12 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], Id)
+ b += 4
+
+ Put32(buf[b:], uint32(Priority))
+ b += 4
+
+ return buf
+}
+
+// Request SyncGetPriority
+// size: 8
+type SyncGetPriorityCookie struct {
+ *cookie
+}
+
+func (c *Conn) SyncGetPriority(Id uint32) SyncGetPriorityCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.syncGetPriorityRequest(Id), cookie)
+ return SyncGetPriorityCookie{cookie}
+}
+
+func (c *Conn) SyncGetPriorityUnchecked(Id uint32) SyncGetPriorityCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.syncGetPriorityRequest(Id), cookie)
+ return SyncGetPriorityCookie{cookie}
+}
+
+// Request reply for SyncGetPriority
+// size: 12
+type SyncGetPriorityReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ Priority int32
+}
+
+// Waits and reads reply data from request SyncGetPriority
+func (cook SyncGetPriorityCookie) Reply() (*SyncGetPriorityReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return syncGetPriorityReply(buf), nil
+}
+
+// Read reply into structure from buffer for SyncGetPriority
+func syncGetPriorityReply(buf []byte) *SyncGetPriorityReply {
+ v := new(SyncGetPriorityReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ v.Priority = int32(Get32(buf[b:]))
+ b += 4
+
+ return v
+}
+
+func (cook SyncGetPriorityCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for SyncGetPriority
+func (c *Conn) syncGetPriorityRequest(Id uint32) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["SYNC"]
+ b += 1
+
+ buf[b] = 13 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], Id)
+ b += 4
+
+ return buf
+}
+
+// Request SyncCreateFence
+// size: 16
+type SyncCreateFenceCookie struct {
+ *cookie
+}
+
+// Write request to wire for SyncCreateFence
+func (c *Conn) SyncCreateFence(Drawable Id, Fence Id, InitiallyTriggered bool) SyncCreateFenceCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.syncCreateFenceRequest(Drawable, Fence, InitiallyTriggered), cookie)
+ return SyncCreateFenceCookie{cookie}
+}
+
+func (c *Conn) SyncCreateFenceChecked(Drawable Id, Fence Id, InitiallyTriggered bool) SyncCreateFenceCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.syncCreateFenceRequest(Drawable, Fence, InitiallyTriggered), cookie)
+ return SyncCreateFenceCookie{cookie}
+}
+
+func (cook SyncCreateFenceCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for SyncCreateFence
+func (c *Conn) syncCreateFenceRequest(Drawable Id, Fence Id, InitiallyTriggered bool) []byte {
+ size := 16
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["SYNC"]
+ b += 1
+
+ buf[b] = 14 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(Drawable))
+ b += 4
+
+ Put32(buf[b:], uint32(Fence))
+ b += 4
+
+ if InitiallyTriggered {
+ buf[b] = 1
+ } else {
+ buf[b] = 0
+ }
+ b += 1
+
+ return buf
+}
+
+// Request SyncTriggerFence
+// size: 8
+type SyncTriggerFenceCookie struct {
+ *cookie
+}
+
+// Write request to wire for SyncTriggerFence
+func (c *Conn) SyncTriggerFence(Fence Id) SyncTriggerFenceCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.syncTriggerFenceRequest(Fence), cookie)
+ return SyncTriggerFenceCookie{cookie}
+}
+
+func (c *Conn) SyncTriggerFenceChecked(Fence Id) SyncTriggerFenceCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.syncTriggerFenceRequest(Fence), cookie)
+ return SyncTriggerFenceCookie{cookie}
+}
+
+func (cook SyncTriggerFenceCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for SyncTriggerFence
+func (c *Conn) syncTriggerFenceRequest(Fence Id) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["SYNC"]
+ b += 1
+
+ buf[b] = 15 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(Fence))
+ b += 4
+
+ return buf
+}
+
+// Request SyncResetFence
+// size: 8
+type SyncResetFenceCookie struct {
+ *cookie
+}
+
+// Write request to wire for SyncResetFence
+func (c *Conn) SyncResetFence(Fence Id) SyncResetFenceCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.syncResetFenceRequest(Fence), cookie)
+ return SyncResetFenceCookie{cookie}
+}
+
+func (c *Conn) SyncResetFenceChecked(Fence Id) SyncResetFenceCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.syncResetFenceRequest(Fence), cookie)
+ return SyncResetFenceCookie{cookie}
+}
+
+func (cook SyncResetFenceCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for SyncResetFence
+func (c *Conn) syncResetFenceRequest(Fence Id) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["SYNC"]
+ b += 1
+
+ buf[b] = 16 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(Fence))
+ b += 4
+
+ return buf
+}
+
+// Request SyncDestroyFence
+// size: 8
+type SyncDestroyFenceCookie struct {
+ *cookie
+}
+
+// Write request to wire for SyncDestroyFence
+func (c *Conn) SyncDestroyFence(Fence Id) SyncDestroyFenceCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.syncDestroyFenceRequest(Fence), cookie)
+ return SyncDestroyFenceCookie{cookie}
+}
+
+func (c *Conn) SyncDestroyFenceChecked(Fence Id) SyncDestroyFenceCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.syncDestroyFenceRequest(Fence), cookie)
+ return SyncDestroyFenceCookie{cookie}
+}
+
+func (cook SyncDestroyFenceCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for SyncDestroyFence
+func (c *Conn) syncDestroyFenceRequest(Fence Id) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["SYNC"]
+ b += 1
+
+ buf[b] = 17 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(Fence))
+ b += 4
+
+ return buf
+}
+
+// Request SyncQueryFence
+// size: 8
+type SyncQueryFenceCookie struct {
+ *cookie
+}
+
+func (c *Conn) SyncQueryFence(Fence Id) SyncQueryFenceCookie {
+ cookie := c.newCookie(true, true)
+ c.newRequest(c.syncQueryFenceRequest(Fence), cookie)
+ return SyncQueryFenceCookie{cookie}
+}
+
+func (c *Conn) SyncQueryFenceUnchecked(Fence Id) SyncQueryFenceCookie {
+ cookie := c.newCookie(false, true)
+ c.newRequest(c.syncQueryFenceRequest(Fence), cookie)
+ return SyncQueryFenceCookie{cookie}
+}
+
+// Request reply for SyncQueryFence
+// size: 32
+type SyncQueryFenceReply struct {
+ Sequence uint16
+ Length uint32
+ // padding: 1 bytes
+ Triggered bool
+ // padding: 23 bytes
+}
+
+// Waits and reads reply data from request SyncQueryFence
+func (cook SyncQueryFenceCookie) Reply() (*SyncQueryFenceReply, error) {
+ buf, err := cook.reply()
+ if err != nil {
+ return nil, err
+ }
+ if buf == nil {
+ return nil, nil
+ }
+ return syncQueryFenceReply(buf), nil
+}
+
+// Read reply into structure from buffer for SyncQueryFence
+func syncQueryFenceReply(buf []byte) *SyncQueryFenceReply {
+ v := new(SyncQueryFenceReply)
+ b := 1 // skip reply determinant
+
+ b += 1 // padding
+
+ v.Sequence = Get16(buf[b:])
+ b += 2
+
+ v.Length = Get32(buf[b:]) // 4-byte units
+ b += 4
+
+ if buf[b] == 1 {
+ v.Triggered = true
+ } else {
+ v.Triggered = false
+ }
+ b += 1
+
+ b += 23 // padding
+
+ return v
+}
+
+func (cook SyncQueryFenceCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for SyncQueryFence
+func (c *Conn) syncQueryFenceRequest(Fence Id) []byte {
+ size := 8
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["SYNC"]
+ b += 1
+
+ buf[b] = 18 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ Put32(buf[b:], uint32(Fence))
+ b += 4
+
+ return buf
+}
+
+// Request SyncAwaitFence
+// size: pad((4 + pad((len(FenceList) * 4))))
+type SyncAwaitFenceCookie struct {
+ *cookie
+}
+
+// Write request to wire for SyncAwaitFence
+func (c *Conn) SyncAwaitFence(FenceList []Id) SyncAwaitFenceCookie {
+ cookie := c.newCookie(false, false)
+ c.newRequest(c.syncAwaitFenceRequest(FenceList), cookie)
+ return SyncAwaitFenceCookie{cookie}
+}
+
+func (c *Conn) SyncAwaitFenceChecked(FenceList []Id) SyncAwaitFenceCookie {
+ cookie := c.newCookie(true, false)
+ c.newRequest(c.syncAwaitFenceRequest(FenceList), cookie)
+ return SyncAwaitFenceCookie{cookie}
+}
+
+func (cook SyncAwaitFenceCookie) Check() error {
+ return cook.check()
+}
+
+// Write request to wire for SyncAwaitFence
+func (c *Conn) syncAwaitFenceRequest(FenceList []Id) []byte {
+ size := pad((4 + pad((len(FenceList) * 4))))
+ b := 0
+ buf := make([]byte, size)
+
+ buf[b] = c.extensions["SYNC"]
+ b += 1
+
+ buf[b] = 19 // request opcode
+ b += 1
+
+ Put16(buf[b:], uint16(size/4)) // write request size in 4-byte units
+ b += 2
+
+ for i := 0; i < int(len(FenceList)); i++ {
+ Put32(buf[b:], uint32(FenceList[i]))
+ b += 4
+ }
+ b = pad(b)
+
+ return buf
+}