FlaggedElmPtr.h

Go to the documentation of this file.

#ifndef OPALX_FlaggedElmPtr_HH
#define OPALX_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 OPALX 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  // OPALX_FlaggedElmPtr_HH