Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by phamelin on Fri, 2010-10-15 13:24

Orocos-users

Hello,

on a previous e-mail, I asked if anyone has already developed a toolkit for
Eigen types. I had two answers about that.

On on hand, Sylvain Joyeux told me that it was hard with RTT dataflow to
guarantee the alignment required by Eigen types. So, we have to create
intermediate types which are able to translate from Eigen types and so forth
(e.g. [1]).

On the other hand, Tinne De Laet just implemented a toolkit (see [2]) and,
as far I can see, without using intermediate types.

At this time, I just want to clarify the difference between both
alternatives. Could we just push Matrix elements in a property bags when
coding the Corba transport and XML marshalling, or the alignment problem
also arises when just using an Eigen type in a Property, Attribute or Ports
(without corba transport) ?

Sorry for these questions. I'm not very familiar with this alignment problem
and even with RTT dataflow internals. My only goal is to implemented as best
as possible an Eigen toolkit with Corba transport that could be usable by
everyone.

Thank you,

Philippe Hamelin

[1] http://github.com/doudou/base/blob/imoby/base/linear_algebra.h
[2]
http://svn.mech.kuleuven.be/repos/orocos/trunk/kul-ros-pkg/iTaSC/src/eig...

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Fri, 2010-10-22 20:40.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

> On 10/18/2010 03:29 PM, Simon Pelletier-Thibault wrote:
>>
>>
>> Property<string> myprop("name", "description",
>> AssignableDataSource<string>::shared_ptr(new DataObjectLocked<string>("name")
>> ) ) ;
>>
>> Sorry for that newbie question, but does someone can give me a brief
> explanation of how this line can make the Property thread-safe?
>
>

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Fri, 2010-10-22 19:52.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Fri, 2010-10-22 19:04.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Fri, 2010-10-22 18:16.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Fri, 2010-10-22 17:28.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Fri, 2010-10-22 16:44.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Fri, 2010-10-22 16:00.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Fri, 2010-10-22 15:16.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Fri, 2010-10-22 14:32.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Fri, 2010-10-22 13:48.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Fri, 2010-10-22 13:04.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Fri, 2010-10-22 12:24.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Fri, 2010-10-22 11:40.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Fri, 2010-10-22 11:00.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Fri, 2010-10-22 10:20.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Fri, 2010-10-22 09:36.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Fri, 2010-10-22 08:56.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Fri, 2010-10-22 08:12.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Fri, 2010-10-22 07:32.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Fri, 2010-10-22 06:52.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Fri, 2010-10-22 06:12.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Fri, 2010-10-22 05:32.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Fri, 2010-10-22 04:52.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Fri, 2010-10-22 04:12.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Fri, 2010-10-22 03:32.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Fri, 2010-10-22 02:52.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Fri, 2010-10-22 02:12.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Fri, 2010-10-22 01:32.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Fri, 2010-10-22 00:52.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Fri, 2010-10-22 00:12.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Thu, 2010-10-21 23:32.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Thu, 2010-10-21 22:52.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Thu, 2010-10-21 22:12.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Thu, 2010-10-21 21:32.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Thu, 2010-10-21 20:52.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Thu, 2010-10-21 20:12.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Thu, 2010-10-21 19:32.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Thu, 2010-10-21 18:52.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Thu, 2010-10-21 18:12.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Thu, 2010-10-21 17:36.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Thu, 2010-10-21 17:00.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Thu, 2010-10-21 16:24.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Thu, 2010-10-21 15:48.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Thu, 2010-10-21 15:12.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Thu, 2010-10-21 14:36.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Thu, 2010-10-21 14:00.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Thu, 2010-10-21 13:24.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Thu, 2010-10-21 12:44.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Thu, 2010-10-21 12:08.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote:

Plugin/Toolkit for Eigen2 or Eigen3 types [revisited]

Submitted by Simon on Thu, 2010-10-21 11:36.

Hi Philippe,

First of all you need to undestand that in rtt, data are encapsulated in a
class named datasource : Here a inheritance graph

http://people.mech.kuleuven.be/~orocos/pub/stable/documentation/rtt/v1.8...

>From DataSource, "getter and setter" are overloaded to act diffently in
DataObjectLocked, for example, use mutex to protect its data.

Since Properties use a member smartPointer on AssignableDataSource. We can
build a properties that will use DataObjectLocked and then become thread
safe properties...

The same principle may be applied to Attribut using this kind of syntax :
Attribute<string> myattr("name", new DataObjectLocked<string>("name") )

Back to Eigen Alignment problems:
If you look far in dataSource implementations, you will see dataSource use
the operator= to transfert data:

On Set on DataPort:
Port -> dataSource -> ( Mutex + operator=)
On Get on DataPort
Port -> DataSource -> (Mutex + operator=)

So if data of Eigen is built correctly in the dataSource there should be no
problem. (I'm still newbie with Eigen).

I don't know how to implement it but I think it's possible to make template
specialisation of DataSource that could handle eigen types. The only problem
is the amount of types ....

Simon

On Tue, Oct 19, 2010 at 9:14 AM, Philippe Hamelin <
philippe [dot] hamelin [..] ...> wrote: