Jack2 1.9.8

JackRequest.h

00001 /*
00002 Copyright (C) 2001 Paul Davis
00003 Copyright (C) 2004-2008 Grame
00004 
00005 This program is free software; you can redistribute it and/or modify
00006 it under the terms of the GNU Lesser General Public License as published by
00007 the Free Software Foundation; either version 2.1 of the License, or
00008 (at your option) any later version.
00009 
00010 This program is distributed in the hope that it will be useful,
00011 but WITHOUT ANY WARRANTY; without even the implied warranty of
00012 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013 GNU Lesser General Public License for more details.
00014 
00015 You should have received a copy of the GNU Lesser General Public License
00016 along with this program; if not, write to the Free Software
00017 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
00018 
00019 */
00020 
00021 #ifndef __JackRequest__
00022 #define __JackRequest__
00023 
00024 #include "JackConstants.h"
00025 #include "JackPlatformPlug.h"
00026 #include "JackTime.h"
00027 #include "types.h"
00028 #include <string.h>
00029 #include <stdio.h>
00030 #include <stdlib.h>
00031 #include <list>
00032 
00033 namespace Jack
00034 {
00035 
00036 #define CheckRes(exp) { if ((exp) < 0) return -1; }
00037 
00042 enum JackSessionReply {
00043 
00044     kImmediateSessionReply = 1,
00045     kPendingSessionReply = 2
00046 
00047 };
00048 
00053 struct JackRequest
00054 {
00055 
00056     enum RequestType {
00057         kRegisterPort = 1,
00058         kUnRegisterPort = 2,
00059         kConnectPorts = 3,
00060         kDisconnectPorts = 4,
00061         kSetTimeBaseClient = 5,
00062         kActivateClient = 6,
00063         kDeactivateClient = 7,
00064         kDisconnectPort = 8,
00065         kSetClientCapabilities = 9,
00066         kGetPortConnections = 10,
00067         kGetPortNConnections = 11,
00068         kReleaseTimebase = 12,
00069         kSetTimebaseCallback = 13,
00070         kSetBufferSize = 20,
00071         kSetFreeWheel = 21,
00072         kClientCheck = 22,
00073         kClientOpen = 23,
00074         kClientClose = 24,
00075         kConnectNamePorts = 25,
00076         kDisconnectNamePorts = 26,
00077         kGetInternalClientName = 27,
00078         kInternalClientHandle = 28,
00079         kInternalClientLoad = 29,
00080         kInternalClientUnload = 30,
00081         kPortRename = 31,
00082         kNotification = 32,
00083         kSessionNotify = 33,
00084         kSessionReply  = 34,
00085         kGetClientByUUID = 35,
00086         kReserveClientName = 36,
00087         kGetUUIDByClient = 37,
00088         kClientHasSessionCallback = 38,
00089         kComputeTotalLatencies = 39
00090     };
00091 
00092     RequestType fType;
00093 
00094     JackRequest(): fType((RequestType)0)
00095     {}
00096 
00097     JackRequest(RequestType type): fType(type)
00098     {}
00099 
00100     virtual ~JackRequest()
00101     {}
00102 
00103     virtual int Read(JackChannelTransaction* trans)
00104     {
00105         return trans->Read(&fType, sizeof(RequestType));
00106     }
00107 
00108     virtual int Write(JackChannelTransaction* trans)
00109     {
00110         return trans->Write(&fType, sizeof(RequestType));
00111     }
00112 
00113 };
00114 
00119 struct JackResult
00120 {
00121 
00122     int fResult;
00123 
00124     JackResult(): fResult( -1)
00125     {}
00126     JackResult(int result): fResult(result)
00127     {}
00128     virtual ~JackResult()
00129     {}
00130 
00131     virtual int Read(JackChannelTransaction* trans)
00132     {
00133         return trans->Read(&fResult, sizeof(int));
00134     }
00135 
00136     virtual int Write(JackChannelTransaction* trans)
00137     {
00138         return trans->Write(&fResult, sizeof(int));
00139     }
00140 
00141 };
00142 
00147 struct JackClientCheckRequest : public JackRequest
00148 {
00149 
00150     char fName[JACK_CLIENT_NAME_SIZE + 1];
00151     int fProtocol;
00152     int fOptions;
00153     int fUUID;
00154     int fOpen;
00155 
00156     JackClientCheckRequest()
00157     {}
00158     JackClientCheckRequest(const char* name, int protocol, int options, int uuid, int open = false)
00159         : JackRequest(JackRequest::kClientCheck), fProtocol(protocol), fOptions(options), fUUID(uuid), fOpen(open)
00160     {
00161         snprintf(fName, sizeof(fName), "%s", name);
00162     }
00163 
00164     int Read(JackChannelTransaction* trans)
00165     {
00166         CheckRes(trans->Read(&fName, sizeof(fName)));
00167         CheckRes(trans->Read(&fProtocol, sizeof(int)));
00168         CheckRes(trans->Read(&fOptions, sizeof(int)));
00169         CheckRes(trans->Read(&fUUID, sizeof(int)));
00170         return trans->Read(&fOpen, sizeof(int));
00171     }
00172 
00173     int Write(JackChannelTransaction* trans)
00174     {
00175         CheckRes(JackRequest::Write(trans));
00176         CheckRes(trans->Write(&fName, sizeof(fName)));
00177         CheckRes(trans->Write(&fProtocol, sizeof(int)));
00178         CheckRes(trans->Write(&fOptions, sizeof(int)));
00179         CheckRes(trans->Write(&fUUID, sizeof(int)));
00180         return trans->Write(&fOpen, sizeof(int));
00181     }
00182 
00183 };
00184 
00189 struct JackClientCheckResult : public JackResult
00190 {
00191 
00192     char fName[JACK_CLIENT_NAME_SIZE + 1];
00193     int fStatus;
00194 
00195     JackClientCheckResult(): JackResult(), fStatus(0)
00196     {}
00197     JackClientCheckResult(int32_t result, const char* name, int status)
00198             : JackResult(result), fStatus(status)
00199     {
00200         snprintf(fName, sizeof(fName), "%s", name);
00201     }
00202 
00203     int Read(JackChannelTransaction* trans)
00204     {
00205         CheckRes(JackResult::Read(trans));
00206         CheckRes(trans->Read(&fName, sizeof(fName)));
00207         CheckRes(trans->Read(&fStatus, sizeof(int)));
00208         return 0;
00209     }
00210 
00211     int Write(JackChannelTransaction* trans)
00212     {
00213         CheckRes(JackResult::Write(trans));
00214         CheckRes(trans->Write(&fName, sizeof(fName)));
00215         CheckRes(trans->Write(&fStatus, sizeof(int)));
00216         return 0;
00217     }
00218 
00219 };
00220 
00225 struct JackClientOpenRequest : public JackRequest
00226 {
00227 
00228     int fPID;
00229     int fUUID;
00230     char fName[JACK_CLIENT_NAME_SIZE + 1];
00231 
00232     JackClientOpenRequest()
00233     {}
00234     JackClientOpenRequest(const char* name, int pid, int uuid): JackRequest(JackRequest::kClientOpen)
00235     {
00236         snprintf(fName, sizeof(fName), "%s", name);
00237         fPID = pid;
00238         fUUID = uuid;
00239     }
00240 
00241     int Read(JackChannelTransaction* trans)
00242     {
00243         CheckRes(trans->Read(&fPID, sizeof(int)));
00244         CheckRes(trans->Read(&fUUID, sizeof(int)));
00245         return trans->Read(&fName, sizeof(fName));
00246     }
00247 
00248     int Write(JackChannelTransaction* trans)
00249     {
00250         CheckRes(JackRequest::Write(trans));
00251         CheckRes(trans->Write(&fPID, sizeof(int)));
00252         CheckRes(trans->Write(&fUUID, sizeof(int)));
00253         return trans->Write(&fName, sizeof(fName));
00254     }
00255 
00256 };
00257 
00262 struct JackClientOpenResult : public JackResult
00263 {
00264 
00265     int fSharedEngine;
00266     int fSharedClient;
00267     int fSharedGraph;
00268 
00269     JackClientOpenResult()
00270             : JackResult(), fSharedEngine(-1), fSharedClient(-1), fSharedGraph(-1)
00271     {}
00272     JackClientOpenResult(int32_t result, int index1, int index2, int index3)
00273             : JackResult(result), fSharedEngine(index1), fSharedClient(index2), fSharedGraph(index3)
00274     {}
00275 
00276     int Read(JackChannelTransaction* trans)
00277     {
00278         CheckRes(JackResult::Read(trans));
00279         CheckRes(trans->Read(&fSharedEngine, sizeof(int)));
00280         CheckRes(trans->Read(&fSharedClient, sizeof(int)));
00281         CheckRes(trans->Read(&fSharedGraph, sizeof(int)));
00282         return 0;
00283     }
00284 
00285     int Write(JackChannelTransaction* trans)
00286     {
00287         CheckRes(JackResult::Write(trans));
00288         CheckRes(trans->Write(&fSharedEngine, sizeof(int)));
00289         CheckRes(trans->Write(&fSharedClient, sizeof(int)));
00290         CheckRes(trans->Write(&fSharedGraph, sizeof(int)));
00291         return 0;
00292     }
00293 
00294 };
00295 
00300 struct JackClientCloseRequest : public JackRequest
00301 {
00302 
00303     int fRefNum;
00304 
00305     JackClientCloseRequest()
00306     {}
00307     JackClientCloseRequest(int refnum): JackRequest(JackRequest::kClientClose), fRefNum(refnum)
00308     {}
00309 
00310     int Read(JackChannelTransaction* trans)
00311     {
00312         return trans->Read(&fRefNum, sizeof(int));
00313     }
00314 
00315     int Write(JackChannelTransaction* trans)
00316     {
00317         CheckRes(JackRequest::Write(trans));
00318         return trans->Write(&fRefNum, sizeof(int));
00319     }
00320 
00321 };
00322 
00327 struct JackActivateRequest : public JackRequest
00328 {
00329 
00330     int fRefNum;
00331     int fIsRealTime;
00332 
00333     JackActivateRequest()
00334     {}
00335     JackActivateRequest(int refnum, int is_real_time)
00336         : JackRequest(JackRequest::kActivateClient), fRefNum(refnum), fIsRealTime(is_real_time)
00337     {}
00338 
00339     int Read(JackChannelTransaction* trans)
00340     {
00341         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00342         return trans->Read(&fIsRealTime, sizeof(int));
00343     }
00344 
00345     int Write(JackChannelTransaction* trans)
00346     {
00347         CheckRes(JackRequest::Write(trans));
00348         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00349         return trans->Write(&fIsRealTime, sizeof(int));
00350     }
00351 
00352 };
00353 
00358 struct JackDeactivateRequest : public JackRequest
00359 {
00360 
00361     int fRefNum;
00362 
00363     JackDeactivateRequest()
00364     {}
00365     JackDeactivateRequest(int refnum): JackRequest(JackRequest::kDeactivateClient), fRefNum(refnum)
00366     {}
00367 
00368     int Read(JackChannelTransaction* trans)
00369     {
00370         return trans->Read(&fRefNum, sizeof(int));
00371     }
00372 
00373     int Write(JackChannelTransaction* trans)
00374     {
00375         CheckRes(JackRequest::Write(trans));
00376         return trans->Write(&fRefNum, sizeof(int));
00377     }
00378 
00379 };
00380 
00385 struct JackPortRegisterRequest : public JackRequest
00386 {
00387 
00388     int fRefNum;
00389     char fName[JACK_PORT_NAME_SIZE + 1];
00390     char fPortType[JACK_PORT_TYPE_SIZE + 1];
00391     unsigned int fFlags;
00392     unsigned int fBufferSize;
00393 
00394     JackPortRegisterRequest()
00395     {}
00396     JackPortRegisterRequest(int refnum, const char* name, const char* port_type, unsigned int flags, unsigned int buffer_size)
00397             : JackRequest(JackRequest::kRegisterPort), fRefNum(refnum), fFlags(flags), fBufferSize(buffer_size)
00398     {
00399         strcpy(fName, name);
00400         strcpy(fPortType, port_type);
00401     }
00402 
00403     int Read(JackChannelTransaction* trans)
00404     {
00405         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00406         CheckRes(trans->Read(&fName, sizeof(fName)));
00407         CheckRes(trans->Read(&fPortType, sizeof(fPortType)));
00408         CheckRes(trans->Read(&fFlags, sizeof(unsigned int)));
00409         CheckRes(trans->Read(&fBufferSize, sizeof(unsigned int)));
00410         return 0;
00411     }
00412 
00413     int Write(JackChannelTransaction* trans)
00414     {
00415         CheckRes(JackRequest::Write(trans));
00416         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00417         CheckRes(trans->Write(&fName, sizeof(fName)));
00418         CheckRes(trans->Write(&fPortType, sizeof(fPortType)));
00419         CheckRes(trans->Write(&fFlags, sizeof(unsigned int)));
00420         CheckRes(trans->Write(&fBufferSize, sizeof(unsigned int)));
00421         return 0;
00422     }
00423 
00424 };
00425 
00430 struct JackPortRegisterResult : public JackResult
00431 {
00432 
00433     jack_port_id_t fPortIndex;
00434 
00435     JackPortRegisterResult(): JackResult(), fPortIndex(NO_PORT)
00436     {}
00437 
00438     int Read(JackChannelTransaction* trans)
00439     {
00440         CheckRes(JackResult::Read(trans));
00441         return trans->Read(&fPortIndex, sizeof(jack_port_id_t));
00442     }
00443 
00444     int Write(JackChannelTransaction* trans)
00445     {
00446         CheckRes(JackResult::Write(trans));
00447         return trans->Write(&fPortIndex, sizeof(jack_port_id_t));
00448     }
00449 
00450 };
00451 
00456 struct JackPortUnRegisterRequest : public JackRequest
00457 {
00458 
00459     int fRefNum;
00460     jack_port_id_t fPortIndex;
00461 
00462     JackPortUnRegisterRequest()
00463     {}
00464     JackPortUnRegisterRequest(int refnum, jack_port_id_t index)
00465         : JackRequest(JackRequest::kUnRegisterPort), fRefNum(refnum), fPortIndex(index)
00466     {}
00467 
00468     int Read(JackChannelTransaction* trans)
00469     {
00470         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00471         CheckRes(trans->Read(&fPortIndex, sizeof(jack_port_id_t)));
00472         return 0;
00473     }
00474 
00475     int Write(JackChannelTransaction* trans)
00476     {
00477         CheckRes(JackRequest::Write(trans));
00478         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00479         CheckRes(trans->Write(&fPortIndex, sizeof(jack_port_id_t)));
00480         return 0;
00481     }
00482 
00483 };
00484 
00489 struct JackPortConnectNameRequest : public JackRequest
00490 {
00491 
00492     int fRefNum;
00493     char fSrc[JACK_PORT_NAME_SIZE + 1];
00494     char fDst[JACK_PORT_NAME_SIZE + 1];
00495 
00496     JackPortConnectNameRequest()
00497     {}
00498     JackPortConnectNameRequest(int refnum, const char* src_name, const char* dst_name)
00499         : JackRequest(JackRequest::kConnectNamePorts), fRefNum(refnum)
00500     {
00501         strcpy(fSrc, src_name);
00502         strcpy(fDst, dst_name);
00503     }
00504 
00505     int Read(JackChannelTransaction* trans)
00506     {
00507         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00508         CheckRes(trans->Read(&fSrc, sizeof(fSrc)));
00509         CheckRes(trans->Read(&fDst, sizeof(fDst)));
00510         return 0;
00511 
00512     }
00513 
00514     int Write(JackChannelTransaction* trans)
00515     {
00516         CheckRes(JackRequest::Write(trans));
00517         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00518         CheckRes(trans->Write(&fSrc, sizeof(fSrc)));
00519         CheckRes(trans->Write(&fDst, sizeof(fDst)));
00520         return 0;
00521     }
00522 
00523 };
00524 
00529 struct JackPortDisconnectNameRequest : public JackRequest
00530 {
00531 
00532     int fRefNum;
00533     char fSrc[JACK_PORT_NAME_SIZE + 1];
00534     char fDst[JACK_PORT_NAME_SIZE + 1];
00535 
00536     JackPortDisconnectNameRequest()
00537     {}
00538     JackPortDisconnectNameRequest(int refnum, const char* src_name, const char* dst_name)
00539         : JackRequest(JackRequest::kDisconnectNamePorts), fRefNum(refnum)
00540     {
00541         strcpy(fSrc, src_name);
00542         strcpy(fDst, dst_name);
00543     }
00544 
00545     int Read(JackChannelTransaction* trans)
00546     {
00547         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00548         CheckRes(trans->Read(&fSrc, sizeof(fSrc)));
00549         CheckRes(trans->Read(&fDst, sizeof(fDst)));
00550         return 0;
00551     }
00552 
00553     int Write(JackChannelTransaction* trans)
00554     {
00555         CheckRes(JackRequest::Write(trans));
00556         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00557         CheckRes(trans->Write(&fSrc, sizeof(fSrc)));
00558         CheckRes(trans->Write(&fDst, sizeof(fDst)));
00559         return 0;
00560     }
00561 
00562 };
00563 
00568 struct JackPortConnectRequest : public JackRequest
00569 {
00570 
00571     int fRefNum;
00572     jack_port_id_t fSrc;
00573     jack_port_id_t fDst;
00574 
00575     JackPortConnectRequest()
00576     {}
00577     JackPortConnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst)
00578         : JackRequest(JackRequest::kConnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
00579     {}
00580 
00581     int Read(JackChannelTransaction* trans)
00582     {
00583         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00584         CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
00585         CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
00586         return 0;
00587     }
00588 
00589     int Write(JackChannelTransaction* trans)
00590     {
00591         CheckRes(JackRequest::Write(trans));
00592         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00593         CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
00594         CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
00595         return 0;
00596     }
00597 
00598 };
00599 
00604 struct JackPortDisconnectRequest : public JackRequest
00605 {
00606 
00607     int fRefNum;
00608     jack_port_id_t fSrc;
00609     jack_port_id_t fDst;
00610 
00611     JackPortDisconnectRequest()
00612     {}
00613     JackPortDisconnectRequest(int refnum, jack_port_id_t src, jack_port_id_t dst)
00614         : JackRequest(JackRequest::kDisconnectPorts), fRefNum(refnum), fSrc(src), fDst(dst)
00615     {}
00616 
00617     int Read(JackChannelTransaction* trans)
00618     {
00619         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00620         CheckRes(trans->Read(&fSrc, sizeof(jack_port_id_t)));
00621         CheckRes(trans->Read(&fDst, sizeof(jack_port_id_t)));
00622         return 0;
00623     }
00624 
00625     int Write(JackChannelTransaction* trans)
00626     {
00627         CheckRes(JackRequest::Write(trans));
00628         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00629         CheckRes(trans->Write(&fSrc, sizeof(jack_port_id_t)));
00630         CheckRes(trans->Write(&fDst, sizeof(jack_port_id_t)));
00631         return 0;
00632     }
00633 
00634 };
00635 
00640 struct JackPortRenameRequest : public JackRequest
00641 {
00642 
00643     int fRefNum;
00644     jack_port_id_t fPort;
00645     char fName[JACK_PORT_NAME_SIZE + 1];
00646 
00647     JackPortRenameRequest()
00648     {}
00649     JackPortRenameRequest(int refnum, jack_port_id_t port, const char* name)
00650         : JackRequest(JackRequest::kPortRename), fRefNum(refnum), fPort(port)
00651     {
00652         strcpy(fName, name);
00653     }
00654 
00655     int Read(JackChannelTransaction* trans)
00656     {
00657         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00658         CheckRes(trans->Read(&fPort, sizeof(jack_port_id_t)));
00659         CheckRes(trans->Read(&fName, sizeof(fName)));
00660         return 0;
00661     }
00662 
00663     int Write(JackChannelTransaction* trans)
00664     {
00665         CheckRes(JackRequest::Write(trans));
00666         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00667         CheckRes(trans->Write(&fPort, sizeof(jack_port_id_t)));
00668         CheckRes(trans->Write(&fName, sizeof(fName)));
00669         return 0;
00670 
00671     }
00672 
00673 };
00674 
00679 struct JackSetBufferSizeRequest : public JackRequest
00680 {
00681 
00682     jack_nframes_t fBufferSize;
00683 
00684     JackSetBufferSizeRequest()
00685     {}
00686     JackSetBufferSizeRequest(jack_nframes_t buffer_size)
00687         : JackRequest(JackRequest::kSetBufferSize), fBufferSize(buffer_size)
00688     {}
00689 
00690     int Read(JackChannelTransaction* trans)
00691     {
00692         return trans->Read(&fBufferSize, sizeof(jack_nframes_t));
00693     }
00694 
00695     int Write(JackChannelTransaction* trans)
00696     {
00697         CheckRes(JackRequest::Write(trans));
00698         return trans->Write(&fBufferSize, sizeof(jack_nframes_t));
00699     }
00700 
00701 };
00702 
00707 struct JackSetFreeWheelRequest : public JackRequest
00708 {
00709 
00710     int fOnOff;
00711 
00712     JackSetFreeWheelRequest()
00713     {}
00714     JackSetFreeWheelRequest(int onoff)
00715         : JackRequest(JackRequest::kSetFreeWheel), fOnOff(onoff)
00716     {}
00717 
00718     int Read(JackChannelTransaction* trans)
00719     {
00720         return trans->Read(&fOnOff, sizeof(int));
00721     }
00722 
00723     int Write(JackChannelTransaction* trans)
00724     {
00725         CheckRes(JackRequest::Write(trans));
00726         return trans->Write(&fOnOff, sizeof(int));
00727     }
00728 
00729 };
00730 
00735 struct JackComputeTotalLatenciesRequest : public JackRequest
00736 {
00737 
00738     JackComputeTotalLatenciesRequest()
00739         : JackRequest(JackRequest::kComputeTotalLatencies)
00740     {}
00741 
00742     int Read(JackChannelTransaction* trans)
00743     {
00744         return 0;
00745     }
00746 
00747     int Write(JackChannelTransaction* trans)
00748     {
00749         CheckRes(JackRequest::Write(trans));
00750         return 0;
00751     }
00752 
00753 };
00754 
00759 struct JackReleaseTimebaseRequest : public JackRequest
00760 {
00761 
00762     int fRefNum;
00763 
00764     JackReleaseTimebaseRequest()
00765     {}
00766     JackReleaseTimebaseRequest(int refnum)
00767         : JackRequest(JackRequest::kReleaseTimebase), fRefNum(refnum)
00768     {}
00769 
00770     int Read(JackChannelTransaction* trans)
00771     {
00772         return trans->Read(&fRefNum, sizeof(int));
00773     }
00774 
00775     int Write(JackChannelTransaction* trans)
00776     {
00777         CheckRes(JackRequest::Write(trans));
00778         return trans->Write(&fRefNum, sizeof(int));
00779     }
00780 
00781 };
00782 
00787 struct JackSetTimebaseCallbackRequest : public JackRequest
00788 {
00789 
00790     int fRefNum;
00791     int fConditionnal;
00792 
00793     JackSetTimebaseCallbackRequest()
00794     {}
00795     JackSetTimebaseCallbackRequest(int refnum, int conditional)
00796         : JackRequest(JackRequest::kSetTimebaseCallback), fRefNum(refnum), fConditionnal(conditional)
00797     {}
00798 
00799     int Read(JackChannelTransaction* trans)
00800     {
00801         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00802         return trans->Read(&fConditionnal, sizeof(int));
00803     }
00804 
00805     int Write(JackChannelTransaction* trans)
00806     {
00807         CheckRes(JackRequest::Write(trans));
00808         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00809         return trans->Write(&fConditionnal, sizeof(int));
00810     }
00811 
00812 };
00813 
00818 struct JackGetInternalClientNameRequest : public JackRequest
00819 {
00820 
00821     int fRefNum;
00822     int fIntRefNum;
00823 
00824     JackGetInternalClientNameRequest()
00825     {}
00826     JackGetInternalClientNameRequest(int refnum, int int_ref)
00827             : JackRequest(JackRequest::kGetInternalClientName), fRefNum(refnum), fIntRefNum(int_ref)
00828     {}
00829 
00830     int Read(JackChannelTransaction* trans)
00831     {
00832         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00833         return trans->Read(&fIntRefNum, sizeof(int));
00834     }
00835 
00836     int Write(JackChannelTransaction* trans)
00837     {
00838         CheckRes(JackRequest::Write(trans));
00839         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00840         return trans->Write(&fIntRefNum, sizeof(int));
00841     }
00842 
00843 };
00844 
00849 struct JackGetInternalClientNameResult : public JackResult
00850 {
00851 
00852     char fName[JACK_CLIENT_NAME_SIZE + 1];
00853 
00854     JackGetInternalClientNameResult(): JackResult()
00855     {}
00856     JackGetInternalClientNameResult(int32_t result, const char* name)
00857             : JackResult(result)
00858     {
00859         snprintf(fName, sizeof(fName), "%s", name);
00860     }
00861 
00862     int Read(JackChannelTransaction* trans)
00863     {
00864         CheckRes(JackResult::Read(trans));
00865         CheckRes(trans->Read(&fName, sizeof(fName)));
00866         return 0;
00867     }
00868 
00869     int Write(JackChannelTransaction* trans)
00870     {
00871         CheckRes(JackResult::Write(trans));
00872         CheckRes(trans->Write(&fName, sizeof(fName)));
00873         return 0;
00874     }
00875 
00876 };
00877 
00882 struct JackInternalClientHandleRequest : public JackRequest
00883 {
00884 
00885     int fRefNum;
00886     char fName[JACK_CLIENT_NAME_SIZE + 1];
00887 
00888     JackInternalClientHandleRequest()
00889     {}
00890     JackInternalClientHandleRequest(int refnum, const char* client_name)
00891             : JackRequest(JackRequest::kInternalClientHandle), fRefNum(refnum)
00892     {
00893         snprintf(fName, sizeof(fName), "%s", client_name);
00894     }
00895 
00896     int Read(JackChannelTransaction* trans)
00897     {
00898         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00899         return trans->Read(&fName, sizeof(fName));
00900     }
00901 
00902     int Write(JackChannelTransaction* trans)
00903     {
00904         CheckRes(JackRequest::Write(trans));
00905         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00906         return trans->Write(&fName, sizeof(fName));
00907     }
00908 
00909 };
00910 
00915 struct JackInternalClientHandleResult : public JackResult
00916 {
00917 
00918     int fStatus;
00919     int fIntRefNum;
00920 
00921     JackInternalClientHandleResult(): JackResult()
00922     {}
00923     JackInternalClientHandleResult(int32_t result, int status, int int_ref)
00924             : JackResult(result), fStatus(status), fIntRefNum(int_ref)
00925     {}
00926 
00927     int Read(JackChannelTransaction* trans)
00928     {
00929         CheckRes(JackResult::Read(trans));
00930         CheckRes(trans->Read(&fStatus, sizeof(int)));
00931         CheckRes(trans->Read(&fIntRefNum, sizeof(int)));
00932         return 0;
00933     }
00934 
00935     int Write(JackChannelTransaction* trans)
00936     {
00937         CheckRes(JackResult::Write(trans));
00938         CheckRes(trans->Write(&fStatus, sizeof(int)));
00939         CheckRes(trans->Write(&fIntRefNum, sizeof(int)));
00940         return 0;
00941     }
00942 
00943 };
00944 
00949 struct JackInternalClientLoadRequest : public JackRequest
00950 {
00951 
00952 #ifndef MAX_PATH
00953 #define MAX_PATH 256
00954 #endif
00955 
00956     int fRefNum;
00957     char fName[JACK_CLIENT_NAME_SIZE + 1];
00958     char fDllName[MAX_PATH + 1];
00959     char fLoadInitName[JACK_LOAD_INIT_LIMIT + 1];
00960     int fOptions;
00961     int fUUID;
00962 
00963     JackInternalClientLoadRequest()
00964     {}
00965     JackInternalClientLoadRequest(int refnum, const char* client_name, const char* so_name, const char* objet_data, int options, int uuid )
00966             : JackRequest(JackRequest::kInternalClientLoad), fRefNum(refnum), fOptions(options), fUUID(uuid)
00967     {
00968         snprintf(fName, sizeof(fName), "%s", client_name);
00969         snprintf(fDllName, sizeof(fDllName), "%s", so_name);
00970         snprintf(fLoadInitName, sizeof(fLoadInitName), "%s", objet_data);
00971         snprintf(fLoadInitName, sizeof(fLoadInitName), "%s", objet_data);
00972     }
00973 
00974     int Read(JackChannelTransaction* trans)
00975     {
00976         CheckRes(trans->Read(&fRefNum, sizeof(int)));
00977         CheckRes(trans->Read(&fName, sizeof(fName)));
00978         CheckRes(trans->Read(&fDllName, sizeof(fDllName)));
00979         CheckRes(trans->Read(&fLoadInitName, sizeof(fLoadInitName)));
00980         CheckRes(trans->Read(&fUUID, sizeof(int)));
00981         return trans->Read(&fOptions, sizeof(int));
00982     }
00983 
00984     int Write(JackChannelTransaction* trans)
00985     {
00986         CheckRes(JackRequest::Write(trans));
00987         CheckRes(trans->Write(&fRefNum, sizeof(int)));
00988         CheckRes(trans->Write(&fName, sizeof(fName)));
00989         CheckRes(trans->Write(&fDllName, sizeof(fDllName)));
00990         CheckRes(trans->Write(&fLoadInitName, sizeof(fLoadInitName)));
00991         CheckRes(trans->Write(&fUUID, sizeof(int)));
00992         return trans->Write(&fOptions, sizeof(int));
00993     }
00994 
00995 };
00996 
01001 struct JackInternalClientLoadResult : public JackResult
01002 {
01003 
01004     int fStatus;
01005     int fIntRefNum;
01006 
01007     JackInternalClientLoadResult(): JackResult()
01008     {}
01009     JackInternalClientLoadResult(int32_t result, int status, int int_ref)
01010             : JackResult(result), fStatus(status), fIntRefNum(int_ref)
01011     {}
01012 
01013     int Read(JackChannelTransaction* trans)
01014     {
01015         CheckRes(JackResult::Read(trans));
01016         CheckRes(trans->Read(&fStatus, sizeof(int)));
01017         CheckRes(trans->Read(&fIntRefNum, sizeof(int)));
01018         return 0;
01019     }
01020 
01021     int Write(JackChannelTransaction* trans)
01022     {
01023         CheckRes(JackResult::Write(trans));
01024         CheckRes(trans->Write(&fStatus, sizeof(int)));
01025         CheckRes(trans->Write(&fIntRefNum, sizeof(int)));
01026         return 0;
01027     }
01028 
01029 };
01030 
01035 struct JackInternalClientUnloadRequest : public JackRequest
01036 {
01037 
01038     int fRefNum;
01039     int fIntRefNum;
01040 
01041     JackInternalClientUnloadRequest()
01042     {}
01043     JackInternalClientUnloadRequest(int refnum, int int_ref)
01044             : JackRequest(JackRequest::kInternalClientUnload), fRefNum(refnum), fIntRefNum(int_ref)
01045     {}
01046 
01047     int Read(JackChannelTransaction* trans)
01048     {
01049         CheckRes(trans->Read(&fRefNum, sizeof(int)));
01050         return trans->Read(&fIntRefNum, sizeof(int));
01051     }
01052 
01053     int Write(JackChannelTransaction* trans)
01054     {
01055         CheckRes(JackRequest::Write(trans));
01056         CheckRes(trans->Write(&fRefNum, sizeof(int)));
01057         return trans->Write(&fIntRefNum, sizeof(int));
01058     }
01059 };
01060 
01065 struct JackInternalClientUnloadResult : public JackResult
01066 {
01067 
01068     int fStatus;
01069 
01070     JackInternalClientUnloadResult(): JackResult()
01071     {}
01072     JackInternalClientUnloadResult(int32_t result, int status)
01073             : JackResult(result), fStatus(status)
01074     {}
01075 
01076     int Read(JackChannelTransaction* trans)
01077     {
01078         CheckRes(JackResult::Read(trans));
01079         CheckRes(trans->Read(&fStatus, sizeof(int)));
01080         return 0;
01081     }
01082 
01083     int Write(JackChannelTransaction* trans)
01084     {
01085         CheckRes(JackResult::Write(trans));
01086         CheckRes(trans->Write(&fStatus, sizeof(int)));
01087         return 0;
01088     }
01089 
01090 };
01091 
01096 struct JackClientNotificationRequest : public JackRequest
01097 {
01098 
01099     int fRefNum;
01100     int fNotify;
01101     int fValue;
01102 
01103     JackClientNotificationRequest()
01104     {}
01105     JackClientNotificationRequest(int refnum, int notify, int value)
01106             : JackRequest(JackRequest::kNotification), fRefNum(refnum), fNotify(notify), fValue(value)
01107     {}
01108 
01109     int Read(JackChannelTransaction* trans)
01110     {
01111         CheckRes(trans->Read(&fRefNum, sizeof(int)));
01112         CheckRes(trans->Read(&fNotify, sizeof(int)));
01113         CheckRes(trans->Read(&fValue, sizeof(int)));
01114         return 0;
01115     }
01116 
01117     int Write(JackChannelTransaction* trans)
01118     {
01119         CheckRes(JackRequest::Write(trans));
01120         CheckRes(trans->Write(&fRefNum, sizeof(int)));
01121         CheckRes(trans->Write(&fNotify, sizeof(int)));
01122         CheckRes(trans->Write(&fValue, sizeof(int)));
01123         return 0;
01124     }
01125 
01126 };
01127 
01128 struct JackSessionCommand
01129 {
01130     char fUUID[JACK_UUID_SIZE];
01131     char fClientName[JACK_CLIENT_NAME_SIZE+1];
01132     char fCommand[JACK_SESSION_COMMAND_SIZE];
01133     jack_session_flags_t fFlags;
01134 
01135     JackSessionCommand()
01136     {}
01137 
01138     JackSessionCommand(const char *uuid, const char *clientname, const char *command, jack_session_flags_t flags)
01139     {
01140         strncpy(fUUID, uuid, sizeof(fUUID));
01141         strncpy(fClientName, clientname, sizeof(fClientName));
01142         strncpy(fCommand, command, sizeof(fCommand));
01143         fFlags = flags;
01144     }
01145 };
01146 
01147 struct JackSessionNotifyResult : public JackResult
01148 {
01149 
01150     std::list<JackSessionCommand> fCommandList;
01151     bool fDone;
01152 
01153     JackSessionNotifyResult(): JackResult(), fDone(false)
01154     {}
01155     JackSessionNotifyResult(int32_t result)
01156             : JackResult(result), fDone(false)
01157     {}
01158 
01159     int Read(JackChannelTransaction* trans)
01160     {
01161         if (trans == NULL)
01162         {
01163             return 0;
01164         }
01165 
01166         CheckRes(JackResult::Read(trans));
01167         while (true) {
01168             JackSessionCommand buffer;
01169 
01170             CheckRes(trans->Read(buffer.fUUID, sizeof(buffer.fUUID)));
01171             if (buffer.fUUID[0] == '\0')
01172                 break;
01173 
01174             CheckRes(trans->Read(buffer.fClientName, sizeof(buffer.fClientName)));
01175             CheckRes(trans->Read(buffer.fCommand, sizeof(buffer.fCommand)));
01176             CheckRes(trans->Read(&(buffer.fFlags), sizeof(buffer.fFlags)));
01177 
01178             fCommandList.push_back(buffer);
01179         }
01180 
01181         fDone = true;
01182 
01183         return 0;
01184     }
01185 
01186     int Write(JackChannelTransaction* trans)
01187     {
01188         if (trans == NULL)
01189         {
01190             fDone = true;
01191             return 0;
01192         }
01193 
01194         char terminator[JACK_UUID_SIZE];
01195         terminator[0] = '\0';
01196 
01197         CheckRes(JackResult::Write(trans));
01198         for (std::list<JackSessionCommand>::iterator i = fCommandList.begin(); i != fCommandList.end(); i++) {
01199             CheckRes(trans->Write(i->fUUID, sizeof(i->fUUID)));
01200             CheckRes(trans->Write(i->fClientName, sizeof(i->fClientName)));
01201             CheckRes(trans->Write(i->fCommand, sizeof(i->fCommand)));
01202             CheckRes(trans->Write(&(i->fFlags), sizeof(i->fFlags)));
01203         }
01204         CheckRes(trans->Write(terminator, sizeof(terminator)));
01205         return 0;
01206     }
01207 
01208     jack_session_command_t* GetCommands()
01209     {
01210         /* TODO: some kind of signal should be used instead */
01211         while (!fDone)
01212         {
01213             JackSleep(50000);    /* 50 ms */
01214         }
01215 
01216         jack_session_command_t* session_command = (jack_session_command_t *)malloc(sizeof(jack_session_command_t) * (fCommandList.size() + 1));
01217         int i = 0;
01218 
01219         for (std::list<JackSessionCommand>::iterator ci = fCommandList.begin(); ci != fCommandList.end(); ci++) {
01220             session_command[i].uuid = strdup(ci->fUUID);
01221             session_command[i].client_name = strdup(ci->fClientName);
01222             session_command[i].command = strdup(ci->fCommand);
01223             session_command[i].flags = ci->fFlags;
01224             i += 1;
01225         }
01226 
01227         session_command[i].uuid = NULL;
01228         session_command[i].client_name = NULL;
01229         session_command[i].command = NULL;
01230         session_command[i].flags = (jack_session_flags_t)0;
01231 
01232         return session_command;
01233     }
01234 };
01235 
01240 struct JackSessionNotifyRequest : public JackRequest
01241 {
01242     char fPath[JACK_MESSAGE_SIZE + 1];
01243     char fDst[JACK_CLIENT_NAME_SIZE + 1];
01244     jack_session_event_type_t fEventType;
01245     int fRefNum;
01246 
01247     JackSessionNotifyRequest()
01248     {}
01249     JackSessionNotifyRequest(int refnum, const char* path, jack_session_event_type_t type, const char* dst)
01250             : JackRequest(JackRequest::kSessionNotify), fEventType(type), fRefNum(refnum)
01251     {
01252         snprintf(fPath, sizeof(fPath), "%s", path);
01253         if (dst) {
01254             snprintf(fDst, sizeof(fDst), "%s", dst);
01255         } else {
01256             fDst[0] = '\0';
01257         }
01258     }
01259 
01260     int Read(JackChannelTransaction* trans)
01261     {
01262         CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));
01263         CheckRes(trans->Read(&fPath, sizeof(fPath)));
01264         CheckRes(trans->Read(&fDst, sizeof(fDst)));
01265         CheckRes(trans->Read(&fEventType, sizeof(fEventType)));
01266         return 0;
01267     }
01268 
01269     int Write(JackChannelTransaction* trans)
01270     {
01271         CheckRes(JackRequest::Write(trans));
01272         CheckRes(trans->Write(&fRefNum, sizeof(fRefNum)));
01273         CheckRes(trans->Write(&fPath, sizeof(fPath)));
01274         CheckRes(trans->Write(&fDst, sizeof(fDst)));
01275         CheckRes(trans->Write(&fEventType, sizeof(fEventType)));
01276         return 0;
01277     }
01278 
01279 };
01280 
01281 struct JackSessionReplyRequest : public JackRequest
01282 {
01283     int fRefNum;
01284 
01285     JackSessionReplyRequest()
01286     {}
01287 
01288     JackSessionReplyRequest(int refnum)
01289             : JackRequest(JackRequest::kSessionReply), fRefNum(refnum)
01290     {}
01291 
01292     int Read(JackChannelTransaction* trans)
01293     {
01294         CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));
01295         return 0;
01296     }
01297 
01298     int Write(JackChannelTransaction* trans)
01299     {
01300         CheckRes(JackRequest::Write(trans));
01301         CheckRes(trans->Write(&fRefNum, sizeof(fRefNum)));
01302         return 0;
01303     }
01304 
01305 };
01306 
01307 struct JackClientNameResult : public JackResult
01308 {
01309     char fName[JACK_CLIENT_NAME_SIZE + 1];
01310 
01311     JackClientNameResult(): JackResult()
01312     {}
01313     JackClientNameResult(int32_t result, const char* name)
01314             : JackResult(result)
01315     {
01316         snprintf(fName, sizeof(fName), "%s", name);
01317     }
01318 
01319     int Read(JackChannelTransaction* trans)
01320     {
01321         CheckRes(JackResult::Read(trans));
01322         CheckRes(trans->Read(&fName, sizeof(fName)));
01323         return 0;
01324     }
01325 
01326     int Write(JackChannelTransaction* trans)
01327     {
01328         CheckRes(JackResult::Write(trans));
01329         CheckRes(trans->Write(&fName, sizeof(fName)));
01330         return 0;
01331     }
01332 
01333 };
01334 
01335 struct JackUUIDResult : public JackResult
01336 {
01337     char fUUID[JACK_UUID_SIZE];
01338 
01339     JackUUIDResult(): JackResult()
01340     {}
01341     JackUUIDResult(int32_t result, const char* uuid)
01342             : JackResult(result)
01343     {
01344         snprintf(fUUID, sizeof(fUUID), "%s", uuid);
01345     }
01346 
01347     int Read(JackChannelTransaction* trans)
01348     {
01349         CheckRes(JackResult::Read(trans));
01350         CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
01351         return 0;
01352     }
01353 
01354     int Write(JackChannelTransaction* trans)
01355     {
01356         CheckRes(JackResult::Write(trans));
01357         CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
01358         return 0;
01359     }
01360 
01361 };
01362 
01363 struct JackGetUUIDRequest : public JackRequest
01364 {
01365     char fName[JACK_CLIENT_NAME_SIZE + 1];
01366 
01367     JackGetUUIDRequest()
01368     {}
01369 
01370     JackGetUUIDRequest(const char* client_name)
01371             : JackRequest(JackRequest::kGetUUIDByClient)
01372     {
01373         strncpy(fName, client_name, sizeof(fName));
01374     }
01375 
01376     int Read(JackChannelTransaction* trans)
01377     {
01378         CheckRes(trans->Read(&fName, sizeof(fName)));
01379         return 0;
01380     }
01381 
01382     int Write(JackChannelTransaction* trans)
01383     {
01384         CheckRes(JackRequest::Write(trans));
01385         CheckRes(trans->Write(&fName, sizeof(fName)));
01386         return 0;
01387     }
01388 
01389 };
01390 
01391 struct JackGetClientNameRequest : public JackRequest
01392 {
01393     char fUUID[JACK_UUID_SIZE];
01394 
01395     JackGetClientNameRequest()
01396     {}
01397 
01398     JackGetClientNameRequest(const char* uuid)
01399             : JackRequest(JackRequest::kGetClientByUUID)
01400     {
01401         strncpy(fUUID, uuid, sizeof(fUUID));
01402     }
01403 
01404     int Read(JackChannelTransaction* trans)
01405     {
01406         CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
01407         return 0;
01408     }
01409 
01410     int Write(JackChannelTransaction* trans)
01411     {
01412         CheckRes(JackRequest::Write(trans));
01413         CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
01414         return 0;
01415     }
01416 
01417 };
01418 
01419 struct JackReserveNameRequest : public JackRequest
01420 {
01421     int  fRefNum;
01422     char fName[JACK_CLIENT_NAME_SIZE + 1];
01423     char fUUID[JACK_UUID_SIZE];
01424 
01425     JackReserveNameRequest()
01426     {}
01427 
01428     JackReserveNameRequest(int refnum, const char *name, const char* uuid)
01429             : JackRequest(JackRequest::kReserveClientName), fRefNum(refnum)
01430     {
01431         strncpy(fName, name, sizeof(fName));
01432         strncpy(fUUID, uuid, sizeof(fUUID));
01433     }
01434 
01435     int Read(JackChannelTransaction* trans)
01436     {
01437         CheckRes(trans->Read(&fUUID, sizeof(fUUID)));
01438         CheckRes(trans->Read(&fName, sizeof(fName)));
01439         CheckRes(trans->Read(&fRefNum, sizeof(fRefNum)));
01440         return 0;
01441     }
01442 
01443     int Write(JackChannelTransaction* trans)
01444     {
01445         CheckRes(JackRequest::Write(trans));
01446         CheckRes(trans->Write(&fUUID, sizeof(fUUID)));
01447         CheckRes(trans->Write(&fName, sizeof(fName)));
01448         CheckRes(trans->Write(&fRefNum, sizeof(fRefNum)));
01449         return 0;
01450     }
01451 
01452 };
01453 
01454 struct JackClientHasSessionCallbackRequest : public JackRequest
01455 {
01456     char fName[JACK_CLIENT_NAME_SIZE + 1];
01457 
01458     JackClientHasSessionCallbackRequest()
01459     {}
01460 
01461     JackClientHasSessionCallbackRequest(const char *name)
01462             : JackRequest(JackRequest::kClientHasSessionCallback)
01463     {
01464         strncpy(fName, name, sizeof(fName));
01465     }
01466 
01467     int Read(JackChannelTransaction* trans)
01468     {
01469         CheckRes(trans->Read(&fName, sizeof(fName)));
01470         return 0;
01471     }
01472 
01473     int Write(JackChannelTransaction* trans)
01474     {
01475         CheckRes(JackRequest::Write(trans));
01476         CheckRes(trans->Write(&fName, sizeof(fName)));
01477         return 0;
01478     }
01479 
01480 };
01481 
01486 struct JackClientNotification
01487 {
01488     char fName[JACK_CLIENT_NAME_SIZE + 1];
01489     int fRefNum;
01490     int fNotify;
01491     int fValue1;
01492     int fValue2;
01493     int fSync;
01494     char fMessage[JACK_MESSAGE_SIZE + 1];
01495 
01496     JackClientNotification(): fNotify(-1), fValue1(-1), fValue2(-1)
01497     {}
01498     JackClientNotification(const char* name, int refnum, int notify, int sync, const char* message, int value1, int value2)
01499             : fRefNum(refnum), fNotify(notify), fValue1(value1), fValue2(value2), fSync(sync)
01500     {
01501         snprintf(fName, sizeof(fName), "%s", name);
01502         snprintf(fMessage, sizeof(fMessage), "%s", message);
01503     }
01504 
01505     int Read(JackChannelTransaction* trans)
01506     {
01507         CheckRes(trans->Read(&fName, sizeof(fName)));
01508         CheckRes(trans->Read(&fRefNum, sizeof(int)));
01509         CheckRes(trans->Read(&fNotify, sizeof(int)));
01510         CheckRes(trans->Read(&fValue1, sizeof(int)));
01511         CheckRes(trans->Read(&fValue2, sizeof(int)));
01512         CheckRes(trans->Read(&fSync, sizeof(int)));
01513         CheckRes(trans->Read(&fMessage, sizeof(fMessage)));
01514         return 0;
01515     }
01516 
01517     int Write(JackChannelTransaction* trans)
01518     {
01519         CheckRes(trans->Write(&fName, sizeof(fName)));
01520         CheckRes(trans->Write(&fRefNum, sizeof(int)));
01521         CheckRes(trans->Write(&fNotify, sizeof(int)));
01522         CheckRes(trans->Write(&fValue1, sizeof(int)));
01523         CheckRes(trans->Write(&fValue2, sizeof(int)));
01524         CheckRes(trans->Write(&fSync, sizeof(int)));
01525         CheckRes(trans->Write(&fMessage, sizeof(fMessage)));
01526         return 0;
01527     }
01528 
01529 };
01530 
01531 } // end of namespace
01532 
01533 #endif