common/JackGlobals.h

   1 /*
   2 Copyright (C) 2004-2006 Grame
   3
   4 This program is free software; you can redistribute it and/or modify
   5 it under the terms of the GNU General Public License as published by
   6 the Free Software Foundation; either version 2 of the License, or
   7 (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program; if not, write to the Free Software
  16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #ifndef __JackGlobals__
  21 #define __JackGlobals__
  22
  23 #include "JackError.h"
  24
  25 namespace Jack
  26 {
  27
  28 class JackSynchro;
  29 class JackServerNotifyChannelInterface;
  30 class JackClientChannelInterface;
  31 class JackNotifyChannelInterface;
  32 class JackServerChannelInterface;
  33 class JackSyncInterface;
  34 class JackThread;
  35 class JackDriverClientInterface;
  36 class JackRunnableInterface;
  37 class JackEngine;
  38
  39 /*!
  40 \brief Factory description
  41
  42 \totdo possibly use in a dynamic way to test different communication/synchro implementations.
  43 */
  44
  45 class JackFactoryImpl
  46 {
  47     public:
  48
  49         JackFactoryImpl()
  50         {}
  51         virtual ~JackFactoryImpl()
  52         {}
  53
  54         virtual JackSynchro* MakeSynchro() = 0;
  55         virtual JackServerNotifyChannelInterface* MakeServerNotifyChannel() = 0;
  56         virtual JackClientChannelInterface* MakeClientChannel() = 0;
  57         virtual JackNotifyChannelInterface* MakeNotifyChannel() = 0;
  58         virtual JackServerChannelInterface* MakeServerChannel() = 0;
  59         virtual JackSyncInterface* MakeInterProcessSync() = 0;
  60         virtual JackThread* MakeThread(JackRunnableInterface* runnable) = 0;
  61 };
  62
  63 #ifdef __linux__
  64
  65 class JackFactoryLinuxServer : public JackFactoryImpl
  66 {
  67     public:
  68
  69         JackFactoryLinuxServer()
  70         {}
  71         virtual ~JackFactoryLinuxServer()
  72         {}
  73
  74         JackSynchro* MakeSynchro();
  75         JackServerNotifyChannelInterface* MakeServerNotifyChannel();
  76         JackClientChannelInterface* MakeClientChannel();
  77         JackNotifyChannelInterface* MakeNotifyChannel();
  78         JackServerChannelInterface* MakeServerChannel();
  79         JackSyncInterface* MakeInterProcessSync();
  80         JackThread* MakeThread(JackRunnableInterface* runnable);
  81 };
  82
  83 class JackFactoryLinuxClient : public JackFactoryImpl
  84 {
  85     public:
  86
  87         JackFactoryLinuxClient()
  88         {}
  89         virtual ~JackFactoryLinuxClient()
  90         {}
  91
  92         JackSynchro* MakeSynchro();
  93         JackServerNotifyChannelInterface* MakeServerNotifyChannel();
  94         JackClientChannelInterface* MakeClientChannel();
  95         JackNotifyChannelInterface* MakeNotifyChannel();
  96         JackServerChannelInterface* MakeServerChannel();
  97         JackSyncInterface* MakeInterProcessSync();
  98         JackThread* MakeThread(JackRunnableInterface* runnable);
  99 };
 100
 101 #endif
 102
 103 #ifdef WIN32
 104
 105 class JackFactoryWindowsServer : public JackFactoryImpl
 106 {
 107     public:
 108
 109         JackFactoryWindowsServer()
 110         {}
 111         virtual ~JackFactoryWindowsServer()
 112         {}
 113
 114         JackSynchro* MakeSynchro();
 115         JackServerNotifyChannelInterface* MakeServerNotifyChannel();
 116         JackClientChannelInterface* MakeClientChannel();
 117         JackNotifyChannelInterface* MakeNotifyChannel();
 118         JackServerChannelInterface* MakeServerChannel();
 119         JackSyncInterface* MakeInterProcessSync();
 120         JackThread* MakeThread(JackRunnableInterface* runnable);
 121 };
 122
 123 class JackFactoryWindowsClient : public JackFactoryImpl
 124 {
 125     public:
 126
 127         JackFactoryWindowsClient()
 128         {}
 129         virtual ~JackFactoryWindowsClient()
 130         {}
 131
 132         JackSynchro* MakeSynchro();
 133         JackServerNotifyChannelInterface* MakeServerNotifyChannel();
 134         JackClientChannelInterface* MakeClientChannel();
 135         JackNotifyChannelInterface* MakeNotifyChannel();
 136         JackServerChannelInterface* MakeServerChannel();
 137         JackSyncInterface* MakeInterProcessSync();
 138         JackThread* MakeThread(JackRunnableInterface* runnable);
 139 };
 140
 141 #endif
 142
 143 #if defined(__APPLE__)
 144
 145 class JackFactoryOSXServer : public JackFactoryImpl
 146 {
 147     public:
 148
 149         JackFactoryOSXServer()
 150         {}
 151         virtual ~JackFactoryOSXServer()
 152         {}
 153
 154         JackSynchro* MakeSynchro();
 155         JackServerNotifyChannelInterface* MakeServerNotifyChannel();
 156         JackClientChannelInterface* MakeClientChannel();
 157         JackNotifyChannelInterface* MakeNotifyChannel();
 158         JackServerChannelInterface* MakeServerChannel();
 159         JackSyncInterface* MakeInterProcessSync();
 160         JackThread* MakeThread(JackRunnableInterface* runnable);
 161 };
 162
 163 class JackFactoryOSXClient : public JackFactoryImpl
 164 {
 165     public:
 166
 167         JackFactoryOSXClient()
 168         {}
 169         virtual ~JackFactoryOSXClient()
 170         {}
 171
 172         JackSynchro* MakeSynchro();
 173         JackServerNotifyChannelInterface* MakeServerNotifyChannel();
 174         JackClientChannelInterface* MakeClientChannel();
 175         JackNotifyChannelInterface* MakeNotifyChannel();
 176         JackServerChannelInterface* MakeServerChannel();
 177         JackSyncInterface* MakeInterProcessSync();
 178         JackThread* MakeThread(JackRunnableInterface* runnable);
 179 };
 180
 181 #endif
 182
 183 /*!
 184 \brief Factory for OS specific ressources.
 185 */
 186
 187 class JackGlobals
 188 {
 189     private:
 190
 191         static JackFactoryImpl* fInstance;
 192
 193     public:
 194
 195         JackGlobals()
 196         {}
 197         virtual ~JackGlobals()
 198         {}
 199
 200         static JackSynchro* MakeSynchro()
 201         {
 202             return fInstance->MakeSynchro();
 203         }
 204         static JackServerNotifyChannelInterface* MakeServerNotifyChannel()
 205         {
 206             return fInstance->MakeServerNotifyChannel();
 207         }
 208         static JackClientChannelInterface* MakeClientChannel()
 209         {
 210             return fInstance->MakeClientChannel();
 211         }
 212         static JackNotifyChannelInterface* MakeNotifyChannel()
 213         {
 214             return fInstance->MakeNotifyChannel();
 215         }
 216         static JackServerChannelInterface* MakeServerChannel()
 217         {
 218             return fInstance->MakeServerChannel();
 219         }
 220         static JackSyncInterface* MakeInterProcessSync()
 221         {
 222             return fInstance->MakeInterProcessSync();
 223         }
 224         static JackThread* MakeThread(JackRunnableInterface* runnable)
 225         {
 226             return fInstance->MakeThread(runnable);
 227         }
 228
 229         static void InitServer()
 230         {
 231             JackLog("JackGlobals InitServer\n");
 232             if (!fInstance) {
 233
 234                 #ifdef __APPLE__
 235                 fInstance = new JackFactoryOSXServer();
 236                 #endif
 237
 238                 #ifdef WIN32
 239                fInstance = new JackFactoryWindowsServer();
 240                 #endif
 241
 242                 #ifdef __linux__
 243                fInstance = new JackFactoryLinuxServer();
 244                 #endif
 245
 246             }
 247         }
 248
 249         static void InitClient()
 250         {
 251             JackLog("JackGlobals InitClient\n");
 252             if (!fInstance) {
 253
 254                 #ifdef __APPLE__
 255                 fInstance = new JackFactoryOSXClient();
 256                 #endif
 257
 258                 #ifdef WIN32
 259                 fInstance = new JackFactoryWindowsClient();
 260                 #endif
 261
 262                 #ifdef __linux__
 263                 fInstance = new JackFactoryLinuxClient();
 264                 #endif
 265
 266             }
 267         }
 268
 269         static void Destroy()
 270         {
 271             JackLog("JackGlobals Destroy\n");
 272             if (fInstance) {
 273                 delete fInstance;
 274                 fInstance = NULL;
 275             }
 276         }
 277
 278 };
 279
 280 } // end of namespace
 281
 282 #endif