DFTBuilder.h

Go to the documentation of this file.

#pragma once
 
#include <map>
#include <unordered_map>
 
#include "storm-dft/storage/DFTLayoutInfo.h"
#include "storm-dft/storage/elements/DFTElements.h"
 
// Forward declaration
namespace storm::storage {
template<typename ValueType>
class DFT;
}  // namespace storm::storage
 
namespace storm::dft {
namespace builder {
 
template<typename ValueType>
class DFTBuilder {
    using DFTElementPointer = std::shared_ptr<storm::dft::storage::elements::DFTElement<ValueType>>;
    using DFTElementCPointer = std::shared_ptr<storm::dft::storage::elements::DFTElement<ValueType> const>;
    using DFTElementVector = std::vector<DFTElementPointer>;
    using DFTBEPointer = std::shared_ptr<storm::dft::storage::elements::DFTBE<ValueType>>;
    using DFTChildrenCPointer = std::shared_ptr<storm::dft::storage::elements::DFTChildren<ValueType> const>;
    using DFTGatePointer = std::shared_ptr<storm::dft::storage::elements::DFTGate<ValueType>>;
    using DFTDependencyPointer = std::shared_ptr<storm::dft::storage::elements::DFTDependency<ValueType>>;
    using DFTRestrictionPointer = std::shared_ptr<storm::dft::storage::elements::DFTRestriction<ValueType>>;
 
   private:
    std::size_t mNextId;
    std::string mTopLevelName;
    std::unordered_map<std::string, DFTElementPointer> mElements;
    std::unordered_map<DFTElementPointer, std::vector<std::string>> mChildNames;
    std::unordered_map<DFTRestrictionPointer, std::vector<std::string>> mRestrictionChildNames;
    std::unordered_map<DFTDependencyPointer, std::vector<std::string>> mDependencyChildNames;
    std::unordered_map<std::string, storm::dft::storage::DFTLayoutInfo> mLayoutInfo;
 
   public:
    DFTBuilder();

    void addBasicElementConst(std::string const& name, bool failed);

    void addBasicElementProbability(std::string const& name, ValueType probability, ValueType dormancyFactor);

    void addBasicElementExponential(std::string const& name, ValueType rate, ValueType dormancyFactor, bool transient = false);

    void addBasicElementErlang(std::string const& name, ValueType rate, unsigned phases, ValueType dormancyFactor);

    void addBasicElementWeibull(std::string const& name, ValueType shape, ValueType rate);

    void addBasicElementLogNormal(std::string const& name, ValueType mean, ValueType standardDeviation);

    void addBasicElementSamples(std::string const& name, std::map<ValueType, ValueType> const& activeSamples);

    void addAndGate(std::string const& name, std::vector<std::string> const& children);

    void addOrGate(std::string const& name, std::vector<std::string> const& children);

    void addVotingGate(std::string const& name, unsigned threshold, std::vector<std::string> const& children);

    void addPandGate(std::string const& name, std::vector<std::string> const& children, bool inclusive = true);

    void addPorGate(std::string const& name, std::vector<std::string> const& children, bool inclusive = true);

    void addSpareGate(std::string const& name, std::vector<std::string> const& children);

    void addSequenceEnforcer(std::string const& name, std::vector<std::string> const& children);

    void addMutex(std::string const& name, std::vector<std::string> const& children);

    void addPdep(std::string const& name, std::vector<std::string> const& children, ValueType probability);

    void setTopLevel(std::string const& tle);

    void addLayoutInfo(std::string const& name, double x, double y);

    storm::dft::storage::DFT<ValueType> build();

    void cloneElement(DFTElementCPointer element);

    void cloneElementWithNewChildren(DFTChildrenCPointer elemWithChildren, std::vector<std::string> const& children);
 
   private:
    void addElement(DFTElementPointer element);

    void addGate(DFTGatePointer gate, std::vector<std::string> const& children);

    void addDependency(DFTDependencyPointer dependency, std::vector<std::string> const& children);

    void addRestriction(DFTRestrictionPointer restriction, std::vector<std::string> const& children);

    bool nameInUse(std::string const& name) const;

    bool isValidProbability(ValueType value) const;

    enum class topoSortColour { WHITE, BLACK, GREY };

    void topologicalVisit(DFTElementPointer const& element,
                          std::map<DFTElementPointer, topoSortColour, storm::dft::storage::OrderElementsById<ValueType>>& visited,
                          DFTElementVector& visitedElements);

    DFTElementVector sortTopological();

    size_t computeRank(DFTElementPointer const& elem);
};
 
}  // namespace builder
}  // namespace storm::dft