Jack2  1.9.10
JackWinNamedPipe.h
00001 /*
00002  Copyright (C) 2004-2008 Grame
00003 
00004  This program is free software; you can redistribute it and/or modify
00005  it under the terms of the GNU Lesser General Public License as published by
00006  the Free Software Foundation; either version 2.1 of the License, or
00007  (at your option) any later version.
00008 
00009  This program is distributed in the hope that it will be useful,
00010  but WITHOUT ANY WARRANTY; without even the implied warranty of
00011  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00012  GNU Lesser General Public License for more details.
00013 
00014  You should have received a copy of the GNU Lesser General Public License
00015  along with this program; if not, write to the Free Software
00016  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
00017 
00018  */
00019 
00020 
00021 #ifndef __JackWinNamedPipe__
00022 #define __JackWinNamedPipe__
00023 
00024 #include <windows.h>
00025 
00026 #include "JackChannel.h"
00027 
00028 namespace Jack
00029 {
00030 
00031 class JackWinNamedPipeAux
00032 {
00033 
00034     protected:
00035 
00036         HANDLE fNamedPipe;
00037         char fName[256];
00038 
00039         int ReadAux(void* data, int len);
00040         int WriteAux(void* data, int len);
00041 
00042     public:
00043 
00044         JackWinNamedPipeAux(): fNamedPipe(INVALID_HANDLE_VALUE)
00045         {}
00046         JackWinNamedPipeAux(HANDLE pipe): fNamedPipe(pipe)
00047         {}
00048         virtual ~JackWinNamedPipeAux()
00049         {}
00050 
00051 };
00052 
00053 
00054 class JackWinNamedPipe : public JackWinNamedPipeAux, public detail::JackChannelTransactionInterface
00055 {
00056 
00057     public:
00058 
00059         JackWinNamedPipe():JackWinNamedPipeAux()
00060         {}
00061         JackWinNamedPipe(HANDLE pipe):JackWinNamedPipeAux(pipe)
00062         {}
00063         virtual ~JackWinNamedPipe()
00064         {}
00065 
00066         virtual int Read(void* data, int len)
00067         {
00068             return ReadAux(data, len);
00069         }
00070         virtual int Write(void* data, int len)
00071         {
00072             return WriteAux(data, len);
00073         }
00074 };
00075 
00080 class JackWinNamedPipeClient : public JackWinNamedPipeAux, public detail::JackClientRequestInterface
00081 {
00082 
00083     protected:
00084 
00085         int ConnectAux();
00086 
00087     public:
00088 
00089         JackWinNamedPipeClient():JackWinNamedPipeAux()
00090         {}
00091         JackWinNamedPipeClient(HANDLE pipe, const char* name):JackWinNamedPipeAux(pipe)
00092         {
00093             strcpy(fName, name);
00094         }
00095 
00096         virtual ~JackWinNamedPipeClient()
00097         {}
00098 
00099         virtual int Connect(const char* dir, int which);
00100         virtual int Connect(const char* dir, const char* name, int which);
00101         virtual int Close();
00102 
00103         virtual int Read(void* data, int len)
00104         {
00105             return ReadAux(data, len);
00106         }
00107         virtual int Write(void* data, int len)
00108         {
00109             return WriteAux(data, len);
00110         }
00111 
00112         virtual void SetReadTimeOut(long sec);
00113         virtual void SetWriteTimeOut(long sec);
00114         
00115         virtual void SetNonBlocking(bool onoff);
00116 };
00117 
00118 class JackWinAsyncNamedPipeClient : public JackWinNamedPipeClient
00119 {
00120         enum kIOState {kIdle = 0, kConnecting, kReading, kWriting};
00121 
00122     private:
00123 
00124         bool fPendingIO;
00125         kIOState fIOState;
00126         OVERLAPPED fOverlap;
00127 
00128     public:
00129 
00130         JackWinAsyncNamedPipeClient();
00131         JackWinAsyncNamedPipeClient(HANDLE pipe, const char* name, bool pending);
00132         virtual ~JackWinAsyncNamedPipeClient();
00133 
00134         virtual int Read(void* data, int len);
00135         virtual int Write(void* data, int len);
00136 
00137         HANDLE GetEvent()
00138         {
00139             return (HANDLE)fOverlap.hEvent;
00140         }
00141 
00142         kIOState GetIOState()
00143         {
00144             return fIOState;
00145         }
00146 
00147         bool GetPending()
00148         {
00149             return fPendingIO;
00150         }
00151 
00152         int FinishIO();
00153 };
00154 
00159 class JackWinNamedPipeServer : public JackWinNamedPipe
00160 {
00161     private:
00162 
00163         int BindAux();
00164 
00165     public:
00166 
00167         JackWinNamedPipeServer(): JackWinNamedPipe()
00168         {}
00169         virtual ~JackWinNamedPipeServer()
00170         {}
00171 
00172         virtual int Bind(const char* dir, int which);
00173         virtual int Bind(const char* dir, const char* name, int which);
00174         virtual bool Accept();
00175         virtual JackWinNamedPipeClient* AcceptClient();
00176         int Close();
00177 };
00178 
00183 class JackWinAsyncNamedPipeServer : public JackWinNamedPipeServer
00184 {
00185 
00186     private:
00187 
00188         int BindAux();
00189 
00190     public:
00191 
00192         JackWinAsyncNamedPipeServer(): JackWinNamedPipeServer()
00193         {}
00194         virtual ~JackWinAsyncNamedPipeServer()
00195         {}
00196 
00197         int Bind(const char* dir, int which);
00198         int Bind(const char* dir, const char* name, int which);
00199         bool Accept();
00200         JackWinNamedPipeClient* AcceptClient();
00201         int Close();
00202 };
00203 
00204 } // end of namespace
00205 
00206 
00207 #endif
00208