Source code for cfxdb.gen.log.MWorkerLog

# 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 from managed node workers. Primary key: (timestamp, node_id, worker_id).


class MWorkerLog(object):


    __slots__ = ["_tab"]


    @classmethod


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


    @classmethod


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


    # MWorkerLog


    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).
    # MWorkerLog


    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.
    # MWorkerLog


    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


    # MWorkerLog


    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


    # MWorkerLog


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


    # MWorkerLog


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


    # Primary key: Local Worker ID on running CF node.
    # MWorkerLog


    def WorkerId(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
        if o != 0:
            return self._tab.String(o + self._tab.Pos)
        return None


    # Heartbeat period in seconds encompassed by this record.
    # MWorkerLog


    def Period(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 0


    # Management realm ID.
    # MWorkerLog


    def MrealmId(self, j):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
        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


    # MWorkerLog


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


    # MWorkerLog


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


    # MWorkerLog


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


    # Type of worker.
    # MWorkerLog


    def Type(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
        return 0


    # Current state of worker.
    # MWorkerLog


    def State(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
        return 0


    # Unix time in ns. This timestamp is from the original received event payload (from CF node clock).
    # MWorkerLog


    def Sent(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


    # 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).
    # MWorkerLog


    def Seq(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0


    # Current load.
    # MWorkerLog


    def NumFds(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 0


    # MWorkerLog


    def NumThreads(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


    # MWorkerLog


    def NumCtxSwitchesInvoluntary(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0


    # MWorkerLog


    def NumCtxSwitchesInvoluntaryPerSec(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 0


    # MWorkerLog


    def NumCtxSwitchesVoluntary(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0


    # MWorkerLog


    def NumCtxSwitchesVoluntaryPerSec(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
        return 0


    # CPU load
    # MWorkerLog


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


    # MWorkerLog


    def CpuSystemPerSec(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


    # MWorkerLog


    def CpuWait(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


    # MWorkerLog


    def CpuWaitPerSec(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


    # MWorkerLog


    def CpuUser(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


    # MWorkerLog


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


    # Disk load
    # MWorkerLog


    def ReadBytes(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0


    # MWorkerLog


    def ReadBytesPerSec(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(48))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0


    # MWorkerLog


    def ReadIos(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(50))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0


    # MWorkerLog


    def ReadIosPerSec(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


    # MWorkerLog


    def WriteBytes(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(54))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0


    # MWorkerLog


    def WriteBytesPerSec(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(56))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0


    # MWorkerLog


    def WriteIos(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(58))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0


    # MWorkerLog


    def WriteIosPerSec(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0


    # Network load
    # MWorkerLog


    def SentBytes(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


    # MWorkerLog


    def SentBytesPerSec(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


    # MWorkerLog


    def SentIos(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


    # MWorkerLog


    def SentIosPerSec(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


    # MWorkerLog


    def RecvBytes(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


    # MWorkerLog


    def RecvBytesPerSec(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


    # MWorkerLog


    def RecvIos(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


    # MWorkerLog


    def RecvIosPerSec(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


    # WAMP roles defined on a router worker
    # MWorkerLog


    def RouterRoles(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


    # WAMP sessions joined on a router worker
    # MWorkerLog


    def RouterSessions(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


    # WAMP messages processed by a router worker
    # MWorkerLog


    def RecvCall(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


    # MWorkerLog


    def RecvYield(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


    # MWorkerLog


    def SentInvocation(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


    # MWorkerLog


    def SentResult(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


    # MWorkerLog


    def RecvPublish(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


    # MWorkerLog


    def SentPublished(self):
        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(92))
        if o != 0:
            return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
        return 0


    # MWorkerLog


    def SentEvent(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


    # MWorkerLog


    def RecvRegister(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


    # MWorkerLog


    def SentRegistered(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


    # MWorkerLog


    def RecvSubscribe(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


    # MWorkerLog


    def SentSubscribed(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






def MWorkerLogStart(builder):
    builder.StartObject(50)





def Start(builder):
    MWorkerLogStart(builder)





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





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





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





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





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





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





def MWorkerLogAddWorkerId(builder, workerId):
    builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(workerId), 0)





def AddWorkerId(builder, workerId):
    MWorkerLogAddWorkerId(builder, workerId)





def MWorkerLogAddPeriod(builder, period):
    builder.PrependUint32Slot(3, period, 0)





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





def MWorkerLogAddMrealmId(builder, mrealmId):
    builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(mrealmId), 0)





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





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





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





def MWorkerLogAddType(builder, type):
    builder.PrependUint8Slot(5, type, 0)





def AddType(builder, type):
    MWorkerLogAddType(builder, type)





def MWorkerLogAddState(builder, state):
    builder.PrependUint8Slot(6, state, 0)





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





def MWorkerLogAddSent(builder, sent):
    builder.PrependUint64Slot(7, sent, 0)





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





def MWorkerLogAddSeq(builder, seq):
    builder.PrependUint64Slot(8, seq, 0)





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





def MWorkerLogAddNumFds(builder, numFds):
    builder.PrependUint32Slot(9, numFds, 0)





def AddNumFds(builder, numFds):
    MWorkerLogAddNumFds(builder, numFds)





def MWorkerLogAddNumThreads(builder, numThreads):
    builder.PrependUint16Slot(10, numThreads, 0)





def AddNumThreads(builder, numThreads):
    MWorkerLogAddNumThreads(builder, numThreads)





def MWorkerLogAddNumCtxSwitchesInvoluntary(builder, numCtxSwitchesInvoluntary):
    builder.PrependUint64Slot(11, numCtxSwitchesInvoluntary, 0)





def AddNumCtxSwitchesInvoluntary(builder, numCtxSwitchesInvoluntary):
    MWorkerLogAddNumCtxSwitchesInvoluntary(builder, numCtxSwitchesInvoluntary)





def MWorkerLogAddNumCtxSwitchesInvoluntaryPerSec(builder, numCtxSwitchesInvoluntaryPerSec):
    builder.PrependUint32Slot(12, numCtxSwitchesInvoluntaryPerSec, 0)





def AddNumCtxSwitchesInvoluntaryPerSec(builder, numCtxSwitchesInvoluntaryPerSec):
    MWorkerLogAddNumCtxSwitchesInvoluntaryPerSec(builder, numCtxSwitchesInvoluntaryPerSec)





def MWorkerLogAddNumCtxSwitchesVoluntary(builder, numCtxSwitchesVoluntary):
    builder.PrependUint64Slot(13, numCtxSwitchesVoluntary, 0)





def AddNumCtxSwitchesVoluntary(builder, numCtxSwitchesVoluntary):
    MWorkerLogAddNumCtxSwitchesVoluntary(builder, numCtxSwitchesVoluntary)





def MWorkerLogAddNumCtxSwitchesVoluntaryPerSec(builder, numCtxSwitchesVoluntaryPerSec):
    builder.PrependUint32Slot(14, numCtxSwitchesVoluntaryPerSec, 0)





def AddNumCtxSwitchesVoluntaryPerSec(builder, numCtxSwitchesVoluntaryPerSec):
    MWorkerLogAddNumCtxSwitchesVoluntaryPerSec(builder, numCtxSwitchesVoluntaryPerSec)





def MWorkerLogAddCpuSystem(builder, cpuSystem):
    builder.PrependFloat32Slot(15, cpuSystem, 0.0)





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





def MWorkerLogAddCpuSystemPerSec(builder, cpuSystemPerSec):
    builder.PrependFloat32Slot(16, cpuSystemPerSec, 0.0)





def AddCpuSystemPerSec(builder, cpuSystemPerSec):
    MWorkerLogAddCpuSystemPerSec(builder, cpuSystemPerSec)





def MWorkerLogAddCpuWait(builder, cpuWait):
    builder.PrependFloat32Slot(17, cpuWait, 0.0)





def AddCpuWait(builder, cpuWait):
    MWorkerLogAddCpuWait(builder, cpuWait)





def MWorkerLogAddCpuWaitPerSec(builder, cpuWaitPerSec):
    builder.PrependFloat32Slot(18, cpuWaitPerSec, 0.0)





def AddCpuWaitPerSec(builder, cpuWaitPerSec):
    MWorkerLogAddCpuWaitPerSec(builder, cpuWaitPerSec)





def MWorkerLogAddCpuUser(builder, cpuUser):
    builder.PrependFloat32Slot(19, cpuUser, 0.0)





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





def MWorkerLogAddCpuUserPerSec(builder, cpuUserPerSec):
    builder.PrependFloat32Slot(20, cpuUserPerSec, 0.0)





def AddCpuUserPerSec(builder, cpuUserPerSec):
    MWorkerLogAddCpuUserPerSec(builder, cpuUserPerSec)





def MWorkerLogAddReadBytes(builder, readBytes):
    builder.PrependUint64Slot(21, readBytes, 0)





def AddReadBytes(builder, readBytes):
    MWorkerLogAddReadBytes(builder, readBytes)





def MWorkerLogAddReadBytesPerSec(builder, readBytesPerSec):
    builder.PrependUint64Slot(22, readBytesPerSec, 0)





def AddReadBytesPerSec(builder, readBytesPerSec):
    MWorkerLogAddReadBytesPerSec(builder, readBytesPerSec)





def MWorkerLogAddReadIos(builder, readIos):
    builder.PrependUint64Slot(23, readIos, 0)





def AddReadIos(builder, readIos):
    MWorkerLogAddReadIos(builder, readIos)





def MWorkerLogAddReadIosPerSec(builder, readIosPerSec):
    builder.PrependUint64Slot(24, readIosPerSec, 0)





def AddReadIosPerSec(builder, readIosPerSec):
    MWorkerLogAddReadIosPerSec(builder, readIosPerSec)





def MWorkerLogAddWriteBytes(builder, writeBytes):
    builder.PrependUint64Slot(25, writeBytes, 0)





def AddWriteBytes(builder, writeBytes):
    MWorkerLogAddWriteBytes(builder, writeBytes)





def MWorkerLogAddWriteBytesPerSec(builder, writeBytesPerSec):
    builder.PrependUint64Slot(26, writeBytesPerSec, 0)





def AddWriteBytesPerSec(builder, writeBytesPerSec):
    MWorkerLogAddWriteBytesPerSec(builder, writeBytesPerSec)





def MWorkerLogAddWriteIos(builder, writeIos):
    builder.PrependUint64Slot(27, writeIos, 0)





def AddWriteIos(builder, writeIos):
    MWorkerLogAddWriteIos(builder, writeIos)





def MWorkerLogAddWriteIosPerSec(builder, writeIosPerSec):
    builder.PrependUint64Slot(28, writeIosPerSec, 0)





def AddWriteIosPerSec(builder, writeIosPerSec):
    MWorkerLogAddWriteIosPerSec(builder, writeIosPerSec)





def MWorkerLogAddSentBytes(builder, sentBytes):
    builder.PrependUint64Slot(29, sentBytes, 0)





def AddSentBytes(builder, sentBytes):
    MWorkerLogAddSentBytes(builder, sentBytes)





def MWorkerLogAddSentBytesPerSec(builder, sentBytesPerSec):
    builder.PrependUint64Slot(30, sentBytesPerSec, 0)





def AddSentBytesPerSec(builder, sentBytesPerSec):
    MWorkerLogAddSentBytesPerSec(builder, sentBytesPerSec)





def MWorkerLogAddSentIos(builder, sentIos):
    builder.PrependUint64Slot(31, sentIos, 0)





def AddSentIos(builder, sentIos):
    MWorkerLogAddSentIos(builder, sentIos)





def MWorkerLogAddSentIosPerSec(builder, sentIosPerSec):
    builder.PrependUint64Slot(32, sentIosPerSec, 0)





def AddSentIosPerSec(builder, sentIosPerSec):
    MWorkerLogAddSentIosPerSec(builder, sentIosPerSec)





def MWorkerLogAddRecvBytes(builder, recvBytes):
    builder.PrependUint64Slot(33, recvBytes, 0)





def AddRecvBytes(builder, recvBytes):
    MWorkerLogAddRecvBytes(builder, recvBytes)





def MWorkerLogAddRecvBytesPerSec(builder, recvBytesPerSec):
    builder.PrependUint64Slot(34, recvBytesPerSec, 0)





def AddRecvBytesPerSec(builder, recvBytesPerSec):
    MWorkerLogAddRecvBytesPerSec(builder, recvBytesPerSec)





def MWorkerLogAddRecvIos(builder, recvIos):
    builder.PrependUint64Slot(35, recvIos, 0)





def AddRecvIos(builder, recvIos):
    MWorkerLogAddRecvIos(builder, recvIos)





def MWorkerLogAddRecvIosPerSec(builder, recvIosPerSec):
    builder.PrependUint64Slot(36, recvIosPerSec, 0)





def AddRecvIosPerSec(builder, recvIosPerSec):
    MWorkerLogAddRecvIosPerSec(builder, recvIosPerSec)





def MWorkerLogAddRouterRoles(builder, routerRoles):
    builder.PrependUint64Slot(37, routerRoles, 0)





def AddRouterRoles(builder, routerRoles):
    MWorkerLogAddRouterRoles(builder, routerRoles)





def MWorkerLogAddRouterSessions(builder, routerSessions):
    builder.PrependUint64Slot(38, routerSessions, 0)





def AddRouterSessions(builder, routerSessions):
    MWorkerLogAddRouterSessions(builder, routerSessions)





def MWorkerLogAddRecvCall(builder, recvCall):
    builder.PrependUint64Slot(39, recvCall, 0)





def AddRecvCall(builder, recvCall):
    MWorkerLogAddRecvCall(builder, recvCall)





def MWorkerLogAddRecvYield(builder, recvYield):
    builder.PrependUint64Slot(40, recvYield, 0)





def AddRecvYield(builder, recvYield):
    MWorkerLogAddRecvYield(builder, recvYield)





def MWorkerLogAddSentInvocation(builder, sentInvocation):
    builder.PrependUint64Slot(41, sentInvocation, 0)





def AddSentInvocation(builder, sentInvocation):
    MWorkerLogAddSentInvocation(builder, sentInvocation)





def MWorkerLogAddSentResult(builder, sentResult):
    builder.PrependUint64Slot(42, sentResult, 0)





def AddSentResult(builder, sentResult):
    MWorkerLogAddSentResult(builder, sentResult)





def MWorkerLogAddRecvPublish(builder, recvPublish):
    builder.PrependUint64Slot(43, recvPublish, 0)





def AddRecvPublish(builder, recvPublish):
    MWorkerLogAddRecvPublish(builder, recvPublish)





def MWorkerLogAddSentPublished(builder, sentPublished):
    builder.PrependUint64Slot(44, sentPublished, 0)





def AddSentPublished(builder, sentPublished):
    MWorkerLogAddSentPublished(builder, sentPublished)





def MWorkerLogAddSentEvent(builder, sentEvent):
    builder.PrependUint64Slot(45, sentEvent, 0)





def AddSentEvent(builder, sentEvent):
    MWorkerLogAddSentEvent(builder, sentEvent)





def MWorkerLogAddRecvRegister(builder, recvRegister):
    builder.PrependUint64Slot(46, recvRegister, 0)





def AddRecvRegister(builder, recvRegister):
    MWorkerLogAddRecvRegister(builder, recvRegister)





def MWorkerLogAddSentRegistered(builder, sentRegistered):
    builder.PrependUint64Slot(47, sentRegistered, 0)





def AddSentRegistered(builder, sentRegistered):
    MWorkerLogAddSentRegistered(builder, sentRegistered)





def MWorkerLogAddRecvSubscribe(builder, recvSubscribe):
    builder.PrependUint64Slot(48, recvSubscribe, 0)





def AddRecvSubscribe(builder, recvSubscribe):
    MWorkerLogAddRecvSubscribe(builder, recvSubscribe)





def MWorkerLogAddSentSubscribed(builder, sentSubscribed):
    builder.PrependUint64Slot(49, sentSubscribed, 0)





def AddSentSubscribed(builder, sentSubscribed):
    MWorkerLogAddSentSubscribed(builder, sentSubscribed)





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





def End(builder):
    return MWorkerLogEnd(builder)