26 августа 2007, Vitamin

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

template<class T, void (T::*_ctor)(), void (T::*_dtor)()>
class AutoEnv
{
        AutoEnv(const AutoEnv&);
        AutoEnv& operator=(const AutoEnv&);
public:
        AutoEnv(T& rc) : rc_(rc)
        {
                (rc_.*_ctor)();
        }
        ~AutoEnv()
        {
                (rc_.*_dtor)();
        }
private:
        T& rc_;
};

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

//options interface with bufferization and timechecking
template<const std::string& name>
std::string getString(const char* defval = "") const
{
static Mutex mutex;
static std::string value;
static time_t lasttime = 0;
       {
              Locker locker(mutex);
              if (lasttime != settings_.timestamp())
              {
                 lasttime = settings_.timestamp();
                 value = settings_.getString(name, defval);
              }
       }
       return value;
}

//same for integer
template<const std::string& name>
int getInteger(int defval = 0) const
{
..
}

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

void Core::logging(const log::LogMessage& msg) const
{
static int donelines[2] = {};

        if ((msg.category() == MSG_NOTICE && msg.loglevel() >
getInteger<OptionVerbose>(VERBOSE_MIN)) ||
            (msg.category() == MSG_WARNING && msg.loglevel() >
getInteger<OptionWarninglevel>(VERBOSE_MIN))) return;

        FILE* logfile = msg.category() == MSG_NOTICE ?
        logFile_.asFile() :
        errFile_.asFile();
        int& doneline = donelines[msg.category() == MSG_NOTICE];
        struct tm thisTime;
        time_t thistim = time(NULL);
        localtime_r(&thistim, &thisTime);
        fprintf
        (
            logfile,
            "\n%02u-%02u-%02u %02i:%02i:%02i>%.*s",
            thisTime.tm_mday,
            thisTime.tm_mon + 1,
            thisTime.tm_year + 1900,
            thisTime.tm_hour,
            thisTime.tm_min,
            thisTime.tm_sec,
            msg.loglevel() * 2 - 1,
            "                                 "
        );
        msg.put(logfile);
        if (++doneline >= getInteger<OptionFlushlines>(100))
        {
                fflush(logfile);
                doneline = 0;
        }
}

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

FileKeeper<std::string> keeper;
static const std::string Field1("[f1]");
static const std::string Field2("[f2]");

       StaticTemplate<std::string> templ;
       templ.add(Field1, field1_value);
       templ.add(Field2, field2_value);
       cout << templ.pass(keeper.get(template_filename));
                
...
class Strings
{
public:
      static const std::string begGroup;
      static const std::string endGroup;
      ...
};

const std::string Strings::begGroup("{begin}");
const std::string Strings::endGroup("{end}");
...

std::vector<std::string> valueslist;
static const std::string FieldVal("[val]");

   // fill valueslist
   valueslist.push_back("1");
   valueslist.push_back("2");
   ...
   valueslist.push_back("8");
   StaticMultipleTemplate<std::string, std::vector> templ;
   //single fields
   templ.add(Field1, "field1");
   templ.add(Field2, "field2");
   //multiple fields
   templ.add(FieldVal, valueslist);
   ...
   //pass
   cout << templ.pass<Strings::begGroup,
   Strings::endGroup>("[f1]:{begin}[val],{end}:[f2]");

   out:
   field1:1,2,3,4,5,6,7,8,:field2