# automatically generated by the FlatBuffers compiler, do not modify

# namespace: log

import flatbuffers
from flatbuffers.compat import import_numpy

np = import_numpy()


# Heartbeat log record of managed nodes. Primary key: (timestamp, node_id).
class MNodeLog(object):
    __slots__ = ["_tab"]

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

    @classmethod
    def GetRootAsMNodeLog(cls, buf, offset=0):
        """This method is deprecated. Please switch to GetRootAs."""
        return cls.GetRootAs(buf, offset)

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

    # Primary key: Unix time in ns when this log record was received (from CFC node clock).
    # MNodeLog
    def Timestamp(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # Primary key: CF node ID.
    # MNodeLog
    def NodeId(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(
                flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)
            )
        return 0

    # MNodeLog
    def NodeIdAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
        if o != 0:
            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
        return 0

    # MNodeLog
    def NodeIdLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # MNodeLog
    def NodeIdIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
        return o == 0

    # Heartbeat period in seconds encompassed by this record.
    # MNodeLog
    def Period(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 0

    # Management realm ID.
    # MNodeLog
    def MrealmId(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
        if o != 0:
            a = self._tab.Vector(o)
            return self._tab.Get(
                flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)
            )
        return 0

    # MNodeLog
    def MrealmIdAsNumpy(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
        if o != 0:
            return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
        return 0

    # MNodeLog
    def MrealmIdLength(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
        if o != 0:
            return self._tab.VectorLen(o)
        return 0

    # MNodeLog
    def MrealmIdIsNone(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
        return o == 0

    # Current state of CF node.
    # MNodeLog
    def State(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
        return 0

    # WAMP session ID of the CF node uplink management session to this CFC instance.
    # MNodeLog
    def Session(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # Unix time in ns. This timestamp is from the original received event payload (from CF node clock).
    # MNodeLog
    def Sent(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # Sequence number as sent in the log record by the CF node (started at 0 for CF start and incremented by one on each heartbeat).
    # MNodeLog
    def Seq(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # Number of controllers running in the CF node (this is always 1).
    # MNodeLog
    def Controllers(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
        return 0

    # Number of router workers currently running in the CF node.
    # MNodeLog
    def Routers(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
        return 0

    # Number of container workers currently running in the CF node.
    # MNodeLog
    def Containers(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
        return 0

    # Number of guest workers currently running in the CF node.
    # MNodeLog
    def Guests(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
        return 0

    # Number of proxy workers currently running in the CF node.
    # MNodeLog
    def Proxies(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
        return 0

    # Number of XBR market maker workers currently running in the CF node.
    # MNodeLog
    def Marketmakers(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
        return 0

    # Number of hostmonitor workers currently running in the CF node (this is usually either 0 or 1).
    # MNodeLog
    def Hostmonitors(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
        return 0

    # CF node system statistics.
    # MNodeLog
    def CpuCtxSwitches(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def CpuFreq(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 0.0

    # MNodeLog
    def CpuGuest(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 0.0

    # MNodeLog
    def CpuGuestNice(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 0.0

    # MNodeLog
    def CpuIdle(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 0.0

    # MNodeLog
    def CpuInterrupts(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def CpuIowait(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 0.0

    # MNodeLog
    def CpuIrq(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(48))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 0.0

    # MNodeLog
    def CpuNice(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(50))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 0.0

    # MNodeLog
    def CpuSoftInterrupts(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def CpuSoftirq(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(54))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 0.0

    # MNodeLog
    def CpuSteal(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(56))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 0.0

    # MNodeLog
    def CpuSystem(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(58))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 0.0

    # MNodeLog
    def CpuUser(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 0.0

    # MNodeLog
    def DiskBusyTime(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def DiskReadBytes(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def DiskReadCount(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def DiskReadMergedCount(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def DiskReadTime(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def DiskWriteBytes(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def DiskWriteCount(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def DiskWriteMergedCount(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(76))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def DiskWriteTime(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(78))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def MemoryActive(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(80))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def MemoryAvailable(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(82))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def MemoryBuffers(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(84))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def MemoryCached(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(86))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def MemoryFree(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(88))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def MemoryInactive(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(90))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def MemoryPercent(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(92))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
        return 0.0

    # MNodeLog
    def MemoryShared(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(94))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def MemorySlab(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(96))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def MemoryTotal(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(98))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def MemoryUsed(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(100))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def NetworkBytesRecv(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(102))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def NetworkBytesSent(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(104))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def NetworkConnectionAfInet(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(106))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def NetworkConnectionAfInet6(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(108))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def NetworkConnectionAfUnix(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(110))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def NetworkDropin(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(112))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def NetworkDropout(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(114))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def NetworkErrin(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(116))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def NetworkErrout(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(118))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def NetworkPacketsRecv(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(120))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0

    # MNodeLog
    def NetworkPacketsSent(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(122))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0


def MNodeLogStart(builder):
    builder.StartObject(60)


def Start(builder):
    MNodeLogStart(builder)


def MNodeLogAddTimestamp(builder, timestamp):
    builder.PrependUint64Slot(0, timestamp, 0)


def AddTimestamp(builder, timestamp):
    MNodeLogAddTimestamp(builder, timestamp)


def MNodeLogAddNodeId(builder, nodeId):
    builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(nodeId), 0)


def AddNodeId(builder, nodeId):
    MNodeLogAddNodeId(builder, nodeId)


def MNodeLogStartNodeIdVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)


def StartNodeIdVector(builder, numElems: int) -> int:
    return MNodeLogStartNodeIdVector(builder, numElems)


def MNodeLogAddPeriod(builder, period):
    builder.PrependUint32Slot(2, period, 0)


def AddPeriod(builder, period):
    MNodeLogAddPeriod(builder, period)


def MNodeLogAddMrealmId(builder, mrealmId):
    builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(mrealmId), 0)


def AddMrealmId(builder, mrealmId):
    MNodeLogAddMrealmId(builder, mrealmId)


def MNodeLogStartMrealmIdVector(builder, numElems):
    return builder.StartVector(1, numElems, 1)


def StartMrealmIdVector(builder, numElems: int) -> int:
    return MNodeLogStartMrealmIdVector(builder, numElems)


def MNodeLogAddState(builder, state):
    builder.PrependUint8Slot(4, state, 0)


def AddState(builder, state):
    MNodeLogAddState(builder, state)


def MNodeLogAddSession(builder, session):
    builder.PrependUint64Slot(5, session, 0)


def AddSession(builder, session):
    MNodeLogAddSession(builder, session)


def MNodeLogAddSent(builder, sent):
    builder.PrependUint64Slot(6, sent, 0)


def AddSent(builder, sent):
    MNodeLogAddSent(builder, sent)


def MNodeLogAddSeq(builder, seq):
    builder.PrependUint64Slot(7, seq, 0)


def AddSeq(builder, seq):
    MNodeLogAddSeq(builder, seq)


def MNodeLogAddControllers(builder, controllers):
    builder.PrependUint16Slot(8, controllers, 0)


def AddControllers(builder, controllers):
    MNodeLogAddControllers(builder, controllers)


def MNodeLogAddRouters(builder, routers):
    builder.PrependUint16Slot(9, routers, 0)


def AddRouters(builder, routers):
    MNodeLogAddRouters(builder, routers)


def MNodeLogAddContainers(builder, containers):
    builder.PrependUint16Slot(10, containers, 0)


def AddContainers(builder, containers):
    MNodeLogAddContainers(builder, containers)


def MNodeLogAddGuests(builder, guests):
    builder.PrependUint16Slot(11, guests, 0)


def AddGuests(builder, guests):
    MNodeLogAddGuests(builder, guests)


def MNodeLogAddProxies(builder, proxies):
    builder.PrependUint16Slot(12, proxies, 0)


def AddProxies(builder, proxies):
    MNodeLogAddProxies(builder, proxies)


def MNodeLogAddMarketmakers(builder, marketmakers):
    builder.PrependUint16Slot(13, marketmakers, 0)


def AddMarketmakers(builder, marketmakers):
    MNodeLogAddMarketmakers(builder, marketmakers)


def MNodeLogAddHostmonitors(builder, hostmonitors):
    builder.PrependUint16Slot(14, hostmonitors, 0)


def AddHostmonitors(builder, hostmonitors):
    MNodeLogAddHostmonitors(builder, hostmonitors)


def MNodeLogAddCpuCtxSwitches(builder, cpuCtxSwitches):
    builder.PrependUint64Slot(15, cpuCtxSwitches, 0)


def AddCpuCtxSwitches(builder, cpuCtxSwitches):
    MNodeLogAddCpuCtxSwitches(builder, cpuCtxSwitches)


def MNodeLogAddCpuFreq(builder, cpuFreq):
    builder.PrependFloat32Slot(16, cpuFreq, 0.0)


def AddCpuFreq(builder, cpuFreq):
    MNodeLogAddCpuFreq(builder, cpuFreq)


def MNodeLogAddCpuGuest(builder, cpuGuest):
    builder.PrependFloat32Slot(17, cpuGuest, 0.0)


def AddCpuGuest(builder, cpuGuest):
    MNodeLogAddCpuGuest(builder, cpuGuest)


def MNodeLogAddCpuGuestNice(builder, cpuGuestNice):
    builder.PrependFloat32Slot(18, cpuGuestNice, 0.0)


def AddCpuGuestNice(builder, cpuGuestNice):
    MNodeLogAddCpuGuestNice(builder, cpuGuestNice)


def MNodeLogAddCpuIdle(builder, cpuIdle):
    builder.PrependFloat32Slot(19, cpuIdle, 0.0)


def AddCpuIdle(builder, cpuIdle):
    MNodeLogAddCpuIdle(builder, cpuIdle)


def MNodeLogAddCpuInterrupts(builder, cpuInterrupts):
    builder.PrependUint64Slot(20, cpuInterrupts, 0)


def AddCpuInterrupts(builder, cpuInterrupts):
    MNodeLogAddCpuInterrupts(builder, cpuInterrupts)


def MNodeLogAddCpuIowait(builder, cpuIowait):
    builder.PrependFloat32Slot(21, cpuIowait, 0.0)


def AddCpuIowait(builder, cpuIowait):
    MNodeLogAddCpuIowait(builder, cpuIowait)


def MNodeLogAddCpuIrq(builder, cpuIrq):
    builder.PrependFloat32Slot(22, cpuIrq, 0.0)


def AddCpuIrq(builder, cpuIrq):
    MNodeLogAddCpuIrq(builder, cpuIrq)


def MNodeLogAddCpuNice(builder, cpuNice):
    builder.PrependFloat32Slot(23, cpuNice, 0.0)


def AddCpuNice(builder, cpuNice):
    MNodeLogAddCpuNice(builder, cpuNice)


def MNodeLogAddCpuSoftInterrupts(builder, cpuSoftInterrupts):
    builder.PrependUint64Slot(24, cpuSoftInterrupts, 0)


def AddCpuSoftInterrupts(builder, cpuSoftInterrupts):
    MNodeLogAddCpuSoftInterrupts(builder, cpuSoftInterrupts)


def MNodeLogAddCpuSoftirq(builder, cpuSoftirq):
    builder.PrependFloat32Slot(25, cpuSoftirq, 0.0)


def AddCpuSoftirq(builder, cpuSoftirq):
    MNodeLogAddCpuSoftirq(builder, cpuSoftirq)


def MNodeLogAddCpuSteal(builder, cpuSteal):
    builder.PrependFloat32Slot(26, cpuSteal, 0.0)


def AddCpuSteal(builder, cpuSteal):
    MNodeLogAddCpuSteal(builder, cpuSteal)


def MNodeLogAddCpuSystem(builder, cpuSystem):
    builder.PrependFloat32Slot(27, cpuSystem, 0.0)


def AddCpuSystem(builder, cpuSystem):
    MNodeLogAddCpuSystem(builder, cpuSystem)


def MNodeLogAddCpuUser(builder, cpuUser):
    builder.PrependFloat32Slot(28, cpuUser, 0.0)


def AddCpuUser(builder, cpuUser):
    MNodeLogAddCpuUser(builder, cpuUser)


def MNodeLogAddDiskBusyTime(builder, diskBusyTime):
    builder.PrependUint64Slot(29, diskBusyTime, 0)


def AddDiskBusyTime(builder, diskBusyTime):
    MNodeLogAddDiskBusyTime(builder, diskBusyTime)


def MNodeLogAddDiskReadBytes(builder, diskReadBytes):
    builder.PrependUint64Slot(30, diskReadBytes, 0)


def AddDiskReadBytes(builder, diskReadBytes):
    MNodeLogAddDiskReadBytes(builder, diskReadBytes)


def MNodeLogAddDiskReadCount(builder, diskReadCount):
    builder.PrependUint64Slot(31, diskReadCount, 0)


def AddDiskReadCount(builder, diskReadCount):
    MNodeLogAddDiskReadCount(builder, diskReadCount)


def MNodeLogAddDiskReadMergedCount(builder, diskReadMergedCount):
    builder.PrependUint64Slot(32, diskReadMergedCount, 0)


def AddDiskReadMergedCount(builder, diskReadMergedCount):
    MNodeLogAddDiskReadMergedCount(builder, diskReadMergedCount)


def MNodeLogAddDiskReadTime(builder, diskReadTime):
    builder.PrependUint64Slot(33, diskReadTime, 0)


def AddDiskReadTime(builder, diskReadTime):
    MNodeLogAddDiskReadTime(builder, diskReadTime)


def MNodeLogAddDiskWriteBytes(builder, diskWriteBytes):
    builder.PrependUint64Slot(34, diskWriteBytes, 0)


def AddDiskWriteBytes(builder, diskWriteBytes):
    MNodeLogAddDiskWriteBytes(builder, diskWriteBytes)


def MNodeLogAddDiskWriteCount(builder, diskWriteCount):
    builder.PrependUint64Slot(35, diskWriteCount, 0)


def AddDiskWriteCount(builder, diskWriteCount):
    MNodeLogAddDiskWriteCount(builder, diskWriteCount)


def MNodeLogAddDiskWriteMergedCount(builder, diskWriteMergedCount):
    builder.PrependUint64Slot(36, diskWriteMergedCount, 0)


def AddDiskWriteMergedCount(builder, diskWriteMergedCount):
    MNodeLogAddDiskWriteMergedCount(builder, diskWriteMergedCount)


def MNodeLogAddDiskWriteTime(builder, diskWriteTime):
    builder.PrependUint64Slot(37, diskWriteTime, 0)


def AddDiskWriteTime(builder, diskWriteTime):
    MNodeLogAddDiskWriteTime(builder, diskWriteTime)


def MNodeLogAddMemoryActive(builder, memoryActive):
    builder.PrependUint64Slot(38, memoryActive, 0)


def AddMemoryActive(builder, memoryActive):
    MNodeLogAddMemoryActive(builder, memoryActive)


def MNodeLogAddMemoryAvailable(builder, memoryAvailable):
    builder.PrependUint64Slot(39, memoryAvailable, 0)


def AddMemoryAvailable(builder, memoryAvailable):
    MNodeLogAddMemoryAvailable(builder, memoryAvailable)


def MNodeLogAddMemoryBuffers(builder, memoryBuffers):
    builder.PrependUint64Slot(40, memoryBuffers, 0)


def AddMemoryBuffers(builder, memoryBuffers):
    MNodeLogAddMemoryBuffers(builder, memoryBuffers)


def MNodeLogAddMemoryCached(builder, memoryCached):
    builder.PrependUint64Slot(41, memoryCached, 0)


def AddMemoryCached(builder, memoryCached):
    MNodeLogAddMemoryCached(builder, memoryCached)


def MNodeLogAddMemoryFree(builder, memoryFree):
    builder.PrependUint64Slot(42, memoryFree, 0)


def AddMemoryFree(builder, memoryFree):
    MNodeLogAddMemoryFree(builder, memoryFree)


def MNodeLogAddMemoryInactive(builder, memoryInactive):
    builder.PrependUint64Slot(43, memoryInactive, 0)


def AddMemoryInactive(builder, memoryInactive):
    MNodeLogAddMemoryInactive(builder, memoryInactive)


def MNodeLogAddMemoryPercent(builder, memoryPercent):
    builder.PrependFloat32Slot(44, memoryPercent, 0.0)


def AddMemoryPercent(builder, memoryPercent):
    MNodeLogAddMemoryPercent(builder, memoryPercent)


def MNodeLogAddMemoryShared(builder, memoryShared):
    builder.PrependUint64Slot(45, memoryShared, 0)


def AddMemoryShared(builder, memoryShared):
    MNodeLogAddMemoryShared(builder, memoryShared)


def MNodeLogAddMemorySlab(builder, memorySlab):
    builder.PrependUint64Slot(46, memorySlab, 0)


def AddMemorySlab(builder, memorySlab):
    MNodeLogAddMemorySlab(builder, memorySlab)


def MNodeLogAddMemoryTotal(builder, memoryTotal):
    builder.PrependUint64Slot(47, memoryTotal, 0)


def AddMemoryTotal(builder, memoryTotal):
    MNodeLogAddMemoryTotal(builder, memoryTotal)


def MNodeLogAddMemoryUsed(builder, memoryUsed):
    builder.PrependUint64Slot(48, memoryUsed, 0)


def AddMemoryUsed(builder, memoryUsed):
    MNodeLogAddMemoryUsed(builder, memoryUsed)


def MNodeLogAddNetworkBytesRecv(builder, networkBytesRecv):
    builder.PrependUint64Slot(49, networkBytesRecv, 0)


def AddNetworkBytesRecv(builder, networkBytesRecv):
    MNodeLogAddNetworkBytesRecv(builder, networkBytesRecv)


def MNodeLogAddNetworkBytesSent(builder, networkBytesSent):
    builder.PrependUint64Slot(50, networkBytesSent, 0)


def AddNetworkBytesSent(builder, networkBytesSent):
    MNodeLogAddNetworkBytesSent(builder, networkBytesSent)


def MNodeLogAddNetworkConnectionAfInet(builder, networkConnectionAfInet):
    builder.PrependUint32Slot(51, networkConnectionAfInet, 0)


def AddNetworkConnectionAfInet(builder, networkConnectionAfInet):
    MNodeLogAddNetworkConnectionAfInet(builder, networkConnectionAfInet)


def MNodeLogAddNetworkConnectionAfInet6(builder, networkConnectionAfInet6):
    builder.PrependUint32Slot(52, networkConnectionAfInet6, 0)


def AddNetworkConnectionAfInet6(builder, networkConnectionAfInet6):
    MNodeLogAddNetworkConnectionAfInet6(builder, networkConnectionAfInet6)


def MNodeLogAddNetworkConnectionAfUnix(builder, networkConnectionAfUnix):
    builder.PrependUint32Slot(53, networkConnectionAfUnix, 0)


def AddNetworkConnectionAfUnix(builder, networkConnectionAfUnix):
    MNodeLogAddNetworkConnectionAfUnix(builder, networkConnectionAfUnix)


def MNodeLogAddNetworkDropin(builder, networkDropin):
    builder.PrependUint32Slot(54, networkDropin, 0)


def AddNetworkDropin(builder, networkDropin):
    MNodeLogAddNetworkDropin(builder, networkDropin)


def MNodeLogAddNetworkDropout(builder, networkDropout):
    builder.PrependUint32Slot(55, networkDropout, 0)


def AddNetworkDropout(builder, networkDropout):
    MNodeLogAddNetworkDropout(builder, networkDropout)


def MNodeLogAddNetworkErrin(builder, networkErrin):
    builder.PrependUint32Slot(56, networkErrin, 0)


def AddNetworkErrin(builder, networkErrin):
    MNodeLogAddNetworkErrin(builder, networkErrin)


def MNodeLogAddNetworkErrout(builder, networkErrout):
    builder.PrependUint32Slot(57, networkErrout, 0)


def AddNetworkErrout(builder, networkErrout):
    MNodeLogAddNetworkErrout(builder, networkErrout)


def MNodeLogAddNetworkPacketsRecv(builder, networkPacketsRecv):
    builder.PrependUint64Slot(58, networkPacketsRecv, 0)


def AddNetworkPacketsRecv(builder, networkPacketsRecv):
    MNodeLogAddNetworkPacketsRecv(builder, networkPacketsRecv)


def MNodeLogAddNetworkPacketsSent(builder, networkPacketsSent):
    builder.PrependUint64Slot(59, networkPacketsSent, 0)


def AddNetworkPacketsSent(builder, networkPacketsSent):
    MNodeLogAddNetworkPacketsSent(builder, networkPacketsSent)


def MNodeLogEnd(builder):
    return builder.EndObject()


def End(builder):
    return MNodeLogEnd(builder)
