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
|
/*-------------------------------------------------------------------------
* C-Pluff, a plug-in framework for C
* Copyright 2007 Johannes Lehtinen
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*-----------------------------------------------------------------------*/
/**
* @page architecture Plug-in architecture
*
* @section architectureOverview Overview
*
* The plug-in architecture supported by C-Pluff is presented in the
* following figure. There is a thin main program controlling the plug-in
* framework. The main program is responsible for initializing and setting
* up the plug-in environment. Most of the application logic is contained in
* plug-ins which are independent components and can be developed and
* distributed separately. Plug-ins integrate with each other by providing
* extension points and extensions. An extension point is a point into which
* other plug-ins can attach extensions. An extension can be just
* information, expressed in XML format, or the plug-in may also provide
* program logic as part of the plug-in runtime library. The framework
* provides services for accessing extensions and for managing plug-in
* dependencies.
*
* @image html architecture.png "C-Pluff plug-in architecture"
*
* @section architectureExtensions Extensions
*
* The idea behind extension points and extensions is that the extensibility
* is not limited only to few fixed plug-in types supported by the
* core application. Although the core plug-ins typically define the extension
* points for the core application logic, it is possible for any plug-in
* to specify additional extension points.
*
* For example, let us assume that we are developing an extensible text
* editor. One extension point defined by core editor plug-in could be
* auto-completion extension point. A plug-in providing basic Java source code
* support could provide an extension for auto-completing Java code.
* Now, while this extension could do basic auto-completion of plain Java code,
* it is customary that Java source code also includes embedded documentation,
* such as JavaDoc comments and tags, or annotations, such as XDoclet tags, as
* part of doc comments. Instead of trying to support all known tags and their
* semantics, the plug-in providing basic Java support could define another
* extension point for additional plug-ins that know how to perform
* auto-completion of different kind of tags in doc comments.
* This way the extensibility of the application is not limited to the
* extension points defined by the core application but the plug-ins can
* incrementally increase the extensibility of the application.
*/
|
