X-Git-Url: https://git.stg.codes/stg.git/blobdiff_plain/2dd96d1468a065ebee3e37b1defcf2c438d72e2f..0c097ef3435d2a45c1ee4ac80f8bd3f254fb8df5:/projects/stargazer/plugins/other/smux/sensors.h?ds=inline diff --git a/projects/stargazer/plugins/other/smux/sensors.h b/projects/stargazer/plugins/other/smux/sensors.h index be53762b..559f051e 100644 --- a/projects/stargazer/plugins/other/smux/sensors.h +++ b/projects/stargazer/plugins/other/smux/sensors.h @@ -1,183 +1,280 @@ -#ifndef __SENSORS_H__ -#define __SENSORS_H__ +#pragma once -#include -#include +#include "value2os.h" +#include "types.h" #include "stg/users.h" +#include "stg/user.h" #include "stg/tariffs.h" +#include "stg/admins.h" +#include "stg/services.h" +#include "stg/corporations.h" +#include "stg/traffcounter.h" #include "stg/user_property.h" -#include "asn1/ObjectSyntax.h" +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wold-style-cast" +#include "stg/ObjectSyntax.h" +#pragma GCC diagnostic pop -#include "value2os.h" +#include class Sensor { public: - virtual bool GetValue(ObjectSyntax_t * objectSyntax) const = 0; + virtual ~Sensor() = default; + virtual void GetValue(ObjectSyntax_t * objectSyntax) const = 0; +#ifdef DEBUG + virtual std::string ToString() const = 0; +#endif }; -typedef std::map Sensors; - -class TableSensor { - public: - virtual bool appendTable(Sensors & sensors); -}; +typedef std::map Sensors; class TotalUsersSensor : public Sensor { public: - TotalUsersSensor(const USERS & u) : users(u) {} - virtual ~TotalUsersSensor() {} + explicit TotalUsersSensor(const STG::Users & u) : users(u) {} - bool GetValue(ObjectSyntax_t * objectSyntax) const + void GetValue(ObjectSyntax_t * objectSyntax) const override { - ValueToOS(users.GetUserNum(), objectSyntax); - return true; + ValueToOS(users.Count(), objectSyntax); } +#ifdef DEBUG + std::string ToString() const override + { std::string res; std::to_string(users.Count(), res); return res; } +#endif + private: - const USERS & users; + const STG::Users & users; }; class UsersSensor : public Sensor { public: - UsersSensor(USERS & u) : users(u) {} - virtual ~UsersSensor() {}; + explicit UsersSensor(STG::Users & u) : users(u) {} - bool GetValue(ObjectSyntax_t * objectSyntax) const; + void GetValue(ObjectSyntax_t * objectSyntax) const override; +#ifdef DEBUG + std::string ToString() const override; +#endif private: - USERS & users; + STG::Users & users; - virtual bool UserPredicate(USER_PTR userPtr) const = 0; + virtual bool UserPredicate(STG::User* userPtr) const = 0; }; class ConnectedUsersSensor : public UsersSensor { public: - ConnectedUsersSensor(USERS & u) : UsersSensor(u) {} - virtual ~ConnectedUsersSensor() {} + explicit ConnectedUsersSensor(STG::Users & u) : UsersSensor(u) {} private: - bool UserPredicate(USER_PTR userPtr) const + bool UserPredicate(STG::User* userPtr) const override { return userPtr->GetConnected(); } }; class AuthorizedUsersSensor : public UsersSensor { public: - AuthorizedUsersSensor(USERS & u) : UsersSensor(u) {} - virtual ~AuthorizedUsersSensor() {} + explicit AuthorizedUsersSensor(STG::Users & u) : UsersSensor(u) {} private: - bool UserPredicate(USER_PTR userPtr) const + bool UserPredicate(STG::User* userPtr) const override { return userPtr->GetAuthorized(); } }; class AlwaysOnlineUsersSensor : public UsersSensor { public: - AlwaysOnlineUsersSensor(USERS & u) : UsersSensor(u) {} - virtual ~AlwaysOnlineUsersSensor() {} + explicit AlwaysOnlineUsersSensor(STG::Users & u) : UsersSensor(u) {} private: - bool UserPredicate(USER_PTR userPtr) const - { return userPtr->GetProperty().alwaysOnline; } + bool UserPredicate(STG::User* userPtr) const override + { return userPtr->GetProperties().alwaysOnline; } }; class NoCashUsersSensor : public UsersSensor { public: - NoCashUsersSensor(USERS & u) : UsersSensor(u) {} - virtual ~NoCashUsersSensor() {} + explicit NoCashUsersSensor(STG::Users & u) : UsersSensor(u) {} private: - bool UserPredicate(USER_PTR userPtr) const - { return userPtr->GetProperty().cash < 0; } + bool UserPredicate(STG::User* userPtr) const override + { return userPtr->GetProperties().cash < 0; } }; class DisabledDetailStatsUsersSensor : public UsersSensor { public: - DisabledDetailStatsUsersSensor(USERS & u) : UsersSensor(u) {} - virtual ~DisabledDetailStatsUsersSensor() {} + explicit DisabledDetailStatsUsersSensor(STG::Users & u) : UsersSensor(u) {} private: - bool UserPredicate(USER_PTR userPtr) const - { return userPtr->GetProperty().disabledDetailStat; } + bool UserPredicate(STG::User* userPtr) const override + { return userPtr->GetProperties().disabledDetailStat; } }; class DisabledUsersSensor : public UsersSensor { public: - DisabledUsersSensor(USERS & u) : UsersSensor(u) {} - virtual ~DisabledUsersSensor() {} + explicit DisabledUsersSensor(STG::Users & u) : UsersSensor(u) {} private: - bool UserPredicate(USER_PTR userPtr) const - { return userPtr->GetProperty().disabled; } + bool UserPredicate(STG::User* userPtr) const override + { return userPtr->GetProperties().disabled; } }; class PassiveUsersSensor : public UsersSensor { public: - PassiveUsersSensor(USERS & u) : UsersSensor(u) {} - virtual ~PassiveUsersSensor() {} + explicit PassiveUsersSensor(STG::Users & u) : UsersSensor(u) {} private: - bool UserPredicate(USER_PTR userPtr) const - { return userPtr->GetProperty().passive; } + bool UserPredicate(STG::User* userPtr) const override + { return userPtr->GetProperties().passive; } }; class CreditUsersSensor : public UsersSensor { public: - CreditUsersSensor(USERS & u) : UsersSensor(u) {} - virtual ~CreditUsersSensor() {} + explicit CreditUsersSensor(STG::Users & u) : UsersSensor(u) {} private: - bool UserPredicate(USER_PTR userPtr) const - { return userPtr->GetProperty().credit > 0; } + bool UserPredicate(STG::User* userPtr) const override + { return userPtr->GetProperties().credit > 0; } }; class FreeMbUsersSensor : public UsersSensor { public: - FreeMbUsersSensor(USERS & u) : UsersSensor(u) {} - virtual ~FreeMbUsersSensor() {} + explicit FreeMbUsersSensor(STG::Users & u) : UsersSensor(u) {} private: - bool UserPredicate(USER_PTR userPtr) const - { return userPtr->GetProperty().freeMb > 0; } + bool UserPredicate(STG::User* userPtr) const override + { return userPtr->GetProperties().freeMb > 0; } }; class TariffChangeUsersSensor : public UsersSensor { public: - TariffChangeUsersSensor(USERS & u) : UsersSensor(u) {} - virtual ~TariffChangeUsersSensor() {} + explicit TariffChangeUsersSensor(STG::Users & u) : UsersSensor(u) {} + + private: + bool UserPredicate(STG::User* userPtr) const override + { return !userPtr->GetProperties().nextTariff.ConstData().empty(); } +}; + +class ActiveUsersSensor : public UsersSensor { + public: + explicit ActiveUsersSensor(STG::Users & u) : UsersSensor(u) {} private: - bool UserPredicate(USER_PTR userPtr) const - { return userPtr->GetProperty().nextTariff.ConstData().empty(); } + bool UserPredicate(STG::User* userPtr) const override; }; class TotalTariffsSensor : public Sensor { public: - TotalTariffsSensor(const TARIFFS & t) : tariffs(t) {} - virtual ~TotalTariffsSensor() {} + explicit TotalTariffsSensor(const STG::Tariffs & t) : tariffs(t) {} + + void GetValue(ObjectSyntax_t * objectSyntax) const override + { + ValueToOS(tariffs.Count(), objectSyntax); + } + +#ifdef DEBUG + std::string ToString() const override + { std::string res; std::to_string(tariffs.Count(), res); return res; } +#endif + + private: + const STG::Tariffs & tariffs; +}; + +class TotalAdminsSensor : public Sensor { + public: + explicit TotalAdminsSensor(const STG::Admins & a) : admins(a) {} + + void GetValue(ObjectSyntax_t * objectSyntax) const override + { + ValueToOS(admins.count(), objectSyntax); + } + +#ifdef DEBUG + std::string ToString() const override + { std::string res; std::to_string(admins.Count(), res); return res; } +#endif + + private: + const STG::Admins & admins; +}; + +class TotalServicesSensor : public Sensor { + public: + explicit TotalServicesSensor(const STG::Services & s) : services(s) {} - bool GetValue(ObjectSyntax_t * objectSyntax) const + void GetValue(ObjectSyntax_t * objectSyntax) const override { - ValueToOS(tariffs.GetTariffsNum(), objectSyntax); - return true; + ValueToOS(services.Count(), objectSyntax); } +#ifdef DEBUG + std::string ToString() const override + { std::string res; std::to_string(services.Count(), res); return res; } +#endif + private: - const TARIFFS & tariffs; + const STG::Services & services; +}; + +class TotalCorporationsSensor : public Sensor { + public: + explicit TotalCorporationsSensor(const STG::Corporations & c) : corporations(c) {} + + void GetValue(ObjectSyntax_t * objectSyntax) const override + { + ValueToOS(corporations.Count(), objectSyntax); + } + +#ifdef DEBUG + std::string ToString() const override + { std::string res; std::to_string(corporations.Count(), res); return res; } +#endif + + private: + const STG::Corporations & corporations; +}; + +class TotalRulesSensor : public Sensor { + public: + explicit TotalRulesSensor(const STG::TraffCounter & t) : traffcounter(t) {} + + void GetValue(ObjectSyntax_t * objectSyntax) const override + { + ValueToOS(traffcounter.rulesCount(), objectSyntax); + } + +#ifdef DEBUG + std::string ToString() const override + { std::string res; std::to_string(traffcounter.rulesCount(), res); return res; } +#endif + + private: + const STG::TraffCounter & traffcounter; }; template class ConstSensor : public Sensor { public: - ConstSensor(const T & v) : value(v) {} - virtual ~ConstSensor() {} + explicit ConstSensor(const T & v) : value(v) {} - bool GetValue(ObjectSyntax * objectSyntax) const - { return ValueToOS(value, objectSyntax); } + void GetValue(ObjectSyntax * objectSyntax) const override + { + ValueToOS(value, objectSyntax); + } + +#ifdef DEBUG + std::string ToString() const override + { std::string res; std::to_string(value, res); return res; } +#endif private: T value; }; +#ifdef DEBUG +template <> +inline +std::string ConstSensor::ToString() const +{ +return value; +} #endif