FlaggedElmPtr.h

Go to the documentation of this file.

#ifndef CLASSIC_FlaggedElmPtr_HH
#define CLASSIC_FlaggedElmPtr_HH
 
// ------------------------------------------------------------------------
// $RCSfile: FlaggedElmPtr.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Class: FlaggedElmPtr
//
// ------------------------------------------------------------------------
// Class category: Beamlines
// ------------------------------------------------------------------------
//
// $Date: 2000/03/27 09:32:35 $
// $Author: fci $
//
// ------------------------------------------------------------------------
 
#include "Beamlines/ElmPtr.h"
 
 
// Class FlaggedElmPtr
// ------------------------------------------------------------------------
//  A FlaggedBeamline is built as a list of FlaggedElmPtr objects.
//  A FlaggedElmPtr contains two flags:
//  [dl]
//  [dt]reflected [dd]If true, this section of the line is reversed.
//  [dt]selected  [dd]Can be set to indicate a selected status for algorithms.
//  [/dl]
 
class FlaggedElmPtr: public ElmPtr {
 
public:
 
    //  Assign an element to this beamline position.
    explicit FlaggedElmPtr
    (const ElmPtr &, bool reflected = false, bool selected = false);
 
    FlaggedElmPtr(const FlaggedElmPtr &);
 
    FlaggedElmPtr();
    virtual ~FlaggedElmPtr();
 
    //  If any error occurs, this method throws an exception.
    virtual void accept(BeamlineVisitor &) const;
 
    //  Return the value set by the last call to [tt]setCounter()[/tt].
    //  See [b]FlaggedElmPtr::itsCounter[/b] for details.
    inline int getCounter() const;
 
    inline bool getReflectionFlag() const;
 
    inline bool getSelectionFlag() const;
 
    //  The value set is the entire responsibility of any algorithm using it.
    //  See [b]FlaggedElmPtr::itsCounter[/b] for details.
    inline void setCounter(int) const;
 
    inline void setReflectionFlag(bool flag) const;
 
    inline void setSelectionFlag(bool flag) const;
 
protected:
 
    //  This value can be set and interrogated by an algorithm.
    //  It is not used by the CLASSIC library.
    mutable int itsCounter;
 
    //  If true, the portion of the line pointed at by [b]itsElement[/b]
    //  is reflected, i.e. its elements occur in reverse order.
    mutable bool isReflected;
 
    //  This flag can be set to indicate a ``selected'' status for certain
    //  algorithms.
    mutable bool isSelected;
};
 
 
inline int FlaggedElmPtr::getCounter() const {
    return itsCounter;
}
 
 
inline bool FlaggedElmPtr::getReflectionFlag() const {
    return isReflected;
}
 
 
inline bool FlaggedElmPtr::getSelectionFlag() const {
    return isSelected;
}
 
 
inline void FlaggedElmPtr::setCounter(int count) const {
    itsCounter = count;
}
 
 
inline void FlaggedElmPtr::setReflectionFlag(bool flag) const {
    isReflected = flag;
}
 
 
inline void FlaggedElmPtr::setSelectionFlag(bool flag) const {
    isSelected = flag;
}
 
#endif // CLASSIC_FlaggedElmPtr_HH