ALIROOT-5600 - skip non-participating detector modules
[u/mrichter/AliRoot.git] / HLT / BASE / AliHLTMessage.h
1 // $Id$
2
3 /** @file   AliHLTMessage.h
4     @author Matthias Richter (customization of Root TMessage )
5     @date   
6     @brief  Serialization of Root objects in the ALICE HLT. */
7
8 // This is the original Root TMessage implementation with a few minor
9 // modifications, original revision:
10 // root/net: v5-14-00 $: TMessage.h,v 1.9 2005/12/09 15:12:19 rdm
11 // Author: Fons Rademakers   19/12/96
12 //
13 // 2009-09-01 updating to revision
14 // @(#)root/net:$Id$
15 // Streaming problems have been encountered, especially when streaming
16 // TObjArrays. As long as there was just one member, the streaming was
17 // fine. With several members, internal variables of the objects have
18 // been interchanged/mixed. This bug only effected the serialization
19 // part, not the restoration of the object.
20
21 /*************************************************************************
22  * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
23  * All rights reserved.                                                  *
24  *                                                                       *
25  * For the licensing terms see $ROOTSYS/LICENSE.                         *
26  * For the list of contributors see $ROOTSYS/README/CREDITS.             *
27  *************************************************************************/
28
29 #ifndef ALIHLTMESSAGE_H
30 #define ALIHLTMESSAGE_H
31
32
33 //////////////////////////////////////////////////////////////////////////
34 //                                                                      //
35 // TMessage                                                             //
36 //                                                                      //
37 // Message buffer class used for serializing objects and sending them   //
38 // over the network.                                                    //
39 //                                                                      //
40 //////////////////////////////////////////////////////////////////////////
41
42 // TBuffer has been made pure virtual in root version v5-15-02, this
43 // requires to inherit from TBufferFile instead of TBuffer.
44 // TMessage is not really used by this class but by including it we also get
45 // TBufferFile if this exists. The define ROOT_TBufferFile can than be used
46 // to differentiate between the usage of TBuffer or TBufferFile.
47 #include "TMessage.h"
48
49 #ifndef ROOT_MessageTypes
50 #include "MessageTypes.h"
51 #endif
52 #ifndef ROOT_TBits
53 #include "TBits.h"
54 #endif
55
56 #include "AliHLTLogging.h"
57 /**
58  * @class AliHLTMessage
59  * Serialization of Root objects for transport in the Alice HLT analysis
60  * chain.
61  * This is the original Root TMessage implementation with a few minor
62  * modifications.
63  * - the <tt> AliHLTMessage(void *buf, Int_t bufsize)</tt> constructor has been
64  *   made public in order to be used externally.
65  *
66  * The class can be used to extract an object from an input data block, or a
67  * data block received via the HOMER interface or from the file writer.
68  * <pre>
69  *  AliHLTMessage msg(buffer, size);
70  *  TObject* pObj=msg.ReadObject(msg.GetClass());
71  * </pre>
72  *
73  * A simple test macro for a file can look like
74  * <pre>
75  *  const char* filename="myobject.dat";
76  *  TString param=filename;
77  *  param+="?filetype=raw";
78  *  TFile file(param);
79  *  if (file.IsZombie()) {
80  *    cout << "can not open file " << filename << endl;
81  *    return;
82  *  }
83  *  
84  *  TArrayC buffer(file.GetSize());
85  *  TArrayC tgtbuffer(file.GetSize());
86  *  if (file.ReadBuffer(buffer.GetArray(), buffer.GetSize())) {
87  *    cout << "error reading file " << filename << endl;
88  *    return;
89  *  }
90  *
91  *  AliHLTMessage msg(buffer.GetArray(), buffer.GetSize());
92  *  TObject* pObj=msg.ReadObject(msg.GetClass());
93  * </pre>
94  *
95  * @see AliHLTRootFileWriterComponent for an easy way to save objects
96  * exported via AliHLTMessage in a ROOT file.
97  *
98  * To serialize an object into a buffer, the normal ROOT TMessage mechanism
99  * can be used.
100  * <pre>
101  *    AliHLTMessage msg(kMESS_OBJECT);
102  *    msg.WriteObject(pObject);
103  *    Int_t iMsgLength=msg.Length();
104  *    if (iMsgLength>0) {
105  *      msg.SetLength(); // sets the length to the first (reserved) word
106  *      char* pMsgBuffer msg.Buffer();
107  *      // do something with pMsgBuffer and iMsgLenghth
108  *    }
109  * </pre>
110  */
111 class AliHLTMessage 
112 :
113 # if defined(ROOT_TBufferFile)
114 public TBufferFile,
115 #else
116 public TBuffer,
117 #endif
118 public AliHLTLogging {
119
120 public:
121    AliHLTMessage(UInt_t what = kMESS_ANY);
122    AliHLTMessage(void *buf, Int_t bufsize);
123    virtual ~AliHLTMessage();
124
125    void SetLength() const;
126
127    void     ForceWriteInfo(TVirtualStreamerInfo *info, Bool_t force);
128    void     Forward();
129    TClass  *GetClass() const { return fClass;}
130    void     IncrementLevel(TVirtualStreamerInfo* info);
131    void     Reset();
132    void     Reset(UInt_t what) { SetWhat(what); Reset(); }
133    UInt_t   What() const { return fWhat; }
134    void     SetWhat(UInt_t what);
135
136    void     EnableSchemaEvolution(Bool_t enable = kTRUE) { fEvolution = enable; }
137    Bool_t   UsesSchemaEvolution() const { return fEvolution; }
138    void     SetCompressionLevel(Int_t level = 1);
139    Int_t    GetCompressionLevel() const { return fCompress; }
140    Int_t    Compress();
141    Int_t    Uncompress();
142    char    *CompBuffer() const { return fBufComp; }
143    Int_t    CompLength() const { return (Int_t)(fBufCompCur - fBufComp); }
144    void     WriteObject(const TObject *obj);
145    UShort_t WriteProcessID(TProcessID *pid);
146
147    static void   EnableSchemaEvolutionForAll(Bool_t enable = kTRUE);
148    static Bool_t UsesSchemaEvolutionForAll();
149
150    const TList* GetStreamerInfos() const {return fInfos;}
151
152    /**
153     * Helper function to stream an object into an AliHLTMessage
154     * The returned instance must be cleaned by the caller
155     */
156    static AliHLTMessage* Stream(TObject* pSrc, Int_t compression=1, unsigned verbosity=0);
157
158    /**
159     * Helper function to extract an object from a buffer.
160     * The returned object must be cleaned by the caller
161     */
162    static TObject* Extract(const void* pBuffer, unsigned bufferSize, unsigned verbosity=0);
163
164    /**
165     * Helper function to extract an object from  a file containing the streamed object.
166     * The returned object must be cleaned by the caller
167     */
168    static TObject* Extract(const char* filename, unsigned verbosity=0);
169
170 private:
171    UInt_t   fWhat;        //!Message type
172    TClass  *fClass;       //!If message is kMESS_OBJECT pointer to object's class
173    Int_t    fCompress;    //!Compression level from 0 (not compressed) to 9 (max compression)
174    char    *fBufComp;     //!Compressed buffer
175    char    *fBufCompCur;  //!Current position in compressed buffer
176    char    *fCompPos;     //!Position of fBufCur when message was compressed
177    char    *fBufUncompressed; //!Uncompressed buffer
178    TBits    fBitsPIDs;    //Array of bits to mark the TProcessIDs uids written to the message
179    TList   *fInfos;       //Array of TStreamerInfo used in WriteObject
180    Bool_t   fEvolution;   //True if support for schema evolution required
181
182    static Bool_t fgEvolution;  //True if global support for schema evolution required
183
184    // AliHLTMessage objects cannot be copied or assigned
185    AliHLTMessage(const AliHLTMessage &);           // not implemented
186    void operator=(const AliHLTMessage &);     // not implemented
187
188    /** the minimum size of a serialized TObject */
189    static const Int_t fgkMinimumSize; //!transient
190
191    /** a default buffer describing an empty message */
192    static UInt_t fgkDefaultBuffer[2]; //!transient
193
194    ClassDef(AliHLTMessage,2)  // Message buffer class
195 };
196
197 #endif // ALIHLTMESSAGE_H