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