Sequence.h

Go to the documentation of this file.

//
// Class Sequence
//   The SEQUENCE definition.
//   A Sequence contains a CLASSIC TBeamline<SequenceMember> which represents
//   the sequence of elements in the line and their positions.  The sequence
//   definition is parsed in collaboration with a SequenceParser.
//
// 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 OPAL_Sequence_HH
#define OPAL_Sequence_HH
 
#include "AbstractObjects/BeamSequence.h"
#include "AbsBeamline/ElementBase.h"
#include "Beamlines/TBeamline.h"
#include "Lines/SequenceMember.h"
#include "MemoryManagement/Pointer.h"
#include <list>
 
class TokenStream;
 
class Sequence: public BeamSequence {
 
    friend class Edit;
    friend class SequenceParser;
    friend class SequenceTemplate;
 
public:
 
    typedef TBeamline<SequenceMember> TLine;
 
    Sequence();
 
    virtual ~Sequence();
 
    // The new object is an empty sequence, it will be filled in by the parser.
    virtual Sequence *clone(const std::string &name);
 
    virtual Sequence *copy(const std::string &name);
 
    virtual double getLength() const;
 
    virtual double getEntrance(ReferenceType) const;
 
    virtual double getExit(ReferenceType) const;
 
    //  "ENTRY", "CENTRE", or "EXIT".
    ReferenceType getReference() const;
 
    //  Arguments:
    //  [ol]
    //  [li] Name to be given to the template.
    //  [li] Token stream to be read for the sequence line.
    //  [li] Statement to be read for the arguments.
    //  [/ol]
    virtual Object *makeTemplate(const std::string &, TokenStream &, Statement &);
 
    virtual void parse(Statement &);
 
    virtual void print(std::ostream &) const;
 
    virtual void replace(Object *oldObject, Object *newObject);
 
    //  Recompute drift lengths.
    virtual void update();
 
    //  The result it the ideal line.
    virtual TLine *fetchLine() const;
 
    //  Assign to the underlying ideal line and re-insert the drifts.
    void storeLine(TLine &line);
 
private:
 
    // Not implemented.
    Sequence(const Sequence &);
    void operator=(const Sequence &);
 
    // Clone constructor.
    Sequence(const std::string &name, Sequence *parent);
 
    // Add the top-level begin and end markers.
    void addEndMarkers(TLine &line) const;
 
    // Compute drift length for a generated drift.
    double findDriftLength(TLine::iterator drift) const;
 
    // Find named position in sequence line.
    TLine::iterator findNamedPosition(TLine &, const std::string &) const;
 
    // Insert the top-level drift spaces.
    void insertDrifts(TLine &line);
 
    //  Recompute drift lengths for a given sequence or sub-sequence.
    static void updateList(Sequence *, TLine *);
 
    // The reference code.
    ReferenceType itsCode;
 
    // The reference point.
    std::string itsRefPoint;
};
 
#endif // OPAL_Sequence_HH