Wolfgang, thank you for your reply. You are right I should provide some
explanation of the problem I am trying to solve here. Could be that you
have an even better solution. :-)
I have two modules. One module represents the facts about the real world
that is possibly modeled by Java objects, which means that some shadow
facts might be involved. The other module's purpose is to reason about
what the effect of firing some rules would be in the environment,
without - and this is of crucial importance - modifying this real world.
This other module does not contain shadow facts. It is intended to be a
dry run. Then, based on some evaluation of the resulting fact base, I
would like to effectuate the result in the real world or not. A rollback
mechanism is not an option because modifying the Java code might have
side effects which cannot be undone, e.g. sending an e-mail.
One solution I had in mind is to make an exact copy of the modules, i.e.
copying all the deftemplates (mimicking defclasses) and rules.
Effectuating the result of the dry run in the real world then becomes a
matter of simply switching focus to the other module and running it. It
seemed to me that doing exactly the same thing twice would be rather
silly and it would be more appropriate to use the track and redo actions
approach I mentioned in my earlier post. Now I realize that doing this
might be a bit tricky, as retracting and modifying facts depends on a
fact id (are these the same in both modules?).
Hope this information gives some more insight in what I am trying to do
here.
Cheers,
Nick.
Wolfgang Laun wrote:
First, I would not use defadvice. If you call assert in the "second"
module, you won't want to add the argument to the linked list. I
*think* that event handling would be more appropriate, even though
this might mean that you'll have to write some Java code.
You write that you want to repeat all assert, modify and retract calls
in the "second" module. It seems that you'll want to have the facts in
that second module to be a copy of the ones in the "first" module. If
that is so, what is the purpose of this exercise? Saving facts so that
they can be safely restored later on can be achieved easier by, e.g.,
calling save-facts.
I hate to give advice without understanding what the other guy is
trying to do; discussing things on a mere technical basis is (mostly)
a waste of time...
Cheers
Wolfgang
On Thu, Dec 4, 2008 at 12:57 PM, <[EMAIL PROTECTED]
<mailto:[EMAIL PROTECTED]>> wrote:
Hi,
I have two modules that are similar. The rules are fired on one
module and
there facts are asserted, modified and retracted. Based on some value
these actions need to performed on the second module. I thought it
might
be a good idea to approach it in this way:
(defglobal ?*acts* = (new LinkedList))
(defadvice before assert
(?*acts* add $?argv)
)
(deffunction makeithappen ( )
(foreach ?a ?*acts*
; call the action
)
)
In words, I store all the actions in the acts list whenever assert is
called. Then, the function makeithappen calls all the functions
again, but
then on the second module. How can I do this? Or is there another way?
Regards,
Nick.
--------------------------------------------------------------------
To unsubscribe, send the words 'unsubscribe jess-users
[EMAIL PROTECTED] <mailto:[EMAIL PROTECTED]>'
in the BODY of a message to [EMAIL PROTECTED]
<mailto:[EMAIL PROTECTED]>, NOT to the list
(use your own address!) List problems? Notify
[EMAIL PROTECTED] <mailto:[EMAIL PROTECTED]>.
--------------------------------------------------------------------
--------------------------------------------------------------------
To unsubscribe, send the words 'unsubscribe jess-users [EMAIL PROTECTED]'
in the BODY of a message to [EMAIL PROTECTED], NOT to the list
(use your own address!) List problems? Notify [EMAIL PROTECTED]
--------------------------------------------------------------------
