Restored compilation on Windows/Cygwin
[u/mrichter/AliRoot.git] / RAW / AliRawEventHeaderBase.cxx
index 18b40cf..742d062 100644 (file)
@@ -1,5 +1,3 @@
-// Author: Cvetan Cheshkov  10/10/2005
-
 /**************************************************************************
  * Copyright(c) 1998-2003, ALICE Experiment at CERN, All rights reserved. *
  *                                                                        *
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
+/* $Id$ */
+
+// Author: Cvetan Cheshkov  10/10/2005
+
 //////////////////////////////////////////////////////////////////////////
 //                                                                      //
 // AliRawEventHeaderBase                                                //
 
 #include <unistd.h>
 
+#include <Bytes.h>
 #include <TClass.h>
 #include <TDataMember.h>
+#include <TList.h>
 #include <TMethodCall.h>
 
 #include "AliLog.h"
 #include "AliRawEventHeaderBase.h"
 
+#include <Riostream.h>
 
 ClassImp(AliRawEventHeaderBase)
 
+//______________________________________________________________________________
+AliRawEventHeaderBase::AliRawEventHeaderBase():
+fSize(0),
+fMagic(0),
+fHeadSize(0),
+fVersion(0),
+fExtendedDataSize(0),
+fExtendedAllocSize(0),
+fExtendedData(NULL),
+fIsSwapped(kFALSE)
+{
+  // Default constructor
+}
 
 //______________________________________________________________________________
 void *AliRawEventHeaderBase::HeaderBegin()
@@ -77,6 +95,14 @@ Int_t AliRawEventHeaderBase::HeaderSize() const
 }
 
 //______________________________________________________________________________
+UInt_t AliRawEventHeaderBase::SwapWord(UInt_t x) const
+{
+   // Swap the endianess of the integer value 'x'
+
+   return (((x & 0x000000ffU) << 24) | ((x & 0x0000ff00U) <<  8) |
+           ((x & 0x00ff0000U) >>  8) | ((x & 0xff000000U) >> 24));
+}
+
 void AliRawEventHeaderBase::Swap()
 {
    // Swap base header data.
@@ -86,15 +112,15 @@ void AliRawEventHeaderBase::Swap()
 
    if (IsSwapped()) {
       fIsSwapped    = kTRUE;
-      fSize         = net2host(fSize);
-      fMagic        = net2host(fMagic);
-      fHeadSize     = net2host(fHeadSize);
-      fVersion      = net2host(fVersion);
+      fSize         = SwapWord(fSize);
+      fMagic        = SwapWord(fMagic);
+      fHeadSize     = SwapWord(fHeadSize);
+      fVersion      = SwapWord(fVersion);
    }
 }
 
 //______________________________________________________________________________
-const char *AliRawEventHeaderBase::GetTypeName()
+const char *AliRawEventHeaderBase::GetTypeName() const
 {
    // Get event type as a string.
    // Will fail in case data header
@@ -129,6 +155,18 @@ const char *AliRawEventHeaderBase::GetTypeName()
       case kFormatError:
          return "EVENT_FORMAT_ERROR";
          break;
+      case kStartOfData:
+        return "START_OF_DATA";
+        break;
+      case kEndOfData:
+        return "END_OF_DATA";
+        break;
+      case kSystemSoftwareTriggerEvent:
+        return "SYSTEM_SOFTWARE_TRIGGER_EVENT";
+        break;
+      case kDetectorSoftwareTriggerEvent:
+        return "DETECTOR_SOFTWARE_TRIGGER_EVENT";
+        break;
       default:
         return "UNKNOWN EVENT TYPE NUMBER";
          break;
@@ -210,16 +248,25 @@ AliRawEventHeaderBase* AliRawEventHeaderBase::Create(char*& data)
   }
   else {
     if (extsize > 0) {
-      hdr->SetExtendedDataSize(extsize);
-      char *extdata = new char[extsize];
-      memset(extdata,0,extsize);
-      hdr->SetExtendedData(extdata);
+      hdr->AllocateExtendedData(extsize);
     }
   }
 
   return hdr;
 }
 
+void AliRawEventHeaderBase::SwapData(const void* inbuf, const void* outbuf, UInt_t size) {
+  // The method swaps the contents of the
+  // raw-data event header
+  UInt_t  intCount = size/sizeof(UInt_t);
+
+  UInt_t* buf = (UInt_t*) inbuf;    // temporary integers buffer
+  for (UInt_t i=0; i<intCount; i++, buf++) {
+      UInt_t value = SwapWord(*buf);
+      memcpy((UInt_t*)outbuf+i, &value, sizeof(UInt_t)); 
+  }
+}
+
 //______________________________________________________________________________
 Int_t AliRawEventHeaderBase::ReadHeader(char*& data)
 {
@@ -229,31 +276,68 @@ Int_t AliRawEventHeaderBase::ReadHeader(char*& data)
   Long_t start = (Long_t)data;
   // Swap header data if needed
   if (DataIsSwapped()) {
-    swab(data,HeaderBaseBegin(), HeaderBaseSize());
+    SwapData(data, HeaderBaseBegin(), HeaderBaseSize());
     data += HeaderBaseSize();
-    swab(data, HeaderBegin(), HeaderSize());
+    SwapData(data, HeaderBegin(), HeaderSize());
     data += HeaderSize();
-    if(GetExtendedDataSize()>0) {
-      swab(data, GetExtendedData(), GetExtendedDataSize());
-      data += GetExtendedDataSize();
-    }
   }
   else {
     memcpy(HeaderBaseBegin(), data, HeaderBaseSize());
     data += HeaderBaseSize();
     memcpy(HeaderBegin(), data, HeaderSize());
     data += HeaderSize();
-    if(GetExtendedDataSize()>0) {
-      memcpy(GetExtendedData(), data, GetExtendedDataSize());
-      data += GetExtendedDataSize();
-    }
   }
+  data += ReadExtendedData(data);
 
   return (Int_t)((Long_t)data - start);
 }
 
 //______________________________________________________________________________
-UInt_t AliRawEventHeaderBase::Get(const char *datamember)
+void AliRawEventHeaderBase::AllocateExtendedData(Int_t extsize)
+{
+  // Allocate the space for the header
+  // extended data
+  if (fExtendedData) delete [] fExtendedData;
+  
+  fExtendedDataSize = fExtendedAllocSize = extsize;
+  fExtendedData = new char[fExtendedAllocSize];
+  memset(fExtendedData,0,fExtendedAllocSize);
+}
+
+//______________________________________________________________________________
+Int_t AliRawEventHeaderBase::ReadExtendedData(char*& data)
+{
+  // Read extended header data
+  // Reallocates memory if the present
+  // buffer is insufficient
+  Int_t extsize = (Int_t)GetHeadSize() - (HeaderBaseSize() + HeaderSize());
+
+  if (extsize == 0) {
+    fExtendedDataSize = 0;
+    return 0;
+  }
+
+  if (extsize < 0) {
+    AliFatal(Form("Invalid header size (%d < %d +%d)!",
+                 GetHeadSize(),HeaderBaseSize(),HeaderSize()));
+    // try recovery... how?
+    return 0;
+  }
+
+  fExtendedDataSize = extsize;
+  if (fExtendedDataSize > fExtendedAllocSize)
+    AllocateExtendedData(fExtendedDataSize);
+
+  if (DataIsSwapped())
+    SwapData(data, fExtendedData, fExtendedDataSize);
+  else
+    memcpy(fExtendedData, data, fExtendedDataSize);
+
+  return fExtendedDataSize;
+}
+
+//______________________________________________________________________________
+UInt_t AliRawEventHeaderBase::Get(const char *datamember) const
 {
   // The method to get a data member from the header object
   // Except for the data members of the base class, all the
@@ -286,7 +370,7 @@ UInt_t AliRawEventHeaderBase::Get(const char *datamember)
 }
 
 //______________________________________________________________________________
-const UInt_t* AliRawEventHeaderBase::GetP(const char *datamember)
+const UInt_t* AliRawEventHeaderBase::GetP(const char *datamember) const
 {
   // The method to get a data member from the header object
   // Except for the data members of the base class, all the
@@ -317,3 +401,22 @@ const UInt_t* AliRawEventHeaderBase::GetP(const char *datamember)
 
   return (const UInt_t*)pointer;
 }
+
+//_____________________________________________________________________________
+void AliRawEventHeaderBase::Print( const Option_t* opt ) const
+{
+  // Dumps the event or sub-event
+  // header fields
+
+  cout << opt << "  Event size: " << GetEventSize() << endl;
+  cout << opt << "  Event header size: " << GetHeadSize() << endl;
+  cout << opt << "  Event header version: " << GetMajorVersion() << "." << GetMinorVersion() << endl;
+  cout << opt << "  Event type: " << Get("Type") << "( " << GetTypeName() << " )" << endl;
+  cout << opt << "  Run Number: " << Get("RunNb") << endl;
+  const UInt_t *id = GetP("Id");
+  cout << opt << "  Period: " << (((id)[0]>>4)&0x0fffffff) << " Orbit: " << ((((id)[0]<<20)&0xf00000)|(((id)[1]>>12)&0xfffff)) << " Bunch-crossing: " << ((id)[1]&0x00000fff) << endl;
+  cout << opt << "  Trigger pattern: " << GetP("TriggerPattern")[0] << "-" << GetP("TriggerPattern")[1] << endl;
+  cout << opt << "  Detector pattern: " << Get("DetectorPattern") << endl;
+  cout << opt << "  Type attribute: " << GetP("TypeAttribute")[0] << "-" << GetP("TypeAttribute")[1] << "-" << GetP("TypeAttribute")[2] << endl;
+  cout << opt << "  GDC: " << Get("GdcId") << " LDC: " << Get("LdcId") << endl;
+}