| //////////////////////////////////////////////////////////////////////////////// |
| // Do not modify! |
| // Generated by codergen -go |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| package service |
| |
| import ( |
| "fmt" |
| |
| "android.googlesource.com/platform/tools/gpu/binary" |
| "android.googlesource.com/platform/tools/gpu/binary/registry" |
| "android.googlesource.com/platform/tools/gpu/binary/schema" |
| ) |
| |
| func init() { |
| registry.Add((*ApiId)(nil).Class()) |
| registry.Add((*FieldInfo)(nil).Class()) |
| registry.Add((*StructInfo)(nil).Class()) |
| registry.Add((*ApiSchema)(nil).Class()) |
| registry.Add((*ArrayInfo)(nil).Class()) |
| registry.Add((*AtomRange)(nil).Class()) |
| registry.Add((*AtomGroup)(nil).Class()) |
| registry.Add((*ParameterInfo)(nil).Class()) |
| registry.Add((*AtomInfo)(nil).Class()) |
| registry.Add((*AtomRangeTimer)(nil).Class()) |
| registry.Add((*AtomStream)(nil).Class()) |
| registry.Add((*AtomStreamId)(nil).Class()) |
| registry.Add((*AtomTimer)(nil).Class()) |
| registry.Add((*Binary)(nil).Class()) |
| registry.Add((*BinaryId)(nil).Class()) |
| registry.Add((*SchemaId)(nil).Class()) |
| registry.Add((*Capture)(nil).Class()) |
| registry.Add((*CaptureId)(nil).Class()) |
| registry.Add((*ClassInfo)(nil).Class()) |
| registry.Add((*Device)(nil).Class()) |
| registry.Add((*DeviceId)(nil).Class()) |
| registry.Add((*EnumEntry)(nil).Class()) |
| registry.Add((*EnumInfo)(nil).Class()) |
| registry.Add((*Hierarchy)(nil).Class()) |
| registry.Add((*HierarchyId)(nil).Class()) |
| registry.Add((*ImageInfo)(nil).Class()) |
| registry.Add((*ImageInfoId)(nil).Class()) |
| registry.Add((*MapInfo)(nil).Class()) |
| registry.Add((*MemoryRange)(nil).Class()) |
| registry.Add((*MemoryInfo)(nil).Class()) |
| registry.Add((*MemoryInfoId)(nil).Class()) |
| registry.Add((*RenderSettings)(nil).Class()) |
| registry.Add((*Schema)(nil).Class()) |
| registry.Add((*SimpleInfo)(nil).Class()) |
| registry.Add((*StaticArrayInfo)(nil).Class()) |
| registry.Add((*TimingInfo)(nil).Class()) |
| registry.Add((*TimingInfoId)(nil).Class()) |
| registry.Add((*callGetCaptures)(nil).Class()) |
| registry.Add((*callGetDevices)(nil).Class()) |
| registry.Add((*callGetFramebufferColor)(nil).Class()) |
| registry.Add((*callGetFramebufferDepth)(nil).Class()) |
| registry.Add((*callGetHierarchy)(nil).Class()) |
| registry.Add((*callGetMemoryInfo)(nil).Class()) |
| registry.Add((*callGetState)(nil).Class()) |
| registry.Add((*callGetTimingInfo)(nil).Class()) |
| registry.Add((*callImport)(nil).Class()) |
| registry.Add((*callPrerenderFramebuffers)(nil).Class()) |
| registry.Add((*callReplaceAtom)(nil).Class()) |
| registry.Add((*callResolveAtomStream)(nil).Class()) |
| registry.Add((*callResolveBinary)(nil).Class()) |
| registry.Add((*callResolveCapture)(nil).Class()) |
| registry.Add((*callResolveDevice)(nil).Class()) |
| registry.Add((*callResolveHierarchy)(nil).Class()) |
| registry.Add((*callResolveImageInfo)(nil).Class()) |
| registry.Add((*callResolveMemoryInfo)(nil).Class()) |
| registry.Add((*callResolveSchema)(nil).Class()) |
| registry.Add((*callResolveTimingInfo)(nil).Class()) |
| registry.Add((*resultGetCaptures)(nil).Class()) |
| registry.Add((*resultGetDevices)(nil).Class()) |
| registry.Add((*resultGetFramebufferColor)(nil).Class()) |
| registry.Add((*resultGetFramebufferDepth)(nil).Class()) |
| registry.Add((*resultGetHierarchy)(nil).Class()) |
| registry.Add((*resultGetMemoryInfo)(nil).Class()) |
| registry.Add((*resultGetState)(nil).Class()) |
| registry.Add((*resultGetTimingInfo)(nil).Class()) |
| registry.Add((*resultImport)(nil).Class()) |
| registry.Add((*resultPrerenderFramebuffers)(nil).Class()) |
| registry.Add((*resultReplaceAtom)(nil).Class()) |
| registry.Add((*resultResolveAtomStream)(nil).Class()) |
| registry.Add((*resultResolveBinary)(nil).Class()) |
| registry.Add((*resultResolveCapture)(nil).Class()) |
| registry.Add((*resultResolveDevice)(nil).Class()) |
| registry.Add((*resultResolveHierarchy)(nil).Class()) |
| registry.Add((*resultResolveImageInfo)(nil).Class()) |
| registry.Add((*resultResolveMemoryInfo)(nil).Class()) |
| registry.Add((*resultResolveSchema)(nil).Class()) |
| registry.Add((*resultResolveTimingInfo)(nil).Class()) |
| } |
| |
| var ( |
| binaryIDApiId = binary.ID{0x20, 0x75, 0x65, 0xf1, 0x82, 0xb1, 0xe1, 0x6a, 0xcd, 0x10, 0x7f, 0x7f, 0x04, 0xee, 0x90, 0x07, 0xa3, 0x62, 0xd1, 0x41} |
| binaryIDFieldInfo = binary.ID{0x16, 0xdb, 0x4c, 0x57, 0x0a, 0x1f, 0xf9, 0x33, 0x7c, 0x1f, 0x03, 0x0d, 0x2a, 0xce, 0x96, 0x7e, 0xba, 0xa8, 0x22, 0xa5} |
| binaryIDStructInfo = binary.ID{0xb1, 0x61, 0x0f, 0x73, 0xad, 0x9a, 0xc4, 0xa8, 0x4f, 0xc9, 0x6c, 0x5c, 0x94, 0x26, 0x12, 0xfc, 0x5a, 0x42, 0x75, 0x2d} |
| binaryIDApiSchema = binary.ID{0x81, 0xc2, 0x28, 0xff, 0x7b, 0xad, 0x6f, 0x74, 0x5e, 0x6c, 0xf7, 0xa3, 0x21, 0xb3, 0x12, 0x26, 0x5f, 0xa7, 0x75, 0x24} |
| binaryIDArrayInfo = binary.ID{0xf1, 0x0b, 0xb1, 0xbf, 0x10, 0xf9, 0x53, 0x4a, 0xf6, 0x5a, 0x6f, 0xc7, 0xcb, 0xa9, 0x47, 0xfd, 0xb1, 0x23, 0x5b, 0x1d} |
| binaryIDAtomRange = binary.ID{0xfa, 0xb9, 0x1d, 0x40, 0x16, 0xc4, 0x26, 0x4d, 0x40, 0x03, 0xb1, 0x72, 0xc9, 0x2f, 0x2f, 0x77, 0xde, 0xa7, 0x96, 0x4a} |
| binaryIDAtomGroup = binary.ID{0x31, 0x4b, 0xc3, 0x9a, 0x0e, 0xb2, 0x00, 0x94, 0x68, 0xc7, 0xcd, 0xbe, 0x0b, 0x1a, 0x23, 0xf0, 0xf3, 0x75, 0x56, 0x1c} |
| binaryIDParameterInfo = binary.ID{0x46, 0x0a, 0xd9, 0x73, 0x17, 0xbd, 0x7d, 0x02, 0x14, 0xed, 0x06, 0xa8, 0x09, 0x15, 0xa4, 0xc3, 0xd0, 0xc3, 0xe0, 0xff} |
| binaryIDAtomInfo = binary.ID{0xed, 0x4f, 0x94, 0x77, 0x10, 0x68, 0x9a, 0xea, 0x51, 0xb3, 0x0f, 0x2b, 0x68, 0x1d, 0x78, 0x5c, 0xa3, 0x23, 0x42, 0xd5} |
| binaryIDAtomRangeTimer = binary.ID{0xe5, 0xdd, 0xf5, 0x99, 0xf2, 0x23, 0xeb, 0x48, 0x06, 0x26, 0xe1, 0x03, 0x9f, 0x5a, 0x6e, 0x2d, 0xaf, 0x76, 0x8a, 0xf2} |
| binaryIDAtomStream = binary.ID{0xda, 0x04, 0xb7, 0x57, 0x79, 0xd1, 0x38, 0xd4, 0xa3, 0x75, 0x8f, 0x31, 0x43, 0x7b, 0xaf, 0x08, 0x0a, 0x6d, 0x57, 0x2c} |
| binaryIDAtomStreamId = binary.ID{0xbe, 0x90, 0x3c, 0x40, 0x28, 0xee, 0x58, 0x7e, 0xab, 0x8c, 0xde, 0x44, 0x43, 0xb3, 0x94, 0x88, 0xff, 0x6b, 0xa0, 0x12} |
| binaryIDAtomTimer = binary.ID{0x7b, 0x64, 0x0c, 0x00, 0x25, 0xee, 0x98, 0xa3, 0x51, 0x7b, 0x1b, 0x0d, 0x98, 0x73, 0x20, 0x93, 0x12, 0x9a, 0x7d, 0xc4} |
| binaryIDBinary = binary.ID{0x9c, 0x60, 0xfa, 0x7c, 0xe1, 0x13, 0x87, 0x3d, 0x95, 0xc1, 0x76, 0xb8, 0x60, 0x56, 0xf7, 0x35, 0x5f, 0x98, 0x27, 0x8b} |
| binaryIDBinaryId = binary.ID{0x71, 0x35, 0xf5, 0x97, 0xf9, 0x3a, 0x8a, 0x25, 0x88, 0xf6, 0x5b, 0xe6, 0x99, 0xf5, 0x1c, 0x9c, 0x97, 0xf5, 0x68, 0x3b} |
| binaryIDSchemaId = binary.ID{0x5c, 0x52, 0xa3, 0xb3, 0xf2, 0xe7, 0x35, 0x90, 0xb6, 0xb2, 0x2e, 0x5e, 0xa7, 0xc5, 0xbf, 0x3a, 0xa6, 0xe7, 0x18, 0x4c} |
| binaryIDCapture = binary.ID{0xe3, 0xb4, 0x59, 0x42, 0xf5, 0xfc, 0xe5, 0x09, 0x29, 0x27, 0x0b, 0xb9, 0x4f, 0x22, 0x3b, 0x4d, 0x13, 0xb5, 0x68, 0xb0} |
| binaryIDCaptureId = binary.ID{0x71, 0x8d, 0x28, 0x9b, 0x6c, 0xa4, 0x85, 0x73, 0xc4, 0x8a, 0x21, 0xb3, 0x9c, 0xae, 0x27, 0xa8, 0xe2, 0x57, 0x9e, 0xdd} |
| binaryIDClassInfo = binary.ID{0x82, 0x7f, 0xfa, 0x73, 0x67, 0x83, 0x4a, 0x7b, 0x4e, 0x8b, 0x52, 0xa0, 0x48, 0xab, 0x03, 0x63, 0xeb, 0xc0, 0x90, 0x32} |
| binaryIDDevice = binary.ID{0x7f, 0xa5, 0x70, 0xd9, 0x93, 0xfc, 0x70, 0x27, 0x32, 0xd9, 0xb8, 0x6e, 0x2a, 0x9b, 0xf3, 0x84, 0x55, 0x4f, 0x26, 0x50} |
| binaryIDDeviceId = binary.ID{0x9e, 0x5b, 0x14, 0x1f, 0xa6, 0x65, 0x62, 0x62, 0x15, 0x6a, 0x39, 0xd2, 0xa4, 0x64, 0x2f, 0x00, 0x49, 0x13, 0x64, 0x20} |
| binaryIDEnumEntry = binary.ID{0xea, 0x7f, 0xa3, 0xef, 0xb6, 0x4c, 0x5a, 0x85, 0xc9, 0x5f, 0xb5, 0xa1, 0x28, 0xfe, 0xb3, 0xa7, 0x53, 0xae, 0xb7, 0xd0} |
| binaryIDEnumInfo = binary.ID{0xc8, 0xb4, 0x37, 0x51, 0xa6, 0x94, 0x50, 0xe5, 0x0e, 0xc7, 0xe1, 0x2f, 0xd6, 0xf2, 0xad, 0x68, 0xf5, 0x31, 0x06, 0xe3} |
| binaryIDHierarchy = binary.ID{0x4a, 0x29, 0x6b, 0x6f, 0x37, 0xca, 0x76, 0x25, 0xbc, 0x89, 0x1a, 0xea, 0x80, 0x56, 0xa9, 0x66, 0x0e, 0x1a, 0x1a, 0x97} |
| binaryIDHierarchyId = binary.ID{0xfd, 0x20, 0x19, 0xa0, 0xb5, 0xac, 0x49, 0xc7, 0x7d, 0x6e, 0xf8, 0x32, 0x6b, 0x78, 0x9f, 0xd7, 0x6d, 0xf0, 0x2c, 0xaf} |
| binaryIDImageInfo = binary.ID{0x83, 0x55, 0x77, 0x9d, 0xe7, 0x6b, 0xed, 0xd5, 0xc5, 0x3c, 0x86, 0x42, 0xfe, 0xd6, 0x1a, 0x6d, 0x2b, 0xd0, 0xfb, 0x88} |
| binaryIDImageInfoId = binary.ID{0xb1, 0x03, 0x2c, 0x17, 0x12, 0xab, 0x40, 0x23, 0x1d, 0x01, 0xb9, 0x4b, 0x9b, 0x8c, 0x9d, 0x5a, 0x19, 0x45, 0xaf, 0x70} |
| binaryIDMapInfo = binary.ID{0xf3, 0x40, 0x60, 0x02, 0x47, 0x89, 0x04, 0x5e, 0x0c, 0x8f, 0xd3, 0x9d, 0xa9, 0xd7, 0x19, 0x8b, 0xd0, 0x88, 0xd8, 0xdf} |
| binaryIDMemoryRange = binary.ID{0xfa, 0xc5, 0x84, 0x24, 0x6c, 0x1b, 0x47, 0x0e, 0xe5, 0xdb, 0x67, 0x29, 0xd8, 0xb1, 0x81, 0x3b, 0xfe, 0x53, 0x3a, 0x9d} |
| binaryIDMemoryInfo = binary.ID{0xfa, 0x6e, 0x9e, 0xc9, 0xe4, 0x44, 0x62, 0x53, 0xa0, 0x69, 0xe7, 0x64, 0x3b, 0x30, 0xc1, 0xaa, 0xfd, 0x73, 0xb1, 0x93} |
| binaryIDMemoryInfoId = binary.ID{0x84, 0x64, 0x1a, 0xae, 0xde, 0x19, 0x1a, 0xa3, 0xae, 0xc7, 0x31, 0x9f, 0x5e, 0x46, 0xa0, 0x51, 0x54, 0xc5, 0x46, 0x15} |
| binaryIDRenderSettings = binary.ID{0x18, 0x23, 0x35, 0xef, 0xd0, 0x3a, 0xe4, 0x25, 0x17, 0xc4, 0x7a, 0x2b, 0xab, 0x32, 0x10, 0x9c, 0x22, 0x86, 0x23, 0x00} |
| binaryIDSchema = binary.ID{0x7d, 0xcb, 0xa0, 0x01, 0x4d, 0xb6, 0x8b, 0x05, 0x82, 0xe4, 0x54, 0x87, 0x36, 0xd1, 0xf9, 0x6b, 0x89, 0xeb, 0xff, 0xb2} |
| binaryIDSimpleInfo = binary.ID{0xcd, 0x73, 0xc4, 0xe7, 0x48, 0x3f, 0x0b, 0xd8, 0x9c, 0x6d, 0xa8, 0x4e, 0x51, 0x6b, 0x4c, 0xcc, 0xa5, 0x94, 0x3a, 0x25} |
| binaryIDStaticArrayInfo = binary.ID{0x98, 0xa5, 0x0e, 0x08, 0x76, 0xa1, 0x4c, 0xe3, 0x39, 0x80, 0x9b, 0x62, 0x24, 0xaa, 0xeb, 0xe7, 0xe6, 0xfd, 0x5f, 0x03} |
| binaryIDTimingInfo = binary.ID{0x19, 0xd8, 0xe7, 0xdb, 0xe7, 0xb2, 0xdc, 0x2e, 0x73, 0x08, 0xc2, 0x97, 0x2e, 0x68, 0xb9, 0x92, 0x52, 0x4a, 0x0a, 0xd7} |
| binaryIDTimingInfoId = binary.ID{0x71, 0x9c, 0x16, 0xeb, 0x4e, 0x5f, 0xa1, 0x6b, 0x71, 0x0c, 0xae, 0xbc, 0x5a, 0xe8, 0x6c, 0x29, 0x97, 0xaa, 0x52, 0x0f} |
| binaryIDcallGetCaptures = binary.ID{0xb0, 0x2f, 0x3d, 0xa5, 0x85, 0x95, 0xf4, 0x21, 0x20, 0x76, 0xa8, 0xa6, 0x5a, 0x53, 0x9f, 0xfc, 0xd8, 0x10, 0xdb, 0x15} |
| binaryIDcallGetDevices = binary.ID{0x19, 0x14, 0x64, 0x05, 0xf6, 0xad, 0x8d, 0x48, 0xc3, 0x8e, 0x7b, 0xc8, 0x18, 0x5b, 0x2f, 0x7c, 0xb7, 0x9f, 0x5c, 0x73} |
| binaryIDcallGetFramebufferColor = binary.ID{0x05, 0xfd, 0x78, 0xff, 0x3d, 0x76, 0x07, 0x2d, 0xee, 0x91, 0x3b, 0xf1, 0x99, 0x83, 0x1e, 0x4f, 0xaf, 0xd3, 0xca, 0x48} |
| binaryIDcallGetFramebufferDepth = binary.ID{0xdd, 0x68, 0xbd, 0xbc, 0x24, 0x0a, 0x1a, 0x1c, 0xa5, 0xa6, 0xfc, 0xe2, 0x64, 0x38, 0xac, 0x67, 0xa6, 0x86, 0x64, 0x5f} |
| binaryIDcallGetHierarchy = binary.ID{0xbf, 0x39, 0x53, 0xd4, 0xc3, 0xac, 0x61, 0x0a, 0xce, 0x6c, 0x72, 0x04, 0x39, 0xcd, 0x5f, 0xe5, 0x92, 0xd5, 0xf6, 0xa6} |
| binaryIDcallGetMemoryInfo = binary.ID{0x89, 0xa1, 0x6f, 0x75, 0x3d, 0x07, 0xb5, 0x9f, 0x0e, 0x20, 0xad, 0x27, 0xfd, 0xe8, 0x16, 0x50, 0x59, 0x24, 0x16, 0xb3} |
| binaryIDcallGetState = binary.ID{0xc3, 0xb2, 0x0b, 0xb8, 0x8b, 0xc7, 0x79, 0xcd, 0x06, 0xc3, 0x16, 0xef, 0x18, 0x3a, 0x96, 0x37, 0xf9, 0xad, 0x28, 0xb3} |
| binaryIDcallGetTimingInfo = binary.ID{0xb1, 0x32, 0x24, 0x67, 0x2e, 0xb9, 0x1f, 0x2f, 0x72, 0xf3, 0x6b, 0x00, 0x23, 0x1f, 0xd4, 0x1a, 0x57, 0x59, 0x22, 0x29} |
| binaryIDcallImport = binary.ID{0x35, 0x11, 0x23, 0xbb, 0xa5, 0x10, 0x7a, 0x10, 0x7d, 0x46, 0x1d, 0x0b, 0xfc, 0x3c, 0x4e, 0x20, 0x68, 0x41, 0x1e, 0xb5} |
| binaryIDcallPrerenderFramebuffers = binary.ID{0x2f, 0x48, 0x59, 0x5f, 0xfc, 0xbf, 0xee, 0x9f, 0xfd, 0x8a, 0x56, 0x4b, 0xab, 0x90, 0xb7, 0xab, 0xeb, 0x38, 0xd1, 0x85} |
| binaryIDcallReplaceAtom = binary.ID{0x3b, 0x6a, 0x9a, 0x30, 0x3a, 0x32, 0xc0, 0x3a, 0x50, 0x5c, 0xed, 0xa9, 0xd4, 0x6a, 0x05, 0x54, 0xb3, 0xe2, 0x95, 0x3d} |
| binaryIDcallResolveAtomStream = binary.ID{0x6b, 0xef, 0x7c, 0x2b, 0x7e, 0x3c, 0x23, 0xe3, 0xe0, 0x38, 0xb8, 0xdc, 0xbb, 0xd2, 0x89, 0x93, 0xba, 0x99, 0x79, 0x90} |
| binaryIDcallResolveBinary = binary.ID{0x08, 0x68, 0x1b, 0x77, 0x97, 0x0b, 0xb5, 0x34, 0x9b, 0xed, 0x14, 0x58, 0x5e, 0x45, 0x09, 0x82, 0x0c, 0x47, 0x57, 0xe9} |
| binaryIDcallResolveCapture = binary.ID{0x4e, 0x6e, 0x5b, 0x49, 0x61, 0xef, 0xfc, 0x3c, 0x4a, 0xf8, 0xf6, 0xae, 0xc0, 0xca, 0xa1, 0x67, 0x17, 0x73, 0xff, 0xf8} |
| binaryIDcallResolveDevice = binary.ID{0x86, 0x54, 0x88, 0xf5, 0x8f, 0x3e, 0x97, 0x57, 0xe2, 0x98, 0x19, 0x7e, 0x67, 0x25, 0xfb, 0xa2, 0x75, 0xeb, 0x30, 0x0a} |
| binaryIDcallResolveHierarchy = binary.ID{0x39, 0x2a, 0x9f, 0x44, 0xfe, 0x2c, 0x0f, 0xd8, 0xc5, 0x44, 0x58, 0x51, 0x94, 0x6a, 0x95, 0xa4, 0x22, 0x90, 0x34, 0x36} |
| binaryIDcallResolveImageInfo = binary.ID{0x4e, 0x51, 0x41, 0x13, 0x68, 0x6f, 0x58, 0x5a, 0xed, 0xe0, 0x0a, 0x05, 0x0d, 0x01, 0x9d, 0x28, 0x9c, 0x21, 0x8c, 0xbb} |
| binaryIDcallResolveMemoryInfo = binary.ID{0xdf, 0x26, 0x6c, 0x3b, 0x06, 0x05, 0x08, 0xc5, 0xc1, 0xd1, 0x86, 0x64, 0x21, 0xf1, 0x58, 0x45, 0x0f, 0x3e, 0x2f, 0x0e} |
| binaryIDcallResolveSchema = binary.ID{0x45, 0xca, 0x16, 0xe5, 0x5d, 0x24, 0x69, 0x78, 0xa1, 0x23, 0x32, 0x77, 0x97, 0x13, 0xe2, 0xaf, 0x30, 0x3b, 0x70, 0x21} |
| binaryIDcallResolveTimingInfo = binary.ID{0xf9, 0x99, 0xeb, 0x43, 0x27, 0x9c, 0x38, 0x16, 0xa6, 0xb5, 0x6a, 0x0e, 0xa0, 0xdf, 0x79, 0xa1, 0x26, 0x2e, 0xe3, 0xe4} |
| binaryIDresultGetCaptures = binary.ID{0xb0, 0x3e, 0x04, 0x4d, 0x32, 0xfd, 0x8f, 0x93, 0x5a, 0xfa, 0x30, 0x09, 0x9e, 0xb6, 0x9b, 0x5d, 0x02, 0x93, 0xe4, 0x7b} |
| binaryIDresultGetDevices = binary.ID{0x7e, 0xc1, 0x80, 0xe3, 0x79, 0x1d, 0xea, 0x0d, 0x62, 0x02, 0x58, 0x6a, 0xeb, 0xa5, 0x24, 0x98, 0x30, 0x8e, 0x46, 0xe8} |
| binaryIDresultGetFramebufferColor = binary.ID{0xd1, 0xf2, 0x9c, 0x48, 0xeb, 0xb0, 0x4e, 0x4e, 0x82, 0xcf, 0xac, 0xe9, 0xc6, 0x71, 0x27, 0x04, 0x57, 0x7e, 0xe4, 0x25} |
| binaryIDresultGetFramebufferDepth = binary.ID{0x08, 0xd8, 0x4e, 0xd2, 0xe4, 0x2f, 0xc3, 0xb6, 0x10, 0x47, 0xeb, 0xae, 0xa2, 0x56, 0x99, 0x91, 0x31, 0x83, 0xb7, 0x27} |
| binaryIDresultGetHierarchy = binary.ID{0xff, 0x28, 0xe0, 0x58, 0x97, 0xa9, 0x5e, 0x1b, 0x62, 0xe1, 0xa0, 0xef, 0x05, 0xea, 0x3e, 0x62, 0x5d, 0x17, 0xaa, 0x47} |
| binaryIDresultGetMemoryInfo = binary.ID{0x54, 0xdc, 0x10, 0xcf, 0x6d, 0x96, 0x70, 0xd9, 0x00, 0x7d, 0xd7, 0x1f, 0x08, 0x4a, 0xa3, 0xaf, 0x57, 0xda, 0x09, 0xee} |
| binaryIDresultGetState = binary.ID{0xa0, 0x1e, 0x40, 0x20, 0xd1, 0x4d, 0xc6, 0x19, 0xf4, 0xcb, 0x10, 0xce, 0x81, 0x09, 0x89, 0xdf, 0xad, 0x63, 0xf6, 0xee} |
| binaryIDresultGetTimingInfo = binary.ID{0x1d, 0x17, 0x32, 0x54, 0xb3, 0xbd, 0xbe, 0x57, 0xda, 0xef, 0xb2, 0xb0, 0x4b, 0x5f, 0xc2, 0x85, 0x85, 0xcb, 0x8f, 0xf3} |
| binaryIDresultImport = binary.ID{0x1e, 0x86, 0x40, 0xb0, 0xc2, 0xb8, 0xa5, 0xa1, 0xf3, 0xc8, 0x51, 0x29, 0x87, 0x4d, 0x0c, 0xd9, 0x49, 0xd8, 0xbe, 0xed} |
| binaryIDresultPrerenderFramebuffers = binary.ID{0xc2, 0x9e, 0x11, 0x61, 0x22, 0xcb, 0xd8, 0xfc, 0x6c, 0x5c, 0xb9, 0x0f, 0x07, 0x81, 0x67, 0xc9, 0x2e, 0x1f, 0x2f, 0xf8} |
| binaryIDresultReplaceAtom = binary.ID{0x52, 0x62, 0xe6, 0x27, 0x54, 0x4e, 0x8e, 0x8f, 0x1e, 0x9f, 0x5e, 0xf5, 0x8d, 0x64, 0x38, 0x99, 0xb4, 0x57, 0xef, 0xff} |
| binaryIDresultResolveAtomStream = binary.ID{0x05, 0xb9, 0x98, 0x3d, 0x6f, 0x5f, 0xc0, 0x23, 0xb2, 0xe1, 0x2e, 0x55, 0xf4, 0x37, 0x71, 0xe6, 0xd3, 0x98, 0xbf, 0x52} |
| binaryIDresultResolveBinary = binary.ID{0xbf, 0xbd, 0x77, 0xf6, 0xc1, 0x13, 0x8c, 0xfe, 0x38, 0xd5, 0x30, 0x3c, 0x58, 0xc8, 0x67, 0xbf, 0x17, 0xce, 0x71, 0xe9} |
| binaryIDresultResolveCapture = binary.ID{0xb3, 0x47, 0xd0, 0x3f, 0x28, 0x63, 0xfe, 0xa4, 0x32, 0xc6, 0xf0, 0x2c, 0xec, 0x6d, 0x33, 0x8a, 0xb2, 0x38, 0xf7, 0x37} |
| binaryIDresultResolveDevice = binary.ID{0x7f, 0xd2, 0x9f, 0x67, 0xe3, 0xbe, 0x0e, 0x46, 0x07, 0xdf, 0x8f, 0x6e, 0x6e, 0x85, 0x6d, 0x26, 0xcf, 0xd1, 0xa6, 0xa3} |
| binaryIDresultResolveHierarchy = binary.ID{0x60, 0xf3, 0x21, 0x98, 0x1b, 0x86, 0x98, 0x38, 0x8c, 0x1e, 0x33, 0x3c, 0x06, 0x9d, 0x67, 0x2a, 0x05, 0x50, 0xef, 0xfc} |
| binaryIDresultResolveImageInfo = binary.ID{0xdf, 0x45, 0x26, 0xc3, 0xec, 0x36, 0x2c, 0x5a, 0x08, 0xe3, 0x0f, 0x8e, 0x58, 0x52, 0xbd, 0xb2, 0xf3, 0x26, 0x69, 0x9f} |
| binaryIDresultResolveMemoryInfo = binary.ID{0x1f, 0xcf, 0x9a, 0x85, 0x99, 0x82, 0x5f, 0xa8, 0x46, 0x93, 0x60, 0xa5, 0x17, 0xda, 0x9e, 0x11, 0x34, 0xe8, 0x3d, 0x22} |
| binaryIDresultResolveSchema = binary.ID{0xe1, 0x27, 0x52, 0x76, 0x82, 0xcc, 0x3e, 0x6c, 0xb8, 0x6a, 0x10, 0xcb, 0x51, 0xc0, 0xcb, 0xf8, 0xa3, 0x32, 0xc7, 0xaa} |
| binaryIDresultResolveTimingInfo = binary.ID{0xc9, 0x37, 0xfb, 0xd4, 0x2d, 0x45, 0xcb, 0x15, 0x56, 0x1d, 0x08, 0xa2, 0xcc, 0xe9, 0xf8, 0x43, 0x68, 0x83, 0x3d, 0xa7} |
| ) |
| |
| type binaryClassApiId struct{} |
| |
| func (*ApiId) Class() binary.Class { |
| return (*binaryClassApiId)(nil) |
| } |
| func doEncodeApiId(e binary.Encoder, o *ApiId) error { |
| if err := e.ID(o.ID); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodeApiId(d binary.Decoder, o *ApiId) error { |
| if obj, err := d.ID(); err != nil { |
| return err |
| } else { |
| o.ID = binary.ID(obj) |
| } |
| return nil |
| } |
| func doSkipApiId(d binary.Decoder) error { |
| if err := d.SkipID(); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassApiId) ID() binary.ID { return binaryIDApiId } |
| func (*binaryClassApiId) New() binary.Object { return &ApiId{} } |
| func (*binaryClassApiId) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeApiId(e, obj.(*ApiId)) |
| } |
| func (*binaryClassApiId) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &ApiId{} |
| return obj, doDecodeApiId(d, obj) |
| } |
| func (*binaryClassApiId) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeApiId(d, obj.(*ApiId)) |
| } |
| func (*binaryClassApiId) Skip(d binary.Decoder) error { return doSkipApiId(d) } |
| func (*binaryClassApiId) Schema() *schema.Class { return schemaApiId } |
| |
| var schemaApiId = &schema.Class{ |
| TypeID: binaryIDApiId, |
| Name: "ApiId", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "ID", Type: &schema.Primitive{Name: "binary.ID", Method: schema.ID}}, |
| }, |
| } |
| |
| type binaryClassFieldInfo struct{} |
| |
| func (*FieldInfo) Class() binary.Class { |
| return (*binaryClassFieldInfo)(nil) |
| } |
| func doEncodeFieldInfo(e binary.Encoder, o *FieldInfo) error { |
| if err := e.String(o.Name); err != nil { |
| return err |
| } |
| if o.Type != nil { |
| if err := e.Object(o.Type); err != nil { |
| return err |
| } |
| } else if err := e.Object(nil); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodeFieldInfo(d binary.Decoder, o *FieldInfo) error { |
| if obj, err := d.String(); err != nil { |
| return err |
| } else { |
| o.Name = string(obj) |
| } |
| if obj, err := d.Object(); err != nil { |
| return err |
| } else if obj != nil { |
| o.Type = obj.(TypeInfo) |
| } else { |
| o.Type = nil |
| } |
| return nil |
| } |
| func doSkipFieldInfo(d binary.Decoder) error { |
| if err := d.SkipString(); err != nil { |
| return err |
| } |
| if _, err := d.SkipObject(); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassFieldInfo) ID() binary.ID { return binaryIDFieldInfo } |
| func (*binaryClassFieldInfo) New() binary.Object { return &FieldInfo{} } |
| func (*binaryClassFieldInfo) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeFieldInfo(e, obj.(*FieldInfo)) |
| } |
| func (*binaryClassFieldInfo) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &FieldInfo{} |
| return obj, doDecodeFieldInfo(d, obj) |
| } |
| func (*binaryClassFieldInfo) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeFieldInfo(d, obj.(*FieldInfo)) |
| } |
| func (*binaryClassFieldInfo) Skip(d binary.Decoder) error { return doSkipFieldInfo(d) } |
| func (*binaryClassFieldInfo) Schema() *schema.Class { return schemaFieldInfo } |
| |
| var schemaFieldInfo = &schema.Class{ |
| TypeID: binaryIDFieldInfo, |
| Name: "FieldInfo", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}}, |
| schema.Field{Declared: "Type", Type: &schema.Interface{Name: "TypeInfo"}}, |
| }, |
| } |
| |
| type binaryClassStructInfo struct{} |
| |
| func (*StructInfo) Class() binary.Class { |
| return (*binaryClassStructInfo)(nil) |
| } |
| func doEncodeStructInfo(e binary.Encoder, o *StructInfo) error { |
| if err := e.String(o.Name); err != nil { |
| return err |
| } |
| if err := e.Int32(int32(o.Kind)); err != nil { |
| return err |
| } |
| if err := e.Uint32(uint32(len(o.Fields))); err != nil { |
| return err |
| } |
| for i := range o.Fields { |
| if o.Fields[i] != nil { |
| if err := e.Object(o.Fields[i]); err != nil { |
| return err |
| } |
| } else if err := e.Object(nil); err != nil { |
| return err |
| } |
| } |
| return nil |
| } |
| func doDecodeStructInfo(d binary.Decoder, o *StructInfo) error { |
| if obj, err := d.String(); err != nil { |
| return err |
| } else { |
| o.Name = string(obj) |
| } |
| if obj, err := d.Int32(); err != nil { |
| return err |
| } else { |
| o.Kind = TypeKind(obj) |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.Fields = make(FieldInfoPtrArray, count) |
| for i := range o.Fields { |
| if obj, err := d.Object(); err != nil { |
| return err |
| } else if obj != nil { |
| o.Fields[i] = obj.(*FieldInfo) |
| } else { |
| o.Fields[i] = nil |
| } |
| } |
| } |
| return nil |
| } |
| func doSkipStructInfo(d binary.Decoder) error { |
| if err := d.SkipString(); err != nil { |
| return err |
| } |
| if _, err := d.Int32(); err != nil { |
| return err |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| for i := uint32(0); i < count; i++ { |
| if _, err := d.SkipObject(); err != nil { |
| return err |
| } |
| } |
| } |
| return nil |
| } |
| func (*binaryClassStructInfo) ID() binary.ID { return binaryIDStructInfo } |
| func (*binaryClassStructInfo) New() binary.Object { return &StructInfo{} } |
| func (*binaryClassStructInfo) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeStructInfo(e, obj.(*StructInfo)) |
| } |
| func (*binaryClassStructInfo) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &StructInfo{} |
| return obj, doDecodeStructInfo(d, obj) |
| } |
| func (*binaryClassStructInfo) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeStructInfo(d, obj.(*StructInfo)) |
| } |
| func (*binaryClassStructInfo) Skip(d binary.Decoder) error { return doSkipStructInfo(d) } |
| func (*binaryClassStructInfo) Schema() *schema.Class { return schemaStructInfo } |
| |
| var schemaStructInfo = &schema.Class{ |
| TypeID: binaryIDStructInfo, |
| Name: "StructInfo", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}}, |
| schema.Field{Declared: "Kind", Type: &schema.Primitive{Name: "TypeKind", Method: schema.Int32}}, |
| schema.Field{Declared: "Fields", Type: &schema.Slice{Alias: "FieldInfoPtrArray", ValueType: &schema.Pointer{Type: &schema.Struct{Name: "FieldInfo"}}}}, |
| }, |
| } |
| |
| type binaryClassApiSchema struct{} |
| |
| func (*ApiSchema) Class() binary.Class { |
| return (*binaryClassApiSchema)(nil) |
| } |
| func doEncodeApiSchema(e binary.Encoder, o *ApiSchema) error { |
| if err := e.Value(&o.Api); err != nil { |
| return err |
| } |
| if err := e.Value(&o.State); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodeApiSchema(d binary.Decoder, o *ApiSchema) error { |
| if err := d.Value(&o.Api); err != nil { |
| return err |
| } |
| if err := d.Value(&o.State); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipApiSchema(d binary.Decoder) error { |
| if err := d.SkipValue((*ApiId)(nil)); err != nil { |
| return err |
| } |
| if err := d.SkipValue((*StructInfo)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassApiSchema) ID() binary.ID { return binaryIDApiSchema } |
| func (*binaryClassApiSchema) New() binary.Object { return &ApiSchema{} } |
| func (*binaryClassApiSchema) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeApiSchema(e, obj.(*ApiSchema)) |
| } |
| func (*binaryClassApiSchema) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &ApiSchema{} |
| return obj, doDecodeApiSchema(d, obj) |
| } |
| func (*binaryClassApiSchema) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeApiSchema(d, obj.(*ApiSchema)) |
| } |
| func (*binaryClassApiSchema) Skip(d binary.Decoder) error { return doSkipApiSchema(d) } |
| func (*binaryClassApiSchema) Schema() *schema.Class { return schemaApiSchema } |
| |
| var schemaApiSchema = &schema.Class{ |
| TypeID: binaryIDApiSchema, |
| Name: "ApiSchema", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "Api", Type: &schema.Struct{Name: "ApiId"}}, |
| schema.Field{Declared: "State", Type: &schema.Struct{Name: "StructInfo"}}, |
| }, |
| } |
| |
| type binaryClassArrayInfo struct{} |
| |
| func (*ArrayInfo) Class() binary.Class { |
| return (*binaryClassArrayInfo)(nil) |
| } |
| func doEncodeArrayInfo(e binary.Encoder, o *ArrayInfo) error { |
| if err := e.String(o.Name); err != nil { |
| return err |
| } |
| if err := e.Int32(int32(o.Kind)); err != nil { |
| return err |
| } |
| if o.ElementType != nil { |
| if err := e.Object(o.ElementType); err != nil { |
| return err |
| } |
| } else if err := e.Object(nil); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodeArrayInfo(d binary.Decoder, o *ArrayInfo) error { |
| if obj, err := d.String(); err != nil { |
| return err |
| } else { |
| o.Name = string(obj) |
| } |
| if obj, err := d.Int32(); err != nil { |
| return err |
| } else { |
| o.Kind = TypeKind(obj) |
| } |
| if obj, err := d.Object(); err != nil { |
| return err |
| } else if obj != nil { |
| o.ElementType = obj.(TypeInfo) |
| } else { |
| o.ElementType = nil |
| } |
| return nil |
| } |
| func doSkipArrayInfo(d binary.Decoder) error { |
| if err := d.SkipString(); err != nil { |
| return err |
| } |
| if _, err := d.Int32(); err != nil { |
| return err |
| } |
| if _, err := d.SkipObject(); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassArrayInfo) ID() binary.ID { return binaryIDArrayInfo } |
| func (*binaryClassArrayInfo) New() binary.Object { return &ArrayInfo{} } |
| func (*binaryClassArrayInfo) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeArrayInfo(e, obj.(*ArrayInfo)) |
| } |
| func (*binaryClassArrayInfo) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &ArrayInfo{} |
| return obj, doDecodeArrayInfo(d, obj) |
| } |
| func (*binaryClassArrayInfo) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeArrayInfo(d, obj.(*ArrayInfo)) |
| } |
| func (*binaryClassArrayInfo) Skip(d binary.Decoder) error { return doSkipArrayInfo(d) } |
| func (*binaryClassArrayInfo) Schema() *schema.Class { return schemaArrayInfo } |
| |
| var schemaArrayInfo = &schema.Class{ |
| TypeID: binaryIDArrayInfo, |
| Name: "ArrayInfo", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}}, |
| schema.Field{Declared: "Kind", Type: &schema.Primitive{Name: "TypeKind", Method: schema.Int32}}, |
| schema.Field{Declared: "ElementType", Type: &schema.Interface{Name: "TypeInfo"}}, |
| }, |
| } |
| |
| type binaryClassAtomRange struct{} |
| |
| func (*AtomRange) Class() binary.Class { |
| return (*binaryClassAtomRange)(nil) |
| } |
| func doEncodeAtomRange(e binary.Encoder, o *AtomRange) error { |
| if err := e.Uint64(o.First); err != nil { |
| return err |
| } |
| if err := e.Uint64(o.Count); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodeAtomRange(d binary.Decoder, o *AtomRange) error { |
| if obj, err := d.Uint64(); err != nil { |
| return err |
| } else { |
| o.First = uint64(obj) |
| } |
| if obj, err := d.Uint64(); err != nil { |
| return err |
| } else { |
| o.Count = uint64(obj) |
| } |
| return nil |
| } |
| func doSkipAtomRange(d binary.Decoder) error { |
| if _, err := d.Uint64(); err != nil { |
| return err |
| } |
| if _, err := d.Uint64(); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassAtomRange) ID() binary.ID { return binaryIDAtomRange } |
| func (*binaryClassAtomRange) New() binary.Object { return &AtomRange{} } |
| func (*binaryClassAtomRange) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeAtomRange(e, obj.(*AtomRange)) |
| } |
| func (*binaryClassAtomRange) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &AtomRange{} |
| return obj, doDecodeAtomRange(d, obj) |
| } |
| func (*binaryClassAtomRange) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeAtomRange(d, obj.(*AtomRange)) |
| } |
| func (*binaryClassAtomRange) Skip(d binary.Decoder) error { return doSkipAtomRange(d) } |
| func (*binaryClassAtomRange) Schema() *schema.Class { return schemaAtomRange } |
| |
| var schemaAtomRange = &schema.Class{ |
| TypeID: binaryIDAtomRange, |
| Name: "AtomRange", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "First", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}}, |
| schema.Field{Declared: "Count", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}}, |
| }, |
| } |
| |
| type binaryClassAtomGroup struct{} |
| |
| func (*AtomGroup) Class() binary.Class { |
| return (*binaryClassAtomGroup)(nil) |
| } |
| func doEncodeAtomGroup(e binary.Encoder, o *AtomGroup) error { |
| if err := e.String(o.Name); err != nil { |
| return err |
| } |
| if err := e.Value(&o.Range); err != nil { |
| return err |
| } |
| if err := e.Uint32(uint32(len(o.SubGroups))); err != nil { |
| return err |
| } |
| for i := range o.SubGroups { |
| if err := e.Value(&o.SubGroups[i]); err != nil { |
| return err |
| } |
| } |
| return nil |
| } |
| func doDecodeAtomGroup(d binary.Decoder, o *AtomGroup) error { |
| if obj, err := d.String(); err != nil { |
| return err |
| } else { |
| o.Name = string(obj) |
| } |
| if err := d.Value(&o.Range); err != nil { |
| return err |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.SubGroups = make(AtomGroupArray, count) |
| for i := range o.SubGroups { |
| if err := d.Value(&o.SubGroups[i]); err != nil { |
| return err |
| } |
| } |
| } |
| return nil |
| } |
| func doSkipAtomGroup(d binary.Decoder) error { |
| if err := d.SkipString(); err != nil { |
| return err |
| } |
| if err := d.SkipValue((*AtomRange)(nil)); err != nil { |
| return err |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| for i := uint32(0); i < count; i++ { |
| if err := d.SkipValue((*AtomGroup)(nil)); err != nil { |
| return err |
| } |
| } |
| } |
| return nil |
| } |
| func (*binaryClassAtomGroup) ID() binary.ID { return binaryIDAtomGroup } |
| func (*binaryClassAtomGroup) New() binary.Object { return &AtomGroup{} } |
| func (*binaryClassAtomGroup) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeAtomGroup(e, obj.(*AtomGroup)) |
| } |
| func (*binaryClassAtomGroup) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &AtomGroup{} |
| return obj, doDecodeAtomGroup(d, obj) |
| } |
| func (*binaryClassAtomGroup) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeAtomGroup(d, obj.(*AtomGroup)) |
| } |
| func (*binaryClassAtomGroup) Skip(d binary.Decoder) error { return doSkipAtomGroup(d) } |
| func (*binaryClassAtomGroup) Schema() *schema.Class { return schemaAtomGroup } |
| |
| var schemaAtomGroup = &schema.Class{ |
| TypeID: binaryIDAtomGroup, |
| Name: "AtomGroup", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}}, |
| schema.Field{Declared: "Range", Type: &schema.Struct{Name: "AtomRange"}}, |
| schema.Field{Declared: "SubGroups", Type: &schema.Slice{Alias: "AtomGroupArray", ValueType: &schema.Struct{Name: "AtomGroup"}}}, |
| }, |
| } |
| |
| type binaryClassParameterInfo struct{} |
| |
| func (*ParameterInfo) Class() binary.Class { |
| return (*binaryClassParameterInfo)(nil) |
| } |
| func doEncodeParameterInfo(e binary.Encoder, o *ParameterInfo) error { |
| if err := e.String(o.Name); err != nil { |
| return err |
| } |
| if o.Type != nil { |
| if err := e.Object(o.Type); err != nil { |
| return err |
| } |
| } else if err := e.Object(nil); err != nil { |
| return err |
| } |
| if err := e.Bool(o.Out); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodeParameterInfo(d binary.Decoder, o *ParameterInfo) error { |
| if obj, err := d.String(); err != nil { |
| return err |
| } else { |
| o.Name = string(obj) |
| } |
| if obj, err := d.Object(); err != nil { |
| return err |
| } else if obj != nil { |
| o.Type = obj.(TypeInfo) |
| } else { |
| o.Type = nil |
| } |
| if obj, err := d.Bool(); err != nil { |
| return err |
| } else { |
| o.Out = bool(obj) |
| } |
| return nil |
| } |
| func doSkipParameterInfo(d binary.Decoder) error { |
| if err := d.SkipString(); err != nil { |
| return err |
| } |
| if _, err := d.SkipObject(); err != nil { |
| return err |
| } |
| if _, err := d.Bool(); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassParameterInfo) ID() binary.ID { return binaryIDParameterInfo } |
| func (*binaryClassParameterInfo) New() binary.Object { return &ParameterInfo{} } |
| func (*binaryClassParameterInfo) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeParameterInfo(e, obj.(*ParameterInfo)) |
| } |
| func (*binaryClassParameterInfo) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &ParameterInfo{} |
| return obj, doDecodeParameterInfo(d, obj) |
| } |
| func (*binaryClassParameterInfo) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeParameterInfo(d, obj.(*ParameterInfo)) |
| } |
| func (*binaryClassParameterInfo) Skip(d binary.Decoder) error { return doSkipParameterInfo(d) } |
| func (*binaryClassParameterInfo) Schema() *schema.Class { return schemaParameterInfo } |
| |
| var schemaParameterInfo = &schema.Class{ |
| TypeID: binaryIDParameterInfo, |
| Name: "ParameterInfo", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}}, |
| schema.Field{Declared: "Type", Type: &schema.Interface{Name: "TypeInfo"}}, |
| schema.Field{Declared: "Out", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, |
| }, |
| } |
| |
| type binaryClassAtomInfo struct{} |
| |
| func (*AtomInfo) Class() binary.Class { |
| return (*binaryClassAtomInfo)(nil) |
| } |
| func doEncodeAtomInfo(e binary.Encoder, o *AtomInfo) error { |
| if err := e.Value(&o.Api); err != nil { |
| return err |
| } |
| if err := e.Uint16(o.Type); err != nil { |
| return err |
| } |
| if err := e.String(o.Name); err != nil { |
| return err |
| } |
| if err := e.Uint32(uint32(len(o.Parameters))); err != nil { |
| return err |
| } |
| for i := range o.Parameters { |
| if err := e.Value(&o.Parameters[i]); err != nil { |
| return err |
| } |
| } |
| if err := e.Bool(o.IsCommand); err != nil { |
| return err |
| } |
| if err := e.Bool(o.IsDrawCall); err != nil { |
| return err |
| } |
| if err := e.Bool(o.IsEndOfFrame); err != nil { |
| return err |
| } |
| if err := e.String(o.DocumentationUrl); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodeAtomInfo(d binary.Decoder, o *AtomInfo) error { |
| if err := d.Value(&o.Api); err != nil { |
| return err |
| } |
| if obj, err := d.Uint16(); err != nil { |
| return err |
| } else { |
| o.Type = uint16(obj) |
| } |
| if obj, err := d.String(); err != nil { |
| return err |
| } else { |
| o.Name = string(obj) |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.Parameters = make(ParameterInfoArray, count) |
| for i := range o.Parameters { |
| if err := d.Value(&o.Parameters[i]); err != nil { |
| return err |
| } |
| } |
| } |
| if obj, err := d.Bool(); err != nil { |
| return err |
| } else { |
| o.IsCommand = bool(obj) |
| } |
| if obj, err := d.Bool(); err != nil { |
| return err |
| } else { |
| o.IsDrawCall = bool(obj) |
| } |
| if obj, err := d.Bool(); err != nil { |
| return err |
| } else { |
| o.IsEndOfFrame = bool(obj) |
| } |
| if obj, err := d.String(); err != nil { |
| return err |
| } else { |
| o.DocumentationUrl = string(obj) |
| } |
| return nil |
| } |
| func doSkipAtomInfo(d binary.Decoder) error { |
| if err := d.SkipValue((*ApiId)(nil)); err != nil { |
| return err |
| } |
| if _, err := d.Uint16(); err != nil { |
| return err |
| } |
| if err := d.SkipString(); err != nil { |
| return err |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| for i := uint32(0); i < count; i++ { |
| if err := d.SkipValue((*ParameterInfo)(nil)); err != nil { |
| return err |
| } |
| } |
| } |
| if _, err := d.Bool(); err != nil { |
| return err |
| } |
| if _, err := d.Bool(); err != nil { |
| return err |
| } |
| if _, err := d.Bool(); err != nil { |
| return err |
| } |
| if err := d.SkipString(); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassAtomInfo) ID() binary.ID { return binaryIDAtomInfo } |
| func (*binaryClassAtomInfo) New() binary.Object { return &AtomInfo{} } |
| func (*binaryClassAtomInfo) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeAtomInfo(e, obj.(*AtomInfo)) |
| } |
| func (*binaryClassAtomInfo) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &AtomInfo{} |
| return obj, doDecodeAtomInfo(d, obj) |
| } |
| func (*binaryClassAtomInfo) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeAtomInfo(d, obj.(*AtomInfo)) |
| } |
| func (*binaryClassAtomInfo) Skip(d binary.Decoder) error { return doSkipAtomInfo(d) } |
| func (*binaryClassAtomInfo) Schema() *schema.Class { return schemaAtomInfo } |
| |
| var schemaAtomInfo = &schema.Class{ |
| TypeID: binaryIDAtomInfo, |
| Name: "AtomInfo", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "Api", Type: &schema.Struct{Name: "ApiId"}}, |
| schema.Field{Declared: "Type", Type: &schema.Primitive{Name: "uint16", Method: schema.Uint16}}, |
| schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}}, |
| schema.Field{Declared: "Parameters", Type: &schema.Slice{Alias: "ParameterInfoArray", ValueType: &schema.Struct{Name: "ParameterInfo"}}}, |
| schema.Field{Declared: "IsCommand", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, |
| schema.Field{Declared: "IsDrawCall", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, |
| schema.Field{Declared: "IsEndOfFrame", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, |
| schema.Field{Declared: "DocumentationUrl", Type: &schema.Primitive{Name: "string", Method: schema.String}}, |
| }, |
| } |
| |
| type binaryClassAtomRangeTimer struct{} |
| |
| func (*AtomRangeTimer) Class() binary.Class { |
| return (*binaryClassAtomRangeTimer)(nil) |
| } |
| func doEncodeAtomRangeTimer(e binary.Encoder, o *AtomRangeTimer) error { |
| if err := e.Uint64(o.FromAtomId); err != nil { |
| return err |
| } |
| if err := e.Uint64(o.ToAtomId); err != nil { |
| return err |
| } |
| if err := e.Uint64(o.Nanoseconds); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodeAtomRangeTimer(d binary.Decoder, o *AtomRangeTimer) error { |
| if obj, err := d.Uint64(); err != nil { |
| return err |
| } else { |
| o.FromAtomId = uint64(obj) |
| } |
| if obj, err := d.Uint64(); err != nil { |
| return err |
| } else { |
| o.ToAtomId = uint64(obj) |
| } |
| if obj, err := d.Uint64(); err != nil { |
| return err |
| } else { |
| o.Nanoseconds = uint64(obj) |
| } |
| return nil |
| } |
| func doSkipAtomRangeTimer(d binary.Decoder) error { |
| if _, err := d.Uint64(); err != nil { |
| return err |
| } |
| if _, err := d.Uint64(); err != nil { |
| return err |
| } |
| if _, err := d.Uint64(); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassAtomRangeTimer) ID() binary.ID { return binaryIDAtomRangeTimer } |
| func (*binaryClassAtomRangeTimer) New() binary.Object { return &AtomRangeTimer{} } |
| func (*binaryClassAtomRangeTimer) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeAtomRangeTimer(e, obj.(*AtomRangeTimer)) |
| } |
| func (*binaryClassAtomRangeTimer) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &AtomRangeTimer{} |
| return obj, doDecodeAtomRangeTimer(d, obj) |
| } |
| func (*binaryClassAtomRangeTimer) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeAtomRangeTimer(d, obj.(*AtomRangeTimer)) |
| } |
| func (*binaryClassAtomRangeTimer) Skip(d binary.Decoder) error { return doSkipAtomRangeTimer(d) } |
| func (*binaryClassAtomRangeTimer) Schema() *schema.Class { return schemaAtomRangeTimer } |
| |
| var schemaAtomRangeTimer = &schema.Class{ |
| TypeID: binaryIDAtomRangeTimer, |
| Name: "AtomRangeTimer", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "FromAtomId", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}}, |
| schema.Field{Declared: "ToAtomId", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}}, |
| schema.Field{Declared: "Nanoseconds", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}}, |
| }, |
| } |
| |
| type binaryClassAtomStream struct{} |
| |
| func (*AtomStream) Class() binary.Class { |
| return (*binaryClassAtomStream)(nil) |
| } |
| func doEncodeAtomStream(e binary.Encoder, o *AtomStream) error { |
| if err := e.Uint32(uint32(len(o.Data))); err != nil { |
| return err |
| } |
| if err := e.Data(o.Data); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodeAtomStream(d binary.Decoder, o *AtomStream) error { |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.Data = make(U8Array, count) |
| if err := d.Data(o.Data); err != nil { |
| return err |
| } |
| } |
| return nil |
| } |
| func doSkipAtomStream(d binary.Decoder) error { |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| if err := d.Skip(count); err != nil { |
| return err |
| } |
| } |
| return nil |
| } |
| func (*binaryClassAtomStream) ID() binary.ID { return binaryIDAtomStream } |
| func (*binaryClassAtomStream) New() binary.Object { return &AtomStream{} } |
| func (*binaryClassAtomStream) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeAtomStream(e, obj.(*AtomStream)) |
| } |
| func (*binaryClassAtomStream) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &AtomStream{} |
| return obj, doDecodeAtomStream(d, obj) |
| } |
| func (*binaryClassAtomStream) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeAtomStream(d, obj.(*AtomStream)) |
| } |
| func (*binaryClassAtomStream) Skip(d binary.Decoder) error { return doSkipAtomStream(d) } |
| func (*binaryClassAtomStream) Schema() *schema.Class { return schemaAtomStream } |
| |
| var schemaAtomStream = &schema.Class{ |
| TypeID: binaryIDAtomStream, |
| Name: "AtomStream", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "Data", Type: &schema.Slice{Alias: "U8Array", ValueType: &schema.Primitive{Name: "uint8", Method: schema.Uint8}}}, |
| }, |
| } |
| |
| type binaryClassAtomStreamId struct{} |
| |
| func (*AtomStreamId) Class() binary.Class { |
| return (*binaryClassAtomStreamId)(nil) |
| } |
| func doEncodeAtomStreamId(e binary.Encoder, o *AtomStreamId) error { |
| if err := e.ID(o.ID); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodeAtomStreamId(d binary.Decoder, o *AtomStreamId) error { |
| if obj, err := d.ID(); err != nil { |
| return err |
| } else { |
| o.ID = binary.ID(obj) |
| } |
| return nil |
| } |
| func doSkipAtomStreamId(d binary.Decoder) error { |
| if err := d.SkipID(); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassAtomStreamId) ID() binary.ID { return binaryIDAtomStreamId } |
| func (*binaryClassAtomStreamId) New() binary.Object { return &AtomStreamId{} } |
| func (*binaryClassAtomStreamId) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeAtomStreamId(e, obj.(*AtomStreamId)) |
| } |
| func (*binaryClassAtomStreamId) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &AtomStreamId{} |
| return obj, doDecodeAtomStreamId(d, obj) |
| } |
| func (*binaryClassAtomStreamId) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeAtomStreamId(d, obj.(*AtomStreamId)) |
| } |
| func (*binaryClassAtomStreamId) Skip(d binary.Decoder) error { return doSkipAtomStreamId(d) } |
| func (*binaryClassAtomStreamId) Schema() *schema.Class { return schemaAtomStreamId } |
| |
| var schemaAtomStreamId = &schema.Class{ |
| TypeID: binaryIDAtomStreamId, |
| Name: "AtomStreamId", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "ID", Type: &schema.Primitive{Name: "binary.ID", Method: schema.ID}}, |
| }, |
| } |
| |
| type binaryClassAtomTimer struct{} |
| |
| func (*AtomTimer) Class() binary.Class { |
| return (*binaryClassAtomTimer)(nil) |
| } |
| func doEncodeAtomTimer(e binary.Encoder, o *AtomTimer) error { |
| if err := e.Uint64(o.AtomId); err != nil { |
| return err |
| } |
| if err := e.Uint64(o.Nanoseconds); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodeAtomTimer(d binary.Decoder, o *AtomTimer) error { |
| if obj, err := d.Uint64(); err != nil { |
| return err |
| } else { |
| o.AtomId = uint64(obj) |
| } |
| if obj, err := d.Uint64(); err != nil { |
| return err |
| } else { |
| o.Nanoseconds = uint64(obj) |
| } |
| return nil |
| } |
| func doSkipAtomTimer(d binary.Decoder) error { |
| if _, err := d.Uint64(); err != nil { |
| return err |
| } |
| if _, err := d.Uint64(); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassAtomTimer) ID() binary.ID { return binaryIDAtomTimer } |
| func (*binaryClassAtomTimer) New() binary.Object { return &AtomTimer{} } |
| func (*binaryClassAtomTimer) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeAtomTimer(e, obj.(*AtomTimer)) |
| } |
| func (*binaryClassAtomTimer) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &AtomTimer{} |
| return obj, doDecodeAtomTimer(d, obj) |
| } |
| func (*binaryClassAtomTimer) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeAtomTimer(d, obj.(*AtomTimer)) |
| } |
| func (*binaryClassAtomTimer) Skip(d binary.Decoder) error { return doSkipAtomTimer(d) } |
| func (*binaryClassAtomTimer) Schema() *schema.Class { return schemaAtomTimer } |
| |
| var schemaAtomTimer = &schema.Class{ |
| TypeID: binaryIDAtomTimer, |
| Name: "AtomTimer", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "AtomId", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}}, |
| schema.Field{Declared: "Nanoseconds", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}}, |
| }, |
| } |
| |
| type binaryClassBinary struct{} |
| |
| func (*Binary) Class() binary.Class { |
| return (*binaryClassBinary)(nil) |
| } |
| func doEncodeBinary(e binary.Encoder, o *Binary) error { |
| if err := e.Uint32(uint32(len(o.Data))); err != nil { |
| return err |
| } |
| if err := e.Data(o.Data); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodeBinary(d binary.Decoder, o *Binary) error { |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.Data = make(U8Array, count) |
| if err := d.Data(o.Data); err != nil { |
| return err |
| } |
| } |
| return nil |
| } |
| func doSkipBinary(d binary.Decoder) error { |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| if err := d.Skip(count); err != nil { |
| return err |
| } |
| } |
| return nil |
| } |
| func (*binaryClassBinary) ID() binary.ID { return binaryIDBinary } |
| func (*binaryClassBinary) New() binary.Object { return &Binary{} } |
| func (*binaryClassBinary) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeBinary(e, obj.(*Binary)) |
| } |
| func (*binaryClassBinary) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &Binary{} |
| return obj, doDecodeBinary(d, obj) |
| } |
| func (*binaryClassBinary) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeBinary(d, obj.(*Binary)) |
| } |
| func (*binaryClassBinary) Skip(d binary.Decoder) error { return doSkipBinary(d) } |
| func (*binaryClassBinary) Schema() *schema.Class { return schemaBinary } |
| |
| var schemaBinary = &schema.Class{ |
| TypeID: binaryIDBinary, |
| Name: "Binary", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "Data", Type: &schema.Slice{Alias: "U8Array", ValueType: &schema.Primitive{Name: "uint8", Method: schema.Uint8}}}, |
| }, |
| } |
| |
| type binaryClassBinaryId struct{} |
| |
| func (*BinaryId) Class() binary.Class { |
| return (*binaryClassBinaryId)(nil) |
| } |
| func doEncodeBinaryId(e binary.Encoder, o *BinaryId) error { |
| if err := e.ID(o.ID); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodeBinaryId(d binary.Decoder, o *BinaryId) error { |
| if obj, err := d.ID(); err != nil { |
| return err |
| } else { |
| o.ID = binary.ID(obj) |
| } |
| return nil |
| } |
| func doSkipBinaryId(d binary.Decoder) error { |
| if err := d.SkipID(); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassBinaryId) ID() binary.ID { return binaryIDBinaryId } |
| func (*binaryClassBinaryId) New() binary.Object { return &BinaryId{} } |
| func (*binaryClassBinaryId) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeBinaryId(e, obj.(*BinaryId)) |
| } |
| func (*binaryClassBinaryId) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &BinaryId{} |
| return obj, doDecodeBinaryId(d, obj) |
| } |
| func (*binaryClassBinaryId) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeBinaryId(d, obj.(*BinaryId)) |
| } |
| func (*binaryClassBinaryId) Skip(d binary.Decoder) error { return doSkipBinaryId(d) } |
| func (*binaryClassBinaryId) Schema() *schema.Class { return schemaBinaryId } |
| |
| var schemaBinaryId = &schema.Class{ |
| TypeID: binaryIDBinaryId, |
| Name: "BinaryId", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "ID", Type: &schema.Primitive{Name: "binary.ID", Method: schema.ID}}, |
| }, |
| } |
| |
| type binaryClassSchemaId struct{} |
| |
| func (*SchemaId) Class() binary.Class { |
| return (*binaryClassSchemaId)(nil) |
| } |
| func doEncodeSchemaId(e binary.Encoder, o *SchemaId) error { |
| if err := e.ID(o.ID); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodeSchemaId(d binary.Decoder, o *SchemaId) error { |
| if obj, err := d.ID(); err != nil { |
| return err |
| } else { |
| o.ID = binary.ID(obj) |
| } |
| return nil |
| } |
| func doSkipSchemaId(d binary.Decoder) error { |
| if err := d.SkipID(); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassSchemaId) ID() binary.ID { return binaryIDSchemaId } |
| func (*binaryClassSchemaId) New() binary.Object { return &SchemaId{} } |
| func (*binaryClassSchemaId) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeSchemaId(e, obj.(*SchemaId)) |
| } |
| func (*binaryClassSchemaId) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &SchemaId{} |
| return obj, doDecodeSchemaId(d, obj) |
| } |
| func (*binaryClassSchemaId) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeSchemaId(d, obj.(*SchemaId)) |
| } |
| func (*binaryClassSchemaId) Skip(d binary.Decoder) error { return doSkipSchemaId(d) } |
| func (*binaryClassSchemaId) Schema() *schema.Class { return schemaSchemaId } |
| |
| var schemaSchemaId = &schema.Class{ |
| TypeID: binaryIDSchemaId, |
| Name: "SchemaId", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "ID", Type: &schema.Primitive{Name: "binary.ID", Method: schema.ID}}, |
| }, |
| } |
| |
| type binaryClassCapture struct{} |
| |
| func (*Capture) Class() binary.Class { |
| return (*binaryClassCapture)(nil) |
| } |
| func doEncodeCapture(e binary.Encoder, o *Capture) error { |
| if err := e.String(o.Name); err != nil { |
| return err |
| } |
| if err := e.Value(&o.Atoms); err != nil { |
| return err |
| } |
| if err := e.Uint32(uint32(len(o.Apis))); err != nil { |
| return err |
| } |
| for i := range o.Apis { |
| if err := e.Value(&o.Apis[i]); err != nil { |
| return err |
| } |
| } |
| if err := e.Value(&o.Schema); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodeCapture(d binary.Decoder, o *Capture) error { |
| if obj, err := d.String(); err != nil { |
| return err |
| } else { |
| o.Name = string(obj) |
| } |
| if err := d.Value(&o.Atoms); err != nil { |
| return err |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.Apis = make(ApiIdArray, count) |
| for i := range o.Apis { |
| if err := d.Value(&o.Apis[i]); err != nil { |
| return err |
| } |
| } |
| } |
| if err := d.Value(&o.Schema); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipCapture(d binary.Decoder) error { |
| if err := d.SkipString(); err != nil { |
| return err |
| } |
| if err := d.SkipValue((*AtomStreamId)(nil)); err != nil { |
| return err |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| for i := uint32(0); i < count; i++ { |
| if err := d.SkipValue((*ApiId)(nil)); err != nil { |
| return err |
| } |
| } |
| } |
| if err := d.SkipValue((*SchemaId)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassCapture) ID() binary.ID { return binaryIDCapture } |
| func (*binaryClassCapture) New() binary.Object { return &Capture{} } |
| func (*binaryClassCapture) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeCapture(e, obj.(*Capture)) |
| } |
| func (*binaryClassCapture) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &Capture{} |
| return obj, doDecodeCapture(d, obj) |
| } |
| func (*binaryClassCapture) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeCapture(d, obj.(*Capture)) |
| } |
| func (*binaryClassCapture) Skip(d binary.Decoder) error { return doSkipCapture(d) } |
| func (*binaryClassCapture) Schema() *schema.Class { return schemaCapture } |
| |
| var schemaCapture = &schema.Class{ |
| TypeID: binaryIDCapture, |
| Name: "Capture", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}}, |
| schema.Field{Declared: "Atoms", Type: &schema.Struct{Name: "AtomStreamId"}}, |
| schema.Field{Declared: "Apis", Type: &schema.Slice{Alias: "ApiIdArray", ValueType: &schema.Struct{Name: "ApiId"}}}, |
| schema.Field{Declared: "Schema", Type: &schema.Struct{Name: "SchemaId"}}, |
| }, |
| } |
| |
| type binaryClassCaptureId struct{} |
| |
| func (*CaptureId) Class() binary.Class { |
| return (*binaryClassCaptureId)(nil) |
| } |
| func doEncodeCaptureId(e binary.Encoder, o *CaptureId) error { |
| if err := e.ID(o.ID); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodeCaptureId(d binary.Decoder, o *CaptureId) error { |
| if obj, err := d.ID(); err != nil { |
| return err |
| } else { |
| o.ID = binary.ID(obj) |
| } |
| return nil |
| } |
| func doSkipCaptureId(d binary.Decoder) error { |
| if err := d.SkipID(); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassCaptureId) ID() binary.ID { return binaryIDCaptureId } |
| func (*binaryClassCaptureId) New() binary.Object { return &CaptureId{} } |
| func (*binaryClassCaptureId) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeCaptureId(e, obj.(*CaptureId)) |
| } |
| func (*binaryClassCaptureId) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &CaptureId{} |
| return obj, doDecodeCaptureId(d, obj) |
| } |
| func (*binaryClassCaptureId) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeCaptureId(d, obj.(*CaptureId)) |
| } |
| func (*binaryClassCaptureId) Skip(d binary.Decoder) error { return doSkipCaptureId(d) } |
| func (*binaryClassCaptureId) Schema() *schema.Class { return schemaCaptureId } |
| |
| var schemaCaptureId = &schema.Class{ |
| TypeID: binaryIDCaptureId, |
| Name: "CaptureId", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "ID", Type: &schema.Primitive{Name: "binary.ID", Method: schema.ID}}, |
| }, |
| } |
| |
| type binaryClassClassInfo struct{} |
| |
| func (*ClassInfo) Class() binary.Class { |
| return (*binaryClassClassInfo)(nil) |
| } |
| func doEncodeClassInfo(e binary.Encoder, o *ClassInfo) error { |
| if err := e.String(o.Name); err != nil { |
| return err |
| } |
| if err := e.Int32(int32(o.Kind)); err != nil { |
| return err |
| } |
| if err := e.Uint32(uint32(len(o.Fields))); err != nil { |
| return err |
| } |
| for i := range o.Fields { |
| if o.Fields[i] != nil { |
| if err := e.Object(o.Fields[i]); err != nil { |
| return err |
| } |
| } else if err := e.Object(nil); err != nil { |
| return err |
| } |
| } |
| if err := e.Uint32(uint32(len(o.Extends))); err != nil { |
| return err |
| } |
| for i := range o.Extends { |
| if o.Extends[i] != nil { |
| if err := e.Object(o.Extends[i]); err != nil { |
| return err |
| } |
| } else if err := e.Object(nil); err != nil { |
| return err |
| } |
| } |
| return nil |
| } |
| func doDecodeClassInfo(d binary.Decoder, o *ClassInfo) error { |
| if obj, err := d.String(); err != nil { |
| return err |
| } else { |
| o.Name = string(obj) |
| } |
| if obj, err := d.Int32(); err != nil { |
| return err |
| } else { |
| o.Kind = TypeKind(obj) |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.Fields = make(FieldInfoPtrArray, count) |
| for i := range o.Fields { |
| if obj, err := d.Object(); err != nil { |
| return err |
| } else if obj != nil { |
| o.Fields[i] = obj.(*FieldInfo) |
| } else { |
| o.Fields[i] = nil |
| } |
| } |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.Extends = make(ClassInfoPtrArray, count) |
| for i := range o.Extends { |
| if obj, err := d.Object(); err != nil { |
| return err |
| } else if obj != nil { |
| o.Extends[i] = obj.(*ClassInfo) |
| } else { |
| o.Extends[i] = nil |
| } |
| } |
| } |
| return nil |
| } |
| func doSkipClassInfo(d binary.Decoder) error { |
| if err := d.SkipString(); err != nil { |
| return err |
| } |
| if _, err := d.Int32(); err != nil { |
| return err |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| for i := uint32(0); i < count; i++ { |
| if _, err := d.SkipObject(); err != nil { |
| return err |
| } |
| } |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| for i := uint32(0); i < count; i++ { |
| if _, err := d.SkipObject(); err != nil { |
| return err |
| } |
| } |
| } |
| return nil |
| } |
| func (*binaryClassClassInfo) ID() binary.ID { return binaryIDClassInfo } |
| func (*binaryClassClassInfo) New() binary.Object { return &ClassInfo{} } |
| func (*binaryClassClassInfo) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeClassInfo(e, obj.(*ClassInfo)) |
| } |
| func (*binaryClassClassInfo) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &ClassInfo{} |
| return obj, doDecodeClassInfo(d, obj) |
| } |
| func (*binaryClassClassInfo) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeClassInfo(d, obj.(*ClassInfo)) |
| } |
| func (*binaryClassClassInfo) Skip(d binary.Decoder) error { return doSkipClassInfo(d) } |
| func (*binaryClassClassInfo) Schema() *schema.Class { return schemaClassInfo } |
| |
| var schemaClassInfo = &schema.Class{ |
| TypeID: binaryIDClassInfo, |
| Name: "ClassInfo", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}}, |
| schema.Field{Declared: "Kind", Type: &schema.Primitive{Name: "TypeKind", Method: schema.Int32}}, |
| schema.Field{Declared: "Fields", Type: &schema.Slice{Alias: "FieldInfoPtrArray", ValueType: &schema.Pointer{Type: &schema.Struct{Name: "FieldInfo"}}}}, |
| schema.Field{Declared: "Extends", Type: &schema.Slice{Alias: "ClassInfoPtrArray", ValueType: &schema.Pointer{Type: &schema.Struct{Name: "ClassInfo"}}}}, |
| }, |
| } |
| |
| type binaryClassDevice struct{} |
| |
| func (*Device) Class() binary.Class { |
| return (*binaryClassDevice)(nil) |
| } |
| func doEncodeDevice(e binary.Encoder, o *Device) error { |
| if err := e.String(o.Name); err != nil { |
| return err |
| } |
| if err := e.String(o.Model); err != nil { |
| return err |
| } |
| if err := e.String(o.OS); err != nil { |
| return err |
| } |
| if err := e.Uint8(o.PointerSize); err != nil { |
| return err |
| } |
| if err := e.Uint8(o.PointerAlignment); err != nil { |
| return err |
| } |
| if err := e.Uint64(o.MaxMemorySize); err != nil { |
| return err |
| } |
| if err := e.Bool(o.RequiresShaderPatching); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodeDevice(d binary.Decoder, o *Device) error { |
| if obj, err := d.String(); err != nil { |
| return err |
| } else { |
| o.Name = string(obj) |
| } |
| if obj, err := d.String(); err != nil { |
| return err |
| } else { |
| o.Model = string(obj) |
| } |
| if obj, err := d.String(); err != nil { |
| return err |
| } else { |
| o.OS = string(obj) |
| } |
| if obj, err := d.Uint8(); err != nil { |
| return err |
| } else { |
| o.PointerSize = uint8(obj) |
| } |
| if obj, err := d.Uint8(); err != nil { |
| return err |
| } else { |
| o.PointerAlignment = uint8(obj) |
| } |
| if obj, err := d.Uint64(); err != nil { |
| return err |
| } else { |
| o.MaxMemorySize = uint64(obj) |
| } |
| if obj, err := d.Bool(); err != nil { |
| return err |
| } else { |
| o.RequiresShaderPatching = bool(obj) |
| } |
| return nil |
| } |
| func doSkipDevice(d binary.Decoder) error { |
| if err := d.SkipString(); err != nil { |
| return err |
| } |
| if err := d.SkipString(); err != nil { |
| return err |
| } |
| if err := d.SkipString(); err != nil { |
| return err |
| } |
| if _, err := d.Uint8(); err != nil { |
| return err |
| } |
| if _, err := d.Uint8(); err != nil { |
| return err |
| } |
| if _, err := d.Uint64(); err != nil { |
| return err |
| } |
| if _, err := d.Bool(); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassDevice) ID() binary.ID { return binaryIDDevice } |
| func (*binaryClassDevice) New() binary.Object { return &Device{} } |
| func (*binaryClassDevice) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeDevice(e, obj.(*Device)) |
| } |
| func (*binaryClassDevice) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &Device{} |
| return obj, doDecodeDevice(d, obj) |
| } |
| func (*binaryClassDevice) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeDevice(d, obj.(*Device)) |
| } |
| func (*binaryClassDevice) Skip(d binary.Decoder) error { return doSkipDevice(d) } |
| func (*binaryClassDevice) Schema() *schema.Class { return schemaDevice } |
| |
| var schemaDevice = &schema.Class{ |
| TypeID: binaryIDDevice, |
| Name: "Device", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}}, |
| schema.Field{Declared: "Model", Type: &schema.Primitive{Name: "string", Method: schema.String}}, |
| schema.Field{Declared: "OS", Type: &schema.Primitive{Name: "string", Method: schema.String}}, |
| schema.Field{Declared: "PointerSize", Type: &schema.Primitive{Name: "uint8", Method: schema.Uint8}}, |
| schema.Field{Declared: "PointerAlignment", Type: &schema.Primitive{Name: "uint8", Method: schema.Uint8}}, |
| schema.Field{Declared: "MaxMemorySize", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}}, |
| schema.Field{Declared: "RequiresShaderPatching", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, |
| }, |
| } |
| |
| type binaryClassDeviceId struct{} |
| |
| func (*DeviceId) Class() binary.Class { |
| return (*binaryClassDeviceId)(nil) |
| } |
| func doEncodeDeviceId(e binary.Encoder, o *DeviceId) error { |
| if err := e.ID(o.ID); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodeDeviceId(d binary.Decoder, o *DeviceId) error { |
| if obj, err := d.ID(); err != nil { |
| return err |
| } else { |
| o.ID = binary.ID(obj) |
| } |
| return nil |
| } |
| func doSkipDeviceId(d binary.Decoder) error { |
| if err := d.SkipID(); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassDeviceId) ID() binary.ID { return binaryIDDeviceId } |
| func (*binaryClassDeviceId) New() binary.Object { return &DeviceId{} } |
| func (*binaryClassDeviceId) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeDeviceId(e, obj.(*DeviceId)) |
| } |
| func (*binaryClassDeviceId) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &DeviceId{} |
| return obj, doDecodeDeviceId(d, obj) |
| } |
| func (*binaryClassDeviceId) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeDeviceId(d, obj.(*DeviceId)) |
| } |
| func (*binaryClassDeviceId) Skip(d binary.Decoder) error { return doSkipDeviceId(d) } |
| func (*binaryClassDeviceId) Schema() *schema.Class { return schemaDeviceId } |
| |
| var schemaDeviceId = &schema.Class{ |
| TypeID: binaryIDDeviceId, |
| Name: "DeviceId", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "ID", Type: &schema.Primitive{Name: "binary.ID", Method: schema.ID}}, |
| }, |
| } |
| |
| type binaryClassEnumEntry struct{} |
| |
| func (*EnumEntry) Class() binary.Class { |
| return (*binaryClassEnumEntry)(nil) |
| } |
| func doEncodeEnumEntry(e binary.Encoder, o *EnumEntry) error { |
| if err := e.String(o.Name); err != nil { |
| return err |
| } |
| if err := e.Uint32(o.Value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodeEnumEntry(d binary.Decoder, o *EnumEntry) error { |
| if obj, err := d.String(); err != nil { |
| return err |
| } else { |
| o.Name = string(obj) |
| } |
| if obj, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.Value = uint32(obj) |
| } |
| return nil |
| } |
| func doSkipEnumEntry(d binary.Decoder) error { |
| if err := d.SkipString(); err != nil { |
| return err |
| } |
| if _, err := d.Uint32(); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassEnumEntry) ID() binary.ID { return binaryIDEnumEntry } |
| func (*binaryClassEnumEntry) New() binary.Object { return &EnumEntry{} } |
| func (*binaryClassEnumEntry) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeEnumEntry(e, obj.(*EnumEntry)) |
| } |
| func (*binaryClassEnumEntry) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &EnumEntry{} |
| return obj, doDecodeEnumEntry(d, obj) |
| } |
| func (*binaryClassEnumEntry) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeEnumEntry(d, obj.(*EnumEntry)) |
| } |
| func (*binaryClassEnumEntry) Skip(d binary.Decoder) error { return doSkipEnumEntry(d) } |
| func (*binaryClassEnumEntry) Schema() *schema.Class { return schemaEnumEntry } |
| |
| var schemaEnumEntry = &schema.Class{ |
| TypeID: binaryIDEnumEntry, |
| Name: "EnumEntry", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}}, |
| schema.Field{Declared: "Value", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}}, |
| }, |
| } |
| |
| type binaryClassEnumInfo struct{} |
| |
| func (*EnumInfo) Class() binary.Class { |
| return (*binaryClassEnumInfo)(nil) |
| } |
| func doEncodeEnumInfo(e binary.Encoder, o *EnumInfo) error { |
| if err := e.String(o.Name); err != nil { |
| return err |
| } |
| if err := e.Int32(int32(o.Kind)); err != nil { |
| return err |
| } |
| if err := e.Uint32(uint32(len(o.Entries))); err != nil { |
| return err |
| } |
| for i := range o.Entries { |
| if err := e.Value(&o.Entries[i]); err != nil { |
| return err |
| } |
| } |
| if err := e.Uint32(uint32(len(o.Extends))); err != nil { |
| return err |
| } |
| for i := range o.Extends { |
| if o.Extends[i] != nil { |
| if err := e.Object(o.Extends[i]); err != nil { |
| return err |
| } |
| } else if err := e.Object(nil); err != nil { |
| return err |
| } |
| } |
| return nil |
| } |
| func doDecodeEnumInfo(d binary.Decoder, o *EnumInfo) error { |
| if obj, err := d.String(); err != nil { |
| return err |
| } else { |
| o.Name = string(obj) |
| } |
| if obj, err := d.Int32(); err != nil { |
| return err |
| } else { |
| o.Kind = TypeKind(obj) |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.Entries = make(EnumEntryArray, count) |
| for i := range o.Entries { |
| if err := d.Value(&o.Entries[i]); err != nil { |
| return err |
| } |
| } |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.Extends = make(EnumInfoPtrArray, count) |
| for i := range o.Extends { |
| if obj, err := d.Object(); err != nil { |
| return err |
| } else if obj != nil { |
| o.Extends[i] = obj.(*EnumInfo) |
| } else { |
| o.Extends[i] = nil |
| } |
| } |
| } |
| return nil |
| } |
| func doSkipEnumInfo(d binary.Decoder) error { |
| if err := d.SkipString(); err != nil { |
| return err |
| } |
| if _, err := d.Int32(); err != nil { |
| return err |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| for i := uint32(0); i < count; i++ { |
| if err := d.SkipValue((*EnumEntry)(nil)); err != nil { |
| return err |
| } |
| } |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| for i := uint32(0); i < count; i++ { |
| if _, err := d.SkipObject(); err != nil { |
| return err |
| } |
| } |
| } |
| return nil |
| } |
| func (*binaryClassEnumInfo) ID() binary.ID { return binaryIDEnumInfo } |
| func (*binaryClassEnumInfo) New() binary.Object { return &EnumInfo{} } |
| func (*binaryClassEnumInfo) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeEnumInfo(e, obj.(*EnumInfo)) |
| } |
| func (*binaryClassEnumInfo) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &EnumInfo{} |
| return obj, doDecodeEnumInfo(d, obj) |
| } |
| func (*binaryClassEnumInfo) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeEnumInfo(d, obj.(*EnumInfo)) |
| } |
| func (*binaryClassEnumInfo) Skip(d binary.Decoder) error { return doSkipEnumInfo(d) } |
| func (*binaryClassEnumInfo) Schema() *schema.Class { return schemaEnumInfo } |
| |
| var schemaEnumInfo = &schema.Class{ |
| TypeID: binaryIDEnumInfo, |
| Name: "EnumInfo", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}}, |
| schema.Field{Declared: "Kind", Type: &schema.Primitive{Name: "TypeKind", Method: schema.Int32}}, |
| schema.Field{Declared: "Entries", Type: &schema.Slice{Alias: "EnumEntryArray", ValueType: &schema.Struct{Name: "EnumEntry"}}}, |
| schema.Field{Declared: "Extends", Type: &schema.Slice{Alias: "EnumInfoPtrArray", ValueType: &schema.Pointer{Type: &schema.Struct{Name: "EnumInfo"}}}}, |
| }, |
| } |
| |
| type binaryClassHierarchy struct{} |
| |
| func (*Hierarchy) Class() binary.Class { |
| return (*binaryClassHierarchy)(nil) |
| } |
| func doEncodeHierarchy(e binary.Encoder, o *Hierarchy) error { |
| if err := e.Value(&o.Root); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodeHierarchy(d binary.Decoder, o *Hierarchy) error { |
| if err := d.Value(&o.Root); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipHierarchy(d binary.Decoder) error { |
| if err := d.SkipValue((*AtomGroup)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassHierarchy) ID() binary.ID { return binaryIDHierarchy } |
| func (*binaryClassHierarchy) New() binary.Object { return &Hierarchy{} } |
| func (*binaryClassHierarchy) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeHierarchy(e, obj.(*Hierarchy)) |
| } |
| func (*binaryClassHierarchy) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &Hierarchy{} |
| return obj, doDecodeHierarchy(d, obj) |
| } |
| func (*binaryClassHierarchy) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeHierarchy(d, obj.(*Hierarchy)) |
| } |
| func (*binaryClassHierarchy) Skip(d binary.Decoder) error { return doSkipHierarchy(d) } |
| func (*binaryClassHierarchy) Schema() *schema.Class { return schemaHierarchy } |
| |
| var schemaHierarchy = &schema.Class{ |
| TypeID: binaryIDHierarchy, |
| Name: "Hierarchy", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "Root", Type: &schema.Struct{Name: "AtomGroup"}}, |
| }, |
| } |
| |
| type binaryClassHierarchyId struct{} |
| |
| func (*HierarchyId) Class() binary.Class { |
| return (*binaryClassHierarchyId)(nil) |
| } |
| func doEncodeHierarchyId(e binary.Encoder, o *HierarchyId) error { |
| if err := e.ID(o.ID); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodeHierarchyId(d binary.Decoder, o *HierarchyId) error { |
| if obj, err := d.ID(); err != nil { |
| return err |
| } else { |
| o.ID = binary.ID(obj) |
| } |
| return nil |
| } |
| func doSkipHierarchyId(d binary.Decoder) error { |
| if err := d.SkipID(); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassHierarchyId) ID() binary.ID { return binaryIDHierarchyId } |
| func (*binaryClassHierarchyId) New() binary.Object { return &HierarchyId{} } |
| func (*binaryClassHierarchyId) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeHierarchyId(e, obj.(*HierarchyId)) |
| } |
| func (*binaryClassHierarchyId) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &HierarchyId{} |
| return obj, doDecodeHierarchyId(d, obj) |
| } |
| func (*binaryClassHierarchyId) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeHierarchyId(d, obj.(*HierarchyId)) |
| } |
| func (*binaryClassHierarchyId) Skip(d binary.Decoder) error { return doSkipHierarchyId(d) } |
| func (*binaryClassHierarchyId) Schema() *schema.Class { return schemaHierarchyId } |
| |
| var schemaHierarchyId = &schema.Class{ |
| TypeID: binaryIDHierarchyId, |
| Name: "HierarchyId", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "ID", Type: &schema.Primitive{Name: "binary.ID", Method: schema.ID}}, |
| }, |
| } |
| |
| type binaryClassImageInfo struct{} |
| |
| func (*ImageInfo) Class() binary.Class { |
| return (*binaryClassImageInfo)(nil) |
| } |
| func doEncodeImageInfo(e binary.Encoder, o *ImageInfo) error { |
| if err := e.Int32(int32(o.Format)); err != nil { |
| return err |
| } |
| if err := e.Uint32(o.Width); err != nil { |
| return err |
| } |
| if err := e.Uint32(o.Height); err != nil { |
| return err |
| } |
| if err := e.Value(&o.Data); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodeImageInfo(d binary.Decoder, o *ImageInfo) error { |
| if obj, err := d.Int32(); err != nil { |
| return err |
| } else { |
| o.Format = ImageFormat(obj) |
| } |
| if obj, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.Width = uint32(obj) |
| } |
| if obj, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.Height = uint32(obj) |
| } |
| if err := d.Value(&o.Data); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipImageInfo(d binary.Decoder) error { |
| if _, err := d.Int32(); err != nil { |
| return err |
| } |
| if _, err := d.Uint32(); err != nil { |
| return err |
| } |
| if _, err := d.Uint32(); err != nil { |
| return err |
| } |
| if err := d.SkipValue((*BinaryId)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassImageInfo) ID() binary.ID { return binaryIDImageInfo } |
| func (*binaryClassImageInfo) New() binary.Object { return &ImageInfo{} } |
| func (*binaryClassImageInfo) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeImageInfo(e, obj.(*ImageInfo)) |
| } |
| func (*binaryClassImageInfo) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &ImageInfo{} |
| return obj, doDecodeImageInfo(d, obj) |
| } |
| func (*binaryClassImageInfo) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeImageInfo(d, obj.(*ImageInfo)) |
| } |
| func (*binaryClassImageInfo) Skip(d binary.Decoder) error { return doSkipImageInfo(d) } |
| func (*binaryClassImageInfo) Schema() *schema.Class { return schemaImageInfo } |
| |
| var schemaImageInfo = &schema.Class{ |
| TypeID: binaryIDImageInfo, |
| Name: "ImageInfo", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "Format", Type: &schema.Primitive{Name: "ImageFormat", Method: schema.Int32}}, |
| schema.Field{Declared: "Width", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}}, |
| schema.Field{Declared: "Height", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}}, |
| schema.Field{Declared: "Data", Type: &schema.Struct{Name: "BinaryId"}}, |
| }, |
| } |
| |
| type binaryClassImageInfoId struct{} |
| |
| func (*ImageInfoId) Class() binary.Class { |
| return (*binaryClassImageInfoId)(nil) |
| } |
| func doEncodeImageInfoId(e binary.Encoder, o *ImageInfoId) error { |
| if err := e.ID(o.ID); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodeImageInfoId(d binary.Decoder, o *ImageInfoId) error { |
| if obj, err := d.ID(); err != nil { |
| return err |
| } else { |
| o.ID = binary.ID(obj) |
| } |
| return nil |
| } |
| func doSkipImageInfoId(d binary.Decoder) error { |
| if err := d.SkipID(); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassImageInfoId) ID() binary.ID { return binaryIDImageInfoId } |
| func (*binaryClassImageInfoId) New() binary.Object { return &ImageInfoId{} } |
| func (*binaryClassImageInfoId) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeImageInfoId(e, obj.(*ImageInfoId)) |
| } |
| func (*binaryClassImageInfoId) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &ImageInfoId{} |
| return obj, doDecodeImageInfoId(d, obj) |
| } |
| func (*binaryClassImageInfoId) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeImageInfoId(d, obj.(*ImageInfoId)) |
| } |
| func (*binaryClassImageInfoId) Skip(d binary.Decoder) error { return doSkipImageInfoId(d) } |
| func (*binaryClassImageInfoId) Schema() *schema.Class { return schemaImageInfoId } |
| |
| var schemaImageInfoId = &schema.Class{ |
| TypeID: binaryIDImageInfoId, |
| Name: "ImageInfoId", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "ID", Type: &schema.Primitive{Name: "binary.ID", Method: schema.ID}}, |
| }, |
| } |
| |
| type binaryClassMapInfo struct{} |
| |
| func (*MapInfo) Class() binary.Class { |
| return (*binaryClassMapInfo)(nil) |
| } |
| func doEncodeMapInfo(e binary.Encoder, o *MapInfo) error { |
| if err := e.String(o.Name); err != nil { |
| return err |
| } |
| if err := e.Int32(int32(o.Kind)); err != nil { |
| return err |
| } |
| if o.KeyType != nil { |
| if err := e.Object(o.KeyType); err != nil { |
| return err |
| } |
| } else if err := e.Object(nil); err != nil { |
| return err |
| } |
| if o.ValueType != nil { |
| if err := e.Object(o.ValueType); err != nil { |
| return err |
| } |
| } else if err := e.Object(nil); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodeMapInfo(d binary.Decoder, o *MapInfo) error { |
| if obj, err := d.String(); err != nil { |
| return err |
| } else { |
| o.Name = string(obj) |
| } |
| if obj, err := d.Int32(); err != nil { |
| return err |
| } else { |
| o.Kind = TypeKind(obj) |
| } |
| if obj, err := d.Object(); err != nil { |
| return err |
| } else if obj != nil { |
| o.KeyType = obj.(TypeInfo) |
| } else { |
| o.KeyType = nil |
| } |
| if obj, err := d.Object(); err != nil { |
| return err |
| } else if obj != nil { |
| o.ValueType = obj.(TypeInfo) |
| } else { |
| o.ValueType = nil |
| } |
| return nil |
| } |
| func doSkipMapInfo(d binary.Decoder) error { |
| if err := d.SkipString(); err != nil { |
| return err |
| } |
| if _, err := d.Int32(); err != nil { |
| return err |
| } |
| if _, err := d.SkipObject(); err != nil { |
| return err |
| } |
| if _, err := d.SkipObject(); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassMapInfo) ID() binary.ID { return binaryIDMapInfo } |
| func (*binaryClassMapInfo) New() binary.Object { return &MapInfo{} } |
| func (*binaryClassMapInfo) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeMapInfo(e, obj.(*MapInfo)) |
| } |
| func (*binaryClassMapInfo) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &MapInfo{} |
| return obj, doDecodeMapInfo(d, obj) |
| } |
| func (*binaryClassMapInfo) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeMapInfo(d, obj.(*MapInfo)) |
| } |
| func (*binaryClassMapInfo) Skip(d binary.Decoder) error { return doSkipMapInfo(d) } |
| func (*binaryClassMapInfo) Schema() *schema.Class { return schemaMapInfo } |
| |
| var schemaMapInfo = &schema.Class{ |
| TypeID: binaryIDMapInfo, |
| Name: "MapInfo", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}}, |
| schema.Field{Declared: "Kind", Type: &schema.Primitive{Name: "TypeKind", Method: schema.Int32}}, |
| schema.Field{Declared: "KeyType", Type: &schema.Interface{Name: "TypeInfo"}}, |
| schema.Field{Declared: "ValueType", Type: &schema.Interface{Name: "TypeInfo"}}, |
| }, |
| } |
| |
| type binaryClassMemoryRange struct{} |
| |
| func (*MemoryRange) Class() binary.Class { |
| return (*binaryClassMemoryRange)(nil) |
| } |
| func doEncodeMemoryRange(e binary.Encoder, o *MemoryRange) error { |
| if err := e.Uint64(o.Base); err != nil { |
| return err |
| } |
| if err := e.Uint64(o.Size); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodeMemoryRange(d binary.Decoder, o *MemoryRange) error { |
| if obj, err := d.Uint64(); err != nil { |
| return err |
| } else { |
| o.Base = uint64(obj) |
| } |
| if obj, err := d.Uint64(); err != nil { |
| return err |
| } else { |
| o.Size = uint64(obj) |
| } |
| return nil |
| } |
| func doSkipMemoryRange(d binary.Decoder) error { |
| if _, err := d.Uint64(); err != nil { |
| return err |
| } |
| if _, err := d.Uint64(); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassMemoryRange) ID() binary.ID { return binaryIDMemoryRange } |
| func (*binaryClassMemoryRange) New() binary.Object { return &MemoryRange{} } |
| func (*binaryClassMemoryRange) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeMemoryRange(e, obj.(*MemoryRange)) |
| } |
| func (*binaryClassMemoryRange) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &MemoryRange{} |
| return obj, doDecodeMemoryRange(d, obj) |
| } |
| func (*binaryClassMemoryRange) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeMemoryRange(d, obj.(*MemoryRange)) |
| } |
| func (*binaryClassMemoryRange) Skip(d binary.Decoder) error { return doSkipMemoryRange(d) } |
| func (*binaryClassMemoryRange) Schema() *schema.Class { return schemaMemoryRange } |
| |
| var schemaMemoryRange = &schema.Class{ |
| TypeID: binaryIDMemoryRange, |
| Name: "MemoryRange", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "Base", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}}, |
| schema.Field{Declared: "Size", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}}, |
| }, |
| } |
| |
| type binaryClassMemoryInfo struct{} |
| |
| func (*MemoryInfo) Class() binary.Class { |
| return (*binaryClassMemoryInfo)(nil) |
| } |
| func doEncodeMemoryInfo(e binary.Encoder, o *MemoryInfo) error { |
| if err := e.Uint32(uint32(len(o.Data))); err != nil { |
| return err |
| } |
| if err := e.Data(o.Data); err != nil { |
| return err |
| } |
| if err := e.Uint32(uint32(len(o.Stale))); err != nil { |
| return err |
| } |
| for i := range o.Stale { |
| if err := e.Value(&o.Stale[i]); err != nil { |
| return err |
| } |
| } |
| if err := e.Uint32(uint32(len(o.Current))); err != nil { |
| return err |
| } |
| for i := range o.Current { |
| if err := e.Value(&o.Current[i]); err != nil { |
| return err |
| } |
| } |
| if err := e.Uint32(uint32(len(o.Unknown))); err != nil { |
| return err |
| } |
| for i := range o.Unknown { |
| if err := e.Value(&o.Unknown[i]); err != nil { |
| return err |
| } |
| } |
| return nil |
| } |
| func doDecodeMemoryInfo(d binary.Decoder, o *MemoryInfo) error { |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.Data = make(U8Array, count) |
| if err := d.Data(o.Data); err != nil { |
| return err |
| } |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.Stale = make(MemoryRangeArray, count) |
| for i := range o.Stale { |
| if err := d.Value(&o.Stale[i]); err != nil { |
| return err |
| } |
| } |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.Current = make(MemoryRangeArray, count) |
| for i := range o.Current { |
| if err := d.Value(&o.Current[i]); err != nil { |
| return err |
| } |
| } |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.Unknown = make(MemoryRangeArray, count) |
| for i := range o.Unknown { |
| if err := d.Value(&o.Unknown[i]); err != nil { |
| return err |
| } |
| } |
| } |
| return nil |
| } |
| func doSkipMemoryInfo(d binary.Decoder) error { |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| if err := d.Skip(count); err != nil { |
| return err |
| } |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| for i := uint32(0); i < count; i++ { |
| if err := d.SkipValue((*MemoryRange)(nil)); err != nil { |
| return err |
| } |
| } |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| for i := uint32(0); i < count; i++ { |
| if err := d.SkipValue((*MemoryRange)(nil)); err != nil { |
| return err |
| } |
| } |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| for i := uint32(0); i < count; i++ { |
| if err := d.SkipValue((*MemoryRange)(nil)); err != nil { |
| return err |
| } |
| } |
| } |
| return nil |
| } |
| func (*binaryClassMemoryInfo) ID() binary.ID { return binaryIDMemoryInfo } |
| func (*binaryClassMemoryInfo) New() binary.Object { return &MemoryInfo{} } |
| func (*binaryClassMemoryInfo) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeMemoryInfo(e, obj.(*MemoryInfo)) |
| } |
| func (*binaryClassMemoryInfo) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &MemoryInfo{} |
| return obj, doDecodeMemoryInfo(d, obj) |
| } |
| func (*binaryClassMemoryInfo) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeMemoryInfo(d, obj.(*MemoryInfo)) |
| } |
| func (*binaryClassMemoryInfo) Skip(d binary.Decoder) error { return doSkipMemoryInfo(d) } |
| func (*binaryClassMemoryInfo) Schema() *schema.Class { return schemaMemoryInfo } |
| |
| var schemaMemoryInfo = &schema.Class{ |
| TypeID: binaryIDMemoryInfo, |
| Name: "MemoryInfo", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "Data", Type: &schema.Slice{Alias: "U8Array", ValueType: &schema.Primitive{Name: "uint8", Method: schema.Uint8}}}, |
| schema.Field{Declared: "Stale", Type: &schema.Slice{Alias: "MemoryRangeArray", ValueType: &schema.Struct{Name: "MemoryRange"}}}, |
| schema.Field{Declared: "Current", Type: &schema.Slice{Alias: "MemoryRangeArray", ValueType: &schema.Struct{Name: "MemoryRange"}}}, |
| schema.Field{Declared: "Unknown", Type: &schema.Slice{Alias: "MemoryRangeArray", ValueType: &schema.Struct{Name: "MemoryRange"}}}, |
| }, |
| } |
| |
| type binaryClassMemoryInfoId struct{} |
| |
| func (*MemoryInfoId) Class() binary.Class { |
| return (*binaryClassMemoryInfoId)(nil) |
| } |
| func doEncodeMemoryInfoId(e binary.Encoder, o *MemoryInfoId) error { |
| if err := e.ID(o.ID); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodeMemoryInfoId(d binary.Decoder, o *MemoryInfoId) error { |
| if obj, err := d.ID(); err != nil { |
| return err |
| } else { |
| o.ID = binary.ID(obj) |
| } |
| return nil |
| } |
| func doSkipMemoryInfoId(d binary.Decoder) error { |
| if err := d.SkipID(); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassMemoryInfoId) ID() binary.ID { return binaryIDMemoryInfoId } |
| func (*binaryClassMemoryInfoId) New() binary.Object { return &MemoryInfoId{} } |
| func (*binaryClassMemoryInfoId) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeMemoryInfoId(e, obj.(*MemoryInfoId)) |
| } |
| func (*binaryClassMemoryInfoId) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &MemoryInfoId{} |
| return obj, doDecodeMemoryInfoId(d, obj) |
| } |
| func (*binaryClassMemoryInfoId) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeMemoryInfoId(d, obj.(*MemoryInfoId)) |
| } |
| func (*binaryClassMemoryInfoId) Skip(d binary.Decoder) error { return doSkipMemoryInfoId(d) } |
| func (*binaryClassMemoryInfoId) Schema() *schema.Class { return schemaMemoryInfoId } |
| |
| var schemaMemoryInfoId = &schema.Class{ |
| TypeID: binaryIDMemoryInfoId, |
| Name: "MemoryInfoId", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "ID", Type: &schema.Primitive{Name: "binary.ID", Method: schema.ID}}, |
| }, |
| } |
| |
| type binaryClassRenderSettings struct{} |
| |
| func (*RenderSettings) Class() binary.Class { |
| return (*binaryClassRenderSettings)(nil) |
| } |
| func doEncodeRenderSettings(e binary.Encoder, o *RenderSettings) error { |
| if err := e.Uint32(o.MaxWidth); err != nil { |
| return err |
| } |
| if err := e.Uint32(o.MaxHeight); err != nil { |
| return err |
| } |
| if err := e.Bool(o.Wireframe); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodeRenderSettings(d binary.Decoder, o *RenderSettings) error { |
| if obj, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.MaxWidth = uint32(obj) |
| } |
| if obj, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.MaxHeight = uint32(obj) |
| } |
| if obj, err := d.Bool(); err != nil { |
| return err |
| } else { |
| o.Wireframe = bool(obj) |
| } |
| return nil |
| } |
| func doSkipRenderSettings(d binary.Decoder) error { |
| if _, err := d.Uint32(); err != nil { |
| return err |
| } |
| if _, err := d.Uint32(); err != nil { |
| return err |
| } |
| if _, err := d.Bool(); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassRenderSettings) ID() binary.ID { return binaryIDRenderSettings } |
| func (*binaryClassRenderSettings) New() binary.Object { return &RenderSettings{} } |
| func (*binaryClassRenderSettings) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeRenderSettings(e, obj.(*RenderSettings)) |
| } |
| func (*binaryClassRenderSettings) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &RenderSettings{} |
| return obj, doDecodeRenderSettings(d, obj) |
| } |
| func (*binaryClassRenderSettings) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeRenderSettings(d, obj.(*RenderSettings)) |
| } |
| func (*binaryClassRenderSettings) Skip(d binary.Decoder) error { return doSkipRenderSettings(d) } |
| func (*binaryClassRenderSettings) Schema() *schema.Class { return schemaRenderSettings } |
| |
| var schemaRenderSettings = &schema.Class{ |
| TypeID: binaryIDRenderSettings, |
| Name: "RenderSettings", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "MaxWidth", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}}, |
| schema.Field{Declared: "MaxHeight", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}}, |
| schema.Field{Declared: "Wireframe", Type: &schema.Primitive{Name: "bool", Method: schema.Bool}}, |
| }, |
| } |
| |
| type binaryClassSchema struct{} |
| |
| func (*Schema) Class() binary.Class { |
| return (*binaryClassSchema)(nil) |
| } |
| func doEncodeSchema(e binary.Encoder, o *Schema) error { |
| if err := e.Uint32(uint32(len(o.Atoms))); err != nil { |
| return err |
| } |
| for i := range o.Atoms { |
| if err := e.Value(&o.Atoms[i]); err != nil { |
| return err |
| } |
| } |
| if err := e.Uint32(uint32(len(o.Apis))); err != nil { |
| return err |
| } |
| for i := range o.Apis { |
| if err := e.Value(&o.Apis[i]); err != nil { |
| return err |
| } |
| } |
| return nil |
| } |
| func doDecodeSchema(d binary.Decoder, o *Schema) error { |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.Atoms = make(AtomInfoArray, count) |
| for i := range o.Atoms { |
| if err := d.Value(&o.Atoms[i]); err != nil { |
| return err |
| } |
| } |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.Apis = make(ApiSchemaArray, count) |
| for i := range o.Apis { |
| if err := d.Value(&o.Apis[i]); err != nil { |
| return err |
| } |
| } |
| } |
| return nil |
| } |
| func doSkipSchema(d binary.Decoder) error { |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| for i := uint32(0); i < count; i++ { |
| if err := d.SkipValue((*AtomInfo)(nil)); err != nil { |
| return err |
| } |
| } |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| for i := uint32(0); i < count; i++ { |
| if err := d.SkipValue((*ApiSchema)(nil)); err != nil { |
| return err |
| } |
| } |
| } |
| return nil |
| } |
| func (*binaryClassSchema) ID() binary.ID { return binaryIDSchema } |
| func (*binaryClassSchema) New() binary.Object { return &Schema{} } |
| func (*binaryClassSchema) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeSchema(e, obj.(*Schema)) |
| } |
| func (*binaryClassSchema) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &Schema{} |
| return obj, doDecodeSchema(d, obj) |
| } |
| func (*binaryClassSchema) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeSchema(d, obj.(*Schema)) |
| } |
| func (*binaryClassSchema) Skip(d binary.Decoder) error { return doSkipSchema(d) } |
| func (*binaryClassSchema) Schema() *schema.Class { return schemaSchema } |
| |
| var schemaSchema = &schema.Class{ |
| TypeID: binaryIDSchema, |
| Name: "Schema", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "Atoms", Type: &schema.Slice{Alias: "AtomInfoArray", ValueType: &schema.Struct{Name: "AtomInfo"}}}, |
| schema.Field{Declared: "Apis", Type: &schema.Slice{Alias: "ApiSchemaArray", ValueType: &schema.Struct{Name: "ApiSchema"}}}, |
| }, |
| } |
| |
| type binaryClassSimpleInfo struct{} |
| |
| func (*SimpleInfo) Class() binary.Class { |
| return (*binaryClassSimpleInfo)(nil) |
| } |
| func doEncodeSimpleInfo(e binary.Encoder, o *SimpleInfo) error { |
| if err := e.String(o.Name); err != nil { |
| return err |
| } |
| if err := e.Int32(int32(o.Kind)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodeSimpleInfo(d binary.Decoder, o *SimpleInfo) error { |
| if obj, err := d.String(); err != nil { |
| return err |
| } else { |
| o.Name = string(obj) |
| } |
| if obj, err := d.Int32(); err != nil { |
| return err |
| } else { |
| o.Kind = TypeKind(obj) |
| } |
| return nil |
| } |
| func doSkipSimpleInfo(d binary.Decoder) error { |
| if err := d.SkipString(); err != nil { |
| return err |
| } |
| if _, err := d.Int32(); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassSimpleInfo) ID() binary.ID { return binaryIDSimpleInfo } |
| func (*binaryClassSimpleInfo) New() binary.Object { return &SimpleInfo{} } |
| func (*binaryClassSimpleInfo) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeSimpleInfo(e, obj.(*SimpleInfo)) |
| } |
| func (*binaryClassSimpleInfo) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &SimpleInfo{} |
| return obj, doDecodeSimpleInfo(d, obj) |
| } |
| func (*binaryClassSimpleInfo) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeSimpleInfo(d, obj.(*SimpleInfo)) |
| } |
| func (*binaryClassSimpleInfo) Skip(d binary.Decoder) error { return doSkipSimpleInfo(d) } |
| func (*binaryClassSimpleInfo) Schema() *schema.Class { return schemaSimpleInfo } |
| |
| var schemaSimpleInfo = &schema.Class{ |
| TypeID: binaryIDSimpleInfo, |
| Name: "SimpleInfo", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}}, |
| schema.Field{Declared: "Kind", Type: &schema.Primitive{Name: "TypeKind", Method: schema.Int32}}, |
| }, |
| } |
| |
| type binaryClassStaticArrayInfo struct{} |
| |
| func (*StaticArrayInfo) Class() binary.Class { |
| return (*binaryClassStaticArrayInfo)(nil) |
| } |
| func doEncodeStaticArrayInfo(e binary.Encoder, o *StaticArrayInfo) error { |
| if err := e.String(o.Name); err != nil { |
| return err |
| } |
| if err := e.Int32(int32(o.Kind)); err != nil { |
| return err |
| } |
| if o.ElementType != nil { |
| if err := e.Object(o.ElementType); err != nil { |
| return err |
| } |
| } else if err := e.Object(nil); err != nil { |
| return err |
| } |
| if err := e.Uint32(o.Size); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodeStaticArrayInfo(d binary.Decoder, o *StaticArrayInfo) error { |
| if obj, err := d.String(); err != nil { |
| return err |
| } else { |
| o.Name = string(obj) |
| } |
| if obj, err := d.Int32(); err != nil { |
| return err |
| } else { |
| o.Kind = TypeKind(obj) |
| } |
| if obj, err := d.Object(); err != nil { |
| return err |
| } else if obj != nil { |
| o.ElementType = obj.(TypeInfo) |
| } else { |
| o.ElementType = nil |
| } |
| if obj, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.Size = uint32(obj) |
| } |
| return nil |
| } |
| func doSkipStaticArrayInfo(d binary.Decoder) error { |
| if err := d.SkipString(); err != nil { |
| return err |
| } |
| if _, err := d.Int32(); err != nil { |
| return err |
| } |
| if _, err := d.SkipObject(); err != nil { |
| return err |
| } |
| if _, err := d.Uint32(); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassStaticArrayInfo) ID() binary.ID { return binaryIDStaticArrayInfo } |
| func (*binaryClassStaticArrayInfo) New() binary.Object { return &StaticArrayInfo{} } |
| func (*binaryClassStaticArrayInfo) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeStaticArrayInfo(e, obj.(*StaticArrayInfo)) |
| } |
| func (*binaryClassStaticArrayInfo) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &StaticArrayInfo{} |
| return obj, doDecodeStaticArrayInfo(d, obj) |
| } |
| func (*binaryClassStaticArrayInfo) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeStaticArrayInfo(d, obj.(*StaticArrayInfo)) |
| } |
| func (*binaryClassStaticArrayInfo) Skip(d binary.Decoder) error { return doSkipStaticArrayInfo(d) } |
| func (*binaryClassStaticArrayInfo) Schema() *schema.Class { return schemaStaticArrayInfo } |
| |
| var schemaStaticArrayInfo = &schema.Class{ |
| TypeID: binaryIDStaticArrayInfo, |
| Name: "StaticArrayInfo", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "Name", Type: &schema.Primitive{Name: "string", Method: schema.String}}, |
| schema.Field{Declared: "Kind", Type: &schema.Primitive{Name: "TypeKind", Method: schema.Int32}}, |
| schema.Field{Declared: "ElementType", Type: &schema.Interface{Name: "TypeInfo"}}, |
| schema.Field{Declared: "Size", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}}, |
| }, |
| } |
| |
| type binaryClassTimingInfo struct{} |
| |
| func (*TimingInfo) Class() binary.Class { |
| return (*binaryClassTimingInfo)(nil) |
| } |
| func doEncodeTimingInfo(e binary.Encoder, o *TimingInfo) error { |
| if err := e.Uint32(uint32(len(o.PerCommand))); err != nil { |
| return err |
| } |
| for i := range o.PerCommand { |
| if err := e.Value(&o.PerCommand[i]); err != nil { |
| return err |
| } |
| } |
| if err := e.Uint32(uint32(len(o.PerDrawCall))); err != nil { |
| return err |
| } |
| for i := range o.PerDrawCall { |
| if err := e.Value(&o.PerDrawCall[i]); err != nil { |
| return err |
| } |
| } |
| if err := e.Uint32(uint32(len(o.PerFrame))); err != nil { |
| return err |
| } |
| for i := range o.PerFrame { |
| if err := e.Value(&o.PerFrame[i]); err != nil { |
| return err |
| } |
| } |
| return nil |
| } |
| func doDecodeTimingInfo(d binary.Decoder, o *TimingInfo) error { |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.PerCommand = make(AtomTimerArray, count) |
| for i := range o.PerCommand { |
| if err := d.Value(&o.PerCommand[i]); err != nil { |
| return err |
| } |
| } |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.PerDrawCall = make(AtomRangeTimerArray, count) |
| for i := range o.PerDrawCall { |
| if err := d.Value(&o.PerDrawCall[i]); err != nil { |
| return err |
| } |
| } |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.PerFrame = make(AtomRangeTimerArray, count) |
| for i := range o.PerFrame { |
| if err := d.Value(&o.PerFrame[i]); err != nil { |
| return err |
| } |
| } |
| } |
| return nil |
| } |
| func doSkipTimingInfo(d binary.Decoder) error { |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| for i := uint32(0); i < count; i++ { |
| if err := d.SkipValue((*AtomTimer)(nil)); err != nil { |
| return err |
| } |
| } |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| for i := uint32(0); i < count; i++ { |
| if err := d.SkipValue((*AtomRangeTimer)(nil)); err != nil { |
| return err |
| } |
| } |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| for i := uint32(0); i < count; i++ { |
| if err := d.SkipValue((*AtomRangeTimer)(nil)); err != nil { |
| return err |
| } |
| } |
| } |
| return nil |
| } |
| func (*binaryClassTimingInfo) ID() binary.ID { return binaryIDTimingInfo } |
| func (*binaryClassTimingInfo) New() binary.Object { return &TimingInfo{} } |
| func (*binaryClassTimingInfo) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeTimingInfo(e, obj.(*TimingInfo)) |
| } |
| func (*binaryClassTimingInfo) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &TimingInfo{} |
| return obj, doDecodeTimingInfo(d, obj) |
| } |
| func (*binaryClassTimingInfo) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeTimingInfo(d, obj.(*TimingInfo)) |
| } |
| func (*binaryClassTimingInfo) Skip(d binary.Decoder) error { return doSkipTimingInfo(d) } |
| func (*binaryClassTimingInfo) Schema() *schema.Class { return schemaTimingInfo } |
| |
| var schemaTimingInfo = &schema.Class{ |
| TypeID: binaryIDTimingInfo, |
| Name: "TimingInfo", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "PerCommand", Type: &schema.Slice{Alias: "AtomTimerArray", ValueType: &schema.Struct{Name: "AtomTimer"}}}, |
| schema.Field{Declared: "PerDrawCall", Type: &schema.Slice{Alias: "AtomRangeTimerArray", ValueType: &schema.Struct{Name: "AtomRangeTimer"}}}, |
| schema.Field{Declared: "PerFrame", Type: &schema.Slice{Alias: "AtomRangeTimerArray", ValueType: &schema.Struct{Name: "AtomRangeTimer"}}}, |
| }, |
| } |
| |
| type binaryClassTimingInfoId struct{} |
| |
| func (*TimingInfoId) Class() binary.Class { |
| return (*binaryClassTimingInfoId)(nil) |
| } |
| func doEncodeTimingInfoId(e binary.Encoder, o *TimingInfoId) error { |
| if err := e.ID(o.ID); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodeTimingInfoId(d binary.Decoder, o *TimingInfoId) error { |
| if obj, err := d.ID(); err != nil { |
| return err |
| } else { |
| o.ID = binary.ID(obj) |
| } |
| return nil |
| } |
| func doSkipTimingInfoId(d binary.Decoder) error { |
| if err := d.SkipID(); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassTimingInfoId) ID() binary.ID { return binaryIDTimingInfoId } |
| func (*binaryClassTimingInfoId) New() binary.Object { return &TimingInfoId{} } |
| func (*binaryClassTimingInfoId) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodeTimingInfoId(e, obj.(*TimingInfoId)) |
| } |
| func (*binaryClassTimingInfoId) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &TimingInfoId{} |
| return obj, doDecodeTimingInfoId(d, obj) |
| } |
| func (*binaryClassTimingInfoId) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodeTimingInfoId(d, obj.(*TimingInfoId)) |
| } |
| func (*binaryClassTimingInfoId) Skip(d binary.Decoder) error { return doSkipTimingInfoId(d) } |
| func (*binaryClassTimingInfoId) Schema() *schema.Class { return schemaTimingInfoId } |
| |
| var schemaTimingInfoId = &schema.Class{ |
| TypeID: binaryIDTimingInfoId, |
| Name: "TimingInfoId", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "ID", Type: &schema.Primitive{Name: "binary.ID", Method: schema.ID}}, |
| }, |
| } |
| |
| type binaryClasscallGetCaptures struct{} |
| |
| func (*callGetCaptures) Class() binary.Class { |
| return (*binaryClasscallGetCaptures)(nil) |
| } |
| func doEncodecallGetCaptures(e binary.Encoder, o *callGetCaptures) error { |
| return nil |
| } |
| func doDecodecallGetCaptures(d binary.Decoder, o *callGetCaptures) error { |
| return nil |
| } |
| func doSkipcallGetCaptures(d binary.Decoder) error { |
| return nil |
| } |
| func (*binaryClasscallGetCaptures) ID() binary.ID { return binaryIDcallGetCaptures } |
| func (*binaryClasscallGetCaptures) New() binary.Object { return &callGetCaptures{} } |
| func (*binaryClasscallGetCaptures) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodecallGetCaptures(e, obj.(*callGetCaptures)) |
| } |
| func (*binaryClasscallGetCaptures) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &callGetCaptures{} |
| return obj, doDecodecallGetCaptures(d, obj) |
| } |
| func (*binaryClasscallGetCaptures) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodecallGetCaptures(d, obj.(*callGetCaptures)) |
| } |
| func (*binaryClasscallGetCaptures) Skip(d binary.Decoder) error { return doSkipcallGetCaptures(d) } |
| func (*binaryClasscallGetCaptures) Schema() *schema.Class { return schemacallGetCaptures } |
| |
| var schemacallGetCaptures = &schema.Class{ |
| TypeID: binaryIDcallGetCaptures, |
| Name: "callGetCaptures", |
| Fields: []schema.Field{}, |
| } |
| |
| type binaryClasscallGetDevices struct{} |
| |
| func (*callGetDevices) Class() binary.Class { |
| return (*binaryClasscallGetDevices)(nil) |
| } |
| func doEncodecallGetDevices(e binary.Encoder, o *callGetDevices) error { |
| return nil |
| } |
| func doDecodecallGetDevices(d binary.Decoder, o *callGetDevices) error { |
| return nil |
| } |
| func doSkipcallGetDevices(d binary.Decoder) error { |
| return nil |
| } |
| func (*binaryClasscallGetDevices) ID() binary.ID { return binaryIDcallGetDevices } |
| func (*binaryClasscallGetDevices) New() binary.Object { return &callGetDevices{} } |
| func (*binaryClasscallGetDevices) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodecallGetDevices(e, obj.(*callGetDevices)) |
| } |
| func (*binaryClasscallGetDevices) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &callGetDevices{} |
| return obj, doDecodecallGetDevices(d, obj) |
| } |
| func (*binaryClasscallGetDevices) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodecallGetDevices(d, obj.(*callGetDevices)) |
| } |
| func (*binaryClasscallGetDevices) Skip(d binary.Decoder) error { return doSkipcallGetDevices(d) } |
| func (*binaryClasscallGetDevices) Schema() *schema.Class { return schemacallGetDevices } |
| |
| var schemacallGetDevices = &schema.Class{ |
| TypeID: binaryIDcallGetDevices, |
| Name: "callGetDevices", |
| Fields: []schema.Field{}, |
| } |
| |
| type binaryClasscallGetFramebufferColor struct{} |
| |
| func (*callGetFramebufferColor) Class() binary.Class { |
| return (*binaryClasscallGetFramebufferColor)(nil) |
| } |
| func doEncodecallGetFramebufferColor(e binary.Encoder, o *callGetFramebufferColor) error { |
| if err := e.Value(&o.device); err != nil { |
| return err |
| } |
| if err := e.Value(&o.capture); err != nil { |
| return err |
| } |
| if err := e.Value(&o.api); err != nil { |
| return err |
| } |
| if err := e.Uint64(o.after); err != nil { |
| return err |
| } |
| if err := e.Value(&o.settings); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodecallGetFramebufferColor(d binary.Decoder, o *callGetFramebufferColor) error { |
| if err := d.Value(&o.device); err != nil { |
| return err |
| } |
| if err := d.Value(&o.capture); err != nil { |
| return err |
| } |
| if err := d.Value(&o.api); err != nil { |
| return err |
| } |
| if obj, err := d.Uint64(); err != nil { |
| return err |
| } else { |
| o.after = uint64(obj) |
| } |
| if err := d.Value(&o.settings); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipcallGetFramebufferColor(d binary.Decoder) error { |
| if err := d.SkipValue((*DeviceId)(nil)); err != nil { |
| return err |
| } |
| if err := d.SkipValue((*CaptureId)(nil)); err != nil { |
| return err |
| } |
| if err := d.SkipValue((*ApiId)(nil)); err != nil { |
| return err |
| } |
| if _, err := d.Uint64(); err != nil { |
| return err |
| } |
| if err := d.SkipValue((*RenderSettings)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClasscallGetFramebufferColor) ID() binary.ID { return binaryIDcallGetFramebufferColor } |
| func (*binaryClasscallGetFramebufferColor) New() binary.Object { return &callGetFramebufferColor{} } |
| func (*binaryClasscallGetFramebufferColor) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodecallGetFramebufferColor(e, obj.(*callGetFramebufferColor)) |
| } |
| func (*binaryClasscallGetFramebufferColor) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &callGetFramebufferColor{} |
| return obj, doDecodecallGetFramebufferColor(d, obj) |
| } |
| func (*binaryClasscallGetFramebufferColor) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodecallGetFramebufferColor(d, obj.(*callGetFramebufferColor)) |
| } |
| func (*binaryClasscallGetFramebufferColor) Skip(d binary.Decoder) error { |
| return doSkipcallGetFramebufferColor(d) |
| } |
| func (*binaryClasscallGetFramebufferColor) Schema() *schema.Class { |
| return schemacallGetFramebufferColor |
| } |
| |
| var schemacallGetFramebufferColor = &schema.Class{ |
| TypeID: binaryIDcallGetFramebufferColor, |
| Name: "callGetFramebufferColor", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "device", Type: &schema.Struct{Name: "DeviceId"}}, |
| schema.Field{Declared: "capture", Type: &schema.Struct{Name: "CaptureId"}}, |
| schema.Field{Declared: "api", Type: &schema.Struct{Name: "ApiId"}}, |
| schema.Field{Declared: "after", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}}, |
| schema.Field{Declared: "settings", Type: &schema.Struct{Name: "RenderSettings"}}, |
| }, |
| } |
| |
| type binaryClasscallGetFramebufferDepth struct{} |
| |
| func (*callGetFramebufferDepth) Class() binary.Class { |
| return (*binaryClasscallGetFramebufferDepth)(nil) |
| } |
| func doEncodecallGetFramebufferDepth(e binary.Encoder, o *callGetFramebufferDepth) error { |
| if err := e.Value(&o.device); err != nil { |
| return err |
| } |
| if err := e.Value(&o.capture); err != nil { |
| return err |
| } |
| if err := e.Value(&o.api); err != nil { |
| return err |
| } |
| if err := e.Uint64(o.after); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodecallGetFramebufferDepth(d binary.Decoder, o *callGetFramebufferDepth) error { |
| if err := d.Value(&o.device); err != nil { |
| return err |
| } |
| if err := d.Value(&o.capture); err != nil { |
| return err |
| } |
| if err := d.Value(&o.api); err != nil { |
| return err |
| } |
| if obj, err := d.Uint64(); err != nil { |
| return err |
| } else { |
| o.after = uint64(obj) |
| } |
| return nil |
| } |
| func doSkipcallGetFramebufferDepth(d binary.Decoder) error { |
| if err := d.SkipValue((*DeviceId)(nil)); err != nil { |
| return err |
| } |
| if err := d.SkipValue((*CaptureId)(nil)); err != nil { |
| return err |
| } |
| if err := d.SkipValue((*ApiId)(nil)); err != nil { |
| return err |
| } |
| if _, err := d.Uint64(); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClasscallGetFramebufferDepth) ID() binary.ID { return binaryIDcallGetFramebufferDepth } |
| func (*binaryClasscallGetFramebufferDepth) New() binary.Object { return &callGetFramebufferDepth{} } |
| func (*binaryClasscallGetFramebufferDepth) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodecallGetFramebufferDepth(e, obj.(*callGetFramebufferDepth)) |
| } |
| func (*binaryClasscallGetFramebufferDepth) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &callGetFramebufferDepth{} |
| return obj, doDecodecallGetFramebufferDepth(d, obj) |
| } |
| func (*binaryClasscallGetFramebufferDepth) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodecallGetFramebufferDepth(d, obj.(*callGetFramebufferDepth)) |
| } |
| func (*binaryClasscallGetFramebufferDepth) Skip(d binary.Decoder) error { |
| return doSkipcallGetFramebufferDepth(d) |
| } |
| func (*binaryClasscallGetFramebufferDepth) Schema() *schema.Class { |
| return schemacallGetFramebufferDepth |
| } |
| |
| var schemacallGetFramebufferDepth = &schema.Class{ |
| TypeID: binaryIDcallGetFramebufferDepth, |
| Name: "callGetFramebufferDepth", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "device", Type: &schema.Struct{Name: "DeviceId"}}, |
| schema.Field{Declared: "capture", Type: &schema.Struct{Name: "CaptureId"}}, |
| schema.Field{Declared: "api", Type: &schema.Struct{Name: "ApiId"}}, |
| schema.Field{Declared: "after", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}}, |
| }, |
| } |
| |
| type binaryClasscallGetHierarchy struct{} |
| |
| func (*callGetHierarchy) Class() binary.Class { |
| return (*binaryClasscallGetHierarchy)(nil) |
| } |
| func doEncodecallGetHierarchy(e binary.Encoder, o *callGetHierarchy) error { |
| if err := e.Value(&o.capture); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodecallGetHierarchy(d binary.Decoder, o *callGetHierarchy) error { |
| if err := d.Value(&o.capture); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipcallGetHierarchy(d binary.Decoder) error { |
| if err := d.SkipValue((*CaptureId)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClasscallGetHierarchy) ID() binary.ID { return binaryIDcallGetHierarchy } |
| func (*binaryClasscallGetHierarchy) New() binary.Object { return &callGetHierarchy{} } |
| func (*binaryClasscallGetHierarchy) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodecallGetHierarchy(e, obj.(*callGetHierarchy)) |
| } |
| func (*binaryClasscallGetHierarchy) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &callGetHierarchy{} |
| return obj, doDecodecallGetHierarchy(d, obj) |
| } |
| func (*binaryClasscallGetHierarchy) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodecallGetHierarchy(d, obj.(*callGetHierarchy)) |
| } |
| func (*binaryClasscallGetHierarchy) Skip(d binary.Decoder) error { return doSkipcallGetHierarchy(d) } |
| func (*binaryClasscallGetHierarchy) Schema() *schema.Class { return schemacallGetHierarchy } |
| |
| var schemacallGetHierarchy = &schema.Class{ |
| TypeID: binaryIDcallGetHierarchy, |
| Name: "callGetHierarchy", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "capture", Type: &schema.Struct{Name: "CaptureId"}}, |
| }, |
| } |
| |
| type binaryClasscallGetMemoryInfo struct{} |
| |
| func (*callGetMemoryInfo) Class() binary.Class { |
| return (*binaryClasscallGetMemoryInfo)(nil) |
| } |
| func doEncodecallGetMemoryInfo(e binary.Encoder, o *callGetMemoryInfo) error { |
| if err := e.Value(&o.capture); err != nil { |
| return err |
| } |
| if err := e.Uint64(o.after); err != nil { |
| return err |
| } |
| if err := e.Value(&o.rng); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodecallGetMemoryInfo(d binary.Decoder, o *callGetMemoryInfo) error { |
| if err := d.Value(&o.capture); err != nil { |
| return err |
| } |
| if obj, err := d.Uint64(); err != nil { |
| return err |
| } else { |
| o.after = uint64(obj) |
| } |
| if err := d.Value(&o.rng); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipcallGetMemoryInfo(d binary.Decoder) error { |
| if err := d.SkipValue((*CaptureId)(nil)); err != nil { |
| return err |
| } |
| if _, err := d.Uint64(); err != nil { |
| return err |
| } |
| if err := d.SkipValue((*MemoryRange)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClasscallGetMemoryInfo) ID() binary.ID { return binaryIDcallGetMemoryInfo } |
| func (*binaryClasscallGetMemoryInfo) New() binary.Object { return &callGetMemoryInfo{} } |
| func (*binaryClasscallGetMemoryInfo) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodecallGetMemoryInfo(e, obj.(*callGetMemoryInfo)) |
| } |
| func (*binaryClasscallGetMemoryInfo) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &callGetMemoryInfo{} |
| return obj, doDecodecallGetMemoryInfo(d, obj) |
| } |
| func (*binaryClasscallGetMemoryInfo) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodecallGetMemoryInfo(d, obj.(*callGetMemoryInfo)) |
| } |
| func (*binaryClasscallGetMemoryInfo) Skip(d binary.Decoder) error { return doSkipcallGetMemoryInfo(d) } |
| func (*binaryClasscallGetMemoryInfo) Schema() *schema.Class { return schemacallGetMemoryInfo } |
| |
| var schemacallGetMemoryInfo = &schema.Class{ |
| TypeID: binaryIDcallGetMemoryInfo, |
| Name: "callGetMemoryInfo", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "capture", Type: &schema.Struct{Name: "CaptureId"}}, |
| schema.Field{Declared: "after", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}}, |
| schema.Field{Declared: "rng", Type: &schema.Struct{Name: "MemoryRange"}}, |
| }, |
| } |
| |
| type binaryClasscallGetState struct{} |
| |
| func (*callGetState) Class() binary.Class { |
| return (*binaryClasscallGetState)(nil) |
| } |
| func doEncodecallGetState(e binary.Encoder, o *callGetState) error { |
| if err := e.Value(&o.capture); err != nil { |
| return err |
| } |
| if err := e.Uint64(o.after); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodecallGetState(d binary.Decoder, o *callGetState) error { |
| if err := d.Value(&o.capture); err != nil { |
| return err |
| } |
| if obj, err := d.Uint64(); err != nil { |
| return err |
| } else { |
| o.after = uint64(obj) |
| } |
| return nil |
| } |
| func doSkipcallGetState(d binary.Decoder) error { |
| if err := d.SkipValue((*CaptureId)(nil)); err != nil { |
| return err |
| } |
| if _, err := d.Uint64(); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClasscallGetState) ID() binary.ID { return binaryIDcallGetState } |
| func (*binaryClasscallGetState) New() binary.Object { return &callGetState{} } |
| func (*binaryClasscallGetState) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodecallGetState(e, obj.(*callGetState)) |
| } |
| func (*binaryClasscallGetState) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &callGetState{} |
| return obj, doDecodecallGetState(d, obj) |
| } |
| func (*binaryClasscallGetState) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodecallGetState(d, obj.(*callGetState)) |
| } |
| func (*binaryClasscallGetState) Skip(d binary.Decoder) error { return doSkipcallGetState(d) } |
| func (*binaryClasscallGetState) Schema() *schema.Class { return schemacallGetState } |
| |
| var schemacallGetState = &schema.Class{ |
| TypeID: binaryIDcallGetState, |
| Name: "callGetState", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "capture", Type: &schema.Struct{Name: "CaptureId"}}, |
| schema.Field{Declared: "after", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}}, |
| }, |
| } |
| |
| type binaryClasscallGetTimingInfo struct{} |
| |
| func (*callGetTimingInfo) Class() binary.Class { |
| return (*binaryClasscallGetTimingInfo)(nil) |
| } |
| func doEncodecallGetTimingInfo(e binary.Encoder, o *callGetTimingInfo) error { |
| if err := e.Value(&o.device); err != nil { |
| return err |
| } |
| if err := e.Value(&o.capture); err != nil { |
| return err |
| } |
| if err := e.Int32(int32(o.mask)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodecallGetTimingInfo(d binary.Decoder, o *callGetTimingInfo) error { |
| if err := d.Value(&o.device); err != nil { |
| return err |
| } |
| if err := d.Value(&o.capture); err != nil { |
| return err |
| } |
| if obj, err := d.Int32(); err != nil { |
| return err |
| } else { |
| o.mask = TimingMask(obj) |
| } |
| return nil |
| } |
| func doSkipcallGetTimingInfo(d binary.Decoder) error { |
| if err := d.SkipValue((*DeviceId)(nil)); err != nil { |
| return err |
| } |
| if err := d.SkipValue((*CaptureId)(nil)); err != nil { |
| return err |
| } |
| if _, err := d.Int32(); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClasscallGetTimingInfo) ID() binary.ID { return binaryIDcallGetTimingInfo } |
| func (*binaryClasscallGetTimingInfo) New() binary.Object { return &callGetTimingInfo{} } |
| func (*binaryClasscallGetTimingInfo) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodecallGetTimingInfo(e, obj.(*callGetTimingInfo)) |
| } |
| func (*binaryClasscallGetTimingInfo) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &callGetTimingInfo{} |
| return obj, doDecodecallGetTimingInfo(d, obj) |
| } |
| func (*binaryClasscallGetTimingInfo) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodecallGetTimingInfo(d, obj.(*callGetTimingInfo)) |
| } |
| func (*binaryClasscallGetTimingInfo) Skip(d binary.Decoder) error { return doSkipcallGetTimingInfo(d) } |
| func (*binaryClasscallGetTimingInfo) Schema() *schema.Class { return schemacallGetTimingInfo } |
| |
| var schemacallGetTimingInfo = &schema.Class{ |
| TypeID: binaryIDcallGetTimingInfo, |
| Name: "callGetTimingInfo", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "device", Type: &schema.Struct{Name: "DeviceId"}}, |
| schema.Field{Declared: "capture", Type: &schema.Struct{Name: "CaptureId"}}, |
| schema.Field{Declared: "mask", Type: &schema.Primitive{Name: "TimingMask", Method: schema.Int32}}, |
| }, |
| } |
| |
| type binaryClasscallImport struct{} |
| |
| func (*callImport) Class() binary.Class { |
| return (*binaryClasscallImport)(nil) |
| } |
| func doEncodecallImport(e binary.Encoder, o *callImport) error { |
| if err := e.String(o.name); err != nil { |
| return err |
| } |
| if err := e.Uint32(uint32(len(o.Data))); err != nil { |
| return err |
| } |
| if err := e.Data(o.Data); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodecallImport(d binary.Decoder, o *callImport) error { |
| if obj, err := d.String(); err != nil { |
| return err |
| } else { |
| o.name = string(obj) |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.Data = make(U8Array, count) |
| if err := d.Data(o.Data); err != nil { |
| return err |
| } |
| } |
| return nil |
| } |
| func doSkipcallImport(d binary.Decoder) error { |
| if err := d.SkipString(); err != nil { |
| return err |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| if err := d.Skip(count); err != nil { |
| return err |
| } |
| } |
| return nil |
| } |
| func (*binaryClasscallImport) ID() binary.ID { return binaryIDcallImport } |
| func (*binaryClasscallImport) New() binary.Object { return &callImport{} } |
| func (*binaryClasscallImport) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodecallImport(e, obj.(*callImport)) |
| } |
| func (*binaryClasscallImport) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &callImport{} |
| return obj, doDecodecallImport(d, obj) |
| } |
| func (*binaryClasscallImport) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodecallImport(d, obj.(*callImport)) |
| } |
| func (*binaryClasscallImport) Skip(d binary.Decoder) error { return doSkipcallImport(d) } |
| func (*binaryClasscallImport) Schema() *schema.Class { return schemacallImport } |
| |
| var schemacallImport = &schema.Class{ |
| TypeID: binaryIDcallImport, |
| Name: "callImport", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "name", Type: &schema.Primitive{Name: "string", Method: schema.String}}, |
| schema.Field{Declared: "Data", Type: &schema.Slice{Alias: "U8Array", ValueType: &schema.Primitive{Name: "uint8", Method: schema.Uint8}}}, |
| }, |
| } |
| |
| type binaryClasscallPrerenderFramebuffers struct{} |
| |
| func (*callPrerenderFramebuffers) Class() binary.Class { |
| return (*binaryClasscallPrerenderFramebuffers)(nil) |
| } |
| func doEncodecallPrerenderFramebuffers(e binary.Encoder, o *callPrerenderFramebuffers) error { |
| if err := e.Value(&o.device); err != nil { |
| return err |
| } |
| if err := e.Value(&o.capture); err != nil { |
| return err |
| } |
| if err := e.Value(&o.api); err != nil { |
| return err |
| } |
| if err := e.Uint32(o.width); err != nil { |
| return err |
| } |
| if err := e.Uint32(o.height); err != nil { |
| return err |
| } |
| if err := e.Uint32(uint32(len(o.atomIds))); err != nil { |
| return err |
| } |
| for i := range o.atomIds { |
| if err := e.Uint64(o.atomIds[i]); err != nil { |
| return err |
| } |
| } |
| return nil |
| } |
| func doDecodecallPrerenderFramebuffers(d binary.Decoder, o *callPrerenderFramebuffers) error { |
| if err := d.Value(&o.device); err != nil { |
| return err |
| } |
| if err := d.Value(&o.capture); err != nil { |
| return err |
| } |
| if err := d.Value(&o.api); err != nil { |
| return err |
| } |
| if obj, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.width = uint32(obj) |
| } |
| if obj, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.height = uint32(obj) |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.atomIds = make(U64Array, count) |
| for i := range o.atomIds { |
| if obj, err := d.Uint64(); err != nil { |
| return err |
| } else { |
| o.atomIds[i] = uint64(obj) |
| } |
| } |
| } |
| return nil |
| } |
| func doSkipcallPrerenderFramebuffers(d binary.Decoder) error { |
| if err := d.SkipValue((*DeviceId)(nil)); err != nil { |
| return err |
| } |
| if err := d.SkipValue((*CaptureId)(nil)); err != nil { |
| return err |
| } |
| if err := d.SkipValue((*ApiId)(nil)); err != nil { |
| return err |
| } |
| if _, err := d.Uint32(); err != nil { |
| return err |
| } |
| if _, err := d.Uint32(); err != nil { |
| return err |
| } |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| for i := uint32(0); i < count; i++ { |
| if _, err := d.Uint64(); err != nil { |
| return err |
| } |
| } |
| } |
| return nil |
| } |
| func (*binaryClasscallPrerenderFramebuffers) ID() binary.ID { return binaryIDcallPrerenderFramebuffers } |
| func (*binaryClasscallPrerenderFramebuffers) New() binary.Object { return &callPrerenderFramebuffers{} } |
| func (*binaryClasscallPrerenderFramebuffers) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodecallPrerenderFramebuffers(e, obj.(*callPrerenderFramebuffers)) |
| } |
| func (*binaryClasscallPrerenderFramebuffers) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &callPrerenderFramebuffers{} |
| return obj, doDecodecallPrerenderFramebuffers(d, obj) |
| } |
| func (*binaryClasscallPrerenderFramebuffers) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodecallPrerenderFramebuffers(d, obj.(*callPrerenderFramebuffers)) |
| } |
| func (*binaryClasscallPrerenderFramebuffers) Skip(d binary.Decoder) error { |
| return doSkipcallPrerenderFramebuffers(d) |
| } |
| func (*binaryClasscallPrerenderFramebuffers) Schema() *schema.Class { |
| return schemacallPrerenderFramebuffers |
| } |
| |
| var schemacallPrerenderFramebuffers = &schema.Class{ |
| TypeID: binaryIDcallPrerenderFramebuffers, |
| Name: "callPrerenderFramebuffers", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "device", Type: &schema.Struct{Name: "DeviceId"}}, |
| schema.Field{Declared: "capture", Type: &schema.Struct{Name: "CaptureId"}}, |
| schema.Field{Declared: "api", Type: &schema.Struct{Name: "ApiId"}}, |
| schema.Field{Declared: "width", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}}, |
| schema.Field{Declared: "height", Type: &schema.Primitive{Name: "uint32", Method: schema.Uint32}}, |
| schema.Field{Declared: "atomIds", Type: &schema.Slice{Alias: "U64Array", ValueType: &schema.Primitive{Name: "uint64", Method: schema.Uint64}}}, |
| }, |
| } |
| |
| type binaryClasscallReplaceAtom struct{} |
| |
| func (*callReplaceAtom) Class() binary.Class { |
| return (*binaryClasscallReplaceAtom)(nil) |
| } |
| func doEncodecallReplaceAtom(e binary.Encoder, o *callReplaceAtom) error { |
| if err := e.Value(&o.capture); err != nil { |
| return err |
| } |
| if err := e.Uint64(o.atomId); err != nil { |
| return err |
| } |
| if err := e.Uint16(o.atomType); err != nil { |
| return err |
| } |
| if err := e.Value(&o.data); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodecallReplaceAtom(d binary.Decoder, o *callReplaceAtom) error { |
| if err := d.Value(&o.capture); err != nil { |
| return err |
| } |
| if obj, err := d.Uint64(); err != nil { |
| return err |
| } else { |
| o.atomId = uint64(obj) |
| } |
| if obj, err := d.Uint16(); err != nil { |
| return err |
| } else { |
| o.atomType = uint16(obj) |
| } |
| if err := d.Value(&o.data); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipcallReplaceAtom(d binary.Decoder) error { |
| if err := d.SkipValue((*CaptureId)(nil)); err != nil { |
| return err |
| } |
| if _, err := d.Uint64(); err != nil { |
| return err |
| } |
| if _, err := d.Uint16(); err != nil { |
| return err |
| } |
| if err := d.SkipValue((*Binary)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClasscallReplaceAtom) ID() binary.ID { return binaryIDcallReplaceAtom } |
| func (*binaryClasscallReplaceAtom) New() binary.Object { return &callReplaceAtom{} } |
| func (*binaryClasscallReplaceAtom) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodecallReplaceAtom(e, obj.(*callReplaceAtom)) |
| } |
| func (*binaryClasscallReplaceAtom) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &callReplaceAtom{} |
| return obj, doDecodecallReplaceAtom(d, obj) |
| } |
| func (*binaryClasscallReplaceAtom) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodecallReplaceAtom(d, obj.(*callReplaceAtom)) |
| } |
| func (*binaryClasscallReplaceAtom) Skip(d binary.Decoder) error { return doSkipcallReplaceAtom(d) } |
| func (*binaryClasscallReplaceAtom) Schema() *schema.Class { return schemacallReplaceAtom } |
| |
| var schemacallReplaceAtom = &schema.Class{ |
| TypeID: binaryIDcallReplaceAtom, |
| Name: "callReplaceAtom", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "capture", Type: &schema.Struct{Name: "CaptureId"}}, |
| schema.Field{Declared: "atomId", Type: &schema.Primitive{Name: "uint64", Method: schema.Uint64}}, |
| schema.Field{Declared: "atomType", Type: &schema.Primitive{Name: "uint16", Method: schema.Uint16}}, |
| schema.Field{Declared: "data", Type: &schema.Struct{Name: "Binary"}}, |
| }, |
| } |
| |
| type binaryClasscallResolveAtomStream struct{} |
| |
| func (*callResolveAtomStream) Class() binary.Class { |
| return (*binaryClasscallResolveAtomStream)(nil) |
| } |
| func doEncodecallResolveAtomStream(e binary.Encoder, o *callResolveAtomStream) error { |
| if err := e.Value(&o.id); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodecallResolveAtomStream(d binary.Decoder, o *callResolveAtomStream) error { |
| if err := d.Value(&o.id); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipcallResolveAtomStream(d binary.Decoder) error { |
| if err := d.SkipValue((*AtomStreamId)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClasscallResolveAtomStream) ID() binary.ID { return binaryIDcallResolveAtomStream } |
| func (*binaryClasscallResolveAtomStream) New() binary.Object { return &callResolveAtomStream{} } |
| func (*binaryClasscallResolveAtomStream) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodecallResolveAtomStream(e, obj.(*callResolveAtomStream)) |
| } |
| func (*binaryClasscallResolveAtomStream) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &callResolveAtomStream{} |
| return obj, doDecodecallResolveAtomStream(d, obj) |
| } |
| func (*binaryClasscallResolveAtomStream) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodecallResolveAtomStream(d, obj.(*callResolveAtomStream)) |
| } |
| func (*binaryClasscallResolveAtomStream) Skip(d binary.Decoder) error { |
| return doSkipcallResolveAtomStream(d) |
| } |
| func (*binaryClasscallResolveAtomStream) Schema() *schema.Class { return schemacallResolveAtomStream } |
| |
| var schemacallResolveAtomStream = &schema.Class{ |
| TypeID: binaryIDcallResolveAtomStream, |
| Name: "callResolveAtomStream", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "id", Type: &schema.Struct{Name: "AtomStreamId"}}, |
| }, |
| } |
| |
| type binaryClasscallResolveBinary struct{} |
| |
| func (*callResolveBinary) Class() binary.Class { |
| return (*binaryClasscallResolveBinary)(nil) |
| } |
| func doEncodecallResolveBinary(e binary.Encoder, o *callResolveBinary) error { |
| if err := e.Value(&o.id); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodecallResolveBinary(d binary.Decoder, o *callResolveBinary) error { |
| if err := d.Value(&o.id); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipcallResolveBinary(d binary.Decoder) error { |
| if err := d.SkipValue((*BinaryId)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClasscallResolveBinary) ID() binary.ID { return binaryIDcallResolveBinary } |
| func (*binaryClasscallResolveBinary) New() binary.Object { return &callResolveBinary{} } |
| func (*binaryClasscallResolveBinary) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodecallResolveBinary(e, obj.(*callResolveBinary)) |
| } |
| func (*binaryClasscallResolveBinary) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &callResolveBinary{} |
| return obj, doDecodecallResolveBinary(d, obj) |
| } |
| func (*binaryClasscallResolveBinary) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodecallResolveBinary(d, obj.(*callResolveBinary)) |
| } |
| func (*binaryClasscallResolveBinary) Skip(d binary.Decoder) error { return doSkipcallResolveBinary(d) } |
| func (*binaryClasscallResolveBinary) Schema() *schema.Class { return schemacallResolveBinary } |
| |
| var schemacallResolveBinary = &schema.Class{ |
| TypeID: binaryIDcallResolveBinary, |
| Name: "callResolveBinary", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "id", Type: &schema.Struct{Name: "BinaryId"}}, |
| }, |
| } |
| |
| type binaryClasscallResolveCapture struct{} |
| |
| func (*callResolveCapture) Class() binary.Class { |
| return (*binaryClasscallResolveCapture)(nil) |
| } |
| func doEncodecallResolveCapture(e binary.Encoder, o *callResolveCapture) error { |
| if err := e.Value(&o.id); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodecallResolveCapture(d binary.Decoder, o *callResolveCapture) error { |
| if err := d.Value(&o.id); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipcallResolveCapture(d binary.Decoder) error { |
| if err := d.SkipValue((*CaptureId)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClasscallResolveCapture) ID() binary.ID { return binaryIDcallResolveCapture } |
| func (*binaryClasscallResolveCapture) New() binary.Object { return &callResolveCapture{} } |
| func (*binaryClasscallResolveCapture) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodecallResolveCapture(e, obj.(*callResolveCapture)) |
| } |
| func (*binaryClasscallResolveCapture) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &callResolveCapture{} |
| return obj, doDecodecallResolveCapture(d, obj) |
| } |
| func (*binaryClasscallResolveCapture) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodecallResolveCapture(d, obj.(*callResolveCapture)) |
| } |
| func (*binaryClasscallResolveCapture) Skip(d binary.Decoder) error { return doSkipcallResolveCapture(d) } |
| func (*binaryClasscallResolveCapture) Schema() *schema.Class { return schemacallResolveCapture } |
| |
| var schemacallResolveCapture = &schema.Class{ |
| TypeID: binaryIDcallResolveCapture, |
| Name: "callResolveCapture", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "id", Type: &schema.Struct{Name: "CaptureId"}}, |
| }, |
| } |
| |
| type binaryClasscallResolveDevice struct{} |
| |
| func (*callResolveDevice) Class() binary.Class { |
| return (*binaryClasscallResolveDevice)(nil) |
| } |
| func doEncodecallResolveDevice(e binary.Encoder, o *callResolveDevice) error { |
| if err := e.Value(&o.id); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodecallResolveDevice(d binary.Decoder, o *callResolveDevice) error { |
| if err := d.Value(&o.id); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipcallResolveDevice(d binary.Decoder) error { |
| if err := d.SkipValue((*DeviceId)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClasscallResolveDevice) ID() binary.ID { return binaryIDcallResolveDevice } |
| func (*binaryClasscallResolveDevice) New() binary.Object { return &callResolveDevice{} } |
| func (*binaryClasscallResolveDevice) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodecallResolveDevice(e, obj.(*callResolveDevice)) |
| } |
| func (*binaryClasscallResolveDevice) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &callResolveDevice{} |
| return obj, doDecodecallResolveDevice(d, obj) |
| } |
| func (*binaryClasscallResolveDevice) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodecallResolveDevice(d, obj.(*callResolveDevice)) |
| } |
| func (*binaryClasscallResolveDevice) Skip(d binary.Decoder) error { return doSkipcallResolveDevice(d) } |
| func (*binaryClasscallResolveDevice) Schema() *schema.Class { return schemacallResolveDevice } |
| |
| var schemacallResolveDevice = &schema.Class{ |
| TypeID: binaryIDcallResolveDevice, |
| Name: "callResolveDevice", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "id", Type: &schema.Struct{Name: "DeviceId"}}, |
| }, |
| } |
| |
| type binaryClasscallResolveHierarchy struct{} |
| |
| func (*callResolveHierarchy) Class() binary.Class { |
| return (*binaryClasscallResolveHierarchy)(nil) |
| } |
| func doEncodecallResolveHierarchy(e binary.Encoder, o *callResolveHierarchy) error { |
| if err := e.Value(&o.id); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodecallResolveHierarchy(d binary.Decoder, o *callResolveHierarchy) error { |
| if err := d.Value(&o.id); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipcallResolveHierarchy(d binary.Decoder) error { |
| if err := d.SkipValue((*HierarchyId)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClasscallResolveHierarchy) ID() binary.ID { return binaryIDcallResolveHierarchy } |
| func (*binaryClasscallResolveHierarchy) New() binary.Object { return &callResolveHierarchy{} } |
| func (*binaryClasscallResolveHierarchy) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodecallResolveHierarchy(e, obj.(*callResolveHierarchy)) |
| } |
| func (*binaryClasscallResolveHierarchy) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &callResolveHierarchy{} |
| return obj, doDecodecallResolveHierarchy(d, obj) |
| } |
| func (*binaryClasscallResolveHierarchy) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodecallResolveHierarchy(d, obj.(*callResolveHierarchy)) |
| } |
| func (*binaryClasscallResolveHierarchy) Skip(d binary.Decoder) error { |
| return doSkipcallResolveHierarchy(d) |
| } |
| func (*binaryClasscallResolveHierarchy) Schema() *schema.Class { return schemacallResolveHierarchy } |
| |
| var schemacallResolveHierarchy = &schema.Class{ |
| TypeID: binaryIDcallResolveHierarchy, |
| Name: "callResolveHierarchy", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "id", Type: &schema.Struct{Name: "HierarchyId"}}, |
| }, |
| } |
| |
| type binaryClasscallResolveImageInfo struct{} |
| |
| func (*callResolveImageInfo) Class() binary.Class { |
| return (*binaryClasscallResolveImageInfo)(nil) |
| } |
| func doEncodecallResolveImageInfo(e binary.Encoder, o *callResolveImageInfo) error { |
| if err := e.Value(&o.id); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodecallResolveImageInfo(d binary.Decoder, o *callResolveImageInfo) error { |
| if err := d.Value(&o.id); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipcallResolveImageInfo(d binary.Decoder) error { |
| if err := d.SkipValue((*ImageInfoId)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClasscallResolveImageInfo) ID() binary.ID { return binaryIDcallResolveImageInfo } |
| func (*binaryClasscallResolveImageInfo) New() binary.Object { return &callResolveImageInfo{} } |
| func (*binaryClasscallResolveImageInfo) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodecallResolveImageInfo(e, obj.(*callResolveImageInfo)) |
| } |
| func (*binaryClasscallResolveImageInfo) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &callResolveImageInfo{} |
| return obj, doDecodecallResolveImageInfo(d, obj) |
| } |
| func (*binaryClasscallResolveImageInfo) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodecallResolveImageInfo(d, obj.(*callResolveImageInfo)) |
| } |
| func (*binaryClasscallResolveImageInfo) Skip(d binary.Decoder) error { |
| return doSkipcallResolveImageInfo(d) |
| } |
| func (*binaryClasscallResolveImageInfo) Schema() *schema.Class { return schemacallResolveImageInfo } |
| |
| var schemacallResolveImageInfo = &schema.Class{ |
| TypeID: binaryIDcallResolveImageInfo, |
| Name: "callResolveImageInfo", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "id", Type: &schema.Struct{Name: "ImageInfoId"}}, |
| }, |
| } |
| |
| type binaryClasscallResolveMemoryInfo struct{} |
| |
| func (*callResolveMemoryInfo) Class() binary.Class { |
| return (*binaryClasscallResolveMemoryInfo)(nil) |
| } |
| func doEncodecallResolveMemoryInfo(e binary.Encoder, o *callResolveMemoryInfo) error { |
| if err := e.Value(&o.id); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodecallResolveMemoryInfo(d binary.Decoder, o *callResolveMemoryInfo) error { |
| if err := d.Value(&o.id); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipcallResolveMemoryInfo(d binary.Decoder) error { |
| if err := d.SkipValue((*MemoryInfoId)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClasscallResolveMemoryInfo) ID() binary.ID { return binaryIDcallResolveMemoryInfo } |
| func (*binaryClasscallResolveMemoryInfo) New() binary.Object { return &callResolveMemoryInfo{} } |
| func (*binaryClasscallResolveMemoryInfo) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodecallResolveMemoryInfo(e, obj.(*callResolveMemoryInfo)) |
| } |
| func (*binaryClasscallResolveMemoryInfo) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &callResolveMemoryInfo{} |
| return obj, doDecodecallResolveMemoryInfo(d, obj) |
| } |
| func (*binaryClasscallResolveMemoryInfo) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodecallResolveMemoryInfo(d, obj.(*callResolveMemoryInfo)) |
| } |
| func (*binaryClasscallResolveMemoryInfo) Skip(d binary.Decoder) error { |
| return doSkipcallResolveMemoryInfo(d) |
| } |
| func (*binaryClasscallResolveMemoryInfo) Schema() *schema.Class { return schemacallResolveMemoryInfo } |
| |
| var schemacallResolveMemoryInfo = &schema.Class{ |
| TypeID: binaryIDcallResolveMemoryInfo, |
| Name: "callResolveMemoryInfo", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "id", Type: &schema.Struct{Name: "MemoryInfoId"}}, |
| }, |
| } |
| |
| type binaryClasscallResolveSchema struct{} |
| |
| func (*callResolveSchema) Class() binary.Class { |
| return (*binaryClasscallResolveSchema)(nil) |
| } |
| func doEncodecallResolveSchema(e binary.Encoder, o *callResolveSchema) error { |
| if err := e.Value(&o.id); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodecallResolveSchema(d binary.Decoder, o *callResolveSchema) error { |
| if err := d.Value(&o.id); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipcallResolveSchema(d binary.Decoder) error { |
| if err := d.SkipValue((*SchemaId)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClasscallResolveSchema) ID() binary.ID { return binaryIDcallResolveSchema } |
| func (*binaryClasscallResolveSchema) New() binary.Object { return &callResolveSchema{} } |
| func (*binaryClasscallResolveSchema) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodecallResolveSchema(e, obj.(*callResolveSchema)) |
| } |
| func (*binaryClasscallResolveSchema) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &callResolveSchema{} |
| return obj, doDecodecallResolveSchema(d, obj) |
| } |
| func (*binaryClasscallResolveSchema) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodecallResolveSchema(d, obj.(*callResolveSchema)) |
| } |
| func (*binaryClasscallResolveSchema) Skip(d binary.Decoder) error { return doSkipcallResolveSchema(d) } |
| func (*binaryClasscallResolveSchema) Schema() *schema.Class { return schemacallResolveSchema } |
| |
| var schemacallResolveSchema = &schema.Class{ |
| TypeID: binaryIDcallResolveSchema, |
| Name: "callResolveSchema", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "id", Type: &schema.Struct{Name: "SchemaId"}}, |
| }, |
| } |
| |
| type binaryClasscallResolveTimingInfo struct{} |
| |
| func (*callResolveTimingInfo) Class() binary.Class { |
| return (*binaryClasscallResolveTimingInfo)(nil) |
| } |
| func doEncodecallResolveTimingInfo(e binary.Encoder, o *callResolveTimingInfo) error { |
| if err := e.Value(&o.id); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecodecallResolveTimingInfo(d binary.Decoder, o *callResolveTimingInfo) error { |
| if err := d.Value(&o.id); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipcallResolveTimingInfo(d binary.Decoder) error { |
| if err := d.SkipValue((*TimingInfoId)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClasscallResolveTimingInfo) ID() binary.ID { return binaryIDcallResolveTimingInfo } |
| func (*binaryClasscallResolveTimingInfo) New() binary.Object { return &callResolveTimingInfo{} } |
| func (*binaryClasscallResolveTimingInfo) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncodecallResolveTimingInfo(e, obj.(*callResolveTimingInfo)) |
| } |
| func (*binaryClasscallResolveTimingInfo) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &callResolveTimingInfo{} |
| return obj, doDecodecallResolveTimingInfo(d, obj) |
| } |
| func (*binaryClasscallResolveTimingInfo) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecodecallResolveTimingInfo(d, obj.(*callResolveTimingInfo)) |
| } |
| func (*binaryClasscallResolveTimingInfo) Skip(d binary.Decoder) error { |
| return doSkipcallResolveTimingInfo(d) |
| } |
| func (*binaryClasscallResolveTimingInfo) Schema() *schema.Class { return schemacallResolveTimingInfo } |
| |
| var schemacallResolveTimingInfo = &schema.Class{ |
| TypeID: binaryIDcallResolveTimingInfo, |
| Name: "callResolveTimingInfo", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "id", Type: &schema.Struct{Name: "TimingInfoId"}}, |
| }, |
| } |
| |
| type binaryClassresultGetCaptures struct{} |
| |
| func (*resultGetCaptures) Class() binary.Class { |
| return (*binaryClassresultGetCaptures)(nil) |
| } |
| func doEncoderesultGetCaptures(e binary.Encoder, o *resultGetCaptures) error { |
| if err := e.Uint32(uint32(len(o.value))); err != nil { |
| return err |
| } |
| for i := range o.value { |
| if err := e.Value(&o.value[i]); err != nil { |
| return err |
| } |
| } |
| return nil |
| } |
| func doDecoderesultGetCaptures(d binary.Decoder, o *resultGetCaptures) error { |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.value = make(CaptureIdArray, count) |
| for i := range o.value { |
| if err := d.Value(&o.value[i]); err != nil { |
| return err |
| } |
| } |
| } |
| return nil |
| } |
| func doSkipresultGetCaptures(d binary.Decoder) error { |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| for i := uint32(0); i < count; i++ { |
| if err := d.SkipValue((*CaptureId)(nil)); err != nil { |
| return err |
| } |
| } |
| } |
| return nil |
| } |
| func (*binaryClassresultGetCaptures) ID() binary.ID { return binaryIDresultGetCaptures } |
| func (*binaryClassresultGetCaptures) New() binary.Object { return &resultGetCaptures{} } |
| func (*binaryClassresultGetCaptures) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncoderesultGetCaptures(e, obj.(*resultGetCaptures)) |
| } |
| func (*binaryClassresultGetCaptures) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &resultGetCaptures{} |
| return obj, doDecoderesultGetCaptures(d, obj) |
| } |
| func (*binaryClassresultGetCaptures) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecoderesultGetCaptures(d, obj.(*resultGetCaptures)) |
| } |
| func (*binaryClassresultGetCaptures) Skip(d binary.Decoder) error { return doSkipresultGetCaptures(d) } |
| func (*binaryClassresultGetCaptures) Schema() *schema.Class { return schemaresultGetCaptures } |
| |
| var schemaresultGetCaptures = &schema.Class{ |
| TypeID: binaryIDresultGetCaptures, |
| Name: "resultGetCaptures", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "value", Type: &schema.Slice{Alias: "CaptureIdArray", ValueType: &schema.Struct{Name: "CaptureId"}}}, |
| }, |
| } |
| |
| type binaryClassresultGetDevices struct{} |
| |
| func (*resultGetDevices) Class() binary.Class { |
| return (*binaryClassresultGetDevices)(nil) |
| } |
| func doEncoderesultGetDevices(e binary.Encoder, o *resultGetDevices) error { |
| if err := e.Uint32(uint32(len(o.value))); err != nil { |
| return err |
| } |
| for i := range o.value { |
| if err := e.Value(&o.value[i]); err != nil { |
| return err |
| } |
| } |
| return nil |
| } |
| func doDecoderesultGetDevices(d binary.Decoder, o *resultGetDevices) error { |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| o.value = make(DeviceIdArray, count) |
| for i := range o.value { |
| if err := d.Value(&o.value[i]); err != nil { |
| return err |
| } |
| } |
| } |
| return nil |
| } |
| func doSkipresultGetDevices(d binary.Decoder) error { |
| if count, err := d.Uint32(); err != nil { |
| return err |
| } else { |
| for i := uint32(0); i < count; i++ { |
| if err := d.SkipValue((*DeviceId)(nil)); err != nil { |
| return err |
| } |
| } |
| } |
| return nil |
| } |
| func (*binaryClassresultGetDevices) ID() binary.ID { return binaryIDresultGetDevices } |
| func (*binaryClassresultGetDevices) New() binary.Object { return &resultGetDevices{} } |
| func (*binaryClassresultGetDevices) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncoderesultGetDevices(e, obj.(*resultGetDevices)) |
| } |
| func (*binaryClassresultGetDevices) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &resultGetDevices{} |
| return obj, doDecoderesultGetDevices(d, obj) |
| } |
| func (*binaryClassresultGetDevices) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecoderesultGetDevices(d, obj.(*resultGetDevices)) |
| } |
| func (*binaryClassresultGetDevices) Skip(d binary.Decoder) error { return doSkipresultGetDevices(d) } |
| func (*binaryClassresultGetDevices) Schema() *schema.Class { return schemaresultGetDevices } |
| |
| var schemaresultGetDevices = &schema.Class{ |
| TypeID: binaryIDresultGetDevices, |
| Name: "resultGetDevices", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "value", Type: &schema.Slice{Alias: "DeviceIdArray", ValueType: &schema.Struct{Name: "DeviceId"}}}, |
| }, |
| } |
| |
| type binaryClassresultGetFramebufferColor struct{} |
| |
| func (*resultGetFramebufferColor) Class() binary.Class { |
| return (*binaryClassresultGetFramebufferColor)(nil) |
| } |
| func doEncoderesultGetFramebufferColor(e binary.Encoder, o *resultGetFramebufferColor) error { |
| if err := e.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecoderesultGetFramebufferColor(d binary.Decoder, o *resultGetFramebufferColor) error { |
| if err := d.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipresultGetFramebufferColor(d binary.Decoder) error { |
| if err := d.SkipValue((*ImageInfoId)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassresultGetFramebufferColor) ID() binary.ID { return binaryIDresultGetFramebufferColor } |
| func (*binaryClassresultGetFramebufferColor) New() binary.Object { return &resultGetFramebufferColor{} } |
| func (*binaryClassresultGetFramebufferColor) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncoderesultGetFramebufferColor(e, obj.(*resultGetFramebufferColor)) |
| } |
| func (*binaryClassresultGetFramebufferColor) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &resultGetFramebufferColor{} |
| return obj, doDecoderesultGetFramebufferColor(d, obj) |
| } |
| func (*binaryClassresultGetFramebufferColor) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecoderesultGetFramebufferColor(d, obj.(*resultGetFramebufferColor)) |
| } |
| func (*binaryClassresultGetFramebufferColor) Skip(d binary.Decoder) error { |
| return doSkipresultGetFramebufferColor(d) |
| } |
| func (*binaryClassresultGetFramebufferColor) Schema() *schema.Class { |
| return schemaresultGetFramebufferColor |
| } |
| |
| var schemaresultGetFramebufferColor = &schema.Class{ |
| TypeID: binaryIDresultGetFramebufferColor, |
| Name: "resultGetFramebufferColor", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "value", Type: &schema.Struct{Name: "ImageInfoId"}}, |
| }, |
| } |
| |
| type binaryClassresultGetFramebufferDepth struct{} |
| |
| func (*resultGetFramebufferDepth) Class() binary.Class { |
| return (*binaryClassresultGetFramebufferDepth)(nil) |
| } |
| func doEncoderesultGetFramebufferDepth(e binary.Encoder, o *resultGetFramebufferDepth) error { |
| if err := e.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecoderesultGetFramebufferDepth(d binary.Decoder, o *resultGetFramebufferDepth) error { |
| if err := d.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipresultGetFramebufferDepth(d binary.Decoder) error { |
| if err := d.SkipValue((*ImageInfoId)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassresultGetFramebufferDepth) ID() binary.ID { return binaryIDresultGetFramebufferDepth } |
| func (*binaryClassresultGetFramebufferDepth) New() binary.Object { return &resultGetFramebufferDepth{} } |
| func (*binaryClassresultGetFramebufferDepth) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncoderesultGetFramebufferDepth(e, obj.(*resultGetFramebufferDepth)) |
| } |
| func (*binaryClassresultGetFramebufferDepth) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &resultGetFramebufferDepth{} |
| return obj, doDecoderesultGetFramebufferDepth(d, obj) |
| } |
| func (*binaryClassresultGetFramebufferDepth) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecoderesultGetFramebufferDepth(d, obj.(*resultGetFramebufferDepth)) |
| } |
| func (*binaryClassresultGetFramebufferDepth) Skip(d binary.Decoder) error { |
| return doSkipresultGetFramebufferDepth(d) |
| } |
| func (*binaryClassresultGetFramebufferDepth) Schema() *schema.Class { |
| return schemaresultGetFramebufferDepth |
| } |
| |
| var schemaresultGetFramebufferDepth = &schema.Class{ |
| TypeID: binaryIDresultGetFramebufferDepth, |
| Name: "resultGetFramebufferDepth", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "value", Type: &schema.Struct{Name: "ImageInfoId"}}, |
| }, |
| } |
| |
| type binaryClassresultGetHierarchy struct{} |
| |
| func (*resultGetHierarchy) Class() binary.Class { |
| return (*binaryClassresultGetHierarchy)(nil) |
| } |
| func doEncoderesultGetHierarchy(e binary.Encoder, o *resultGetHierarchy) error { |
| if err := e.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecoderesultGetHierarchy(d binary.Decoder, o *resultGetHierarchy) error { |
| if err := d.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipresultGetHierarchy(d binary.Decoder) error { |
| if err := d.SkipValue((*HierarchyId)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassresultGetHierarchy) ID() binary.ID { return binaryIDresultGetHierarchy } |
| func (*binaryClassresultGetHierarchy) New() binary.Object { return &resultGetHierarchy{} } |
| func (*binaryClassresultGetHierarchy) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncoderesultGetHierarchy(e, obj.(*resultGetHierarchy)) |
| } |
| func (*binaryClassresultGetHierarchy) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &resultGetHierarchy{} |
| return obj, doDecoderesultGetHierarchy(d, obj) |
| } |
| func (*binaryClassresultGetHierarchy) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecoderesultGetHierarchy(d, obj.(*resultGetHierarchy)) |
| } |
| func (*binaryClassresultGetHierarchy) Skip(d binary.Decoder) error { return doSkipresultGetHierarchy(d) } |
| func (*binaryClassresultGetHierarchy) Schema() *schema.Class { return schemaresultGetHierarchy } |
| |
| var schemaresultGetHierarchy = &schema.Class{ |
| TypeID: binaryIDresultGetHierarchy, |
| Name: "resultGetHierarchy", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "value", Type: &schema.Struct{Name: "HierarchyId"}}, |
| }, |
| } |
| |
| type binaryClassresultGetMemoryInfo struct{} |
| |
| func (*resultGetMemoryInfo) Class() binary.Class { |
| return (*binaryClassresultGetMemoryInfo)(nil) |
| } |
| func doEncoderesultGetMemoryInfo(e binary.Encoder, o *resultGetMemoryInfo) error { |
| if err := e.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecoderesultGetMemoryInfo(d binary.Decoder, o *resultGetMemoryInfo) error { |
| if err := d.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipresultGetMemoryInfo(d binary.Decoder) error { |
| if err := d.SkipValue((*MemoryInfoId)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassresultGetMemoryInfo) ID() binary.ID { return binaryIDresultGetMemoryInfo } |
| func (*binaryClassresultGetMemoryInfo) New() binary.Object { return &resultGetMemoryInfo{} } |
| func (*binaryClassresultGetMemoryInfo) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncoderesultGetMemoryInfo(e, obj.(*resultGetMemoryInfo)) |
| } |
| func (*binaryClassresultGetMemoryInfo) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &resultGetMemoryInfo{} |
| return obj, doDecoderesultGetMemoryInfo(d, obj) |
| } |
| func (*binaryClassresultGetMemoryInfo) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecoderesultGetMemoryInfo(d, obj.(*resultGetMemoryInfo)) |
| } |
| func (*binaryClassresultGetMemoryInfo) Skip(d binary.Decoder) error { |
| return doSkipresultGetMemoryInfo(d) |
| } |
| func (*binaryClassresultGetMemoryInfo) Schema() *schema.Class { return schemaresultGetMemoryInfo } |
| |
| var schemaresultGetMemoryInfo = &schema.Class{ |
| TypeID: binaryIDresultGetMemoryInfo, |
| Name: "resultGetMemoryInfo", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "value", Type: &schema.Struct{Name: "MemoryInfoId"}}, |
| }, |
| } |
| |
| type binaryClassresultGetState struct{} |
| |
| func (*resultGetState) Class() binary.Class { |
| return (*binaryClassresultGetState)(nil) |
| } |
| func doEncoderesultGetState(e binary.Encoder, o *resultGetState) error { |
| if err := e.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecoderesultGetState(d binary.Decoder, o *resultGetState) error { |
| if err := d.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipresultGetState(d binary.Decoder) error { |
| if err := d.SkipValue((*BinaryId)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassresultGetState) ID() binary.ID { return binaryIDresultGetState } |
| func (*binaryClassresultGetState) New() binary.Object { return &resultGetState{} } |
| func (*binaryClassresultGetState) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncoderesultGetState(e, obj.(*resultGetState)) |
| } |
| func (*binaryClassresultGetState) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &resultGetState{} |
| return obj, doDecoderesultGetState(d, obj) |
| } |
| func (*binaryClassresultGetState) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecoderesultGetState(d, obj.(*resultGetState)) |
| } |
| func (*binaryClassresultGetState) Skip(d binary.Decoder) error { return doSkipresultGetState(d) } |
| func (*binaryClassresultGetState) Schema() *schema.Class { return schemaresultGetState } |
| |
| var schemaresultGetState = &schema.Class{ |
| TypeID: binaryIDresultGetState, |
| Name: "resultGetState", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "value", Type: &schema.Struct{Name: "BinaryId"}}, |
| }, |
| } |
| |
| type binaryClassresultGetTimingInfo struct{} |
| |
| func (*resultGetTimingInfo) Class() binary.Class { |
| return (*binaryClassresultGetTimingInfo)(nil) |
| } |
| func doEncoderesultGetTimingInfo(e binary.Encoder, o *resultGetTimingInfo) error { |
| if err := e.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecoderesultGetTimingInfo(d binary.Decoder, o *resultGetTimingInfo) error { |
| if err := d.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipresultGetTimingInfo(d binary.Decoder) error { |
| if err := d.SkipValue((*TimingInfoId)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassresultGetTimingInfo) ID() binary.ID { return binaryIDresultGetTimingInfo } |
| func (*binaryClassresultGetTimingInfo) New() binary.Object { return &resultGetTimingInfo{} } |
| func (*binaryClassresultGetTimingInfo) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncoderesultGetTimingInfo(e, obj.(*resultGetTimingInfo)) |
| } |
| func (*binaryClassresultGetTimingInfo) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &resultGetTimingInfo{} |
| return obj, doDecoderesultGetTimingInfo(d, obj) |
| } |
| func (*binaryClassresultGetTimingInfo) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecoderesultGetTimingInfo(d, obj.(*resultGetTimingInfo)) |
| } |
| func (*binaryClassresultGetTimingInfo) Skip(d binary.Decoder) error { |
| return doSkipresultGetTimingInfo(d) |
| } |
| func (*binaryClassresultGetTimingInfo) Schema() *schema.Class { return schemaresultGetTimingInfo } |
| |
| var schemaresultGetTimingInfo = &schema.Class{ |
| TypeID: binaryIDresultGetTimingInfo, |
| Name: "resultGetTimingInfo", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "value", Type: &schema.Struct{Name: "TimingInfoId"}}, |
| }, |
| } |
| |
| type binaryClassresultImport struct{} |
| |
| func (*resultImport) Class() binary.Class { |
| return (*binaryClassresultImport)(nil) |
| } |
| func doEncoderesultImport(e binary.Encoder, o *resultImport) error { |
| if err := e.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecoderesultImport(d binary.Decoder, o *resultImport) error { |
| if err := d.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipresultImport(d binary.Decoder) error { |
| if err := d.SkipValue((*CaptureId)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassresultImport) ID() binary.ID { return binaryIDresultImport } |
| func (*binaryClassresultImport) New() binary.Object { return &resultImport{} } |
| func (*binaryClassresultImport) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncoderesultImport(e, obj.(*resultImport)) |
| } |
| func (*binaryClassresultImport) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &resultImport{} |
| return obj, doDecoderesultImport(d, obj) |
| } |
| func (*binaryClassresultImport) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecoderesultImport(d, obj.(*resultImport)) |
| } |
| func (*binaryClassresultImport) Skip(d binary.Decoder) error { return doSkipresultImport(d) } |
| func (*binaryClassresultImport) Schema() *schema.Class { return schemaresultImport } |
| |
| var schemaresultImport = &schema.Class{ |
| TypeID: binaryIDresultImport, |
| Name: "resultImport", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "value", Type: &schema.Struct{Name: "CaptureId"}}, |
| }, |
| } |
| |
| type binaryClassresultPrerenderFramebuffers struct{} |
| |
| func (*resultPrerenderFramebuffers) Class() binary.Class { |
| return (*binaryClassresultPrerenderFramebuffers)(nil) |
| } |
| func doEncoderesultPrerenderFramebuffers(e binary.Encoder, o *resultPrerenderFramebuffers) error { |
| if err := e.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecoderesultPrerenderFramebuffers(d binary.Decoder, o *resultPrerenderFramebuffers) error { |
| if err := d.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipresultPrerenderFramebuffers(d binary.Decoder) error { |
| if err := d.SkipValue((*BinaryId)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassresultPrerenderFramebuffers) ID() binary.ID { |
| return binaryIDresultPrerenderFramebuffers |
| } |
| func (*binaryClassresultPrerenderFramebuffers) New() binary.Object { |
| return &resultPrerenderFramebuffers{} |
| } |
| func (*binaryClassresultPrerenderFramebuffers) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncoderesultPrerenderFramebuffers(e, obj.(*resultPrerenderFramebuffers)) |
| } |
| func (*binaryClassresultPrerenderFramebuffers) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &resultPrerenderFramebuffers{} |
| return obj, doDecoderesultPrerenderFramebuffers(d, obj) |
| } |
| func (*binaryClassresultPrerenderFramebuffers) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecoderesultPrerenderFramebuffers(d, obj.(*resultPrerenderFramebuffers)) |
| } |
| func (*binaryClassresultPrerenderFramebuffers) Skip(d binary.Decoder) error { |
| return doSkipresultPrerenderFramebuffers(d) |
| } |
| func (*binaryClassresultPrerenderFramebuffers) Schema() *schema.Class { |
| return schemaresultPrerenderFramebuffers |
| } |
| |
| var schemaresultPrerenderFramebuffers = &schema.Class{ |
| TypeID: binaryIDresultPrerenderFramebuffers, |
| Name: "resultPrerenderFramebuffers", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "value", Type: &schema.Struct{Name: "BinaryId"}}, |
| }, |
| } |
| |
| type binaryClassresultReplaceAtom struct{} |
| |
| func (*resultReplaceAtom) Class() binary.Class { |
| return (*binaryClassresultReplaceAtom)(nil) |
| } |
| func doEncoderesultReplaceAtom(e binary.Encoder, o *resultReplaceAtom) error { |
| if err := e.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecoderesultReplaceAtom(d binary.Decoder, o *resultReplaceAtom) error { |
| if err := d.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipresultReplaceAtom(d binary.Decoder) error { |
| if err := d.SkipValue((*CaptureId)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassresultReplaceAtom) ID() binary.ID { return binaryIDresultReplaceAtom } |
| func (*binaryClassresultReplaceAtom) New() binary.Object { return &resultReplaceAtom{} } |
| func (*binaryClassresultReplaceAtom) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncoderesultReplaceAtom(e, obj.(*resultReplaceAtom)) |
| } |
| func (*binaryClassresultReplaceAtom) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &resultReplaceAtom{} |
| return obj, doDecoderesultReplaceAtom(d, obj) |
| } |
| func (*binaryClassresultReplaceAtom) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecoderesultReplaceAtom(d, obj.(*resultReplaceAtom)) |
| } |
| func (*binaryClassresultReplaceAtom) Skip(d binary.Decoder) error { return doSkipresultReplaceAtom(d) } |
| func (*binaryClassresultReplaceAtom) Schema() *schema.Class { return schemaresultReplaceAtom } |
| |
| var schemaresultReplaceAtom = &schema.Class{ |
| TypeID: binaryIDresultReplaceAtom, |
| Name: "resultReplaceAtom", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "value", Type: &schema.Struct{Name: "CaptureId"}}, |
| }, |
| } |
| |
| type binaryClassresultResolveAtomStream struct{} |
| |
| func (*resultResolveAtomStream) Class() binary.Class { |
| return (*binaryClassresultResolveAtomStream)(nil) |
| } |
| func doEncoderesultResolveAtomStream(e binary.Encoder, o *resultResolveAtomStream) error { |
| if err := e.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecoderesultResolveAtomStream(d binary.Decoder, o *resultResolveAtomStream) error { |
| if err := d.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipresultResolveAtomStream(d binary.Decoder) error { |
| if err := d.SkipValue((*AtomStream)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassresultResolveAtomStream) ID() binary.ID { return binaryIDresultResolveAtomStream } |
| func (*binaryClassresultResolveAtomStream) New() binary.Object { return &resultResolveAtomStream{} } |
| func (*binaryClassresultResolveAtomStream) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncoderesultResolveAtomStream(e, obj.(*resultResolveAtomStream)) |
| } |
| func (*binaryClassresultResolveAtomStream) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &resultResolveAtomStream{} |
| return obj, doDecoderesultResolveAtomStream(d, obj) |
| } |
| func (*binaryClassresultResolveAtomStream) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecoderesultResolveAtomStream(d, obj.(*resultResolveAtomStream)) |
| } |
| func (*binaryClassresultResolveAtomStream) Skip(d binary.Decoder) error { |
| return doSkipresultResolveAtomStream(d) |
| } |
| func (*binaryClassresultResolveAtomStream) Schema() *schema.Class { |
| return schemaresultResolveAtomStream |
| } |
| |
| var schemaresultResolveAtomStream = &schema.Class{ |
| TypeID: binaryIDresultResolveAtomStream, |
| Name: "resultResolveAtomStream", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "value", Type: &schema.Struct{Name: "AtomStream"}}, |
| }, |
| } |
| |
| type binaryClassresultResolveBinary struct{} |
| |
| func (*resultResolveBinary) Class() binary.Class { |
| return (*binaryClassresultResolveBinary)(nil) |
| } |
| func doEncoderesultResolveBinary(e binary.Encoder, o *resultResolveBinary) error { |
| if err := e.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecoderesultResolveBinary(d binary.Decoder, o *resultResolveBinary) error { |
| if err := d.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipresultResolveBinary(d binary.Decoder) error { |
| if err := d.SkipValue((*Binary)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassresultResolveBinary) ID() binary.ID { return binaryIDresultResolveBinary } |
| func (*binaryClassresultResolveBinary) New() binary.Object { return &resultResolveBinary{} } |
| func (*binaryClassresultResolveBinary) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncoderesultResolveBinary(e, obj.(*resultResolveBinary)) |
| } |
| func (*binaryClassresultResolveBinary) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &resultResolveBinary{} |
| return obj, doDecoderesultResolveBinary(d, obj) |
| } |
| func (*binaryClassresultResolveBinary) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecoderesultResolveBinary(d, obj.(*resultResolveBinary)) |
| } |
| func (*binaryClassresultResolveBinary) Skip(d binary.Decoder) error { |
| return doSkipresultResolveBinary(d) |
| } |
| func (*binaryClassresultResolveBinary) Schema() *schema.Class { return schemaresultResolveBinary } |
| |
| var schemaresultResolveBinary = &schema.Class{ |
| TypeID: binaryIDresultResolveBinary, |
| Name: "resultResolveBinary", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "value", Type: &schema.Struct{Name: "Binary"}}, |
| }, |
| } |
| |
| type binaryClassresultResolveCapture struct{} |
| |
| func (*resultResolveCapture) Class() binary.Class { |
| return (*binaryClassresultResolveCapture)(nil) |
| } |
| func doEncoderesultResolveCapture(e binary.Encoder, o *resultResolveCapture) error { |
| if err := e.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecoderesultResolveCapture(d binary.Decoder, o *resultResolveCapture) error { |
| if err := d.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipresultResolveCapture(d binary.Decoder) error { |
| if err := d.SkipValue((*Capture)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassresultResolveCapture) ID() binary.ID { return binaryIDresultResolveCapture } |
| func (*binaryClassresultResolveCapture) New() binary.Object { return &resultResolveCapture{} } |
| func (*binaryClassresultResolveCapture) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncoderesultResolveCapture(e, obj.(*resultResolveCapture)) |
| } |
| func (*binaryClassresultResolveCapture) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &resultResolveCapture{} |
| return obj, doDecoderesultResolveCapture(d, obj) |
| } |
| func (*binaryClassresultResolveCapture) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecoderesultResolveCapture(d, obj.(*resultResolveCapture)) |
| } |
| func (*binaryClassresultResolveCapture) Skip(d binary.Decoder) error { |
| return doSkipresultResolveCapture(d) |
| } |
| func (*binaryClassresultResolveCapture) Schema() *schema.Class { return schemaresultResolveCapture } |
| |
| var schemaresultResolveCapture = &schema.Class{ |
| TypeID: binaryIDresultResolveCapture, |
| Name: "resultResolveCapture", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "value", Type: &schema.Struct{Name: "Capture"}}, |
| }, |
| } |
| |
| type binaryClassresultResolveDevice struct{} |
| |
| func (*resultResolveDevice) Class() binary.Class { |
| return (*binaryClassresultResolveDevice)(nil) |
| } |
| func doEncoderesultResolveDevice(e binary.Encoder, o *resultResolveDevice) error { |
| if err := e.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecoderesultResolveDevice(d binary.Decoder, o *resultResolveDevice) error { |
| if err := d.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipresultResolveDevice(d binary.Decoder) error { |
| if err := d.SkipValue((*Device)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassresultResolveDevice) ID() binary.ID { return binaryIDresultResolveDevice } |
| func (*binaryClassresultResolveDevice) New() binary.Object { return &resultResolveDevice{} } |
| func (*binaryClassresultResolveDevice) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncoderesultResolveDevice(e, obj.(*resultResolveDevice)) |
| } |
| func (*binaryClassresultResolveDevice) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &resultResolveDevice{} |
| return obj, doDecoderesultResolveDevice(d, obj) |
| } |
| func (*binaryClassresultResolveDevice) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecoderesultResolveDevice(d, obj.(*resultResolveDevice)) |
| } |
| func (*binaryClassresultResolveDevice) Skip(d binary.Decoder) error { |
| return doSkipresultResolveDevice(d) |
| } |
| func (*binaryClassresultResolveDevice) Schema() *schema.Class { return schemaresultResolveDevice } |
| |
| var schemaresultResolveDevice = &schema.Class{ |
| TypeID: binaryIDresultResolveDevice, |
| Name: "resultResolveDevice", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "value", Type: &schema.Struct{Name: "Device"}}, |
| }, |
| } |
| |
| type binaryClassresultResolveHierarchy struct{} |
| |
| func (*resultResolveHierarchy) Class() binary.Class { |
| return (*binaryClassresultResolveHierarchy)(nil) |
| } |
| func doEncoderesultResolveHierarchy(e binary.Encoder, o *resultResolveHierarchy) error { |
| if err := e.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecoderesultResolveHierarchy(d binary.Decoder, o *resultResolveHierarchy) error { |
| if err := d.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipresultResolveHierarchy(d binary.Decoder) error { |
| if err := d.SkipValue((*Hierarchy)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassresultResolveHierarchy) ID() binary.ID { return binaryIDresultResolveHierarchy } |
| func (*binaryClassresultResolveHierarchy) New() binary.Object { return &resultResolveHierarchy{} } |
| func (*binaryClassresultResolveHierarchy) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncoderesultResolveHierarchy(e, obj.(*resultResolveHierarchy)) |
| } |
| func (*binaryClassresultResolveHierarchy) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &resultResolveHierarchy{} |
| return obj, doDecoderesultResolveHierarchy(d, obj) |
| } |
| func (*binaryClassresultResolveHierarchy) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecoderesultResolveHierarchy(d, obj.(*resultResolveHierarchy)) |
| } |
| func (*binaryClassresultResolveHierarchy) Skip(d binary.Decoder) error { |
| return doSkipresultResolveHierarchy(d) |
| } |
| func (*binaryClassresultResolveHierarchy) Schema() *schema.Class { return schemaresultResolveHierarchy } |
| |
| var schemaresultResolveHierarchy = &schema.Class{ |
| TypeID: binaryIDresultResolveHierarchy, |
| Name: "resultResolveHierarchy", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "value", Type: &schema.Struct{Name: "Hierarchy"}}, |
| }, |
| } |
| |
| type binaryClassresultResolveImageInfo struct{} |
| |
| func (*resultResolveImageInfo) Class() binary.Class { |
| return (*binaryClassresultResolveImageInfo)(nil) |
| } |
| func doEncoderesultResolveImageInfo(e binary.Encoder, o *resultResolveImageInfo) error { |
| if err := e.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecoderesultResolveImageInfo(d binary.Decoder, o *resultResolveImageInfo) error { |
| if err := d.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipresultResolveImageInfo(d binary.Decoder) error { |
| if err := d.SkipValue((*ImageInfo)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassresultResolveImageInfo) ID() binary.ID { return binaryIDresultResolveImageInfo } |
| func (*binaryClassresultResolveImageInfo) New() binary.Object { return &resultResolveImageInfo{} } |
| func (*binaryClassresultResolveImageInfo) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncoderesultResolveImageInfo(e, obj.(*resultResolveImageInfo)) |
| } |
| func (*binaryClassresultResolveImageInfo) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &resultResolveImageInfo{} |
| return obj, doDecoderesultResolveImageInfo(d, obj) |
| } |
| func (*binaryClassresultResolveImageInfo) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecoderesultResolveImageInfo(d, obj.(*resultResolveImageInfo)) |
| } |
| func (*binaryClassresultResolveImageInfo) Skip(d binary.Decoder) error { |
| return doSkipresultResolveImageInfo(d) |
| } |
| func (*binaryClassresultResolveImageInfo) Schema() *schema.Class { return schemaresultResolveImageInfo } |
| |
| var schemaresultResolveImageInfo = &schema.Class{ |
| TypeID: binaryIDresultResolveImageInfo, |
| Name: "resultResolveImageInfo", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "value", Type: &schema.Struct{Name: "ImageInfo"}}, |
| }, |
| } |
| |
| type binaryClassresultResolveMemoryInfo struct{} |
| |
| func (*resultResolveMemoryInfo) Class() binary.Class { |
| return (*binaryClassresultResolveMemoryInfo)(nil) |
| } |
| func doEncoderesultResolveMemoryInfo(e binary.Encoder, o *resultResolveMemoryInfo) error { |
| if err := e.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecoderesultResolveMemoryInfo(d binary.Decoder, o *resultResolveMemoryInfo) error { |
| if err := d.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipresultResolveMemoryInfo(d binary.Decoder) error { |
| if err := d.SkipValue((*MemoryInfo)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassresultResolveMemoryInfo) ID() binary.ID { return binaryIDresultResolveMemoryInfo } |
| func (*binaryClassresultResolveMemoryInfo) New() binary.Object { return &resultResolveMemoryInfo{} } |
| func (*binaryClassresultResolveMemoryInfo) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncoderesultResolveMemoryInfo(e, obj.(*resultResolveMemoryInfo)) |
| } |
| func (*binaryClassresultResolveMemoryInfo) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &resultResolveMemoryInfo{} |
| return obj, doDecoderesultResolveMemoryInfo(d, obj) |
| } |
| func (*binaryClassresultResolveMemoryInfo) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecoderesultResolveMemoryInfo(d, obj.(*resultResolveMemoryInfo)) |
| } |
| func (*binaryClassresultResolveMemoryInfo) Skip(d binary.Decoder) error { |
| return doSkipresultResolveMemoryInfo(d) |
| } |
| func (*binaryClassresultResolveMemoryInfo) Schema() *schema.Class { |
| return schemaresultResolveMemoryInfo |
| } |
| |
| var schemaresultResolveMemoryInfo = &schema.Class{ |
| TypeID: binaryIDresultResolveMemoryInfo, |
| Name: "resultResolveMemoryInfo", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "value", Type: &schema.Struct{Name: "MemoryInfo"}}, |
| }, |
| } |
| |
| type binaryClassresultResolveSchema struct{} |
| |
| func (*resultResolveSchema) Class() binary.Class { |
| return (*binaryClassresultResolveSchema)(nil) |
| } |
| func doEncoderesultResolveSchema(e binary.Encoder, o *resultResolveSchema) error { |
| if err := e.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecoderesultResolveSchema(d binary.Decoder, o *resultResolveSchema) error { |
| if err := d.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipresultResolveSchema(d binary.Decoder) error { |
| if err := d.SkipValue((*Schema)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassresultResolveSchema) ID() binary.ID { return binaryIDresultResolveSchema } |
| func (*binaryClassresultResolveSchema) New() binary.Object { return &resultResolveSchema{} } |
| func (*binaryClassresultResolveSchema) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncoderesultResolveSchema(e, obj.(*resultResolveSchema)) |
| } |
| func (*binaryClassresultResolveSchema) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &resultResolveSchema{} |
| return obj, doDecoderesultResolveSchema(d, obj) |
| } |
| func (*binaryClassresultResolveSchema) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecoderesultResolveSchema(d, obj.(*resultResolveSchema)) |
| } |
| func (*binaryClassresultResolveSchema) Skip(d binary.Decoder) error { |
| return doSkipresultResolveSchema(d) |
| } |
| func (*binaryClassresultResolveSchema) Schema() *schema.Class { return schemaresultResolveSchema } |
| |
| var schemaresultResolveSchema = &schema.Class{ |
| TypeID: binaryIDresultResolveSchema, |
| Name: "resultResolveSchema", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "value", Type: &schema.Struct{Name: "Schema"}}, |
| }, |
| } |
| |
| type binaryClassresultResolveTimingInfo struct{} |
| |
| func (*resultResolveTimingInfo) Class() binary.Class { |
| return (*binaryClassresultResolveTimingInfo)(nil) |
| } |
| func doEncoderesultResolveTimingInfo(e binary.Encoder, o *resultResolveTimingInfo) error { |
| if err := e.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doDecoderesultResolveTimingInfo(d binary.Decoder, o *resultResolveTimingInfo) error { |
| if err := d.Value(&o.value); err != nil { |
| return err |
| } |
| return nil |
| } |
| func doSkipresultResolveTimingInfo(d binary.Decoder) error { |
| if err := d.SkipValue((*TimingInfo)(nil)); err != nil { |
| return err |
| } |
| return nil |
| } |
| func (*binaryClassresultResolveTimingInfo) ID() binary.ID { return binaryIDresultResolveTimingInfo } |
| func (*binaryClassresultResolveTimingInfo) New() binary.Object { return &resultResolveTimingInfo{} } |
| func (*binaryClassresultResolveTimingInfo) Encode(e binary.Encoder, obj binary.Object) error { |
| return doEncoderesultResolveTimingInfo(e, obj.(*resultResolveTimingInfo)) |
| } |
| func (*binaryClassresultResolveTimingInfo) Decode(d binary.Decoder) (binary.Object, error) { |
| obj := &resultResolveTimingInfo{} |
| return obj, doDecoderesultResolveTimingInfo(d, obj) |
| } |
| func (*binaryClassresultResolveTimingInfo) DecodeTo(d binary.Decoder, obj binary.Object) error { |
| return doDecoderesultResolveTimingInfo(d, obj.(*resultResolveTimingInfo)) |
| } |
| func (*binaryClassresultResolveTimingInfo) Skip(d binary.Decoder) error { |
| return doSkipresultResolveTimingInfo(d) |
| } |
| func (*binaryClassresultResolveTimingInfo) Schema() *schema.Class { |
| return schemaresultResolveTimingInfo |
| } |
| |
| var schemaresultResolveTimingInfo = &schema.Class{ |
| TypeID: binaryIDresultResolveTimingInfo, |
| Name: "resultResolveTimingInfo", |
| Fields: []schema.Field{ |
| schema.Field{Declared: "value", Type: &schema.Struct{Name: "TimingInfo"}}, |
| }, |
| } |
| |
| const _ImageFormat_name = "RGBA8Float32" |
| |
| var _ImageFormat_map = map[ImageFormat]string{ |
| 0: _ImageFormat_name[0:5], |
| 1: _ImageFormat_name[5:12], |
| } |
| |
| func (v ImageFormat) String() string { |
| if s, ok := _ImageFormat_map[v]; ok { |
| return s |
| } |
| return fmt.Sprintf("ImageFormat(%d)", v) |
| } |
| |
| func (v *ImageFormat) Parse(s string) error { |
| for k, t := range _ImageFormat_map { |
| if s == t { |
| *v = k |
| return nil |
| } |
| } |
| return fmt.Errorf("%s not in ImageFormat", s) |
| } |
| |
| const _TimingMask_name = "TimingPerCommandTimingPerDrawCallTimingPerFrame" |
| |
| var _TimingMask_map = map[TimingMask]string{ |
| 1: _TimingMask_name[0:16], |
| 2: _TimingMask_name[16:33], |
| 4: _TimingMask_name[33:47], |
| } |
| |
| func (v TimingMask) String() string { |
| if s, ok := _TimingMask_map[v]; ok { |
| return s |
| } |
| return fmt.Sprintf("TimingMask(%d)", v) |
| } |
| |
| func (v *TimingMask) Parse(s string) error { |
| for k, t := range _TimingMask_map { |
| if s == t { |
| *v = k |
| return nil |
| } |
| } |
| return fmt.Errorf("%s not in TimingMask", s) |
| } |
| |
| const _TypeKind_name = "BoolS8U8S16U16S32U32F32S64U64F64StringEnumStructClassArrayStaticArrayMapPointerMemoryAnyID" |
| |
| var _TypeKind_map = map[TypeKind]string{ |
| 0: _TypeKind_name[0:4], |
| 1: _TypeKind_name[4:6], |
| 2: _TypeKind_name[6:8], |
| 3: _TypeKind_name[8:11], |
| 4: _TypeKind_name[11:14], |
| 5: _TypeKind_name[14:17], |
| 6: _TypeKind_name[17:20], |
| 7: _TypeKind_name[20:23], |
| 8: _TypeKind_name[23:26], |
| 9: _TypeKind_name[26:29], |
| 10: _TypeKind_name[29:32], |
| 11: _TypeKind_name[32:38], |
| 12: _TypeKind_name[38:42], |
| 14: _TypeKind_name[42:48], |
| 15: _TypeKind_name[48:53], |
| 16: _TypeKind_name[53:58], |
| 17: _TypeKind_name[58:69], |
| 18: _TypeKind_name[69:72], |
| 19: _TypeKind_name[72:79], |
| 20: _TypeKind_name[79:85], |
| 21: _TypeKind_name[85:88], |
| 22: _TypeKind_name[88:90], |
| } |
| |
| func (v TypeKind) String() string { |
| if s, ok := _TypeKind_map[v]; ok { |
| return s |
| } |
| return fmt.Sprintf("TypeKind(%d)", v) |
| } |
| |
| func (v *TypeKind) Parse(s string) error { |
| for k, t := range _TypeKind_map { |
| if s == t { |
| *v = k |
| return nil |
| } |
| } |
| return fmt.Errorf("%s not in TypeKind", s) |
| } |
