commons-user mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Evaldas Taroza <etar...@optaros.com>
Subject Re: [jelly] certain way to evaluate a document (usecase)
Date Mon, 10 Dec 2007 13:23:50 GMT
Hi,
Actually I already have a solution that works (i.e. I have some sort of 
executable XML which has the needed logic), however, for me it is very 
important to answer the question, would it be better to refactor that 
solution in the way that it would use Jelly.

What I have is an engine (coincides with the Jelly script engine) that 
is able to evaluate the XML documents with embedded executable parts. 
These parts are simply XML tags in a special namespace. So for me it 
looks completely like Jelly. The thing is that my engine is:
1. can only understand my tags in my namespace
2. can execute those tags in the order that I predefine (possibly inside 
the tags)
3. during the execution of tags some new data can appear next to those 
tags as a result of execution

Now the question: in order to transition to Jelly will I need to develop 
taglibs only, or I will end up extending and modifying the jelly script 
engine? I would really like it to be the former case:) do you think it 
is reasonable?

Evaldas

Paul Libbrecht wrote:
> Evaldas,
> 
> the jelly script is loaded in memory then the doTag methods are called.
> So, of course, it could not scale to kilometers of source, but, indeed, 
> then a fancy branching logic of doTag is doable.
> 
> hope it helps.
> 
> paul
> 
> 
> Le 10 déc. 07 à 09:42, Evaldas Taroza a écrit :
> 
>> Hi,
>> Yes, I think I would need to implement something similar to the thread 
>> taglib. Because I will need something like:
>> 1. There is a dedicated thread for every tag
>> 2. Some threads are blocked by other threads (waiting to end)
>> 3. Unblocked threads can run
>>
>> I haven't looked deep into Jelly yet, nor available taglibs, but what 
>> worries me is that the script engine is like SAX, so will I be able to 
>> construct a difficult "execution plan" with only one-pass parsing?
>>
>> Evaldas
>>
>> Paul Libbrecht wrote:
>>> Evaldas,
>>> I believe that the answer to your question is that it is flexible.
>>> Jelly's default follows Ant and SAX: most tag's doTag call invokeBody 
>>> which produces a depth-first execution. The thread taglib does it 
>>> differently though.
>>> You might be well served with Jelly although it still has some rough 
>>> edges.
>>> paul
>>> Le 9 déc. 07 à 17:16, Evaldas Taroza a écrit :
>>>> Hi,
>>>> I have a very specific usecase to program. Specifically, I need to 
>>>> be able to execute the tags in a certain order. For instance, I 
>>>> should be able to say that this tag is executing after another, 
>>>> others can execute in parallel etc.
>>>>
>>>> So I am considering Jelly as already implementing the execution of 
>>>> the tags but what about the ordering? In what order are the tags 
>>>> executed now? Is it at all feasible to use Jelly for such a usecase 
>>>> or I will end up implementing a completely new Jelly script 
>>>> evaluation engine?
>>>>
>>>> Evaldas
>>>>
>>
>>
>> ---------------------------------------------------------------------
>> To unsubscribe, e-mail: user-unsubscribe@commons.apache.org
>> For additional commands, e-mail: user-help@commons.apache.org
>>
> 


---------------------------------------------------------------------
To unsubscribe, e-mail: user-unsubscribe@commons.apache.org
For additional commands, e-mail: user-help@commons.apache.org


Mime
View raw message