DFTBuilder.h

Go to the documentation of this file.

#pragma once
 
#include <iostream>
#include <map>
#include <unordered_map>
 
#include "storm-dft/storage/DFTLayoutInfo.h"
#include "storm-dft/storage/elements/DFTElements.h"
#include "storm-dft/storage/elements/DFTRestriction.h"
 
#include "storm/exceptions/NotSupportedException.h"
#include "storm/utility/ConstantsComparator.h"
#include "storm/utility/macros.h"
 
namespace storm::storage {
// Forward declaration
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