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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
|
/*
* Ekiga -- A VoIP and Video-Conferencing application
* Copyright (C) 2000-2009 Damien Sandras <dsandras@seconix.com>
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at
* your option) any later version. This program is distributed in the hope
* that it will be useful, but WITHOUT ANY WARRANTY; without even the
* implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
*
* Ekiga is licensed under the GPL license and as a special exception, you
* have permission to link or otherwise combine this program with the
* programs OPAL, OpenH323 and PWLIB, and distribute the combination, without
* applying the requirements of the GNU GPL to the OPAL, OpenH323 and PWLIB
* programs, as long as you do follow the requirements of the GNU GPL for all
* the rest of the software thus combined.
*/
/*
* kickstart.h - description
* ------------------------------------------
* begin : written in 2009 by Julien Puydt
* copyright : (c) 2009 by Julien Puydt
* description : declaration of a kickstart object
*
*/
#ifndef __KICKSTART_H__
#define __KICKSTART_H__
/* We want the engine startup to be as automatic as possible -- in particular,
* it should handle dependancies as transparently as possible so external
* plugins work correctly.
*
* This kickstart object works like this : some objects are registered to it,
* and are responsible of initializing a portion of code. Those objects are
* called sparks, and have basically three states :
* - blank -- they haven't managed to initialize anything yet ;
* - partial -- they have initialized something, but could do more ;
* - full -- they have initialized all they could.
*
* This means that a spark object will have a method which will try to
* initialize more, and a method which will tell in which state it is : indeed,
* the kickstart object will need to know when it reached a point where all
* sparks have done as much as they could, so we need a strictly increasing
* function up until then.
*
* We want the following to be guaranteed by each Spark implementation :
* - if try_initialize_more returns 'true', then the state should be at least
* partial ;
* - try_initialize_more shouldn't return 'true' if no new service could be
* registered ;
* - states should always evolve as BLANK -> PARTIAL -> FULL : no coming back!
*/
#include "services.h"
namespace Ekiga
{
struct Spark
{
typedef enum { BLANK, PARTIAL, FULL } state;
virtual ~Spark () {}
virtual bool try_initialize_more (ServiceCore& core,
int* argc,
char** argv[]) = 0;
virtual state get_state () const = 0;
// this method is useful for debugging purposes
virtual const std::string get_name () const = 0;
};
class KickStart
{
public:
KickStart ();
~KickStart ();
void add_spark (boost::shared_ptr<Spark>& spark);
/* try to do more with the known blank/partial sparks */
void kick (Ekiga::ServiceCore& core,
int* argc,
char** argv[]);
private:
std::list<boost::shared_ptr<Spark> > blanks;
std::list<boost::shared_ptr<Spark> > partials;
};
};
#endif
|
