Getting rid of zero length arrays in the block structure declarations since this...
authoraszostak <aszostak@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 30 Apr 2008 13:24:02 +0000 (13:24 +0000)
committeraszostak <aszostak@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 30 Apr 2008 13:24:02 +0000 (13:24 +0000)
The solution of checking the __SUNPRO_CC macro and specifying a one element array also will not work on those platforms because it introduces runtime bugs.
This has all been fixed by not using arrays at all inside the structures.

22 files changed:
HLT/MUON/AliHLTMUONChannelsBlockStruct.cxx
HLT/MUON/AliHLTMUONChannelsBlockStruct.h
HLT/MUON/AliHLTMUONClustersBlockStruct.cxx
HLT/MUON/AliHLTMUONClustersBlockStruct.h
HLT/MUON/AliHLTMUONDataBlockReader.h
HLT/MUON/AliHLTMUONMansoCandidatesBlockStruct.cxx
HLT/MUON/AliHLTMUONMansoCandidatesBlockStruct.h
HLT/MUON/AliHLTMUONMansoTracksBlockStruct.cxx
HLT/MUON/AliHLTMUONMansoTracksBlockStruct.h
HLT/MUON/AliHLTMUONPairsDecisionBlockStruct.cxx
HLT/MUON/AliHLTMUONPairsDecisionBlockStruct.h
HLT/MUON/AliHLTMUONRecHitsBlockStruct.cxx
HLT/MUON/AliHLTMUONRecHitsBlockStruct.h
HLT/MUON/AliHLTMUONSinglesDecisionBlockStruct.cxx
HLT/MUON/AliHLTMUONSinglesDecisionBlockStruct.h
HLT/MUON/AliHLTMUONTrigRecsDebugBlockStruct.cxx
HLT/MUON/AliHLTMUONTrigRecsDebugBlockStruct.h
HLT/MUON/AliHLTMUONTriggerChannelsBlockStruct.cxx
HLT/MUON/AliHLTMUONTriggerChannelsBlockStruct.h
HLT/MUON/AliHLTMUONTriggerRecordsBlockStruct.cxx
HLT/MUON/AliHLTMUONTriggerRecordsBlockStruct.h
HLT/MUON/AliHLTMUONUtils.cxx

index c2e7e8e824562a0b886b5d28a62fe35e534d047e..709b1ce8a66e5733b468a1f0efa86a53756c9a39 100644 (file)
@@ -46,10 +46,12 @@ std::ostream& operator << (
 {
        assert( AliHLTMUONUtils::IntegrityOk(block) );
 
+       const AliHLTMUONChannelStruct* channel =
+               reinterpret_cast<const AliHLTMUONChannelStruct*>(&block + 1);
        stream  << "{fHeader = " << block.fHeader << ", fChannel[] = [";
-       if (block.fHeader.fNrecords > 0) stream << block.fChannel[0];
+       if (block.fHeader.fNrecords > 0) stream << channel[0];
        for (AliHLTUInt32_t i = 1; i < block.fHeader.fNrecords; i++)
-               stream << ", " << block.fChannel[i];
+               stream << ", " << channel[i];
        stream << "]}";
        return stream;
 }
@@ -62,12 +64,17 @@ bool operator == (
 {
        assert( AliHLTMUONUtils::IntegrityOk(a) );
        assert( AliHLTMUONUtils::IntegrityOk(b) );
+       
+       const AliHLTMUONChannelStruct* channelA =
+               reinterpret_cast<const AliHLTMUONChannelStruct*>(&a + 1);
+       const AliHLTMUONChannelStruct* channelB =
+               reinterpret_cast<const AliHLTMUONChannelStruct*>(&b + 1);
 
        // First check if the blocks have the same header. If they do then check
        // if every channel is the same. In either case if we find a difference
        // return false.
        if (a.fHeader != b.fHeader) return false;
        for (AliHLTUInt32_t i = 0; i < a.fHeader.fNrecords; i++)
-               if (a.fChannel[i] != b.fChannel[i]) return false;
+               if (channelA[i] != channelB[i]) return false;
        return true;
 }
index 5eafd8262e556bff5b0d766a669f6a24b2950725..b62fd1818000fbf01d350451c25465c7dd326bf7 100644 (file)
@@ -47,11 +47,7 @@ struct AliHLTMUONChannelsBlockStruct
        AliHLTMUONDataBlockHeader fHeader; // Common data block header
 
        // Array of cluster channels/pads.
-#ifndef __SUNPRO_CC
-       AliHLTMUONChannelStruct fChannel[/*fHeader.fNrecords*/];
-#else
-       AliHLTMUONChannelStruct fChannel[1];
-#endif
+       //AliHLTMUONChannelStruct fChannel[/*fHeader.fNrecords*/];
 };
 
 } // extern "C"
index 637e30e1f716d04a5e1a9913de041fb0e4fc49ff..cb068e5b2f67d964f0778a7d947449f233cc9434 100644 (file)
@@ -45,10 +45,12 @@ std::ostream& operator << (
 {
        assert( AliHLTMUONUtils::IntegrityOk(block) );
 
+       const AliHLTMUONClusterStruct* cluster =
+               reinterpret_cast<const AliHLTMUONClusterStruct*>(&block + 1);
        stream  << "{fHeader = " << block.fHeader << ", fCluster[] = [";
-       if (block.fHeader.fNrecords > 0) stream << block.fCluster[0];
+       if (block.fHeader.fNrecords > 0) stream << cluster[0];
        for (AliHLTUInt32_t i = 1; i < block.fHeader.fNrecords; i++)
-               stream << ", " << block.fCluster[i];
+               stream << ", " << cluster[i];
        stream << "]}";
        return stream;
 }
@@ -61,12 +63,17 @@ bool operator == (
 {
        assert( AliHLTMUONUtils::IntegrityOk(a) );
        assert( AliHLTMUONUtils::IntegrityOk(b) );
+       
+       const AliHLTMUONClusterStruct* clusterA =
+               reinterpret_cast<const AliHLTMUONClusterStruct*>(&a + 1);
+       const AliHLTMUONClusterStruct* clusterB =
+               reinterpret_cast<const AliHLTMUONClusterStruct*>(&b + 1);
 
        // First check if the blocks have the same header. If they do then check
        // if every cluster is the same. In either case if we find a difference
        // return false.
        if (a.fHeader != b.fHeader) return false;
        for (AliHLTUInt32_t i = 0; i < a.fHeader.fNrecords; i++)
-               if (a.fCluster[i] != b.fCluster[i]) return false;
+               if (clusterA[i] != clusterB[i]) return false;
        return true;
 }
index 946160304dc6768b4f243295265b16179c89a81f..1c4b5a0858a717cfe7f254c99f74082d4b73a6d1 100644 (file)
@@ -49,11 +49,7 @@ struct AliHLTMUONClustersBlockStruct
        AliHLTMUONDataBlockHeader fHeader; // Common data block header
 
        // Array of clusters.
-#ifndef __SUNPRO_CC
-       AliHLTMUONClusterStruct fCluster[/*fHeader.fNrecords*/];
-#else
-       AliHLTMUONClusterStruct fCluster[1];
-#endif
+       //AliHLTMUONClusterStruct fCluster[/*fHeader.fNrecords*/];
 };
 
 } // extern "C"
index ce604c61c0c1a3137b3d18b7a0e731d845a846de..2e98e576fd6769d9f773edf19adb8aa1d942788c 100644 (file)
@@ -194,7 +194,7 @@ public:
         */
        AliHLTUInt32_t BytesUsed() const
        {
-               assert( sizeof(DataElementType) == fBlock->fHeader.fRecordWidth);
+               assert( sizeof(DataElementType) == fBlock->fHeader.fRecordWidth);
                return sizeof(DataBlockType) + Nentries() * sizeof(DataElementType);
        }
 
index 8d9bddd614f1886f33b4ab925a16b6d1617308a9..e0334948ddbd062b8fbb5f682b9c09a65f8c302c 100644 (file)
@@ -61,10 +61,12 @@ std::ostream& operator << (
 {
        assert( AliHLTMUONUtils::IntegrityOk(block) );
 
+       const AliHLTMUONMansoCandidateStruct* candidate =
+               reinterpret_cast<const AliHLTMUONMansoCandidateStruct*>(&block + 1);
        stream  << "{fHeader = " << block.fHeader << ", fCandidate[] = [";
-       if (block.fHeader.fNrecords > 0) stream << block.fCandidate[0];
+       if (block.fHeader.fNrecords > 0) stream << candidate[0];
        for (AliHLTUInt32_t i = 1; i < block.fHeader.fNrecords; i++)
-               stream << ", " << block.fCandidate[i];
+               stream << ", " << candidate[i];
        stream << "]}";
        return stream;
 }
@@ -77,12 +79,17 @@ bool operator == (
 {
        assert( AliHLTMUONUtils::IntegrityOk(a) );
        assert( AliHLTMUONUtils::IntegrityOk(b) );
+       
+       const AliHLTMUONMansoCandidateStruct* candidateA =
+               reinterpret_cast<const AliHLTMUONMansoCandidateStruct*>(&a + 1);
+       const AliHLTMUONMansoCandidateStruct* candidateB =
+               reinterpret_cast<const AliHLTMUONMansoCandidateStruct*>(&b + 1);
 
        // First check if the blocks have the same header. If they do then check
        // if every track candidate is the same. In either case if we find a
        // difference return false.
        if (a.fHeader != b.fHeader) return false;
        for (AliHLTUInt32_t i = 0; i < a.fHeader.fNrecords; i++)
-               if (a.fCandidate[i] != b.fCandidate[i]) return false;
+               if (candidateA[i] != candidateB[i]) return false;
        return true;
 }
index 31011bbe0af0d9aa05c18c462140df701c134c58..10fcadf1697c96814fe9959be733c8258842c09c 100644 (file)
@@ -57,11 +57,7 @@ struct AliHLTMUONMansoCandidatesBlockStruct
        AliHLTMUONDataBlockHeader fHeader; // Common data block header.
 
        // Array of Manso track candidates.
-#ifndef __SUNPRO_CC
-       AliHLTMUONMansoCandidateStruct fCandidate[/*fHeader.fNrecords*/];
-#else
-       AliHLTMUONMansoCandidateStruct fCandidate[1];
-#endif
+       //AliHLTMUONMansoCandidateStruct fCandidate[/*fHeader.fNrecords*/];
 };
 
 } // extern "C"
index 5fb0e770fa410e4b57d63dff9bf2fab33cd3737b..ad03f0df4247ffda3beeed0069664f92f2d0aba1 100644 (file)
@@ -55,10 +55,12 @@ std::ostream& operator << (
 {
        assert( AliHLTMUONUtils::IntegrityOk(block) );
 
+       const AliHLTMUONMansoTrackStruct* track =
+               reinterpret_cast<const AliHLTMUONMansoTrackStruct*>(&block + 1);
        stream  << "{fHeader = " << block.fHeader << ", fTrack[] = [";
-       if (block.fHeader.fNrecords > 0) stream << block.fTrack[0];
+       if (block.fHeader.fNrecords > 0) stream << track[0];
        for (AliHLTUInt32_t i = 1; i < block.fHeader.fNrecords; i++)
-               stream << ", " << block.fTrack[i];
+               stream << ", " << track[i];
        stream << "]}";
        return stream;
 }
@@ -72,11 +74,16 @@ bool operator == (
        assert( AliHLTMUONUtils::IntegrityOk(a) );
        assert( AliHLTMUONUtils::IntegrityOk(b) );
 
+       const AliHLTMUONMansoTrackStruct* trackA =
+               reinterpret_cast<const AliHLTMUONMansoTrackStruct*>(&a + 1);
+       const AliHLTMUONMansoTrackStruct* trackB =
+               reinterpret_cast<const AliHLTMUONMansoTrackStruct*>(&b + 1);
+       
        // First check if the blocks have the same header. If they do then check
        // if every track is the same. In either case if we find a difference
        // return false.
        if (a.fHeader != b.fHeader) return false;
        for (AliHLTUInt32_t i = 0; i < a.fHeader.fNrecords; i++)
-               if (a.fTrack[i] != b.fTrack[i]) return false;
+               if (trackA[i] != trackB[i]) return false;
        return true;
 }
index 42bab28273223e009cb3095051db180dc09bf7ca..9877ae02cb82668ecc23149765d01fd0f21516d7 100644 (file)
@@ -65,11 +65,7 @@ struct AliHLTMUONMansoTracksBlockStruct
        AliHLTMUONDataBlockHeader fHeader; // Common data block header.
 
        // Array of Manso tracks.
-#ifndef __SUNPRO_CC
-       AliHLTMUONMansoTrackStruct fTrack[/*fHeader.fNrecords*/];
-#else
-       AliHLTMUONMansoTrackStruct fTrack[1];
-#endif
+       //AliHLTMUONMansoTrackStruct fTrack[/*fHeader.fNrecords*/];
 };
 
 } // extern "C"
index 5606956a16e1cc6ce885fbfee78e0b27f4702852..9e75cbec984c9541ab53cb76d755e36f84b37181 100644 (file)
@@ -33,6 +33,9 @@ std::ostream& operator << (
        )
 {
        assert( AliHLTMUONUtils::IntegrityOk(block) );
+       
+       const AliHLTMUONPairDecisionStruct* decision =
+               reinterpret_cast<const AliHLTMUONPairDecisionStruct*>(&block + 1);
 
        stream  << "{fHeader = " << block.fHeader
                << ", fNunlikeAnyPt = " << block.fNunlikeAnyPt
@@ -45,9 +48,9 @@ std::ostream& operator << (
                << ", fNmassLow = " << block.fNmassLow
                << ", fNmassHigh = " << block.fNmassHigh
                << ", fDecision[] = [";
-       if (block.fHeader.fNrecords > 0) stream << block.fDecision[0];
+       if (block.fHeader.fNrecords > 0) stream << decision[0];
        for (AliHLTUInt32_t i = 1; i < block.fHeader.fNrecords; i++)
-               stream << ", " << block.fDecision[i];
+               stream << ", " << decision[i];
        stream << "]}";
        return stream;
 }
@@ -60,6 +63,11 @@ bool operator == (
 {
        assert( AliHLTMUONUtils::IntegrityOk(a) );
        assert( AliHLTMUONUtils::IntegrityOk(b) );
+       
+       const AliHLTMUONPairDecisionStruct* decisionA =
+               reinterpret_cast<const AliHLTMUONPairDecisionStruct*>(&a + 1);
+       const AliHLTMUONPairDecisionStruct* decisionB =
+               reinterpret_cast<const AliHLTMUONPairDecisionStruct*>(&b + 1);
 
        // First check if the blocks have the same header. If they do then
        // check if every track pair's decision is the same. In either case if
@@ -75,6 +83,6 @@ bool operator == (
        if (a.fNmassLow != b.fNmassLow) return false;
        if (a.fNmassHigh != b.fNmassHigh) return false;
        for (AliHLTUInt32_t i = 0; i < a.fHeader.fNrecords; i++)
-               if (a.fDecision[i] != b.fDecision[i]) return false;
+               if (decisionA[i] != decisionB[i]) return false;
        return true;
 }
index e1b8211361efa3a754fc9a0df873a3925097bb03..bd5ed646b1f52e9f3a90ec263a38a6b186d4fe65 100644 (file)
@@ -91,11 +91,7 @@ struct AliHLTMUONPairsDecisionBlockStruct
        AliHLTUInt32_t fNmassHigh;
 
        // Array of decisions for track pairs.
-#ifndef __SUNPRO_CC
-       AliHLTMUONPairDecisionStruct fDecision[/*fHeader.fNrecords*/];
-#else
-       AliHLTMUONPairDecisionStruct fDecision[1];
-#endif
+       //AliHLTMUONPairDecisionStruct fDecision[/*fHeader.fNrecords*/];
 };
 
 } // extern "C"
index 8d24148a050a1317c847fed44b77ec7595bb6279..c60158275de844514c20a948b2bd4c276915dfbe 100644 (file)
@@ -33,10 +33,12 @@ std::ostream& operator << (
 {
        assert( AliHLTMUONUtils::IntegrityOk(block) );
 
+       const AliHLTMUONRecHitStruct* hit =
+               reinterpret_cast<const AliHLTMUONRecHitStruct*>(&block + 1);
        stream  << "{fHeader = " << block.fHeader << ", fHit[] = [";
-       if (block.fHeader.fNrecords > 0) stream << block.fHit[0];
+       if (block.fHeader.fNrecords > 0) stream << hit[0];
        for (AliHLTUInt32_t i = 1; i < block.fHeader.fNrecords; i++)
-               stream << ", " << block.fHit[i];
+               stream << ", " << hit[i];
        stream << "]}";
        return stream;
 }
@@ -49,11 +51,16 @@ bool operator == (
 {
        assert( AliHLTMUONUtils::IntegrityOk(a) );
        assert( AliHLTMUONUtils::IntegrityOk(b) );
+       
+       const AliHLTMUONRecHitStruct* hitA =
+               reinterpret_cast<const AliHLTMUONRecHitStruct*>(&a + 1);
+       const AliHLTMUONRecHitStruct* hitB =
+               reinterpret_cast<const AliHLTMUONRecHitStruct*>(&b + 1);
 
        // First check if the blocks have the same header. If they do then check if
        // every hit is the same. In either case if we find a difference return false.
        if (a.fHeader != b.fHeader) return false;
        for (AliHLTUInt32_t i = 0; i < a.fHeader.fNrecords; i++)
-               if (a.fHit[i] != b.fHit[i]) return false;
+               if (hitA[i] != hitB[i]) return false;
        return true;
 }
index bdf5c7d537108f801f52daa0b2f4d493f2132785..4f8529b052a51d750d85f0a4cf80bdec42712fb2 100644 (file)
@@ -43,11 +43,7 @@ struct AliHLTMUONRecHitsBlockStruct
        AliHLTMUONDataBlockHeader fHeader; // Common data block header
 
        // Array of reconstructed hits.
-#ifndef __SUNPRO_CC
-       AliHLTMUONRecHitStruct fHit[/*fHeader.fNrecords*/];
-#else
-       AliHLTMUONRecHitStruct fHit[1];
-#endif
+       //AliHLTMUONRecHitStruct fHit[/*fHeader.fNrecords*/];
 };
 
 } // extern "C"
index c6b2c606aab279b060f06c647addfcc6984a79c8..4df793b3d7d0e0134ea4b52a4c81c43390f86d36 100644 (file)
@@ -34,13 +34,16 @@ std::ostream& operator << (
 {
        assert( AliHLTMUONUtils::IntegrityOk(block) );
 
+       const AliHLTMUONTrackDecisionStruct* decision =
+               reinterpret_cast<const AliHLTMUONTrackDecisionStruct*>(&block + 1);
+       
        stream  << "{fHeader = " << block.fHeader
                << ", fNlowPt = " << block.fNlowPt
                << ", fNhighPt = " << block.fNhighPt
                << ", fDecision[] = [";
-       if (block.fHeader.fNrecords > 0) stream << block.fDecision[0];
+       if (block.fHeader.fNrecords > 0) stream << decision[0];
        for (AliHLTUInt32_t i = 1; i < block.fHeader.fNrecords; i++)
-               stream << ", " << block.fDecision[i];
+               stream << ", " << decision[i];
        stream << "]}";
        return stream;
 }
@@ -54,6 +57,11 @@ bool operator == (
        assert( AliHLTMUONUtils::IntegrityOk(a) );
        assert( AliHLTMUONUtils::IntegrityOk(b) );
 
+       const AliHLTMUONTrackDecisionStruct* decisionA =
+               reinterpret_cast<const AliHLTMUONTrackDecisionStruct*>(&a + 1);
+       const AliHLTMUONTrackDecisionStruct* decisionB =
+               reinterpret_cast<const AliHLTMUONTrackDecisionStruct*>(&b + 1);
+       
        // First check if the blocks have the same header. If they do then
        // check if every track decision is the same. In either case if we find
        // a difference return false.
@@ -61,6 +69,6 @@ bool operator == (
        if (a.fNlowPt != b.fNlowPt) return false;
        if (a.fNhighPt != b.fNhighPt) return false;
        for (AliHLTUInt32_t i = 0; i < a.fHeader.fNrecords; i++)
-               if (a.fDecision[i] != b.fDecision[i]) return false;
+               if (decisionA[i] != decisionB[i]) return false;
        return true;
 }
index 03810524c17f1451927eefd2beea5fcf7109672c..342ac4851293bd99e758ad304cf0e7a4afbffcb1 100644 (file)
@@ -48,11 +48,7 @@ struct AliHLTMUONSinglesDecisionBlockStruct
        AliHLTUInt32_t fNhighPt; // Number of high pt triggers.
 
        // Array of decisions for individual tracks.
-#ifndef __SUNPRO_CC
-       AliHLTMUONTrackDecisionStruct fDecision[/*fHeader.fNrecords*/];
-#else
-       AliHLTMUONTrackDecisionStruct fDecision[1];
-#endif
+       //AliHLTMUONTrackDecisionStruct fDecision[/*fHeader.fNrecords*/];
 };
 
 } // extern "C"
index 28366bc25ec04df462f8680326d6bf3b39bd8230..87a3942ebb782f0c01b9d469d3ca72cdd06711cb 100644 (file)
@@ -50,10 +50,12 @@ std::ostream& operator << (
 {
        assert( AliHLTMUONUtils::IntegrityOk(block) );
 
+       const AliHLTMUONTrigRecInfoStruct* trigRecInfo =
+               reinterpret_cast<const AliHLTMUONTrigRecInfoStruct*>(&block + 1);
        stream  << "{fHeader = " << block.fHeader << ", fTrigRecInfo[] = [";
-       if (block.fHeader.fNrecords > 0) stream << block.fTrigRecInfo[0];
+       if (block.fHeader.fNrecords > 0) stream << trigRecInfo[0];
        for (AliHLTUInt32_t i = 1; i < block.fHeader.fNrecords; i++)
-               stream << ", " << block.fTrigRecInfo[i];
+               stream << ", " << trigRecInfo[i];
        stream << "]}";
        return stream;
 }
@@ -67,11 +69,16 @@ bool operator == (
        assert( AliHLTMUONUtils::IntegrityOk(a) );
        assert( AliHLTMUONUtils::IntegrityOk(b) );
 
+       const AliHLTMUONTrigRecInfoStruct* trigRecInfoA =
+               reinterpret_cast<const AliHLTMUONTrigRecInfoStruct*>(&a + 1);
+       const AliHLTMUONTrigRecInfoStruct* trigRecInfoB =
+               reinterpret_cast<const AliHLTMUONTrigRecInfoStruct*>(&b + 1);
+       
        // First check if the blocks have the same header. If they do then check
        // if all debug information is the same. In either case if we find a
        // difference return false.
        if (a.fHeader != b.fHeader) return false;
        for (AliHLTUInt32_t i = 0; i < a.fHeader.fNrecords; i++)
-               if (a.fTrigRecInfo[i] != b.fTrigRecInfo[i]) return false;
+               if (trigRecInfoA[i] != trigRecInfoB[i]) return false;
        return true;
 }
index 1dbe26e325648003d1b9cd46f87702bfd34da860..1d96e4dee3948b2f1a896729faf1a786aee0974d 100644 (file)
@@ -49,11 +49,7 @@ struct AliHLTMUONTrigRecsDebugBlockStruct
        AliHLTMUONDataBlockHeader fHeader; // Common data block header
 
        // Array of trigger records.
-#ifndef __SUNPRO_CC
-       AliHLTMUONTrigRecInfoStruct fTrigRecInfo[/*fHeader.fNrecords*/];
-#else
-       AliHLTMUONTrigRecInfoStruct fTrigRecInfo[1];
-#endif
+       //AliHLTMUONTrigRecInfoStruct fTrigRecInfo[/*fHeader.fNrecords*/];
 };
 
 } // extern "C"
index c2cb208e4947bfd809e3fb32ebadf5cb7f76fa57..60328a9f320b793b4b23ae1aace0c88d0a6137cb 100644 (file)
@@ -46,10 +46,12 @@ std::ostream& operator << (
 {
        assert( AliHLTMUONUtils::IntegrityOk(block) );
 
+       const AliHLTMUONTriggerChannelStruct* channel =
+               reinterpret_cast<const AliHLTMUONTriggerChannelStruct*>(&block + 1);
        stream  << "{fHeader = " << block.fHeader << ", fChannel[] = [";
-       if (block.fHeader.fNrecords > 0) stream << block.fChannel[0];
+       if (block.fHeader.fNrecords > 0) stream << channel[0];
        for (AliHLTUInt32_t i = 1; i < block.fHeader.fNrecords; i++)
-               stream << ", " << block.fChannel[i];
+               stream << ", " << channel[i];
        stream << "]}";
        return stream;
 }
@@ -63,11 +65,16 @@ bool operator == (
        assert( AliHLTMUONUtils::IntegrityOk(a) );
        assert( AliHLTMUONUtils::IntegrityOk(b) );
 
+       const AliHLTMUONTriggerChannelStruct* channelA =
+               reinterpret_cast<const AliHLTMUONTriggerChannelStruct*>(&a + 1);
+       const AliHLTMUONTriggerChannelStruct* channelB =
+               reinterpret_cast<const AliHLTMUONTriggerChannelStruct*>(&b + 1);
+       
        // First check if the blocks have the same header. If they do then check
        // if every channel is the same. In either case if we find a difference
        // return false.
        if (a.fHeader != b.fHeader) return false;
        for (AliHLTUInt32_t i = 0; i < a.fHeader.fNrecords; i++)
-               if (a.fChannel[i] != b.fChannel[i]) return false;
+               if (channelA[i] != channelB[i]) return false;
        return true;
 }
index 03ebe84755a8a479af05fe96a22cfc9ad0374835..d0a66729bc58e320943af40bc41d434459fe8116 100644 (file)
@@ -30,10 +30,10 @@ struct AliHLTMUONTriggerChannelStruct
 {
        AliHLTInt32_t fTrigRecId; // ID corresponding to the trigger records this
                                  // channel is part of. -1 == invalid.
-                                 
+       
        AliHLTUInt16_t fChamber; // The chamber this hit corresponds to.
                                 // In the range [11..14].
-                                
+       
        AliHLTUInt16_t fSignal;      // ADC value of signal.
        AliHLTUInt32_t fRawDataWord; // The raw data word as found in the DDL stream.
 };
@@ -47,11 +47,7 @@ struct AliHLTMUONTriggerChannelsBlockStruct
        AliHLTMUONDataBlockHeader fHeader; // Common data block header
 
        // Array of trigger channels/strips.
-#ifndef __SUNPRO_CC
-       AliHLTMUONTriggerChannelStruct fChannel[/*fHeader.fNrecords*/];
-#else
-       AliHLTMUONTriggerChannelStruct fChannel[1];
-#endif
+       //AliHLTMUONTriggerChannelStruct fChannel[/*fHeader.fNrecords*/];
 };
 
 } // extern "C"
index f16984e3a896e12f01d103445bbe9405ba94fa37..bd1f6af660504dcbb74ac4a129ec8d974de8c5a2 100644 (file)
@@ -53,10 +53,12 @@ std::ostream& operator << (
 {
        assert( AliHLTMUONUtils::IntegrityOk(block) );
 
+       const AliHLTMUONTriggerRecordStruct* triggerRecord =
+               reinterpret_cast<const AliHLTMUONTriggerRecordStruct*>(&block + 1);
        stream  << "{fHeader = " << block.fHeader << ", fTriggerRecord[] = [";
-       if (block.fHeader.fNrecords > 0) stream << block.fTriggerRecord[0];
+       if (block.fHeader.fNrecords > 0) stream << triggerRecord[0];
        for (AliHLTUInt32_t i = 1; i < block.fHeader.fNrecords; i++)
-               stream << ", " << block.fTriggerRecord[i];
+               stream << ", " << triggerRecord[i];
        stream << "]}";
        return stream;
 }
@@ -70,11 +72,15 @@ bool operator == (
        assert( AliHLTMUONUtils::IntegrityOk(a) );
        assert( AliHLTMUONUtils::IntegrityOk(b) );
 
+       const AliHLTMUONTriggerRecordStruct* triggerRecordA =
+               reinterpret_cast<const AliHLTMUONTriggerRecordStruct*>(&a + 1);
+       const AliHLTMUONTriggerRecordStruct* triggerRecordB =
+               reinterpret_cast<const AliHLTMUONTriggerRecordStruct*>(&b + 1);
        // First check if the blocks have the same header. If they do then check
        // if every trigger record is the same. In either case if we find a
        // difference return false.
        if (a.fHeader != b.fHeader) return false;
        for (AliHLTUInt32_t i = 0; i < a.fHeader.fNrecords; i++)
-               if (a.fTriggerRecord[i] != b.fTriggerRecord[i]) return false;
+               if (triggerRecordA[i] != triggerRecordB[i]) return false;
        return true;
 }
index 8dfac71453695360631269e6ee71f38e62096cdb..ee1a019c3033c842f0757faba8788b2aff645ac6 100644 (file)
@@ -58,11 +58,7 @@ struct AliHLTMUONTriggerRecordsBlockStruct
        AliHLTMUONDataBlockHeader fHeader; // Common data block header
 
        // Array of trigger records.
-#ifndef __SUNPRO_CC
-       AliHLTMUONTriggerRecordStruct fTriggerRecord[/*fHeader.fNrecords*/];
-#else
-       AliHLTMUONTriggerRecordStruct fTriggerRecord[1];
-#endif
+       //AliHLTMUONTriggerRecordStruct fTriggerRecord[/*fHeader.fNrecords*/];
 };
 
 } // extern "C"
index b237c6b346e783238c3cd8b4087182d5c14c23db..60302d71801179ec33287c98fadd4d05309e2261 100644 (file)
@@ -584,14 +584,17 @@ bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONTriggerRecordsBlockStruct& blo
        ///
        
        if (not HeaderOk(block)) return false;
+       
+       const AliHLTMUONTriggerRecordStruct* triggerRecord =
+               reinterpret_cast<const AliHLTMUONTriggerRecordStruct*>(&block + 1);
 
        // Check if any ID is duplicated.
        for (AliHLTUInt32_t i = 0; i < block.fHeader.fNrecords; i++)
        {
-               AliHLTInt32_t id = block.fTriggerRecord[i].fId;
+               AliHLTInt32_t id = triggerRecord[i].fId;
                for (AliHLTUInt32_t j = i+1; i < block.fHeader.fNrecords; j++)
                {
-                       if (id == block.fTriggerRecord[j].fId)
+                       if (id == triggerRecord[j].fId)
                                return false;
                }
        }
@@ -599,7 +602,7 @@ bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONTriggerRecordsBlockStruct& blo
        // Check integrity of individual trigger records.
        for (AliHLTUInt32_t i = 0; i < block.fHeader.fNrecords; i++)
        {
-               if (not IntegrityOk(block.fTriggerRecord[i])) return false;
+               if (not IntegrityOk(triggerRecord[i])) return false;
        }
 
        return true;
@@ -655,13 +658,16 @@ bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONClustersBlockStruct& block)
        
        if (not HeaderOk(block)) return false;
 
+       const AliHLTMUONClusterStruct* cluster =
+               reinterpret_cast<const AliHLTMUONClusterStruct*>(&block + 1);
+       
        // Check if any ID is duplicated.
        for (AliHLTUInt32_t i = 0; i < block.fHeader.fNrecords; i++)
        {
-               AliHLTInt32_t id = block.fCluster[i].fId;
+               AliHLTInt32_t id = cluster[i].fId;
                for (AliHLTUInt32_t j = i+1; i < block.fHeader.fNrecords; j++)
                {
-                       if (id == block.fCluster[j].fId)
+                       if (id == cluster[j].fId)
                                return false;
                }
        }
@@ -721,13 +727,16 @@ bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONMansoTracksBlockStruct& block)
        
        if (not HeaderOk(block)) return false;
 
+       const AliHLTMUONMansoTrackStruct* track =
+               reinterpret_cast<const AliHLTMUONMansoTrackStruct*>(&block + 1);
+       
        // Check if any ID is duplicated.
        for (AliHLTUInt32_t i = 0; i < block.fHeader.fNrecords; i++)
        {
-               AliHLTInt32_t id = block.fTrack[i].fId;
+               AliHLTInt32_t id = track[i].fId;
                for (AliHLTUInt32_t j = i+1; i < block.fHeader.fNrecords; j++)
                {
-                       if (id == block.fTrack[j].fId)
+                       if (id == track[j].fId)
                                return false;
                }
        }
@@ -735,7 +744,7 @@ bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONMansoTracksBlockStruct& block)
        // Check that the tracks have integrity.
        for (AliHLTUInt32_t i = 0; i < block.fHeader.fNrecords; i++)
        {
-               if (not IntegrityOk(block.fTrack[i])) return false;
+               if (not IntegrityOk(track[i])) return false;
        }
 
        return true;
@@ -752,10 +761,13 @@ bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONMansoCandidatesBlockStruct& bl
        
        if (not HeaderOk(block)) return false;
 
+       const AliHLTMUONMansoCandidateStruct* candidate =
+               reinterpret_cast<const AliHLTMUONMansoCandidateStruct*>(&block + 1);
+       
        // Check that the tracks have integrity.
        for (AliHLTUInt32_t i = 0; i < block.fHeader.fNrecords; i++)
        {
-               if (not IntegrityOk(block.fCandidate[i].fTrack)) return false;
+               if (not IntegrityOk(candidate[i].fTrack)) return false;
        }
        
        return true;
@@ -786,11 +798,14 @@ bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONSinglesDecisionBlockStruct& bl
        ///
        
        if (not HeaderOk(block)) return false;
+       
+       const AliHLTMUONTrackDecisionStruct* decision =
+               reinterpret_cast<const AliHLTMUONTrackDecisionStruct*>(&block + 1);
 
        // Check that the trigger bits for each track have integrity.
        for (AliHLTUInt32_t i = 0; i < block.fHeader.fNrecords; i++)
        {
-               if (not IntegrityOk(block.fDecision[i])) return false;
+               if (not IntegrityOk(decision[i])) return false;
        }
        
        return true;
@@ -835,10 +850,13 @@ bool AliHLTMUONUtils::IntegrityOk(const AliHLTMUONPairsDecisionBlockStruct& bloc
        
        if (not HeaderOk(block)) return false;
 
+       const AliHLTMUONPairDecisionStruct* decision =
+               reinterpret_cast<const AliHLTMUONPairDecisionStruct*>(&block + 1);
+       
        // Check that the trigger bits for each track pair have integrity.
        for (AliHLTUInt32_t i = 0; i < block.fHeader.fNrecords; i++)
        {
-               if (not IntegrityOk(block.fDecision[i])) return false;
+               if (not IntegrityOk(decision[i])) return false;
        }
        
        return true;