This is Sonar rule S1235
https://sonarcloud.io/organizations/simgrid/rules?open=cpp%3AS1235&rule_key=cpp%3AS1235
Some of the classes are simply marked "final" so that they can never become a
polymorphic base class.
* @brief Network Model interface class
*/
class XBT_PUBLIC NetworkModelIntf {
* @brief Network Model interface class
*/
class XBT_PUBLIC NetworkModelIntf {
+protected:
+ ~NetworkModelIntf() = default;
+
public:
/**
* @brief Callback to set the bandwidth and latency factors used in a communication
public:
/**
* @brief Callback to set the bandwidth and latency factors used in a communication
} // namespace kernel
} // namespace simgrid
} // namespace kernel
} // namespace simgrid
-#endif /* SIMGRID_KERNEL_RESOURCE_NETWORKMODELINTF_HPP */
\ No newline at end of file
+#endif /* SIMGRID_KERNEL_RESOURCE_NETWORKMODELINTF_HPP */
namespace kernel {
namespace actor {
namespace kernel {
namespace actor {
-class ActivityTestSimcall : public ResultingSimcall<bool> {
+class ActivityTestSimcall final : public ResultingSimcall<bool> {
activity::ActivityImpl* const activity_;
public:
activity::ActivityImpl* const activity_;
public:
void serialize(std::stringstream& stream) const override;
};
void serialize(std::stringstream& stream) const override;
};
-class ActivityTestanySimcall : public ResultingSimcall<ssize_t> {
+class ActivityTestanySimcall final : public ResultingSimcall<ssize_t> {
const std::vector<activity::ActivityImpl*>& activities_;
std::vector<int> indexes_; // indexes in activities_ pointing to ready activities (=whose test() is positive)
int next_value_ = 0;
const std::vector<activity::ActivityImpl*>& activities_;
std::vector<int> indexes_; // indexes in activities_ pointing to ready activities (=whose test() is positive)
int next_value_ = 0;
int get_value() const { return next_value_; }
};
int get_value() const { return next_value_; }
};
-class ActivityWaitSimcall : public ResultingSimcall<bool> {
+class ActivityWaitSimcall final : public ResultingSimcall<bool> {
activity::ActivityImpl* activity_;
const double timeout_;
activity::ActivityImpl* activity_;
const double timeout_;
double get_timeout() const { return timeout_; }
};
double get_timeout() const { return timeout_; }
};
-class ActivityWaitanySimcall : public ResultingSimcall<ssize_t> {
+class ActivityWaitanySimcall final : public ResultingSimcall<ssize_t> {
const std::vector<activity::ActivityImpl*>& activities_;
std::vector<int> indexes_; // indexes in activities_ pointing to ready activities (=whose test() is positive)
const double timeout_;
const std::vector<activity::ActivityImpl*>& activities_;
std::vector<int> indexes_; // indexes in activities_ pointing to ready activities (=whose test() is positive)
const double timeout_;
int get_value() const { return next_value_; }
};
int get_value() const { return next_value_; }
};
-class CommIsendSimcall : public SimcallObserver {
+class CommIsendSimcall final : public SimcallObserver {
activity::MailboxImpl* mbox_;
double payload_size_;
double rate_;
activity::MailboxImpl* mbox_;
double payload_size_;
double rate_;
auto const& get_copy_data_fun() const { return copy_data_fun_; }
};
auto const& get_copy_data_fun() const { return copy_data_fun_; }
};
-class CommIrecvSimcall : public SimcallObserver {
+class CommIrecvSimcall final : public SimcallObserver {
activity::MailboxImpl* mbox_;
unsigned char* dst_buff_;
size_t* dst_buff_size_;
activity::MailboxImpl* mbox_;
unsigned char* dst_buff_;
size_t* dst_buff_size_;
class SimcallObserver {
ActorImpl* const issuer_;
class SimcallObserver {
ActorImpl* const issuer_;
+protected:
+ ~SimcallObserver() = default;
+
public:
explicit SimcallObserver(ActorImpl* issuer) : issuer_(issuer) {}
ActorImpl* get_issuer() const { return issuer_; }
public:
explicit SimcallObserver(ActorImpl* issuer) : issuer_(issuer) {}
ActorImpl* get_issuer() const { return issuer_; }
template <class T> class ResultingSimcall : public SimcallObserver {
T result_;
template <class T> class ResultingSimcall : public SimcallObserver {
T result_;
+protected:
+ ~ResultingSimcall() = default;
+
public:
ResultingSimcall() = default;
ResultingSimcall(ActorImpl* actor, T default_result) : SimcallObserver(actor), result_(default_result) {}
public:
ResultingSimcall() = default;
ResultingSimcall(ActorImpl* actor, T default_result) : SimcallObserver(actor), result_(default_result) {}
T get_result() const { return result_; }
};
T get_result() const { return result_; }
};
-class RandomSimcall : public SimcallObserver {
+class RandomSimcall final : public SimcallObserver {
const int min_;
const int max_;
int next_value_ = 0;
const int min_;
const int max_;
int next_value_ = 0;
int get_value() const { return next_value_; }
};
int get_value() const { return next_value_; }
};
-class ConditionWaitSimcall : public ResultingSimcall<bool> {
+class ConditionWaitSimcall final : public ResultingSimcall<bool> {
activity::ConditionVariableImpl* const cond_;
activity::MutexImpl* const mutex_;
const double timeout_;
activity::ConditionVariableImpl* const cond_;
activity::MutexImpl* const mutex_;
const double timeout_;
namespace actor {
/* All the observers of Mutex transitions are very similar, so implement them all together in this class */
namespace actor {
/* All the observers of Mutex transitions are very similar, so implement them all together in this class */
-class MutexObserver : public SimcallObserver {
+class MutexObserver final : public SimcallObserver {
mc::Transition::Type type_;
activity::MutexImpl* const mutex_;
mc::Transition::Type type_;
activity::MutexImpl* const mutex_;
};
/* This observer is used for SEM_LOCK and SEM_UNLOCK (only) */
};
/* This observer is used for SEM_LOCK and SEM_UNLOCK (only) */
-class SemaphoreObserver : public SimcallObserver {
+class SemaphoreObserver final : public SimcallObserver {
mc::Transition::Type type_;
activity::SemaphoreImpl* const sem_;
mc::Transition::Type type_;
activity::SemaphoreImpl* const sem_;
};
/* This observer is ued for SEM_WAIT, that is returning and needs the acquisition (in MC mode) */
};
/* This observer is ued for SEM_WAIT, that is returning and needs the acquisition (in MC mode) */
-class SemaphoreAcquisitionObserver : public ResultingSimcall<bool> {
+class SemaphoreAcquisitionObserver final : public ResultingSimcall<bool> {
mc::Transition::Type type_;
activity::SemAcquisitionImpl* const acquisition_;
const double timeout_;
mc::Transition::Type type_;
activity::SemAcquisitionImpl* const acquisition_;
const double timeout_;
};
/* This observer is ued for BARRIER_LOCK and BARRIER_WAIT. WAIT is returning and needs the acquisition */
};
/* This observer is ued for BARRIER_LOCK and BARRIER_WAIT. WAIT is returning and needs the acquisition */
-class BarrierObserver : public ResultingSimcall<bool> {
+class BarrierObserver final : public ResultingSimcall<bool> {
mc::Transition::Type type_;
activity::BarrierImpl* const barrier_ = nullptr;
activity::BarrierAcquisitionImpl* const acquisition_ = nullptr;
mc::Transition::Type type_;
activity::BarrierImpl* const barrier_ = nullptr;
activity::BarrierAcquisitionImpl* const acquisition_ = nullptr;