wfn_transition.h

Go to the documentation of this file.

/*
 * Copyright (c) 2012-2026, QORE Lab, Imperial College London
 * All rights reserved.
 */
#ifndef LINE_API_WFN_WFN_TRANSITION_H
#define LINE_API_WFN_WFN_TRANSITION_H
 
/**
 * @file
 * @ingroup api_wfn
 * A transition (task) of a WorkflowNet.
 *
 * A timed transition fires after its firing-time law; an immediate one fires in
 * zero time, and among the enabled immediate transitions only those of the
 * highest priority fire, chosen in proportion to their weights.
 *
 * MATLAB twin: matlab/src/api/wfn/WFNTransition.m
 */
 
#include <cstddef>
#include <limits>
#include <string>
 
#include "line/lang/lang_types.h"
#include "line/util/error.h"
 
namespace line {
namespace wfn {
 
class WorkflowNet;
 
class WFNTransition {
public:
    const std::string& name() const { return name_; }
    /** 0-based position in `WorkflowNet::transitions()`. */
    std::size_t index() const { return index_; }
    const lang::Distrib<double>& distribution() const { return distribution_; }
    lang::TimingStrategy timing() const { return timing_; }
    /** Concurrent firings allowed; infinite unless the task limits its own concurrency. */
    double servers() const { return servers_; }
    double priority() const { return priority_; }
    double weight() const { return weight_; }
    /** 0-based index into `WorkflowNet::resources()`, or -1 when the task holds none. */
    long resource() const { return resource_; }
 
    bool is_timed() const { return timing_ == lang::TimingStrategy::TIMED; }
    bool is_immediate() const { return timing_ == lang::TimingStrategy::IMMEDIATE; }
 
    /** `setDistribution(d)`. */
    void set_distribution(const lang::Distrib<double>& d) { distribution_ = d; }
    /** `setTiming(t)`. */
    void set_timing(lang::TimingStrategy timing) {
        if (timing != lang::TimingStrategy::TIMED && timing != lang::TimingStrategy::IMMEDIATE)
            throw InputError(ErrorKind("Argument"),
                             "Timing must be TimingStrategy.TIMED or TimingStrategy.IMMEDIATE.");
        timing_ = timing;
    }
    /** `setServers(n)`. */
    void set_servers(double servers) {
        if (!(servers >= 1))
            throw InputError(ErrorKind("Argument"), "Number of servers must be at least 1.");
        servers_ = servers;
    }
    /** `setPriority(p)`. */
    void set_priority(double priority) {
        if (!(priority > 0)) throw InputError(ErrorKind("Argument"), "Priority must be positive.");
        priority_ = priority;
    }
    /** `setWeight(w)`. */
    void set_weight(double weight) {
        if (!(weight > 0)) throw InputError(ErrorKind("Argument"), "Weight must be positive.");
        weight_ = weight;
    }
 
private:
    friend class WorkflowNet;
    WFNTransition(const std::string& name, std::size_t index, const lang::Distrib<double>& d,
                  lang::TimingStrategy timing, double servers, double priority, double weight)
        : name_(name), index_(index), distribution_(d), timing_(timing), servers_(servers),
          priority_(priority), weight_(weight) {}
 
    std::string name_;
    std::size_t index_;
    lang::Distrib<double> distribution_;
    lang::TimingStrategy timing_;
    double servers_ = std::numeric_limits<double>::infinity();
    double priority_ = 1.0;
    double weight_ = 1.0;
    long resource_ = -1;
};
 
}  // namespace wfn
}  // namespace line
 
#endif  // LINE_API_WFN_WFN_TRANSITION_H