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 c2e7e8e..709b1ce 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 5eafd82..b62fd18 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 637e30e..cb068e5 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 9461603..1c4b5a0 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 ce604c6..2e98e57 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 8d9bddd..e033494 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 31011bb..10fcadf 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 5fb0e77..ad03f0d 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 42bab28..9877ae0 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 5606956..9e75cbe 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 e1b8211..bd5ed64 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 8d24148..c601582 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 bdf5c7d..4f8529b 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 c6b2c60..4df793b 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 0381052..342ac48 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 28366bc..87a3942 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 1dbe26e..1d96e4d 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 c2cb208..60328a9 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 03ebe84..d0a6672 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 f16984e..bd1f6af 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 8dfac71..ee1a019 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 b237c6b..60302d7 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;