// **********************************************************************
//
// Generated by the OmniBroker IDL-to-C++ Translator
//
// Copyright (c) 1997
// Object-Oriented Concepts, Inc.
// Billerica, MA, USA
//
// All Rights Reserved
//
// **********************************************************************

#include <OB/CORBA.h>
#include <OB/TemplateI.h>
#include "log.h"

//
// IDL:otLog:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBObjVar< otLog >;
template class OBObjForSeq< otLog >;
#endif

otLog_ptr
otLog::_narrow(CORBA_Object_ptr p)
{
    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:otLog:1.0");

        if(v)
            return _duplicate((otLog_ptr)v);

        if(p -> _OB_remoteIsA("IDL:otLog:1.0"))
        {
            otLog_ptr val = new otLog;
            val -> _OB_copyFrom(p);
            return val;
        }
    }

    return _nil();
}

void*
otLog::_OB_narrowHelp(const char* _ob_id) const
{
    if(strcmp("IDL:otLog:1.0", _ob_id) == 0)
        return (void*)this;
    else
        return CORBA_Object::_OB_narrowHelp(_ob_id);
}

const char*
otLog::_OB_typeId() const
{
    return "IDL:otLog:1.0";
}

void
OBUnmarshal(otLog_ptr& val, const CORBA_Octet*& coct, bool swap)
{
    otLog_var old = val;
    CORBA_Object_var p;
    OBUnmarshal(p.inout(), coct, swap);

    if(!CORBA_is_nil(p))
    {
        void* v = p -> _OB_narrowHelp("IDL:otLog:1.0");

        if(v)
            val = otLog::_duplicate((otLog_ptr)v);
        else
        {
            assert_nca(!(p -> _is_local() && p -> _is_dynamic()), OBNCADynamicAsStatic);
            assert(!p -> _is_local());
            val = new otLog;
            val -> _OB_copyFrom(p);
        }
    }
    else
        val = otLog::_nil();
}

const OBTypeCodeConst _tc_otLog(
"010000000E00000022000000010000000E00000049444C3A6F744C6F673A312E3000000006000"
"0006F744C6F6700"
);

void
operator<<=(CORBA_Any& any, otLog_ptr val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = CORBA_Object::_duplicate(val);
    o -> d = CORBA_Object::_duplicate(val);
    any.replace(_tc_otLog, o, true);
}

void
operator<<=(CORBA_Any& any, otLog_ptr* val)
{
    OBObjAny* o = new OBObjAny;
    o -> b = *val;
    o -> d = CORBA_Object::_duplicate(*val);
    any.replace(_tc_otLog, o, true);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, otLog_ptr& val)
{
    if(any.check_type(_tc_otLog))
    {
        OBObjAny* o = (OBObjAny*)any.value();
        assert(o);

        if(!CORBA_is_nil(o -> d))
        {
            void* v = o -> d -> _OB_narrowHelp("IDL:otLog:1.0");

            if(v)
                val = (otLog_ptr)v;
            else
            {
                assert_nca(!(o -> d -> _is_local() && o -> d -> _is_dynamic()), OBNCADynamicAsStatic);
                assert(!o -> d -> _is_local());
                val = new otLog;
                val -> _OB_copyFrom(o -> d);
                OBObjAny* no = new OBObjAny;
                no -> b = CORBA_Object::_duplicate(o -> b);
                no -> d = val;
                ((CORBA_Any&)any).replace(_tc_otLog, no, true);
            }
        }
        else
            val = otLog::_nil();

        return true;
    }
    else
        return false;
}

//
// IDL:otLog/Assignment:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarVar< otLog::Assignment >;
#endif

otLog::Assignment::Assignment(const otLog::Assignment& val)
    : identifier(val.identifier),
      component(val.component),
      value(val.value)
{
}

otLog::Assignment&
otLog::Assignment::operator=(const Assignment& val)
{
    if(this != &val)
    {
        identifier = val.identifier;
        component = val.component;
        value = val.value;
    }
    return *this;
}

void
OBMarshal(const otLog::Assignment& val, CORBA_Octet*& oct)
{
    OBMarshal(val.identifier.in(), oct);
    OBMarshal(val.component.in(), oct);
    OBMarshal(val.value, oct);
}

void
OBMarshalCount(const otLog::Assignment& val, CORBA_ULong& count)
{
    OBMarshalCount(val.identifier.in(), count);
    OBMarshalCount(val.component.in(), count);
    OBMarshalCount(val.value, count);
}

void
OBUnmarshal(otLog::Assignment& val, const CORBA_Octet*& coct, bool swap)
{
    OBUnmarshal(val.identifier.inout(), coct, swap);
    OBUnmarshal(val.component.inout(), coct, swap);
    OBUnmarshal(val.value, coct, swap);
}

const OBTypeCodeConst otLog::_tc_Assignment(
"010000000F00000018020000010000001900000049444C3A6F744C6F672F41737369676E6D656"
"E743A312E30000000000B00000041737369676E6D656E740000030000000B0000006964656E74"
"6966696572000012000000000000000A000000636F6D706F6E656E74000000120000000000000"
"00600000076616C7565000000150000009C010000010000002400000049444C3A6F744D657373"
"6167652F53657269616C697A65644D6573736167653A312E30001200000053657269616C697A6"
"5644D6573736167650000001300000050010000010000000F00000040010000010000001A0000"
"0049444C3A6F744D6573736167652F456C656D656E743A312E3000000008000000456C656D656"
"E740004000000050000006B696E640000000011000000BB000000010000001E00000049444C3A"
"6F744D6573736167652F456C656D656E744B696E643A312E300000000C000000456C656D656E7"
"44B696E6400080000000D0000004265674F66456C656D656E74000000000D000000456E644F66"
"456C656D656E740000000008000000496E74656765720008000000426F6F6C65616E000A00000"
"0426974537472696E670000000A000000486578537472696E670000000C0000004F6374657453"
"7472696E67000B00000043686172537472696E6700000B0000006964656E74696669657200001"
"2000000000000000600000076616C75650000001200000000000000070000006E756D62657200"
"000300000000000000"
);

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBInfo< otLog::Assignment >;
#endif

void
operator<<=(CORBA_Any& any, otLog::Assignment* p)
{
    static const OBInfo< otLog::Assignment > info;
    any.replace(otLog::_tc_Assignment, p, true, &info);
}

void
operator<<=(CORBA_Any& any, const otLog::Assignment& val)
{
    otLog::Assignment* p = new otLog::Assignment(val);
    static const OBInfo< otLog::Assignment > info;
    any.replace(otLog::_tc_Assignment, p, true, &info);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, otLog::Assignment*& p)
{
    if(any.check_type(otLog::_tc_Assignment))
    {
        if(!any.info())
        {
            const CORBA_Octet* coct = (CORBA_Octet*)any.value() + 4;
            otLog::Assignment* v = new otLog::Assignment;
            OBUnmarshal(*v, coct, false);
            (CORBA_Any&)any <<= v;
        }

        p = (otLog::Assignment*)any.value();
        return true;
    }
    else
        return false;
}

//
// IDL:otLog/TimerOperation:1.0
//
const OBTypeCodeConst otLog::_tc_TimerOperation(
"01000000110000006E000000010000001D00000049444C3A6F744C6F672F54696D65724F70657"
"26174696F6E3A312E30000000000F00000054696D65724F7065726174696F6E0000030000000B"
"000000737461727454696D657200000C00000063616E63656C54696D6572000A0000007265616"
"454696D657200"
);

void
operator<<=(CORBA_Any& any, otLog::TimerOperation val)
{
    any.replace(otLog::_tc_TimerOperation, new CORBA_ULong((CORBA_ULong)val), true);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, otLog::TimerOperation& val)
{
    if(any.check_type(otLog::_tc_TimerOperation))
    {
        val = (otLog::TimerOperation)(*(CORBA_ULong*)any.value());
        return true;
    }
    else
        return false;
}

//
// IDL:otLog/TimerOpInformation:1.0
//
#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarVar< otLog::TimerOpInformation >;
#endif

#ifdef OB_CLEAR_MEM
otLog::TimerOpInformation::TimerOpInformation()
{
    memset(&running, 0, sizeof(running));
    memset(&op, 0, sizeof(op));
}
#endif

otLog::TimerOpInformation::TimerOpInformation(const otLog::TimerOpInformation& val)
    : identifier(val.identifier),
      elapsed(val.elapsed),
      running(val.running),
      op(val.op),
      duration(val.duration)
{
}

otLog::TimerOpInformation&
otLog::TimerOpInformation::operator=(const TimerOpInformation& val)
{
    if(this != &val)
    {
        identifier = val.identifier;
        elapsed = val.elapsed;
        running = val.running;
        op = val.op;
        duration = val.duration;
    }
    return *this;
}

void
OBMarshal(const otLog::TimerOpInformation& val, CORBA_Octet*& oct)
{
    OBMarshal(val.identifier.in(), oct);
    OBMarshal(val.elapsed.in(), oct);
    OBMarshal(val.running, oct);
    OBMarshal(val.op, oct);
    OBMarshal(val.duration.in(), oct);
}

void
OBMarshalCount(const otLog::TimerOpInformation& val, CORBA_ULong& count)
{
    OBMarshalCount(val.identifier.in(), count);
    OBMarshalCount(val.elapsed.in(), count);
    OBMarshalCount(val.running, count);
    OBMarshalCount(val.op, count);
    OBMarshalCount(val.duration.in(), count);
}

void
OBUnmarshal(otLog::TimerOpInformation& val, const CORBA_Octet*& coct, bool swap)
{
    OBUnmarshal(val.identifier.inout(), coct, swap);
    OBUnmarshal(val.elapsed.inout(), coct, swap);
    OBUnmarshal(val.running, coct, swap);
    OBUnmarshal(val.op, coct, swap);
    OBUnmarshal(val.duration.inout(), coct, swap);
}

const OBTypeCodeConst otLog::_tc_TimerOpInformation(
"010000000F0000001C010000010000002100000049444C3A6F744C6F672F54696D65724F70496"
"E666F726D6174696F6E3A312E30000000001300000054696D65724F70496E666F726D6174696F"
"6E0000050000000B0000006964656E7469666965720000120000000000000008000000656C617"
"07365640012000000000000000800000072756E6E696E670008000000030000006F7000001100"
"00006E000000010000001D00000049444C3A6F744C6F672F54696D65724F7065726174696F6E3"
"A312E30000000000F00000054696D65724F7065726174696F6E0000030000000B000000737461"
"727454696D657200000C00000063616E63656C54696D6572000A0000007265616454696D65720"
"00000090000006475726174696F6E000000001200000000000000"
);

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBInfo< otLog::TimerOpInformation >;
#endif

void
operator<<=(CORBA_Any& any, otLog::TimerOpInformation* p)
{
    static const OBInfo< otLog::TimerOpInformation > info;
    any.replace(otLog::_tc_TimerOpInformation, p, true, &info);
}

void
operator<<=(CORBA_Any& any, const otLog::TimerOpInformation& val)
{
    otLog::TimerOpInformation* p = new otLog::TimerOpInformation(val);
    static const OBInfo< otLog::TimerOpInformation > info;
    any.replace(otLog::_tc_TimerOpInformation, p, true, &info);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, otLog::TimerOpInformation*& p)
{
    if(any.check_type(otLog::_tc_TimerOpInformation))
    {
        if(!any.info())
        {
            const CORBA_Octet* coct = (CORBA_Octet*)any.value() + 4;
            otLog::TimerOpInformation* v = new otLog::TimerOpInformation;
            OBUnmarshal(*v, coct, false);
            (CORBA_Any&)any <<= v;
        }

        p = (otLog::TimerOpInformation*)any.value();
        return true;
    }
    else
        return false;
}

//
// IDL:otLog/TimerOpList:1.0
//
const OBTypeCodeConst otLog::_tc_TimerOpList(
"010000001500000068010000010000001A00000049444C3A6F744C6F672F54696D65724F704C6"
"973743A312E300000000C00000054696D65724F704C69737400130000002C010000010000000F"
"0000001C010000010000002100000049444C3A6F744C6F672F54696D65724F70496E666F726D6"
"174696F6E3A312E30000000001300000054696D65724F70496E666F726D6174696F6E00000500"
"00000B0000006964656E7469666965720000120000000000000008000000656C6170736564001"
"2000000000000000800000072756E6E696E670008000000030000006F700000110000006E0000"
"00010000001D00000049444C3A6F744C6F672F54696D65724F7065726174696F6E3A312E30000"
"000000F00000054696D65724F7065726174696F6E0000030000000B000000737461727454696D"
"657200000C00000063616E63656C54696D6572000A0000007265616454696D657200000009000"
"0006475726174696F6E00000000120000000000000000000000"
);

//
// IDL:otLog/AssignmentList:1.0
//
const OBTypeCodeConst otLog::_tc_AssignmentList(
"01000000150000006C020000010000001D00000049444C3A6F744C6F672F41737369676E6D656"
"E744C6973743A312E30000000000F00000041737369676E6D656E744C69737400001300000028"
"020000010000000F00000018020000010000001900000049444C3A6F744C6F672F41737369676"
"E6D656E743A312E30000000000B00000041737369676E6D656E740000030000000B0000006964"
"656E746966696572000012000000000000000A000000636F6D706F6E656E74000000120000000"
"00000000600000076616C7565000000150000009C010000010000002400000049444C3A6F744D"
"6573736167652F53657269616C697A65644D6573736167653A312E30001200000053657269616"
"C697A65644D6573736167650000001300000050010000010000000F0000004001000001000000"
"1A00000049444C3A6F744D6573736167652F456C656D656E743A312E3000000008000000456C6"
"56D656E740004000000050000006B696E640000000011000000BB000000010000001E00000049"
"444C3A6F744D6573736167652F456C656D656E744B696E643A312E300000000C000000456C656"
"D656E744B696E6400080000000D0000004265674F66456C656D656E74000000000D000000456E"
"644F66456C656D656E740000000008000000496E74656765720008000000426F6F6C65616E000"
"A000000426974537472696E670000000A000000486578537472696E670000000C0000004F6374"
"6574537472696E67000B00000043686172537472696E6700000B0000006964656E74696669657"
"2000012000000000000000600000076616C75650000001200000000000000070000006E756D62"
"65720000030000000000000000000000"
);

//
// IDL:otLog/IdentifierList:1.0
//
const OBTypeCodeConst otLog::_tc_IdentifierList(
"010000001500000054000000010000001D00000049444C3A6F744C6F672F4964656E746966696"
"5724C6973743A312E30000000000F0000004964656E7469666965724C69737400001300000010"
"00000001000000120000000000000000000000"
);

//
// IDL:otLog/implicitSendEvent:1.0
//
void
otLog::implicitSendEvent(const char* _ob_a0,
                         CORBA_Long _ob_a1,
                         const char* _ob_a2,
                         CORBA_Long _ob_a3,
                         const char* _ob_a4,
                         const AssignmentList& _ob_a5,
                         const TimerOpList& _ob_a6,
                         const char* _ob_a7,
                         const otMessage::SerializedMessage& _ob_a8)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "implicitSendEvent");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);
    OBMarshalCount(_ob_a5, _ob_cnt);
    OBMarshalCount(_ob_a6, _ob_cnt);
    OBMarshalCount(_ob_a7, _ob_cnt);
    OBMarshalCount(_ob_a8, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);
    OBMarshal(_ob_a5, _ob_o);
    OBMarshal(_ob_a6, _ob_o);
    OBMarshal(_ob_a7, _ob_o);
    OBMarshal(_ob_a8, _ob_o);

    _ob_con_ -> oneway(this, "implicitSendEvent", _ob_seq);
}

//
// IDL:otLog/sendEvent:1.0
//
void
otLog::sendEvent(const char* _ob_a0,
                 CORBA_Long _ob_a1,
                 const char* _ob_a2,
                 CORBA_Long _ob_a3,
                 const char* _ob_a4,
                 const AssignmentList& _ob_a5,
                 const TimerOpList& _ob_a6,
                 const char* _ob_a7,
                 const char* _ob_a8,
                 const otMessage::SerializedMessage& _ob_a9)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "sendEvent");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);
    OBMarshalCount(_ob_a5, _ob_cnt);
    OBMarshalCount(_ob_a6, _ob_cnt);
    OBMarshalCount(_ob_a7, _ob_cnt);
    OBMarshalCount(_ob_a8, _ob_cnt);
    OBMarshalCount(_ob_a9, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);
    OBMarshal(_ob_a5, _ob_o);
    OBMarshal(_ob_a6, _ob_o);
    OBMarshal(_ob_a7, _ob_o);
    OBMarshal(_ob_a8, _ob_o);
    OBMarshal(_ob_a9, _ob_o);

    _ob_con_ -> oneway(this, "sendEvent", _ob_seq);
}

//
// IDL:otLog/receiveEvent:1.0
//
void
otLog::receiveEvent(const char* _ob_a0,
                    CORBA_Long _ob_a1,
                    const char* _ob_a2,
                    CORBA_Long _ob_a3,
                    const char* _ob_a4,
                    const AssignmentList& _ob_a5,
                    const TimerOpList& _ob_a6,
                    const char* _ob_a7,
                    const char* _ob_a8,
                    const otMessage::SerializedMessage& _ob_a9)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "receiveEvent");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);
    OBMarshalCount(_ob_a5, _ob_cnt);
    OBMarshalCount(_ob_a6, _ob_cnt);
    OBMarshalCount(_ob_a7, _ob_cnt);
    OBMarshalCount(_ob_a8, _ob_cnt);
    OBMarshalCount(_ob_a9, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);
    OBMarshal(_ob_a5, _ob_o);
    OBMarshal(_ob_a6, _ob_o);
    OBMarshal(_ob_a7, _ob_o);
    OBMarshal(_ob_a8, _ob_o);
    OBMarshal(_ob_a9, _ob_o);

    _ob_con_ -> oneway(this, "receiveEvent", _ob_seq);
}

//
// IDL:otLog/otherwiseEvent:1.0
//
void
otLog::otherwiseEvent(const char* _ob_a0,
                      CORBA_Long _ob_a1,
                      const char* _ob_a2,
                      CORBA_Long _ob_a3,
                      const char* _ob_a4,
                      const AssignmentList& _ob_a5,
                      const TimerOpList& _ob_a6,
                      const char* _ob_a7,
                      const char* _ob_a8,
                      const otMessage::SerializedMessage& _ob_a9)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "otherwiseEvent");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);
    OBMarshalCount(_ob_a5, _ob_cnt);
    OBMarshalCount(_ob_a6, _ob_cnt);
    OBMarshalCount(_ob_a7, _ob_cnt);
    OBMarshalCount(_ob_a8, _ob_cnt);
    OBMarshalCount(_ob_a9, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);
    OBMarshal(_ob_a5, _ob_o);
    OBMarshal(_ob_a6, _ob_o);
    OBMarshal(_ob_a7, _ob_o);
    OBMarshal(_ob_a8, _ob_o);
    OBMarshal(_ob_a9, _ob_o);

    _ob_con_ -> oneway(this, "otherwiseEvent", _ob_seq);
}

//
// IDL:otLog/timeoutEvent:1.0
//
void
otLog::timeoutEvent(const char* _ob_a0,
                    CORBA_Long _ob_a1,
                    const char* _ob_a2,
                    CORBA_Long _ob_a3,
                    const char* _ob_a4,
                    const AssignmentList& _ob_a5,
                    const TimerOpList& _ob_a6,
                    const char* _ob_a7)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "timeoutEvent");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);
    OBMarshalCount(_ob_a5, _ob_cnt);
    OBMarshalCount(_ob_a6, _ob_cnt);
    OBMarshalCount(_ob_a7, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);
    OBMarshal(_ob_a5, _ob_o);
    OBMarshal(_ob_a6, _ob_o);
    OBMarshal(_ob_a7, _ob_o);

    _ob_con_ -> oneway(this, "timeoutEvent", _ob_seq);
}

//
// IDL:otLog/pseudoEvent:1.0
//
void
otLog::pseudoEvent(const char* _ob_a0,
                   CORBA_Long _ob_a1,
                   const char* _ob_a2,
                   CORBA_Long _ob_a3,
                   const char* _ob_a4,
                   const AssignmentList& _ob_a5,
                   const TimerOpList& _ob_a6)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "pseudoEvent");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);
    OBMarshalCount(_ob_a5, _ob_cnt);
    OBMarshalCount(_ob_a6, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);
    OBMarshal(_ob_a5, _ob_o);
    OBMarshal(_ob_a6, _ob_o);

    _ob_con_ -> oneway(this, "pseudoEvent", _ob_seq);
}

//
// IDL:otLog/attachEvent:1.0
//
void
otLog::attachEvent(const char* _ob_a0,
                   CORBA_Long _ob_a1,
                   const char* _ob_a2,
                   CORBA_Long _ob_a3,
                   const char* _ob_a4,
                   const char* _ob_a5)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "attachEvent");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);
    OBMarshalCount(_ob_a5, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);
    OBMarshal(_ob_a5, _ob_o);

    _ob_con_ -> oneway(this, "attachEvent", _ob_seq);
}

//
// IDL:otLog/repeatEvent:1.0
//
void
otLog::repeatEvent(const char* _ob_a0,
                   CORBA_Long _ob_a1,
                   const char* _ob_a2,
                   CORBA_Long _ob_a3,
                   const char* _ob_a4,
                   const char* _ob_a5)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "repeatEvent");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);
    OBMarshalCount(_ob_a5, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);
    OBMarshal(_ob_a5, _ob_o);

    _ob_con_ -> oneway(this, "repeatEvent", _ob_seq);
}

//
// IDL:otLog/gotoEvent:1.0
//
void
otLog::gotoEvent(const char* _ob_a0,
                 CORBA_Long _ob_a1,
                 const char* _ob_a2,
                 CORBA_Long _ob_a3,
                 const char* _ob_a4,
                 const char* _ob_a5)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "gotoEvent");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);
    OBMarshalCount(_ob_a5, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);
    OBMarshal(_ob_a5, _ob_o);

    _ob_con_ -> oneway(this, "gotoEvent", _ob_seq);
}

//
// IDL:otLog/returnEvent:1.0
//
void
otLog::returnEvent(const char* _ob_a0,
                   CORBA_Long _ob_a1,
                   const char* _ob_a2,
                   CORBA_Long _ob_a3,
                   const char* _ob_a4)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "returnEvent");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);

    _ob_con_ -> oneway(this, "returnEvent", _ob_seq);
}

//
// IDL:otLog/preliminaryPassEvent:1.0
//
void
otLog::preliminaryPassEvent(const char* _ob_a0,
                            CORBA_Long _ob_a1,
                            const char* _ob_a2,
                            CORBA_Long _ob_a3)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "preliminaryPassEvent");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);

    _ob_con_ -> oneway(this, "preliminaryPassEvent", _ob_seq);
}

//
// IDL:otLog/preliminaryInconcEvent:1.0
//
void
otLog::preliminaryInconcEvent(const char* _ob_a0,
                              CORBA_Long _ob_a1,
                              const char* _ob_a2,
                              CORBA_Long _ob_a3)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "preliminaryInconcEvent");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);

    _ob_con_ -> oneway(this, "preliminaryInconcEvent", _ob_seq);
}

//
// IDL:otLog/preliminaryFailEvent:1.0
//
void
otLog::preliminaryFailEvent(const char* _ob_a0,
                            CORBA_Long _ob_a1,
                            const char* _ob_a2,
                            CORBA_Long _ob_a3)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "preliminaryFailEvent");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);

    _ob_con_ -> oneway(this, "preliminaryFailEvent", _ob_seq);
}

//
// IDL:otLog/passEvent:1.0
//
void
otLog::passEvent(const char* _ob_a0,
                 CORBA_Long _ob_a1,
                 const char* _ob_a2,
                 CORBA_Long _ob_a3)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "passEvent");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);

    _ob_con_ -> oneway(this, "passEvent", _ob_seq);
}

//
// IDL:otLog/inconcEvent:1.0
//
void
otLog::inconcEvent(const char* _ob_a0,
                   CORBA_Long _ob_a1,
                   const char* _ob_a2,
                   CORBA_Long _ob_a3)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "inconcEvent");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);

    _ob_con_ -> oneway(this, "inconcEvent", _ob_seq);
}

//
// IDL:otLog/failEvent:1.0
//
void
otLog::failEvent(const char* _ob_a0,
                 CORBA_Long _ob_a1,
                 const char* _ob_a2,
                 CORBA_Long _ob_a3)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "failEvent");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);

    _ob_con_ -> oneway(this, "failEvent", _ob_seq);
}

//
// IDL:otLog/createEvent:1.0
//
void
otLog::createEvent(const char* _ob_a0,
                   CORBA_Long _ob_a1,
                   const char* _ob_a2,
                   CORBA_Long _ob_a3,
                   const char* _ob_a4,
                   const char* _ob_a5)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "createEvent");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);
    OBMarshalCount(_ob_a5, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);
    OBMarshal(_ob_a5, _ob_o);

    _ob_con_ -> oneway(this, "createEvent", _ob_seq);
}

//
// IDL:otLog/doneEvent:1.0
//
void
otLog::doneEvent(const char* _ob_a0,
                 CORBA_Long _ob_a1,
                 const char* _ob_a2,
                 CORBA_Long _ob_a3,
                 const char* _ob_a4,
                 const IdentifierList& _ob_a5)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "doneEvent");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);
    OBMarshalCount(_ob_a5, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);
    OBMarshal(_ob_a5, _ob_o);

    _ob_con_ -> oneway(this, "doneEvent", _ob_seq);
}

//
// IDL:otLog/activateEvent:1.0
//
void
otLog::activateEvent(const char* _ob_a0,
                     CORBA_Long _ob_a1,
                     const char* _ob_a2,
                     CORBA_Long _ob_a3,
                     const char* _ob_a4)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "activateEvent");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);

    _ob_con_ -> oneway(this, "activateEvent", _ob_seq);
}

//
// IDL:otLog/caseStartedEvent:1.0
//
void
otLog::caseStartedEvent(const char* _ob_a0,
                        CORBA_Long _ob_a1,
                        const char* _ob_a2,
                        const char* _ob_a3)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "caseStartedEvent");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);

    _ob_con_ -> oneway(this, "caseStartedEvent", _ob_seq);
}

//
// IDL:otLog/caseDoneEvent:1.0
//
void
otLog::caseDoneEvent(const char* _ob_a0,
                     CORBA_Long _ob_a1,
                     const char* _ob_a2,
                     const char* _ob_a3)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "caseDoneEvent");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);

    _ob_con_ -> oneway(this, "caseDoneEvent", _ob_seq);
}

//
// IDL:otLog/divideByZeroError:1.0
//
void
otLog::divideByZeroError(const char* _ob_a0,
                         CORBA_Long _ob_a1,
                         const char* _ob_a2,
                         CORBA_Long _ob_a3)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "divideByZeroError");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);

    _ob_con_ -> oneway(this, "divideByZeroError", _ob_seq);
}

//
// IDL:otLog/overflowError:1.0
//
void
otLog::overflowError(const char* _ob_a0,
                     CORBA_Long _ob_a1,
                     const char* _ob_a2,
                     CORBA_Long _ob_a3)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "overflowError");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);

    _ob_con_ -> oneway(this, "overflowError", _ob_seq);
}

//
// IDL:otLog/notSupportedOperationError:1.0
//
void
otLog::notSupportedOperationError(const char* _ob_a0,
                                  CORBA_Long _ob_a1,
                                  const char* _ob_a2,
                                  const char* _ob_a3,
                                  const char* _ob_a4,
                                  CORBA_Long _ob_a5)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "notSupportedOperationError");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);
    OBMarshalCount(_ob_a5, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);
    OBMarshal(_ob_a5, _ob_o);

    _ob_con_ -> oneway(this, "notSupportedOperationError", _ob_seq);
}

//
// IDL:otLog/elementNotFoundError:1.0
//
void
otLog::elementNotFoundError(const char* _ob_a0,
                            CORBA_Long _ob_a1,
                            const char* _ob_a2,
                            const char* _ob_a3,
                            CORBA_Long _ob_a4)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "elementNotFoundError");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);

    _ob_con_ -> oneway(this, "elementNotFoundError", _ob_seq);
}

//
// IDL:otLog/unboundError:1.0
//
void
otLog::unboundError(const char* _ob_a0,
                    CORBA_Long _ob_a1,
                    const char* _ob_a2,
                    const char* _ob_a3,
                    CORBA_Long _ob_a4)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "unboundError");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);

    _ob_con_ -> oneway(this, "unboundError", _ob_seq);
}

//
// IDL:otLog/deadlockError:1.0
//
void
otLog::deadlockError(const char* _ob_a0,
                     CORBA_Long _ob_a1,
                     const char* _ob_a2,
                     CORBA_Long _ob_a3)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "deadlockError");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);

    _ob_con_ -> oneway(this, "deadlockError", _ob_seq);
}

//
// IDL:otLog/verdictMissingError:1.0
//
void
otLog::verdictMissingError(const char* _ob_a0,
                           CORBA_Long _ob_a1,
                           const char* _ob_a2)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "verdictMissingError");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);

    _ob_con_ -> oneway(this, "verdictMissingError", _ob_seq);
}

//
// IDL:otLog/inconsistentVerdictError:1.0
//
void
otLog::inconsistentVerdictError(const char* _ob_a0,
                                CORBA_Long _ob_a1,
                                const char* _ob_a2)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "inconsistentVerdictError");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);

    _ob_con_ -> oneway(this, "inconsistentVerdictError", _ob_seq);
}

//
// IDL:otLog/incompatibleTypeError:1.0
//
void
otLog::incompatibleTypeError(const char* _ob_a0,
                             CORBA_Long _ob_a1,
                             const char* _ob_a2,
                             const char* _ob_a3,
                             CORBA_Long _ob_a4)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "incompatibleTypeError");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);

    _ob_con_ -> oneway(this, "incompatibleTypeError", _ob_seq);
}

//
// IDL:otLog/jumpToNowhereError:1.0
//
void
otLog::jumpToNowhereError(const char* _ob_a0,
                          CORBA_Long _ob_a1,
                          const char* _ob_a2,
                          const char* _ob_a3,
                          CORBA_Long _ob_a4)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "jumpToNowhereError");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);

    _ob_con_ -> oneway(this, "jumpToNowhereError", _ob_seq);
}

//
// IDL:otLog/tooManyParametersError:1.0
//
void
otLog::tooManyParametersError(const char* _ob_a0,
                              CORBA_Long _ob_a1,
                              const char* _ob_a2,
                              const char* _ob_a3,
                              CORBA_Long _ob_a4)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "tooManyParametersError");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);

    _ob_con_ -> oneway(this, "tooManyParametersError", _ob_seq);
}

//
// IDL:otLog/tooFewParametersError:1.0
//
void
otLog::tooFewParametersError(const char* _ob_a0,
                             CORBA_Long _ob_a1,
                             const char* _ob_a2,
                             const char* _ob_a3,
                             CORBA_Long _ob_a4)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "tooFewParametersError");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);

    _ob_con_ -> oneway(this, "tooFewParametersError", _ob_seq);
}

//
// IDL:otLog/wrongTypeOfParameterError:1.0
//
void
otLog::wrongTypeOfParameterError(const char* _ob_a0,
                                 CORBA_Long _ob_a1,
                                 const char* _ob_a2,
                                 const char* _ob_a3,
                                 CORBA_Long _ob_a4)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "wrongTypeOfParameterError");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);

    _ob_con_ -> oneway(this, "wrongTypeOfParameterError", _ob_seq);
}

//
// IDL:otLog/negativeValueError:1.0
//
void
otLog::negativeValueError(const char* _ob_a0,
                          CORBA_Long _ob_a1,
                          const char* _ob_a2,
                          const char* _ob_a3,
                          CORBA_Long _ob_a4)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "negativeValueError");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);

    _ob_con_ -> oneway(this, "negativeValueError", _ob_seq);
}

//
// IDL:otLog/negativeLengthError:1.0
//
void
otLog::negativeLengthError(const char* _ob_a0,
                           CORBA_Long _ob_a1,
                           const char* _ob_a2,
                           const char* _ob_a3,
                           CORBA_Long _ob_a4)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "negativeLengthError");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);

    _ob_con_ -> oneway(this, "negativeLengthError", _ob_seq);
}

//
// IDL:otLog/resultTooBigError:1.0
//
void
otLog::resultTooBigError(const char* _ob_a0,
                         CORBA_Long _ob_a1,
                         const char* _ob_a2,
                         const char* _ob_a3,
                         CORBA_Long _ob_a4)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "resultTooBigError");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);

    _ob_con_ -> oneway(this, "resultTooBigError", _ob_seq);
}

//
// IDL:otLog/outOfRangeError:1.0
//
void
otLog::outOfRangeError(const char* _ob_a0,
                       CORBA_Long _ob_a1,
                       const char* _ob_a2,
                       const char* _ob_a3,
                       CORBA_Long _ob_a4,
                       CORBA_Long _ob_a5,
                       CORBA_Long _ob_a6)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "outOfRangeError");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);
    OBMarshalCount(_ob_a5, _ob_cnt);
    OBMarshalCount(_ob_a6, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);
    OBMarshal(_ob_a5, _ob_o);
    OBMarshal(_ob_a6, _ob_o);

    _ob_con_ -> oneway(this, "outOfRangeError", _ob_seq);
}

//
// IDL:otLog/illegalObjectError:1.0
//
void
otLog::illegalObjectError(const char* _ob_a0,
                          CORBA_Long _ob_a1,
                          const char* _ob_a2,
                          const char* _ob_a3,
                          CORBA_Long _ob_a4)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "illegalObjectError");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);

    _ob_con_ -> oneway(this, "illegalObjectError", _ob_seq);
}

//
// IDL:otLog/incompleteExpressionError:1.0
//
void
otLog::incompleteExpressionError(const char* _ob_a0,
                                 CORBA_Long _ob_a1,
                                 const char* _ob_a2,
                                 CORBA_Long _ob_a3)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "incompleteExpressionError");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);

    _ob_con_ -> oneway(this, "incompleteExpressionError", _ob_seq);
}

//
// IDL:otLog/outOfMemory:1.0
//
void
otLog::outOfMemory(const char* _ob_a0,
                   CORBA_Long _ob_a1,
                   const char* _ob_a2)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "outOfMemory");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);

    _ob_con_ -> oneway(this, "outOfMemory", _ob_seq);
}

//
// IDL:otLog/zeroPointer:1.0
//
void
otLog::zeroPointer(const char* _ob_a0,
                   CORBA_Long _ob_a1,
                   const char* _ob_a2,
                   CORBA_Long _ob_a3,
                   const char* _ob_a4)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "zeroPointer");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);

    _ob_con_ -> oneway(this, "zeroPointer", _ob_seq);
}

//
// IDL:otLog/internalError:1.0
//
void
otLog::internalError(const char* _ob_a0,
                     CORBA_Long _ob_a1,
                     const char* _ob_a2,
                     CORBA_Long _ob_a3,
                     const char* _ob_a4)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "internalError");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);

    _ob_con_ -> oneway(this, "internalError", _ob_seq);
}

//
// IDL:otLog/unexpectedEvent:1.0
//
void
otLog::unexpectedEvent(const char* _ob_a0,
                       CORBA_Long _ob_a1,
                       const char* _ob_a2,
                       CORBA_Long _ob_a3,
                       const char* _ob_a4)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "unexpectedEvent");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);

    _ob_con_ -> oneway(this, "unexpectedEvent", _ob_seq);
}

//
// IDL:otLog/notImplemented:1.0
//
void
otLog::notImplemented(const char* _ob_a0,
                      CORBA_Long _ob_a1,
                      const char* _ob_a2,
                      CORBA_Long _ob_a3,
                      const char* _ob_a4)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "notImplemented");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);
    OBMarshalCount(_ob_a4, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);
    OBMarshal(_ob_a4, _ob_o);

    _ob_con_ -> oneway(this, "notImplemented", _ob_seq);
}

//
// IDL:otLog/communicationFailureWithDatabase:1.0
//
void
otLog::communicationFailureWithDatabase(const char* _ob_a0,
                                        CORBA_Long _ob_a1,
                                        const char* _ob_a2)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "communicationFailureWithDatabase");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);

    _ob_con_ -> oneway(this, "communicationFailureWithDatabase", _ob_seq);
}

//
// IDL:otLog/PCONotSpecified:1.0
//
void
otLog::PCONotSpecified(const char* _ob_a0,
                       CORBA_Long _ob_a1,
                       const char* _ob_a2,
                       const char* _ob_a3)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "PCONotSpecified");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);

    _ob_con_ -> oneway(this, "PCONotSpecified", _ob_seq);
}

//
// IDL:otLog/unreachablePCO:1.0
//
void
otLog::unreachablePCO(const char* _ob_a0,
                      CORBA_Long _ob_a1,
                      const char* _ob_a2,
                      const char* _ob_a3)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "unreachablePCO");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);

    _ob_con_ -> oneway(this, "unreachablePCO", _ob_seq);
}

//
// IDL:otLog/orbFailed:1.0
//
void
otLog::orbFailed(const char* _ob_a0,
                 CORBA_Long _ob_a1,
                 const char* _ob_a2)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "orbFailed");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);

    _ob_con_ -> oneway(this, "orbFailed", _ob_seq);
}

//
// IDL:otLog/objectCannotBeCreated:1.0
//
void
otLog::objectCannotBeCreated(const char* _ob_a0,
                             CORBA_Long _ob_a1,
                             const char* _ob_a2,
                             const char* _ob_a3)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "objectCannotBeCreated");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);

    _ob_con_ -> oneway(this, "objectCannotBeCreated", _ob_seq);
}

//
// IDL:otLog/receiverCannotDecode:1.0
//
void
otLog::receiverCannotDecode(const char* _ob_a0,
                            CORBA_Long _ob_a1,
                            const char* _ob_a2,
                            const char* _ob_a3)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "receiverCannotDecode");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);

    _ob_con_ -> oneway(this, "receiverCannotDecode", _ob_seq);
}

//
// IDL:otLog/operationNotImplemented:1.0
//
void
otLog::operationNotImplemented(const char* _ob_a0,
                               CORBA_Long _ob_a1,
                               const char* _ob_a2,
                               const char* _ob_a3)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "operationNotImplemented");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);

    _ob_con_ -> oneway(this, "operationNotImplemented", _ob_seq);
}

//
// IDL:otLog/operationEvaluationFailed:1.0
//
void
otLog::operationEvaluationFailed(const char* _ob_a0,
                                 CORBA_Long _ob_a1,
                                 const char* _ob_a2,
                                 const char* _ob_a3)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "operationEvaluationFailed");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);

    _ob_con_ -> oneway(this, "operationEvaluationFailed", _ob_seq);
}

//
// IDL:otLog/parameterRepositoryNotSpecified:1.0
//
void
otLog::parameterRepositoryNotSpecified(const char* _ob_a0,
                                       CORBA_Long _ob_a1,
                                       const char* _ob_a2)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "parameterRepositoryNotSpecified");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);

    _ob_con_ -> oneway(this, "parameterRepositoryNotSpecified", _ob_seq);
}

//
// IDL:otLog/versionInfo:1.0
//
void
otLog::versionInfo(const char* _ob_a0,
                   CORBA_Long _ob_a1,
                   const char* _ob_a2)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "versionInfo");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);

    _ob_con_ -> oneway(this, "versionInfo", _ob_seq);
}

//
// IDL:otLog/treeStartedInfo:1.0
//
void
otLog::treeStartedInfo(const char* _ob_a0,
                       CORBA_Long _ob_a1,
                       const char* _ob_a2,
                       const char* _ob_a3)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "treeStartedInfo");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);

    _ob_con_ -> oneway(this, "treeStartedInfo", _ob_seq);
}

//
// IDL:otLog/treeDoneInfo:1.0
//
void
otLog::treeDoneInfo(const char* _ob_a0,
                    CORBA_Long _ob_a1,
                    const char* _ob_a2,
                    const char* _ob_a3)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "treeDoneInfo");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);

    _ob_con_ -> oneway(this, "treeDoneInfo", _ob_seq);
}

//
// IDL:otLog/defaultStartedInfo:1.0
//
void
otLog::defaultStartedInfo(const char* _ob_a0,
                          CORBA_Long _ob_a1,
                          const char* _ob_a2,
                          const char* _ob_a3)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "defaultStartedInfo");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);

    _ob_con_ -> oneway(this, "defaultStartedInfo", _ob_seq);
}

//
// IDL:otLog/defaultDoneInfo:1.0
//
void
otLog::defaultDoneInfo(const char* _ob_a0,
                       CORBA_Long _ob_a1,
                       const char* _ob_a2,
                       const char* _ob_a3)
{
    if(CORBA_is_nil(_ob_con_))
        throw CORBA_NO_IMPLEMENT();

    CORBA_ULong _ob_off = _ob_con_ -> offset(this, "defaultDoneInfo");
    CORBA_ULong _ob_cnt = _ob_off;
    OBMarshalCount(_ob_a0, _ob_cnt);
    OBMarshalCount(_ob_a1, _ob_cnt);
    OBMarshalCount(_ob_a2, _ob_cnt);
    OBMarshalCount(_ob_a3, _ob_cnt);

    OBFixSeq< CORBA_Octet > _ob_seq(_ob_cnt);
    _ob_seq.length(_ob_cnt);
#ifdef OB_CLEAR_MEM
    memset(_ob_seq.data(), 0, _ob_seq.length());
#endif
    CORBA_Octet* _ob_o = _ob_seq.data() + _ob_off;
    OBMarshal(_ob_a0, _ob_o);
    OBMarshal(_ob_a1, _ob_o);
    OBMarshal(_ob_a2, _ob_o);
    OBMarshal(_ob_a3, _ob_o);

    _ob_con_ -> oneway(this, "defaultDoneInfo", _ob_seq);
}

//
// OBVarSeq< otMessage::Element >
//
#ifdef OB_use_OBVarSeq_otMessage_Element_from_log_h

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarSeq< otMessage::Element >;
template class OBSeqVar< OBVarSeq< otMessage::Element > >;
#endif

void
OBMarshal(const OBVarSeq< otMessage::Element >& seq, CORBA_Octet*& oct)
{
    OBMarshal(seq.length(), oct);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshal(seq[i], oct);
}

void
OBMarshalCount(const OBVarSeq< otMessage::Element >& seq, CORBA_ULong& count)
{
    OBMarshalCount(seq.length(), count);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshalCount(seq[i], count);
}

void
OBUnmarshal(OBVarSeq< otMessage::Element >& seq, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ULong len;
    OBUnmarshal(len, coct, swap);
    seq.length(len);
    for(CORBA_ULong i = 0 ; i < len ; i++)
        OBUnmarshal(seq[i], coct, swap);
}

static const OBTypeCodeConst _tc_OBVarSeq_otMessage_Element(
"010000001300000050010000010000000F00000040010000010000001A00000049444C3A6F744"
"D6573736167652F456C656D656E743A312E3000000008000000456C656D656E74000400000005"
"0000006B696E640000000011000000BB000000010000001E00000049444C3A6F744D657373616"
"7652F456C656D656E744B696E643A312E300000000C000000456C656D656E744B696E64000800"
"00000D0000004265674F66456C656D656E74000000000D000000456E644F66456C656D656E740"
"000000008000000496E74656765720008000000426F6F6C65616E000A00000042697453747269"
"6E670000000A000000486578537472696E670000000C0000004F63746574537472696E67000B0"
"0000043686172537472696E6700000B0000006964656E74696669657200001200000000000000"
"0600000076616C75650000001200000000000000070000006E756D62657200000300000000000"
"000"
);

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBInfo< OBVarSeq< otMessage::Element > >;
#endif

void
operator<<=(CORBA_Any& any, OBVarSeq< otMessage::Element >* p)
{
    static const OBInfo< OBVarSeq< otMessage::Element > > info;
    any.replace(_tc_OBVarSeq_otMessage_Element, p, true, &info);
}

void
operator<<=(CORBA_Any& any, const OBVarSeq< otMessage::Element >& seq)
{
    static const OBInfo< OBVarSeq< otMessage::Element > > info;
    OBVarSeq< otMessage::Element >* p = new OBVarSeq< otMessage::Element >(seq);
    any.replace(_tc_OBVarSeq_otMessage_Element, p, true, &info);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, OBVarSeq< otMessage::Element >*& p)
{
    if(any.check_type(_tc_OBVarSeq_otMessage_Element))
    {
        if(!any.info())
        {
            const CORBA_Octet* coct = (CORBA_Octet*)any.value() + 4;
            OBVarSeq< otMessage::Element >* v = new OBVarSeq< otMessage::Element >;
            OBUnmarshal(*v, coct, false);
            (CORBA_Any&)any <<= v;
        }

        p = (OBVarSeq< otMessage::Element >*)any.value();
        return true;
    }
    else
        return false;
}

#endif

//
// OBVarSeq< otLog::TimerOpInformation >
//
#ifdef OB_use_OBVarSeq_otLog_TimerOpInformation_from_log_h

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarSeq< otLog::TimerOpInformation >;
template class OBSeqVar< OBVarSeq< otLog::TimerOpInformation > >;
#endif

void
OBMarshal(const OBVarSeq< otLog::TimerOpInformation >& seq, CORBA_Octet*& oct)
{
    OBMarshal(seq.length(), oct);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshal(seq[i], oct);
}

void
OBMarshalCount(const OBVarSeq< otLog::TimerOpInformation >& seq, CORBA_ULong& count)
{
    OBMarshalCount(seq.length(), count);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshalCount(seq[i], count);
}

void
OBUnmarshal(OBVarSeq< otLog::TimerOpInformation >& seq, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ULong len;
    OBUnmarshal(len, coct, swap);
    seq.length(len);
    for(CORBA_ULong i = 0 ; i < len ; i++)
        OBUnmarshal(seq[i], coct, swap);
}

static const OBTypeCodeConst _tc_OBVarSeq_otLog_TimerOpInformation(
"01000000130000002C010000010000000F0000001C010000010000002100000049444C3A6F744"
"C6F672F54696D65724F70496E666F726D6174696F6E3A312E30000000001300000054696D6572"
"4F70496E666F726D6174696F6E0000050000000B0000006964656E74696669657200001200000"
"00000000008000000656C61707365640012000000000000000800000072756E6E696E67000800"
"0000030000006F700000110000006E000000010000001D00000049444C3A6F744C6F672F54696"
"D65724F7065726174696F6E3A312E30000000000F00000054696D65724F7065726174696F6E00"
"00030000000B000000737461727454696D657200000C00000063616E63656C54696D6572000A0"
"000007265616454696D6572000000090000006475726174696F6E000000001200000000000000"
"00000000"
);

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBInfo< OBVarSeq< otLog::TimerOpInformation > >;
#endif

void
operator<<=(CORBA_Any& any, OBVarSeq< otLog::TimerOpInformation >* p)
{
    static const OBInfo< OBVarSeq< otLog::TimerOpInformation > > info;
    any.replace(_tc_OBVarSeq_otLog_TimerOpInformation, p, true, &info);
}

void
operator<<=(CORBA_Any& any, const OBVarSeq< otLog::TimerOpInformation >& seq)
{
    static const OBInfo< OBVarSeq< otLog::TimerOpInformation > > info;
    OBVarSeq< otLog::TimerOpInformation >* p = new OBVarSeq< otLog::TimerOpInformation >(seq);
    any.replace(_tc_OBVarSeq_otLog_TimerOpInformation, p, true, &info);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, OBVarSeq< otLog::TimerOpInformation >*& p)
{
    if(any.check_type(_tc_OBVarSeq_otLog_TimerOpInformation))
    {
        if(!any.info())
        {
            const CORBA_Octet* coct = (CORBA_Octet*)any.value() + 4;
            OBVarSeq< otLog::TimerOpInformation >* v = new OBVarSeq< otLog::TimerOpInformation >;
            OBUnmarshal(*v, coct, false);
            (CORBA_Any&)any <<= v;
        }

        p = (OBVarSeq< otLog::TimerOpInformation >*)any.value();
        return true;
    }
    else
        return false;
}

#endif

//
// OBVarSeq< otLog::Assignment >
//
#ifdef OB_use_OBVarSeq_otLog_Assignment_from_log_h

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBVarSeq< otLog::Assignment >;
template class OBSeqVar< OBVarSeq< otLog::Assignment > >;
#endif

void
OBMarshal(const OBVarSeq< otLog::Assignment >& seq, CORBA_Octet*& oct)
{
    OBMarshal(seq.length(), oct);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshal(seq[i], oct);
}

void
OBMarshalCount(const OBVarSeq< otLog::Assignment >& seq, CORBA_ULong& count)
{
    OBMarshalCount(seq.length(), count);
    for(CORBA_ULong i = 0 ; i < seq.length() ; i++)
        OBMarshalCount(seq[i], count);
}

void
OBUnmarshal(OBVarSeq< otLog::Assignment >& seq, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ULong len;
    OBUnmarshal(len, coct, swap);
    seq.length(len);
    for(CORBA_ULong i = 0 ; i < len ; i++)
        OBUnmarshal(seq[i], coct, swap);
}

static const OBTypeCodeConst _tc_OBVarSeq_otLog_Assignment(
"010000001300000028020000010000000F00000018020000010000001900000049444C3A6F744"
"C6F672F41737369676E6D656E743A312E30000000000B00000041737369676E6D656E74000003"
"0000000B0000006964656E746966696572000012000000000000000A000000636F6D706F6E656"
"E7400000012000000000000000600000076616C7565000000150000009C010000010000002400"
"000049444C3A6F744D6573736167652F53657269616C697A65644D6573736167653A312E30001"
"200000053657269616C697A65644D6573736167650000001300000050010000010000000F0000"
"0040010000010000001A00000049444C3A6F744D6573736167652F456C656D656E743A312E300"
"0000008000000456C656D656E740004000000050000006B696E640000000011000000BB000000"
"010000001E00000049444C3A6F744D6573736167652F456C656D656E744B696E643A312E30000"
"0000C000000456C656D656E744B696E6400080000000D0000004265674F66456C656D656E7400"
"0000000D000000456E644F66456C656D656E740000000008000000496E7465676572000800000"
"0426F6F6C65616E000A000000426974537472696E670000000A000000486578537472696E6700"
"00000C0000004F63746574537472696E67000B00000043686172537472696E6700000B0000006"
"964656E746966696572000012000000000000000600000076616C756500000012000000000000"
"00070000006E756D6265720000030000000000000000000000"
);

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBInfo< OBVarSeq< otLog::Assignment > >;
#endif

void
operator<<=(CORBA_Any& any, OBVarSeq< otLog::Assignment >* p)
{
    static const OBInfo< OBVarSeq< otLog::Assignment > > info;
    any.replace(_tc_OBVarSeq_otLog_Assignment, p, true, &info);
}

void
operator<<=(CORBA_Any& any, const OBVarSeq< otLog::Assignment >& seq)
{
    static const OBInfo< OBVarSeq< otLog::Assignment > > info;
    OBVarSeq< otLog::Assignment >* p = new OBVarSeq< otLog::Assignment >(seq);
    any.replace(_tc_OBVarSeq_otLog_Assignment, p, true, &info);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, OBVarSeq< otLog::Assignment >*& p)
{
    if(any.check_type(_tc_OBVarSeq_otLog_Assignment))
    {
        if(!any.info())
        {
            const CORBA_Octet* coct = (CORBA_Octet*)any.value() + 4;
            OBVarSeq< otLog::Assignment >* v = new OBVarSeq< otLog::Assignment >;
            OBUnmarshal(*v, coct, false);
            (CORBA_Any&)any <<= v;
        }

        p = (OBVarSeq< otLog::Assignment >*)any.value();
        return true;
    }
    else
        return false;
}

#endif

//
// OBStrSeq
//
#ifdef OB_use_OBStrSeq_from_log_h

static const OBTypeCodeConst _tc_OBStrSeq(
"01000000130000001000000001000000120000000000000000000000"
);

#ifndef HAVE_NO_EXPLICIT_TEMPLATES
template class OBInfo< OBStrSeq >;
#endif

void
operator<<=(CORBA_Any& any, OBStrSeq* p)
{
    static const OBInfo< OBStrSeq > info;
    any.replace(_tc_OBStrSeq, p, true, &info);
}

void
operator<<=(CORBA_Any& any, const OBStrSeq& seq)
{
    static const OBInfo< OBStrSeq > info;
    OBStrSeq* p = new OBStrSeq(seq);
    any.replace(_tc_OBStrSeq, p, true, &info);
}

CORBA_Boolean
operator>>=(const CORBA_Any& any, OBStrSeq*& p)
{
    if(any.check_type(_tc_OBStrSeq))
    {
        if(!any.info())
        {
            const CORBA_Octet* coct = (CORBA_Octet*)any.value() + 4;
            OBStrSeq* v = new OBStrSeq;
            OBUnmarshal(*v, coct, false);
            (CORBA_Any&)any <<= v;
        }

        p = (OBStrSeq*)any.value();
        return true;
    }
    else
        return false;
}

#endif
