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

#ifndef __log_h__
#define __log_h__

#include <msg.h>

//
// IDL:otMessage:1.0
//
class otMessage;
typedef otMessage* otMessage_ptr;
typedef otMessage* otMessageRef;
typedef OBObjVar< otMessage > otMessage_var;

//
// IDL:otLog:1.0
//
class otLog;
typedef otLog* otLog_ptr;
typedef otLog* otLogRef;
typedef OBObjVar< otLog > otLog_var;

//
// IDL:otLog:1.0
//
class otLog : virtual public CORBA_Object
{
    otLog(const otLog&);
    void operator=(const otLog&);

protected:

    otLog() { }

public:

    static inline otLog_ptr
    _duplicate(otLog_ptr p)
    {
        CORBA_Object::_duplicate(p);
        return p;
    }

    static inline otLog_ptr
    _nil()
    {
        return 0;
    }

    static otLog_ptr _narrow(CORBA_Object_ptr);
    virtual void* _OB_narrowHelp(const char*) const;
    virtual const char* _OB_typeId() const;

    friend void OBUnmarshal(otLog_ptr&, const CORBA_Octet*&, bool);
    friend CORBA_Boolean operator>>=(const CORBA_Any&, otLog_ptr&);

    //
    // IDL:otLog/Assignment:1.0
    //
    struct Assignment
    {
        Assignment() { }
        Assignment(const Assignment&);
        Assignment& operator=(const Assignment&);

        CORBA_String_var identifier;
        CORBA_String_var component;
        otMessage::SerializedMessage value;
    };

    typedef OBVarVar< Assignment > Assignment_var;

    static const OBTypeCodeConst _tc_Assignment;

    //
    // IDL:otLog/TimerOperation:1.0
    //
    enum TimerOperation
    {
        startTimer,
        cancelTimer,
        readTimer
    };

    static const OBTypeCodeConst _tc_TimerOperation;

    //
    // IDL:otLog/TimerOpInformation:1.0
    //
    struct TimerOpInformation
    {
#ifdef OB_CLEAR_MEM
        TimerOpInformation();
#else
        TimerOpInformation() { }
#endif
        TimerOpInformation(const TimerOpInformation&);
        TimerOpInformation& operator=(const TimerOpInformation&);

        CORBA_String_var identifier;
        CORBA_String_var elapsed;
        CORBA_Boolean running;
        TimerOperation op;
        CORBA_String_var duration;
    };

    typedef OBVarVar< TimerOpInformation > TimerOpInformation_var;

    static const OBTypeCodeConst _tc_TimerOpInformation;

    //
    // IDL:otLog/TimerOpList:1.0
    //
    typedef OBVarSeq< TimerOpInformation > TimerOpList;
    typedef OBSeqVar< OBVarSeq< TimerOpInformation > > TimerOpList_var;
    static const OBTypeCodeConst _tc_TimerOpList;

    //
    // IDL:otLog/AssignmentList:1.0
    //
    typedef OBVarSeq< Assignment > AssignmentList;
    typedef OBSeqVar< OBVarSeq< Assignment > > AssignmentList_var;
    static const OBTypeCodeConst _tc_AssignmentList;

    //
    // IDL:otLog/IdentifierList:1.0
    //
    typedef OBStrSeq IdentifierList;
    typedef OBSeqVar< OBStrSeq > IdentifierList_var;
    static const OBTypeCodeConst _tc_IdentifierList;

    //
    // IDL:otLog/implicitSendEvent:1.0
    //
    virtual void implicitSendEvent(const char* sender,
                                   CORBA_Long seq,
                                   const char* time,
                                   CORBA_Long line,
                                   const char* label,
                                   const AssignmentList& assignments,
                                   const TimerOpList& ops,
                                   const char* identifier,
                                   const otMessage::SerializedMessage& message);

    //
    // IDL:otLog/sendEvent:1.0
    //
    virtual void sendEvent(const char* sender,
                           CORBA_Long seq,
                           const char* time,
                           CORBA_Long line,
                           const char* label,
                           const AssignmentList& assignments,
                           const TimerOpList& ops,
                           const char* pco,
                           const char* identifier,
                           const otMessage::SerializedMessage& message);

    //
    // IDL:otLog/receiveEvent:1.0
    //
    virtual void receiveEvent(const char* sender,
                              CORBA_Long seq,
                              const char* time,
                              CORBA_Long line,
                              const char* label,
                              const AssignmentList& assignments,
                              const TimerOpList& ops,
                              const char* pco,
                              const char* identifier,
                              const otMessage::SerializedMessage& message);

    //
    // IDL:otLog/otherwiseEvent:1.0
    //
    virtual void otherwiseEvent(const char* sender,
                                CORBA_Long seq,
                                const char* time,
                                CORBA_Long line,
                                const char* label,
                                const AssignmentList& assignments,
                                const TimerOpList& ops,
                                const char* pco,
                                const char* identifier,
                                const otMessage::SerializedMessage& message);

    //
    // IDL:otLog/timeoutEvent:1.0
    //
    virtual void timeoutEvent(const char* sender,
                              CORBA_Long seq,
                              const char* time,
                              CORBA_Long line,
                              const char* label,
                              const AssignmentList& assignments,
                              const TimerOpList& ops,
                              const char* timer);

    //
    // IDL:otLog/pseudoEvent:1.0
    //
    virtual void pseudoEvent(const char* sender,
                             CORBA_Long seq,
                             const char* time,
                             CORBA_Long line,
                             const char* label,
                             const AssignmentList& assignments,
                             const TimerOpList& ops);

    //
    // IDL:otLog/attachEvent:1.0
    //
    virtual void attachEvent(const char* sender,
                             CORBA_Long seq,
                             const char* time,
                             CORBA_Long line,
                             const char* label,
                             const char* tree);

    //
    // IDL:otLog/repeatEvent:1.0
    //
    virtual void repeatEvent(const char* sender,
                             CORBA_Long seq,
                             const char* time,
                             CORBA_Long line,
                             const char* label,
                             const char* tree);

    //
    // IDL:otLog/gotoEvent:1.0
    //
    virtual void gotoEvent(const char* sender,
                           CORBA_Long seq,
                           const char* time,
                           CORBA_Long line,
                           const char* label,
                           const char* identifier);

    //
    // IDL:otLog/returnEvent:1.0
    //
    virtual void returnEvent(const char* sender,
                             CORBA_Long seq,
                             const char* time,
                             CORBA_Long line,
                             const char* label);

    //
    // IDL:otLog/preliminaryPassEvent:1.0
    //
    virtual void preliminaryPassEvent(const char* sender,
                                      CORBA_Long seq,
                                      const char* time,
                                      CORBA_Long line);

    //
    // IDL:otLog/preliminaryInconcEvent:1.0
    //
    virtual void preliminaryInconcEvent(const char* sender,
                                        CORBA_Long seq,
                                        const char* time,
                                        CORBA_Long line);

    //
    // IDL:otLog/preliminaryFailEvent:1.0
    //
    virtual void preliminaryFailEvent(const char* sender,
                                      CORBA_Long seq,
                                      const char* time,
                                      CORBA_Long line);

    //
    // IDL:otLog/passEvent:1.0
    //
    virtual void passEvent(const char* sender,
                           CORBA_Long seq,
                           const char* time,
                           CORBA_Long line);

    //
    // IDL:otLog/inconcEvent:1.0
    //
    virtual void inconcEvent(const char* sender,
                             CORBA_Long seq,
                             const char* time,
                             CORBA_Long line);

    //
    // IDL:otLog/failEvent:1.0
    //
    virtual void failEvent(const char* sender,
                           CORBA_Long seq,
                           const char* time,
                           CORBA_Long line);

    //
    // IDL:otLog/createEvent:1.0
    //
    virtual void createEvent(const char* sender,
                             CORBA_Long seq,
                             const char* time,
                             CORBA_Long line,
                             const char* label,
                             const char* component);

    //
    // IDL:otLog/doneEvent:1.0
    //
    virtual void doneEvent(const char* sender,
                           CORBA_Long seq,
                           const char* time,
                           CORBA_Long line,
                           const char* label,
                           const IdentifierList& components);

    //
    // IDL:otLog/activateEvent:1.0
    //
    virtual void activateEvent(const char* sender,
                               CORBA_Long seq,
                               const char* time,
                               CORBA_Long line,
                               const char* label);

    //
    // IDL:otLog/caseStartedEvent:1.0
    //
    virtual void caseStartedEvent(const char* sender,
                                  CORBA_Long seq,
                                  const char* time,
                                  const char* identifier);

    //
    // IDL:otLog/caseDoneEvent:1.0
    //
    virtual void caseDoneEvent(const char* sender,
                               CORBA_Long seq,
                               const char* time,
                               const char* identifier);

    //
    // IDL:otLog/divideByZeroError:1.0
    //
    virtual void divideByZeroError(const char* sender,
                                   CORBA_Long seq,
                                   const char* time,
                                   CORBA_Long line);

    //
    // IDL:otLog/overflowError:1.0
    //
    virtual void overflowError(const char* sender,
                               CORBA_Long seq,
                               const char* time,
                               CORBA_Long line);

    //
    // IDL:otLog/notSupportedOperationError:1.0
    //
    virtual void notSupportedOperationError(const char* sender,
                                            CORBA_Long seq,
                                            const char* time,
                                            const char* operation,
                                            const char* of,
                                            CORBA_Long line);

    //
    // IDL:otLog/elementNotFoundError:1.0
    //
    virtual void elementNotFoundError(const char* sender,
                                      CORBA_Long seq,
                                      const char* time,
                                      const char* identifier,
                                      CORBA_Long line);

    //
    // IDL:otLog/unboundError:1.0
    //
    virtual void unboundError(const char* sender,
                              CORBA_Long seq,
                              const char* time,
                              const char* identifier,
                              CORBA_Long line);

    //
    // IDL:otLog/deadlockError:1.0
    //
    virtual void deadlockError(const char* sender,
                               CORBA_Long seq,
                               const char* time,
                               CORBA_Long line);

    //
    // IDL:otLog/verdictMissingError:1.0
    //
    virtual void verdictMissingError(const char* sender,
                                     CORBA_Long seq,
                                     const char* time);

    //
    // IDL:otLog/inconsistentVerdictError:1.0
    //
    virtual void inconsistentVerdictError(const char* sender,
                                          CORBA_Long seq,
                                          const char* time);

    //
    // IDL:otLog/incompatibleTypeError:1.0
    //
    virtual void incompatibleTypeError(const char* sender,
                                       CORBA_Long seq,
                                       const char* time,
                                       const char* identifier,
                                       CORBA_Long line);

    //
    // IDL:otLog/jumpToNowhereError:1.0
    //
    virtual void jumpToNowhereError(const char* sender,
                                    CORBA_Long seq,
                                    const char* time,
                                    const char* identifier,
                                    CORBA_Long line);

    //
    // IDL:otLog/tooManyParametersError:1.0
    //
    virtual void tooManyParametersError(const char* sender,
                                        CORBA_Long seq,
                                        const char* time,
                                        const char* identifier,
                                        CORBA_Long line);

    //
    // IDL:otLog/tooFewParametersError:1.0
    //
    virtual void tooFewParametersError(const char* sender,
                                       CORBA_Long seq,
                                       const char* time,
                                       const char* identifier,
                                       CORBA_Long line);

    //
    // IDL:otLog/wrongTypeOfParameterError:1.0
    //
    virtual void wrongTypeOfParameterError(const char* sender,
                                           CORBA_Long seq,
                                           const char* time,
                                           const char* identifier,
                                           CORBA_Long line);

    //
    // IDL:otLog/negativeValueError:1.0
    //
    virtual void negativeValueError(const char* sender,
                                    CORBA_Long seq,
                                    const char* time,
                                    const char* identifier,
                                    CORBA_Long line);

    //
    // IDL:otLog/negativeLengthError:1.0
    //
    virtual void negativeLengthError(const char* sender,
                                     CORBA_Long seq,
                                     const char* time,
                                     const char* identifier,
                                     CORBA_Long line);

    //
    // IDL:otLog/resultTooBigError:1.0
    //
    virtual void resultTooBigError(const char* sender,
                                   CORBA_Long seq,
                                   const char* time,
                                   const char* identifier,
                                   CORBA_Long line);

    //
    // IDL:otLog/outOfRangeError:1.0
    //
    virtual void outOfRangeError(const char* sender,
                                 CORBA_Long seq,
                                 const char* time,
                                 const char* identifier,
                                 CORBA_Long asked,
                                 CORBA_Long max,
                                 CORBA_Long line);

    //
    // IDL:otLog/illegalObjectError:1.0
    //
    virtual void illegalObjectError(const char* sender,
                                    CORBA_Long seq,
                                    const char* time,
                                    const char* identifier,
                                    CORBA_Long line);

    //
    // IDL:otLog/incompleteExpressionError:1.0
    //
    virtual void incompleteExpressionError(const char* sender,
                                           CORBA_Long seq,
                                           const char* time,
                                           CORBA_Long line);

    //
    // IDL:otLog/outOfMemory:1.0
    //
    virtual void outOfMemory(const char* sender,
                             CORBA_Long seq,
                             const char* time);

    //
    // IDL:otLog/zeroPointer:1.0
    //
    virtual void zeroPointer(const char* sender,
                             CORBA_Long seq,
                             const char* time,
                             CORBA_Long line,
                             const char* file);

    //
    // IDL:otLog/internalError:1.0
    //
    virtual void internalError(const char* sender,
                               CORBA_Long seq,
                               const char* time,
                               CORBA_Long line,
                               const char* file);

    //
    // IDL:otLog/unexpectedEvent:1.0
    //
    virtual void unexpectedEvent(const char* sender,
                                 CORBA_Long seq,
                                 const char* time,
                                 CORBA_Long line,
                                 const char* file);

    //
    // IDL:otLog/notImplemented:1.0
    //
    virtual void notImplemented(const char* sender,
                                CORBA_Long seq,
                                const char* time,
                                CORBA_Long line,
                                const char* file);

    //
    // IDL:otLog/communicationFailureWithDatabase:1.0
    //
    virtual void communicationFailureWithDatabase(const char* sender,
                                                  CORBA_Long seq,
                                                  const char* time);

    //
    // IDL:otLog/PCONotSpecified:1.0
    //
    virtual void PCONotSpecified(const char* sender,
                                 CORBA_Long seq,
                                 const char* time,
                                 const char* identifier);

    //
    // IDL:otLog/unreachablePCO:1.0
    //
    virtual void unreachablePCO(const char* sender,
                                CORBA_Long seq,
                                const char* time,
                                const char* identifier);

    //
    // IDL:otLog/orbFailed:1.0
    //
    virtual void orbFailed(const char* sender,
                           CORBA_Long seq,
                           const char* time);

    //
    // IDL:otLog/objectCannotBeCreated:1.0
    //
    virtual void objectCannotBeCreated(const char* sender,
                                       CORBA_Long seq,
                                       const char* time,
                                       const char* identifier);

    //
    // IDL:otLog/receiverCannotDecode:1.0
    //
    virtual void receiverCannotDecode(const char* sender,
                                      CORBA_Long seq,
                                      const char* time,
                                      const char* identifier);

    //
    // IDL:otLog/operationNotImplemented:1.0
    //
    virtual void operationNotImplemented(const char* sender,
                                         CORBA_Long seq,
                                         const char* time,
                                         const char* identifier);

    //
    // IDL:otLog/operationEvaluationFailed:1.0
    //
    virtual void operationEvaluationFailed(const char* sender,
                                           CORBA_Long seq,
                                           const char* time,
                                           const char* identifier);

    //
    // IDL:otLog/parameterRepositoryNotSpecified:1.0
    //
    virtual void parameterRepositoryNotSpecified(const char* sender,
                                                 CORBA_Long seq,
                                                 const char* time);

    //
    // IDL:otLog/versionInfo:1.0
    //
    virtual void versionInfo(const char* sender,
                             CORBA_Long seq,
                             const char* time);

    //
    // IDL:otLog/treeStartedInfo:1.0
    //
    virtual void treeStartedInfo(const char* sender,
                                 CORBA_Long seq,
                                 const char* time,
                                 const char* identifier);

    //
    // IDL:otLog/treeDoneInfo:1.0
    //
    virtual void treeDoneInfo(const char* sender,
                              CORBA_Long seq,
                              const char* time,
                              const char* identifier);

    //
    // IDL:otLog/defaultStartedInfo:1.0
    //
    virtual void defaultStartedInfo(const char* sender,
                                    CORBA_Long seq,
                                    const char* time,
                                    const char* identifier);

    //
    // IDL:otLog/defaultDoneInfo:1.0
    //
    virtual void defaultDoneInfo(const char* sender,
                                 CORBA_Long seq,
                                 const char* time,
                                 const char* identifier);
};

extern const OBTypeCodeConst _tc_otLog;

//
// IDL:otLog:1.0
//
inline void
CORBA_release(otLog_ptr p)
{
    CORBA_release((CORBA_Object_ptr)p);
}

inline CORBA_Boolean
CORBA_is_nil(otLog_ptr p)
{
    return p == 0;
}

inline void
OBMarshal(otLog_ptr p, CORBA_Octet*& oct)
{
    OBMarshal((CORBA_Object_ptr)p, oct);
}

inline void
OBMarshalCount(otLog_ptr p, CORBA_ULong& count)
{
    OBMarshalCount((CORBA_Object_ptr)p, count);
}

void OBUnmarshal(otLog_ptr&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, otLog_ptr);
void operator<<=(CORBA_Any&, otLog_ptr*);
CORBA_Boolean operator>>=(const CORBA_Any&, otLog_ptr&);

inline void
operator<<=(CORBA_Any_var& any, otLog_ptr val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA_Any_var& any, otLog_ptr* val)
{
    any.inout() <<= val;
}

inline CORBA_Boolean
operator>>=(const CORBA_Any_var& any, otLog_ptr& val)
{
    return any.in() >>= val;
}

//
// IDL:otLog/Assignment:1.0
//
void OBMarshal(const otLog::Assignment&, CORBA_Octet*&);
void OBMarshalCount(const otLog::Assignment&, CORBA_ULong&);
void OBUnmarshal(otLog::Assignment&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, otLog::Assignment*);
void operator<<=(CORBA_Any&, const otLog::Assignment&);
CORBA_Boolean operator>>=(const CORBA_Any&, otLog::Assignment*&);

inline void
operator<<=(CORBA_Any_var& any, otLog::Assignment* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA_Any_var& any, const otLog::Assignment& val)
{
    any.inout() <<= val;
}

inline CORBA_Boolean
operator>>=(const CORBA_Any_var& any, otLog::Assignment*& val)
{
    return any.in() >>= val;
}

//
// IDL:otLog/TimerOperation:1.0
//
inline void
OBMarshal(otLog::TimerOperation val, CORBA_Octet*& oct)
{
    OBMarshal((CORBA_ULong)val, oct);
}

inline void
OBMarshalCount(otLog::TimerOperation, CORBA_ULong& count)
{
    OBMarshalCount(0L, count);
}

inline void
OBUnmarshal(otLog::TimerOperation& val, const CORBA_Octet*& coct, bool swap)
{
    CORBA_ULong v;
    OBUnmarshal(v, coct, swap);
    val = (otLog::TimerOperation)v;
}

void operator<<=(CORBA_Any&, otLog::TimerOperation);
CORBA_Boolean operator>>=(const CORBA_Any&, otLog::TimerOperation&);

//
// IDL:otLog/TimerOpInformation:1.0
//
void OBMarshal(const otLog::TimerOpInformation&, CORBA_Octet*&);
void OBMarshalCount(const otLog::TimerOpInformation&, CORBA_ULong&);
void OBUnmarshal(otLog::TimerOpInformation&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, otLog::TimerOpInformation*);
void operator<<=(CORBA_Any&, const otLog::TimerOpInformation&);
CORBA_Boolean operator>>=(const CORBA_Any&, otLog::TimerOpInformation*&);

inline void
operator<<=(CORBA_Any_var& any, otLog::TimerOpInformation* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA_Any_var& any, const otLog::TimerOpInformation& val)
{
    any.inout() <<= val;
}

inline CORBA_Boolean
operator>>=(const CORBA_Any_var& any, otLog::TimerOpInformation*& val)
{
    return any.in() >>= val;
}

//
// OBVarSeq< otMessage::Element >
//
#ifndef OB_use_OBVarSeq_otMessage_Element
#define OB_use_OBVarSeq_otMessage_Element
#define OB_use_OBVarSeq_otMessage_Element_from_log_h

void OBMarshal(const OBVarSeq< otMessage::Element >&, CORBA_Octet*&);
void OBMarshalCount(const OBVarSeq< otMessage::Element >&, CORBA_ULong&);
void OBUnmarshal(OBVarSeq< otMessage::Element >&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, OBVarSeq< otMessage::Element >*);
void operator<<=(CORBA_Any&, const OBVarSeq< otMessage::Element >&);
CORBA_Boolean operator>>=(const CORBA_Any&, OBVarSeq< otMessage::Element >*&);

inline void
operator<<=(CORBA_Any_var& any, OBVarSeq< otMessage::Element >* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA_Any_var& any, const OBVarSeq< otMessage::Element >& val)
{
    any.inout() <<= val;
}

inline CORBA_Boolean
operator>>=(const CORBA_Any_var& any, OBVarSeq< otMessage::Element >*& val)
{
    return any.in() >>= val;
}

#endif

//
// OBVarSeq< otLog::TimerOpInformation >
//
#ifndef OB_use_OBVarSeq_otLog_TimerOpInformation
#define OB_use_OBVarSeq_otLog_TimerOpInformation
#define OB_use_OBVarSeq_otLog_TimerOpInformation_from_log_h

void OBMarshal(const OBVarSeq< otLog::TimerOpInformation >&, CORBA_Octet*&);
void OBMarshalCount(const OBVarSeq< otLog::TimerOpInformation >&, CORBA_ULong&);
void OBUnmarshal(OBVarSeq< otLog::TimerOpInformation >&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, OBVarSeq< otLog::TimerOpInformation >*);
void operator<<=(CORBA_Any&, const OBVarSeq< otLog::TimerOpInformation >&);
CORBA_Boolean operator>>=(const CORBA_Any&, OBVarSeq< otLog::TimerOpInformation >*&);

inline void
operator<<=(CORBA_Any_var& any, OBVarSeq< otLog::TimerOpInformation >* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA_Any_var& any, const OBVarSeq< otLog::TimerOpInformation >& val)
{
    any.inout() <<= val;
}

inline CORBA_Boolean
operator>>=(const CORBA_Any_var& any, OBVarSeq< otLog::TimerOpInformation >*& val)
{
    return any.in() >>= val;
}

#endif

//
// OBVarSeq< otLog::Assignment >
//
#ifndef OB_use_OBVarSeq_otLog_Assignment
#define OB_use_OBVarSeq_otLog_Assignment
#define OB_use_OBVarSeq_otLog_Assignment_from_log_h

void OBMarshal(const OBVarSeq< otLog::Assignment >&, CORBA_Octet*&);
void OBMarshalCount(const OBVarSeq< otLog::Assignment >&, CORBA_ULong&);
void OBUnmarshal(OBVarSeq< otLog::Assignment >&, const CORBA_Octet*&, bool);

void operator<<=(CORBA_Any&, OBVarSeq< otLog::Assignment >*);
void operator<<=(CORBA_Any&, const OBVarSeq< otLog::Assignment >&);
CORBA_Boolean operator>>=(const CORBA_Any&, OBVarSeq< otLog::Assignment >*&);

inline void
operator<<=(CORBA_Any_var& any, OBVarSeq< otLog::Assignment >* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA_Any_var& any, const OBVarSeq< otLog::Assignment >& val)
{
    any.inout() <<= val;
}

inline CORBA_Boolean
operator>>=(const CORBA_Any_var& any, OBVarSeq< otLog::Assignment >*& val)
{
    return any.in() >>= val;
}

#endif

//
// OBStrSeq
//
#ifndef OB_use_OBStrSeq
#define OB_use_OBStrSeq
#define OB_use_OBStrSeq_from_log_h

void operator<<=(CORBA_Any&, OBStrSeq*);
void operator<<=(CORBA_Any&, const OBStrSeq&);
CORBA_Boolean operator>>=(const CORBA_Any&, OBStrSeq*&);

inline void
operator<<=(CORBA_Any_var& any, OBStrSeq* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA_Any_var& any, const OBStrSeq& val)
{
    any.inout() <<= val;
}

inline CORBA_Boolean
operator>>=(const CORBA_Any_var& any, OBStrSeq*& val)
{
    return any.in() >>= val;
}

#endif

#endif