executorch/exir/_serialize/generated/executorch_flatbuffer/NonConstBufferDevice.py at b4c5f13fdcbb5fa9393490dffbd0a787121b62cf · pytorch/executorch · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
# automatically generated by the FlatBuffers compiler, do not modify

# namespace: executorch_flatbuffer

import flatbuffers
from flatbuffers.compat import import_numpy
from typing import Any
np = import_numpy()

class NonConstBufferDevice(object):
    __slots__ = ['_tab']

    @classmethod
    def GetRootAs(cls, buf, offset: int = 0):
        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
        x = NonConstBufferDevice()
        x.Init(buf, n + offset)
        return x

    @classmethod
    def GetRootAsNonConstBufferDevice(cls, buf, offset=0):
        """This method is deprecated. Please switch to GetRootAs."""
        return cls.GetRootAs(buf, offset)
    @classmethod
    def NonConstBufferDeviceBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
        return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x45\x54\x31\x32", size_prefixed=size_prefixed)

    # NonConstBufferDevice
    def Init(self, buf: bytes, pos: int):
        self._tab = flatbuffers.table.Table(buf, pos)

    # NonConstBufferDevice
    def BufferIdx(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
        return 0

    # NonConstBufferDevice
    def DeviceType(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
        return 0

    # NonConstBufferDevice
    def DeviceIndex(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
        return 0

def NonConstBufferDeviceStart(builder: flatbuffers.Builder):
    builder.StartObject(3)

def Start(builder: flatbuffers.Builder):
    NonConstBufferDeviceStart(builder)

def NonConstBufferDeviceAddBufferIdx(builder: flatbuffers.Builder, bufferIdx: int):
    builder.PrependInt32Slot(0, bufferIdx, 0)

def AddBufferIdx(builder: flatbuffers.Builder, bufferIdx: int):
    NonConstBufferDeviceAddBufferIdx(builder, bufferIdx)

def NonConstBufferDeviceAddDeviceType(builder: flatbuffers.Builder, deviceType: int):
    builder.PrependInt8Slot(1, deviceType, 0)

def AddDeviceType(builder: flatbuffers.Builder, deviceType: int):
    NonConstBufferDeviceAddDeviceType(builder, deviceType)

def NonConstBufferDeviceAddDeviceIndex(builder: flatbuffers.Builder, deviceIndex: int):
    builder.PrependInt8Slot(2, deviceIndex, 0)

def AddDeviceIndex(builder: flatbuffers.Builder, deviceIndex: int):
    NonConstBufferDeviceAddDeviceIndex(builder, deviceIndex)

def NonConstBufferDeviceEnd(builder: flatbuffers.Builder) -> int:
    return builder.EndObject()

def End(builder: flatbuffers.Builder) -> int:
    return NonConstBufferDeviceEnd(builder)


class NonConstBufferDeviceT(object):

    # NonConstBufferDeviceT
    def __init__(self):
        self.bufferIdx = 0  # type: int
        self.deviceType = 0  # type: int
        self.deviceIndex = 0  # type: int

    @classmethod
    def InitFromBuf(cls, buf, pos):
        nonConstBufferDevice = NonConstBufferDevice()
        nonConstBufferDevice.Init(buf, pos)
        return cls.InitFromObj(nonConstBufferDevice)

    @classmethod
    def InitFromPackedBuf(cls, buf, pos=0):
        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
        return cls.InitFromBuf(buf, pos+n)

    @classmethod
    def InitFromObj(cls, nonConstBufferDevice):
        x = NonConstBufferDeviceT()
        x._UnPack(nonConstBufferDevice)
        return x

    def __eq__(self, other):
        return type(self) == type(other) and \
            self.bufferIdx == other.bufferIdx and \
            self.deviceType == other.deviceType and \
            self.deviceIndex == other.deviceIndex

    # NonConstBufferDeviceT
    def _UnPack(self, nonConstBufferDevice):
        if nonConstBufferDevice is None:
            return
        self.bufferIdx = nonConstBufferDevice.BufferIdx()
        self.deviceType = nonConstBufferDevice.DeviceType()
        self.deviceIndex = nonConstBufferDevice.DeviceIndex()

    # NonConstBufferDeviceT
    def Pack(self, builder):
        NonConstBufferDeviceStart(builder)
        NonConstBufferDeviceAddBufferIdx(builder, self.bufferIdx)
        NonConstBufferDeviceAddDeviceType(builder, self.deviceType)
        NonConstBufferDeviceAddDeviceIndex(builder, self.deviceIndex)
        nonConstBufferDevice = NonConstBufferDeviceEnd(builder)
        return nonConstBufferDevice