BeamlineVisitor.h

Go to the documentation of this file.

//
// Class BeamlineVisitor
//   The abstract class BeamlineVisitor is the base class for all visitors
//   (algorithms) that can iterator over a beam line representation.
//   A BeamlineVisitor applies itself to the representation via the
//   ``Visitor'' pattern, see
//   [p]
//   E. Gamma, R. Helm, R. Johnson, and J. Vlissides,
//   [BR]
//   Design Patterns, Elements of Reusable Object-Oriented Software.
//   [p]
//   By using only pure abstract classes as an interface between the
//   BeamlineVisitor and the beam line representation,
//   we decouple the former from the implementation details of the latter.
//   [p]
//   The interface is defined in such a way that a visitor cannot modify the
//   structure of a beam line, but it can assign special data like misalignments
//   or integrators without problems.
//
// Copyright (c) 200x - 2020, Paul Scherrer Institut, Villigen PSI, Switzerland
// All rights reserved
//
// This file is part of OPAL.
//
// OPAL is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// You should have received a copy of the GNU General Public License
// along with OPAL. If not, see <https://www.gnu.org/licenses/>.
//
#ifndef CLASSIC_BeamlineVisitor_HH
#define CLASSIC_BeamlineVisitor_HH
 
// Generic element classes interacting with a BeamlineVisitor.
class Component;
 
// Beam line structure classes.
class Beamline;
class FlaggedElmPtr;
 
// Specific element classes interacting with a BeamlineVisitor
class CCollimator;
class Corrector;
class Cyclotron;
class Degrader;
class Drift;
class FlexibleCollimator;
class Marker;
class Monitor;
class Multipole;
class MultipoleT;
class MultipoleTStraight;
class MultipoleTCurvedConstRadius;
class MultipoleTCurvedVarRadius;
class Offset;
class OutputPlane;
class Probe;
class RBend;
class RBend3D;
class RFCavity;
class Ring;
class SBend;
class SBend3D;
class ScalingFFAMagnet;
class Septum;
class Solenoid;
class Source;
class Stripper;
class TravelingWave;
#ifdef ENABLE_OPAL_FEL
class Undulator;
#endif
class Vacuum;
class VariableRFCavity;
class VariableRFCavityFringeField;
class VerticalFFAMagnet;
 
class BeamlineVisitor {
 
public:
 
    BeamlineVisitor();
    virtual ~BeamlineVisitor();

    virtual void execute() = 0;

    virtual void visitBeamline(const Beamline &) = 0;
    
    virtual void visitCCollimator(const CCollimator &) = 0;

    virtual void visitComponent(const Component &) = 0;

    virtual void visitCorrector(const Corrector &) = 0;

    virtual void visitCyclotron(const Cyclotron &) = 0;

    virtual void visitDegrader(const Degrader &) = 0;

    virtual void visitDrift(const Drift &) = 0;

    virtual void visitFlaggedElmPtr(const FlaggedElmPtr &) = 0;

    virtual void visitFlexibleCollimator(const FlexibleCollimator &) = 0;

    virtual void visitMarker(const Marker &) = 0;

    virtual void visitMonitor(const Monitor &) = 0;

    virtual void visitMultipole(const Multipole &) = 0;

    virtual void visitMultipoleT(const MultipoleT &) = 0;

    virtual void visitOffset(const Offset &) = 0;

    virtual void visitOutputPlane(const OutputPlane &) = 0;

    virtual void visitProbe(const Probe &) = 0;

    virtual void visitRBend(const RBend &) = 0;

    virtual void visitRBend3D(const RBend3D &);

    virtual void visitRFCavity(const RFCavity &) = 0;

    virtual void visitRing(const Ring &) = 0;

    virtual void visitSBend(const SBend &) = 0;

    virtual void visitSBend3D(const SBend3D &) = 0;

    virtual void visitScalingFFAMagnet(const ScalingFFAMagnet &) = 0;

    virtual void visitSeptum(const Septum &) = 0;

    virtual void visitSolenoid(const Solenoid &) = 0;

    virtual void visitSource(const Source &) = 0;

    virtual void visitStripper(const Stripper &) = 0;

    virtual void visitTravelingWave(const TravelingWave &) = 0;
 
#ifdef ENABLE_OPAL_FEL
    virtual void visitUndulator(const Undulator &) = 0;
#endif

    virtual void visitVacuum(const Vacuum &) = 0;
    
    virtual void visitVariableRFCavity(const VariableRFCavity &) = 0;

    virtual void visitVariableRFCavityFringeField
                                      (const VariableRFCavityFringeField &) = 0;

    virtual void visitVerticalFFAMagnet(const VerticalFFAMagnet &) = 0;
 
private:
 
    // Not implemented.
    BeamlineVisitor(const BeamlineVisitor &);
    void operator=(const BeamlineVisitor &);
};
 
inline
void BeamlineVisitor::visitRBend3D(const RBend3D &) {
 
}
 
#endif // CLASSIC_BeamlineVisitor_HH