Coding conventions (A.Szostak)

[u/mrichter/AliRoot.git] / HLT / MUON / src / AliRoot / MicrodHLT.hpp

diff --git a/HLT/MUON/src/AliRoot/MicrodHLT.hpp b/HLT/MUON/src/AliRoot/MicrodHLT.hpp
index 857de67542f941cfb8181939f7c461fcd00b1f44..8b98a325f482e7fd6d694160ba6c4fb3a0aca040 100644 (file)
--- a/HLT/MUON/src/AliRoot/MicrodHLT.hpp
+++ b/HLT/MUON/src/AliRoot/MicrodHLT.hpp
@@ -5,8 +5,8 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_ALIROOT_MICRODHLT_HPP
-#define dHLT_ALIROOT_MICRODHLT_HPP
+#ifndef ALIHLTMUONMICRODHLT_H
+#define ALIHLTMUONMICRODHLT_H
 
 #include "TROOT.h"
 #include "TObject.h"
@@ -16,64 +16,65 @@
 #include "AliRoot/TrackSink.hpp"
 #include "AliRoot/TrackerCallback.hpp"
 
-namespace AliMUONHLT
-{
-
 
-class ClusterFinder;
-class ClusterFinderInterface;
-class Tracker;
-class TrackerInterface;
+class AliHLTMUONDummyClusterFinder;
+class AliHLTMUONClusterFinderInterface;
+class AliHLTMUONDummyTracker;
+class AliHLTMUONTrackerInterface;
 
 
 /* Routines for getting dHLT version information.
 */
-TString Version();
-UInt_t MajorVersion();
-UInt_t MinorVersion();
-UInt_t BuildNumber();
+TString AliHLTMUONVersion();
+UInt_t AliHLTMUONMajorVersion();
+UInt_t AliHLTMUONMinorVersion();
+UInt_t AliHLTMUONBuildNumber();
 
 
-class MicrodHLT : public TObject
+class AliHLTMUONMicrodHLT : public TObject
 {
 public:
 
-       MicrodHLT();
-       virtual ~MicrodHLT();
+       AliHLTMUONMicrodHLT();
+       virtual ~AliHLTMUONMicrodHLT();
 
        /* Get/Set methods for the trigger data source.
           Note: The source object must be cleaned up by the caller.
         */
-       void SetTriggerSource(const TriggerSource* source);
-       const TriggerSource* GetTriggerSource() const { return fTriggerSource; };
+       void SetTriggerSource(const AliHLTMUONTriggerSource* source);
+       const AliHLTMUONTriggerSource* GetTriggerSource() const { return fTriggerSource; };
        
        /* Get/Set methods for the cluster data source.
           Note: The source object must be cleaned up by the caller.
         */
-       void SetClusterSource(const ClusterSource* source);
-       const ClusterSource* GetClusterSource() const { return fClusterSource; };
+       void SetClusterSource(const AliHLTMUONClusterSource* source);
+       const AliHLTMUONClusterSource* GetClusterSource() const { return fClusterSource; };
        
        /* Get/Set methods for the track data sink (output target).
           Note: The output object must be cleaned up by the caller.
         */
-       void SetTrackSink(TrackSink* sink)    { fTrackSink = sink; };
-       const TrackSink* GetTrackSink() const { return fTrackSink; };
+       void SetTrackSink(AliHLTMUONTrackSink* sink)    { fTrackSink = sink; };
+       const AliHLTMUONTrackSink* GetTrackSink() const { return fTrackSink; };
        
        /* Get/Set methods for the cluster finder interface.
           Note: The cluster finder object must be cleaned up by the caller.
           This field is optional. Use it if a custom cluster finder should be used.
         */
-       void SetClusterFinder(ClusterFinderInterface* clusterfinder) { fClusterFinder = clusterfinder; };
-       const ClusterFinderInterface* GetClusterFinder() const { return fClusterFinder; };
-       void SetClusterFinder(ClusterFinder* clusterfinder);
+       void SetClusterFinder(AliHLTMUONClusterFinderInterface* clusterfinder)
+       {
+               fClusterFinder = clusterfinder;
+       }
+
+       const AliHLTMUONClusterFinderInterface* GetClusterFinder() const { return fClusterFinder; };
+       void SetClusterFinder(AliHLTMUONDummyClusterFinder* clusterfinder);
        
        /* Get/Set methods for the tracker interface.
           Note: The tracker object must be cleaned up by the caller.
           This field is optional. Use it if a custom tracker should be used.
         */
-       void SetTracker(TrackerInterface* tracker) { fTracker = tracker; };
-       const TrackerInterface* GetTracker() const { return fTracker; };
-       void SetTracker(Tracker* tracker);
+       void SetTracker(AliHLTMUONTrackerInterface* tracker) { fTracker = tracker; };
+       const AliHLTMUONTrackerInterface* GetTracker() const { return fTracker; };
+       void SetTracker(AliHLTMUONDummyTracker* tracker);
        
        /* The entry point routine for the dHLT algorithm in the micro format.
           To run the dHLT set the input and output objects with the set methods
@@ -87,16 +88,14 @@ public:
        
 private:
 
-       TriggerSource* fTriggerSource;           //! Trigger record input source.
-       ClusterSource* fClusterSource;           //! Cluster point input source.
-       TrackSink* fTrackSink;                   //! Track output sink.
-       ClusterFinderInterface* fClusterFinder;  //! Interface to a custom cluster finder.
-       TrackerInterface* fTracker;              //! Interface to a custom tracker.
+       AliHLTMUONTriggerSource* fTriggerSource;           //! Trigger record input source.
+       AliHLTMUONClusterSource* fClusterSource;           //! Cluster point input source.
+       AliHLTMUONTrackSink* fTrackSink;                   //! Track output sink.
+       AliHLTMUONClusterFinderInterface* fClusterFinder;  //! Interface to a custom cluster finder.
+       AliHLTMUONTrackerInterface* fTracker;              //! Interface to a custom tracker.
 
-       ClassDef(MicrodHLT, 0);  // A very minimal implementation of the dHLT algorithm.
+       ClassDef(AliHLTMUONMicrodHLT, 0);  // A very minimal implementation of the dHLT algorithm.
 };
 
 
-} // AliMUONHLT
-
-#endif // dHLT_ALIROOT_MICRODHLT_HPP
+#endif // ALIHLTMUONMICRODHLT_H