English
资源说明：OSGi-like module platform and service bus for C++
h1. Sekai Framework Sekai Framework is a software extensibility platform for C++ projects. Framework provides multiple solutions for developing modular extensible applications. It also includes library for cross-language development, allowing you to easily use C++ in combination with scripting languages. h2. Introduction Welcome to the _Sekai Framework_. _Sekai Framework_ is a middleware solution that allows easily create modular and extensible plug-in-based C++ applications. It saves you a great deal of time and effort by providing powerful facilities for structuring your project and increasing the ease of code-reuse. _Sekai Framework_ currently provides two extension systems (or plug-in buses): * First uses a *declarative* approach for description of plug-ins and their connections. This approach allows extending applications without changing a single line of source code of existing modules. All project structure is defined by plug-ins' metadata (XML files), so it can be reconfigured using a simple text editor. Simply saying, XML file describes classes that exported from the plug-ins, and extension points it wants to extend. bq. For Java programmers this approach can be known as an *Eclipse Extensions* model. * Second system is much more powerful. It implements a complete *dynamic component model*. It allows dynamic installing, starting, stopping, updating and uninstalling of plug-ins (coming in form of _bundles_) without requiring application restart. This involves a complex logic of dependency management and plug-in event handling. All functionality in bundles defined as a *service* that can be also dynamically registered and unregistered. bq. Implementation of this system can be described as C++ interpretation of Java's *OSGi* standard. It tries to follow standard as closely as possible, while modifying language-specific parts of it. _Sekai Framework_ also offers a distinctive approach for embedding a scripting language into your application. This approach is based on _reflection_ (_introspection_) library. Reflection on its own is useful for multiple purposes (for example GUI generation based on class properties). In this system it is used to generate script bindings at the program run-time. Currently binding generation is implemented for Pyhton language and allows: * exporting C++ classes, structures and enums to the script with only a few lines of code * gain access to values inside the script, read and modify its variables * inheriting python classes from C++ types Framework also provides multiple utilities for logging, debugging, profiling, multithreading, file system access, unicode support, all to make developers' life easier. h2. Structure The framework implementation intended to be highly modular. Functionality packed into a set of modules, while coupling between them is kept to the minimum. This means that developer should be able to choose those modules he actually need in his application and leave the rest aside. h3. Main modules Main set of modules includes: * _Common_ library * _Module_ library * _Debugging_ module * _Logging_ module * _File System_ module * _Reflection_ library * _Scripting_ library with bindings generator * _Unicode_ library * _Threading_ library * _Platform_ library * _Serialization_ library * _Extension Manager_ module * _Framework_ module h4. Module library This library is a heart of the framework. It provides means to export functionality from modules. It also deals with such problems as binary encapsulation, protecting modules from the changes in modules they depend on. This library allows to: * Define own interfaces wit unique IDs (GUID) * Define implementation classes * Query interface support by the class instance * Export implementation from module * Export classes with non-intrusive reference counting * Create implementation instances on-the-stack inside the module who provides them * Support different allocation policies for exported classes * Simplify reference counting by usage of smart pointers h4. Extension manager Extension management module allows to organize project into a plug-in-based system, where nearly any part of the system is a plug-in. The common tasks of this module are: * Allow modules to define extension points (where they can be extended by other modules) * Allow modules to extend specified extension points (own or other modules') * Create extension graph of the program at start-up * Manage lifetimes of the modules * Support lazy loading of modules via creation indirection * Provide environment access to the modules h4. Debugging library This module provides multiple utilities for programmers to analyze program behavior, do defensive programming, inspect crashes etc. Main utilities are: * Assertions (SuperAssert style) * Call stack generation * Minidump generation * Exception interception (maybe some RTTI to translate exception names) h4. Logging module Features: * Adjustable log details (both at compile-time and runtime) * Log listeners (for console output etc.) * Thread safety h4. FileSystem module Cross-platform file system access library. Features: * Object model of file system * Seamless support of archives * Thread-safe * Asynchronous operation support * Supports Unicode paths h4. Reflection library Reflection (introspection) library allows to add meta-info about any class and use it at run-time. It is also used in script binding generation, to expose classes to script. Features: * Non-intrusive (will allow to add reflection to third-party libraries) * Simple way to expose class members, methods, and accessors * Support of generic method invocation (like in C#, using an array of parameters) * Events h4. Script bindings generator This module allows to dynamically expose C++ types with reflection to the script language. This is very useful, because most of the not performance critical logic can bee easily scripted and will not require a recompilation on change. Currently, bindings are implemented for Python. Using Python bindings generator, user can inherit C++ class in Python, override its methods etc. Bindings work both ways, this means that C++ side can operate on Python objects, call functions and modify variables. Stackless Python offers micro-threading solution to be used by the application. h4. Unicode library Unicode module can be a wrapped third-party solution (like ICU from IBM). It should provide: * Unicode strings (for a specified encoding type) * Conversions between formats * TBD h4. Threading library May be wait for C++0X ?? * Task creation and scheduling * Atomic operations * Barriers * Synchronization primitives h4. Platform library This library contains all needed to identify platform and compiler. Means to identify PC configuration, installed software etc. h4. Serialization library Serialization can be useful in lots of places. Primarily it can be used to save objects' states to the disk and load them afterward. It is also useful in networking, when forming some XML or other requests. h2. License Sekai Framework is _dual-licensed_ under GPL v.3.0 and commercial license. See LICENSE file for details. h2. Contacts If you have any questions - mail me: Sergey Mikhtonyuk - mikhtonyuk@gmail.com
本源码包内暂不包含可直接显示的源代码文件，请下载源码包。
