AbstractSkel.h

Go to the documentation of this file.

/***************************************************************************
 * Copyright (C) 2005 by Benjamin Hadorn (bhadorn@swissinfo.org)           *
 ***************************************************************************
 * Projekt : Zeus
 * Module  : AbstractSkel
 * Package : Remote
 * Author  : Benjamin Hadorn
 * Datum   : $Date: 18.10.09 23:37 $
 * Ablage  : $File$
 * System  : Cell Computing Model
 ***************************************************************************
 * Licence:                                                                *
 *   This library is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU Lesser General Public License as        *
 *   published by the Free Software Foundation; either version             *
 *   2.1 of the License, or (at your option) any later version.            *
 *                                                                         *
 *   This library 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 Lesser General Public License for more details.                   *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA  *
 ***************************************************************************/

/***************************************************************************
 Changes :
 $Log: /Development_F/StuderWIN/dev/Zeus/src/zeusbase/Remote/AbstractSkel.h $
** 
** 22    18.10.09 23:37 Bha
** MSC problem with sub class solved
** 
** 21    18.10.09 22:58 Bha
** querying socket of skeletons
**
** 20    10.09.09 17:02 Bha
** minor changes of version 1.0.1
**
** 19    27.03.09 15:11 Bha
** new version 1.0 implemented
**
** 18    3.09.07 17:21 Mabbuehl
** VS6 warnings removed.
**
** 17    3.09.07 7:03 bha
** New Framework using auto pointer and improved lists
**
** 16    4.04.07 6:49 bha
***************************************************************************/

#ifndef AbstractSkelH
#define AbstractSkelH

#include <zeusbase/System/Thread.h>
#include <zeusbase/System/ZVariant.h>
#include <zeusbase/System/ByteArray.hpp>
#include <zeusbase/Net/ServerSocket.h>
#include <zeusbase/Remote/RemoteDefines.hpp>
#include <zeusbase/Remote/RemoteMethodCall.h>
#include <zeusbase/Remote/RemoteReference.h>
#include <zeusbase/Remote/Interfaces/IRemoteObject.hpp>

/***************************************************************************/
/***************************************************************************/
#define SKEL_DECL(classid, objectid) \
class classid : public TAbstractSkel \
{ \
  public : \
    classid(objectid& rInstance)\
     : TAbstractSkel(), \
       m_rInstance(rInstance)\
    { \
    } \
    \
  protected: \
    virtual ~classid() \
    { \
    } \
    virtual Retval dispatchCommand(const IRemoteMethodCall& rMethod, IRemoteMethodCall*& rMethodreturn); \
  \
  private: \
    objectid& m_rInstance; \
}; \


/***************************************************************************/
/***************************************************************************/
#define SKEL_REMOTEREF(__param) pRemote##__param


/***************************************************************************/
/***************************************************************************/
#define SKEL_DISPATCH_START(classid) \
Retval classid::dispatchCommand(const IRemoteMethodCall& rMethod, IRemoteMethodCall*& rpMethodreturn) \
{ \
  Retval retValue = RET_NOERROR; \
  \
  TSingleLinkedList<IZUnknown*> lstParams; \
  TString strMethodName; \
  TRemoteMethodCall* pReturnCall = new TRemoteMethodCall(strMethodName); \
  TZVariant* pVarRetval = new TZVariant(); \
  rMethod.getMethodName(strMethodName); \
  RootLogger.printfln(LOGMODE_INFO, "Method received [%s]", strMethodName.c_str(NULL)); \

/***************************************************************************/
/***************************************************************************/
#define SKEL_DISP_SWITCH(__name) \
  if (strMethodName == __name) \
  {

/***************************************************************************/
/***************************************************************************/
#define SKEL_DISP_SWITCH_END }


/***************************************************************************/
/***************************************************************************/
#define SKEL_READ_PARAM(__name, __param) \
    TString strParam##__param = __name; \
    if (rMethod.getParameterByName(strParam##__param, __param) ==RET_NOERROR) \
    { \
      lstParams.add(__param); \
      RootLogger.printfln(LOGMODE_INFO, "Read param %s...ok",strParam##__param.c_str(NULL)); \
    } \
    else \
    { \
      RootLogger.printfln(LOGMODE_ERROR, "Read param %s...failed", strParam##__param.c_str(NULL)); \
      retValue = RET_REQUEST_FAILED; \
    } \

/***************************************************************************/
/***************************************************************************/
#define SKEL_READ_PARAM_REMOTEREF(__name, __param) \
    SKEL_READ_PARAM(__name, __param) \
    ISerializable* pSerial##__param = NULL; \
    IRemoteObject* SKEL_REMOTEREF(__param) = NULL; \
    if (__param != NULL && __param->getObject(pSerial##__param) == RET_NOERROR) \
    { \
      if (pSerial##__param->askForInterface(INTERFACE_IRemoteObject, ICAST(SKEL_REMOTEREF(__param))) == RET_NOERROR) \
      { \
        lstParams.add(SKEL_REMOTEREF(__param)); \
      } \
      else \
      { \
        RootLogger.printfln(LOGMODE_ERROR, "Failed. Object is not of type IRemoteObject"); \
        retValue = RET_REQUEST_FAILED; \
      } \
      pSerial##__param->release(); \
    } \
    else \
    { \
      RootLogger.printfln(LOGMODE_ERROR, "Failed. Object is NULL"); \
      retValue = RET_REQUEST_FAILED; \
    } \

/***************************************************************************/
/***************************************************************************/
#define SKEL_REMOTEREF_CHECK(__param) (SKEL_REMOTEREF(__param) != NULL)

/***************************************************************************/
/***************************************************************************/
#define SKEL_DISPATCH_END \
  while(lstParams.getCount() > 0) \
  { \
    lstParams[0]->release(); \
    lstParams.deleteItem(0); \
  } \
  rpMethodreturn = pReturnCall; \
  rpMethodreturn->setReturnValue(*pVarRetval); \
  pVarRetval->release(); \
  return retValue; \
}

BEGIN_NAMESPACE_Zeus

class TCCTPRequest;
class TCCTPResponse;
class TCriticalSection;

/***************************************************************************/
/***************************************************************************/
zeusbase_class TAbstractSkel : public TThread
{
  public:
    TAbstractSkel();

    virtual Retval startSkeleton(IString& rAddress, Uint& rPort, bool bDynamic);
    virtual void kill(Float64 dTimeOut = 5.0);
    virtual void execute();
    void dispatch1(const TCCTPRequest& request, TCCTPResponse& response);

    Retval getClientSocket(Uint uiThreadID, TSocket*& rpSocket) const;
    bool isRunning() const;
    void setCleanFlag();
    void setUseRemoteObjectAsReferencesOnly(bool bFlag);

  protected:

    //Compiler problem on older version from microsoft
    #ifdef _MSC_VER
      public:
    #endif
    /**********************************************************************/
    /* This inner class manages the incomming requests of clients and
       calls the parenr dispatching method
    */
    /**********************************************************************/
    class TClientHandlerThread : public TThread
    {
      public :
        TClientHandlerThread(TAbstractSkel& rParent, TSocket& rSocket);

        Retval getSocket(TSocket*& rpSocket) const;

        virtual void kill(Float64 dTimeOut = 5.0);
        virtual void execute();

      protected:
        virtual ~TClientHandlerThread();

        TAbstractSkel& m_rParent;
        TSocket& m_rClientSocket;
    };
    //Compiler problem on older version from microsoft
    #ifdef _MSC_VER
      protected:
    #endif

    TSingleLinkedList<TClientHandlerThread*> m_lstClients;
    TCriticalSection& m_rLock;
    TAutoPtr<TServerSocket> m_ptrSocket;
    bool m_bCleanFlag;
    bool m_bUseRemoteObjectAsReferencesOnly;

    virtual ~TAbstractSkel();
    virtual Retval dispatchCommand(const IRemoteMethodCall& rMethod, IRemoteMethodCall*& rpMethodreturn)=0;
    virtual void startNewHandler(TSocket& rClient);

};

//INLINE METHODS
/***************************************************************************/
/***************************************************************************/
inline bool TAbstractSkel::isRunning() const
{
  return (this->isAlive() && m_ptrSocket != NULL && m_ptrSocket->isBound());
}

/***************************************************************************/
/***************************************************************************/
inline void TAbstractSkel::setUseRemoteObjectAsReferencesOnly(bool bFlag)
{
  m_bUseRemoteObjectAsReferencesOnly = bFlag;
}

/***************************************************************************/
/***************************************************************************/
namespace TAbstractSkelObjectRelease
{

  /***************************************************************************/
  /***************************************************************************/
  template <class T> inline void releaseInstances(T& rObject)
  {
    rObject.release();
  }

  /***************************************************************************/
  /***************************************************************************/
  template <class T> inline void releaseInstances(T*& rpObject)
  {
    if (rpObject != NULL)
    {
      rpObject->release();
      rpObject = NULL;
    }
  }

  /***************************************************************************/
  /***************************************************************************/
  template <> void inline releaseInstances(IRemoteObjectList& rObjectList)
  {
    while(rObjectList.getCount() > 0)
    {
      rObjectList.getItem(0)->release();
      rObjectList.deleteItem(0);
    }
  }

  /***************************************************************************/
  /***************************************************************************/
  template <> void inline releaseInstances(IStringList& /*rObject*/) {}
}

END_NAMESPACE_Zeus

#endif

---

Written by Benjamin Hadorn http://www.xatlantis.ch.
Last change made on Wed Oct 28 21:42:29 2009