SoDisp.h

/*
 *     ____             _________                __                _     
 *    / __ \___  ____ _/ /_  __(_)___ ___  ___  / /   ____  ____ _(_)____
 *   / /_/ / _ \/ __ `/ / / / / / __ `__ \/ _ \/ /   / __ \/ __ `/ / ___/
 *  / _, _/  __/ /_/ / / / / / / / / / / /  __/ /___/ /_/ / /_/ / / /__  
 * /_/ |_|\___/\__,_/_/ /_/ /_/_/ /_/ /_/\___/_____/\____/\__, /_/\___/  
 *                                                       /____/          
 *
 *                  Barracuda Embedded Web-Server
 *
 ****************************************************************************
 *                            HEADER
 *
 *   $Id: SoDisp.h 5078 2022-02-10 22:52:48Z wini $
 *
 *   COPYRIGHT:  Real Time Logic LLC, 2002-2021
 *
 *   This software is copyrighted by and is the sole property of Real
 *   Time Logic LLC.  All rights, title, ownership, or other interests in
 *   the software remain the property of Real Time Logic LLC.  This
 *   software may only be used in accordance with the terms and
 *   conditions stipulated in the corresponding license agreement under
 *   which the software has been supplied.  Any unauthorized use,
 *   duplication, transmission, distribution, or disclosure of this
 *   software is expressly forbidden.
 *                                                                        
 *   This Copyright notice may not be removed or modified without prior
 *   written consent of Real Time Logic LLC.
 *                                                                         
 *   Real Time Logic LLC. reserves the right to modify this software
 *   without notice.
 *
 *               http://www.realtimelogic.com
 ****************************************************************************
 *
 *
 */
 
#ifndef _SoDisp_h
#define _SoDisp_h
 
#include <HttpCfg.h>
#include <ThreadLib.h>
 
 
struct SoDispCon;
struct HttpServer;
 
typedef struct SoDisp
{
#ifdef __cplusplus
 
      void *operator new(size_t s) { return ::baMalloc(s); }
      void operator delete(void* d) { if(d) ::baFree(d); }
      void *operator new(size_t, void *place) { return place; }
      void operator delete(void*, void *) { }
 
      SoDisp(ThreadMutex* mutex);
 
      void mutexSet();
 
      void mutexRelease();
 
      ThreadMutex* getMutex();
 
      void addConnection(SoDispCon* con);
      void activateRec(SoDispCon* con);
      void deactivateRec(SoDispCon* con);
      void activateSend(SoDispCon* con);
      void deactivateSend(SoDispCon* con);
      void removeConnection(SoDispCon* con);
 
      void setExit();
 
      void run(S32 timeout=-1);
#endif
      DISPATCHER_DATA;
      ThreadMutex* mutex;
      void* timeoutO;
      BaBool doExit;
} SoDisp;
 
#ifdef __cplusplus
extern "C" {
#endif
BA_API void SoDisp_constructor(SoDisp* o, ThreadMutex* mutex);
#ifndef SoDisp_destructor
#define SoDisp_destructor(o)
#endif
BA_API void SoDisp_addConnection(SoDisp* o, struct SoDispCon* con);
BA_API void SoDisp_activateRec(SoDisp* o, struct SoDispCon* con);
BA_API void SoDisp_deactivateRec(SoDisp* o, struct SoDispCon* con);
#ifdef NO_ASYNCH_RESP
#define SoDisp_activateSend(o, con)
#define SoDisp_deactivateSend(o, con)
#else
BA_API void SoDisp_activateSend(SoDisp* o, struct SoDispCon* con);
BA_API void SoDisp_deactivateSend(SoDisp* o, struct SoDispCon* con);
#endif
BA_API void SoDisp_removeConnection(SoDisp* o, struct SoDispCon* con);
BA_API void SoDisp_run(SoDisp* o, S32 timeout);
#ifdef OSE
union SIGNAL* SoDisp_receive(SoDisp* o, S32 time, SIGSELECT* sel);
#endif
#define SoDisp_getMutex(o) ((o) ? ((o)->mutex) : 0)
#define SoDisp_mutexSet(o) ThreadMutex_set((o)->mutex)
#define SoDisp_mutexRelease(o) ThreadMutex_release((o)->mutex)
#define SoDisp_setExit(o) (o)->doExit=TRUE
 
BA_API void SoDisp_newCon(SoDisp*, struct SoDispCon*);
 
#ifdef __cplusplus
}
inline SoDisp::SoDisp(ThreadMutex* mutex) {
   SoDisp_constructor(this, mutex); }
inline void SoDisp::addConnection(SoDispCon* con) {
   SoDisp_addConnection(this, con); }
inline void SoDisp::activateRec(SoDispCon* con) {
   SoDisp_activateRec(this, con); }
inline void SoDisp::deactivateRec(SoDispCon* con) {
   SoDisp_deactivateRec(this, con); }
inline void SoDisp::activateSend(SoDispCon* con) {
   SoDisp_activateSend(this, con); }
inline void SoDisp::deactivateSend(SoDispCon* con) {
   SoDisp_deactivateSend(this, con); }
inline void SoDisp::removeConnection(SoDispCon* con) {
   SoDisp_removeConnection(this, con); }
inline void SoDisp::run(S32 timeout) {
   SoDisp_run(this, timeout); }
inline ThreadMutex* SoDisp::getMutex() {
   return this->mutex; }
#ifdef OSE
inline union SIGNAL* SoDisp::receive(S32 time, SIGSELECT* sel) {
   return SoDisp_receive(this, time, sel); }
#endif
inline void SoDisp::mutexSet() { SoDisp_mutexSet(this); }
inline void SoDisp::mutexRelease() {SoDisp_mutexRelease(this);}
inline void SoDisp::setExit() { SoDisp_setExit(this); }
 
#endif
 
void SoDisp_setTimeout(
   SoDisp* o, BaTime t, void (*cb)(void* object), void* object);
 
 
#endif