Some more BSD-related issues.

[stg.git] / stargazer / tariffs_impl.cpp

diff --git a/stargazer/tariffs_impl.cpp b/stargazer/tariffs_impl.cpp
index d47ecf8f5e90b68685bbe4d1205efa78d36cb678..7e92657d797fcb97c1a6f818f8ed8630ddaa4b3a 100644 (file)
--- a/stargazer/tariffs_impl.cpp
+++ b/stargazer/tariffs_impl.cpp
@@ -36,32 +36,23 @@
 #include "stg/logger.h"
 #include "stg/store.h"
 #include "stg/admin.h"
 #include "stg/logger.h"
 #include "stg/store.h"
 #include "stg/admin.h"

+#include "stg/admin_conf.h"

 #include "tariffs_impl.h"
 
 #include "tariffs_impl.h"
 

+using STG::TariffsImpl;
+

 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------

-TARIFFS_IMPL::TARIFFS_IMPL(STORE * st)
-    : TARIFFS(),
-      tariffs(),
-      store(st),
-      WriteServLog(GetStgLogger()),
-      mutex(),
-      strError(),
-      noTariff(NO_TARIFF_NAME),
-      onAddNotifiers(),
-      onDelNotifiers()
+TariffsImpl::TariffsImpl(Store * st)
+    : store(st),
+      WriteServLog(Logger::get()),
+      noTariff(NO_TARIFF_NAME)

 {
 {

-pthread_mutex_init(&mutex, NULL);

 ReadTariffs();
 }
 //-----------------------------------------------------------------------------
 ReadTariffs();
 }
 //-----------------------------------------------------------------------------

-TARIFFS_IMPL::~TARIFFS_IMPL()
-{
-pthread_mutex_destroy(&mutex);
-}
-//-----------------------------------------------------------------------------
-int TARIFFS_IMPL::ReadTariffs()
+int TariffsImpl::ReadTariffs()

 {
 {

-STG_LOCKER lock(&mutex);
+std::lock_guard<std::mutex> lock(m_mutex);

 
 std::vector<std::string> tariffsList;
 if (store->GetTariffsList(&tariffsList))
 
 std::vector<std::string> tariffsList;
 if (store->GetTariffsList(&tariffsList))


@@ -70,37 +61,36 @@ if (store->GetTariffsList(&tariffsList))
     WriteServLog("%s", store->GetStrError().c_str());
     }
 
     WriteServLog("%s", store->GetStrError().c_str());
     }
 

-Tariffs::size_type tariffsNum = tariffsList.size();
+Data::size_type tariffsNum = tariffsList.size();

 
 

-for (Tariffs::size_type i = 0; i < tariffsNum; i++)
+for (Data::size_type i = 0; i < tariffsNum; i++)

     {
     {

-    TARIFF_DATA td;
+    TariffData td;

     if (store->RestoreTariff(&td, tariffsList[i]))
         {
         WriteServLog("Cannot read tariff %s.", tariffsList[i].c_str());
         WriteServLog("%s", store->GetStrError().c_str());
         return -1;
         }
     if (store->RestoreTariff(&td, tariffsList[i]))
         {
         WriteServLog("Cannot read tariff %s.", tariffsList[i].c_str());
         WriteServLog("%s", store->GetStrError().c_str());
         return -1;
         }

-    tariffs.push_back(TARIFF_IMPL(td));
+    tariffs.push_back(TariffImpl(td));

     }
 
 return 0;
 }
 //-----------------------------------------------------------------------------
     }
 
 return 0;
 }
 //-----------------------------------------------------------------------------

-size_t TARIFFS_IMPL::Count() const
+size_t TariffsImpl::Count() const

 {
 {

-STG_LOCKER lock(&mutex);
+std::lock_guard<std::mutex> lock(m_mutex);

 return tariffs.size();
 }
 //-----------------------------------------------------------------------------
 return tariffs.size();
 }
 //-----------------------------------------------------------------------------

-const TARIFF * TARIFFS_IMPL::FindByName(const std::string & name) const
+const STG::Tariff* TariffsImpl::FindByName(const std::string & name) const

 {
 if (name == NO_TARIFF_NAME)
     return &noTariff;
 
 {
 if (name == NO_TARIFF_NAME)
     return &noTariff;
 

-STG_LOCKER lock(&mutex);
-std::list<TARIFF_IMPL>::const_iterator ti;
-ti = find(tariffs.begin(), tariffs.end(), TARIFF_IMPL(name));
+std::lock_guard<std::mutex> lock(m_mutex);
+const auto ti = find(tariffs.begin(), tariffs.end(), TariffImpl(name));

 
 if (ti != tariffs.end())
     return &(*ti);
 
 if (ti != tariffs.end())
     return &(*ti);


@@ -108,9 +98,9 @@ if (ti != tariffs.end())
 return NULL;
 }
 //-----------------------------------------------------------------------------
 return NULL;
 }
 //-----------------------------------------------------------------------------

-int TARIFFS_IMPL::Chg(const TARIFF_DATA & td, const ADMIN * admin)
+int TariffsImpl::Chg(const TariffData & td, const Admin * admin)

 {
 {

-const PRIV * priv = admin->GetPriv();
+const auto priv = admin->GetPriv();

 
 if (!priv->tariffChg)
     {
 
 if (!priv->tariffChg)
     {


@@ -121,10 +111,9 @@ if (!priv->tariffChg)
     return -1;
     }
 
     return -1;
     }
 

-STG_LOCKER lock(&mutex);
+std::lock_guard<std::mutex> lock(m_mutex);

 
 

-std::list<TARIFF_IMPL>::iterator ti;
-ti = find(tariffs.begin(), tariffs.end(), TARIFF_IMPL(td.tariffConf.name));
+auto ti = find(tariffs.begin(), tariffs.end(), TariffImpl(td.tariffConf.name));

 
 if (ti == tariffs.end())
     {
 
 if (ti == tariffs.end())
     {


@@ -148,9 +137,9 @@ WriteServLog("%s Tariff \'%s\' changed.",
 return 0;
 }
 //-----------------------------------------------------------------------------
 return 0;
 }
 //-----------------------------------------------------------------------------

-int TARIFFS_IMPL::Del(const std::string & name, const ADMIN * admin)
+int TariffsImpl::Del(const std::string & name, const Admin * admin)

 {
 {

-const PRIV * priv = admin->GetPriv();
+const auto priv = admin->GetPriv();

 
 if (!priv->tariffChg)
     {
 
 if (!priv->tariffChg)
     {


@@ -161,13 +150,12 @@ if (!priv->tariffChg)
     return -1;
     }
 
     return -1;
     }
 

-TARIFF_DATA td;
+TariffData td;

 
     {
 
     {

-    STG_LOCKER lock(&mutex);
+    std::lock_guard<std::mutex> lock(m_mutex);

 
 

-    std::list<TARIFF_IMPL>::iterator ti;
-    ti = find(tariffs.begin(), tariffs.end(), TARIFF_IMPL(name));
+    const auto ti = find(tariffs.begin(), tariffs.end(), TariffImpl(name));

 
     if (ti == tariffs.end())
         {
 
     if (ti == tariffs.end())
         {


@@ -188,7 +176,7 @@ TARIFF_DATA td;
     tariffs.erase(ti);
     }
 
     tariffs.erase(ti);
     }
 

-std::set<NOTIFIER_BASE<TARIFF_DATA> *>::iterator ni = onDelNotifiers.begin();
+auto ni = onDelNotifiers.begin();

 while (ni != onDelNotifiers.end())
     {
     (*ni)->Notify(td);
 while (ni != onDelNotifiers.end())
     {
     (*ni)->Notify(td);


@@ -201,9 +189,9 @@ WriteServLog("%s Tariff \'%s\' deleted.",
 return 0;
 }
 //-----------------------------------------------------------------------------
 return 0;
 }
 //-----------------------------------------------------------------------------

-int TARIFFS_IMPL::Add(const std::string & name, const ADMIN * admin)
+int TariffsImpl::Add(const std::string & name, const Admin * admin)

 {
 {

-const PRIV * priv = admin->GetPriv();
+const auto priv = admin->GetPriv();

 
 if (!priv->tariffChg)
     {
 
 if (!priv->tariffChg)
     {


@@ -215,10 +203,9 @@ if (!priv->tariffChg)
     }
 
     {
     }
 
     {

-    STG_LOCKER lock(&mutex);
+    std::lock_guard<std::mutex> lock(m_mutex);

 
 

-    std::list<TARIFF_IMPL>::iterator ti;
-    ti = find(tariffs.begin(), tariffs.end(), TARIFF_IMPL(name));
+    const auto ti = find(tariffs.begin(), tariffs.end(), TariffImpl(name));

 
     if (ti != tariffs.end())
         {
 
     if (ti != tariffs.end())
         {


@@ -227,7 +214,7 @@ if (!priv->tariffChg)
         return -1;
         }
 
         return -1;
         }
 

-    tariffs.push_back(TARIFF_IMPL(name));
+    tariffs.push_back(TariffImpl(name));

     }
 
 if (store->AddTariff(name) < 0)
     }
 
 if (store->AddTariff(name) < 0)


@@ -238,7 +225,7 @@ if (store->AddTariff(name) < 0)
     }
 
 // Fire all "on add" notifiers
     }
 
 // Fire all "on add" notifiers

-std::set<NOTIFIER_BASE<TARIFF_DATA> *>::iterator ni = onAddNotifiers.begin();
+auto ni = onAddNotifiers.begin();

 while (ni != onAddNotifiers.end())
     {
     (*ni)->Notify(tariffs.back().GetTariffData());
 while (ni != onAddNotifiers.end())
     {
     (*ni)->Notify(tariffs.back().GetTariffData());


@@ -251,39 +238,39 @@ WriteServLog("%s Tariff \'%s\' added.",
 return 0;
 }
 //-----------------------------------------------------------------------------
 return 0;
 }
 //-----------------------------------------------------------------------------

-void TARIFFS_IMPL::GetTariffsData(std::list<TARIFF_DATA> * tdl) const
+void TariffsImpl::GetTariffsData(std::vector<TariffData> * tdl) const

 {
 assert(tdl != NULL && "Tariffs data list is not null");
 {
 assert(tdl != NULL && "Tariffs data list is not null");

-STG_LOCKER lock(&mutex);
+std::lock_guard<std::mutex> lock(m_mutex);

 
 

-Tariffs::const_iterator it = tariffs.begin();
+auto it = tariffs.begin();

 for (; it != tariffs.end(); ++it)
     {
     tdl->push_back(it->GetTariffData());
     }
 }
 //-----------------------------------------------------------------------------
 for (; it != tariffs.end(); ++it)
     {
     tdl->push_back(it->GetTariffData());
     }
 }
 //-----------------------------------------------------------------------------

-void TARIFFS_IMPL::AddNotifierAdd(NOTIFIER_BASE<TARIFF_DATA> * n)
+void TariffsImpl::AddNotifierAdd(NotifierBase<TariffData> * n)

 {
 {

-STG_LOCKER lock(&mutex);
+std::lock_guard<std::mutex> lock(m_mutex);

 onAddNotifiers.insert(n);
 }
 //-----------------------------------------------------------------------------
 onAddNotifiers.insert(n);
 }
 //-----------------------------------------------------------------------------

-void TARIFFS_IMPL::DelNotifierAdd(NOTIFIER_BASE<TARIFF_DATA> * n)
+void TariffsImpl::DelNotifierAdd(NotifierBase<TariffData> * n)

 {
 {

-STG_LOCKER lock(&mutex);
+std::lock_guard<std::mutex> lock(m_mutex);

 onAddNotifiers.erase(n);
 }
 //-----------------------------------------------------------------------------
 onAddNotifiers.erase(n);
 }
 //-----------------------------------------------------------------------------

-void TARIFFS_IMPL::AddNotifierDel(NOTIFIER_BASE<TARIFF_DATA> * n)
+void TariffsImpl::AddNotifierDel(NotifierBase<TariffData> * n)

 {
 {

-STG_LOCKER lock(&mutex);
+std::lock_guard<std::mutex> lock(m_mutex);

 onDelNotifiers.insert(n);
 }
 //-----------------------------------------------------------------------------
 onDelNotifiers.insert(n);
 }
 //-----------------------------------------------------------------------------

-void TARIFFS_IMPL::DelNotifierDel(NOTIFIER_BASE<TARIFF_DATA> * n)
+void TariffsImpl::DelNotifierDel(NotifierBase<TariffData> * n)

 {
 {

-STG_LOCKER lock(&mutex);
+std::lock_guard<std::mutex> lock(m_mutex);

 onDelNotifiers.erase(n);
 }
 //-----------------------------------------------------------------------------
 onDelNotifiers.erase(n);
 }
 //-----------------------------------------------------------------------------