Andrew Borley wrote:
On 9/15/06, Jean-Sebastien Delfino <[EMAIL PROTECTED]> wrote:
Andrew Borley wrote:
[snip]
> In other news, I have just added in support for properties to the
Python
> extension:
> - A composite with a property defined in a component and the
associated
> .componentType file:
> <component name="DivideComponent">
> <implementation.python module="DivideImpl" scope="composite"/>
> <property name="doRounding">true</property>
> </component>
>
> <componentType
> ...
> <property name="doRounding" type="xsd:boolean"/>
> </componentType>
>
> Is automatically instantiated and assigned the property value in the
> python
> implementation module:
>
> def divide(val1, val2):
> result = float(val1) / float(val2)
> print "Python - DivideImpl.divide " + str(val1) + " / " + str(val2)
> + "
> = " + str(result)
>
> # Use the doRounding property
> if doRounding:
> result = round(result)
> print "Python - DivideImpl.divide is rounding the result to " +
> str(result)
>
> return result
>
>
> Cheers
>
> Andy
>
Andy, this is nice. What do you think about going just one small step
further to make ComponentType definitions optional, and basically
define the Python variable automatically when it is configured as a
property or a reference on the component definition?
As a scripting developer I am not used to declare my variables ahead of
time, they are just created automatically once I assign a value to them.
Doing this would be in the same spirit: you get a variable created for
you when you configure/assign its value on the component declaration and
the scripting developer does not need to write ComponentType files to
declare things that he usually doesn't like to declare...
+1 for this. I don't really get why we need the .componentType file
when the
info is already in the .composite.
Yes, ComponentTypes are very similar to Classes (and Components to
Objects) so they make most sense when you work with a OO language with
Classes and Objects. In your Python scripting environment you can define
properties directly on Objects so ComponentTypes are less useful.
This would just require a small change to ModelLoader.cpp and your
PythonImplementation.cpp, for references we would do the following:
- ModelLoader would call a new needReferenceType(name) method or a
findReferenceType(string name, createNew=true) method on the
ComponentType (your PythonImplementation) and in this method you would
create the ReferenceType.
- We would follow a similar scheme for properties.
I had started to implement that scheme for Ruby (see
RubyImplementation::findReferenceType() in revision r442461 or
RubyImplementation.cpp) then backed it out as in Ruby you usually
declare your public attributes/properties. But I think that this would
apply well to languages like Python and Javascript.
Let me know what you think.
It sounds good to me - do you have time to implement this? If not I'll
have
a go - I didn't want to touch any of the core code for the extension,
but I
don't mind getting stuck in :)
Cheers
Andy
Great. I can help if you have any questions but if you are interested in
digging into the core code please feel free to go ahead and make the
changes you need :) The more people know the core code the better IMO.
--
Jean-Sebastien
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
