[rkward-cvs] SF.net SVN: rkward: [2349] trunk/rkward
tfry at users.sourceforge.net
tfry at users.sourceforge.net
Tue Jan 29 00:00:33 UTC 2008
Revision: 2349
http://rkward.svn.sourceforge.net/rkward/?rev=2349&view=rev
Author: tfry
Date: 2008-01-28 16:00:33 -0800 (Mon, 28 Jan 2008)
Log Message:
-----------
Move technical docs to an own subdirectory and add thoughts on redesigning the backend
Added Paths:
-----------
trunk/rkward/techdocs/
trunk/rkward/techdocs/component-draft
trunk/rkward/techdocs/r_eventloop
trunk/rkward/techdocs/release_recipe
Removed Paths:
-------------
trunk/rkward/component-draft
trunk/rkward/release_recipe
Deleted: trunk/rkward/component-draft
===================================================================
--- trunk/rkward/component-draft 2008-01-28 23:59:59 UTC (rev 2348)
+++ trunk/rkward/component-draft 2008-01-29 00:00:33 UTC (rev 2349)
@@ -1,213 +0,0 @@
-RKComponent (and related classes) draft:
-
-Key classes:
-
-RKComponentProperty
-something used as input, and output. Several types of this may exist, each offering different values. The more interesting application is using them as input-suppliers for components. RKComponentProperty should probably also do input verification. Basically, an RKComponentProperty is the GUI-independent portion of a GUI-settable value. Mockups:
-
-class RKComponentPropertyBase : public QObject {
-public signals:
-/** property has changed its value. Any connected RKComponentPropertys/RKComponents should update their state
- at param property A pointer to the changed property for easy reference */
- void valueChanged (RKComponentPropertyBase *property);
-public slots:
-/** the (Qt-)slot in which (by default) the (RKComponent-)property is notified, when a property it depends on has changed. Generally you should reimplement this function to add special handling for the properties you know about. */
- virtual void governorValueChanged (RKComponentPropertyBase *property);
-public:
- enum RKComponentPropertyTypes {
- 0: RKComponentPropertyBase,
- 1: RKComponentPropertyBool,
- 2: RKComponentPropertyInt,
- 3: RKComponentPropertyDouble,
- 4: RKComponentPropertyRObject,
- 5: RKComponentPropertyRObjectList,
- 1000: RKComponentPropertyUser /**< for user expansion */
- };
-/** constructor. Pass a valid QObject as parent so the property will be auto-destructed when no longer needed */
- RKComponentPropertyBase (QObject *parent);
-/** destructor */
- virtual ~RKComponentPropertyBase ();
-/** supplies the current value. Since more than one value may be supplied, modifier can be used to select a value. Default implementation only has a single string, however. */
- virtual QString value (const QString &modifier=QString::null);
-/** set the value in string form.
- at returns false if the value is illegal (in the base class, all strings are legal) */
- virtual bool setValue (const QString &string);
-/** do not set the value, only check, whether it is legal */
- virtual bool isValid (const QString &string);
-/** current setting valid? */
- bool isValid ();
-/** set to required: will only be satisfied if it holds a valid value. Else: satisfied if valid *or empty* */
- void setRequired ();
-/** see setRequired () */
- bool isSatisfied ();
-/** for RTTI. see RKComponentPropertyTypes */
- virtual int type ();
-/** connect this property to a governor property (given as argument). If reconcile_requirements, the requirements of both properties are reconciled to the least common denominator. The dependent property will be notified on all changes made in the governing property, so it can update its value.
-Generally with few exceptions, you can only connect to properties that are either of the same class as this property, or of an extended class. Maybe in the future we will add some sophisticated converters allowing to connect vastly different types of properties in a meaningful way.
-If you specify a modifier, only the sub-value indicated by the modifier will be retrieved from the governing property on governorValueChanged. In this case reconcile_requirements is ignored. */
- virtual void connectGovernor (RKComponentPropertyBase *governor, const QString &modifier=QString::null, bool reconcile_requirements=true);
-private:
- bool valid;
- bool required;
-/** if we're only interested in a specific sub-information of the governor-property, we need to remember the corresponding modifier */
- QString governor_modifier;
-};
-
-/** special type of RKComponentProperty, that is based on a bool setting */
-class RKComponentPropertyBool : public RKComponentPropertyBase {
-public:
-/** param value_true string value if true/on
-param value_false string value if false/off
-param default value to use, if invalid string value was set */
- RKComponentPropertyBool (const QString &value_true, const QString &value_false, bool default);
-/** sets the bool value. Also takes care of notifying dependent components */
- void setValue (bool value);
-/** current value as bool */
- bool boolValue ();
-/** reimplemented from RKComponentPropertyBase. Modifier "true" returns value if true. Modifier "false" returns value if false. Modifier QString::null returns current value. */
- QString value (const QString &modifier=QString::null);
-/** reimplemented from RKComponentPropertyBase to convert to bool value according to current settings */
- bool setValue (const QString &value);
-/** reimplemented from RKComponentPropertyBase to test whether conversion to bool value is possible according to current settings */
- bool isValid (const QString &value);
-};
-
-class RKComponentPropertyInt; // min, max
-class RKComponentPropertyDouble; // min, max
-
-/** special type of RKComponentProperty, that prepresents an RObject
-//TODO: this property should auto-connect to RKModificationTracker, to be safe when the object gets deleted/changed
-class RKComponentPropertyRObject : public RKComponentPropertyBase {
-public:
- void setClassFilter (const QString &classes);
- void setTypeFilter (const QString &types);
- void setDimensionFilter (int dimensionality, int min_length=-1, int max_length=-1);
- bool setValue (RObject *object);
- bool isValid (RObject *object);
- RObject *objectValue ();
-/** reimplemented from RKComponentPropertyBase. Modifier "label" returns label. Modifier "shortname" returns short name. Modifier QString::null returns full name. */
- QString value (const QString &modifier=QString::null);
-/** reimplemented from RKComponentPropertyBase to convert to RObject, if possible with current constraints */
- bool setValue (const QString &value);
-/** reimplemented from RKComponentPropertyBase to test whether conversion to RObject, is possible with current constraints */
- bool isValid (const QString &value);
-};
-
-/** extension of RKComponentPropertyRObject, allowing to hold several RObjects at once. */
-class RKComponentPropertyRObjectList : public RKComponentPropertyRObject {
-public:
- void setListLength (int min_length, int min_length_if_any=-1, int max_length=-1);
- bool addValue (RObject *object);
- void removeValue (RObject *object);
- bool isValid (RObject *object);
-/** reimplemented from RKComponentPropertyBase to return the first RObject in the list */
- RObject *objectValue ();
- QValueList<RObject *> objectList ();
-/** reimplemented from RKComponentPropertyBase. Modifier "label" returns label. Modifier "shortname" returns short name. Modifier QString::null returns full name. */
- QString value (const QString &modifier=QString::null);
-/** reimplemented from RKComponentPropertyBase to convert to list of RObject, if possible with current constraints */
- bool setValue (const QString &value);
-/** reimplemented from RKComponentPropertyBase to test whether conversion to list of RObject, is possible with current constraints */
- bool isValid (const QString &value);
-};
-
-/** special type of RKComponentProperty used to contain R code. All stand-alone RKComponents have this. The great thing about this, is that code can be made available to embedding RKComponents by just fetching the component.code.preprocess (or .calculate, .printout, .cleanup) value */
-class RKComponentPropertyCode : public RKComponentPropertyBase {
-public:
-/** the preprocess code */
- QString preprocess ();
-/** the calculate code */
- QString calculate ();
-/** the printout code */ // TODO, maybe we can abstract this away. A component should _either_ do calculation _or_ printout, hence it could all be calculate () only, as well.
- QString printout ();
-/** the cleanup code */
- QString cleanup ();
-};
-
-RKComponentPropertys are attached to and owned by RKComponents (those that use it as output)
-
-/** abstract base class of all RKComponents, including component widgets */
-class RKComponent : public QWidget {
-public slots:
-/** generally the valueChanged () signal of all RKComponentPropertys directly owned by this component should be connected to this (Qt-)slot, so the component can update itself accordingly */
- void propertyValueChanged (RKComponentPropertyBase *property);
-public:
-/** standard property controlling visibility */
- RKComponentPropertyBool *visibilityProperty ();
-/** standard property controlling enabledness */
- RKComponentPropertyBool *enablednessProperty ();
-/** standard property controlling requiredness */
- RKComponentPropertyBool *requirednessProperty ();
-
-/** The parent of this component. Should be notified, whenever isSatisfied () or isReady ()-state changed. */
- RKComponent *parent ();
- bool isSatisfied ();
- bool isReady ();
-/** Locate the component.subcomponent.property.value described by modifier and return its value as a string. Especially useful as a callback in code templates! Recursively walks subcomponents/properties until the requested value is found. */
- QString fetchStringValue (const QString &modifier);
-private:
-/** also notifies the parent, if applicable */
- void setSatisfied (bool satisfied);
- void setReady (bool ready);
-};
-
-/** "regular" components, described in XML format */
-class RKStandardComponent : public RKComponent {
-};
-
-/** wrapper class for "external" components, i.e. components implemented in stand-alone applets */
-class RKExternalComponent : public RKComponent {
-};
-
-/** (long-term): A special RKComponent doing some sort of logic conversion. It's used to connect to one or more governing properties, process/convert the value of those properties in some way, and provide one (or more) output properties.
-//TODO: how will these be programmed? Hopefully we will soon have a better picture on what logic elements are actually commonly needed */
-class RKLogicComponent;
-
-// TODO: do we need this at all?
-/** describes the external interface provided by an RKComponent. This means a list of all properties that can be used as input for this component. Used for matching/mapping external RKComponentPropertys to RKComponentPropertys inside this component */
-class RKComponentInterface {
-};
-
-
-
-Initialization steps in creating an RKComponent:
-On top level: probably a call to setUpdatesEnabled (false) should be done!
- - create Subcomponents (depth first is important!)
- - ...
- - create RKComponentProperty's
- - initialize
- - set initial values in RKComponentProperty's
- (- updates GUI)
- (- may trigger changes in subcomponents)
- - connect RKComponentPropertys within this component and to subcomponents (those are already fully connected!)
- - connect
- - retrieve values from governing properties
- (- may trigger further changes in this, and subcomponents)
- - return to parent
-On top level: probably a call to setUpdatesEnabled (true); update () should be done!
-
-/** A helper class used to build and initialize an RKComponent. Most importantly this will keep track of the properties yet to be connected. Used at least by RKStandardComponent. */
-class RKComponentBuilder {
-public:
- RKComponentBuilder (RKComponent *parent);
- ~RKComponentBuilder ();
- void buildElement (const QDomElement &element);
- void makeConnections ();
-private:
- RKComponent *parent;
- struct RKComponentPropertyConnection {
- QString governor_property;
- QString client_property;
- bool reconcile;
- };
- QValueList <RKComponentPropertyConnection *> connection_list;
-};
-
-
-Implementation plan:
-0) Create new directory component. Most of what's in plugin now will be migrated there.
-1) Create main RKComponentProperty classes (full API, basic implementation)
-2) Create an initial implementation of RKStandardComponent, copying heavily from RKPlugin (little code will remain in RKPlugin at the end)
-3) Create a few first RKComponentWidgets, copying from RKPluginWidgets, but using RKComponentProperty's internally, and deriving from RKComponent
-4) Test and get basic functionality working
-5) Finish migration
Deleted: trunk/rkward/release_recipe
===================================================================
--- trunk/rkward/release_recipe 2008-01-28 23:59:59 UTC (rev 2348)
+++ trunk/rkward/release_recipe 2008-01-29 00:00:33 UTC (rev 2349)
@@ -1,11 +0,0 @@
-This procedure helps working around a number of strange problems while creating releases, such as .moc-files not being generated, generated files not being removed, autotools being run again (with bad results) for no good reason... The following procedure seems to eliminate those problems, and thus should be followed for releases. Some items may also serve to keep the package lean.
-
-make clean
-make dist
-unpack tarball and cd there
-rm -rf admin/.svn
-make -f Makefile.svn
-rm rkward/rkward_skel.cpp
-touch config.h.in
-rm -r autom4te.cache
-repackage tarball
Copied: trunk/rkward/techdocs/component-draft (from rev 2323, trunk/rkward/component-draft)
===================================================================
--- trunk/rkward/techdocs/component-draft (rev 0)
+++ trunk/rkward/techdocs/component-draft 2008-01-29 00:00:33 UTC (rev 2349)
@@ -0,0 +1,213 @@
+RKComponent (and related classes) draft:
+
+Key classes:
+
+RKComponentProperty
+something used as input, and output. Several types of this may exist, each offering different values. The more interesting application is using them as input-suppliers for components. RKComponentProperty should probably also do input verification. Basically, an RKComponentProperty is the GUI-independent portion of a GUI-settable value. Mockups:
+
+class RKComponentPropertyBase : public QObject {
+public signals:
+/** property has changed its value. Any connected RKComponentPropertys/RKComponents should update their state
+ at param property A pointer to the changed property for easy reference */
+ void valueChanged (RKComponentPropertyBase *property);
+public slots:
+/** the (Qt-)slot in which (by default) the (RKComponent-)property is notified, when a property it depends on has changed. Generally you should reimplement this function to add special handling for the properties you know about. */
+ virtual void governorValueChanged (RKComponentPropertyBase *property);
+public:
+ enum RKComponentPropertyTypes {
+ 0: RKComponentPropertyBase,
+ 1: RKComponentPropertyBool,
+ 2: RKComponentPropertyInt,
+ 3: RKComponentPropertyDouble,
+ 4: RKComponentPropertyRObject,
+ 5: RKComponentPropertyRObjectList,
+ 1000: RKComponentPropertyUser /**< for user expansion */
+ };
+/** constructor. Pass a valid QObject as parent so the property will be auto-destructed when no longer needed */
+ RKComponentPropertyBase (QObject *parent);
+/** destructor */
+ virtual ~RKComponentPropertyBase ();
+/** supplies the current value. Since more than one value may be supplied, modifier can be used to select a value. Default implementation only has a single string, however. */
+ virtual QString value (const QString &modifier=QString::null);
+/** set the value in string form.
+ at returns false if the value is illegal (in the base class, all strings are legal) */
+ virtual bool setValue (const QString &string);
+/** do not set the value, only check, whether it is legal */
+ virtual bool isValid (const QString &string);
+/** current setting valid? */
+ bool isValid ();
+/** set to required: will only be satisfied if it holds a valid value. Else: satisfied if valid *or empty* */
+ void setRequired ();
+/** see setRequired () */
+ bool isSatisfied ();
+/** for RTTI. see RKComponentPropertyTypes */
+ virtual int type ();
+/** connect this property to a governor property (given as argument). If reconcile_requirements, the requirements of both properties are reconciled to the least common denominator. The dependent property will be notified on all changes made in the governing property, so it can update its value.
+Generally with few exceptions, you can only connect to properties that are either of the same class as this property, or of an extended class. Maybe in the future we will add some sophisticated converters allowing to connect vastly different types of properties in a meaningful way.
+If you specify a modifier, only the sub-value indicated by the modifier will be retrieved from the governing property on governorValueChanged. In this case reconcile_requirements is ignored. */
+ virtual void connectGovernor (RKComponentPropertyBase *governor, const QString &modifier=QString::null, bool reconcile_requirements=true);
+private:
+ bool valid;
+ bool required;
+/** if we're only interested in a specific sub-information of the governor-property, we need to remember the corresponding modifier */
+ QString governor_modifier;
+};
+
+/** special type of RKComponentProperty, that is based on a bool setting */
+class RKComponentPropertyBool : public RKComponentPropertyBase {
+public:
+/** param value_true string value if true/on
+param value_false string value if false/off
+param default value to use, if invalid string value was set */
+ RKComponentPropertyBool (const QString &value_true, const QString &value_false, bool default);
+/** sets the bool value. Also takes care of notifying dependent components */
+ void setValue (bool value);
+/** current value as bool */
+ bool boolValue ();
+/** reimplemented from RKComponentPropertyBase. Modifier "true" returns value if true. Modifier "false" returns value if false. Modifier QString::null returns current value. */
+ QString value (const QString &modifier=QString::null);
+/** reimplemented from RKComponentPropertyBase to convert to bool value according to current settings */
+ bool setValue (const QString &value);
+/** reimplemented from RKComponentPropertyBase to test whether conversion to bool value is possible according to current settings */
+ bool isValid (const QString &value);
+};
+
+class RKComponentPropertyInt; // min, max
+class RKComponentPropertyDouble; // min, max
+
+/** special type of RKComponentProperty, that prepresents an RObject
+//TODO: this property should auto-connect to RKModificationTracker, to be safe when the object gets deleted/changed
+class RKComponentPropertyRObject : public RKComponentPropertyBase {
+public:
+ void setClassFilter (const QString &classes);
+ void setTypeFilter (const QString &types);
+ void setDimensionFilter (int dimensionality, int min_length=-1, int max_length=-1);
+ bool setValue (RObject *object);
+ bool isValid (RObject *object);
+ RObject *objectValue ();
+/** reimplemented from RKComponentPropertyBase. Modifier "label" returns label. Modifier "shortname" returns short name. Modifier QString::null returns full name. */
+ QString value (const QString &modifier=QString::null);
+/** reimplemented from RKComponentPropertyBase to convert to RObject, if possible with current constraints */
+ bool setValue (const QString &value);
+/** reimplemented from RKComponentPropertyBase to test whether conversion to RObject, is possible with current constraints */
+ bool isValid (const QString &value);
+};
+
+/** extension of RKComponentPropertyRObject, allowing to hold several RObjects at once. */
+class RKComponentPropertyRObjectList : public RKComponentPropertyRObject {
+public:
+ void setListLength (int min_length, int min_length_if_any=-1, int max_length=-1);
+ bool addValue (RObject *object);
+ void removeValue (RObject *object);
+ bool isValid (RObject *object);
+/** reimplemented from RKComponentPropertyBase to return the first RObject in the list */
+ RObject *objectValue ();
+ QValueList<RObject *> objectList ();
+/** reimplemented from RKComponentPropertyBase. Modifier "label" returns label. Modifier "shortname" returns short name. Modifier QString::null returns full name. */
+ QString value (const QString &modifier=QString::null);
+/** reimplemented from RKComponentPropertyBase to convert to list of RObject, if possible with current constraints */
+ bool setValue (const QString &value);
+/** reimplemented from RKComponentPropertyBase to test whether conversion to list of RObject, is possible with current constraints */
+ bool isValid (const QString &value);
+};
+
+/** special type of RKComponentProperty used to contain R code. All stand-alone RKComponents have this. The great thing about this, is that code can be made available to embedding RKComponents by just fetching the component.code.preprocess (or .calculate, .printout, .cleanup) value */
+class RKComponentPropertyCode : public RKComponentPropertyBase {
+public:
+/** the preprocess code */
+ QString preprocess ();
+/** the calculate code */
+ QString calculate ();
+/** the printout code */ // TODO, maybe we can abstract this away. A component should _either_ do calculation _or_ printout, hence it could all be calculate () only, as well.
+ QString printout ();
+/** the cleanup code */
+ QString cleanup ();
+};
+
+RKComponentPropertys are attached to and owned by RKComponents (those that use it as output)
+
+/** abstract base class of all RKComponents, including component widgets */
+class RKComponent : public QWidget {
+public slots:
+/** generally the valueChanged () signal of all RKComponentPropertys directly owned by this component should be connected to this (Qt-)slot, so the component can update itself accordingly */
+ void propertyValueChanged (RKComponentPropertyBase *property);
+public:
+/** standard property controlling visibility */
+ RKComponentPropertyBool *visibilityProperty ();
+/** standard property controlling enabledness */
+ RKComponentPropertyBool *enablednessProperty ();
+/** standard property controlling requiredness */
+ RKComponentPropertyBool *requirednessProperty ();
+
+/** The parent of this component. Should be notified, whenever isSatisfied () or isReady ()-state changed. */
+ RKComponent *parent ();
+ bool isSatisfied ();
+ bool isReady ();
+/** Locate the component.subcomponent.property.value described by modifier and return its value as a string. Especially useful as a callback in code templates! Recursively walks subcomponents/properties until the requested value is found. */
+ QString fetchStringValue (const QString &modifier);
+private:
+/** also notifies the parent, if applicable */
+ void setSatisfied (bool satisfied);
+ void setReady (bool ready);
+};
+
+/** "regular" components, described in XML format */
+class RKStandardComponent : public RKComponent {
+};
+
+/** wrapper class for "external" components, i.e. components implemented in stand-alone applets */
+class RKExternalComponent : public RKComponent {
+};
+
+/** (long-term): A special RKComponent doing some sort of logic conversion. It's used to connect to one or more governing properties, process/convert the value of those properties in some way, and provide one (or more) output properties.
+//TODO: how will these be programmed? Hopefully we will soon have a better picture on what logic elements are actually commonly needed */
+class RKLogicComponent;
+
+// TODO: do we need this at all?
+/** describes the external interface provided by an RKComponent. This means a list of all properties that can be used as input for this component. Used for matching/mapping external RKComponentPropertys to RKComponentPropertys inside this component */
+class RKComponentInterface {
+};
+
+
+
+Initialization steps in creating an RKComponent:
+On top level: probably a call to setUpdatesEnabled (false) should be done!
+ - create Subcomponents (depth first is important!)
+ - ...
+ - create RKComponentProperty's
+ - initialize
+ - set initial values in RKComponentProperty's
+ (- updates GUI)
+ (- may trigger changes in subcomponents)
+ - connect RKComponentPropertys within this component and to subcomponents (those are already fully connected!)
+ - connect
+ - retrieve values from governing properties
+ (- may trigger further changes in this, and subcomponents)
+ - return to parent
+On top level: probably a call to setUpdatesEnabled (true); update () should be done!
+
+/** A helper class used to build and initialize an RKComponent. Most importantly this will keep track of the properties yet to be connected. Used at least by RKStandardComponent. */
+class RKComponentBuilder {
+public:
+ RKComponentBuilder (RKComponent *parent);
+ ~RKComponentBuilder ();
+ void buildElement (const QDomElement &element);
+ void makeConnections ();
+private:
+ RKComponent *parent;
+ struct RKComponentPropertyConnection {
+ QString governor_property;
+ QString client_property;
+ bool reconcile;
+ };
+ QValueList <RKComponentPropertyConnection *> connection_list;
+};
+
+
+Implementation plan:
+0) Create new directory component. Most of what's in plugin now will be migrated there.
+1) Create main RKComponentProperty classes (full API, basic implementation)
+2) Create an initial implementation of RKStandardComponent, copying heavily from RKPlugin (little code will remain in RKPlugin at the end)
+3) Create a few first RKComponentWidgets, copying from RKPluginWidgets, but using RKComponentProperty's internally, and deriving from RKComponent
+4) Test and get basic functionality working
+5) Finish migration
Added: trunk/rkward/techdocs/r_eventloop
===================================================================
--- trunk/rkward/techdocs/r_eventloop (rev 0)
+++ trunk/rkward/techdocs/r_eventloop 2008-01-29 00:00:33 UTC (rev 2349)
@@ -0,0 +1,44 @@
+** Notes for restructuring the R event processing **
+
+I've had it with fighting R's event processing. In the current design (two threads in one app), there appear to be some incompatibilities and threading issues with are very hard to solve. See e.g. https://sourceforge.net/tracker/index.php?func=detail&aid=1878594&group_id=50231&atid=459007 .
+
+The new plan: Move the R backend to a separate slave application, instead of just a separate thread.
+
+** The slave app **
+
+The slave app will be single threaded and mostly just run the regular R event loop using Rf_mainloop(). ptr_R_ReadConsole will be overridden, and responsible for getting the code (based on the R_Busy status), as before. We will instantiate a top level callback to find out, when a toplevel command has finished. Substack-calls are handled as before in a tryEval(). Since these are no user calls, they do not need to go through ReadConsole. We leave all event processing to R.
+
+Inside ptr_R_ReadConsole we will run a minimal loop, which simply checks for new commands available.
+
+** The main app **
+
+We can flatten the frontend to only single threaded as well. This will keep a command stack as before, and check for new output in regular intervals as before. However, it only needs to sumbit commands, when the slave app requests that, or a new command has been issued while the slave app is idle. So we save all the ugly processing, here.
+
+** Communication between the apps **
+
+Eventually, we will want network-transparent communication. For now, we focus on the more important single machine case. To keep things fast, we'll use a block of shared memory at least for command result data, and for output. For all other purposes, we can probably simply copy stuff around, even though this, too will probably go through shared memory.
+
+*** Communication routes ***
+
+- Send command string to execute and flags to slave
+- Retrieve current status flag from slave
+- Retrieve status flag of last command from slave
+- Retrieve data of finished command from slave
+- Retrieve list of changed symbols from slave
+- Retrieve callback request from slave
+- Write callback reply to slave
+- Retrieve current output (and type) from slave
+separately:
+- Send interrupt to slave
+
+** Dealing with shared memory **
+
+The devil will be in the details:
+- libmm seems to be a decent standard shared memory library
+ - other libraries: NSPR
+- can this handle only fork()ed processes? I sure hope it also support exec()ed ones!
+- I don't think the implicitely shared Qt classes (most importantly QStrings!) will make it through shared memory. Therefore we will basically pass plain char*s (all UTF8, though). For the other data types we need, we will not have a problem.
+
+** Alternatives **
+
+Maybe we really should use message passing, instead of shared memory? For the case of a local process, we should be able to safely pass raw binary data, so we can probably get very good speed. This would also make it easier to support a remote backend in the future.
\ No newline at end of file
Copied: trunk/rkward/techdocs/release_recipe (from rev 2323, trunk/rkward/release_recipe)
===================================================================
--- trunk/rkward/techdocs/release_recipe (rev 0)
+++ trunk/rkward/techdocs/release_recipe 2008-01-29 00:00:33 UTC (rev 2349)
@@ -0,0 +1,11 @@
+This procedure helps working around a number of strange problems while creating releases, such as .moc-files not being generated, generated files not being removed, autotools being run again (with bad results) for no good reason... The following procedure seems to eliminate those problems, and thus should be followed for releases. Some items may also serve to keep the package lean.
+
+make clean
+make dist
+unpack tarball and cd there
+rm -rf admin/.svn
+make -f Makefile.svn
+rm rkward/rkward_skel.cpp
+touch config.h.in
+rm -r autom4te.cache
+repackage tarball
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
More information about the rkward-tracker
mailing list