store(st),
WriteServLog(GetStgLogger()),
searchDescriptors(),
- handle(0)
+ handle(0),
+ mutex(),
+ strError()
{
pthread_mutex_init(&mutex, NULL);
Read();
int CloseSearch(int) const;
private:
+ ADMINS_IMPL(const ADMINS_IMPL & rvalue);
+ ADMINS_IMPL & operator=(const ADMINS_IMPL & rvalue);
+
typedef list<ADMIN_IMPL>::iterator admin_iter;
typedef list<ADMIN_IMPL>::const_iterator const_admin_iter;
store(st),
WriteServLog(GetStgLogger()),
searchDescriptors(),
- handle(0)
+ handle(0),
+ mutex(),
+ strError()
{
pthread_mutex_init(&mutex, NULL);
Read();
int CloseSearch(int) const;
private:
+ CORPORATIONS_IMPL(const CORPORATIONS_IMPL & rvalue);
+ CORPORATIONS_IMPL & operator=(const CORPORATIONS_IMPL & rvalue);
+
typedef list<CORP_CONF>::iterator crp_iter;
typedef list<CORP_CONF>::const_iterator const_crp_iter;
bool Read();
std::list<CORP_CONF> data;
- STORE * store;
- STG_LOGGER & WriteServLog;
+ STORE * store;
+ STG_LOGGER & WriteServLog;
mutable std::map<int, const_crp_iter> searchDescriptors;
- mutable unsigned int handle;
+ mutable unsigned int handle;
mutable pthread_mutex_t mutex;
- std::string strError;
+ std::string strError;
};
#endif
store(st),
WriteServLog(GetStgLogger()),
searchDescriptors(),
- handle(0)
+ handle(0),
+ mutex(),
+ strError()
{
pthread_mutex_init(&mutex, NULL);
Read();
int CloseSearch(int) const;
private:
+ SERVICES_IMPL(const SERVICES_IMPL & rvalue);
+ SERVICES_IMPL & operator=(const SERVICES_IMPL & rvalue);
+
typedef list<SERVICE_CONF>::iterator srv_iter;
typedef list<SERVICE_CONF>::const_iterator const_srv_iter;
STORE * GetStore() { return plugin; }
const std::string & GetStrError() const { return errorStr; }
+
private:
+ STORE_LOADER(const STORE_LOADER & rvalue);
+ STORE_LOADER & operator=(const STORE_LOADER & rvalue);
+
bool isLoaded;
void * handle;
STORE * plugin;
tariffs(),
store(st),
WriteServLog(GetStgLogger()),
+ mutex(),
strError(),
noTariff(NO_TARIFF_NAME),
onAddNotifiers(),
void GetTariffsData(std::list<TARIFF_DATA> * tdl);
const std::string & GetStrError() const { return strError; }
+
private:
+ TARIFFS_IMPL(const TARIFFS_IMPL & rvalue);
+ TARIFFS_IMPL & operator=(const TARIFFS_IMPL & rvalue);
+
std::list<TARIFF_IMPL> tariffs;
STORE * store;
STG_LOGGER & WriteServLog;
size_t RulesCount() const { return rules.size(); }
private:
+ TRAFFCOUNTER_IMPL(const TRAFFCOUNTER_IMPL & rvalue);
+ TRAFFCOUNTER_IMPL & operator=(const TRAFFCOUNTER_IMPL & rvalue);
+
bool ParseAddress(const char * ta, RULE * rule) const;
uint32_t CalcMask(uint32_t msk) const;
void FreeRules();
void Notify(const int & oldPassive, const int & newPassive);
private:
+ CHG_PASSIVE_NOTIFIER(const CHG_PASSIVE_NOTIFIER & rvalue);
+ CHG_PASSIVE_NOTIFIER & operator=(const CHG_PASSIVE_NOTIFIER & rvalue);
+
USER_IMPL * user;
};
//-----------------------------------------------------------------------------
void Notify(const std::string & oldTariff, const std::string & newTariff);
private:
+ CHG_TARIFF_NOTIFIER(const CHG_TARIFF_NOTIFIER & rvalue);
+ CHG_TARIFF_NOTIFIER & operator=(const CHG_TARIFF_NOTIFIER & rvalue);
+
USER_IMPL * user;
};
//-----------------------------------------------------------------------------
void Notify(const double & oldCash, const double & newCash);
private:
+ CHG_CASH_NOTIFIER(const CHG_CASH_NOTIFIER & rvalue);
+ CHG_CASH_NOTIFIER & operator=(const CHG_CASH_NOTIFIER & rvalue);
+
USER_IMPL * user;
};
//-----------------------------------------------------------------------------
class CHG_IPS_NOTIFIER : public PROPERTY_NOTIFIER_BASE<USER_IPS>,
private NONCOPYABLE {
public:
+ CHG_IPS_NOTIFIER(const CHG_IPS_NOTIFIER & rvalue);
+ CHG_IPS_NOTIFIER & operator=(const CHG_IPS_NOTIFIER & rvalue);
+
CHG_IPS_NOTIFIER(USER_IMPL * u) : user(u) {}
void Notify(const USER_IPS & oldIPs, const USER_IPS & newIPs);
class USERS_IMPL;
//-----------------------------------------------------------------------------
-/*class PROPERTY_NOTIFER_IP_BEFORE: public PROPERTY_NOTIFIER_BASE<uint32_t> {
-public:
- PROPERTY_NOTIFER_IP_BEFORE(USERS_IMPL & us, user_iter u) : users(us), user(u) {}
- void Notify(const uint32_t & oldValue, const uint32_t & newValue);
- user_iter GetUser() const { return user; }
-private:
- USERS_IMPL & users;
- user_iter user;
-};
-//-----------------------------------------------------------------------------
-class PROPERTY_NOTIFER_IP_AFTER: public PROPERTY_NOTIFIER_BASE<uint32_t> {
-public:
- PROPERTY_NOTIFER_IP_AFTER(USERS_IMPL & us, user_iter u) : users(us), user(u) {}
- void Notify(const uint32_t & oldValue, const uint32_t & newValue);
- user_iter GetUser() const { return user; }
-private:
- USERS_IMPL & users;
- user_iter user;
-};*/
-//-----------------------------------------------------------------------------
struct USER_TO_DEL {
USER_TO_DEL()
: iter(),
int Stop();
private:
+ USERS_IMPL(const USERS_IMPL & rvalue);
+ USERS_IMPL & operator=(const USERS_IMPL & rvalue);
+
void AddToIPIdx(user_iter user);
void DelFromIPIdx(uint32_t ip);
bool FindByIPIdx(uint32_t ip, user_iter & iter) const;