---

sbimpl.h

Go to the documentation of this file.

/* --------------------------------------------------------------
Copyright (C) 2001 LifeLine Networks BV <soap2corba@lifeline.nl>

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-------------------------------------------------------------- */

extern CORBA::ORB_ptr orb;
extern DynamicAny::DynAnyFactory_var dynFact;
extern IRPLUS_H irplusHandle;
extern CORBA::String_var ObjCtxMan_SIOR;
extern JTCMonitor *p_struct_tm_monitor;

class ParList_Holder {
public:
    SCParamList *pParList;

    ParList_Holder () : pParList (NULL) { };
    virtual ~ParList_Holder () { delete pParList; };
};

class CorbaSoap
{
protected:
    SOAPBridge::ObjectContextManager_var ObjCtxMan;
    void DynAny2Xml (DOM_Document &doc, DOM_Node &node, SCParamValue *pParVal, DynamicAny::DynAny_ptr da,
        const char *ctxKey, bool needOuter = false)  throw (DOM_Document &);
    void FillInDynAny (HrefIdMap &Map, SCParamValue *pParVal, DynamicAny::DynAny_ptr da, DOM_Element &elm)
        throw (DOM_Document &);
    bool TypeConversion (DynamicAny::DynAny_ptr da, DOM_Element &elm, CString &Value, 
        SCParamValue *pParVal, CORBA::TCKind kind) throw (DOM_Document &);
    bool TypeConversion (DynamicAny::DynAny_ptr da, DOM_Document &doc, DOM_Node &node, 
        SCParamValue *pParVal, CORBA::TCKind kind) throw (DOM_Document &);
    CorbaSoap ();
    virtual ~CorbaSoap ()
    {
    };
    virtual void aFault (FaultCode fCode, const char *fSubCode, const char *fString) = 0;
    virtual void CheckTag (char *cNam, DOM_Node &node) throw (DOM_Document &) = 0;
};

class SOAPBridge_SOAPCall_i: public CorbaSoap, public POA_SOAPBridge::SOAPCall, public PortableServer::ServantLocator
{
private:
    CosNaming::NamingContext_ptr m_inc;
    CORBA::Object_ptr suppliedObject;
    bool useSupplied;
    void soapFault(DOM_Document &doc, FaultCode fCode, const char *fSubCode, const char *fString);
    virtual void aFault (FaultCode fCode, const char *fSubCode, const char *fString)
    {
        DOM_Document doc;
        soapFault (doc, fCode, fSubCode, fString);
        throw (doc);
    };
    void soapFault(DOM_Document &doc, FaultCode fCode, const char *fSubCode, const char *fString, 
        DynamicAny::DynAny_ptr da);
    virtual void CheckTag (char *cNam, DOM_Node &node) throw (DOM_Document &);
    
public:
    SOAPBridge::SOAPCall::XMLData * Fault (FaultCode fCode, const char *fSubCode, const char *fString);
    SOAPBridge_SOAPCall_i (CosNaming::NamingContext_ptr inc);
    virtual ~SOAPBridge_SOAPCall_i ();
    SOAPBridge::SOAPCall::XMLData* invokeAction (const char* action, const SOAPBridge::SOAPCall::XMLData& data)
        throw (CORBA::SystemException, SOAPBridge::SOAPCall::InvocationFailed);
    SOAPBridge::SOAPCall::XMLData* invokeInstance (CORBA::Object_ptr objRef, const char* action, const SOAPBridge::SOAPCall::XMLData& data)
        throw (CORBA::SystemException, SOAPBridge::SOAPCall::InvocationFailed);
    SOAPBridge::SOAPCall::SOAPActionSeq* listActions ()
        throw (CORBA::SystemException);
    CORBA::Boolean fetchSample (const char* action, SOAPBridge::SOAPCall::XMLData_out request, SOAPBridge::SOAPCall::XMLData_out respons)
        throw (CORBA::SystemException);
};

class SOAPBridge_TypeConversions_impl : virtual public POA_SOAPBridge::TypeConversions,
                             virtual public PortableServer::RefCountServantBase
{
    SOAPBridge_TypeConversions_impl(const SOAPBridge_TypeConversions_impl&);
    void operator=(const SOAPBridge_TypeConversions_impl&);
    PortableServer::POA_var poa_;

public:
    SOAPBridge_TypeConversions_impl(PortableServer::POA_ptr);
    ~SOAPBridge_TypeConversions_impl();
    virtual PortableServer::POA_ptr _default_POA();

    virtual void Set(const SOAPBridge::TypeConversions::Specification& spec)
        throw(SOAPBridge::TypeConversions::BadSpecification,
              CORBA::SystemException);
    virtual CORBA::Boolean Get(SOAPBridge::TypeConversions::Specification& spec,
                               CORBA::Boolean getNext)
        throw(CORBA::SystemException);
};

class AnyInterface : public CorbaSoap, virtual public PortableServer::DynamicImplementation
{
private:
    virtual void aFault (FaultCode fCode, const char *fSubCode, const char *fString)
    {
        printf ("FAULT: %s\n", fString);
        throw CORBA::BAD_OPERATION ();
    };
    virtual void CheckTag (char *cNam, DOM_Node &node) throw (DOM_Document &)
    {
        // do nothing
    };
    void ErrorCallback (const char *name, const char *msg);
protected:
    JTCMonitor monitor;
public:
    CString m_Addr, m_Intf, m_Ctxk;
    SOAPBridge::CORBACallback_var m_cb;

    AnyInterface (const char *soapAddr, const char *intfName, const char *ctxKey,
                  SOAPBridge::CORBACallback_ptr cb)
        : CorbaSoap ()
        , m_Addr (soapAddr)
        , m_Intf (intfName)
        , m_Ctxk (ctxKey)
    {
        if (!CORBA::is_nil (cb)) {
            m_cb = SOAPBridge::CORBACallback::_duplicate (cb);
        } else {
            m_cb = SOAPBridge::CORBACallback::_nil ();
        }
    };
    virtual ~AnyInterface ()
    {
    };
    virtual CORBA::RepositoryId _primary_interface (
        const PortableServer::ObjectId &,
        PortableServer::POA_ptr);
    virtual CORBA::Boolean _is_a (const char *name)
        throw (CORBA::SystemException);
    virtual void invoke (CORBA::ServerRequest_ptr request) throw ();
};

class DOM_Holder {
public:
    DOM_H domHdl;

    DOM_Holder (DOM_H hdl) : domHdl (hdl) { };
    virtual ~DOM_Holder () { releaseDOM (domHdl); };
};

namespace SOAPBridge
{

//
// IDL:SOAPBridge/CORBACall:1.0
//
class CORBACall_impl : virtual public POA_SOAPBridge::CORBACall,
                       virtual public PortableServer::RefCountServantBase
{
    CORBACall_impl(const CORBACall_impl&);
    void operator=(const CORBACall_impl&);

    PortableServer::POA_var poa_;
    CString ctxKey;

public:

    CORBACall_impl(PortableServer::POA_ptr);
    ~CORBACall_impl();

    virtual PortableServer::POA_ptr _default_POA();

    //
    // IDL:SOAPBridge/CORBACall/contextKey:1.0
    //
    virtual char* contextKey()
        throw(CORBA::SystemException);
    virtual void contextKey(const char*)
        throw(CORBA::SystemException);

    //
    // IDL:SOAPBridge/CORBACall/CreateSession:1.0
    //
    virtual CORBA::Object_ptr CreateSession(const char* soapAddress,
                                            const char* intfName,
                                            CORBA::Boolean obtainContextKey,
                                            SOAPBridge::CORBACallback_ptr cb)
        throw(CORBA::SystemException);

    //
    // IDL:SOAPBridge/CORBACall/DestroySession:1.0
    //
    virtual void DestroySession(CORBA::Object_ptr sessionObject)
        throw(CORBA::SystemException);
};

}

---