#pragma once #include #include "src/storage/jani/Action.h" #include "src/storage/jani/ModelType.h" #include "src/storage/jani/Automaton.h" #include "src/storage/jani/Constant.h" #include "src/storage/jani/Composition.h" namespace storm { namespace expressions { class ExpressionManager; } namespace jani { class Exporter; class Model { public: friend class Exporter; /*! * Creates an uninitialized model. */ Model(); /*! * Creates an empty model with the given type. */ Model(std::string const& name, ModelType const& modelType, uint64_t version = 1, boost::optional> const& expressionManager = boost::none); /*! * Retrieves the JANI-version of the model. */ uint64_t getJaniVersion() const; /*! * Retrieves the type of the model. */ ModelType const& getModelType() const; /*! * Retrievest the name of the model. */ std::string const& getName() const; /** * Checks whether the model has an action with the given name. * * @param name The name to look for. */ bool hasAction(std::string const& name) const; /** * Get the index of the action * @param the name of the model * @return the index of the (unique) action with the given name, undefined if no such action is present. */ uint64_t getActionIndex(std::string const& name) const; /** * Adds an action to the model. * * @return the index for this action. */ uint64_t addAction(Action const& action); /*! * Retrieves the action with the given index. */ Action const& getAction(uint64_t index) const; /*! * Retrieves the actions of the model. */ std::vector const& getActions() const; /*! * Adds the given constant to the model. */ uint64_t addConstant(Constant const& constant); /*! * Retrieves whether the model has a constant with the given name. */ bool hasConstant(std::string const& name) const; /*! * Retrieves the constants of the model. */ std::vector const& getConstants() const; /*! * Retrieves the constants of the model. */ std::vector& getConstants(); /*! * Retrieves the constant with the given name (if any). */ Constant const& getConstant(std::string const& name) const; /*! * Adds the given boolean variable to this model. */ void addBooleanVariable(BooleanVariable const& variable); /*! * Adds the given bounded integer variable to this model. */ void addBoundedIntegerVariable(BoundedIntegerVariable const& variable); /*! * Adds the given unbounded integer variable to this model. */ void addUnboundedIntegerVariable(UnboundedIntegerVariable const& variable); /*! * Retrieves the variables of this automaton. */ VariableSet& getGlobalVariables(); /*! * Retrieves the variables of this automaton. */ VariableSet const& getGlobalVariables() const; /*! * Retrieves the manager responsible for the expressions in the JANI model. */ storm::expressions::ExpressionManager& getExpressionManager(); /*! * Retrieves the manager responsible for the expressions in the JANI model. */ storm::expressions::ExpressionManager const& getExpressionManager() const; /*! * Adds the given automaton to the automata of this model. */ uint64_t addAutomaton(Automaton const& automaton); /*! * Retrieves the automata of the model. */ std::vector& getAutomata(); /*! * Retrieves the automata of the model. */ std::vector const& getAutomata() const; /*! * Retrieves the automaton with the given name. */ Automaton& getAutomaton(std::string const& name); /*! * Retrieves the automaton with the given name. */ Automaton const& getAutomaton(std::string const& name) const; /*! * Retrieves the number of automata in this model. */ std::size_t getNumberOfAutomata() const; /*! * Sets the system composition expression of the JANI model. */ void setSystemComposition(std::shared_ptr const& composition); /*! * Gets the system composition as the standard, fully-synchronizing parallel composition. */ std::shared_ptr getStandardSystemComposition() const; /*! * Retrieves the system composition expression. */ Composition const& getSystemComposition() const; /*! * Retrieves the set of action names. */ std::set getActionNames(bool includeSilent = true) const; /*! * Retrieves the name of the silent action. */ std::string const& getSilentActionName() const; /*! * Retrieves the index of the silent action. */ uint64_t getSilentActionIndex() const; /*! * Defines the undefined constants of the model by the given expressions. The original model is not modified, * but instead a new model is created. */ Model defineUndefinedConstants(std::map const& constantDefinitions) const; /*! * Retrieves whether the model still has undefined constants. */ bool hasUndefinedConstants() const; /*! * Retrieves all undefined constants of the model. */ std::vector> getUndefinedConstants() const; /*! * Substitutes all constants in all expressions of the model. The original model is not modified, but * instead a new model is created. */ Model substituteConstants() const; /*! * Retrieves a mapping from expression variables associated with defined constants of the model to their * (the constants') defining expression. */ std::map getConstantsSubstitution() const; /*! * Retrieves whether there is an expression defining the legal initial values of the global variables. */ bool hasInitialStatesExpression() const; /*! * Retrieves the expression defining the legal initial values of the variables. * * @param includeAutomataInitialStatesExpressions If set to true, the expression defines the legal initial * states not only for the global variables but also for the variables of each automaton. */ storm::expressions::Expression getInitialStatesExpression(bool includeAutomataInitialStatesExpressions = false) const; /*! * Sets the expression defining the legal initial values of the global variables. */ void setInitialStatesExpression(storm::expressions::Expression const& initialStatesExpression); /*! * Determines whether this model is a deterministic one in the sense that each state only has one choice. */ bool isDeterministicModel() const; /*! * Determines whether this model is a discrete-time model. */ bool isDiscreteTimeModel() const; /*! * Retrieves a list of expressions that characterize the legal values of the variables in this model. */ std::vector getAllRangeExpressions() const; /*! * Retrieves whether this model has the default composition, that is it composes all automata in parallel * and synchronizes over all common actions. */ bool hasDefaultComposition() const; /*! * Checks if the model is valid JANI, which should be verified before any further operations are applied to a model. */ bool checkValidity(bool logdbg = true) const; private: /// The model name. std::string name; /// The type of the model. ModelType modelType; /// The JANI-version used to specify the model. uint64_t version; /// The manager responsible for the expressions in this model. std::shared_ptr expressionManager; /// The list of actions. std::vector actions; /// A mapping from names to action indices. std::unordered_map actionToIndex; /// The index of the silent action. uint64_t silentActionIndex; /// The constants defined by the model. std::vector constants; /// A mapping from names to constants. std::unordered_map constantToIndex; /// The global variables of the model. VariableSet globalVariables; /// The list of automata. std::vector automata; /// A mapping from names to automata indices. std::unordered_map automatonToIndex; /// An expression describing how the system is composed of the automata. std::shared_ptr composition; // The expression characterizing the legal initial values of the global variables. storm::expressions::Expression initialStatesExpression; }; } }