From 8e250839f46115b8f29d189db623710d41def628 Mon Sep 17 00:00:00 2001 From: Ichthyostega Date: Sat, 28 Feb 2026 22:55:09 +0100 Subject: [PATCH] Application: Adjustments to the Layer structure MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit During the last months, a lot of gradual changes to policies and guidelines had been finalised and documented. Moreover, recent clarifications regarding memory management in the render engine will lead to a clearer definition of the »Vault« Layer's role, with some ''engine code'' expected to move down. On this occasion, I reworked relevant sections in the documentation to confirm the role that now falls to central parts of the overall architecture. Notably I decided to rename those parts related to the application backbone as »Vessel« — to underpin the more active and defining role they assumed. --- doc/design/application/ApplicationStart.txt | 94 ++++----- doc/design/application/Config.txt | 74 ++++++- doc/design/application/index.txt | 48 ++++- doc/design/application/plugin_loader.txt | 5 - doc/design/architecture/Subsystems.txt | 6 +- .../PluginBrainstorm.txt | 0 .../PluginVersioning.txt | 0 doc/design/extension/index.txt | 19 ++ doc/design/index.txt | 53 ++--- doc/design/lowlevel/index.txt | 30 ++- doc/design/plugins/index.txt | 4 - doc/index.txt | 14 +- doc/technical/build/SCons.txt | 2 +- doc/technical/code/LinkingStructure.txt | 4 +- doc/technical/index.txt | 26 +-- doc/technical/infra/TestSupport.txt | 28 +-- doc/technical/library/index.txt | 87 ++++++--- doc/technical/overview.txt | 136 +++++++++---- doc/technical/stage/index.txt | 2 +- doc/technical/steam/index.txt | 41 ++-- doc/user/intro/intro.txt | 52 +++-- src/SConscript | 14 +- src/common/DIR_INFO | 1 - src/include/gui-notification-facade.h | 2 +- src/include/{lifecycle.h => lifecycle.hpp} | 36 +--- src/include/session-command-facade.h | 2 +- src/lib/error-exception.cpp | 5 +- src/lib/format-obj.cpp | 1 + src/lib/lifecycle.cpp | 34 +--- src/lib/lifecycleregistry.hpp | 16 +- src/lib/meta/generator.hpp | 2 +- src/lib/nobug-init.cpp | 2 +- src/lib/nobug-init.hpp | 6 +- src/lib/sync.hpp | 2 +- src/lumiera/main.cpp | 28 +-- src/stage/config-keys.cpp | 4 +- src/stage/config-keys.hpp | 12 +- src/stage/ctrl/demo-controller.cpp | 4 +- src/stage/ctrl/demo-controller.hpp | 4 +- src/stage/gtk-base.hpp | 8 +- src/stage/gtk-lumiera.cpp | 12 +- src/stage/guifacade.hpp | 12 +- src/stage/notification-service.cpp | 2 +- src/stage/notification-service.hpp | 8 +- src/stage/output/displayer.cpp | 2 +- src/stage/output/displayer.hpp | 4 +- src/stage/output/pixbuf-displayer.hpp | 2 +- src/stage/output/xv-displayer.hpp | 2 +- src/stage/timeline/body-canvas-widget.cpp | 6 +- src/stage/timeline/timeline-layout.cpp | 2 +- src/stage/widget/video-display-widget.hpp | 2 +- src/stage/workspace/ui-style.cpp | 2 +- src/stage/workspace/ui-style.hpp | 6 +- src/steam/asset/meta/time-grid.cpp | 4 +- src/steam/asset/pipe.hpp | 4 +- src/steam/asset/struct-factory-impl.hpp | 6 +- src/steam/asset/struct.cpp | 4 +- src/steam/asset/struct.hpp | 4 +- src/steam/asset/typed-id.hpp | 2 +- src/steam/config-resolver.cpp | 12 +- src/steam/config-resolver.hpp | 8 +- src/steam/control/command-setup.cpp | 6 +- .../session-command-interface-proxy.cpp | 6 +- src/steam/control/session-command-service.cpp | 2 +- src/steam/control/session-command-service.hpp | 8 +- src/steam/control/steam-dispatcher.hpp | 4 +- src/steam/control/stypemanager.cpp | 13 +- src/steam/control/stypemanager.hpp | 18 +- src/steam/control/styperegistry.hpp | 4 +- src/steam/engine/calc-stream.hpp | 8 +- src/steam/engine/engine-diagnostics.hpp | 8 +- src/steam/engine/engine-service.cpp | 2 +- src/steam/engine/engine-service.hpp | 8 +- .../engine/worker/dummy-image-generator.cpp | 14 +- .../engine/worker/dummy-image-generator.hpp | 4 +- src/steam/external/libgavl.cpp | 2 +- src/steam/facade.cpp | 8 +- src/steam/facade.hpp | 10 +- src/steam/mobject/builder/operationpoint.cpp | 2 +- src/steam/mobject/builder/operationpoint.hpp | 2 +- src/steam/mobject/output-designation.cpp | 13 +- src/steam/mobject/output-mapping.hpp | 4 +- src/steam/mobject/session.hpp | 4 +- .../mobject/session/lifecycle-advisor.hpp | 6 +- src/steam/mobject/session/mobjectfactory.cpp | 4 +- src/steam/mobject/session/mobjectfactory.hpp | 4 +- .../placement-index-query-resolver.cpp | 10 +- .../placement-index-query-resolver.hpp | 8 +- .../session/query/fake-configrules.cpp | 2 +- .../session/query/fake-configrules.hpp | 10 +- src/steam/mobject/session/root.cpp | 4 +- src/steam/mobject/session/root.hpp | 6 +- src/steam/mobject/session/scope-locator.hpp | 2 +- src/steam/mobject/session/scope-query.hpp | 6 +- src/steam/mobject/session/scope.cpp | 4 +- .../mobject/session/sess-manager-impl.cpp | 6 +- .../session/session-interface-modules.hpp | 4 +- .../session/session-service-explore-scope.hpp | 4 +- src/steam/mobject/session/session.cpp | 2 +- .../session/specific-contents-query.hpp | 4 +- src/steam/play/output-director.hpp | 11 +- src/steam/play/play-controller.cpp | 12 +- src/steam/play/play-controller.hpp | 60 ------ src/steam/play/play-process.cpp | 2 +- src/steam/play/play-process.hpp | 11 +- src/steam/play/play-service.cpp | 27 +-- src/steam/play/play-service.hpp | 11 +- src/steam/play/render-configurator.cpp | 1 - src/steam/play/render-configurator.hpp | 5 +- src/steam/play/sound/jack-output.hpp | 4 +- src/steam/streamtype.hpp | 8 +- src/vault/enginefacade.cpp | 7 +- src/vault/enginefacade.hpp | 6 +- src/vault/netnodefacade.cpp | 7 +- src/vault/netnodefacade.hpp | 6 +- src/vault/scriptrunnerfacade.cpp | 7 +- src/vault/scriptrunnerfacade.hpp | 6 +- src/vessel/DIR_INFO | 1 + src/{common => vessel}/advice.hpp | 12 +- src/{common => vessel}/advice/advice.cpp | 8 +- src/{common => vessel}/advice/binding.cpp | 6 +- src/{common => vessel}/advice/binding.hpp | 10 +- src/{common => vessel}/advice/index.hpp | 27 +-- src/{common => vessel}/basic-setup.cpp | 9 +- src/{common => vessel}/basic-setup.hpp | 19 +- src/{common => vessel}/config-interface.c | 6 +- src/{common => vessel}/config-interface.h | 2 +- src/{common => vessel}/config-lookup.c | 4 +- src/{common => vessel}/config-lookup.h | 2 +- src/{common => vessel}/config-rules.hpp | 27 +-- src/{common => vessel}/config-typed.c | 2 +- src/{common => vessel}/config-wordlist.c | 2 +- src/{common => vessel}/config.c | 2 +- src/{common => vessel}/config.h | 6 +- src/{common => vessel}/configentry.c | 2 +- src/{common => vessel}/configentry.h | 2 +- src/{common => vessel}/configfacade.cpp | 22 ++- src/{common => vessel}/configitem.c | 6 +- src/{common => vessel}/configitem.h | 2 +- src/{common => vessel}/guifacade.cpp | 18 +- src/{common => vessel}/instancehandle.hpp | 16 +- .../integration/common-services.cpp | 4 +- src/{common => vessel}/interface-descriptor.h | 2 +- src/{common => vessel}/interface.c | 6 +- src/{common => vessel}/interface.h | 0 src/{common => vessel}/interfaceregistry.c | 4 +- src/{common => vessel}/interfaceregistry.h | 4 +- .../notification-interface-proxy.cpp | 6 +- src/{common => vessel}/option.cpp | 6 +- src/{common => vessel}/option.hpp | 14 +- src/{common => vessel}/plugin-dynlib.c | 2 +- src/{common => vessel}/plugin.c | 8 +- src/{common => vessel}/plugin.h | 2 +- src/{common => vessel}/query.hpp | 16 +- src/{common => vessel}/query/config-rules.cpp | 11 +- .../query/defs-manager-impl.hpp | 30 ++- src/{common => vessel}/query/defs-manager.hpp | 18 +- .../query/defs-registry.hpp | 12 +- .../query/query-resolver.cpp | 6 +- .../query/query-resolver.hpp | 12 +- src/{include => vessel/spine}/config-facade.h | 19 +- .../spine}/display-handles.hpp | 14 +- .../spine}/interfaceproxy.hpp | 19 +- src/{include => vessel/spine}/play-facade.hpp | 8 +- src/{common => vessel}/subsys.cpp | 8 +- src/{common => vessel}/subsys.hpp | 24 +-- src/{common => vessel}/subsystem-runner.hpp | 23 +-- src/{common => vessel}/ui-protocol.cpp | 0 .../appstate.cpp => vessel/voyage.cpp} | 50 ++--- .../appstate.hpp => vessel/voyage.hpp} | 44 ++--- tests/SConscript | 6 +- tests/basics/stream-type-lifecycle-test.cpp | 4 +- tests/basics/visitingtool-concept.cpp | 4 +- tests/core/steam/asset/basicpipetest.cpp | 4 +- tests/core/steam/asset/typed-id-test.cpp | 2 +- .../core/steam/control/command-use2-test.cpp | 2 +- .../control/session-command-function-test.cpp | 2 +- .../fixture/fixture-change-detector-test.cpp | 4 +- .../fixture/model-port-registry-test.cpp | 4 +- .../fixture/segmentation-integration-test.cpp | 4 +- .../session/defs-manager-impl-test.cpp | 10 +- .../mobject/session/defs-manager-test.cpp | 4 +- .../session/defs-registry-impl-test.cpp | 12 +- .../session/placement-index-query-test.cpp | 4 +- .../mobject/session/query-resolver-test.cpp | 8 +- .../session/session-element-tracker-test.cpp | 4 +- .../session/session-modify-parts-test.cpp | 4 +- .../timeline-sequence-handling-test.cpp | 4 +- .../steam/play/diagnostic-output-slot.hpp | 4 +- .../core/steam/play/dummy-builder-context.hpp | 4 +- .../steam/play/dummy-play-connection-test.cpp | 4 +- .../core/steam/play/dummy-play-connection.hpp | 1 - .../steam/play/timing-constraints-test.cpp | 9 - .../vessel}/advice/advice-basics-test.cpp | 6 +- .../advice/advice-binding-pattern-test.cpp | 6 +- .../advice/advice-configuration-test.cpp | 6 +- .../vessel}/advice/advice-index-test.cpp | 6 +- .../advice/advice-multiplicity-test.cpp | 6 +- .../vessel}/advice/advice-situations-test.cpp | 6 +- .../subsystem-runner-test.cpp | 25 +-- .../test-configloader.c | 4 +- .../{application => vessel}/test-interfaces.c | 10 +- tests/include/interface/say-hello.h | 2 +- tests/library/app-config-test.cpp | 16 +- tests/library/life-cycle-test.cpp | 8 +- tests/plugin/test-c-plugin/example-plugin.c | 4 +- .../plugin/test-cpp-plugin/example-plugin.cpp | 8 +- tests/testrunner.cpp | 8 +- wiki/thinkPad.ichthyo.mm | 184 +++++++++++++++++- 209 files changed, 1354 insertions(+), 1085 deletions(-) delete mode 100644 doc/design/application/plugin_loader.txt rename doc/design/{plugins => extension}/PluginBrainstorm.txt (100%) rename doc/design/{plugins => extension}/PluginVersioning.txt (100%) create mode 100644 doc/design/extension/index.txt delete mode 100644 doc/design/plugins/index.txt delete mode 100644 src/common/DIR_INFO rename src/include/{lifecycle.h => lifecycle.hpp} (79%) delete mode 100644 src/steam/play/play-controller.hpp create mode 100644 src/vessel/DIR_INFO rename src/{common => vessel}/advice.hpp (99%) rename src/{common => vessel}/advice/advice.cpp (99%) rename src/{common => vessel}/advice/binding.cpp (98%) rename src/{common => vessel}/advice/binding.hpp (98%) rename src/{common => vessel}/advice/index.hpp (97%) rename src/{common => vessel}/basic-setup.cpp (97%) rename src/{common => vessel}/basic-setup.hpp (92%) rename src/{common => vessel}/config-interface.c (98%) rename src/{common => vessel}/config-interface.h (99%) rename src/{common => vessel}/config-lookup.c (99%) rename src/{common => vessel}/config-lookup.h (99%) rename src/{common => vessel}/config-rules.hpp (95%) rename src/{common => vessel}/config-typed.c (99%) rename src/{common => vessel}/config-wordlist.c (99%) rename src/{common => vessel}/config.c (99%) rename src/{common => vessel}/config.h (98%) rename src/{common => vessel}/configentry.c (97%) rename src/{common => vessel}/configentry.h (97%) rename src/{common => vessel}/configfacade.cpp (89%) rename src/{common => vessel}/configitem.c (99%) rename src/{common => vessel}/configitem.h (98%) rename src/{common => vessel}/guifacade.cpp (93%) rename src/{common => vessel}/instancehandle.hpp (96%) rename src/{common => vessel}/integration/common-services.cpp (98%) rename src/{common => vessel}/interface-descriptor.h (99%) rename src/{common => vessel}/interface.c (99%) rename src/{common => vessel}/interface.h (100%) rename src/{common => vessel}/interfaceregistry.c (99%) rename src/{common => vessel}/interfaceregistry.h (98%) rename src/{common => vessel}/notification-interface-proxy.cpp (96%) rename src/{common => vessel}/option.cpp (98%) rename src/{common => vessel}/option.hpp (94%) rename src/{common => vessel}/plugin-dynlib.c (98%) rename src/{common => vessel}/plugin.c (98%) rename src/{common => vessel}/plugin.h (99%) rename src/{common => vessel}/query.hpp (98%) rename src/{common => vessel}/query/config-rules.cpp (90%) rename src/{common => vessel}/query/defs-manager-impl.hpp (83%) rename src/{common => vessel}/query/defs-manager.hpp (96%) rename src/{common => vessel}/query/defs-registry.hpp (98%) rename src/{common => vessel}/query/query-resolver.cpp (97%) rename src/{common => vessel}/query/query-resolver.hpp (96%) rename src/{include => vessel/spine}/config-facade.h (86%) rename src/{include => vessel/spine}/display-handles.hpp (82%) rename src/{include => vessel/spine}/interfaceproxy.hpp (94%) rename src/{include => vessel/spine}/play-facade.hpp (98%) rename src/{common => vessel}/subsys.cpp (91%) rename src/{common => vessel}/subsys.hpp (87%) rename src/{common => vessel}/subsystem-runner.hpp (93%) rename src/{common => vessel}/ui-protocol.cpp (100%) rename src/{common/appstate.cpp => vessel/voyage.cpp} (84%) rename src/{common/appstate.hpp => vessel/voyage.hpp} (79%) rename tests/{library => core/vessel}/advice/advice-basics-test.cpp (98%) rename tests/{library => core/vessel}/advice/advice-binding-pattern-test.cpp (98%) rename tests/{library => core/vessel}/advice/advice-configuration-test.cpp (97%) rename tests/{library => core/vessel}/advice/advice-index-test.cpp (99%) rename tests/{library => core/vessel}/advice/advice-multiplicity-test.cpp (98%) rename tests/{library => core/vessel}/advice/advice-situations-test.cpp (97%) rename tests/core/{application => vessel}/subsystem-runner-test.cpp (97%) rename tests/core/{application => vessel}/test-configloader.c (99%) rename tests/core/{application => vessel}/test-interfaces.c (99%) diff --git a/doc/design/application/ApplicationStart.txt b/doc/design/application/ApplicationStart.txt index a460039e4..2eaa6bccf 100644 --- a/doc/design/application/ApplicationStart.txt +++ b/doc/design/application/ApplicationStart.txt @@ -1,42 +1,47 @@ -The Application : Start-up and Subsystems -========================================= +Application : Start-up and Subsystems +===================================== :Date: 2009 :Author: Ichthyo //MENU: label Start-up .the purpose of »Application-main« -Lumiera is envisioned as a heavyweight yet coherent »**Application**« -- not so much -as platform, framework or operating system. And, in accordance with this focus, we -place no emphasis on possible configuration changes and state transitions within -the running application _as a whole._ And, while in fact it is possible to close -and load a new Session, most of the time we assume the application just to be -``up and running'' -- all required services to be available and interfaces to -be accessible. Without doubt, these are simplifications, but serve us well -to cut down complexity -- yet still there needs to be one dedicated realm -to deal with these specific concerns of configuration, dependency and lifecyle. +Lumiera is envisaged as a heavyweight yet coherent »**Application**« -- which implies +it is not so much seen as ``a platform'', framework or operating system. And, in line +with this understanding, we place no emphasis on possible configuration changes and state +transitions within the running application _as a whole._ The ability to react ``life'' to +some global setting changes can be limited to relevant special cases. And, while it is +indeed possible to close and load a new Session from a running application instance, in +most parts of the code base we assume the application just to be ``up and running'' -- all +required services are assumed to be available and interfaces to be accessible. If some of +these assumptions break, an exception is raised and the application unwinds. +Without doubt, these decisions represent a forcible simplification, and might be limiting +at times, yet serve us well to cut down complexity in large parts of the code base -- +however, there needs to be _one dedicated realm_ to deal with all these specific concerns +related to configuration, interdependency and lifecyle. -The Application Realm ---------------------- -So we treat all these concerns within a small and self contained structure, clearly -set apart from all the other layers, services and subsystems. This dedicated -_Application Realm_ is organised around the ``Application main object''.footnote:[ -This is the singleton `lumiera::AppState`, which is triggered by the `main` function -of the Lumiera Application. The sourcecode is kept in a separate folder 'src/common' -and linked into the shared library 'liblumieracommon.so'] -It serves the purpose of pulling up and tearing down the application in a controlled -fashion. And additionally, it provides the Interface and Config core services. -The act of building or tearing down this core realm and main object is what creates -the *Lifecycle* of the application. This is a succession of ``lifecycle phases'' -- -and almost all activities happen within the _operational phase,_ when everything -is ``up and running'' or ``just available''. +The Vessel +---------- +So we treat all these concerns within a small and self contained structure, called the +»**Vessel**«, and clearly set apart from all the other layers, services and subsystems. +This dedicated _Application Realm_ is organised around the ``Application main object''.footnote:[ + This is the singleton `vessel::Voyage`, which is triggered by the `main` function + of the Lumiera Application. The sourcecode is kept in a separate folder 'src/vessel' + and linked into the shared library 'liblumieravessel.so'] +Its purpose is to bootstrap and tear-down the application in a controlled way, +which includes to provide the backbone services, evaluate the start-up parameters +and to connect and start the necessary core components. The beginning and end of +this vessel's voyage therefore marks the *Lifecycle* of the application, as a +succession of ``lifecycle phases'' -- where almost any activity happens within +the _operational phase,_ when everything is considered ``up and running''. Subsystems ~~~~~~~~~~ -However, initially the application needs to be brought up, and at the end, all -parts need to be unwound cleanly. To organise this process, we identify a limited -number of *Subsystems* within the Application, which are more or less independent. +However, before becoming operational, the application must be bootstrapped, and at the end, +all parts need to be unwound cleanly. To organise this process, we identify a limited number +of *Subsystems* within the Application, which are self-sufficient and operate independently, +at least to some degree. Each link:{ldoc}/design/architecture/Subsystems.html[Subsystem] is self contained and groups some other parts and services, which typically work together and may be mutually dependent. These subsystems represent a grouping, applied for the purpose @@ -61,7 +66,7 @@ the startup phase. It is the responsibility of the _Application main object_ to pull up required functionality, which in turn might result in pulling up further subsystems as dependencies. -Subsystems are defined by implementing the interface `lumiera::Subsys`, which acts +Subsystems are defined by implementing the interface `vessel::Subsys`, which acts as façade to conduct the lifecycle, find out about dependencies and shut down the subsystem in the end. So this interface, together with the _Subsystem Runner,_ define a lifecycle protocol; each subsystem is free to implement this as it @@ -97,20 +102,21 @@ within the engine independently, relying on worker jobs and a thread pool. Initialisation and Lifecycle ---------------------------- -After some discussion,footnote:[See the -link:{rfc}/GlobalInitialization.html[GlobalInitialisation] RfC -from spring 2008. In the beginning, we all agreed to ``keep matters simple'' -and build an `init()` function within one central piece of code everyone knows -and hooks into. However, while the outline of the application emerged, there -was a tension between the concern about _over-engineering_ versus the concern -about _tangled and unmanageable complexity._ At some point, an alternative -implementation based on lifecycle callbacks was elaborated, which then turned -into the solution described here. Lumiera then ceased to be the typical UI -application started by GTK, and the existing GTK code was retrofitted to -launch from within a plug-in.] +After some discussion,footnote:[ + See the link:{rfc}/GlobalInitialization.html[GlobalInitialisation] RfC + from spring 2008. In the beginning, we all agreed to ``keep matters simple'' + and build an `init()` function within one central piece of code everyone knows + and hooks into. However, while the outline of the application emerged, there + was a tension between the concern about _over-engineering_ versus the concern + about _tangled and unmanageable complexity._ At some point, an alternative + implementation based on lifecycle callbacks was elaborated, which then turned + into the solution described here. At that point, Lumiera ceased to be the + typical UI based application started-up by GTK-main, and the existing GTK + code was retrofitted to be launched from within a plug-in. +] the design leaned toward loosely coupled parts and a formal lifecycle; which saves us from investigating and coding up the various interdependencies -explicitly. Rather, the parts of the application have to comply to +explicitly. Rather, all parts of the application have to comply to link:{ldoc}/design/architecture/Subsystems.html#lifecycle[Lifecycle Phases], and each part has to care for its own state transitions, invoked through _lifecycle callbacks._ We can distinguish two distinct models how to deal @@ -128,9 +134,9 @@ Application Start ~~~~~~~~~~~~~~~~~ * some fundamental language-level facilities will be prepared during _static initialisation._ At some point, execution enters `main(argc,arvv)`. - * `AppState::init()` brings up the plugin loader and opens the config-interface. + * `Voyage::init()` brings up the plugin loader and opens the config-interface. * ...followed by triggering *ON_GLOBAL_INIT* - * the main thread then pulls up the subsystems (`AppState::maybeStart(subsystem)`), + * the main thread then pulls up the subsystems (`Voyage::maybeStart(subsystem)`), according to the command line options. * within each subsystem, façade interfaces will be opened through the interface/plug-in system. @@ -142,7 +148,7 @@ Application Start the main window. * there is an *ON_GLOBAL_SHUTDOWN* event, which can be used for normal cleanup; In case of an emergency exit, the *ON_EMERGENCY_EXIT* event is triggered alternatively. - * the AppState destructor tears down the core systems (config-interface and pluginloader). + * the Voyage destructor tears down the core systems (config-interface and pluginloader). * we establish a policy to _prohibit any non-local and non-trivial activities_ during the tear-down phase after leaving the `main()` function. diff --git a/doc/design/application/Config.txt b/doc/design/application/Config.txt index dec73272b..631c2362c 100644 --- a/doc/design/application/Config.txt +++ b/doc/design/application/Config.txt @@ -1,15 +1,71 @@ -Lumiera Design: Application and Session Configuration -===================================================== +Application and Session Configuration +===================================== -*TODO* : 'write design document' +.After initial discussion, this topic was postponed. +[CAUTION] +In its current form, as of 2026, the Lumiera application is headed towards a first +integration of the parts developed thus far. A simple configuration file, 'setup.ini' +is used to supply some minimal parameters for bootstrap of the application; all further +settings are defined as local constants in the source code. -The Lumiera application uses two quite different sources for configuration +**Configuration and Parametrisation** of software describe a state of setting, that lies +between the fixed structure embodied into the code and the transient work state of the +application. It encompasses all settings and options that determine how a software system +behaves in a specific environment, without changing its underlying source code. -- individual __settings values__ can be loaded from an application- and user configuration in the conventional way -- various facilities, especially in the Steam-Layer, base the actual behavour on __queries__, which are - to be resolve employing a rules based system '(planned)'. Configuration rules will be provided by the - application (defaults), a session template and rules stored in the actual session. +The purpose of configuration +---------------------------- +For a video editing application, the scope of ``configuration'' can be far reaching. +Not only are there numerous parameters in the engine, that must be fine-tuned for optimal +performance, but also several patterns of behaviour are available that can not be decided by +first principle alone and must thus be left open for the user to configure to their preference. +Some of these are linked to the actual user, some to the setup in the system, and some to the +current project. +Furthermore, many of these ``settings'' turn out, upon closer inspection, to be a form of +rule-based knowledge. In a project with the scale of a movie, it is essential for a fluid +and intuitive working style to handle some default setup and configuration of connections +and conversions automatically, while the user can have very valid reasons to prohibit +some other specific class of automatic conversions to be applied without explicit confirmation. --> see also the link:rfc/ConfigLoaderDraft2008.html[Config Loader brainstorming from 2008] (implementation details) +After some initial, prototyping for a ``config loader'', it was deemed too risky to engage +into any kind of preliminary design without knowing the possible ramifications. + +-> link:/x/rfc/ConfigLoaderDraft2008.html[Config Loader brainstorming from 2008] +The following preliminary measures have now been established for the ongoing development: +- whenever a _tweaking parameter_ is discovered, it will be extracted and marked + with a **language constant** in the setup or integration header of the software component. +- whenever a _decision point_ is encountered, that can not be related to technical dependencies, + it is marked as a **query call** -- with a corresponding, hard-wired _faked configuration rule_. + +The integration of some kind of configuration rule language is considered part of the primary agenda. + +Requirements +------------ +To track any insights gained regarding the requirements for configuration, +https://issues.lumiera.org/ticket/1224[Ticket #1224 (»Layered Configuration«)] +was added to the list of medium-term +https://issues.lumiera.org/report/17[»Focus Topics«] + +The following requirements have been identified to date (2026) + +- It is pointless to build one huge flat global "configuration file"; + rather, groups of configuration settings are scoped and closely related to a _local context_ +- the degree of _consistency checking_ must be tied to such a local context, where the + situation is reasonably clear: the consumer of specific configuration usually has + clear-cut requirements to demand some configuration to be mandatory, while other + configuration is optional. Misspelled or misplaced configuration that does not + fit in such a category must be flagged as error. +- such a locally defined set of expected and optional configuration might become + subject to versioning (forward- / backward compatibility) +- Configuration must be assembled from several configuration sources, + with clearly defined precedence and shadowing. Notably we have default configuration, + system-wide configuration, user specific configuration and project related configuration. +- a _preferences UI_ must be able to alter configuration settings, thereby intelligently + routing the changes into the appropriate configuration source or create a suitable overlay +- when configuration causes a decision from a rule to flip, this fact must be recorded + permanently in the session; the reason for this mechanism is that configuration might + change later, and the application must be able then to point out all places + affected by the change. +- Any detected configuration change must be captured and logged as Event and thus + be un-doable cleanly, with all possible ripple effects. diff --git a/doc/design/application/index.txt b/doc/design/application/index.txt index 11b8b02d5..a99ee7e66 100644 --- a/doc/design/application/index.txt +++ b/doc/design/application/index.txt @@ -1,10 +1,48 @@ -Design Documents: Application Framework -======================================= +The Application Realm +===================== // Menu : prepend child ApplicationStart - * link:Config.html[Configuration] - * link:plugin_loader.html[Plugin Loader] - * link:ApplicationStart.html[Application Subsystems and Lifecycle] +Shaping the outside world through software requires a variety of effective mechanisms +that capture, represent, and transform elements of reality. A well-designed part is +focused on a single aspect, is coherent and cohesive in itself, with links to other +parts based on concepts and abstraction rather then on shared technology. Yet this +structural perspective must be complemented by a meaningful overall arrangement that +supports the desired workflow and can be adapted to circumstances. +In software systems, such coherency does not emerge spontaneously. It must be supported +by definition work to establish suitable terms and interfaces, components must be +interconnected and configured, and the overall state needs coordination. +An application is therefore more than just a collection of software components. +In the Lumiera Architecture, this application realm is embodied into a structure +called the »**Vessel**«: + +- it is built as a library with only basic linkage to the support library +- it can be invoked from a `main()` function, with an argument parser +- at source code level, it provides all the types and definitions + required to express the _binding_ between components +- _conceptually,_ all layers are encased in the application Vessel +- and while the Vessel can not just ``control'' the configuration of parts + on upper layers, it has to bootstrap their ability to adapt to circumstances. + +-- +  +-- + +Dependencies:: + While the code base is organised into _three layers,_ the actual implementation + structures are arranged into **Subsystems** that _depend_ on each other and + can be _started and shut down_ ++ +-> link:ApplicationStart.html[Subsystems and Lifecycle] + +Configuration:: + As a means to adapt to the environment and enable flexibility, + this topic is surprisingly intricate and development has barely scratched + the surface: while the effective configuration is assembled from several + layered sources, the meaning (and documentation) of individual settings + is scoped, and users can expect the ability to override some settings + from within the application. ++ +-> link:Config.html[Configuration] diff --git a/doc/design/application/plugin_loader.txt b/doc/design/application/plugin_loader.txt deleted file mode 100644 index a0e2d9a1a..000000000 --- a/doc/design/application/plugin_loader.txt +++ /dev/null @@ -1,5 +0,0 @@ -Lumiera Design: Plugin system -============================= - -Eventually, this will have design documentation for the Plugin system. - diff --git a/doc/design/architecture/Subsystems.txt b/doc/design/architecture/Subsystems.txt index 67406f860..74e276d25 100644 --- a/doc/design/architecture/Subsystems.txt +++ b/doc/design/architecture/Subsystems.txt @@ -237,7 +237,7 @@ Lifecycle Events The Application as a whole conducts a well defined lifecycle; whenever transitioning to the next phase, a _Lifecycle Event_ is issued. Components may register a notification hook with the central _Lifecycle Manager_ (see 'include/lifecycle.h') to be invoked whenever a specific event is emitted. The process of registration -can be simplified by planting a static variable of type `lumiera::LifecycleHook`. +can be simplified by planting a static variable of type `vessel::LifecycleHook`. WARNING: A callback enrolled this way needs to be callable at the respective point in the lifecycle, otherwise the application will crash. @@ -246,7 +246,7 @@ WARNING: A callback enrolled this way needs to be callable at the respective poi Invoked as early as possible, somewhere in the static initialisation phase prior to entering `main()`. In order to install a callback hook for this event, the client must plant a static variable somewhere. -`AppState`:: +`Voyage`:: This is the Lumiera »Application Object«. It is a singleton, and should be used by `main()` solely. While not a lifecycle event in itself, it serves to bring up some very fundamental application services: + @@ -255,7 +255,7 @@ WARNING: A callback enrolled this way needs to be callable at the respective poi - the application configuration -- + -After starting those services within the `AppState::init()` function, +After starting those services within the `Voyage::init()` function, the event `ON_GLOBAL_INIT` is emitted. `ON_GLOBAL_INIT`:: diff --git a/doc/design/plugins/PluginBrainstorm.txt b/doc/design/extension/PluginBrainstorm.txt similarity index 100% rename from doc/design/plugins/PluginBrainstorm.txt rename to doc/design/extension/PluginBrainstorm.txt diff --git a/doc/design/plugins/PluginVersioning.txt b/doc/design/extension/PluginVersioning.txt similarity index 100% rename from doc/design/plugins/PluginVersioning.txt rename to doc/design/extension/PluginVersioning.txt diff --git a/doc/design/extension/index.txt b/doc/design/extension/index.txt new file mode 100644 index 000000000..4291329a8 --- /dev/null +++ b/doc/design/extension/index.txt @@ -0,0 +1,19 @@ +Extending the Application +========================= + +During the inception phase, the link:/x/rfc/AllPluginInterfacesAreC.html[idea was commended] +to bootstrap the application as a multi-lingual compound of plug-ins, for maximum flexibility +and ease of contribution. Although this approach garnered much support initially, the ensuing +discussions questioned its viability, with well-known plugin-based systems and frameworks +cited as cautionary example. + +A prototype implementation +(-> link:PluginBrainstorm.html[draft for the plugin interface]) +was nevertheless developed, but it proved problematic in practical use. +The goal of a flexibly expandable application is still maintained, +but the path to achieving it should be based on actual requirements. + +Development of an https://issues.lumiera.org/ticket/1212[Extension Concept #1212] +was thus placed on the list of medium-term +https://issues.lumiera.org/report/17[»Focus Topics«] + diff --git a/doc/design/index.txt b/doc/design/index.txt index 9e3d27811..80e513f4a 100644 --- a/doc/design/index.txt +++ b/doc/design/index.txt @@ -7,22 +7,23 @@ Lumiera Design Documents // Menu : prepend child design/gui // Menu : prepend child architecture -// Menu : append child plugins +// Menu : append child extension // Menu : append child workflow // Menu : append child governance -Lumiera is to be a professional tool for video editing on +Lumiera aspires to be a professional tool for video editing on GNU/Linux systems. The vision of the development team defines a modern design for the core of a Non-Linear Editing software. A key aspect of Lumiera is the strong separation between the user interface and the processing core. -We are developing Lumiera with a GTK GUI but that will in no way be exclusive; -other GUIs can be written, as well as scripts to drive the core. +We are developing Lumiera with a general purpose GTK UI -- which is loaded as +an optional component, so that the core can also be invoked from scripts to +use the editing and processing capabilities of the engine. This becomes possible by an ongoing effort to decrease coupling. Each major component in the application strives to be open to extensions, but closed against external modification. The presentation, the model and the ``performing'' -of the model are separate and self-contained parts of the application. Lumiera -as a processing core will be able to perform any conceivable -task on video and audio, maybe even tasks entirely unrelated to video editing. +of the model are separate and self-contained parts of the application. +Lumiera as a processing core will be able to perform any conceivable task +on video and audio, maybe even tasks entirely unrelated to video editing. .Workflow ***************** @@ -52,7 +53,8 @@ specialised GUIs. The interface is the component that is closest to the user. I provides purely visual interaction with the user. Within this work environment, the user manipulates, organizes, loads, configures all sorts of data, especially MObjects (media objects) and Assets. These elements are contained within a structure called the Session. + --> link:gui/index.html[GUI/Stage-Layer design documents] +-> link:gui/index.html[GUI/Stage-Layer design documents] + +-> link:{ldoc}/technical/stage/index.html[GUI technical documentation] Steam: the Transformation Layer @@ -87,24 +89,23 @@ the screen or to external output. + Extra Components ---------------- -The Application -~~~~~~~~~~~~~~~ - -The application controls the initialization and shutdown procedures as well as -loading external elements such as plug-ins, which are widely used throughout -Lumiera. It acts as the framework which supports core component operations. This -framework is complemented by a library of commonly used components, algorithms and data structures. + --> link:application/index.html[Application framework] +The Vessel +~~~~~~~~~~ +A structure that is anchored below all layers, yet contains everything, conceptually. +Definitions for building common interfaces are located here, as is the mechanism for initialisation +and shutdown of the application, the loading of bootstrap configuration and optional components. +It encloses and coordinates all parts to work together as a coherent whole. +This -> link:application/index.html[Application framework] is complemented by +a link:{ldoc}/technical/library/index.html[Support-Lbrary] with commonly used components, +algorithms and data structures. -link:plugins/index.html[Plugins] -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -Plug-ins play an important role within Lumiera since the application relies -heavily on current FLOSS implementations and external libraries. Moreover, the -application will be configurable and can be extended in various -ways; whenever some extension isn't permanent or will be used only on demand, it -is packaged as a separate module into a plug-in. For example, the GUI of Lumiera -is a plugin. + --> design documents regarding the link:plugins/index.html[Plugins] +Extensions +~~~~~~~~~~ +Lumiera uses proven and field-tested implementations for the actual media processing, +which are available as FLOSS or open-source libraries. To avoid extensive external dependencies +on the main application however, such libraries need to be loaded through _adaptor plug-ins._ +Furthermore, the application will be configurable and it is conceivable that external +extensions will be created. Designing and building a future-proof framework for configuration +and extension is an important medium-term goal for further development. diff --git a/doc/design/lowlevel/index.txt b/doc/design/lowlevel/index.txt index e4bf2de20..431e0f3ab 100644 --- a/doc/design/lowlevel/index.txt +++ b/doc/design/lowlevel/index.txt @@ -1,14 +1,30 @@ -Design Documents: Vault -======================= +Low-level Services +================== -What follows is a summary of Lumiera's *Data Handling Backend* +Towards the _upper side_ of the Lumiera core, in »Steam Layer«, +several components and subsystems work together to provide functionality +that is close to the requirements of the _problem domain_ -- editing and +rendering of media. The implementation of these features however requires +a foundation of generic, technical services: Memory needs to be allocated, +working buffers must be provided and managed, work tasks coordinated. +It is hard to associate these responsibilities directly to +some specific domain, other than just _data processing._ -This is the foundation layer responsible for any high performance or high volume -data access. Within Lumiera, there are two main kinds of data handling: +A common trait of all those special aspects of processing is that they +require special care and attention to achieve the necessary level of +performance, while they are _technical_ in nature and do not directly +reflect and model structures of the real world. + +Data Handling +------------- +The task of editing video and processing media requires to read and write +a significant amount of data, while using the capabilities of the hardware +to the best degree possible. Lumiera thus needs a foundation layer for +high volume data access; two kinds of data handling can be distinguished: * The Session and the object models manipulated through the GUI are kept in memory. - They are backed by a _storage backend,_ which provides database-like storage and - especially logging, replaying and ``Undo'' of all ongoing modifications.. + They will be backed by a _storage backend,_ which provides database-like storage + and especially logging, and controlled execution of _mutating actions._ * Media data is handled _frame wise_ -- prefetching data asynchronously. The goal is to optimize CPU utilization; large scale data IO will be performed diff --git a/doc/design/plugins/index.txt b/doc/design/plugins/index.txt deleted file mode 100644 index 6ad7e6138..000000000 --- a/doc/design/plugins/index.txt +++ /dev/null @@ -1,4 +0,0 @@ -Design Documents: Plug-In -========================= - - * link:PluginBrainstorm.html[early draft for the plugin interface] diff --git a/doc/index.txt b/doc/index.txt index 676804e85..0439abeb2 100644 --- a/doc/index.txt +++ b/doc/index.txt @@ -1,7 +1,7 @@ Documentation ============= -This documentation section contains documentation for both users and developers. +This documentation section contains documentation for users and developers alike. == User == @@ -60,8 +60,8 @@ deeper documentation dungeons. At the second layer, the reader must make the first major decision on which router to pursue: documentation with a heavy code based leaning; or more descriptive -documentation on the design of Lumiera which avoids a code narrative. This -section has two main sections: +documentation on the design of Lumiera, which omits most technical details of the implementation. +Consequently, the documentation is divided into two main parts: * link:design/index.html[Lumiera Developer Design Documents] * link:technical/index.html[Lumiera Developer Technical Documents] @@ -75,14 +75,14 @@ section has two main sections: [width="90%",frame="topbot",options="header",cols="^,2<"] |================================================================================================ -|Sub-System|Remarks +|Section|Remarks |link:design/architecture/[Architecture]|Structure of Lumiera |link:design/gui/[GUI]|The Lumiera ⟷ user interaction layer |link:design/model/[Model]|Low-level and high-level models |link:design/engine/[Engine]|Renderer, output generation, ... |link:design/lowlevel/[Low-level]|Low-level and system services |link:design/application/[Application]|Application framework -|link:design/plugins/[Plugins]|Dynamically loaded Extensions +|link:design/extension/[Extension]|Dynamically loaded Extensions |link:design/workflow/[Workflow]|Workflow and Interaction Design |link:design/governance/[Governance]|Meta project concerns |================================================================================================ @@ -93,12 +93,12 @@ section has two main sections: [width="90%",frame="topbot",options="header",cols="^,2<"] |================================================================================================ -|Sub-System|Remarks +|Section|Remarks |link:technical/build/[Build System]|Build, Packaging and CI |link:technical/stage/[Stage]|GUI (technical aspects) |link:technical/steam/[Steam]|Session and processing coordination |link:technical/vault/[Vault]|Low-level operations -|link:technical/library/[Support lib]|Interface and support libraries +|link:technical/library/[Library]|Utilities and custom frameworks |link:technical/code/[Code base]|Code management, organisation, ... |link:technical/infra/[Infrastructure]|Website and developer tooling ... |link:technical/howto/[Developer HowTos]|Instructions and guides for developers diff --git a/doc/technical/build/SCons.txt b/doc/technical/build/SCons.txt index cd4acb7e2..b5e24e1b3 100644 --- a/doc/technical/build/SCons.txt +++ b/doc/technical/build/SCons.txt @@ -352,6 +352,6 @@ shared object (dynamic library), which is then again a SCons target and can be passed to other executable builders as library dependency for compilation and linking. Look into 'src/SConscript' or 'test/SConscript' to see examples of that technique -- which we also use to define that -global compound target variables like `core`, `app_lib`, `core_lib`, +global compound target variables like `core`, `vessel_lib`, `core_lib`, `vault_lib`, and `support_lib`. These in turn are essential for building the layered dependency hierarchy in our code. diff --git a/doc/technical/code/LinkingStructure.txt b/doc/technical/code/LinkingStructure.txt index c1ab3700a..4618afe19 100644 --- a/doc/technical/code/LinkingStructure.txt +++ b/doc/technical/code/LinkingStructure.txt @@ -322,8 +322,8 @@ actively step by step modules of the application will be placed by default . after the core application has been loaded and all direct dependencies are resolved, - but still before entering `main()`, the class `lumiera::AppState` will be initialised, - which in turn holds a member of type `lumiera::BasicSetup`. The latter will figure out + but still before entering `main()`, the class `vessel::Voyage` will be initialised, + which in turn holds a member of type `vessel::BasicSetup`. The latter will figure out the location of the executable footnote:[this is a Linux-only trick, using `/proc/self/exe`] and require a 'setup.ini' file in the same directory. This setup file is mandatory. diff --git a/doc/technical/index.txt b/doc/technical/index.txt index f3ace95bd..9fcd9007e 100644 --- a/doc/technical/index.txt +++ b/doc/technical/index.txt @@ -9,34 +9,34 @@ Technical Documentation // Menu : prepend child overview -This documentation section contains technical documentation about Lumiera. To -get an *overview* of all the internals and components, you might want to read +This documentation section contains technical documentation about Lumiera. + +To get an *overview* of all the internals and components, you might want to read link:overview.html[Lumiera the Inner Core] == Three Layers -The technical documentation is split in three parts, one for each of the three -main layers of Lumiera. You may want to read the -link:{ldoc}/design/index.html[Design Documents] first to get an overview of all the -components. +The technical documentation is divided into three main parts and some supplements, +corresponding to the code organisation in three layers. The information here can be +very detailed and technical at times, and the topics are organised by individual components. * link:stage/index.html[*Stage Layer*] : Documents related to the GTK based Lumiera GUI - -* link:steam/index.html[*Steam Layer*] : Documents regarding Session, models and the engine structure - +* link:steam/index.html[*Steam Layer*] : Documents regarding Session, the models and the engine * link:vault/index.html[*Vault Layer*] : Documents about the data and processing backend +To better understand the underlying concepts, it might be helpful to also consult the +link:{ldoc}/design/index.html[Design Documents]. + == Tools .Development -* link:/doxy/[*Doxygen* generated documentation] : API documentation of the Lumiera code. +* link:/doxy/[*Doxygen*] : API documentation of the Lumiera code. * organisation of the link:code/index.html[Code Base] in general * link:/x/CodingGuidelines.html[Coding Style] and further guidelines .Building -* link:build/index.html[Buildsystem] : Installation & compilation tools, dependencies and packaging. +* link:build/index.html[Buildsystem] : Installation and compilation tools, dependencies and packaging. .HOWTO -* link:/x/DevHowto.html[Developer *HOWTOs*] : Collection of instructions, recipes, hints and similar - materials intended for developers +* link:/x/DevHowto.html[Developer *HOWTOs*] : Collection of instructions, recipes, hints, misdeeds + and confessions and similar helpful resources for developers diff --git a/doc/technical/infra/TestSupport.txt b/doc/technical/infra/TestSupport.txt index ca5146c76..a4350baf7 100644 --- a/doc/technical/infra/TestSupport.txt +++ b/doc/technical/infra/TestSupport.txt @@ -8,30 +8,32 @@ NOTE: This page holds content copied from the old "main" TiddlyWiki + It needs to be reworked, formatted and generally brought into line ******************************************** -.Lumiera relies on *test-driven development* +.Lumiera employs test-driven development This page discusses the overall organisation of test code, and the tools used for running test cases ******************************************** -Tests are the only form of documentation, known to provides some resilience against -becoming outdated. Tests help to focus on the usage, instead of engaging in spurious +Tests are the only known form of documentation that offers some resilience against +getting outdated. Tests help to focus on the usage, instead of engaging in spurious implementation details. Developers are highly encouraged to write the tests _before_ the actual implementation, or at least alongside and interleaved with expanding the feature set of the actual code. + There may be exceptions to this rule. Not every single bit needs to be covered by tests. Some features are highly cross-cutting and exceptionally difficult to cover with tests. -And sometimes, just an abstract specification is a better choice. +Test code must not duplicate the logic of implementation code, it should represent an +abstracted, outside, logical view of the matter at hand. And sometimes it is the better +choice to simply write an abstract specification in understandable language. As a rule of thumb, consider to write test code which is easy to read and understand, _like a narration_ to show off the relevant properties of the test subject. + Test Structure -------------- -- a *test case* is an executable, expected to run without failure, and optionally producing - some verifiable output -- simple test cases may be written as stand-alone application, while the more tightly - integrated test cases can be written as classes within the Lumiera application framework. +- a *test case* is an executable, expected to run without failure; test code not only invokes + a _subject under test_ -- the important part is to _verify_ its behaviour. - test cases should use the +CHECK+ macro of NoBug to verify test results, since the normal assertions may be de-configured for optimised release builds. - our test runner script 'test.sh' provides mechanisms to check for expected output @@ -41,15 +43,13 @@ several functions within the same test fixture. This allows to create a ``narrat in the code: first do this, than do that, and now that, and now this should happen... Generally speaking, it is up to the individual test to take care or isolate himself from any _dependencies_. Test code and application code uses the same mechanisms -for accessing other components within the application. Up to now (2014), there -was no need for any kind of _dependency injection_, nor did we face any -difficulties with tainted state. +for accessing other components within the application. Test classes are organised into a tree closely mirroring the main application source code tree. Large sections of this test tree are linked together into *test libraries*. Some of these are linked against a specific (sub)scope of the application, like e.g. only against the support library, the application framework or the vault. Since we -use _strict dependencies_, this linking step will spot code not being placed at the +use _strict dependencies_, this linking step will also spot code not placed at the correct scope within the whole system. As a final step, the build system creates a *test runner* application (`target/test-suite`), which links dynamically against _all_ the test libraries and thus against all application dependencies. @@ -81,9 +81,9 @@ to help with automating the build and test execution, test code should adhere to - test classes should be placed into a sub namespace +...::test+ - specific definitions for a single test case may rely on global variables, but these should live within an anonymous namespace -- all test executables should be named according to the pattern +test-*+ +- free standing test executables should be named according to the pattern `test-*` - all test source code is within the 'tests' subtree -- immediately within the 'tests/' directory are the test collection definitions +*.tests+, +- immediately within the 'tests/' directory are the test collection definitions `*.tests`, ordered by number prefixes - below are the directories with test cases, to be grouped into the aforementioned test-executables. - we distinguish two ways to write and link tests: _standalone_ and _suite_ diff --git a/doc/technical/library/index.txt b/doc/technical/library/index.txt index 67e0a7946..f15c65b9f 100644 --- a/doc/technical/library/index.txt +++ b/doc/technical/library/index.txt @@ -1,41 +1,70 @@ Library documentation ===================== -//Menu: label Support Lib -Alongside with the core Lumiera Application, we're also creating several *Libraries*. + -This section holds pages with in-depth technical documentation regarding those. Please don't -expect a coherent or complete coverage for the time being -- library functionality is typically -``discovered'' while in the middle of the implementation, then factored out, reused and remoulded -over time. +Alongside with the core Lumiera Application, and as part of ongoing development work, +a lot of *Library code* is written. Many of this happens on occasion. Library solutions +are frequently ``discovered'', while in the middle of the implementation, driven by the +desire to re-use some code structure that was built just recently and in a similar way. + + +Support Library +--------------- +Over time, a huge and growing number of generic building blocks has been collected. +Hoever, not all parts of this collection are equally well maintained and presentable. +It happened time and again that some pattern extracted into the library turned out +to be rather some kind or ephemeral habit -- maybe even a bad habit in hindsight -- +and turned into a dead-end eventually. Furthermore, a lot of our library code has +been superseded by very similar features of newer language standards.footnote:[ + It seems like developers working on similar problems tend to have similar ideas + to improve productivity. Unfortunately, the solutions resulting from this convergence + of ideas have a tendency not to ``converge'' so well in practical terms. + For example, Lumiera had a tuple type a long time before a mature tuple implementation + was available in the Boost libraries, yet in the end, we could retrofit most of our + tuple-handling library. However, other cases did not play out so well: we evolved + the idea of ``iterators'' to become a lazy processing pipeline, but unfortunately + our design leans more into the direction of functional programming and is much + more expressive and powerful as abbreviation than the »Range-TS« from C++20. +] +The entrance barrier for something to be added to our _Support Library_ is rather low: + +- extracting it as a library function _must make the client code clearer_ +- it must be possible to describe its purpose and its usage in _generic terms_ -- + without referring to data types and definitions from our domain models. +- it must be _essentially stateless_ and self-contained +- it must be easy to document with an unit-test. + +Over time, parts of the Support Library have evolved into some kind of a framework: +Notably the link:{ldoc}/design/architecture/time/index.html[time and timecode] handling, +our link:Dependencies.html[dependency and service handling], +the link:DiffFramework.html[»Diff framework«], together with the recursive property trees +used for link:{ldoc}/design/architecture/ETD.html[»External Tree Description«], the +link:iterator.html[iterator pipeline builders], the metaprogramming helpers for transforming +function signatures and generic sequences, and our collection of string conversion, parsing +and rendering functions. These all turned into distinguishing traits of the Lumiera code base. + +The link:{ldoc}/technical/overview.html#_library[»Library« section of the »Overview« document] +contains a long list of short descriptions for relevant features of the Support Library. + + +.how to crack nuts... +[NOTE] +In the how-to section, there is a page with a loose collection of +link:{ldoc}/technical/howto/crackNuts.html[successful solution patterns], +many of which rely on unique features of our Support Lib. + Interface Library ----------------- The Lumiera Application is designed deliberately in a way to be controllable by scripts. All of the Session, the models and the vault are fully operational without the GUI. Any significant -functionality can be addressed through the primary Façade Interfaces. +functionality shall be usable through the primary Façade Interfaces alone. Yet in order to create +such an open and extensible application as envisioned, we also need to build up an _interface layer._ +Eventually, this should evolve into a binding library for using Lumiera -- however, none of this +interface building work has been accomplished yet, as of 2026. We do not even have a complete +picture how _event sourcing_ meshes together with our UI commands and the configuration rules. -But, in order to make such an open and extensible application a reality, we need to build up -an 'interface layer' -- provided as library for client code and script adapters to link against. -This library allows to access the primary external interfaces and exposes everything needed to -work with the specifics of the application. - -[,yellow]#TODO as of 1/2012:# _this is just a nebulous plan for now._ Nothing of the work required -really to address facilities from the outside has been done. All we've managed to achieve is actually -to use clean interfaces and decouple the parts of the application appropriately. - -- we still need to identify those core concepts which need to be exposed +- we still need to identify those select core concepts which need to be exposed - we need to refactor the corresponding data types to resolve cross dependencies to the implementation -- then we could think about moving those data types into an _official Lumiera interface_ - -Support Library ---------------- -There is a huge collection of generic building blocks, re-used more or less frequently. -The're written in a generic way, but in accordance to the rest of the source base, relying only -on the general error handling and logging framework used within Lumiera. (Some facilities may depend -on other parts of the Application; this can be qualified as a bug -- please complain when you've found -something of that sort). - - - +- only then we could think about moving those data types into an _official Lumiera interface_ diff --git a/doc/technical/overview.txt b/doc/technical/overview.txt index a37f5d649..9565c6f9e 100644 --- a/doc/technical/overview.txt +++ b/doc/technical/overview.txt @@ -1,7 +1,7 @@ Lumiera: The Inner Core ======================= :Author: Lumiera_Core_Developers -:Date: 2012 / 2025 +:Date: 2012 / 2026 :toc: [abstract] @@ -30,7 +30,7 @@ This three Layers are: The Steam Layer:: Keeps the Session, generates the rendering graphs for sequences, - arranges what to do when and how. + prearranges elements and decides what to do when and how. The Vault Layer:: Manages worker pools, schedules jobs, does the memory management for the @@ -39,13 +39,11 @@ This three Layers are: The extra components are: - Lumiera:: - The main program itself, which starts all Subsystems and controls the - overall lifecycle. - - Common:: - Vital components and common services which must be available for pulling up - any part of the system. + The Vessel:: + This is the »backbone« of the application, it is rooted below the three + layers and encompasses everything. It defines the periphery, starts all + Subsystems, controls the overall lifecycle and provides vital services + which must be available for engaging any part of the system. Library:: A lot of (largely) stateless helper functionality used throughout the code. @@ -55,9 +53,9 @@ Coding Style ~~~~~~~~~~~~ The Lumiera team agreed on using GNU coding style with slight adaptations. -Generally speaking, we strive to keep the code base consistent and stick to -widely accepted guidelines and best practices. See our separate -link:{ldoc}/technical/code/codingGuidelines.html[Coding Guidelines] page. +In general, we strive to maintain source code consistency and adhere to widely +accepted guidelines and practices of good craftsmanship. See our separate +link:{ldoc}/technical/code/CodingGuidelines.html[Coding Guidelines] page. @@ -148,7 +146,7 @@ contained within the Session, which belongs to the _steam layer_ below. User interfaces are implemented as plug-ins and are pulled up on demand, they won't contain any relevant persistent state beyond presentation. -_As of 2023, the one and only interface under active development is +_As of 2026, the one and only interface under active development is the Lumiera GTK GUI,_ based on GTK-3 / gtkmm. The sources are in tree (directory 'src/stage') and it is integrated into the standard build and installation process. By default, running the 'lumiera' executable will @@ -250,7 +248,7 @@ for each output channel is required. The player service ^^^^^^^^^^^^^^^^^^ -Client code accesses the player (subsystem) through the play-facade (`lumiera::Play`). +Client code accesses the player (subsystem) through the play-facade (`Play`). The exposed service allows to _set up an output connection for playback or rendering,_ resulting in a play-controller object. @@ -285,11 +283,6 @@ performance critical. - the OutputSlot exposed by the output manager is responsible for accepting timed frame delivery - - -Vault Layer ------------ - Engine Interface ~~~~~~~~~~~~~~~~ While on itself just a thin interface and adaptation layer forwarding calls to @@ -318,16 +311,21 @@ the job ticket acts as blueprint for the actual jobs to be enqueued with the _Scheduler._ + +Vault Layer +----------- Scheduler ~~~~~~~~~ The Scheduler serves as the central hub in the implementation of the RenderEngine and coordinates the processing resources of the application. Its purpose is to invoke and control the dependency and time based execution of the _Render Jobs._ -Regarding architecture, the Scheduler is located in the Vault-Layer and running the Scheduler -is equivalent to activating the »Vault Subsystem«. An EngineFaçade acts as entrance point, -providing high-level render services to other parts of the application: render jobs can be -activated under various timing and dependency constraints, which can be grouped +As far as architecture is concerned, the Scheduler is located in the Vault-Layer and +is a _passive service_ -- like most components in the vault it needs to be put into +use by some coordinating and integrating facility. An EngineFaçade, itself located +above, in the »Steam« layer, acts as entrance point, to provide the high-level +render services to other parts of the application: render jobs can be activated +under various timing and dependency constraints, which can be grouped into three basic modes of control: Deadline:: @@ -362,6 +360,29 @@ The scheduler is able to observe and maintain dependencies between render jobs, to break down an extended calculation into a chain of small steps. +The Work Force +~~~~~~~~~~~~~~ +Since the typical work job dimensions can be expected to lie in the range of _some milliseconds,_ +the Lumiera engine can adopt a statistical model of capacity distribution. This is notably +different to an _operating system scheduler_ where the response times are measured in +microseconds and the coordination of work approaches hardware limits. These observations +lead to the (maybe slightly surprising approach) to rely on an _actively pulling_ work force +combined with a _passive scheduling service._ + +The _Work Force_ is a **pool of worker threads** with a size typically matching the nominal +number of independent CPU cores in the system. Spinning up the Work Force is equivalent to +activating the »Vault Subsystem«. Deliberately, there is no dedicated ``engine'' or +``manager'' thread. All workers participate in the coordination work on equal footing. +An idle worker enters the (passive) scheduling code, and thereby performs management +work up to the point where the next render job is determined. The worker then leaves +the management realm and continues with performing this job. However, the scheduling +code preloads each worker with some random sleep delay in order to distribute the +``incidence'' of idle workers and to avoid contention. This way, the available +computing capacity is distributed stochastically into that time window where +demand is foreseeable, based on the next job's starting time, the currently +dispatched jobs and the observed load factor. + + Resource Management ~~~~~~~~~~~~~~~~~~~ @@ -378,12 +399,12 @@ the system and current circumstances. -Common Services ---------------- +Vessel: Common Services +----------------------- Subsystem runner ~~~~~~~~~~~~~~~~ -Conceptually, the application is structured into layers. However, as actual runtime +Conceptually, the application is structured into layers. However, as the actual runtime entities we rely on a small number of link:{ldoc}/design/architecture/Subsystems.html[Subsystems], which can be started and stopped and have well defined dependencies: @@ -418,17 +439,14 @@ link:{ldoc}/design/architecture/Subsystems.html#_lifecycle[documentation] [small]#(likewise incomplete, but we're getting there, eventually [yellow-background]##2018##)# -Plugin loader -~~~~~~~~~~~~~ -_tbw_ Advice framework ~~~~~~~~~~~~~~~~ This is a ``whiteboard'' system, allowing implementation-level services to _publish_ some piece of information as _advice_, while other parts of the system may pick up this advice just by a name token, without requiring a direct knowledge of the -original _advisor._ The _Advice System_ is a singleton service maintaining a -lookup and registration data structure. Individual _piece of advice_ elements +original _advisor._ The _Advice System_ is a singleton service that maintains +a lookup and registration data structure. Individual _piece of advice_ elements are stored _as value copy_. Publishing new advice requires locking, but accessing advice is lock-free (actually there needs to be a memory barrier ``somewhere'', otherwise the advice requesting client might not see new advice) @@ -458,13 +476,27 @@ Library ------- The Lumiera support library contains lots of helper functionality -factored out from the internals and re-used. It is extended as we go. +factored out from the internals and re-used. Some parts evolved into +basic frameworks, that are used pervasively throughout the code base. + + - link:{ldoc}/design/architecture/time/index.html[time and timecode] + (-> xref:_time[below]) + - link:Dependencies.html[dependency and service handling] + (-> xref:_singletons_and_dependencies[below]), + - the link:DiffFramework.html[»Diff framework«] + - property trees for link:{ldoc}/design/architecture/ETD.html[»External Tree Description«] + (-> xref:_external_tree_description[below]) + - the link:iterator.html[iterator pipeline builders] + (-> xref:_iterators[below]) + - various metaprogramming helpers (function signatures and generic sequences) + - string conversion, parsing and rendering functions + practical shortcuts ~~~~~~~~~~~~~~~~~~~ -The header 'lib/util.hpp' defines some shortcuts heavily used throughout -the code base. The idea is to highlight a common semantic meaning, while -hide differentiation on the technical details. +The header 'lib/util.hpp' defines some shortcuts that are used almost +everywhere in the code base. The general idea is to highlight a common semantic meaning, +while hide the differentiation related to the technical details. isnil:: indicate a _missing value_, irrespective if this is a NULL pointer, an empty string or an empty container. Several of our custom wrappers also @@ -473,8 +505,29 @@ isnil:: indicate a _missing value_, irrespective if this is a NULL pointer, contains:: indicate that a value is _somehow contained_ within a collection, irrespective if this is a set, a map, a vector or string (substring test) -sanitise:: make any string usable as identifier. +limited:: to bracket some value. +unConst:: a functional notation to cast away `const`, which is used typically + at the barrier between a type safe front-end and a low-level back-end, + and to avoid needless duplication of accessor code implementation + for sake of providing `const` information functions. + +isSameObject:: identity test based on bare memory location, + which is used a lot in assertions and unit tests + +string shorthands:: + trim, startsWith, endsWith, boolVal, sanitise (turn arbitrary string into an identifier) + + +Literals and Symbols +~~~~~~~~~~~~~~~~~~~~ +Besides the well-known C++ strings (and `string_view`), Lumiera introduces +two marker types for string tokens + +Literal:: a C-string literal directly given in the Source code + +Symbol:: an _interned_ token stored in a Symbol table, so that its + address hash can be used as unique identity Locking @@ -892,6 +945,17 @@ and assignment incur the cost of an additional virtual call, assuming the target objects cooperate by mixing in a copy management interface. +.uninitialised storage +A cornerstone of the C++ language is the deterministic and reliable invocation +of constructors and destructors. However, when building low-level storage schemes, +a frequent requirement is to cover the precise storage of an object collection, +_without_ actually invoking any constructor or destructor. The `UninitialisedStorage` +template is a building block to support this task. It is parametrised with a type +and an element count, and provides a force-casted array-like access to the storage cells. +This can be used either to placement-construct some elements on-demand, or to ``project'' +an object-like view over existing data in the storage. + + Unique Identifiers ~~~~~~~~~~~~~~~~~~ diff --git a/doc/technical/stage/index.txt b/doc/technical/stage/index.txt index ad34a0085..a7252f702 100644 --- a/doc/technical/stage/index.txt +++ b/doc/technical/stage/index.txt @@ -1,5 +1,5 @@ Technical Documentation: Stage Layer ==================================== -Eventually, this will have technical documentation for the GUI. +This section offers a loose collection with detailed information regarding the GUI implementation. diff --git a/doc/technical/steam/index.txt b/doc/technical/steam/index.txt index 56c69524b..c48e8741f 100644 --- a/doc/technical/steam/index.txt +++ b/doc/technical/steam/index.txt @@ -1,27 +1,36 @@ Technical Documentation: Steam-Layer ==================================== -Eventually, this section will hold technical documentation for the Steam-Layer. +As implementation progresses, this section will gradually compile +the technical documentation for the Steam layer. Development Scrapbook TiddlyWiki -------------------------------- -Hermann Voßeler, core developer of the Steam-Layer uses an separate embedded wiki -for his day-to-day design sketches, notes and also for the more persistent planning. -This *TiddlyWiki* is a nifty JavaScript wiki embedded in a single HTML page; as such -it lives right within the source tree, where it can be worked on alongside with the -code. Besides the actual planning and descriptions, this wiki also links to the -UML diagrams created with *BOUML* during the ongoing planning and design. +It is sometimes difficult to write complete documentation while a system is still under construction. +For taking work notes and formulating new ideas while working, _Ichthyostega_ frequently uses the +https://classic.tiddlywiki.com/[TiddlyWiki] -- which is a nifty JavaScript wiki embedded within a +single HTML page; as such it lives right within the source tree, where it can be worked on alongside +with the code. Notes and sketches for the planning often evolve into detailed descriptions, complete +with test data and UML diagrams to document the structure. Material drafted in the TiddlyWiki +will be moved gradually into this documentation section, as time permits. -This setup started as a temporary solution -- but as uWiki is not expected to come -to life soon, the current website can't serve as replacement for a real wiki, an -we'll stick to that situation for the time being. As the content in the TiddlyWiki -becomes more mature and stable, it will be moved over into this section here. +This arrangement started as a temporary solution at a time where we did not have a suitable website +for permanent documentation -- and it was kept ever since, as the TiddlyWiki is very convenient +to work with, once you are accustomed to its quirks.footnote:[ + It is quite fluid and inspiring to work with indeed. The content is an unordered collection + of small notepad pages, called ``Tiddlers'', which can be opened and closed conveniently. + Any "CamelCaseWord" becomes a new Tiddler, recent changes appear in a timeline, and Tiddlers + can be organised with tags. The only point to be careful is that you need to _save_ + your work, which can be achieved with the `save' action in the menu to overwrite + the old version in the Git tree. Sometimes this might produce Git conflicts, + which are easy to resolve, since the content is plain text. +] +Additions to the TiddlyWiki are usually made during coding, and are deliberately committed always +together with the corresponding code. As such, these additions will propagate to Lumiera/Master eventually; +yet to make the newest development notes easier to access, we have put up a `rsync`ed version of the +TiddlyWiki online for direct access over the internet (which then is of course read-only). -While additions to the TiddlyWiki generally propagate to Lumiera/Master through -the normal merges, we've put up a rsynced version of the TiddlyWiki online for -direct access (of course read-only). - --> access the Proy-Layer link:/wiki/renderengine.html[TiddlyWiki online here] +-> access the link:/wiki/renderengine.html[TiddlyWiki online here] diff --git a/doc/user/intro/intro.txt b/doc/user/intro/intro.txt index 3f34822d2..ce9692336 100755 --- a/doc/user/intro/intro.txt +++ b/doc/user/intro/intro.txt @@ -113,8 +113,11 @@ each have a distinct _type_ which explicitly identifies the possible connections modules. Within these constraints, any combination is possible without hidden restrictions. -Lumiera is not a set of Lego bricks, nor is it a business application -driven by finite usage stories. +However, the application strives for a certain degree of internal coherence. + +Lumiera is not a set of Lego bricks allowing you to build ``just anything'' +(in a clumsy way) -- nor is it the next universal programming platform or +application framework driven by finite high-level usage stories, where you +``just push the button'' and magic does the rest. Medium Level Abstraction and Project Specific Conventions @@ -131,9 +134,8 @@ details such as header format conversion or access to individual channels. To complement this approach, Lumiera does _not_ rely on hard-wired, global conventions -- rather we allow the building up of project specific conventions and rules xref:rules[<-] to fit a given requirement and preferred working style. - -Lumiera will be supplied with a conventional template and a default -configuration to ease the learning curve for new users. +However, in its default configuration, Lumiera will be supplied with a conventional +UI template and key bindings to ease the learning curve for new users. [[graphs]] @@ -218,16 +220,15 @@ Lumiera consists of three major parts: In this section, we discuss the user's perspective when working with the GUI. -Although Lumiera will initially ship with a standard, default GUI, we do not presume that this GUI will be suitable for all uses. -We expect there to be multiple, different GUIs, each designed for different -kinds of tasks. We expect that some of these will be written by users, and the -steam-layer is designed to facilitate this easily. +Although Lumiera ships with a conventional desktop UI by default, we do not presume +that this GUI will be suitable for all uses. We expect there to be several specialised +UIs eventually, designed to handle very specific kinds of tasks. Indeed, Lumiera can even work satisfactorily without a GUI, for example, for special purposes (e.g. as headless render-node xref:rendernode[<-] or frameserver -xref:frameserver[<-]). Scripts will eventually be written -to facilitate automated processing. +xref:frameserver[<-]). A script interface will be added at some +point to facilitate automated processing. Now it is time to take a look at the preliminary Lumiera GUI: @@ -505,21 +506,19 @@ A Plug-in is a kind of generalisation of a library. All applications use, to varying degrees of intensity, libraries. A programmer will not reinvent the wheel each time he sits down to programme an application. A programmer will typically borrow and use features and -functionality from other programmers---or even borrow from himself, stuff +functionality from other programmers -- or even borrow from himself, stuff written long ago in the past. Such features are collected together in libraries. -A library is used in an application by _linking_ the library into the -application. (There are other things to be done, but we'll call these 'details', -which wont concern us here.) There are different ways to _link_ a library -into an application: linking statically and linking dynamically. +A library is used in an application by _linking_ the library into the application. +However, there are different ways to _link_ a library: linking statically and +linking dynamically. _Static Linking_ is done while the application is being built, or compiled. It is performed by the linker, which executes as the last step -of the compilation process. The linker can perform some sanity checks -(mostly checks regarding formally correct function invocation) and warn the user -hat some particular feature is being used incorrectly. The user can then correct -the offending code, and recompile. + +of the compilation process. The linker can perform some sanity checks and +some optimisation. In the end, the functionality of the library is ``baked into'' +the resulting executable. + There are a number of disadvantages associated with static linking. Features and libraries are being constantly improved. If the application wants to use new features, it will have to be recompiled with the new library which provides the @@ -532,15 +531,14 @@ features can be used by the application. The features provided by a dynamic library are loaded when the application starts to run. However both methods exhibit a number of shortcomings. Wouldn't it be better if -all features could be loaded only when needed? If features could be loaded only -when needed, then they could also be unloaded when not required, thus saving -memory and possibly increasing performance. This scheme of making features -available to an application is known as run-time linking, aka plug-ins. +all features could be loaded only when needed? This scheme of making features +available to an application on-demand is known as run-time linking. A component +intended to be added this way, at run time, by the user, is known as a Plug-in. Plug-ins offer other benefits: the application can continue to use both the old features and the new features together, side-by-side, by using the version -number associated with the plug-in. This saves the application from the havoc -of library incompatibility that is -associated with other linking methods. +number associated with the plug-in. Furthermore, Plug-ins can load other Plug-ins +and thus extend the application in creative ways, beyond anything the original +developers of the application had planned. Most modern applications use plug-ins, some are heavily dependent on plug-ins and only provide limited functionality without any plug-ins. diff --git a/src/SConscript b/src/SConscript index 018937615..e52b258a3 100644 --- a/src/SConscript +++ b/src/SConscript @@ -12,16 +12,16 @@ Import('env icons config') # define the source file/dirs comprising each artifact to be built. lLib = env.SharedLibrary('lumierasupport', srcSubtree('lib'), install=True) -lApp = env.SharedLibrary('lumieracommon', srcSubtree('common'), addLibs=lLib, install=True) -lVault = env.SharedLibrary('lumieravault', srcSubtree('vault'), addLibs=lLib+lApp, install=True) -lSteam = env.SharedLibrary('lumierasteam', srcSubtree('steam'), addLibs=lLib+lApp+lVault,install=True) +lApp = env.SharedLibrary('lumieravessel', srcSubtree('vessel'),addLibs=lLib, install=True) +lVault = env.SharedLibrary('lumieravault', srcSubtree('vault'), addLibs=lLib+lApp, install=True) +lSteam = env.SharedLibrary('lumierasteam', srcSubtree('steam'), addLibs=lLib+lApp+lVault, install=True) # in reverse dependency order core = lSteam+lVault+lApp+lLib # used to build the core application -app_lib = lApp+lLib # use to link against the platform -core_lib = core # use to link against the core application -vault_lib = lVault+app_lib # use to link against the low-level backend support_lib = lLib # use to link against the support lib only +vessel_lib = lApp+support_lib # use to link against the application-framework +vault_lib = lVault+vessel_lib # use to link against the low-level backend +core_lib = lSteam+vault_lib # use to link against the core application lumiera = ( env.Program('lumiera', ['lumiera/main.cpp'] + core, install=True) + config @@ -49,4 +49,4 @@ gui = ( guimodule ) -Export('lumiera core core_lib app_lib vault_lib support_lib plugins envGtk guimodule gui') +Export('lumiera core core_lib vessel_lib vault_lib support_lib plugins envGtk guimodule gui') diff --git a/src/common/DIR_INFO b/src/common/DIR_INFO deleted file mode 100644 index 8b648aa43..000000000 --- a/src/common/DIR_INFO +++ /dev/null @@ -1 +0,0 @@ -Common application services diff --git a/src/include/gui-notification-facade.h b/src/include/gui-notification-facade.h index 7ff5b7f87..f8f21c660 100644 --- a/src/include/gui-notification-facade.h +++ b/src/include/gui-notification-facade.h @@ -122,7 +122,7 @@ extern "C" { #endif /* =========================== CL Interface ===================== */ -#include "common/interface.h" +#include "vessel/interface.h" #include "lib/hash-value.h" diff --git a/src/include/lifecycle.h b/src/include/lifecycle.hpp similarity index 79% rename from src/include/lifecycle.h rename to src/include/lifecycle.hpp index aa9f37206..9c1150027 100644 --- a/src/include/lifecycle.h +++ b/src/include/lifecycle.hpp @@ -1,5 +1,5 @@ /* - LIFECYCLE.h - interface for registering and triggering lifecycle callbacks + LIFECYCLE.hpp - interface for registering and triggering lifecycle callbacks Copyright (C) 2008, Hermann Vosseler @@ -11,32 +11,30 @@ */ -/** @file lifecycle.h +/** @file lifecycle.hpp ** Installing and invoking of application lifecycle event callbacks. - ** This service is a facade for and implemented by the lumiera::LifecycleRegistry. + ** This service is a facade for and implemented by the vessel::LifecycleRegistry. ** By placing a static LifecycleHook variable or by calling LifecycleHook::add, ** a callback can be registered to be executed on a specific application lifecycle ** event. Examples being #ON_BASIC_INIT, #ON_GLOBAL_INIT. Other subsystems may ** register additional events for more specific purpose. ** ** @note the implementation resides in lib/lifecycle.cpp and gets linked into liblumiera.so - ** @see lumiera::AppState + ** @see vessel::Voyage ** @see main.cpp */ -#ifndef LUMIERA_LIFECYCLE_H -#define LUMIERA_LIFECYCLE_H +#ifndef VESSEL_LIFECYCLE_H +#define VESSEL_LIFECYCLE_H -#ifdef __cplusplus - #include "lib/symbol.hpp" #include "lib/nocopy.hpp" -namespace lumiera { +namespace vessel { using lib::Symbol; @@ -81,21 +79,5 @@ namespace lumiera { -} // namespace lumiera - - - -#else /* =========== C interface ====================== */ - - -//defined in liblumiera.so -extern const char * lumiera_ON_BASIC_INIT; -extern const char * lumiera_ON_GLOBAL_INIT; -extern const char * lumiera_ON_GLOBAL_SHUTDOWN; - - -void lumiera_LifecycleHook_add (const char* eventLabel, void callbackFun(void)); -void lumiera_Lifecycle_trigger (const char* eventLabel); - -#endif -#endif +} // namespace vessel +#endif /*VESSEL_LIFECYCLE_H*/ diff --git a/src/include/session-command-facade.h b/src/include/session-command-facade.h index a23dbf593..6851ca146 100644 --- a/src/include/session-command-facade.h +++ b/src/include/session-command-facade.h @@ -116,7 +116,7 @@ extern "C" { #endif /* =========================== CL Interface ===================== */ -#include "common/interface.h" +#include "vessel/interface.h" LUMIERA_INTERFACE_DECLARE (lumieraorg_SessionCommand, 0, LUMIERA_INTERFACE_SLOT (const char*, cycle, (const char*, const char*)), diff --git a/src/lib/error-exception.cpp b/src/lib/error-exception.cpp index 74669ddfe..36191a7e5 100644 --- a/src/lib/error-exception.cpp +++ b/src/lib/error-exception.cpp @@ -24,7 +24,7 @@ #include "lib/error.hpp" -#include "include/lifecycle.h" +#include "include/lifecycle.hpp" #include "lib/meta/util.hpp" #include "lib/util.hpp" @@ -154,6 +154,9 @@ namespace lumiera { namespace error { namespace { + using vessel::LifecycleHook; + using vessel::ON_BASIC_INIT; + void install_unexpectedException_handler () { std::set_terminate (lumiera_unexpectedException); diff --git a/src/lib/format-obj.cpp b/src/lib/format-obj.cpp index 57dc1191c..06086cb8c 100644 --- a/src/lib/format-obj.cpp +++ b/src/lib/format-obj.cpp @@ -205,6 +205,7 @@ apologies for that." "|stage::model" "|stage::ctrl" "|lumiera::" + "|vessel::" , regex::ECMAScript | regex::optimize}; static regex lolong {"long long" diff --git a/src/lib/lifecycle.cpp b/src/lib/lifecycle.cpp index 5d38e7090..d4de5b8a8 100644 --- a/src/lib/lifecycle.cpp +++ b/src/lib/lifecycle.cpp @@ -18,14 +18,14 @@ #include "lib/error.hpp" -#include "include/lifecycle.h" +#include "include/lifecycle.hpp" #include "lib/lifecycleregistry.hpp" #include "lib/util.hpp" -namespace lumiera { +namespace vessel { // ==== implementation Lifecycle Registry ======= @@ -64,7 +64,6 @@ namespace lumiera { if (isNew and eventLabel == ON_BASIC_INIT) callbackFun(); // when this code executes, // then per definition we are already post "basic init" - // (which happens in the AppState ctor); thus fire it immediately } @@ -83,31 +82,4 @@ namespace lumiera { CStr ON_EMERGENCY ("ON_EMERGENCY"); -} // namespace lumiera - - -extern "C" { /* ==== implementation C interface for lifecycle hooks ======= */ - - - const char * lumiera_ON_BASIC_INIT = lumiera::ON_BASIC_INIT; - const char * lumiera_ON_GLOBAL_INIT = lumiera::ON_GLOBAL_INIT; - const char * lumiera_ON_GLOBAL_SHUTDOWN = lumiera::ON_GLOBAL_SHUTDOWN; - - const char * lumiera_ON_EMERGENCY = lumiera::ON_EMERGENCY; - - - - void - lumiera_LifecycleHook_add (const char* eventLabel, void callbackFun(void)) - { - lumiera::LifecycleHook (eventLabel, callbackFun); - } - - - void - lumiera_Lifecycle_trigger (const char* eventLabel) - { - lumiera::LifecycleRegistry::instance().execute (eventLabel); - } - -} +} // namespace vessel diff --git a/src/lib/lifecycleregistry.hpp b/src/lib/lifecycleregistry.hpp index 912aec541..5e5da74fb 100644 --- a/src/lib/lifecycleregistry.hpp +++ b/src/lib/lifecycleregistry.hpp @@ -14,7 +14,7 @@ /** @file lifecycleregistry.hpp ** Helper for registering lifecycle event callbacks, which are - ** provided as a global service by lumiera::AppState. This service + ** provided as an application service within the »vessel«. This service ** allows to enrol functions under a given label and then to call ** all those registered functions. ** @note this is in fact an event mechanism, and if we start using @@ -22,12 +22,12 @@ ** boost::signals. (which has the downside of being an binary ** dependency). ** - ** @see appstate.hpp + ** @see voyage.hpp */ -#ifndef LUMIERA_LIFECYCLEREGISTRY_H -#define LUMIERA_LIFECYCLEREGISTRY_H +#ifndef VESSEL_LIFECYCLE_REGISTRY_H +#define VESSEL_LIFECYCLE_REGISTRY_H #include "lib/util.hpp" @@ -39,7 +39,7 @@ #include -namespace lumiera { +namespace vessel { using util::contains; using std::function; @@ -50,7 +50,7 @@ namespace lumiera { /** * Registry of callback functions accessible by a label (ID) * provided at registration. Registered functions will be added - * to a list, which can be triggered via label. Used by AppState + * to a list, which can be triggered via label. Used by vessel::Voyage * to implement the lumiera lifecycle (init, shutdown) hooks. */ class LifecycleRegistry @@ -98,5 +98,5 @@ namespace lumiera { -} // namespace lumiera -#endif +} // namespace vessel +#endif /*VESSEL_LIFECYCLE_REGISTRY_H*/ diff --git a/src/lib/meta/generator.hpp b/src/lib/meta/generator.hpp index 4585f396e..2cf37b381 100644 --- a/src/lib/meta/generator.hpp +++ b/src/lib/meta/generator.hpp @@ -41,7 +41,7 @@ This code is heavily inspired by ** instantiation is mixed or inherited into the resulting product. ** ** @see generator-test.cpp - ** @see lumiera::query::ConfigRules usage example + ** @see vessel::query::ConfigRules usage example ** @see typelist.hpp ** */ diff --git a/src/lib/nobug-init.cpp b/src/lib/nobug-init.cpp index b00add93d..adcf83fb6 100644 --- a/src/lib/nobug-init.cpp +++ b/src/lib/nobug-init.cpp @@ -26,7 +26,7 @@ -namespace lumiera { +namespace lib { void initialise_NoBug () diff --git a/src/lib/nobug-init.hpp b/src/lib/nobug-init.hpp index da66b4f23..4f3bec90f 100644 --- a/src/lib/nobug-init.hpp +++ b/src/lib/nobug-init.hpp @@ -27,17 +27,17 @@ #ifndef NOBUG_INIT_H #define NOBUG_INIT_H -#include "include/lifecycle.h" +#include "include/lifecycle.hpp" #include -namespace lumiera { +namespace lib { void initialise_NoBug (); namespace { - LifecycleHook trigger_init_ (ON_BASIC_INIT, &initialise_NoBug); + vessel::LifecycleHook trigger_init_ (vessel::ON_BASIC_INIT, &initialise_NoBug); } } diff --git a/src/lib/sync.hpp b/src/lib/sync.hpp index 3cd730da8..90ab042c5 100644 --- a/src/lib/sync.hpp +++ b/src/lib/sync.hpp @@ -282,5 +282,5 @@ namespace lib { }; -} // namespace lumiera +} // namespace lib::sync #endif diff --git a/src/lumiera/main.cpp b/src/lumiera/main.cpp index bdb698040..f91739cbb 100644 --- a/src/lumiera/main.cpp +++ b/src/lumiera/main.cpp @@ -20,8 +20,8 @@ #include "include/logging.h" #include "lib/error.hpp" -#include "common/appstate.hpp" -#include "common/option.hpp" +#include "vessel/voyage.hpp" +#include "vessel/option.hpp" #include "vault/enginefacade.hpp" #include "vault/netnodefacade.hpp" @@ -30,8 +30,8 @@ #include "stage/guifacade.hpp" using lib::Cmdline; -using lumiera::Subsys; -using lumiera::AppState; +using vessel::Subsys; +using vessel::Voyage; namespace { Subsys& engine = vault::EngineFacade::getDescriptor(); @@ -49,12 +49,12 @@ main (int argc, const char* argv[]) { NOTICE (main, "*** Lumiera NLE for Linux ***"); - AppState& application = AppState::instance(); + Voyage& voyage = Voyage::access(); try { Cmdline args (argc,argv); - lumiera::Option options (args); - application.init (options); + vessel::Option options (args); + voyage.init (options); netNode.depends (session); netNode.depends (engine); @@ -65,21 +65,21 @@ main (int argc, const char* argv[]) script.depends (session); script.depends (engine); - application.maybeStart (playOut); - application.maybeStart (netNode); - application.maybeStart (lumigui); - application.maybeStart (script); + voyage.maybeStart (playOut); + voyage.maybeStart (netNode); + voyage.maybeStart (lumigui); + voyage.maybeStart (script); - return application.maybeWait(); + return voyage.maybeWait(); } catch (lumiera::Error& problem) { - return application.abort (problem); + return voyage.abort (problem); } catch (...) { - return application.abort(); + return voyage.abort(); } } diff --git a/src/stage/config-keys.cpp b/src/stage/config-keys.cpp index b1a370571..1d7a3676b 100644 --- a/src/stage/config-keys.cpp +++ b/src/stage/config-keys.cpp @@ -16,8 +16,8 @@ /** @file config-keys.hpp ** Definition of access keys for global UI configuration. ** - ** @see lumiera::AppState general Lumiera application main - ** @see lumiera::Config + ** @see vessel::Voyage general Lumiera application main + ** @see vessel::spine::Config ** */ diff --git a/src/stage/config-keys.hpp b/src/stage/config-keys.hpp index e4902d34b..28210e671 100644 --- a/src/stage/config-keys.hpp +++ b/src/stage/config-keys.hpp @@ -18,7 +18,7 @@ ** ** # configuration and resource search ** - ** The UI layer retrieves the necessary configuration values from lumiera::Config, + ** The UI layer retrieves the necessary configuration values from vessel::spine::Config, ** the config facade in the application core. Currently as of 2/2011 these values are ** loaded from setup.ini, because the full-blown config system is not yet implemented. ** Amongst others, this configuration defines a _search path_ for icons and a @@ -27,9 +27,9 @@ ** This allows for a relocatable Lumiera installation bundle. ** ** @see gtk-lumiera.cpp the plugin to pull up this GUI - ** @see lumiera::BasicSetup definition of the acceptable configuration values - ** @see lumiera::AppState general Lumiera application main - ** @see lumiera::Config + ** @see vessel::BasicSetup definition of the acceptable configuration values + ** @see vessel::Voyage general Lumiera application main + ** @see vessel::spine::Config ** */ @@ -38,14 +38,14 @@ #include "lib/symbol.hpp" -#include "include/config-facade.h" +#include "vessel/spine/config-facade.h" namespace stage { using lib::Literal; - using lumiera::Config; + using vessel::spine::Config; extern Literal KEY_TITLE; extern Literal KEY_VERSION; diff --git a/src/stage/ctrl/demo-controller.cpp b/src/stage/ctrl/demo-controller.cpp index 4617beb26..7a21047eb 100644 --- a/src/stage/ctrl/demo-controller.cpp +++ b/src/stage/ctrl/demo-controller.cpp @@ -37,7 +37,7 @@ namespace ctrl { using std::make_unique; using steam::node::DummyTickService; using steam::node::DummyImageGenerator; - using lumiera::DisplayerInput; + using vessel::spine::DisplayerInput; DemoController::DemoController() @@ -54,7 +54,7 @@ namespace ctrl { * @param displayFormat format for the frames expected in the passed image buffer. */ void - DemoController::activate (lumiera::DisplayerInput displayFormat) + DemoController::activate (DisplayerInput displayFormat) { REQUIRE (imageGen_); imageGen_->configure (displayFormat); diff --git a/src/stage/ctrl/demo-controller.hpp b/src/stage/ctrl/demo-controller.hpp index 0474f793f..510b47bc4 100644 --- a/src/stage/ctrl/demo-controller.hpp +++ b/src/stage/ctrl/demo-controller.hpp @@ -32,7 +32,7 @@ #define DEMO_CONTROLLER_H #include "stage/gtk-base.hpp" -#include "include/display-handles.hpp" +#include "vessel/spine/display-handles.hpp" #include "lib/nocopy.hpp" #include @@ -68,7 +68,7 @@ namespace ctrl { void pause(); void stop(); - void activate (lumiera::DisplayerInput); + void activate (vessel::spine::DisplayerInput); sigc::signal output_; private: bool playing_; diff --git a/src/stage/gtk-base.hpp b/src/stage/gtk-base.hpp index a84a8a631..2e07354d6 100644 --- a/src/stage/gtk-base.hpp +++ b/src/stage/gtk-base.hpp @@ -25,7 +25,7 @@ ** ** # configuration and resource search ** - ** The GUI backbone retrieves the necessary configuration values from lumiera::Config, + ** The GUI backbone retrieves the necessary configuration values from vessel::spine::Config, ** the config facade in the application core. Currently as of 2/2011 these values are ** loaded from setup.ini, because the full-blown config system is not yet implemented. ** Amongst others, this configuration defines a _search path_ for icons and a @@ -39,9 +39,9 @@ ** @see gtk-lumiera.cpp the plugin to pull up this GUI ** @see stage::GuiFacade access point for starting the GUI ** @see stage::GuiNotification interface for communication with the gui from the lower layers - ** @see lumiera::Config - ** @see lumiera::BasicSetup definition of the acceptable configuration values - ** @see lumiera::AppState general Lumiera application main + ** @see vessel::spine::Config + ** @see vessel::BasicSetup definition of the acceptable configuration values + ** @see vessel::Voyage general Lumiera application main */ diff --git a/src/stage/gtk-lumiera.cpp b/src/stage/gtk-lumiera.cpp index fd2d21a09..4f83196a4 100644 --- a/src/stage/gtk-lumiera.cpp +++ b/src/stage/gtk-lumiera.cpp @@ -19,7 +19,7 @@ ** This plugin is linked together with the Lumiera GUI code; when loaded as ** Lumiera plugin, it allows to kick off the GTK main event loop and thus to bring ** up the GUI. The loading and shutdown process is carried out by stage::GuiFacade and - ** controlled by lumiera::AppState, which in turn is activated by Lumiera main(). + ** controlled by the vessel::Voyage, which in turn is activated by Lumiera main(). ** ** After successfully loading this module, a call to GuiFacade::launchUI is expected to ** happen, passing a termination signal (callback) to be executed when the GUI terminates. @@ -31,7 +31,7 @@ ** This entails also to open the primary "business" interface(s) of the GUI ** (currently as of 1/16 this is the interface stage::GuiNotification.) ** - ** @see lumiera::AppState + ** @see vessel::Voyage ** @see stage::GuiFacade ** @see guifacade.cpp ** @see ui-manager.hpp @@ -44,19 +44,19 @@ #include "stage/ui-bus.hpp" #include "stage/guifacade.hpp" #include "stage/ctrl/ui-manager.hpp" -#include "common/subsys.hpp" +#include "vessel/subsys.hpp" #include "lib/nocopy.hpp" extern "C" { -#include "common/interface.h" -#include "common/interface-descriptor.h" +#include "vessel/interface.h" +#include "vessel/interface-descriptor.h" } #include -using lumiera::Subsys; +using vessel::Subsys; using lib::launchDetached; using lumiera::error::LUMIERA_ERROR_STATE; using stage::LUMIERA_INTERFACE_INAME(lumieraorg_Gui, 1); diff --git a/src/stage/guifacade.hpp b/src/stage/guifacade.hpp index c410b8f1b..66f0d3165 100644 --- a/src/stage/guifacade.hpp +++ b/src/stage/guifacade.hpp @@ -18,8 +18,8 @@ ** contained within the GUI dynamic module), because it's job is to load and ** activate this module as plug-in and to startup the GUI. ** - ** @see lumiera::AppState - ** @see lumiera::Option + ** @see vessel::Voyage + ** @see vessel::Option ** @see guifacade.cpp ** @see main.cpp */ @@ -29,11 +29,11 @@ #define STAGE_FACADE_H -#include "common/subsys.hpp" +#include "vessel/subsys.hpp" #include "lib/nocopy.hpp" extern "C" { -#include "common/interface.h" +#include "vessel/interface.h" } @@ -72,10 +72,10 @@ namespace stage { { public: - /** provide a descriptor for lumiera::AppState, + /** provide a descriptor for vessel::Voyage, * wired accordingly to allow main to load, * start and stop the Lumiera GTK GUI. */ - static lumiera::Subsys& getDescriptor(); + static vessel::Subsys& getDescriptor(); /** weather the GUI has been started and all interfaces are opened */ diff --git a/src/stage/notification-service.cpp b/src/stage/notification-service.cpp index ef6fc2f62..90fbff503 100644 --- a/src/stage/notification-service.cpp +++ b/src/stage/notification-service.cpp @@ -57,7 +57,7 @@ #include "lib/util.hpp" extern "C" { -#include "common/interface-descriptor.h" +#include "vessel/interface-descriptor.h" } #include diff --git a/src/stage/notification-service.hpp b/src/stage/notification-service.hpp index 7d88da63e..7c1596d45 100644 --- a/src/stage/notification-service.hpp +++ b/src/stage/notification-service.hpp @@ -32,7 +32,7 @@ #include "include/gui-notification-facade.h" -#include "common/instancehandle.hpp" +#include "vessel/instancehandle.hpp" #include "stage/ctrl/bus-term.hpp" #include @@ -77,9 +77,9 @@ namespace stage { /* === Interface Lifecycle === */ - using ServiceInstanceHandle = lumiera::InstanceHandle< LUMIERA_INTERFACE_INAME(lumieraorg_GuiNotification, 0) - , GuiNotification - > ; + using ServiceInstanceHandle = vessel::InstanceHandle< LUMIERA_INTERFACE_INAME(lumieraorg_GuiNotification, 0) + , GuiNotification + > ; ServiceInstanceHandle serviceInstance_; diff --git a/src/stage/output/displayer.cpp b/src/stage/output/displayer.cpp index a80fbcc2a..e7f8613b6 100644 --- a/src/stage/output/displayer.cpp +++ b/src/stage/output/displayer.cpp @@ -38,7 +38,7 @@ namespace output { DisplayerInput Displayer::format() { - return lumiera::DISPLAY_NONE; + return vessel::spine::DISPLAY_NONE; } void diff --git a/src/stage/output/displayer.hpp b/src/stage/output/displayer.hpp index b10d4f106..9dece1eaf 100644 --- a/src/stage/output/displayer.hpp +++ b/src/stage/output/displayer.hpp @@ -28,12 +28,12 @@ #include "lib/nocopy.hpp" -#include "include/display-handles.hpp" +#include "vessel/spine/display-handles.hpp" namespace stage { namespace output { - using lumiera::DisplayerInput; + using vessel::spine::DisplayerInput; /** diff --git a/src/stage/output/pixbuf-displayer.hpp b/src/stage/output/pixbuf-displayer.hpp index 469affd3d..e186129f0 100644 --- a/src/stage/output/pixbuf-displayer.hpp +++ b/src/stage/output/pixbuf-displayer.hpp @@ -71,7 +71,7 @@ class PixbufDisplayer DisplayerInput format() override { - return lumiera::DISPLAY_RGB; + return vessel::spine::DISPLAY_RGB; } }; diff --git a/src/stage/output/xv-displayer.hpp b/src/stage/output/xv-displayer.hpp index 9cc1ae048..f69d75147 100644 --- a/src/stage/output/xv-displayer.hpp +++ b/src/stage/output/xv-displayer.hpp @@ -72,7 +72,7 @@ namespace output { DisplayerInput format() override { - return lumiera::DISPLAY_YUV; + return vessel::spine::DISPLAY_YUV; } diff --git a/src/stage/timeline/body-canvas-widget.cpp b/src/stage/timeline/body-canvas-widget.cpp index ad5b79da8..2483ae704 100644 --- a/src/stage/timeline/body-canvas-widget.cpp +++ b/src/stage/timeline/body-canvas-widget.cpp @@ -43,7 +43,7 @@ #include "stage/timeline/track-body.hpp" #include "stage/style-scheme.hpp" -#include "common/advice.hpp" +#include "vessel/advice.hpp" #include "lib/util.hpp" #include @@ -71,8 +71,8 @@ namespace timeline { const int MINIMAL_CONTENT_WIDTH_px = 100; /** request a pre-defined CSS style context for the track body */ - lumiera::advice::Request trackBodyStyle{"style(trackBody)"}; - lumiera::advice::Request trackRulerStyle{"style(trackRuler)"}; + vessel::advice::Request trackBodyStyle{"style(trackBody)"}; + vessel::advice::Request trackRulerStyle{"style(trackRuler)"}; cuString slopeClassName(int depth) diff --git a/src/stage/timeline/timeline-layout.cpp b/src/stage/timeline/timeline-layout.cpp index e997b5685..c2ce4ae4a 100644 --- a/src/stage/timeline/timeline-layout.cpp +++ b/src/stage/timeline/timeline-layout.cpp @@ -25,7 +25,7 @@ #include "stage/timeline/timeline-layout.hpp" #include "stage/timeline/track-body.hpp" -#include "common/advice.hpp" +#include "vessel/advice.hpp" #include "lib/time/timevalue.hpp" using lib::time::Time; diff --git a/src/stage/widget/video-display-widget.hpp b/src/stage/widget/video-display-widget.hpp index c749d3feb..1eb69a2d5 100644 --- a/src/stage/widget/video-display-widget.hpp +++ b/src/stage/widget/video-display-widget.hpp @@ -33,7 +33,7 @@ namespace stage { namespace widget { using stage::output::Displayer; - using lumiera::DisplayerInput; + using vessel::spine::DisplayerInput; /** diff --git a/src/stage/workspace/ui-style.cpp b/src/stage/workspace/ui-style.cpp index 5b7c79660..832d228d2 100644 --- a/src/stage/workspace/ui-style.cpp +++ b/src/stage/workspace/ui-style.cpp @@ -52,7 +52,7 @@ namespace workspace { * either from the default theme of via the given Lumiera icon search paths, * typically from `setup.ini`. * - * @see lumiera::Config + * @see vessel::spine::Config */ UiStyle::UiStyle() : Gtk::UIManager() diff --git a/src/stage/workspace/ui-style.hpp b/src/stage/workspace/ui-style.hpp index 600e1366f..21ee115a5 100644 --- a/src/stage/workspace/ui-style.hpp +++ b/src/stage/workspace/ui-style.hpp @@ -28,7 +28,7 @@ #define STAGE_WORKSPACE_UI_STYLE_H #include "stage/gtk-base.hpp" -#include "common/advice.hpp" +#include "vessel/advice.hpp" #include "lib/symbol.hpp" #include "lib/nocopy.hpp" @@ -49,7 +49,7 @@ namespace workspace { using lib::Literal; using std::string; - using StyleAdvice = lumiera::advice::Provision; + using StyleAdvice = vessel::advice::Provision; @@ -99,7 +99,7 @@ namespace workspace { * Sets the theme to use for the Lumiera GUI. * @param stylesheetName GTK CSS stylesheet to load from the resourceSearchPath_ * @throw error::Config if this stylesheet can't be resolved on the searchpath - * @see lumiera::Config + * @see vessel::spine::Config */ void setTheme (string const& stylesheetName); diff --git a/src/steam/asset/meta/time-grid.cpp b/src/steam/asset/meta/time-grid.cpp index e6d098366..2b4d42576 100644 --- a/src/steam/asset/meta/time-grid.cpp +++ b/src/steam/asset/meta/time-grid.cpp @@ -23,7 +23,7 @@ #include "lib/time/quantiser.hpp" #include "lib/time/timevalue.hpp" #include "lib/format-string.hpp" -#include "common/advice.hpp" +#include "vessel/advice.hpp" #include "lib/util.hpp" #include @@ -62,7 +62,7 @@ namespace meta { using lib::time::FixedFrameQuantiser; using std::dynamic_pointer_cast; - namespace advice = lumiera::advice; + namespace advice = vessel::advice; namespace { diff --git a/src/steam/asset/pipe.hpp b/src/steam/asset/pipe.hpp index d1ad00362..5ca1857f0 100644 --- a/src/steam/asset/pipe.hpp +++ b/src/steam/asset/pipe.hpp @@ -27,7 +27,7 @@ #include "steam/asset/struct.hpp" #include "steam/asset/procpatt.hpp" #include "steam/streamtype.hpp" -#include "common/query.hpp" +#include "vessel/query.hpp" #include @@ -36,7 +36,7 @@ namespace steam { namespace asset { - using lumiera::Query; + using vessel::Query; using std::string; class Pipe; diff --git a/src/steam/asset/struct-factory-impl.hpp b/src/steam/asset/struct-factory-impl.hpp index 01666240a..016e294d2 100644 --- a/src/steam/asset/struct-factory-impl.hpp +++ b/src/steam/asset/struct-factory-impl.hpp @@ -33,8 +33,8 @@ #include "steam/mobject/session/element-query.hpp" #include "steam/mobject/session/session-query.hpp" #include "steam/mobject/session/scope.hpp" -#include "common/config-rules.hpp" -#include "common/query.hpp" +#include "vessel/config-rules.hpp" +#include "vessel/query.hpp" #include "steam/asset/timeline.hpp" #include "steam/asset/sequence.hpp" #include "steam/asset/procpatt.hpp" @@ -60,7 +60,7 @@ namespace asset { using util::uNum; using util::isnil; using util::contains; - using lumiera::Query; + using vessel::Query; using LERR_(CAPABILITY_QUERY); using lib::query::extractID; diff --git a/src/steam/asset/struct.cpp b/src/steam/asset/struct.cpp index 71451aef3..a814d3a78 100644 --- a/src/steam/asset/struct.cpp +++ b/src/steam/asset/struct.cpp @@ -39,12 +39,12 @@ #include "lib/query-util.hpp" #include "lib/format-string.hpp" #include "include/logging.h" -#include "common/query.hpp" +#include "vessel/query.hpp" using util::_Fmt; using lib::Symbol; using lib::query::normaliseID; -using lumiera::query::QueryHandler; +using vessel::query::QueryHandler; using steam::ConfigResolver; using util::contains; diff --git a/src/steam/asset/struct.hpp b/src/steam/asset/struct.hpp index bb9d50007..317338b4d 100644 --- a/src/steam/asset/struct.hpp +++ b/src/steam/asset/struct.hpp @@ -54,7 +54,7 @@ #include "lib/symbol.hpp" #include "steam/asset.hpp" -#include "common/query.hpp" +#include "vessel/query.hpp" #include "lib/nocopy.hpp" #include @@ -67,7 +67,7 @@ namespace asset { using std::string; using std::unique_ptr; - using lumiera::Query; + using vessel::Query; using lib::Symbol; class Struct; diff --git a/src/steam/asset/typed-id.hpp b/src/steam/asset/typed-id.hpp index 4b6a2bcb5..73fc6b8d2 100644 --- a/src/steam/asset/typed-id.hpp +++ b/src/steam/asset/typed-id.hpp @@ -47,7 +47,7 @@ #include -namespace lumiera{ ///////TODO: shouldn't that be namespace lib? or steam? +namespace vessel { ///////TODO: shouldn't that be namespace lib? or steam? namespace query { /** diff --git a/src/steam/config-resolver.cpp b/src/steam/config-resolver.cpp index fc733c367..22fc26b6b 100644 --- a/src/steam/config-resolver.cpp +++ b/src/steam/config-resolver.cpp @@ -21,13 +21,13 @@ #include "lib/error.hpp" -#include "include/lifecycle.h" +#include "include/lifecycle.hpp" #include "steam/config-resolver.hpp" #include "steam/mobject/session/query/fake-configrules.hpp" #include "lib/depend-inject.hpp" -using lumiera::LifecycleHook; -using lumiera::ON_GLOBAL_INIT; +using vessel::LifecycleHook; +using vessel::ON_GLOBAL_INIT; namespace steam { @@ -66,7 +66,7 @@ namespace steam { -#include "common/query/defs-manager-impl.hpp" +#include "vessel/query/defs-manager-impl.hpp" @@ -80,7 +80,7 @@ namespace steam { #include "steam/asset/sequence.hpp" #include "steam/mobject/session/fork.hpp" -namespace lumiera{ +namespace vessel { namespace query { using steam::asset::Pipe; @@ -105,4 +105,4 @@ namespace query { template bool DefsManager::forget (PPipe const&); -}} // namespace lumiera::query +}} // namespace vessel::query diff --git a/src/steam/config-resolver.hpp b/src/steam/config-resolver.hpp index cdecb0de4..9f7800be5 100644 --- a/src/steam/config-resolver.hpp +++ b/src/steam/config-resolver.hpp @@ -25,7 +25,7 @@ ** @note this is placeholder code using a preliminary/mock implementation... don't take this code too literal! ** @todo clarify the relation of config query and query-for-defaults ///////////////TICKET #705 ** - ** @see lumiera::Query + ** @see vessel::Query ** @see mobject::session::DefsManager ** @see asset::StructFactory ** @see fake-configrules.hpp currently used dummy-implementation @@ -37,8 +37,8 @@ #ifndef STEAM_CONFIG_RESOLVER #define STEAM_CONFIG_RESOLVER -#include "common/query.hpp" -#include "common/config-rules.hpp" +#include "vessel/query.hpp" +#include "vessel/config-rules.hpp" #include "lib/depend.hpp" // types for explicit specialisations.... @@ -73,7 +73,7 @@ namespace steam { * Configured as Singleton (with hidden Implementation class) */ class ConfigResolver - : public lumiera::query::ConfigRules + : public vessel::query::ConfigRules { public: diff --git a/src/steam/control/command-setup.cpp b/src/steam/control/command-setup.cpp index 630029a54..d9aef6b7e 100644 --- a/src/steam/control/command-setup.cpp +++ b/src/steam/control/command-setup.cpp @@ -28,7 +28,7 @@ #include "lib/error.hpp" #include "include/logging.h" -#include "include/lifecycle.h" +#include "include/lifecycle.hpp" #include "steam/control/command.hpp" #include "steam/control/command-setup.hpp" #include "steam/control/command-instance-manager.hpp" @@ -45,8 +45,8 @@ using std::get; using std::function; using std::move; using lib::Symbol; -using lumiera::LifecycleHook; -using lumiera::ON_GLOBAL_INIT; +using vessel::LifecycleHook; +using vessel::ON_GLOBAL_INIT; using std::string; using util::unConst; using util::_Fmt; diff --git a/src/steam/control/session-command-interface-proxy.cpp b/src/steam/control/session-command-interface-proxy.cpp index 32595db90..25cfb7dcd 100644 --- a/src/steam/control/session-command-interface-proxy.cpp +++ b/src/steam/control/session-command-interface-proxy.cpp @@ -24,14 +24,14 @@ #include "include/session-command-facade.h" -#include "include/interfaceproxy.hpp" +#include "vessel/spine/interfaceproxy.hpp" namespace steam { namespace control{ /** static storage for the facade access front-end */ lib::Depend SessionCommand::facade; }} -namespace lumiera { +namespace vessel { namespace facade { @@ -65,4 +65,4 @@ namespace facade { template class Link; -}} //namespace facade::lumiera +}} //namespace vessel::facade diff --git a/src/steam/control/session-command-service.cpp b/src/steam/control/session-command-service.cpp index 7ff9c66ec..c0128900a 100644 --- a/src/steam/control/session-command-service.cpp +++ b/src/steam/control/session-command-service.cpp @@ -30,7 +30,7 @@ #include "lib/util.hpp" extern "C" { -#include "common/interface-descriptor.h" +#include "vessel/interface-descriptor.h" } #include diff --git a/src/steam/control/session-command-service.hpp b/src/steam/control/session-command-service.hpp index 8ffe6fd99..1ebd8c4c5 100644 --- a/src/steam/control/session-command-service.hpp +++ b/src/steam/control/session-command-service.hpp @@ -36,7 +36,7 @@ #include "include/session-command-facade.h" #include "steam/control/command-dispatch.hpp" #include "steam/control/command-instance-manager.hpp" -#include "common/instancehandle.hpp" +#include "vessel/instancehandle.hpp" #include "lib/diff/gen-node.hpp" #include "lib/nocopy.hpp" #include "lib/symbol.hpp" @@ -77,9 +77,9 @@ namespace control { /* === Interface Lifecycle === */ - using ServiceInstanceHandle = lumiera::InstanceHandle< LUMIERA_INTERFACE_INAME(lumieraorg_SessionCommand, 0) - , SessionCommand - >; + using ServiceInstanceHandle = vessel::InstanceHandle< LUMIERA_INTERFACE_INAME(lumieraorg_SessionCommand, 0) + , SessionCommand + >; ServiceInstanceHandle serviceInstance_; public: diff --git a/src/steam/control/steam-dispatcher.hpp b/src/steam/control/steam-dispatcher.hpp index 95ef51a9e..48f7448c8 100644 --- a/src/steam/control/steam-dispatcher.hpp +++ b/src/steam/control/steam-dispatcher.hpp @@ -45,7 +45,7 @@ #ifndef STEAM_CONTROL_PROC_DISPATCHER_H #define STEAM_CONTROL_PROC_DISPATCHER_H -#include "common/subsys.hpp" +#include "vessel/subsys.hpp" #include "lib/depend.hpp" #include "lib/sync.hpp" @@ -57,7 +57,7 @@ namespace steam { namespace control { using std::unique_ptr; - using lumiera::Subsys; + using vessel::Subsys; class DispatcherLoop; diff --git a/src/steam/control/stypemanager.cpp b/src/steam/control/stypemanager.cpp index 7f8450268..18763cc59 100644 --- a/src/steam/control/stypemanager.cpp +++ b/src/steam/control/stypemanager.cpp @@ -20,7 +20,7 @@ #include "steam/common.hpp" #include "steam/control/stypemanager.hpp" #include "steam/control/styperegistry.hpp" -#include "include/lifecycle.h" +#include "include/lifecycle.hpp" namespace steam { @@ -49,7 +49,7 @@ namespace control { STypeManager::reset() { reg_.reset(new Registry); - lumiera::LifecycleHook::trigger (ON_STREAMTYPES_RESET); + vessel::LifecycleHook::trigger (ON_STREAMTYPES_RESET); } /** \par @@ -111,12 +111,3 @@ namespace control { } }} // namespace steam::control - - -// ==== C interface for registering setup of basic stream type configuration ======= - -void -lumiera_StreamType_registerInitFunction (void setupFun(void)) -{ - lumiera::LifecycleHook (steam::control::ON_STREAMTYPES_RESET, setupFun); -} diff --git a/src/steam/control/stypemanager.hpp b/src/steam/control/stypemanager.hpp index f25ec7331..3de3d8f46 100644 --- a/src/steam/control/stypemanager.hpp +++ b/src/steam/control/stypemanager.hpp @@ -110,20 +110,4 @@ namespace proc_interface { } // namespace proc_interface - - -extern "C" { //TODO provide a separate header if some C code or plugin happens to need this... - - /** any stream type implementation, which needs to be present on the - * pristine default level (without any session specific configuration), - * should register a setup function, which will be called on each - * STypemanager::reset() - */ - void - lumiera_StreamType_registerInitFunction (void setupFun(void)); - - // TODO provide a C interface usable from such a setupFun to access the STypeManager registration functions. -} - - -#endif +#endif /*STEAM_CONTROL_STYPEMANAGER_H*/ diff --git a/src/steam/control/styperegistry.hpp b/src/steam/control/styperegistry.hpp index 1a02b9d81..2c75dd2ff 100644 --- a/src/steam/control/styperegistry.hpp +++ b/src/steam/control/styperegistry.hpp @@ -17,7 +17,7 @@ ** Only used in stypemanager.cpp and accompanying unit tests. ** ** @see control::STypeManager - ** @see lumiera::StreamType + ** @see steam::StreamType ** */ @@ -30,7 +30,7 @@ #include "steam/control/stypemanager.hpp" #include "lib/nocopy.hpp" -//#include "common/query.hpp" +//#include "vessel/query.hpp" //#include "lib/util.hpp" //#include "lib/p.hpp" diff --git a/src/steam/engine/calc-stream.hpp b/src/steam/engine/calc-stream.hpp index 6eaa711c9..c020368bb 100644 --- a/src/steam/engine/calc-stream.hpp +++ b/src/steam/engine/calc-stream.hpp @@ -42,7 +42,7 @@ #include "steam/engine/render-drive.hpp" //#include "include/dummy-player-facade.h" //#include "include/display-facade.h" -//#include "common/instancehandle.hpp" +//#include "vessel/instancehandle.hpp" //#include "lib/singleton-ref.hpp" // //#include @@ -56,9 +56,9 @@ namespace engine{ namespace error = lumiera::error; // using std::string; -// using lumiera::Subsys; -// using lumiera::Display; -// using lumiera::DummyPlayer; +// using vessel::Subsys; +// using vessel::Display; +// using vessel::DummyPlayer; class RenderEnvironment; diff --git a/src/steam/engine/engine-diagnostics.hpp b/src/steam/engine/engine-diagnostics.hpp index 0395ee3c1..b77540044 100644 --- a/src/steam/engine/engine-diagnostics.hpp +++ b/src/steam/engine/engine-diagnostics.hpp @@ -37,7 +37,7 @@ //#include "steam/mobject/model-port.hpp" #include "steam/play/timings.hpp" //#include "steam/play/output-slot.hpp" -//#include "common/instancehandle.hpp" +//#include "vessel/instancehandle.hpp" //#include "lib/singleton-ref.hpp" //#include "lib/polymorphic-value.hpp" //#include "lib/depend.hpp" @@ -49,9 +49,9 @@ namespace steam { namespace engine{ // using std::string; -// using lumiera::Subsys; -// using lumiera::Display; -// using lumiera::DummyPlayer; +// using vessel::Subsys; +// using vessel::Display; +// using vessel::DummyPlayer; using steam::play::Timings; diff --git a/src/steam/engine/engine-service.cpp b/src/steam/engine/engine-service.cpp index a438cf6ea..e4c3bc241 100644 --- a/src/steam/engine/engine-service.cpp +++ b/src/steam/engine/engine-service.cpp @@ -31,7 +31,7 @@ namespace steam { namespace engine{ // using std::string; -// using lumiera::Subsys; +// using vessel::Subsys; using std::function; using std::bind; using std::ref; diff --git a/src/steam/engine/engine-service.hpp b/src/steam/engine/engine-service.hpp index 786a7378b..6d6e79e6e 100644 --- a/src/steam/engine/engine-service.hpp +++ b/src/steam/engine/engine-service.hpp @@ -53,7 +53,7 @@ #include "steam/mobject/model-port.hpp" #include "steam/play/timings.hpp" #include "steam/play/output-slot.hpp" -//#include "common/instancehandle.hpp" +//#include "vessel/instancehandle.hpp" //#include "lib/singleton-ref.hpp" #include "lib/polymorphic-value.hpp" #include "lib/depend.hpp" @@ -66,9 +66,9 @@ namespace steam { namespace engine{ // using std::string; -// using lumiera::Subsys; -// using lumiera::Display; -// using lumiera::DummyPlayer; +// using vessel::Subsys; +// using vessel::Display; +// using vessel::DummyPlayer; // using std::function; using mobject::ModelPort; using steam::play::Timings; diff --git a/src/steam/engine/worker/dummy-image-generator.cpp b/src/steam/engine/worker/dummy-image-generator.cpp index 1085194ec..4a75c0f3c 100644 --- a/src/steam/engine/worker/dummy-image-generator.cpp +++ b/src/steam/engine/worker/dummy-image-generator.cpp @@ -75,6 +75,10 @@ namespace node { } // (End) implementation details + using vessel::spine::DisplayerInput; + using vessel::spine::DISPLAY_NONE; + using vessel::spine::DISPLAY_YUV; + using vessel::spine::DISPLAY_RGB; @@ -86,14 +90,14 @@ namespace node { { } void - DummyImageGenerator::configure (lumiera::DisplayerInput displayFormat) + DummyImageGenerator::configure (DisplayerInput displayFormat) { INFO (steam, "ImageGen: use format %d", displayFormat); - REQUIRE ( displayFormat == lumiera::DISPLAY_NONE - or displayFormat == lumiera::DISPLAY_YUV - or displayFormat == lumiera::DISPLAY_RGB); + REQUIRE ( displayFormat == DISPLAY_NONE + or displayFormat == DISPLAY_YUV + or displayFormat == DISPLAY_RGB); - useRGB_ = (displayFormat == lumiera::DISPLAY_RGB); + useRGB_ = (displayFormat == DISPLAY_RGB); } void diff --git a/src/steam/engine/worker/dummy-image-generator.hpp b/src/steam/engine/worker/dummy-image-generator.hpp index a9f741b3f..fd89eeed4 100644 --- a/src/steam/engine/worker/dummy-image-generator.hpp +++ b/src/steam/engine/worker/dummy-image-generator.hpp @@ -33,7 +33,7 @@ #include "lib/error.hpp" -#include "include/display-handles.hpp" +#include "vessel/spine/display-handles.hpp" #include @@ -53,7 +53,7 @@ namespace node { static const uint H = 240; DummyImageGenerator(uint fps); - void configure (lumiera::DisplayerInput); + void configure (vessel::spine::DisplayerInput); /** generate the next frame and occupy the alternate buffer. diff --git a/src/steam/external/libgavl.cpp b/src/steam/external/libgavl.cpp index 3ca80e537..7eaedc5bd 100644 --- a/src/steam/external/libgavl.cpp +++ b/src/steam/external/libgavl.cpp @@ -32,7 +32,7 @@ namespace external { using control::STypeManager; using control::ON_STREAMTYPES_RESET; - using lumiera::LifecycleHook; + using vessel::LifecycleHook; void provide_GAVL_stream_implementation_types () diff --git a/src/steam/facade.cpp b/src/steam/facade.cpp index 7a5440b78..1c5db5253 100644 --- a/src/steam/facade.cpp +++ b/src/steam/facade.cpp @@ -20,12 +20,12 @@ ** - The »play out subsystem« is able to _perform_ such a render nodes network ** for video playback and rendering. ** - ** lumiera::Subsys and lumiera::SubsystemRunner together define a protocol for some + ** vessel::Subsys and vessel::SubsystemRunner together define a protocol for some ** large scale building blocks of the whole application to be started and terminated. ** Typically this entails to create a dedicated thread to manage the top level concerns ** for the given subsystem, and to create registration and services for public access: ** - to operate on the session, use the steam::control::SessionCommand facade - ** - playback and render operations can be operated by the lumiera::Play facade + ** - playback and render operations can be operated by the vessel::spine::Play facade ** ** @see SteamDispatcher ** @see OutputDirector @@ -47,8 +47,8 @@ namespace steam { using std::string; using std::unique_ptr; - using lumiera::Subsys; - using lumiera::Option; + using vessel::Subsys; + using vessel::Option; using steam::control::SteamDispatcher; diff --git a/src/steam/facade.hpp b/src/steam/facade.hpp index 578db2179..36e6797d4 100644 --- a/src/steam/facade.hpp +++ b/src/steam/facade.hpp @@ -28,7 +28,7 @@ #define STEAM_INTERFACE_FACADE_H -#include "common/subsys.hpp" +#include "vessel/subsys.hpp" @@ -51,18 +51,18 @@ namespace steam { */ struct Facade { - /** provide a descriptor for lumiera::AppState, + /** provide a descriptor for the vessel::Voyage, * wired accordingly to allow `main()` to boot * the support infrastructure for loading of * and working on the editing session. */ - static lumiera::Subsys& getSessionDescriptor(); + static vessel::Subsys& getSessionDescriptor(); - /** provide a descriptor for lumiera::AppState, + /** provide a descriptor for vessel::Voyage, * wired accordingly to allow `main()` to bring up * the render / playback coordination and * output management subsystem. */ - static lumiera::Subsys& getPlayOutDescriptor(); + static vessel::Subsys& getPlayOutDescriptor(); //////////////////TODO: define the global access interfaces for the Steam-Layer diff --git a/src/steam/mobject/builder/operationpoint.cpp b/src/steam/mobject/builder/operationpoint.cpp index 9be3c4695..4c9ce2e69 100644 --- a/src/steam/mobject/builder/operationpoint.cpp +++ b/src/steam/mobject/builder/operationpoint.cpp @@ -26,7 +26,7 @@ #include "steam/asset/proc.hpp" #include "steam/engine/node-factory.hpp" #include "steam/streamtype.hpp" -//#include "common/util.hpp" +//#include "vessel/util.hpp" //#include diff --git a/src/steam/mobject/builder/operationpoint.hpp b/src/steam/mobject/builder/operationpoint.hpp index af2f2e84b..992209454 100644 --- a/src/steam/mobject/builder/operationpoint.hpp +++ b/src/steam/mobject/builder/operationpoint.hpp @@ -28,7 +28,7 @@ #define MOBJECT_BUILDER_OPERATIONPOINT_H //#include "steam/engine/proc-node.hpp" /////TODO can we get rid of this header here? -//#include "common/query.hpp" +//#include "vessel/query.hpp" #include "lib/hash-standard.hpp" #include diff --git a/src/steam/mobject/output-designation.cpp b/src/steam/mobject/output-designation.cpp index 1d4c97272..7897116c4 100644 --- a/src/steam/mobject/output-designation.cpp +++ b/src/steam/mobject/output-designation.cpp @@ -31,7 +31,7 @@ #include "lib/error.hpp" #include "lib/symbol.hpp" #include "lib/query-util.hpp" -#include "common/query/query-resolver.hpp" +#include "vessel/query/query-resolver.hpp" #include "steam/mobject/mobject.hpp" #include "steam/mobject/placement-ref.hpp" #include "steam/mobject/output-designation.hpp" @@ -42,8 +42,9 @@ #include #include -using lumiera::Symbol; -using lumiera::query::QueryHandler; +using lib::Symbol; +using vessel::Query; +using vessel::query::QueryHandler; using lib::query::removeTerm; using lib::query::extractID; using steam::ConfigResolver; @@ -53,9 +54,9 @@ using util::uNum; namespace steam { namespace mobject { - typedef OutputDesignation::PPipe PPipe; - typedef OutputDesignation::PID PID; - typedef OutputDesignation::TargetSpec TargetSpec; + using PPipe = OutputDesignation::PPipe; + using PID = OutputDesignation::PID; + using TargetSpec = OutputDesignation::TargetSpec; struct AbsoluteSpec diff --git a/src/steam/mobject/output-mapping.hpp b/src/steam/mobject/output-mapping.hpp index 7e53cb440..be4e3f9aa 100644 --- a/src/steam/mobject/output-mapping.hpp +++ b/src/steam/mobject/output-mapping.hpp @@ -47,7 +47,7 @@ #include "lib/util.hpp" #include "lib/hash-value.h" #include "steam/asset/pipe.hpp" -#include "common/query.hpp" +#include "vessel/query.hpp" #include #include @@ -87,7 +87,7 @@ namespace mobject { }//(End) type rebinding helper namespace error = lumiera::error; - using lumiera::Query; + using vessel::Query; using lib::HashVal; diff --git a/src/steam/mobject/session.hpp b/src/steam/mobject/session.hpp index 919e66039..455a3d051 100644 --- a/src/steam/mobject/session.hpp +++ b/src/steam/mobject/session.hpp @@ -43,7 +43,7 @@ #include "steam/mobject/placement.hpp" #include "steam/mobject/mobject-ref.hpp" -#include "common/query/defs-manager.hpp" ////////////////////////////TICKET #643 forward declare this? +#include "vessel/query/defs-manager.hpp" ////////////////////////////TICKET #643 forward declare this? #include "lib/depend.hpp" #include "lib/symbol.hpp" #include "lib/p.hpp" @@ -101,7 +101,7 @@ namespace mobject { : util::NonCopyable { protected: - typedef lumiera::query::DefsManager& DefaultsAccess; + typedef vessel::query::DefsManager& DefaultsAccess; typedef session::ElementQuery& ElementsAccess; typedef std::vector const& TimelineAccess; typedef std::vector const& SequenceAccess; diff --git a/src/steam/mobject/session/lifecycle-advisor.hpp b/src/steam/mobject/session/lifecycle-advisor.hpp index d4a32cb04..b331838f1 100644 --- a/src/steam/mobject/session/lifecycle-advisor.hpp +++ b/src/steam/mobject/session/lifecycle-advisor.hpp @@ -30,7 +30,7 @@ ** ** @see SessManager ** @see LifecycleHook - ** @see lumiera::AppState + ** @see vessel::Voyage ** @see session.hpp ** @see sess-manager-impl.cpp concrete definition of Lifecycle ** @@ -42,7 +42,7 @@ #include "lib/error.hpp" #include "lib/nocopy.hpp" -#include "include/lifecycle.h" +#include "include/lifecycle.hpp" #include "steam/mobject/session.hpp" #include "lib/symbol.hpp" @@ -119,7 +119,7 @@ namespace session { void emitEvent (Symbol eventLabel) { - lumiera::LifecycleHook::trigger (eventLabel); + vessel::LifecycleHook::trigger (eventLabel); } diff --git a/src/steam/mobject/session/mobjectfactory.cpp b/src/steam/mobject/session/mobjectfactory.cpp index 2ce145e64..0a1c34f39 100644 --- a/src/steam/mobject/session/mobjectfactory.cpp +++ b/src/steam/mobject/session/mobjectfactory.cpp @@ -27,9 +27,9 @@ #include "steam/mobject/session/binding.hpp" #include "steam/asset/clip.hpp" #include "steam/asset/effect.hpp" -#include "common/query/defs-manager.hpp" +#include "vessel/query/defs-manager.hpp" -using lumiera::query::DefsManager; +using vessel::query::DefsManager; namespace steam { namespace mobject { diff --git a/src/steam/mobject/session/mobjectfactory.hpp b/src/steam/mobject/session/mobjectfactory.hpp index 6821eed13..29e057299 100644 --- a/src/steam/mobject/session/mobjectfactory.hpp +++ b/src/steam/mobject/session/mobjectfactory.hpp @@ -28,7 +28,7 @@ #include "lib/symbol.hpp" -namespace lumiera { +namespace vessel{ namespace query { class DefsManager; }} @@ -66,7 +66,7 @@ namespace session { public: - Placement operator() (lumiera::query::DefsManager&); + Placement operator() (vessel::query::DefsManager&); Placement operator() (asset::Clip const&, asset::Media const&); Placement operator() (asset::Clip const&, vector); Placement operator() (lib::idi::EntryID const&); diff --git a/src/steam/mobject/session/placement-index-query-resolver.cpp b/src/steam/mobject/session/placement-index-query-resolver.cpp index 1decae585..c9c8a3c62 100644 --- a/src/steam/mobject/session/placement-index-query-resolver.cpp +++ b/src/steam/mobject/session/placement-index-query-resolver.cpp @@ -36,10 +36,10 @@ namespace session { using std::unique_ptr; - using lumiera::Goal; - using lumiera::Query; - using lumiera::Resolution; - using lumiera::getResultTypeID; + using vessel::Goal; + using vessel::Query; + using vessel::Resolution; + using vessel::getResultTypeID; typedef PlacementIndex::ID PID; @@ -191,7 +191,7 @@ namespace session { * there is a smart-ptr managing this ResultSet. */ class ResultSet - : public lumiera::Resolution + : public vessel::Resolution { ContentFilter acceptable_; ExplorerBuilder buildExploartion_; diff --git a/src/steam/mobject/session/placement-index-query-resolver.hpp b/src/steam/mobject/session/placement-index-query-resolver.hpp index fda97815a..a4c3bc879 100644 --- a/src/steam/mobject/session/placement-index-query-resolver.hpp +++ b/src/steam/mobject/session/placement-index-query-resolver.hpp @@ -50,7 +50,7 @@ #include "steam/mobject/session/placement-index.hpp" #include "steam/mobject/session/scope-query.hpp" -#include "common/query.hpp" +#include "vessel/query.hpp" #include @@ -60,7 +60,7 @@ namespace mobject { namespace session { using std::function; - using lumiera::Goal; + using vessel::Goal; typedef PlacementIndex& IndexLink(void); @@ -79,7 +79,7 @@ namespace session { * * more generally, any ScopeQuery with these properties, in some variations */ class PlacementIndexQueryResolver - : public lumiera::QueryResolver + : public vessel::QueryResolver { function _getIndex; @@ -98,7 +98,7 @@ namespace session { void defineHandling(); template - lumiera::Resolution* resolutionFunction (Goal const& goal); + vessel::Resolution* resolutionFunction (Goal const& goal); public: diff --git a/src/steam/mobject/session/query/fake-configrules.cpp b/src/steam/mobject/session/query/fake-configrules.cpp index 48ad184ff..4e11aa1cc 100644 --- a/src/steam/mobject/session/query/fake-configrules.cpp +++ b/src/steam/mobject/session/query/fake-configrules.cpp @@ -34,7 +34,7 @@ #include "steam/asset/procpatt.hpp" #include "steam/asset/pipe.hpp" #include "lib/query-util.hpp" -#include "common/query.hpp" +#include "vessel/query.hpp" #include "include/logging.h" #include "lib/symbol.hpp" diff --git a/src/steam/mobject/session/query/fake-configrules.hpp b/src/steam/mobject/session/query/fake-configrules.hpp index 3e75238a3..4c05a6561 100644 --- a/src/steam/mobject/session/query/fake-configrules.hpp +++ b/src/steam/mobject/session/query/fake-configrules.hpp @@ -28,8 +28,8 @@ ** away, some day the real thing will be there, displacing this mess without further notice. ** @todo to be removed in Alpha, when integrating a real resolution engine /////////////////TICKET #710 ** - ** @see lumiera::Query - ** @see lumiera::ConfigRules + ** @see vessel::Query + ** @see vessel::ConfigRules ** */ @@ -64,9 +64,9 @@ namespace session { using lib::meta::InstantiateChained; using lib::P; - using lumiera::Query; - using lumiera::QueryKey; - using lumiera::query::isFakeBypass; /////////TODO placeholder until there is a real resolution engine + using vessel::Query; + using vessel::QueryKey; + using vessel::query::isFakeBypass; /////////TODO placeholder until there is a real resolution engine using util::contains; using util::isnil; diff --git a/src/steam/mobject/session/root.cpp b/src/steam/mobject/session/root.cpp index ee89fb7bb..d71ac75eb 100644 --- a/src/steam/mobject/session/root.cpp +++ b/src/steam/mobject/session/root.cpp @@ -19,9 +19,9 @@ #include "steam/mobject/session/root.hpp" -#include "common/query/defs-manager.hpp" +#include "vessel/query/defs-manager.hpp" -using lumiera::query::DefsManager; +using vessel::query::DefsManager; using lib::idi::EntryID; namespace steam { diff --git a/src/steam/mobject/session/root.hpp b/src/steam/mobject/session/root.hpp index 54075b50e..fcdec9d07 100644 --- a/src/steam/mobject/session/root.hpp +++ b/src/steam/mobject/session/root.hpp @@ -33,7 +33,7 @@ #include "lib/idi/entry-id.hpp" -namespace lumiera { +namespace vessel { namespace query { class DefsManager; }} @@ -59,7 +59,7 @@ namespace session { */ class Root : public Meta { - lumiera::query::DefsManager& defaults_; + vessel::query::DefsManager& defaults_; ///////////TODO: timespan fields here or already in class Meta?? ///////////TODO: any idea about the purpose of root's "timespan"?? ///////TICKET #448 @@ -73,7 +73,7 @@ namespace session { virtual bool isValid() const; public: - Root (lumiera::query::DefsManager&); + Root (vessel::query::DefsManager&); static lib::idi::EntryID getID(); static lib::idi::EntryID getAssetID(); diff --git a/src/steam/mobject/session/scope-locator.hpp b/src/steam/mobject/session/scope-locator.hpp index 1f13dd265..8e4d704dc 100644 --- a/src/steam/mobject/session/scope-locator.hpp +++ b/src/steam/mobject/session/scope-locator.hpp @@ -93,7 +93,7 @@ namespace session { friend class lib::DependencyFactory; private: - lumiera::QueryResolver const& theResolver(); + vessel::QueryResolver const& theResolver(); }; diff --git a/src/steam/mobject/session/scope-query.hpp b/src/steam/mobject/session/scope-query.hpp index 84b45ee5d..9f1a6f981 100644 --- a/src/steam/mobject/session/scope-query.hpp +++ b/src/steam/mobject/session/scope-query.hpp @@ -34,7 +34,7 @@ #include "steam/mobject/placement.hpp" -#include "common/query/query-resolver.hpp" +#include "vessel/query/query-resolver.hpp" #include "lib/format-string.hpp" #include @@ -48,8 +48,8 @@ namespace session { using std::function; using std::placeholders::_1; - using lumiera::Goal; - using lumiera::Query; + using vessel::Goal; + using vessel::Query; diff --git a/src/steam/mobject/session/scope.cpp b/src/steam/mobject/session/scope.cpp index 031bda956..f1f70f651 100644 --- a/src/steam/mobject/session/scope.cpp +++ b/src/steam/mobject/session/scope.cpp @@ -35,7 +35,7 @@ #include "steam/mobject/session/session-service-explore-scope.hpp" #include "steam/mobject/mobject.hpp" #include "lib/iter-source.hpp" ////////////////////TICKET #493 : only using the IterSource wrapIter adapter here -#include "common/query/query-resolver.hpp" +#include "vessel/query/query-resolver.hpp" #include @@ -115,7 +115,7 @@ namespace session { * of contents discovery queries to the PlacementIndex * managed within the session */ - lumiera::QueryResolver const& + vessel::QueryResolver const& ScopeLocator::theResolver() { return SessionServiceExploreScope::getResolver(); diff --git a/src/steam/mobject/session/sess-manager-impl.cpp b/src/steam/mobject/session/sess-manager-impl.cpp index 6e80e4508..0b55ea23b 100644 --- a/src/steam/mobject/session/sess-manager-impl.cpp +++ b/src/steam/mobject/session/sess-manager-impl.cpp @@ -36,8 +36,8 @@ #include "steam/control/steam-dispatcher.hpp" #include "steam/config-resolver.hpp" #include "steam/asset/timeline.hpp" -#include "common/query/defs-manager.hpp" -#include "common/query.hpp" +#include "vessel/query/defs-manager.hpp" +#include "vessel/query.hpp" #include #include @@ -119,7 +119,7 @@ namespace session { REQUIRE (0 == session_->timelines.size(), "injecting default timeline, but session isn't pristine"); // issue a default query to retrieve or create a Timeline and a default Sequence - asset::PTimeline initialTimeline = session_->defaults (lumiera::Query ("")); + asset::PTimeline initialTimeline = session_->defaults (vessel::Query ("")); // these got registered automatically ENSURE (1 == session_->timelines.size()); diff --git a/src/steam/mobject/session/session-interface-modules.hpp b/src/steam/mobject/session/session-interface-modules.hpp index 141a4c847..31afc3ce9 100644 --- a/src/steam/mobject/session/session-interface-modules.hpp +++ b/src/steam/mobject/session/session-interface-modules.hpp @@ -65,7 +65,7 @@ #include "steam/asset/timeline.hpp" #include "steam/asset/sequence.hpp" #include "steam/mobject/session/element-query.hpp" -#include "common/query/defs-manager.hpp" +#include "vessel/query/defs-manager.hpp" @@ -87,7 +87,7 @@ namespace session { struct SessionInterfaceModules : util::NonCopyable { - lumiera::query::DefsManager defaultsManager_; + vessel::query::DefsManager defaultsManager_; mobject::session::ElementQuery elementQueryAPI_; TimelineTracker timelineRegistry_; SequenceTracker sequenceRegistry_; diff --git a/src/steam/mobject/session/session-service-explore-scope.hpp b/src/steam/mobject/session/session-service-explore-scope.hpp index e6082aa4b..8883d7875 100644 --- a/src/steam/mobject/session/session-service-explore-scope.hpp +++ b/src/steam/mobject/session/session-service-explore-scope.hpp @@ -38,7 +38,7 @@ #define MOBJECT_SESSION_SESSION_SERVICE_EXPLORE_SCOPE_H #include "steam/mobject/placement.hpp" -#include "common/query/query-resolver.hpp" +#include "vessel/query/query-resolver.hpp" @@ -59,7 +59,7 @@ namespace session { */ struct SessionServiceExploreScope { - static lumiera::QueryResolver const& getResolver(); + static vessel::QueryResolver const& getResolver(); static PlacementMO& getScope (PlacementMO const&); static PlacementMO& getScope (PlacementMO::ID const&); diff --git a/src/steam/mobject/session/session.cpp b/src/steam/mobject/session/session.cpp index f72aecd42..b8f39bd88 100644 --- a/src/steam/mobject/session/session.cpp +++ b/src/steam/mobject/session/session.cpp @@ -25,7 +25,7 @@ #include "steam/mobject/session.hpp" #include "steam/mobject/session/session-impl.hpp" #include "steam/mobject/session/sess-manager-impl.hpp" -//#include "common/query/defs-manager.hpp" +//#include "vessel/query/defs-manager.hpp" #include "lib/symbol.hpp" #include "lib/depend.hpp" diff --git a/src/steam/mobject/session/specific-contents-query.hpp b/src/steam/mobject/session/specific-contents-query.hpp index b521103e7..ae7abf644 100644 --- a/src/steam/mobject/session/specific-contents-query.hpp +++ b/src/steam/mobject/session/specific-contents-query.hpp @@ -28,7 +28,7 @@ #include "steam/mobject/session/scope-query.hpp" #include "steam/mobject/placement.hpp" -#include "common/query/query-resolver.hpp" +#include "vessel/query/query-resolver.hpp" #include @@ -39,7 +39,7 @@ namespace session { using std::function; - using lumiera::QueryResolver; + using vessel::QueryResolver; /** diff --git a/src/steam/play/output-director.hpp b/src/steam/play/output-director.hpp index 93e402c89..fdf946ad1 100644 --- a/src/steam/play/output-director.hpp +++ b/src/steam/play/output-director.hpp @@ -30,16 +30,17 @@ #include "lib/depend.hpp" #include "lib/depend-inject.hpp" #include "steam/play/output-manager.hpp" -#include "common/subsys.hpp" +#include "vessel/subsys.hpp" #include "lib/nocopy.hpp" #include "lib/sync.hpp" #include -namespace lumiera { +namespace vessel { +namespace spine { class Play; -} +}} namespace steam { namespace play { @@ -61,8 +62,8 @@ namespace play { : util::NonCopyable , public lib::Sync<> { - using SigTerm = lumiera::Subsys::SigTerm; - using PlayServiceHandle = lib::DependInject::ServiceInstance; + using SigTerm = vessel::Subsys::SigTerm; + using PlayServiceHandle = lib::DependInject::ServiceInstance; PlayServiceHandle player_; ///////TODO more components and connections to manage here... diff --git a/src/steam/play/play-controller.cpp b/src/steam/play/play-controller.cpp index a460b42ed..ce457e697 100644 --- a/src/steam/play/play-controller.cpp +++ b/src/steam/play/play-controller.cpp @@ -15,18 +15,17 @@ /** @file play-controller.cpp ** Implementation of the control- / management frontend(s) exposed ** to clients for talking to an ongoing PlayProcess. This includes - ** the implementation of lumiera::Play::Controller, exposed directly + ** the implementation of vessel::spine::Play::Controller, exposed directly ** from the Player facade interface. Besides that primary control ** interface, this translation unit also contains the implementation ** for several extended play controllers targeted at special usage ** situations ** - ** @see lumiera::DummyPlayer ** @see stage::PlaybackController usage example */ -#include "steam/play/play-controller.hpp" +#include "vessel/spine/play-facade.hpp" #include "steam/play/play-process.hpp" #include "lib/time/timevalue.hpp" @@ -34,7 +33,8 @@ //#include //#include -namespace lumiera { +namespace vessel { +namespace spine { using lib::time::Time; using lib::time::Duration; @@ -191,14 +191,14 @@ namespace lumiera { -} +}}// namespace vessel::spine namespace steam{ namespace play{ // using std::string; -// using lumiera::Subsys; +// using vessel::Subsys; // using std::bind; diff --git a/src/steam/play/play-controller.hpp b/src/steam/play/play-controller.hpp deleted file mode 100644 index ab9f19e1e..000000000 --- a/src/steam/play/play-controller.hpp +++ /dev/null @@ -1,60 +0,0 @@ -/* - PLAY-CONTROLLER.hpp - frontend handle to control an play process - - Copyright (C) - 2011, Hermann Vosseler - -  **Lumiera** 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. See the file COPYING for further details. - -*/ - -/** @file play-controller.hpp - ** Functionality for driving and controlling an ongoing playback or render. - ** - ** @see lumiera::DummyPlayer - ** @see stage::PlaybackController usage example - */ - - -#ifndef STEAM_PLAY_PLAY_CONTROLLER_H -#define STEAM_PLAY_PLAY_CONTROLLER_H - - -#include "steam/play/play-service.hpp" -//#include "include/display-facade.h" -//#include "common/instancehandle.hpp" -//#include "lib/singleton-ref.hpp" -#include "lib/nocopy.hpp" - -//#include - - -namespace steam { -namespace play { - - using std::string; - - - /****************************************************************//** - * TODO do we still need that?????? - * Isn't lumiera::Play::Controller already sufficient? - */ - class PlayController - : util::NonCopyable - { - - public: - - private: - }; - - - - - - -}} // namespace steam::play -#endif diff --git a/src/steam/play/play-process.cpp b/src/steam/play/play-process.cpp index 5cfd2751a..ad96fa114 100644 --- a/src/steam/play/play-process.cpp +++ b/src/steam/play/play-process.cpp @@ -34,7 +34,7 @@ namespace steam { namespace play { // using std::string; -// using lumiera::Subsys; +// using vessel::Subsys; // using std::bind; diff --git a/src/steam/play/play-process.hpp b/src/steam/play/play-process.hpp index 8ac6c3386..01619ba72 100644 --- a/src/steam/play/play-process.hpp +++ b/src/steam/play/play-process.hpp @@ -33,7 +33,6 @@ ** the playback or rendering state and goals, which then causes the PlayProcess ** to reconfigure the ongoing or planned calculations. ** - ** @see lumiera::DummyPlayer ** @see stage::PlaybackController usage example */ @@ -46,7 +45,7 @@ #include "lib/nocopy.hpp" //#include "include/dummy-player-facade.h" //#include "include/display-facade.h" -//#include "common/instancehandle.hpp" +//#include "vessel/instancehandle.hpp" //#include "lib/singleton-ref.hpp" #include "steam/mobject/model-port.hpp" #include "steam/engine/calc-stream.hpp" @@ -62,9 +61,9 @@ namespace steam { namespace play { // using std::string; -// using lumiera::Subsys; -// using lumiera::Display; -// using lumiera::DummyPlayer; +// using vessel::Subsys; +// using vessel::Display; +// using vessel::DummyPlayer; using util::isnil; using steam::mobject::ModelPort; using std::function; @@ -114,7 +113,7 @@ namespace play { * * @note PlayProcess entities are never directly visible. * Client code handles and controls these processes - * through a lumiera::Play::Controller returned + * through a vessel::spine::Play::Controller returned * from the PlayService. */ class PlayProcess diff --git a/src/steam/play/play-service.cpp b/src/steam/play/play-service.cpp index 5be3aefd9..a28ed7a59 100644 --- a/src/steam/play/play-service.cpp +++ b/src/steam/play/play-service.cpp @@ -21,7 +21,8 @@ #include "lib/error.hpp" -#include "include/play-facade.hpp" +#include "lib/sync.hpp" +#include "vessel/spine/play-facade.hpp" #include "steam/play/play-service.hpp" #include "steam/play/play-process.hpp" #include "steam/play/render-configurator.hpp" @@ -35,8 +36,13 @@ #include - namespace lumiera { + namespace error { + LUMIERA_ERROR_DEFINE (CANT_PLAY, "unable to build playback or render process for this configuration"); +} } + +namespace vessel { +namespace spine { Play::~Play() { } // emit VTables here... @@ -44,18 +50,14 @@ namespace lumiera { /** static storage for the facade access front-end */ lib::Depend Play::facade; - - namespace error { - LUMIERA_ERROR_DEFINE (CANT_PLAY, "unable to build playback or render process for this configuration"); - } -}//(End) namespace lumiera +}}//(End) namespace vessel::spine namespace steam { namespace play { //using std::string; -//using lumiera::Subsys; +//using vessel::Subsys; //using std::bind; using lib::Sync; using lib::RecursiveLock_NoWait; @@ -77,7 +79,7 @@ namespace play { } // (End) hidden service impl details - using lumiera::Play; + using vessel::spine::Play; typedef POutputManager Output; @@ -155,7 +157,7 @@ namespace play { * This service allows to create individual PlayProcess instances * to \em perform a timeline or similar model object, creating * rendered data for output. Client code is assumed to access - * this service through the lumiera::Play facade. + * this service through the vessel::spine::Play facade. */ PlayService::PlayService() : pTable_(new ProcessTable) @@ -196,7 +198,8 @@ namespace play { }} // namespace steam::play -namespace lumiera { +namespace vessel { +namespace spine { /* ==== convenience shortcuts for creating a PlayProcess ==== */ @@ -265,4 +268,4 @@ namespace lumiera { } -} +}}// namespace vessel::spine diff --git a/src/steam/play/play-service.hpp b/src/steam/play/play-service.hpp index 9bdbd11de..b55c4b9d6 100644 --- a/src/steam/play/play-service.hpp +++ b/src/steam/play/play-service.hpp @@ -14,7 +14,7 @@ /** @file play-service.hpp ** Primary service of the Player subsystem: Starting and controlling render/playback. ** This is the implementation level service interface for the "Player". Client code - ** should access this service through the lumiera::Play facade interface. + ** should access this service through the vessel::spine::Play facade interface. ** ** The player and render control subsystem allows to start and control playback and ** rendering at any given collection of model ports (the conceptual exit points @@ -50,7 +50,7 @@ #include "lib/error.hpp" #include "lib/nocopy.hpp" -#include "include/play-facade.hpp" +#include "vessel/spine/play-facade.hpp" #include //#include @@ -65,9 +65,6 @@ namespace steam { namespace play { using std::string; -//using lumiera::Subsys; -//using lumiera::Display; -//using lumiera::DummyPlayer; // class DummyImageGenerator; @@ -91,10 +88,10 @@ namespace play { * by the OutputDirector, which acts as a central hub * for the Player subsystem. Clients should always * access this functionality through the - * lumiera::Play facade interface. + * vessel::spine::Play facade interface. */ class PlayService - : public lumiera::Play + : public vessel::spine::Play , util::NonCopyable { std::unique_ptr pTable_; diff --git a/src/steam/play/render-configurator.cpp b/src/steam/play/render-configurator.cpp index 58f5ed405..7472eb26a 100644 --- a/src/steam/play/render-configurator.cpp +++ b/src/steam/play/render-configurator.cpp @@ -37,7 +37,6 @@ namespace play { namespace error = lumiera::error; // using std::string; -// using lumiera::Subsys; using std::shared_ptr; using std::bind; using std::placeholders::_1; diff --git a/src/steam/play/render-configurator.hpp b/src/steam/play/render-configurator.hpp index de1c7b9e0..c25211907 100644 --- a/src/steam/play/render-configurator.hpp +++ b/src/steam/play/render-configurator.hpp @@ -31,7 +31,7 @@ #include "lib/nocopy.hpp" //#include "include/dummy-player-facade.h" //#include "include/display-facade.h" -//#include "common/instancehandle.hpp" +//#include "vessel/instancehandle.hpp" //#include "lib/singleton-ref.hpp" #include "steam/mobject/model-port.hpp" #include "steam/play/play-process.hpp" @@ -50,9 +50,6 @@ namespace steam { namespace play { // using std::string; -// using lumiera::Subsys; -// using lumiera::Display; -// using lumiera::DummyPlayer; // using util::isnil; using std::function; using steam::mobject::ModelPort; diff --git a/src/steam/play/sound/jack-output.hpp b/src/steam/play/sound/jack-output.hpp index 31e04b3a2..e8ccf63cc 100644 --- a/src/steam/play/sound/jack-output.hpp +++ b/src/steam/play/sound/jack-output.hpp @@ -15,8 +15,6 @@ ** ** @todo empty placeholder to underpin the claim: yes we will support Jack Audio! ** - ** @see lumiera::Display - ** @see lumiera::DummyPlayer ** @see stage::PlaybackController usage example */ @@ -26,7 +24,7 @@ //#include "include/display-facade.h" -//#include "common/instancehandle.hpp" +//#include "vessel/instancehandle.hpp" //#include "lib/singleton-ref.hpp" //#include "lib/scoped-ptrvect.hpp" // diff --git a/src/steam/streamtype.hpp b/src/steam/streamtype.hpp index affcd4fa5..719f9e175 100644 --- a/src/steam/streamtype.hpp +++ b/src/steam/streamtype.hpp @@ -26,7 +26,7 @@ #define STEAM_STREAMTYPE_H #include "lib/symbol.hpp" -//#include "common/query.hpp" +//#include "vessel/query.hpp" #include "lib/idi/entry-id.hpp" @@ -184,10 +184,4 @@ namespace steam { } // namespace steam - - -namespace lumiera { - using steam::StreamType; -} - #endif /*STEAM_STREAMTYPE_H*/ diff --git a/src/vault/enginefacade.cpp b/src/vault/enginefacade.cpp index ee9043e49..3b71020b2 100644 --- a/src/vault/enginefacade.cpp +++ b/src/vault/enginefacade.cpp @@ -33,7 +33,8 @@ namespace vault { using std::string; - using lumiera::Subsys; + using vessel::Subsys; + using vessel::Option; class EngineSubsysDescriptor : public Subsys @@ -41,14 +42,14 @@ namespace vault { operator string () const { return "Engine"; } bool - shouldStart (lumiera::Option&) override + shouldStart (Option&) override { TODO ("determine, if renderengine should be started"); return false; } bool - start (lumiera::Option&, Subsys::SigTerm termination) override + start (Option&, Subsys::SigTerm termination) override { UNIMPLEMENTED ("pull up renderengine and register shutdown hook"); return false; diff --git a/src/vault/enginefacade.hpp b/src/vault/enginefacade.hpp index 0acf53d5f..9c2e2f42b 100644 --- a/src/vault/enginefacade.hpp +++ b/src/vault/enginefacade.hpp @@ -25,7 +25,7 @@ #define VAULT_INTERFACE_ENGINEFACADE_H -#include "common/subsys.hpp" +#include "vessel/subsys.hpp" @@ -46,10 +46,10 @@ namespace vault { */ struct EngineFacade { - /** provide a descriptor for lumiera::AppState, + /** provide a descriptor for the vessel::Voyage, * wired accordingly to allow main to pull up and * shut down the renderengine. */ - static lumiera::Subsys& getDescriptor(); + static vessel::Subsys& getDescriptor(); //////////////////TODO: define the global access interface for the engine diff --git a/src/vault/netnodefacade.cpp b/src/vault/netnodefacade.cpp index 6582ac2bc..73c16d9e6 100644 --- a/src/vault/netnodefacade.cpp +++ b/src/vault/netnodefacade.cpp @@ -28,7 +28,8 @@ namespace vault { using std::string; - using lumiera::Subsys; + using vessel::Subsys; + using vessel::Option; class NetNodeSubsysDescriptor : public Subsys @@ -36,14 +37,14 @@ namespace vault { operator string () const { return "Renderfarm node"; } bool - shouldStart (lumiera::Option&) override + shouldStart (Option&) override { TODO ("determine, if render node service should be provided"); return false; } bool - start (lumiera::Option&, SigTerm termination) override + start (Option&, SigTerm termination) override { UNIMPLEMENTED ("open a render node server port and register shutdown hook"); return false; diff --git a/src/vault/netnodefacade.hpp b/src/vault/netnodefacade.hpp index 21898241f..ab6739b16 100644 --- a/src/vault/netnodefacade.hpp +++ b/src/vault/netnodefacade.hpp @@ -24,7 +24,7 @@ #define VAULT_INTERFACE_NETNODEFACADE_H -#include "common/subsys.hpp" +#include "vessel/subsys.hpp" @@ -43,10 +43,10 @@ namespace vault { */ struct NetNodeFacade { - /** provide a descriptor for lumiera::AppState, + /** provide a descriptor for the vessel::Voyage, * wired accordingly to allow main to start and stop * a node server accepting render / file jobs via network. */ - static lumiera::Subsys& getDescriptor(); + static vessel::Subsys& getDescriptor(); //////////////////TODO: define the global access interface for a renderfarm node server diff --git a/src/vault/scriptrunnerfacade.cpp b/src/vault/scriptrunnerfacade.cpp index c46b39f35..cb467513e 100644 --- a/src/vault/scriptrunnerfacade.cpp +++ b/src/vault/scriptrunnerfacade.cpp @@ -30,7 +30,8 @@ namespace vault { using std::string; - using lumiera::Subsys; + using vessel::Subsys; + using vessel::Option; class ScriptRunnerSubsysDescriptor : public Subsys @@ -38,14 +39,14 @@ namespace vault { operator string () const { return "Script runner"; } bool - shouldStart (lumiera::Option&) override + shouldStart (Option&) override { TODO ("determine, if a script should be executed"); return false; } bool - start (lumiera::Option&, SigTerm termination) override + start (Option&, SigTerm termination) override { UNIMPLEMENTED ("start the script as defined by the options and register script abort/exit hook"); return false; diff --git a/src/vault/scriptrunnerfacade.hpp b/src/vault/scriptrunnerfacade.hpp index 1b5a6d59e..8814156bb 100644 --- a/src/vault/scriptrunnerfacade.hpp +++ b/src/vault/scriptrunnerfacade.hpp @@ -24,7 +24,7 @@ #define VAULT_INTERFACE_SCRIPTRUNNERFACADE_H -#include "common/subsys.hpp" +#include "vessel/subsys.hpp" @@ -41,10 +41,10 @@ namespace vault { */ struct ScriptRunnerFacade { - /** provide a descriptor for lumiera::AppState, + /** provide a descriptor for the vessel::Voyage, * wired accordingly to allow main to start a script and to * (prematurely) abort a running script. */ - static lumiera::Subsys& getDescriptor(); + static vessel::Subsys& getDescriptor(); //////////////////TODO: define the access interface for starting a (LUA, C, ...)-script diff --git a/src/vessel/DIR_INFO b/src/vessel/DIR_INFO new file mode 100644 index 000000000..800d8321d --- /dev/null +++ b/src/vessel/DIR_INFO @@ -0,0 +1 @@ +Main application and backbone diff --git a/src/common/advice.hpp b/src/vessel/advice.hpp similarity index 99% rename from src/common/advice.hpp rename to src/vessel/advice.hpp index 5016d02f7..4b9733aef 100644 --- a/src/common/advice.hpp +++ b/src/vessel/advice.hpp @@ -86,8 +86,8 @@ */ -#ifndef LUMIERA_ADVICE_H -#define LUMIERA_ADVICE_H +#ifndef VESSEL_ADVICE_H +#define VESSEL_ADVICE_H #include "lib/error.hpp" @@ -96,10 +96,10 @@ #include "lib/symbol.hpp" #include "lib/util.hpp" -#include "common/advice/binding.hpp" +#include "vessel/advice/binding.hpp" -namespace lumiera{ +namespace vessel { namespace advice { using lib::Literal; @@ -492,5 +492,5 @@ namespace advice { -}} // namespace lumiera::advice -#endif +}} // namespace vessel::advice +#endif /*VESSEL_ADVICE_H*/ diff --git a/src/common/advice/advice.cpp b/src/vessel/advice/advice.cpp similarity index 99% rename from src/common/advice/advice.cpp rename to src/vessel/advice/advice.cpp index f246f62d2..7abe1ac9b 100644 --- a/src/common/advice/advice.cpp +++ b/src/vessel/advice/advice.cpp @@ -90,8 +90,8 @@ #include "lib/sync.hpp" #include "lib/util.hpp" #include "include/logging.h" -#include "common/advice.hpp" -#include "common/advice/index.hpp" +#include "vessel/advice.hpp" +#include "vessel/advice/index.hpp" using lib::Literal; @@ -101,7 +101,7 @@ using util::unConst; typedef void (DeleterFunc)(void*); -namespace lumiera{ +namespace vessel { namespace advice { namespace { // ======= implementation of the AdviceSystem ============ @@ -352,4 +352,4 @@ namespace advice { -}} // namespace lib::advice +}} // namespace lib::vessel diff --git a/src/common/advice/binding.cpp b/src/vessel/advice/binding.cpp similarity index 98% rename from src/common/advice/binding.cpp rename to src/vessel/advice/binding.cpp index 76c077b90..0f2b88a62 100644 --- a/src/common/advice/binding.cpp +++ b/src/vessel/advice/binding.cpp @@ -21,7 +21,7 @@ */ -#include "common/advice/binding.hpp" +#include "vessel/advice/binding.hpp" #include "lib/symbol.hpp" #include "lib/util.hpp" @@ -41,7 +41,7 @@ using boost::hash_combine; using boost::lexical_cast; -namespace lumiera{ +namespace vessel { namespace advice { LUMIERA_ERROR_DEFINE (BINDING_PATTERN_SYNTAX, "Unable to parse the given binding pattern definition"); @@ -191,4 +191,4 @@ namespace advice { -}} // namespace lumiera::advice +}} // namespace vessel::advice diff --git a/src/common/advice/binding.hpp b/src/vessel/advice/binding.hpp similarity index 98% rename from src/common/advice/binding.hpp rename to src/vessel/advice/binding.hpp index ea0c15082..060df9b15 100644 --- a/src/common/advice/binding.hpp +++ b/src/vessel/advice/binding.hpp @@ -62,8 +62,8 @@ */ -#ifndef LUMIERA_ADVICE_BINDING_H -#define LUMIERA_ADVICE_BINDING_H +#ifndef VESSEL_ADVICE_BINDING_H +#define VESSEL_ADVICE_BINDING_H #include "lib/error.hpp" @@ -75,7 +75,7 @@ #include -namespace lumiera{ +namespace vessel { namespace advice { using lib::Literal; @@ -285,5 +285,5 @@ namespace advice { -}} // namespace lumiera::advice -#endif +}} // namespace vessel::advice +#endif /*VESSEL_ADVICE_BINDING_H*/ diff --git a/src/common/advice/index.hpp b/src/vessel/advice/index.hpp similarity index 97% rename from src/common/advice/index.hpp rename to src/vessel/advice/index.hpp index 6e4d3339b..eec0db14b 100644 --- a/src/common/advice/index.hpp +++ b/src/vessel/advice/index.hpp @@ -14,22 +14,23 @@ /** @file index.hpp ** Implementation datastructure for use by the Advice system. - ** To support the \em Advice collaboration, it is necessary to match advice requests with + ** To support the **Advice** collaboration, it is necessary to match advice requests with ** existing advice provisions. Each successful match creates an advice solution, resulting in ** the bound piece of advice (data) to become visible to all the advised entities having placed ** a matching advice request into the advice system. ** ** This header is intended to be incorporated as part of the advice system implementation (advice.cpp). - ** It is \em not usable as an external interface. But it is written in a rather self-contained manner, + ** It is _not usable as an external interface_. But it is written in a rather self-contained manner, ** in order to be testable in isolation. To this end, the actual PointOfAdvice entities \a POA organised ** by this index datastructure remain abstract (defined as template parameter), and are only manipulated ** through the following functions: - ** - \c hash_value(POA) - ** - \c POA::getMatcher() - ** - \c POA::getSolution() - ** - \c POA::setSolution(solution*) + ** - `hash_value(POA)` + ** - `POA::getMatcher()` + ** - `POA::getSolution()` + ** - `POA::setSolution(solution*)` + ** + ** # Implementation notes ** - ** \par implementation notes ** The advice binding index is implemented by two hashtables holding Binding::Matcher entries. ** Each entry associates a back-link to the corresponding POA (PointOfAdvice), which is assumed ** to be maintained outside the index. PointOfAdvice is an type-erased interface baseclass. @@ -74,8 +75,8 @@ */ -#ifndef LUMIERA_ADVICE_INDEX_H -#define LUMIERA_ADVICE_INDEX_H +#ifndef VESSEL_ADVICE_INDEX_H +#define VESSEL_ADVICE_INDEX_H #include "lib/error.hpp" @@ -85,12 +86,12 @@ #include "lib/format-obj.hpp" #include "lib/util-foreach.hpp" #include "lib/util.hpp" -#include "common/advice/binding.hpp" +#include "vessel/advice/binding.hpp" #include #include -namespace lumiera{ +namespace vessel { namespace advice { namespace error = lumiera::error; @@ -577,5 +578,5 @@ namespace advice { #undef VERIFY -}} // namespace lumiera::advice -#endif +}} // namespace vessel::advice +#endif /*VESSEL_ADVICE_INDEX_H*/ diff --git a/src/common/basic-setup.cpp b/src/vessel/basic-setup.cpp similarity index 97% rename from src/common/basic-setup.cpp rename to src/vessel/basic-setup.cpp index 3a1850c56..30fc54399 100644 --- a/src/common/basic-setup.cpp +++ b/src/vessel/basic-setup.cpp @@ -24,19 +24,16 @@ */ -#include "common/basic-setup.hpp" +#include "vessel/basic-setup.hpp" #include "lib/searchpath.hpp" #include "lib/error.hpp" #include "lib/file.hpp" #include "lib/util.hpp" -extern "C" { -#include -} #include -namespace lumiera { +namespace vessel { using std::string; using std::ifstream; @@ -113,4 +110,4 @@ namespace lumiera { -} // namespace lumiera +} // namespace vessel diff --git a/src/common/basic-setup.hpp b/src/vessel/basic-setup.hpp similarity index 92% rename from src/common/basic-setup.hpp rename to src/vessel/basic-setup.hpp index eca7abcf4..26ab0703a 100644 --- a/src/common/basic-setup.hpp +++ b/src/vessel/basic-setup.hpp @@ -35,14 +35,14 @@ ** be mapped into FSH compliant installation folders by the ** packager. ** - ** @see lumiera::AppState::AppState() + ** @see vessel::Voyage::Voyage() ** @see main.cpp ** */ -#ifndef COMMON_BASIC_SETUP_H -#define COMMON_BASIC_SETUP_H +#ifndef VESSEL_BASIC_SETUP_H +#define VESSEL_BASIC_SETUP_H #include "lib/error.hpp" #include "lib/symbol.hpp" @@ -58,11 +58,12 @@ -namespace lumiera { +namespace vessel { + namespace err = lumiera::error; + namespace opt = boost::program_options; using std::string; - namespace opt = boost::program_options; /** @@ -83,7 +84,7 @@ namespace lumiera { * configuration as a replacement for the time being. * * @see configfacade.hpp - * @see AppState + * @see vessel::Voyage */ class BasicSetup : util::NonCopyable @@ -114,10 +115,10 @@ namespace lumiera { __ensure_hasKey (string const& key) const { if (!util::contains (settings, key)) - throw error::Logic ("Key \""+key+"\" not found in setup.ini"); + throw err::Logic ("Key \""+key+"\" not found in setup.ini"); } }; -} // namespace lumiera -#endif +} // namespace vessel +#endif /*VESSEL_BASIC_SETUP_H*/ diff --git a/src/common/config-interface.c b/src/vessel/config-interface.c similarity index 98% rename from src/common/config-interface.c rename to src/vessel/config-interface.c index f80acf51e..d4966aedf 100644 --- a/src/common/config-interface.c +++ b/src/vessel/config-interface.c @@ -20,8 +20,8 @@ */ -#include "common/config-interface.h" -#include "common/config.h" +#include "vessel/config-interface.h" +#include "vessel/config.h" @@ -133,7 +133,7 @@ LUMIERA_EXPORT( #ifndef LUMIERA_PLUGIN -#include "common/interfaceregistry.h" +#include "vessel/interfaceregistry.h" void lumiera_config_interface_init (void) { diff --git a/src/common/config-interface.h b/src/vessel/config-interface.h similarity index 99% rename from src/common/config-interface.h rename to src/vessel/config-interface.h index 8945d2536..14123007a 100644 --- a/src/common/config-interface.h +++ b/src/vessel/config-interface.h @@ -29,7 +29,7 @@ #define LUMIERA_CONFIG_INTERFACE_H -#include "common/interface.h" +#include "vessel/interface.h" diff --git a/src/common/config-lookup.c b/src/vessel/config-lookup.c similarity index 99% rename from src/common/config-lookup.c rename to src/vessel/config-lookup.c index 42017df37..414438f0f 100644 --- a/src/common/config-lookup.c +++ b/src/vessel/config-lookup.c @@ -24,8 +24,8 @@ #include "lib/safeclib.h" #include "lib/tmpbuf.h" -#include "common/config-lookup.h" -#include "common/config.h" +#include "vessel/config-lookup.h" +#include "vessel/config.h" /* we only use one fatal error for now, when allocation in the config system fail, something else is pretty wrong */ LUMIERA_ERROR_DEFINE (CONFIG_LOOKUP, "config lookup failure"); diff --git a/src/common/config-lookup.h b/src/vessel/config-lookup.h similarity index 99% rename from src/common/config-lookup.h rename to src/vessel/config-lookup.h index 3b204c141..7df940fd3 100644 --- a/src/common/config-lookup.h +++ b/src/vessel/config-lookup.h @@ -39,7 +39,7 @@ typedef struct lumiera_config_lookupentry_struct lumiera_config_lookupentry; typedef lumiera_config_lookupentry* LumieraConfigLookupentry; -#include "common/configitem.h" +#include "vessel/configitem.h" #include diff --git a/src/common/config-rules.hpp b/src/vessel/config-rules.hpp similarity index 95% rename from src/common/config-rules.hpp rename to src/vessel/config-rules.hpp index b06a25eb0..0cf5c78cd 100644 --- a/src/common/config-rules.hpp +++ b/src/vessel/config-rules.hpp @@ -41,7 +41,7 @@ ** @todo as of 11/2016 the situation is basically the same: this is placeholder code ** and just implemented enough to keep us going without violating the architecture vision ** - ** @see lumiera::Query + ** @see vessel::Query ** @see mobject::session::DefsManager ** @see asset::StructFactory ** @see config-resolver.hpp specialised setup for the Steam-Layer @@ -50,13 +50,13 @@ */ -#ifndef LUMIERA_CONFIG_RULES_H -#define LUMIERA_CONFIG_RULES_H +#ifndef VESSEL_CONFIG_RULES_H +#define VESSEL_CONFIG_RULES_H #include "lib/p.hpp" #include "lib/symbol.hpp" #include "lib/meta/generator.hpp" -#include "common/query.hpp" +#include "vessel/query.hpp" #include @@ -65,11 +65,12 @@ namespace lumiera { namespace error { LUMIERA_ERROR_DECLARE (CAPABILITY_QUERY); ///< unresolvable capability query. - } +}} + +namespace vessel { using std::string; using lib::P; - /////////////////////////////////////////////////////////////////////TICKET #705 this is draft/preview code; a real resolution system needs to be integrated @@ -99,7 +100,7 @@ namespace lumiera { using lib::Symbol; using lib::Literal; - using lumiera::Query; + using vessel::Query; /** placeholder definition for later. * @todo intention is to integrate with lib::Symbol @@ -147,8 +148,8 @@ namespace lumiera { * we use a mock implementation. * (this code works and is already used 2/2008) * @todo retrofit this to install and use a QueryResolver - * @see lumiera::query::LookupPreconfigured - * @see lumiera::query::MockTable + * @see vessel::query::LookupPreconfigured + * @see vessel::query::MockTable */ template class QueryHandler @@ -217,11 +218,11 @@ namespace lumiera { * will magically succeed with every candidate object provided. This * is currently necessary to get objects into the defaults manager, * as the query system is not able to do real query resolution */ - void setFakeBypass(lumiera::QueryKey const& q); - bool isFakeBypass (lumiera::QueryKey const& q); + void setFakeBypass(vessel::QueryKey const& q); + bool isFakeBypass (vessel::QueryKey const& q); /////////////////////////////////////////////////////////////////////////////TICKET 710 } // namespace query -} // namespace lumiera -#endif +} // namespace vessel +#endif /*VESSEL_CONFIG_RULES_H*/ diff --git a/src/common/config-typed.c b/src/vessel/config-typed.c similarity index 99% rename from src/common/config-typed.c rename to src/vessel/config-typed.c index f351d24fd..533158d1e 100644 --- a/src/common/config-typed.c +++ b/src/vessel/config-typed.c @@ -22,7 +22,7 @@ #include "include/logging.h" #include "lib/tmpbuf.h" -#include "common/config.h" +#include "vessel/config.h" #include diff --git a/src/common/config-wordlist.c b/src/vessel/config-wordlist.c similarity index 99% rename from src/common/config-wordlist.c rename to src/vessel/config-wordlist.c index f8a679030..45ff6e47f 100644 --- a/src/common/config-wordlist.c +++ b/src/vessel/config-wordlist.c @@ -26,7 +26,7 @@ #include "lib/tmpbuf.h" -#include "common/config.h" +#include "vessel/config.h" extern LumieraConfig lumiera_global_config; diff --git a/src/common/config.c b/src/vessel/config.c similarity index 99% rename from src/common/config.c rename to src/vessel/config.c index a07bb91a1..d0ad29535 100644 --- a/src/common/config.c +++ b/src/vessel/config.c @@ -22,7 +22,7 @@ #include "include/logging.h" #include "lib/safeclib.h" #include "lib/tmpbuf.h" -#include "common/config.h" +#include "vessel/config.h" #include #include diff --git a/src/common/config.h b/src/vessel/config.h similarity index 98% rename from src/common/config.h rename to src/vessel/config.h index b34d88fd0..b29f51ccf 100644 --- a/src/common/config.h +++ b/src/vessel/config.h @@ -26,7 +26,7 @@ ** ** @todo as of 2016, this code is not in any meaningful use ** - ** @see lumiera::BasicSetup simple start-up configuration + ** @see vessel::BasicSetup simple start-up configuration ** @see http://lumiera.org/documentation/technical/vault/ConfigLoader.html ConfigLoader draft from 2008 */ @@ -35,8 +35,8 @@ #include "lib/error.h" #include "lib/mutex.h" -#include "common/config-lookup.h" -#include "common/configitem.h" +#include "vessel/config-lookup.h" +#include "vessel/configitem.h" #include #include diff --git a/src/common/configentry.c b/src/vessel/configentry.c similarity index 97% rename from src/common/configentry.c rename to src/vessel/configentry.c index 49ed0b269..39b1afe2c 100644 --- a/src/common/configentry.c +++ b/src/vessel/configentry.c @@ -20,7 +20,7 @@ #include "lib/safeclib.h" -#include "common/configentry.h" +#include "vessel/configentry.h" diff --git a/src/common/configentry.h b/src/vessel/configentry.h similarity index 97% rename from src/common/configentry.h rename to src/vessel/configentry.h index 23ec6d701..3f05f923c 100644 --- a/src/common/configentry.h +++ b/src/vessel/configentry.h @@ -22,7 +22,7 @@ #ifndef COMMON_CONFIGENTRY_H #define COMMON_CONFIGENTRY_H -#include "common/configitem.h" +#include "vessel/configitem.h" #include diff --git a/src/common/configfacade.cpp b/src/vessel/configfacade.cpp similarity index 89% rename from src/common/configfacade.cpp rename to src/vessel/configfacade.cpp index d5a4fd121..ab59ef2e4 100644 --- a/src/common/configfacade.cpp +++ b/src/vessel/configfacade.cpp @@ -31,16 +31,16 @@ #include "include/logging.h" -#include "include/lifecycle.h" -#include "include/config-facade.h" -#include "common/appstate.hpp" +#include "include/lifecycle.hpp" +#include "vessel/spine/config-facade.h" +#include "vessel/voyage.hpp" #include "lib/searchpath.hpp" #include "lib/iter-explorer.hpp" #include "lib/format-util.hpp" #include "lib/util.hpp" extern "C" { - #include "common/config.h" + #include "vessel/config.h" } @@ -61,7 +61,9 @@ extern "C" { -namespace lumiera { +namespace vessel { +namespace spine { + namespace error = lumiera::error; using util::isnil; using lib::Literal; @@ -88,7 +90,7 @@ namespace lumiera { Config::Config () { - string extendedConfigSearchPath = AppState::instance().fetchSetupValue (KEY_CONFIG_PATH); + string extendedConfigSearchPath = Voyage::access().fetchSetupValue (KEY_CONFIG_PATH); lumiera_config_init (cStr(extendedConfigSearchPath)); TRACE (config, "Config system ready."); } @@ -108,7 +110,7 @@ namespace lumiera { string Config::get (lib::Literal key) { - string value = AppState::instance().fetchSetupValue (key); + string value = Voyage::access().fetchSetupValue (key); if (isnil (value)) throw error::Config ("Configuration value for key=\""+key+"\" is missing"); @@ -117,14 +119,14 @@ namespace lumiera { -} // namespace lumiera +} // namespace vessel extern "C" { /* ==== implementation C interface for accessing setup.ini ======= */ using std::string; - using lumiera::Config; + using vessel::spine::Config; using lib::SearchPathSplitter; using util::isnil; @@ -139,4 +141,4 @@ extern "C" { /* ==== implementation C interface for accessing setup.ini ======= }(); return cStr(pathSpec); } -} +}}// namespace vessel::spine diff --git a/src/common/configitem.c b/src/vessel/configitem.c similarity index 99% rename from src/common/configitem.c rename to src/vessel/configitem.c index 3530955b0..21f449f91 100644 --- a/src/common/configitem.c +++ b/src/vessel/configitem.c @@ -25,9 +25,9 @@ #include "lib/safeclib.h" #include "lib/tmpbuf.h" -#include "common/config.h" -#include "common/configitem.h" -#include "common/configentry.h" +#include "vessel/config.h" +#include "vessel/configitem.h" +#include "vessel/configentry.h" #include #include diff --git a/src/common/configitem.h b/src/vessel/configitem.h similarity index 98% rename from src/common/configitem.h rename to src/vessel/configitem.h index 7ea72c926..82efd9722 100644 --- a/src/common/configitem.h +++ b/src/vessel/configitem.h @@ -54,7 +54,7 @@ typedef lumiera_configitem* LumieraConfigitem; struct lumiera_configitem_vtable; -#include "common/config-lookup.h" +#include "vessel/config-lookup.h" #include diff --git a/src/common/guifacade.cpp b/src/vessel/guifacade.cpp similarity index 93% rename from src/common/guifacade.cpp rename to src/vessel/guifacade.cpp index 4f43ecfee..9f742f452 100644 --- a/src/common/guifacade.cpp +++ b/src/vessel/guifacade.cpp @@ -27,8 +27,8 @@ #include "lib/sync.hpp" #include "lib/error.hpp" #include "lib/depend.hpp" -#include "common/instancehandle.hpp" -#include "common/option.hpp" +#include "vessel/instancehandle.hpp" +#include "vessel/option.hpp" #include #include @@ -38,8 +38,8 @@ namespace stage { using std::string; using std::unique_ptr; - using lumiera::Subsys; - using lumiera::InstanceHandle; + using vessel::Subsys; + using vessel::InstanceHandle; using lib::Sync; using lib::RecursiveLock_NoWait; @@ -49,7 +49,7 @@ namespace stage { struct GuiRunner : util::NonCopyable { - typedef InstanceHandle GuiHandle; + using GuiHandle = InstanceHandle; GuiHandle theGUI_; @@ -89,13 +89,13 @@ namespace stage { class GuiSubsysDescriptor - : public lumiera::Subsys, + : public vessel::Subsys, public Sync { operator string() const { return "Lumiera GTK GUI"; } bool - shouldStart (lumiera::Option& opts) override + shouldStart (vessel::Option& opts) override { if (opts.isHeadless() or 0 < opts.getPort()) { @@ -107,7 +107,7 @@ namespace stage { } bool - start (lumiera::Option&, Subsys::SigTerm termNotification) override + start (vessel::Option&, Subsys::SigTerm termNotification) override { Lock guard{this}; if (facade) @@ -188,7 +188,7 @@ namespace stage { /** @internal intended for use by main(). */ - lumiera::Subsys& + vessel::Subsys& GuiFacade::getDescriptor() { return theDescriptor(); diff --git a/src/common/instancehandle.hpp b/src/vessel/instancehandle.hpp similarity index 96% rename from src/common/instancehandle.hpp rename to src/vessel/instancehandle.hpp index aac59d963..8850a30b7 100644 --- a/src/common/instancehandle.hpp +++ b/src/vessel/instancehandle.hpp @@ -28,8 +28,8 @@ */ -#ifndef LUMIERA_INSTANCEHANDLE_H -#define LUMIERA_INSTANCEHANDLE_H +#ifndef VESSEL_INSTANCEHANDLE_H +#define VESSEL_INSTANCEHANDLE_H #include "include/logging.h" @@ -38,15 +38,15 @@ #include "lib/depend-inject.hpp" extern "C" { -#include "common/interface.h" -#include "common/interfaceregistry.h" +#include "vessel/interface.h" +#include "vessel/interfaceregistry.h" } #include -namespace lumiera { +namespace vessel { using std::string; @@ -120,7 +120,7 @@ namespace lumiera { * between an InstanceHandle and a facade interface, * which is going to be implemented through the given * interface/plugin. This way, creating the InstanceHandle - * automatically creates a lumiera::facade::Proxy, to route + * automatically creates a vessel::facade::Proxy, to route * any facade calls through the interface/plugin. Similarly, * when destroying the InstanceHandle, the proxy will be closed. */ @@ -267,5 +267,5 @@ namespace lumiera { }; -} // namespace lumiera -#endif /*LUMIERA_INSTANCEHANDLE_H*/ +} // namespace vessel +#endif /*VESSEL_INSTANCEHANDLE_H*/ diff --git a/src/common/integration/common-services.cpp b/src/vessel/integration/common-services.cpp similarity index 98% rename from src/common/integration/common-services.cpp rename to src/vessel/integration/common-services.cpp index 1829cec1e..3c0e91c60 100644 --- a/src/common/integration/common-services.cpp +++ b/src/vessel/integration/common-services.cpp @@ -49,7 +49,7 @@ namespace error = lumiera::error; #include "lib/time/quantiser.hpp" #include "lib/time/timecode.hpp" #include "lib/time/mutation.hpp" -#include "common/advice.hpp" +#include "vessel/advice.hpp" namespace lib { @@ -59,7 +59,7 @@ namespace time { using util::_Fmt; - namespace advice = lumiera::advice; + namespace advice = vessel::advice; PQuant diff --git a/src/common/interface-descriptor.h b/src/vessel/interface-descriptor.h similarity index 99% rename from src/common/interface-descriptor.h rename to src/vessel/interface-descriptor.h index 2ffc720a8..d86dd5653 100644 --- a/src/common/interface-descriptor.h +++ b/src/vessel/interface-descriptor.h @@ -24,7 +24,7 @@ #ifndef COMMON_INTERFACEDESCRIPTOR_H #define COMMON_INTERFACEDESCRIPTOR_H -#include "common/interface.h" +#include "vessel/interface.h" /** diff --git a/src/common/interface.c b/src/vessel/interface.c similarity index 99% rename from src/common/interface.c rename to src/vessel/interface.c index 8b8481bc9..1df98a9e6 100644 --- a/src/common/interface.c +++ b/src/vessel/interface.c @@ -26,10 +26,10 @@ #include "lib/recmutex.h" #include "lib/safeclib.h" -#include "common/plugin.h" -#include "common/interface.h" +#include "vessel/plugin.h" +#include "vessel/interface.h" -#include "common/interfaceregistry.h" +#include "vessel/interfaceregistry.h" #include diff --git a/src/common/interface.h b/src/vessel/interface.h similarity index 100% rename from src/common/interface.h rename to src/vessel/interface.h diff --git a/src/common/interfaceregistry.c b/src/vessel/interfaceregistry.c similarity index 99% rename from src/common/interfaceregistry.c rename to src/vessel/interfaceregistry.c index d7444f83f..2b2b6515f 100644 --- a/src/common/interfaceregistry.c +++ b/src/vessel/interfaceregistry.c @@ -25,8 +25,8 @@ #include -#include "common/plugin.h" -#include "common/interfaceregistry.h" +#include "vessel/plugin.h" +#include "vessel/interfaceregistry.h" diff --git a/src/common/interfaceregistry.h b/src/vessel/interfaceregistry.h similarity index 98% rename from src/common/interfaceregistry.h rename to src/vessel/interfaceregistry.h index fb17f41c4..e0f7cabae 100644 --- a/src/common/interfaceregistry.h +++ b/src/vessel/interfaceregistry.h @@ -26,8 +26,8 @@ #include "lib/recmutex.h" #include "lib/psplay.h" -#include "common/interface.h" -#include "common/plugin.h" +#include "vessel/interface.h" +#include "vessel/plugin.h" #include diff --git a/src/common/notification-interface-proxy.cpp b/src/vessel/notification-interface-proxy.cpp similarity index 96% rename from src/common/notification-interface-proxy.cpp rename to src/vessel/notification-interface-proxy.cpp index a6ffe13a4..556364ea5 100644 --- a/src/common/notification-interface-proxy.cpp +++ b/src/vessel/notification-interface-proxy.cpp @@ -24,13 +24,13 @@ #include "include/gui-notification-facade.h" -#include "include/interfaceproxy.hpp" +#include "vessel/spine/interfaceproxy.hpp" namespace stage { /** static storage for the facade access front-end */ lib::Depend GuiNotification::facade; } -namespace lumiera { +namespace vessel { namespace facade { using stage::ID; using lib::diff::GenNode; @@ -71,4 +71,4 @@ namespace facade { template class Link; -}} //namespace facade::lumiera +}} //namespace vessel::facade diff --git a/src/common/option.cpp b/src/vessel/option.cpp similarity index 98% rename from src/common/option.cpp rename to src/vessel/option.cpp index fa2244b03..dc862a3af 100644 --- a/src/common/option.cpp +++ b/src/vessel/option.cpp @@ -20,7 +20,7 @@ #include "lib/error.hpp" #include "lib/util.hpp" -#include "common/option.hpp" +#include "vessel/option.hpp" @@ -32,7 +32,7 @@ namespace op = boost::program_options; using lib::VectS; -namespace lumiera { +namespace vessel { /** set up an options parser to use the application commandline. * Recognises the following options @@ -155,4 +155,4 @@ namespace lumiera { -} // namespace lumiera +} // namespace vessel diff --git a/src/common/option.hpp b/src/vessel/option.hpp similarity index 94% rename from src/common/option.hpp rename to src/vessel/option.hpp index 89bbf59bc..2a98ddbf5 100644 --- a/src/common/option.hpp +++ b/src/vessel/option.hpp @@ -28,14 +28,14 @@ ** [Boost program options library] : https://www.boost.org/doc/libs/1_83_0/doc/html/program_options.html ** ** @see basic-setup.hpp - ** @see lumiera::AppState - ** @see lumiera::Config + ** @see vessel::Voyage + ** @see vessel::spine::Config ** */ -#ifndef LUMIERA_OPTION_H -#define LUMIERA_OPTION_H +#ifndef VESSEL_OPTION_H +#define VESSEL_OPTION_H #include "lib/nocopy.hpp" #include "lib/cmdline.hpp" @@ -47,7 +47,7 @@ -namespace lumiera { +namespace vessel { using std::string; using std::ostream; @@ -95,5 +95,5 @@ namespace lumiera { ostream& operator<< (ostream& os, const Option& to); -} // namespace lumiera -#endif +} // namespace vessel +#endif /*VESSEL_OPTION_H*/ diff --git a/src/common/plugin-dynlib.c b/src/vessel/plugin-dynlib.c similarity index 98% rename from src/common/plugin-dynlib.c rename to src/vessel/plugin-dynlib.c index 56fe57c2f..7677579e5 100644 --- a/src/common/plugin-dynlib.c +++ b/src/vessel/plugin-dynlib.c @@ -18,7 +18,7 @@ #include "include/logging.h" #include "lib/tmpbuf.h" -#include "common/plugin.h" +#include "vessel/plugin.h" #include #include diff --git a/src/common/plugin.c b/src/vessel/plugin.c similarity index 98% rename from src/common/plugin.c rename to src/vessel/plugin.c index 7d25061d0..33a62dca6 100644 --- a/src/common/plugin.c +++ b/src/vessel/plugin.c @@ -25,10 +25,10 @@ #include "lib/recmutex.h" #include "lib/error.h" -#include "include/config-facade.h" -#include "common/interfaceregistry.h" -#include "common/config.h" -#include "common/plugin.h" +#include "vessel/spine/config-facade.h" +#include "vessel/interfaceregistry.h" +#include "vessel/config.h" +#include "vessel/plugin.h" #include diff --git a/src/common/plugin.h b/src/vessel/plugin.h similarity index 99% rename from src/common/plugin.h rename to src/vessel/plugin.h index 6301ffaaa..f0f474838 100644 --- a/src/common/plugin.h +++ b/src/vessel/plugin.h @@ -44,7 +44,7 @@ #include "lib/psplay.h" #include "lib/error.h" -#include "common/interface.h" +#include "vessel/interface.h" #include #include diff --git a/src/common/query.hpp b/src/vessel/query.hpp similarity index 98% rename from src/common/query.hpp rename to src/vessel/query.hpp index 62be08cab..ee1988fd9 100644 --- a/src/common/query.hpp +++ b/src/vessel/query.hpp @@ -39,7 +39,7 @@ ** tag to indicate the kind of query. In addition, queries are usually required to provide ** a syntactical representation, allowing to transform each query into a generic query. ** - ** To resolve the query, a lumiera::QueryResolver instance is necessary, and this + ** To resolve the query, a vessel::QueryResolver instance is necessary, and this ** query resolver needs the ability to deal with this specific kind of query. Typically ** this is achieved by installing a resolution function into the resolver on application start. ** The QueryResolver returns a result set, actually a Query::Cursor, which can be used to @@ -51,7 +51,7 @@ ** @note as of 1/2013 this is rather a concept draft, but some parts of the code base ** are already actively using some more specific queries ** - ** @see lumiera::QueryResolver + ** @see vessel::QueryResolver ** @see mobject::session::DefsManager ** @see asset::StructFactory ** @see config-resolver.hpp specialised setup for the Steam-Layer @@ -62,8 +62,8 @@ */ -#ifndef LUMIERA_QUERY_H -#define LUMIERA_QUERY_H +#ifndef VESSEL_QUERY_H +#define VESSEL_QUERY_H #include "lib/hash-combine.hpp" @@ -83,7 +83,7 @@ #include -namespace lumiera { +namespace vessel { using lib::IxID; using lib::Symbol; @@ -232,7 +232,7 @@ namespace lumiera { * of specific resolution mechanisms. This way, clients may retrieve a set of results, * where each result represents a possible solution to the original query. * - * @remarks lumiera::Query is an interface, but can be used as-is to represent a generic query. + * @remarks vessel::Query is an interface, but can be used as-is to represent a generic query. * Specialised subclasses are required to provide a syntactic representation, but are * free to do so only on demand. In this case, generate an \em empty lib::QueryText * definition and implement the Query#buildSyntacticRepresentation function. @@ -589,5 +589,5 @@ namespace lumiera { -} // namespace lumiera -#endif +} // namespace vessel +#endif /*VESSEL_QUERY_H*/ diff --git a/src/common/query/config-rules.cpp b/src/vessel/query/config-rules.cpp similarity index 90% rename from src/common/query/config-rules.cpp rename to src/vessel/query/config-rules.cpp index 2c9ab903f..6cd4c7e80 100644 --- a/src/common/query/config-rules.cpp +++ b/src/vessel/query/config-rules.cpp @@ -20,16 +20,17 @@ #include "lib/error.hpp" -#include "common/query.hpp" -#include "common/config-rules.hpp" +#include "vessel/query.hpp" +#include "vessel/config-rules.hpp" -using lumiera::QueryKey; +using vessel::QueryKey; namespace lumiera { namespace error { LUMIERA_ERROR_DEFINE (CAPABILITY_QUERY, "unresolvable capability query"); - } +}} +namespace vessel { namespace query { @@ -50,4 +51,4 @@ namespace lumiera { /////////////////////////////////////////////////////////////////////////////TICKET 710 }// namespace query -} // namespace lumiera +} // namespace vessel diff --git a/src/common/query/defs-manager-impl.hpp b/src/vessel/query/defs-manager-impl.hpp similarity index 83% rename from src/common/query/defs-manager-impl.hpp rename to src/vessel/query/defs-manager-impl.hpp index 41421e0f1..a2b912690 100644 --- a/src/common/query/defs-manager-impl.hpp +++ b/src/vessel/query/defs-manager-impl.hpp @@ -30,25 +30,23 @@ -#ifndef LUMIERA_QUERY_DEFS_MANAGER_IMPL_H -#define LUMIERA_QUERY_DEFS_MANAGER_IMPL_H +#ifndef VESSEL_QUERY_DEFS_MANAGER_IMPL_H +#define VESSEL_QUERY_DEFS_MANAGER_IMPL_H -#include "common/query/defs-manager.hpp" -#include "common/query/defs-registry.hpp" -#include "common/config-rules.hpp" +#include "vessel/query/defs-manager.hpp" +#include "vessel/query/defs-registry.hpp" +#include "vessel/config-rules.hpp" #include "lib/format-string.hpp" #include "lib/error.hpp" -using util::_Fmt; -using steam::ConfigResolver; -using lumiera::query::QueryHandler; ///////TODO preliminary interface defined in config-rules.hpp - - -namespace lumiera{ +namespace vessel { namespace query { + namespace err = lumiera::error; + using util::_Fmt; + using steam::ConfigResolver; @@ -139,12 +137,12 @@ namespace query { res = create (capabilities); // not yet known as default, create new if (!res) - throw error::Config (_Fmt("The following Query could not be resolved: %s.") - % capabilities.rebuild().asKey() - , LERR_(CAPABILITY_QUERY) ); + throw err::Config (_Fmt("The following Query could not be resolved: %s.") + % capabilities.rebuild().asKey() + , LERR_(CAPABILITY_QUERY) ); else return res; } -}} // namespace lumiera::query -#endif /* LUMIERA_QUERY_DEFS_MANAGER_IMPL_H */ +}} // namespace vessel::query +#endif /* VESSEL_QUERY_DEFS_MANAGER_IMPL_H */ diff --git a/src/common/query/defs-manager.hpp b/src/vessel/query/defs-manager.hpp similarity index 96% rename from src/common/query/defs-manager.hpp rename to src/vessel/query/defs-manager.hpp index 99f7f927f..6a77953bc 100644 --- a/src/common/query/defs-manager.hpp +++ b/src/vessel/query/defs-manager.hpp @@ -47,7 +47,7 @@ ** importance that we build our implementations with this goal in mind ** ** # Configuration Query Interface - ** The [Defaults Manager](\ref lumiera::query::DefsManager) exposes an interface + ** The [Defaults Manager](\ref vessel::query::DefsManager) exposes an interface ** similar to a database. The intended audience of this interface is the writer ** of low-level implementation code. This facade interface is meant to create ** a more familiar front-end to an essentially logic and rules driven @@ -90,23 +90,21 @@ */ -#ifndef LUMIERA_QUERY_DEFS_MANAGER_H -#define LUMIERA_QUERY_DEFS_MANAGER_H +#ifndef VESSEL_QUERY_DEFS_MANAGER_H +#define VESSEL_QUERY_DEFS_MANAGER_H #include "lib/p.hpp" #include "lib/nocopy.hpp" -#include "common/query.hpp" +#include "vessel/query.hpp" #include -namespace lumiera{ +namespace vessel { namespace query { - - using lumiera::Query; using std::unique_ptr; namespace impl { class DefsRegistry; } @@ -185,7 +183,7 @@ namespace query { // < class TAR, ///< the target to query for // template class SMP ///< smart pointer class to wrap the result // > -// SMP operator() (const lumiera::Query&); +// SMP operator() (const vessel::Query&); // 12/09: according to my current knowledge of template metaprogramming, the answer is "no", // but we could use a traits template to set up a fixed association of smart pointers @@ -198,5 +196,5 @@ namespace query { -}} // namespace lumiera::query -#endif +}} // namespace vessel::query +#endif /*VESSEL_QUERY_DEFS_MANAGER_H*/ diff --git a/src/common/query/defs-registry.hpp b/src/vessel/query/defs-registry.hpp similarity index 98% rename from src/common/query/defs-registry.hpp rename to src/vessel/query/defs-registry.hpp index e258e918c..d7e6059e4 100644 --- a/src/common/query/defs-registry.hpp +++ b/src/vessel/query/defs-registry.hpp @@ -35,8 +35,8 @@ -#ifndef LUMIERA_QUERY_DEFS_REGISTRY_H -#define LUMIERA_QUERY_DEFS_REGISTRY_H +#ifndef VESSEL_QUERY_DEFS_REGISTRY_H +#define VESSEL_QUERY_DEFS_REGISTRY_H #include "lib/p.hpp" @@ -45,7 +45,7 @@ #include "lib/sync-classlock.hpp" #include "lib/format-string.hpp" #include "lib/query-util.hpp" -#include "common/query.hpp" +#include "vessel/query.hpp" #include "lib/nocopy.hpp" #include @@ -53,7 +53,7 @@ #include -namespace lumiera{ +namespace vessel { namespace query { using lib::P; @@ -339,5 +339,5 @@ namespace query { using impl::DefsRegistry; -}} // namespace lumiera::query -#endif +}} // namespace vessel::query +#endif /*VESSEL_QUERY_DEFS_REGISTRY_H*/ diff --git a/src/common/query/query-resolver.cpp b/src/vessel/query/query-resolver.cpp similarity index 97% rename from src/common/query/query-resolver.cpp rename to src/vessel/query/query-resolver.cpp index 7ccaba42a..048a5626e 100644 --- a/src/common/query/query-resolver.cpp +++ b/src/vessel/query/query-resolver.cpp @@ -25,9 +25,9 @@ #include "lib/multifact.hpp" -#include "common/query/query-resolver.hpp" +#include "vessel/query/query-resolver.hpp" -namespace lumiera { +namespace vessel { @@ -118,4 +118,4 @@ namespace lumiera { -} // namespace lumiera +} // namespace vessel diff --git a/src/common/query/query-resolver.hpp b/src/vessel/query/query-resolver.hpp similarity index 96% rename from src/common/query/query-resolver.hpp rename to src/vessel/query/query-resolver.hpp index 564aa3da0..44be0090f 100644 --- a/src/common/query/query-resolver.hpp +++ b/src/vessel/query/query-resolver.hpp @@ -23,11 +23,11 @@ */ -#ifndef LUMIERA_QUERY_RESOLVER_H -#define LUMIERA_QUERY_RESOLVER_H +#ifndef VESSEL_QUERY_RESOLVER_H +#define VESSEL_QUERY_RESOLVER_H #include "lib/iter-adapter.hpp" -#include "common/query.hpp" +#include "vessel/query.hpp" #include "lib/nocopy.hpp" #include @@ -36,7 +36,7 @@ using std::function; -namespace lumiera { +namespace vessel { using std::unique_ptr; using std::string; @@ -164,5 +164,5 @@ namespace lumiera { } -} // namespace lumiera -#endif +} // namespace vessel +#endif /*VESSEL_QUERY_RESOLVER_H*/ diff --git a/src/include/config-facade.h b/src/vessel/spine/config-facade.h similarity index 86% rename from src/include/config-facade.h rename to src/vessel/spine/config-facade.h index c506128f4..5b9839293 100644 --- a/src/include/config-facade.h +++ b/src/vessel/spine/config-facade.h @@ -12,7 +12,7 @@ */ /** @file config-facade.h - ** The lumiera::Config wrapper class addresses two issues. + ** The vessel::spine::Config wrapper class addresses two issues. ** First, it registers startup and shutdown hooks to bring up the config system ** as early as possible. Later, on application main initialisation, the global ** config interface is opened and wrapped for convenient access from C++ code. @@ -26,16 +26,16 @@ ** was detached and replaced by an _ini file solution_ based on lib Boost. ** ** @todo there ought to be an external Interface for the Config subsystem. - ** But the full-blown Config system isn't implemented yet anyway + ** But the full-blown Config system isn't implemented yet anyway ////////////////////////////////////TICKET #1224 : Call for Design -- Layered Configuration System ** ** @see config.h - ** @see lumiera::AppState + ** @see vessel::Voyage ** @see main.cpp */ -#ifndef INTERFACE_CONFIGFACADE_H -#define INTERFACE_CONFIGFACADE_H +#ifndef VESSEL_SPINE_CONFIGFACADE_H +#define VESSEL_SPINE_CONFIGFACADE_H @@ -49,7 +49,8 @@ #include -namespace lumiera { +namespace vessel{ +namespace spine { using std::string; @@ -77,7 +78,7 @@ namespace lumiera { -} // namespace lumiera +}} // namespace vessel::spine @@ -93,5 +94,5 @@ namespace lumiera { const char* lumiera_get_plugin_path_default (); -#endif -#endif +#endif /*C++ vs C*/ +#endif /*VESSEL_SPINE_CONFIGFACADE_H*/ diff --git a/src/include/display-handles.hpp b/src/vessel/spine/display-handles.hpp similarity index 82% rename from src/include/display-handles.hpp rename to src/vessel/spine/display-handles.hpp index 9f9efcc91..ac4e7a68b 100644 --- a/src/include/display-handles.hpp +++ b/src/vessel/spine/display-handles.hpp @@ -12,8 +12,7 @@ */ /** @file display-handles.hpp - ** Opaque handles and similar typedefs used to communicate via the - ** lumiera::Display and lumiera::DummyPlayer facade interfaces. + ** Opaque handles and similar typedefs used to communicate via facade interfaces. ** ** @deprecated this is part of prototyping code; as of 5/2025 it is clear ** that we will not use any of these interface schemes (yet something similar) @@ -23,8 +22,8 @@ */ -#ifndef LUMIERA_DISPLAY_HANDLES_H -#define LUMIERA_DISPLAY_HANDLES_H +#ifndef VESSEL_SPINE_DISPLAY_HANDLES_H +#define VESSEL_SPINE_DISPLAY_HANDLES_H #include @@ -37,7 +36,8 @@ using DummyFrame = std::byte *; -namespace lumiera { +namespace vessel { +namespace spine { /** Supported Displayer formats */ enum DisplayerInput { @@ -48,5 +48,5 @@ namespace lumiera { DISPLAY_BGR0, DISPLAY_RGB16 }; -} // namespace lumiera -#endif /*LUMIERA_DISPLAY_HANDLES_H*/ +}} // namespace vessel::spine +#endif /*VESSEL_SPINE_DISPLAY_HANDLES_H*/ diff --git a/src/include/interfaceproxy.hpp b/src/vessel/spine/interfaceproxy.hpp similarity index 94% rename from src/include/interfaceproxy.hpp rename to src/vessel/spine/interfaceproxy.hpp index f9d7e2c3a..dc7cc42c7 100644 --- a/src/include/interfaceproxy.hpp +++ b/src/vessel/spine/interfaceproxy.hpp @@ -20,7 +20,7 @@ ** ** A *crucial requirement* for this approach to work is that any relevant interface ** to be bound and exposed as C++ object needs to set up a concrete specialisation of - ** lumiera::facade::Proxy to drive instantiation of the actual binding proxy. + ** vessel::facade::Proxy to drive instantiation of the actual binding proxy. ** The result of this setup is that clients can just invoke `SomeInterface::facade()` ** and thus call through proper C++ bindings with type safety and automatic ** lifecycle management. @@ -60,7 +60,7 @@ ** high-level call into an invocation of the corresponding low-level function on the CL-interface. ** ** Whenever InstanceHandle was created with a second template parameter defining a façade interface, - ** it automatically attempts to instantiate a lumiera::facade::Proxy templated to the actual type + ** it automatically attempts to instantiate a vessel::facade::Proxy templated to the actual type ** of the InstanceHandle. This proxy instance is then exposed via `lib::Depend` ** This way, any call will be routed through the corresponding C Language function defined within ** the Interface/Plugin system. Moreover, there will be another subclass of the Facade interface @@ -97,7 +97,7 @@ ** While client code just includes the interface header (including lib/depend.hpp), ** there needs to be an actual implementation of each proxy object located in some translation ** unit, linked into the application core or `liblumieracommon.so`. This translation unit - ** needs to specialise lumiera::facade::Proxy and then create an instance of that template. + ** needs to specialise vessel::facade::Proxy and then create an instance of that template. ** And, most importantly, such translation units (and _only such translation units_) must ** include this header `interfaceproxy.hpp` -- because it defines the concrete ctor ** and dtor of the facade::Link template and thus creates the missing "link" between @@ -111,16 +111,16 @@ */ -#ifndef LUMIERA_INTERFACE_PROXY_H -#define LUMIERA_INTERFACE_PROXY_H +#ifndef VESSEL_INTERFACE_PROXY_H +#define VESSEL_INTERFACE_PROXY_H -#include "common/instancehandle.hpp" +#include "vessel/instancehandle.hpp" #include "lib/error.hpp" #include "lib/util.hpp" -namespace lumiera { +namespace vessel { namespace facade { /** @@ -169,9 +169,8 @@ namespace facade { { return ServiceHandle::operator->(); } - -}} // namespace lumiera::facade +}} // namespace vessel::facade -#endif +#endif /*VESSEL_INTERFACE_PROXY_H*/ diff --git a/src/include/play-facade.hpp b/src/vessel/spine/play-facade.hpp similarity index 98% rename from src/include/play-facade.hpp rename to src/vessel/spine/play-facade.hpp index 727889577..69f6f3a15 100644 --- a/src/include/play-facade.hpp +++ b/src/vessel/spine/play-facade.hpp @@ -43,14 +43,14 @@ namespace steam { -namespace play { +namespace play { class PlayProcess; }} -namespace lumiera { - +namespace vessel{ +namespace spine { namespace time = lib::time; using std::weak_ptr; @@ -145,5 +145,5 @@ namespace lumiera { }; -} // namespace lumiera +}} // namespace vessel::spine #endif /*STEAM_INTERFACE_PLAY_H*/ diff --git a/src/common/subsys.cpp b/src/vessel/subsys.cpp similarity index 91% rename from src/common/subsys.cpp rename to src/vessel/subsys.cpp index 7ce87512b..da942c7f7 100644 --- a/src/common/subsys.cpp +++ b/src/vessel/subsys.cpp @@ -18,17 +18,17 @@ ** which are prompted by main() to start/stop. ** ** @see subsystem-runner.hpp - ** @see lumiera::AppState + ** @see vessel::Voyage ** @see facade.cpp ** @see main.cpp ** */ -#include "common/subsys.hpp" +#include "vessel/subsys.hpp" -namespace lumiera { +namespace vessel { @@ -56,4 +56,4 @@ namespace lumiera { -} // namespace lumiera +} // namespace vessel diff --git a/src/common/subsys.hpp b/src/vessel/subsys.hpp similarity index 87% rename from src/common/subsys.hpp rename to src/vessel/subsys.hpp index 69adff139..5b35c62ec 100644 --- a/src/common/subsys.hpp +++ b/src/vessel/subsys.hpp @@ -18,21 +18,21 @@ ** While the activation of the key components is controlled by options, maybe ** some prerequisite subsystems need to be pulled up, and in case of an regular ** or irregular exit of a given subsystem, the whole dependency graph needs - ** to be brought down in a clean manner. The purpose of lumiera::Subsys is + ** to be brought down in a clean manner. The purpose of vessel::Subsys is ** to maintain these in a self-explanatory script-like fashion within main(), ** without forcing the individual subsystems into a fixed implementation scheme. ** The only requirement is that for each subsystem there is sort-of an entry ** point or facade object, providing a Subsys descriptor instance to be ** used within main. ** - ** @see lumiera::AppState - ** @see lumiera::Option + ** @see vessel::Voyage + ** @see vessel::Option ** @see main.cpp */ -#ifndef LUMIERA_SUBSYS_H -#define LUMIERA_SUBSYS_H +#ifndef VESSEL_SUBSYS_H +#define VESSEL_SUBSYS_H #include "lib/error.hpp" #include "lib/nocopy.hpp" @@ -43,7 +43,7 @@ -namespace lumiera { +namespace vessel { using std::string; using std::function; @@ -54,8 +54,8 @@ namespace lumiera { /** * Dependencies and lifecycle of a partially independent Subsystem of the Application. - * Using such descriptors, AppState as activated from main() is able to pull up, - * maintain and shut down the primary parts of the Application. + * After launch from the main() function, the vessel::Voyage uses these descriptors + * to pull up, maintain and shut down the primary parts of the Lumiera application. * @note synchronisation is up to the implementor. */ class Subsys @@ -83,7 +83,7 @@ namespace lumiera { * if this subsystem should be activated. * @note even if not started explicitly, it could still * be started as prerequisite of another one */ - virtual bool shouldStart (lumiera::Option&) =0; + virtual bool shouldStart (vessel::Option&) =0; /** attempt to bring up this subsystem up. On return, the @@ -95,7 +95,7 @@ namespace lumiera { * @param SigTerm to be signalled by the subsystem. * @warning termination must be signalled reliably. * @return `true` if actually started. */ - virtual bool start (lumiera::Option& options, SigTerm) =0; + virtual bool start (vessel::Option& options, SigTerm) =0; /** initiate termination of this subsystem. @@ -124,6 +124,6 @@ namespace lumiera { -} // namespace lumiera +} // namespace vessel -#endif +#endif /*VESSEL_SUBSYS_H*/ diff --git a/src/common/subsystem-runner.hpp b/src/vessel/subsystem-runner.hpp similarity index 93% rename from src/common/subsystem-runner.hpp rename to src/vessel/subsystem-runner.hpp index 4b31aae04..0c80603d4 100644 --- a/src/common/subsystem-runner.hpp +++ b/src/vessel/subsystem-runner.hpp @@ -15,8 +15,8 @@ /** @file subsystem-runner.hpp ** Manage execution of the independent [Subsystems](\ref subsys.hpp) ** of the Lumiera application. The SubsystemRunner is used by - ** lumiera::AppState::init() for actually "performing" the various subsystems, - ** as defined by their [Subsystem descriptors](\ref lumiera::Subsys). Together + ** vessel::Voyage::init() for actually "performing" the various subsystems, + ** as defined by their [Subsystem descriptors](\ref vessel::Subsys). Together ** these parts define the lifecycle protocol. ** ** @todo as of 2018, a design rework seems indicated eventually /////////////////////////TICKET #1177 @@ -35,21 +35,22 @@ */ -#ifndef LUMIERA_SUBSYSTEMRUNNER_H -#define LUMIERA_SUBSYSTEMRUNNER_H +#ifndef VESSEL_SUBSYSTEMRUNNER_H +#define VESSEL_SUBSYSTEMRUNNER_H #include "lib/error.hpp" #include "lib/util.hpp" #include "lib/util-foreach.hpp" #include "lib/format-string.hpp" -#include "common/subsys.hpp" +#include "vessel/subsys.hpp" #include "lib/sync.hpp" #include #include -namespace lumiera { +namespace vessel { + namespace error = lumiera::error; using lib::Sync; using lib::RecursiveLock_Waitable; @@ -79,7 +80,7 @@ namespace lumiera { * complete layer of the application (e.g. the GUI). * * # Protocol of operation - * The SubsystemRunner is to be configured with a lumiera::Option object first. + * The SubsystemRunner is to be configured with a vessel::Option object first. * Then, primary subsystems are [provided](\ref SubsystemRunner::maybeRun) for * eventual startup, which may depend on conditions defined by the subsystem. * When it turns out (by investigating the options) that a Subsystem is actually @@ -102,8 +103,8 @@ namespace lumiera { * * @todo 2018 this component works well but could be (re)written in a cleaner way ////////////////////////TICKET #1177 * - * @see lumiera::AppState - * @see lumiera::Subsys + * @see vessel::Voyage + * @see vessel::Subsys * @see main.cpp */ class SubsystemRunner @@ -209,5 +210,5 @@ namespace lumiera { -} // namespace lumiera -#endif +} // namespace vessel +#endif /*VESSEL_SUBSYSTEMRUNNER_H*/ diff --git a/src/common/ui-protocol.cpp b/src/vessel/ui-protocol.cpp similarity index 100% rename from src/common/ui-protocol.cpp rename to src/vessel/ui-protocol.cpp diff --git a/src/common/appstate.cpp b/src/vessel/voyage.cpp similarity index 84% rename from src/common/appstate.cpp rename to src/vessel/voyage.cpp index 76bf2a795..05f751b14 100644 --- a/src/common/appstate.cpp +++ b/src/vessel/voyage.cpp @@ -1,5 +1,5 @@ /* - AppState - application initialisation and behaviour + Voyage - global application initialisation and behaviour Copyright (C) 2008, Hermann Vosseler @@ -12,27 +12,27 @@ * *****************************************************************/ -/** @file appstate.cpp +/** @file voyage.cpp ** Implementation of the _main application object_ of Lumiera. ** This is a service to manage some _really global_ state and to ** organise, start and stop the ["Subsystems"](\ref subsys.hpp). - ** The AppState object provides the building blocks for the - ** `main()` function to control the global lifecycle. + ** The vessel::Voyage object is set off by the `main()` function + ** and coordinates the lifecycle of all parts of the application. ** ** @see main.cpp */ #include "lib/error.hpp" -#include "common/appstate.hpp" -#include "common/subsystem-runner.hpp" +#include "vessel/voyage.hpp" +#include "vessel/subsystem-runner.hpp" extern "C" { -#include "common/config-interface.h" +#include "vessel/config-interface.h" -#include "common/interface.h" -#include "common/interfaceregistry.h" -#include "common/plugin.h" +#include "vessel/interface.h" +#include "vessel/interfaceregistry.h" +#include "vessel/plugin.h" } #include "lib/symbol.hpp" @@ -41,10 +41,12 @@ extern "C" { using lib::Literal; using std::unique_ptr; +using lumiera::maybeThrow; -namespace lumiera { +namespace vessel { + namespace error = lumiera::error; namespace { // implementation details @@ -68,19 +70,19 @@ namespace lumiera { * static initialisation code accesses the instance). * @note all further application startup is conducted by \c main.cpp */ - AppState::AppState() + Voyage::Voyage() : setup_{LUMIERA_LOCATION_OF_BOOTSTRAP_INI} , subsystems_{} , emergency_{false} , core_up_{false} { } - /** storage for the Appstate Singleton instance */ - lib::Depend AppState::instance; + /** storage for the Voyage Singleton instance */ + lib::Depend Voyage::access; string - AppState::fetchSetupValue (Literal key) + Voyage::fetchSetupValue (Literal key) { return setup_.get(key).as(); } @@ -99,7 +101,7 @@ namespace lumiera { void - AppState::init (Option& options) + Voyage::init (Option& options) { TRACE (common, "initialising application core..."); @@ -124,7 +126,7 @@ namespace lumiera { void - AppState::maybeStart (lumiera::Subsys& subsys) + Voyage::maybeStart (Subsys& subsys) { TRACE (common, "maybe startup %s...?", cStr(subsys)); REQUIRE (subsystems_); @@ -133,7 +135,7 @@ namespace lumiera { - typedef AppState::ExitCode ExitCode; + using ExitCode = Voyage::ExitCode; /** @remark @@ -149,7 +151,7 @@ namespace lumiera { * is activated. */ ExitCode - AppState::maybeWait() + Voyage::maybeWait() { if (subsystems_) { @@ -175,7 +177,7 @@ namespace lumiera { ExitCode - AppState::abort (lumiera::Error& problem) + Voyage::abort (lumiera::Error& problem) { ERROR (common, "Aborting Lumiera after unhandled error: %s", cStr(problem.what())); @@ -200,7 +202,7 @@ namespace lumiera { ExitCode - AppState::abort () noexcept + Voyage::abort () noexcept { log_and_clear_unexpected_errorstate(); @@ -220,11 +222,11 @@ namespace lumiera { /** anything which should be closed as late as possible and after - * the normal shutdown sequence can be placed into the AppState dtor. + * the normal shutdown sequence can be placed into the Voyage dtor. * But note though, when the application is halted unconditionally, * no dtors will be executed. */ - AppState::~AppState() + Voyage::~Voyage() { if (core_up_) try @@ -241,4 +243,4 @@ namespace lumiera { -} // namespace lumiera +} // namespace vessel diff --git a/src/common/appstate.hpp b/src/vessel/voyage.hpp similarity index 79% rename from src/common/appstate.hpp rename to src/vessel/voyage.hpp index df66a01e9..94941641f 100644 --- a/src/common/appstate.hpp +++ b/src/vessel/voyage.hpp @@ -1,5 +1,5 @@ /* - APPSTATE.hpp - application initialisation and behaviour + VOYAGE.hpp - application initialisation and behaviour Copyright (C) 2008, Hermann Vosseler @@ -11,13 +11,13 @@ */ -/** @file appstate.hpp +/** @file voyage.hpp ** Registering and managing primary application-global services. ** This can be considered the "main" object of the Lumiera application ** Besides encapsulating the logic to start up the fundamental parts of ** the application, there is a mechanism for registering \em subsystems - ** to be brought up and shut down in order. AppState will issue the global - ** application lifecycle events (where other parts may have registered + ** to be brought up and shut down in order. The vessel::Voyage will issue + ** global application lifecycle events (where other parts may have attached ** callbacks) and provides the top-level catch-all error handling. ** ** @see LifecycleHook @@ -28,15 +28,15 @@ */ -#ifndef LUMIERA_APPSTATE_H -#define LUMIERA_APPSTATE_H +#ifndef VESSEL_VOYAGE_H +#define VESSEL_VOYAGE_H #include "lib/symbol.hpp" #include "lib/nocopy.hpp" #include "lib/depend.hpp" -#include "common/option.hpp" -#include "common/subsys.hpp" -#include "common/basic-setup.hpp" +#include "vessel/option.hpp" +#include "vessel/subsys.hpp" +#include "vessel/basic-setup.hpp" #include #include @@ -44,7 +44,7 @@ -namespace lumiera { +namespace vessel { using std::string; @@ -55,29 +55,28 @@ namespace lumiera { * The Lumiera Application state and basic initialisation. * Singleton to hold global flags directing the overall application behaviour, * responsible for triggering lifecycle events and performing early initialisation tasks. - * AppState services are available already from static initialisation code. - * @warning don't use AppState in destructors. + * @warning don't use vessel::Voyage in destructors. */ - class AppState + class Voyage : util::NonCopyable { private: - AppState (); + Voyage(); + ~Voyage(); - ~AppState (); - friend class lib::DependencyFactory; + friend class lib::DependencyFactory; public: - /** get the (single) AppState instance. + /** get the (single) vessel::Voyage instance. * @warning don't use it after the end of main()! */ - static lib::Depend instance; + static lib::Depend access; /** evaluate the result of option parsing and maybe additional configuration * such as to be able to determine the further behaviour of the application. * Set the internal state within this object accordingly. */ - void init (lumiera::Option& options); + void init (Option& options); /** access basic application setup values (from \c setup.ini) */ @@ -88,7 +87,7 @@ namespace lumiera { * needs to be pulled up and, if necessary, register the Subsys and its * prerequisites to be maintained throughout the application's lifetime. */ - void maybeStart (lumiera::Subsys&); + void maybeStart (Subsys&); enum ExitCode { @@ -133,6 +132,5 @@ namespace lumiera { }; -} // namespace lumiera - -#endif +} // namespace vessel +#endif /*VESSEL_VOYAGE_H*/ diff --git a/tests/SConscript b/tests/SConscript index b74f84cce..75e9e6f8e 100644 --- a/tests/SConscript +++ b/tests/SConscript @@ -12,7 +12,7 @@ from Buildhelper import scanSubtree from Buildhelper import globRootdirs from Buildhelper import createPlugins -Import('env core_lib app_lib vault_lib guimodule tools config') +Import('env core_lib vessel_lib vault_lib guimodule tools config') env = env.Clone() env.Append(CPPPATH='include') # additional headers for tests @@ -23,9 +23,9 @@ sharedTestLibs = {} def linkContext(id): if id.startswith('lib'): - return app_lib # tests in 'lib*' subdirs only linked against application framework + return vessel_lib # tests in 'lib*' subdirs only linked with framework (including support-lib) elif id.startswith('vault'): - return vault_lib # tests in 'vault*' subdirs only linked against vault layer + return vault_lib # tests in 'vault*' subdirs only linked against vault layer (including framework) elif id.startswith('stage'): return guimodule+core_lib # tests in 'stage*' are additionally linked against the GTK GUI module else: diff --git a/tests/basics/stream-type-lifecycle-test.cpp b/tests/basics/stream-type-lifecycle-test.cpp index dabb5bff4..154a8ca00 100644 --- a/tests/basics/stream-type-lifecycle-test.cpp +++ b/tests/basics/stream-type-lifecycle-test.cpp @@ -22,7 +22,7 @@ #include "steam/control/stypemanager.hpp" #include "steam/mobject/session.hpp" //#include "teststreamtypes.hpp" -#include "include/lifecycle.h" +#include "include/lifecycle.hpp" @@ -33,7 +33,7 @@ namespace test_format { using mobject::Session; using control::STypeManager; using control::ON_STREAMTYPES_RESET; - using lumiera::LifecycleHook; + using vessel::LifecycleHook; //////////TODO define a dummy-type-info here diff --git a/tests/basics/visitingtool-concept.cpp b/tests/basics/visitingtool-concept.cpp index 67c4922ff..aa9bf18a1 100644 --- a/tests/basics/visitingtool-concept.cpp +++ b/tests/basics/visitingtool-concept.cpp @@ -54,7 +54,7 @@ using util::_Fmt; using std::string; -namespace lumiera { +namespace lib { namespace visitor_concept_draft { // ================================================================== Library ==== @@ -443,4 +443,4 @@ namespace lumiera { -}}} // namespace lumiera::visitor_concept_draft::test +}}} // namespace lib::visitor_concept_draft::test diff --git a/tests/core/steam/asset/basicpipetest.cpp b/tests/core/steam/asset/basicpipetest.cpp index 39c1a844e..890efe717 100644 --- a/tests/core/steam/asset/basicpipetest.cpp +++ b/tests/core/steam/asset/basicpipetest.cpp @@ -26,7 +26,7 @@ #include "steam/mobject/session.hpp" #include "steam/asset/asset-diagnostics.hpp" #include "lib/query-util.hpp" -#include "common/query.hpp" +#include "vessel/query.hpp" using util::contains; @@ -39,7 +39,7 @@ namespace asset { namespace test { using mobject::Session; - using lumiera::Query; + using vessel::Query; using lib::query::normaliseID; diff --git a/tests/core/steam/asset/typed-id-test.cpp b/tests/core/steam/asset/typed-id-test.cpp index 9c7150994..1b5476b69 100644 --- a/tests/core/steam/asset/typed-id-test.cpp +++ b/tests/core/steam/asset/typed-id-test.cpp @@ -58,7 +58,7 @@ namespace test { }}}} -namespace lumiera{ ///////TODO: shouldn't that be namespace lib? or steam? +namespace vessel { ///////TODO: shouldn't that be namespace lib? or steam? namespace query { /** diff --git a/tests/core/steam/control/command-use2-test.cpp b/tests/core/steam/control/command-use2-test.cpp index 3023fb85e..a70e0bc69 100644 --- a/tests/core/steam/control/command-use2-test.cpp +++ b/tests/core/steam/control/command-use2-test.cpp @@ -28,7 +28,7 @@ #include "steam/control/test-dummy-commands.hpp" extern "C" { -#include "common/interfaceregistry.h" +#include "vessel/interfaceregistry.h" } #include "steam/control/steam-dispatcher.hpp" #include "include/session-command-facade.h" diff --git a/tests/core/steam/control/session-command-function-test.cpp b/tests/core/steam/control/session-command-function-test.cpp index 1ea244f9a..a32530db4 100644 --- a/tests/core/steam/control/session-command-function-test.cpp +++ b/tests/core/steam/control/session-command-function-test.cpp @@ -67,7 +67,7 @@ #include "lib/test/run.hpp" #include "lib/test/test-helper.hpp" extern "C" { -#include "common/interfaceregistry.h" +#include "vessel/interfaceregistry.h" } #include "steam/control/steam-dispatcher.hpp" diff --git a/tests/core/steam/fixture/fixture-change-detector-test.cpp b/tests/core/steam/fixture/fixture-change-detector-test.cpp index 9e80e7a96..086f8e273 100644 --- a/tests/core/steam/fixture/fixture-change-detector-test.cpp +++ b/tests/core/steam/fixture/fixture-change-detector-test.cpp @@ -21,7 +21,7 @@ #include "steam/fixture/fixture-change-detector.hpp" #include "steam/asset/timeline.hpp" #include "steam/asset/pipe.hpp" -#include "common/query.hpp" +#include "vessel/query.hpp" #include "lib/util.hpp" @@ -37,7 +37,7 @@ namespace test { using asset::Struct; using asset::Timeline; using asset::PTimeline; - using lumiera::Query; + using vessel::Query; // typedef asset::ID PID; typedef asset::ID TID; diff --git a/tests/core/steam/fixture/model-port-registry-test.cpp b/tests/core/steam/fixture/model-port-registry-test.cpp index cce9c3b6e..e756c0f9a 100644 --- a/tests/core/steam/fixture/model-port-registry-test.cpp +++ b/tests/core/steam/fixture/model-port-registry-test.cpp @@ -21,7 +21,7 @@ #include "steam/fixture/model-port-registry.hpp" #include "steam/asset/timeline.hpp" #include "steam/asset/pipe.hpp" -#include "common/query.hpp" +#include "vessel/query.hpp" #include "lib/util.hpp" @@ -38,7 +38,7 @@ namespace test { using asset::Timeline; using asset::PTimeline; using mobject::ModelPort; - using lumiera::Query; + using vessel::Query; using PID = asset::ID; using TID = asset::ID; diff --git a/tests/core/steam/fixture/segmentation-integration-test.cpp b/tests/core/steam/fixture/segmentation-integration-test.cpp index e2b1cc3e2..c51346e6d 100644 --- a/tests/core/steam/fixture/segmentation-integration-test.cpp +++ b/tests/core/steam/fixture/segmentation-integration-test.cpp @@ -21,7 +21,7 @@ #include "steam/fixture/fixture-change-detector.hpp" #include "steam/asset/timeline.hpp" #include "steam/asset/pipe.hpp" -#include "common/query.hpp" +#include "vessel/query.hpp" #include "lib/util.hpp" @@ -37,7 +37,7 @@ namespace test { using asset::Struct; using asset::Timeline; using asset::PTimeline; - using lumiera::Query; + using vessel::Query; // typedef asset::ID PID; typedef asset::ID TID; diff --git a/tests/core/steam/mobject/session/defs-manager-impl-test.cpp b/tests/core/steam/mobject/session/defs-manager-impl-test.cpp index 3dd75582c..bd81c4d66 100644 --- a/tests/core/steam/mobject/session/defs-manager-impl-test.cpp +++ b/tests/core/steam/mobject/session/defs-manager-impl-test.cpp @@ -28,7 +28,7 @@ #include "steam/streamtype.hpp" #include "lib/format-string.hpp" #include "lib/query-util.hpp" -#include "common/query/defs-manager-impl.hpp" +#include "vessel/query/defs-manager-impl.hpp" using util::_Fmt; using util::isnil; @@ -47,8 +47,8 @@ namespace test { using asset::PPipe; using asset::Struct; - using lumiera::Query; - using lumiera::query::QueryHandler; + using vessel::Query; + using vessel::query::QueryHandler; using lib::query::normaliseID; using steam::ConfigResolver; @@ -116,11 +116,11 @@ namespace test { // now declare that these objects should be considered "default" Query justAnyPipe (""); -lumiera::query::setFakeBypass(justAnyPipe); /////////////////////////////////////////////////TODO mock resolution +vessel::query::setFakeBypass(justAnyPipe); /////////////////////////////////////////////////////////////////TICKET #1336 mock resolution CHECK (Session::current->defaults.define (pipe1, justAnyPipe)); // unrestricted default Query pipeWithSpecificStream("stream("+sID+")"); -lumiera::query::setFakeBypass(pipeWithSpecificStream); ///////////////////////////////////TODO mock resolution +vessel::query::setFakeBypass(pipeWithSpecificStream); ///////////////////////////////////////////////////////TICKET #1336 mock resolution CHECK (Session::current->defaults.define (pipe2, pipeWithSpecificStream)); CHECK ( find (pipe1->getPipeID()), "failure declaring object as default"); diff --git a/tests/core/steam/mobject/session/defs-manager-test.cpp b/tests/core/steam/mobject/session/defs-manager-test.cpp index 9560074ac..52488fb4d 100644 --- a/tests/core/steam/mobject/session/defs-manager-test.cpp +++ b/tests/core/steam/mobject/session/defs-manager-test.cpp @@ -21,7 +21,7 @@ #include "lib/util.hpp" #include "lib/format-string.hpp" #include "lib/query-util.hpp" -#include "common/query.hpp" +#include "vessel/query.hpp" #include "steam/asset.hpp" #include "steam/asset/pipe.hpp" @@ -48,7 +48,7 @@ namespace test { using asset::Pipe; using asset::PPipe; using asset::Struct; - using lumiera::Query; + using vessel::Query; using lib::query::normaliseID; diff --git a/tests/core/steam/mobject/session/defs-registry-impl-test.cpp b/tests/core/steam/mobject/session/defs-registry-impl-test.cpp index f33a6d719..6b3247d32 100644 --- a/tests/core/steam/mobject/session/defs-registry-impl-test.cpp +++ b/tests/core/steam/mobject/session/defs-registry-impl-test.cpp @@ -19,8 +19,8 @@ #include "lib/test/run.hpp" #include "lib/util.hpp" -#include "common/query.hpp" -#include "common/query/defs-registry.hpp" +#include "vessel/query.hpp" +#include "vessel/query/defs-registry.hpp" #include "lib/format-string.hpp" #include "lib/p.hpp" @@ -39,9 +39,9 @@ using std::map; -namespace lumiera { -namespace query { -namespace test { +namespace vessel { +namespace query { +namespace test { namespace { // Test helpers... @@ -292,4 +292,4 @@ namespace test { -}}} // namespace lumiera::query::test +}}} // namespace vessel::query::test diff --git a/tests/core/steam/mobject/session/placement-index-query-test.cpp b/tests/core/steam/mobject/session/placement-index-query-test.cpp index bf4f567f0..937d0d632 100644 --- a/tests/core/steam/mobject/session/placement-index-query-test.cpp +++ b/tests/core/steam/mobject/session/placement-index-query-test.cpp @@ -21,7 +21,7 @@ #include "steam/mobject/session/session-service-explore-scope.hpp" #include "steam/mobject/session/placement-index-query-resolver.hpp" #include "steam/mobject/session/test-scopes.hpp" -#include "common/query/query-resolver.hpp" +#include "vessel/query/query-resolver.hpp" #include "lib/format-cout.hpp" #include "lib/util.hpp" @@ -32,7 +32,7 @@ namespace mobject { namespace session { namespace test { - using lumiera::QueryResolver; + using vessel::QueryResolver; using session::PathQuery; using session::ContentsQuery; using util::isSameObject; diff --git a/tests/core/steam/mobject/session/query-resolver-test.cpp b/tests/core/steam/mobject/session/query-resolver-test.cpp index aa007135e..9ed9b0200 100644 --- a/tests/core/steam/mobject/session/query-resolver-test.cpp +++ b/tests/core/steam/mobject/session/query-resolver-test.cpp @@ -21,14 +21,14 @@ #include "lib/format-cout.hpp" #include "lib/depend.hpp" -#include "common/query/query-resolver.hpp" +#include "vessel/query/query-resolver.hpp" #include -namespace lumiera { -namespace test{ +namespace vessel { +namespace test { using lib::test::showSizeof; using std::string; @@ -215,4 +215,4 @@ namespace test{ LAUNCHER (QueryResolver_test, "unit session"); -}} // namespace lumiera::test +}} // namespace vessel::test diff --git a/tests/core/steam/mobject/session/session-element-tracker-test.cpp b/tests/core/steam/mobject/session/session-element-tracker-test.cpp index 59a4bf9fc..18ffe8128 100644 --- a/tests/core/steam/mobject/session/session-element-tracker-test.cpp +++ b/tests/core/steam/mobject/session/session-element-tracker-test.cpp @@ -24,7 +24,7 @@ #include "steam/mobject/session.hpp" #include "steam/asset/timeline.hpp" #include "steam/asset/sequence.hpp" -#include "common/query.hpp" +#include "vessel/query.hpp" #include "lib/p.hpp" @@ -81,7 +81,7 @@ namespace test { using lib::P; - using lumiera::Query; + using vessel::Query; using asset::Timeline; using asset::PTimeline; using asset::AssetManager; diff --git a/tests/core/steam/mobject/session/session-modify-parts-test.cpp b/tests/core/steam/mobject/session/session-modify-parts-test.cpp index 850f9487f..9de711101 100644 --- a/tests/core/steam/mobject/session/session-modify-parts-test.cpp +++ b/tests/core/steam/mobject/session/session-modify-parts-test.cpp @@ -27,7 +27,7 @@ #include "steam/mobject/session/testclip.hpp" #include "steam/mobject/mobject-ref.hpp" #include "steam/mobject/placement.hpp" -#include "common/query.hpp" +#include "vessel/query.hpp" #include #include @@ -51,7 +51,7 @@ namespace test { using asset::PSequence; using asset::Sequence; - using lumiera::Query; + using vessel::Query; typedef MORef RClip; typedef PlacementMO::ID PID; diff --git a/tests/core/steam/mobject/session/timeline-sequence-handling-test.cpp b/tests/core/steam/mobject/session/timeline-sequence-handling-test.cpp index 811093c68..479e8f2b3 100644 --- a/tests/core/steam/mobject/session/timeline-sequence-handling-test.cpp +++ b/tests/core/steam/mobject/session/timeline-sequence-handling-test.cpp @@ -25,7 +25,7 @@ #include "steam/asset/timeline.hpp" #include "steam/asset/sequence.hpp" #include "steam/asset/pipe.hpp" -#include "common/query.hpp" +#include "vessel/query.hpp" #include "lib/util.hpp" @@ -47,7 +47,7 @@ namespace test { using asset::PSequence; using asset::Pipe; - using lumiera::Query; + using vessel::Query; /****************************************************************************//** diff --git a/tests/core/steam/play/diagnostic-output-slot.hpp b/tests/core/steam/play/diagnostic-output-slot.hpp index 47721d627..296d0f887 100644 --- a/tests/core/steam/play/diagnostic-output-slot.hpp +++ b/tests/core/steam/play/diagnostic-output-slot.hpp @@ -35,7 +35,7 @@ #include "lib/iter-source.hpp" #include "lib/symbol.hpp" #include "lib/util.hpp" -#include "common/advice.hpp" +#include "vessel/advice.hpp" #include "steam/engine/testframe.hpp" //#include "lib/sync.hpp" @@ -69,7 +69,7 @@ namespace play { getTestTimeGrid() { Symbol gridID("DiagnosticOutputSlot-buffer-grid"); - lumiera::advice::Request query4grid(gridID) ; + vessel::advice::Request query4grid(gridID) ; PGrid testGrid25 = query4grid.getAdvice(); if (!testGrid25) diff --git a/tests/core/steam/play/dummy-builder-context.hpp b/tests/core/steam/play/dummy-builder-context.hpp index 8c9fe6e8f..cf7f231d8 100644 --- a/tests/core/steam/play/dummy-builder-context.hpp +++ b/tests/core/steam/play/dummy-builder-context.hpp @@ -44,7 +44,7 @@ #include "steam/play/output-manager.hpp" #include "steam/asset/timeline.hpp" #include "steam/asset/pipe.hpp" -#include "common/query.hpp" +#include "vessel/query.hpp" #include "lib/iter-source.hpp" #include "lib/nocopy.hpp" @@ -87,7 +87,7 @@ namespace test { using mobject::ModelPort; using fixture::ModelPortRegistry; using util::contains; - using lumiera::Query; + using vessel::Query; using PID = asset::ID; diff --git a/tests/core/steam/play/dummy-play-connection-test.cpp b/tests/core/steam/play/dummy-play-connection-test.cpp index 3f40c7b5c..badbfaf90 100644 --- a/tests/core/steam/play/dummy-play-connection-test.cpp +++ b/tests/core/steam/play/dummy-play-connection-test.cpp @@ -19,7 +19,7 @@ #include "lib/test/run.hpp" #include "steam/play/dummy-play-connection.hpp" -#include "include/play-facade.hpp" +#include "vessel/spine/play-facade.hpp" #include "lib/time/control.hpp" @@ -34,7 +34,7 @@ namespace test { //using steam::engine::test::testData; //using steam::engine::test::TestFrame; - using lumiera::Play; + using vessel::spine::Play; typedef time::Control DurationControl; diff --git a/tests/core/steam/play/dummy-play-connection.hpp b/tests/core/steam/play/dummy-play-connection.hpp index d1baf7acc..65c0e0429 100644 --- a/tests/core/steam/play/dummy-play-connection.hpp +++ b/tests/core/steam/play/dummy-play-connection.hpp @@ -60,7 +60,6 @@ ** As of 2016, I still consider this design valid and intend to pick up development when ** able to address this topic again. At the moment, the UI-Session connection is more urgent. ** - ** @see lumiera::DummyPlayer ** @see stage::PlaybackController usage exampleS */ diff --git a/tests/core/steam/play/timing-constraints-test.cpp b/tests/core/steam/play/timing-constraints-test.cpp index f7dd98f56..9ccc982f9 100644 --- a/tests/core/steam/play/timing-constraints-test.cpp +++ b/tests/core/steam/play/timing-constraints-test.cpp @@ -34,15 +34,6 @@ namespace test { using lib::time::Duration; using lib::time::FrameRate; -//using steam::engine::BuffHandle; -//using steam::engine::test::testData; -//using steam::engine::test::TestFrame; - -//using lumiera::Play; - -//typedef time::Control DurationControl; -// -//typedef DummyPlayConnection DummyPlayer; /***************************************************************//** diff --git a/tests/library/advice/advice-basics-test.cpp b/tests/core/vessel/advice/advice-basics-test.cpp similarity index 98% rename from tests/library/advice/advice-basics-test.cpp rename to tests/core/vessel/advice/advice-basics-test.cpp index 5688e5437..e5f10d3e8 100644 --- a/tests/library/advice/advice-basics-test.cpp +++ b/tests/core/vessel/advice/advice-basics-test.cpp @@ -17,10 +17,10 @@ #include "lib/test/run.hpp" -#include "common/advice.hpp" +#include "vessel/advice.hpp" -namespace lumiera { +namespace vessel { namespace advice { namespace test { @@ -256,4 +256,4 @@ namespace test { LAUNCHER (AdviceBasics_test, "unit common"); -}}} // namespace lumiera::advice::test +}}} // namespace vessel::advice::test diff --git a/tests/library/advice/advice-binding-pattern-test.cpp b/tests/core/vessel/advice/advice-binding-pattern-test.cpp similarity index 98% rename from tests/library/advice/advice-binding-pattern-test.cpp rename to tests/core/vessel/advice/advice-binding-pattern-test.cpp index d92003fa7..880a49fa8 100644 --- a/tests/library/advice/advice-binding-pattern-test.cpp +++ b/tests/core/vessel/advice/advice-binding-pattern-test.cpp @@ -21,13 +21,13 @@ #include "lib/format-cout.hpp" #include "lib/time/timevalue.hpp" -#include "common/advice.hpp" +#include "vessel/advice.hpp" using lib::time::Time; -namespace lumiera { +namespace vessel { namespace advice { namespace test { @@ -207,4 +207,4 @@ namespace test { LAUNCHER (AdviceBindingPattern_test, "unit common"); -}}} // namespace lumiera::advice::test +}}} // namespace vessel::advice::test diff --git a/tests/library/advice/advice-configuration-test.cpp b/tests/core/vessel/advice/advice-configuration-test.cpp similarity index 97% rename from tests/library/advice/advice-configuration-test.cpp rename to tests/core/vessel/advice/advice-configuration-test.cpp index 41415be23..3d39a590f 100644 --- a/tests/library/advice/advice-configuration-test.cpp +++ b/tests/core/vessel/advice/advice-configuration-test.cpp @@ -19,7 +19,7 @@ #include "lib/test/run.hpp" //#include "lib/test/test-helper.hpp" -#include "common/advice.hpp" +#include "vessel/advice.hpp" //#include "lib/p.hpp" //#include "steam/assetmanager.hpp" //#include "steam/asset/inventory.hpp" @@ -44,7 +44,7 @@ -namespace lumiera { +namespace vessel { namespace advice { namespace test { @@ -121,4 +121,4 @@ namespace test { LAUNCHER (AdviceConfiguration_test, "unit common"); -}}} // namespace lumiera::advice::test +}}} // namespace vessel::advice::test diff --git a/tests/library/advice/advice-index-test.cpp b/tests/core/vessel/advice/advice-index-test.cpp similarity index 99% rename from tests/library/advice/advice-index-test.cpp rename to tests/core/vessel/advice/advice-index-test.cpp index f288f745c..b02c00cd9 100644 --- a/tests/library/advice/advice-index-test.cpp +++ b/tests/core/vessel/advice/advice-index-test.cpp @@ -18,7 +18,7 @@ #include "lib/test/run.hpp" #include "lib/hash-value.h" -#include "common/advice/index.hpp" +#include "vessel/advice/index.hpp" #include @@ -26,7 +26,7 @@ using lib::Literal; -namespace lumiera { +namespace vessel { namespace advice { namespace test { @@ -426,4 +426,4 @@ namespace test { LAUNCHER (AdviceIndex_test, "function common"); -}}} // namespace lumiera::advice::test +}}} // namespace vessel::advice::test diff --git a/tests/library/advice/advice-multiplicity-test.cpp b/tests/core/vessel/advice/advice-multiplicity-test.cpp similarity index 98% rename from tests/library/advice/advice-multiplicity-test.cpp rename to tests/core/vessel/advice/advice-multiplicity-test.cpp index 2ec305ddd..24507b755 100644 --- a/tests/library/advice/advice-multiplicity-test.cpp +++ b/tests/core/vessel/advice/advice-multiplicity-test.cpp @@ -27,7 +27,7 @@ //#include "lib/meta/trait-special.hpp" //#include "lib/util-foreach.hpp" //#include "lib/symbol.hpp" -#include "common/advice.hpp" +#include "vessel/advice.hpp" //#include @@ -44,7 +44,7 @@ -namespace lumiera { +namespace vessel { namespace advice { namespace test { @@ -123,4 +123,4 @@ namespace test { LAUNCHER (AdviceMultiplicity_test, "function common"); -}}} // namespace lumiera::advice::test +}}} // namespace vessel::advice::test diff --git a/tests/library/advice/advice-situations-test.cpp b/tests/core/vessel/advice/advice-situations-test.cpp similarity index 97% rename from tests/library/advice/advice-situations-test.cpp rename to tests/core/vessel/advice/advice-situations-test.cpp index 9e18f6198..3ae11a29b 100644 --- a/tests/library/advice/advice-situations-test.cpp +++ b/tests/core/vessel/advice/advice-situations-test.cpp @@ -19,11 +19,11 @@ #include "lib/test/run.hpp" //#include "lib/test/test-helper.hpp" -#include "common/advice.hpp" +#include "vessel/advice.hpp" -namespace lumiera { +namespace vessel { namespace advice { namespace test { @@ -137,4 +137,4 @@ namespace test { LAUNCHER (AdviceSituations_test, "function common"); -}}} // namespace lumiera::advice::test +}}} // namespace vessel::advice::test diff --git a/tests/core/application/subsystem-runner-test.cpp b/tests/core/vessel/subsystem-runner-test.cpp similarity index 97% rename from tests/core/application/subsystem-runner-test.cpp rename to tests/core/vessel/subsystem-runner-test.cpp index b058397d5..021a630f8 100644 --- a/tests/core/application/subsystem-runner-test.cpp +++ b/tests/core/vessel/subsystem-runner-test.cpp @@ -20,9 +20,9 @@ #include "lib/test/run.hpp" #include "lib/test/test-helper.hpp" -#include "common/subsys.hpp" -#include "common/subsystem-runner.hpp" -#include "common/option.hpp" +#include "vessel/subsys.hpp" +#include "vessel/subsystem-runner.hpp" +#include "vessel/option.hpp" #include "lib/symbol.hpp" #include "lib/thread.hpp" @@ -48,11 +48,12 @@ using std::this_thread::sleep_for; using std::chrono::milliseconds; -namespace lumiera { +namespace vessel { namespace test { namespace { // private test classes and data... + using lumiera::Error; using lib::query::extractID; /** limit for the randomly selected duration of @@ -80,7 +81,7 @@ namespace test { /** dummy options just to be ignored */ lib::Cmdline dummyArgs (""); - lumiera::Option dummyOpt (dummyArgs); + Option dummyOpt (dummyArgs); /** marker for simulated failure exceptions */ LUMIERA_ERROR_DEFINE( TEST, "simulated failure."); @@ -98,7 +99,7 @@ namespace test { * by a number of definitions, given at construction in logic predicate notation. */ class MockSys - : public lumiera::Subsys + : public Subsys { const string id_; const string spec_; @@ -114,7 +115,7 @@ namespace test { unique_ptr thread_{}; bool - shouldStart (lumiera::Option&) override + shouldStart (Option&) override { string startSpec (extractID ("start",spec_)); return "true" ==startSpec @@ -124,7 +125,7 @@ namespace test { bool - start (lumiera::Option&, Subsys::SigTerm termination) override + start (Option&, Subsys::SigTerm termination) override { CHECK (not (isUp_ or started_ or didRun_), "attempt to start %s twice!", cStr(*this)); @@ -261,9 +262,9 @@ namespace test { * For each such MockSys, we can define a behaviour pattern, e.g. * weather the start succeeds and if the run terminates with error. * - * @see lumiera::Subsys - * @see lumiera::SubsystemRunner - * @see lumiera::AppState + * @see vessel::Subsys + * @see vessel::SubsystemRunner + * @see vessel::Voyage * @see main.cpp */ class SubsystemRunner_test : public Test @@ -436,4 +437,4 @@ namespace test { -}} // namespace lumiera::test +}} // namespace vessel::test diff --git a/tests/core/application/test-configloader.c b/tests/core/vessel/test-configloader.c similarity index 99% rename from tests/core/application/test-configloader.c rename to tests/core/vessel/test-configloader.c index 0db7ab7f0..8d3da7c83 100644 --- a/tests/core/application/test-configloader.c +++ b/tests/core/vessel/test-configloader.c @@ -20,8 +20,8 @@ #include "lib/tmpbuf.h" -#include "common/config.h" -#include "common/configitem.h" +#include "vessel/config.h" +#include "vessel/configitem.h" #include "lib/test/test.h" diff --git a/tests/core/application/test-interfaces.c b/tests/core/vessel/test-interfaces.c similarity index 99% rename from tests/core/application/test-interfaces.c rename to tests/core/vessel/test-interfaces.c index 09116192f..2699e7e93 100644 --- a/tests/core/application/test-interfaces.c +++ b/tests/core/vessel/test-interfaces.c @@ -18,11 +18,11 @@ */ -#include "common/interface.h" -#include "common/interfaceregistry.h" -#include "common/interface-descriptor.h" -#include "common/config.h" -#include "common/config-interface.h" +#include "vessel/interface.h" +#include "vessel/interfaceregistry.h" +#include "vessel/interface-descriptor.h" +#include "vessel/config.h" +#include "vessel/config-interface.h" #include "lib/test/test.h" #include "interface/say-hello.h" diff --git a/tests/include/interface/say-hello.h b/tests/include/interface/say-hello.h index 1c0308ee3..dcf791c5d 100644 --- a/tests/include/interface/say-hello.h +++ b/tests/include/interface/say-hello.h @@ -5,7 +5,7 @@ #ifndef TESTS_INCLUDE_SAY_HELLO_H #define TESTS_INCLUDE_SAY_HELLO_H -#include "common/interface.h" +#include "vessel/interface.h" /** mock interface which can greet in different languages */ diff --git a/tests/library/app-config-test.cpp b/tests/library/app-config-test.cpp index d8d254d60..df3c55d06 100644 --- a/tests/library/app-config-test.cpp +++ b/tests/library/app-config-test.cpp @@ -1,5 +1,5 @@ /* - Appconfig(Test) - accessing the always-available AppState singleton + AppConfig(Test) - accessing the always-available Voyage singleton Copyright (C) 2008, Hermann Vosseler @@ -18,18 +18,22 @@ #include "lib/test/run.hpp" -#include "include/config-facade.h" +#include "vessel/spine/config-facade.h" #include "lib/symbol.hpp" #include "lib/util.hpp" +#include + using lib::Literal; using util::isnil; -namespace lumiera { +namespace vessel { namespace test { + using spine::Config; + class Appconfig_test : public Test { @@ -44,8 +48,8 @@ namespace test { void fetchSetupValue () { Literal key("Lumiera.version"); - string ver = Config::get(key); - CHECK (!isnil(ver)); + std::string ver = Config::get(key); + CHECK (not isnil(ver)); } }; @@ -53,5 +57,5 @@ namespace test { LAUNCHER (Appconfig_test, "function common"); -}} // namespace util::test +}} // namespace vessel::test diff --git a/tests/library/life-cycle-test.cpp b/tests/library/life-cycle-test.cpp index b585b173e..4e2a297bd 100644 --- a/tests/library/life-cycle-test.cpp +++ b/tests/library/life-cycle-test.cpp @@ -1,5 +1,5 @@ /* - LifeCycle(Test) - checking the lifecycle callback hooks provided by AppState + LifeCycle(Test) - verufy the lifecycle callback hooks Copyright (C) 2008, Hermann Vosseler @@ -20,12 +20,12 @@ #include "lib/test/run.hpp" #include "lib/util.hpp" -#include "include/lifecycle.h" +#include "include/lifecycle.hpp" -namespace lumiera{ +namespace vessel { namespace test { uint basicInit (0); @@ -68,5 +68,5 @@ namespace test { -}} // namespace util::test +}}// namespace vessel::test diff --git a/tests/plugin/test-c-plugin/example-plugin.c b/tests/plugin/test-c-plugin/example-plugin.c index 18b190421..bee966be4 100644 --- a/tests/plugin/test-c-plugin/example-plugin.c +++ b/tests/plugin/test-c-plugin/example-plugin.c @@ -21,8 +21,8 @@ #include -#include "common/interface-descriptor.h" -#include "common/config-interface.h" +#include "vessel/interface-descriptor.h" +#include "vessel/config-interface.h" #include "interface/say-hello.h" diff --git a/tests/plugin/test-cpp-plugin/example-plugin.cpp b/tests/plugin/test-cpp-plugin/example-plugin.cpp index 19af884eb..a70b8df63 100644 --- a/tests/plugin/test-cpp-plugin/example-plugin.cpp +++ b/tests/plugin/test-cpp-plugin/example-plugin.cpp @@ -21,13 +21,13 @@ -#include "common/interface-descriptor.h" -#include "common/config-interface.h" +#include "vessel/interface-descriptor.h" +#include "vessel/config-interface.h" #include "lib/format-string.hpp" extern "C" { -#include "common/interface.h" -#include "common/interface-descriptor.h" +#include "vessel/interface.h" +#include "vessel/interface-descriptor.h" #include "interface/say-hello.h" } diff --git a/tests/testrunner.cpp b/tests/testrunner.cpp index a8a8927f2..bf4b91ded 100644 --- a/tests/testrunner.cpp +++ b/tests/testrunner.cpp @@ -18,13 +18,13 @@ ** together with this translation unit into the executable `target/test-suite` */ -#include "include/lifecycle.h" +#include "include/lifecycle.hpp" #include "lib/test/testoption.hpp" #include "lib/test/suite.hpp" -using lumiera::LifecycleHook; -using lumiera::ON_GLOBAL_INIT; -using lumiera::ON_GLOBAL_SHUTDOWN; +using vessel::LifecycleHook; +using vessel::ON_GLOBAL_INIT; +using vessel::ON_GLOBAL_SHUTDOWN; /** run all tests or any single test specified in the first diff --git a/wiki/thinkPad.ichthyo.mm b/wiki/thinkPad.ichthyo.mm index 7cc0cf4f2..82b8a74b2 100644 --- a/wiki/thinkPad.ichthyo.mm +++ b/wiki/thinkPad.ichthyo.mm @@ -71658,6 +71658,20 @@ + + + + + + + + + + + + + + @@ -71737,7 +71751,27 @@ - + + + + + + + + + + + + + + + + + + + + + @@ -71747,6 +71781,14 @@ + + + + + + + + @@ -71757,6 +71799,9 @@ + + + @@ -71806,9 +71851,27 @@ - - + + + + + +

+ Damit stelle ich mich gegen die vorherschende Tendenz meines Zeitalters. +

+

+ Die Bedingtheiten und Umstände, die ich nicht wirklich zu vertreten habe, brachten mich in die Position, diese Entscheidung zu fällen. +

+

+ Grundsätzlich war dies aber von Beginn an meine Haltung, und diese Haltung hat verhindert, daß sich das Projekt »Lumiera« normal entwickelt hat. +

+ + + + + + @@ -71827,6 +71890,121 @@ + + + + +

+ The »Vessel« +

+ + + + + + + + + + + +

+ Die Bedeutung dieser Abgrenzung ergibt sich aus der Historie des Projekts. +

+

+ Es gab einmal eine andere Vision. Das war niemals meine Vision — aber ich habe sie anfangs, und für viel zu lange Zeit mitgetragen. Meine Gründe dafür sind zweifelhaft. Ich war nicht in der Position, mich offen gegen einen derart emotional besetzten Trend zu stellen. Inzwischen jedoch ist eine solche Position für mich in greifbarer Nähe, wenngleich ich trotzdem auf der Hut sein sollte und daraus kein eigenes Thema machen. +

+
+

+ Diese andere Vision beruht darin, jedwede Begrenzung zu verachten, und sich vielmehr durch geschicktes Manövrieren jederzeit unermessliche Möglichkeiten offen zu halten. Dazu sagt »man«, daß nur ein nahezu vernachlässigbar kleiner Anker notwendig ist, ein Mikro-Kern, der lediglich die Fähigkeit beitet, weitere Elemente dynamisch nachzuladen. Damit könnte man »im Prinzip« jederzeit alles Erdenkliche machen, und vor allem jederzeit blitzschnell etwas ganz anderes machen, wenn's denn grad commod ist. Natürlich kann »man« das nicht selber machen, schließlich sind wir ja alle sterblich, aber im Moment noch nicht. Weiß doch jedes Kind. Aber wenn »die Anderen« einen Drive bekommen, dann könnte »man« so viel schaffen. Und den Rest wird man dann schon sehen. +

+
+

+ Die Wesenszüge dieser anderen Vision sind Folgende: +

+
    +
  • + die primäre Leistung besteht darin, die Sache als unvorstellbar einfach, billig und geschickt darzustellen +
    • +
  • + das erzeugt ein Gefühl der Leichtigkeit, das die Umstehenden zum »Mitmachen« ermuntert +
    • +
  • + die Grundeinrichtung muß so beschaffen sein, daß sich damit vor allem sehr schnell ein sichtbarer Effekt erzeugen läßt, der Außenstehende in Staunen versetzt +
    • +
  • + die eigentliche Arbeit an der Inkohärenz der Realität verschiebt man geschickt in die Zukunft („das werden wir dann sehen und lösen, wenns so weit ist“) +
    • +
  • + der schnell sichtbare Erfolg wird umgemünzt in einen Beleg einer tatsächlichen Leistung, die auf wunderbare Weise durch die Kräfte der Gemeinschaft zustande gekommen ist +
    • +
  • + »man» selber hat ganz entschieden keine eigene Vision, sondern nur „so Ideen“ und betont stets, daß man der Gemeinschaft dient und folgt +
    • +
  • + bei den ersten sich zeigenden Schwierigkeiten wird anderen die Schuld zugewiesen, dumm und vernagelt zu sein, und »man« zieht verärgert weiter, auf die nächste grüne Wiese nebenan... +
    • +
+

+ +

+

+ Um deutlicher zu werden: heute haben wir die »KI«. Vor 20 Jahren haben wir von »Plug-ins« geträumt. Irgendwo dazwischen lag der Hype um Frameworks und Plattformen. Das Grundmuster bleibt das Gleiche: man muß eine »Wirkung ohne Ursache« erzeugen. Jede Festlegung und Eingrenzung ist zu vermeiden, denn sie beschneidet schon wieder die unendlichen Möglichkeiten! +

+ + + + + + + + + + + + +

+ Ein »Basis-Kontext« wäre durch folgende Eigenschaften gekennzeinet: +

+
    +
  • + er ist stes »einfach da« +
    • +
  • + er hat keinen eigenen Lebenszyklus +
    • +
  • + er ist nach Bedarf zugänglich +
    • +
+ + + + + + + +

+ Wenn man einen solchen Basis-Kontext (der mit gegebenen technischen Mitteln durchaus realisierbar ist) verbindet mit einem »Bootstrap-Mechanismus«, dann gelangt man zu einem Mikro-Kern. Dieser Start-Mechanismus würde vor allem eine »Konfiguration« laden aus einer per Konvention festgelegten Quelle. All die eigentlichen Strukturen sind dann in der Konfiguration versteckt, die damit zur eigentlichen Konstruktion des Systems wird. +

+

+ +

+

+ Unter speziellen gegebenen Umständen kann das eine tragfähige technische Lösung sein. Aber der Mikro-Kern war das Zentrale Element in dem Wunder-Glauben, der vor 20 Jahren mit »Plug-ins« verbunden wurde. Und wo an Wunder geglaubt wird, stelle ich kritische Fragen. +

+ + + + + + + + + + + +