RE: Problem with IDL to c++

Hi David,
         Here is the IDL file and CPP file.


-----------------------------------
Logger.idl----------------------------------------------------


/**
 * ejbinterop/Logger.idl
 * Tuesday, March 15, 2005 12:29:26 AM PST
 */


#include "javax/ejb/EJBObject.idl"
#include "orb.idl"

#ifndef __ejbinterop_Logger__
#define __ejbinterop_Logger__


module ejbinterop {

    interface Logger: ::javax::ejb::EJBObject {

        void logString(
in ::CORBA::WStringValue arg0 );

    };

#pragma ID Logger "RMI:ejbinterop.Logger:0000000000000000"

};

#endif



----------------------------------Logger.cpp--------------------------------
-----------------------

#include <OB/CORBAClient.h>
#include <Logger.h>

#ifndef OB_INTEGER_VERSION
#   error No ORBacus version defined! Is <OB/CORBA.h> included?
#endif

#ifndef OB_NO_VERSION_CHECK
#   if (OB_INTEGER_VERSION != 4020200L)
#       error ORBacus version mismatch!
#   endif
#endif


namespace ejbinterop
{	::OB::TypeCodeConst
_tc_Logger("01dd48000e0000003b0000000100000027000000524d493a656a62696e746572
6f702e4c6f676""765723a303030303030303030303030303030300000070000004c6f676765
7200");

} // End of namespace ejbinterop

//
// RMI:ejbinterop.Logger:0000000000000000
//
const char* ejbinterop::Logger::ids_[] =
{"RMIejbinterop.Logger:0000000000000000",
"RMI:javax.ejb.EJBObject:0000000000000000", 0
};

void OBDuplicate(ejbinterop::Logger_ptr p)
{
    if(p)
        p -> _add_ref();
}

void OBRelease(ejbinterop::Logger_ptr p)
{
    if(p)
        p -> _remove_ref();
}

ejbinterop::Logger_ptr ejbinterop::Logger::_narrow(::CORBA::Object_ptr p)
{
    if(!::CORBA::is_nil(p))
    {
        Logger_ptr v = dynamic_cast<Logger_ptr>(p);
        if(v)
            return _duplicate(v);

        if(p -> _is_a(ids_[0]))
        {
            OBProxy_ejbinterop::Logger* val = new
OBProxy_ejbinterop::Logger;
            val -> _OB_copyFrom(p);
            return val;
        }
    }

    return _nil();
}

ejbinterop::Logger_ptr ejbinterop::Logger::_narrow(::CORBA::AbstractBase_ptr
p)
{
    if(!::CORBA::is_nil(p))
    {
        Logger_ptr v = dynamic_cast<Logger_ptr>(p);
        if(v)
            return _duplicate(v);

        ::CORBA::Object_var obj = p -> _to_object();
        return _narrow(obj);
    }
    return _nil();
}

ejbinterop::Logger_ptr
ejbinterop::Logger::_unchecked_narrow(::CORBA::Object_ptr p)
{
    if(!::CORBA::is_nil(p))
    {
        Logger_ptr v = dynamic_cast<Logger_ptr>(p);
        if(v)
            return _duplicate(v);

        OBProxy_ejbinterop::Logger* val = new OBProxy_ejbinterop::Logger;
        val -> _OB_copyFrom(p);
        return val;
    }

    return _nil();
}

ejbinterop::Logger_ptr
ejbinterop::Logger::_unchecked_narrow(::CORBA::AbstractBase_ptr p)
{
    if(!::CORBA::is_nil(p))
    {
        ::CORBA::Object_var obj = p -> _to_object();
        return _unchecked_narrow(obj);
    }
    return _nil();
}

const char**
ejbinterop::Logger::_OB_staticIds()
{
    return ids_;
}

void
OBMarshal(ejbinterop::Logger_ptr _ob_v, OB::OutputStreamImpl* _ob_out)
{
    _ob_out -> write_Object(_ob_v);
}

void
OBUnmarshal(ejbinterop::Logger_ptr& _ob_v, OB::InputStreamImpl* _ob_in)
{
    ejbinterop::Logger_var old = _ob_v;
    ::CORBA::Object_var p = _ob_in -> read_Object();

    if(!::CORBA::is_nil(p))
    {
        OBProxy_ejbinterop::Logger* _ob_obj = new
OBProxy_ejbinterop::Logger;
        _ob_obj -> _OB_copyFrom(p);
        _ob_v = _ob_obj;
    }
    else
        _ob_v = ejbinterop::Logger::_nil();
}

void
operator<<=(::CORBA::Any& any, ejbinterop::Logger_ptr* v)
{
    any.replace(ejbinterop::_tc_Logger, (::CORBA::Object_ptr)*v, true);
}

void
operator<<=(::CORBA::Any& any, ejbinterop::Logger_ptr v)
{
    ejbinterop::Logger_ptr val = ejbinterop::Logger::_duplicate(v);
    any <<= &val;
}

::CORBA::Boolean
operator>>=(const ::CORBA::Any& any, ejbinterop::Logger_ptr& v)
{
    if(any.check_type(ejbinterop::_tc_Logger))
    {
        ::CORBA::Object_ptr val = (::CORBA::Object_ptr)any.value();

        if(!::CORBA::is_nil(val))
        {
            if(!(v = dynamic_cast<ejbinterop::Logger_ptr>(val)))
            {
                OBProxy_ejbinterop::Logger* obj = new
OBProxy_ejbinterop::Logger;
                obj -> _OB_copyFrom(val);
                v = obj;
                (::CORBA::Any&)any <<= &v;
            }
        }
        else
            v = ejbinterop::Logger::_nil();

        return true;
    }
    else
        return false;
}

//
// RMI:ejbinterop.Logger:0000000000000000
//
OB::MarshalStubImpl_ptr
OBProxy_ejbinterop::Logger::_OB_createMarshalStubImpl()
{
    return new OBMarshalStubImpl_ejbinterop::Logger;
}

const char**
OBProxy_ejbinterop::Logger::_OB_ids() const
{
    return ::ejbinterop::Logger::ids_;
}

//
// IDL:ejbinterop/Logger/logString:1.0
//
void
OBProxy_ejbinterop::Logger::logString(::CORBA::WStringValue* _ob_a0)
{
    ::CORBA::ULong _ob_retry = 0, _ob_hop = 0;
    while(true)
    {
        try
        {
            OB::StubImplBase_var _ob_stubImplBase = _OB_getStubImpl();
            OBStubImpl_ejbinterop::Logger_ptr _ob_stubImpl = dynamic_cast<
OBStubImpl_ejbinterop::Logger_ptr>(_ob_stubImplBase.in());
            _ob_stubImpl -> logString(_ob_a0);
            return;
        }
        catch(const OB::ExceptionBase& _ob_ex)
        {
            _OB_handleException(_ob_ex, _ob_retry, _ob_hop);
        }
    }
}

//
// RMI:ejbinterop.Logger:0000000000000000
//
void
OBDuplicate(OBStubImpl_ejbinterop::Logger_ptr p)
{
    if(p)
        p -> _OB_incRef();
}

void
OBRelease(OBStubImpl_ejbinterop::Logger_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

//
// IDL:ejbinterop/Logger/logString:1.0
//
void
OBMarshalStubImpl_ejbinterop::Logger::logString(::CORBA::WStringValue*
_ob_a0)
{
    while(true)
    {
        OB::Downcall_var _ob_down = _OB_createDowncall("logString", true);
        try
        {
            OB::OutputStreamImpl* _ob_out = _OB_preMarshal(_ob_down);
            try
            {
                OBMarshal(_ob_a0, _ob_out);
            }
            catch(const ::CORBA::SystemException& _ob_ex)
            {
                _OB_marshalEx(_ob_down, _ob_ex);
            }
            _OB_postMarshal(_ob_down);
            _OB_request(_ob_down);
            _OB_preUnmarshal(_ob_down);
            _OB_postUnmarshal(_ob_down);
            return;
        }
        catch(const OB::FailureException& _ob_ex)
        {
            _OB_handleFailureException(_ob_down, _ob_ex);
        }
    }
}





-----Original Message-----
From: David Weir [mailto:[email protected]]
Sent: Tuesday, March 15, 2005 2:06 AM
To: Swapnil Wale
Cc: David Weir; [email protected]
Subject: Re: [OB-Users] Problem with IDL to c++


Hello again Swapnil,

On Mon, Mar 14, 2005 at 10:25:29PM +0530, Swapnil Wale wrote:
> Hi David,
>            Yes I am using Sun's RMIC complier. Have you come across
someone
> who has successfully implemented RMI-IIOP using Sun's RMIC compiler or is
it
> just in theory?
>
> I have a long way to go with the project. So if you can give me some
advise
> I can think on migrating. Thank you and have a nice day.
>
> -Swapnil-

Would it be possible for you to send along your IDL file and the
"Logger.cpp" file? It looks like there is a namespace issue here
that may be resolved fairly easily.

Cheers,
Dave

--
David Weir
Team Orbacus - Your CORBA Source
E-Mail: [email protected]
Phone: (709) 738-3725 x20
WWW: http://www.orbacus.com


_______________________________________________
OB-Users Mailing List - [email protected]
http://mail.ooc.nf.ca/mailman/listinfo/ob-users
Visit our support FAQ before you send a message.
http://www.orbacus.com/faq/support.html