← Back to branch summary

~registry/scalestack/trunk

« back to all changes in this revision

Viewing changes to scalestack/event/libevent/service_provider.cc

  • Committer: Eric Day
  • Date: 2010-07-02 04:33:01 UTC
  • mfrom: (56.1.4)
  • Revision ID: git-v1:1084ed00d423bd6296f3362ba35e6781eca9233a
Merged style-updates branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
scalestack/event/libevent/service_provider.cc
1
 
/*
2
 
 * Scale Stack
3
 
 *
4
 
 * Copyright (C) 2010 Eric Day (eday@oddments.org)
5
 
 * All rights reserved.
6
 
 *
7
 
 * Use and distribution licensed under the BSD license. See the
8
 
 * COPYING file in the root project directory for full text.
9
 
 */
10
 
 
11
 
/**
12
 
 * @file
13
 
 * @brief libevent Event Service Provider Definitions
14
 
 */
15
 
 
16
 
#include "config.h"
17
 
 
18
 
#include <algorithm>
19
 
#include <exception>
20
 
#include <functional>
21
 
 
22
 
#include <scalestack/event/service.h>
23
 
#include <scalestack/event/libevent/handler_provider.h>
24
 
#include <scalestack/event/libevent/service_provider.h>
25
 
#include <scalestack/event/libevent/thread.h>
26
 
#include <scalestack/kernel/module.h>
27
 
#include <scalestack/kernel/option.h>
28
 
 
29
 
using namespace std;
30
 
 
31
 
namespace scalestack
32
 
{
33
 
namespace event
34
 
{
35
 
namespace libevent
36
 
{
37
 
 
38
 
/*
39
 
 * Public methods.
40
 
 */
41
 
 
42
 
service_provider::service_provider(kernel::module& module):
43
 
  event::service_provider(module),
44
 
  _current_thread(),
45
 
  _threads()
46
 
{
47
 
  size_t thread_count = _module.get_option("threads").get_size_value();
48
 
  if (thread_count == 0)
49
 
    _module.log_fatal("The 'threads' option must be greater than 0");
50
 
 
51
 
  for (size_t thread_index = 0; thread_index < thread_count; thread_index++)
52
 
  {
53
 
    thread* new_thread = NULL;
54
 
    try
55
 
    {
56
 
      new_thread = new thread(*this, thread_index);
57
 
      _threads.push_back(new_thread);
58
 
    }
59
 
    catch (exception&)
60
 
    {
61
 
      if (new_thread != NULL)
62
 
      {
63
 
        new_thread->stop();
64
 
        delete new_thread;
65
 
      }
66
 
 
67
 
      _remove_threads();
68
 
      throw;
69
 
    }
70
 
  }
71
 
}
72
 
 
73
 
service_provider::~service_provider()
74
 
{
75
 
  _remove_threads();
76
 
}
77
 
 
78
 
void service_provider::add_handler(event::handler* handler)
79
 
{
80
 
  handler_provider* new_handler_provider = new handler_provider(_module);
81
 
  try
82
 
  {
83
 
    new_handler_provider->set_handler(handler);
84
 
 
85
 
    /* Choose assigned thread by round-robin. */
86
 
    _current_thread++;
87
 
    new_handler_provider->set_thread(_threads[_current_thread % _threads.size()]);
88
 
  }
89
 
  catch (exception&)
90
 
  {
91
 
    delete new_handler_provider;
92
 
    throw;
93
 
  }
94
 
}
95
 
 
96
 
void service_provider::remove_handler_provider(handler_provider* handler_provider)
97
 
{
98
 
  remove_handler(handler_provider->get_handler());
99
 
  delete handler_provider;
100
 
}
101
 
 
102
 
/*
103
 
 * Private methods.
104
 
 */
105
 
 
106
 
void service_provider::_remove_threads(void)
107
 
{
108
 
  for_each(_threads.begin(), _threads.end(), mem_fun(&thread::stop));
109
 
 
110
 
  for (vector<thread*>::iterator thread = _threads.begin();
111
 
       thread != _threads.end();
112
 
       ++thread)
113
 
  {
114
 
    delete *thread;
115
 
  }
116
 
}
117
 
 
118
 
} /* namespace libevent */
119
 
} /* namespace event */
120
 
} /* namespace scalestack */