How to add a vector<MyType> to my typekit?

Submitted by peter on Sun, 2010-10-24 09:56.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sun, 2010-10-24 09:00.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sun, 2010-10-24 08:04.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sun, 2010-10-24 07:08.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sun, 2010-10-24 06:12.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sun, 2010-10-24 05:16.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sun, 2010-10-24 04:20.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sun, 2010-10-24 03:24.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sun, 2010-10-24 02:28.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sun, 2010-10-24 01:32.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sun, 2010-10-24 00:36.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sat, 2010-10-23 23:40.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sat, 2010-10-23 22:44.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sat, 2010-10-23 21:48.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sat, 2010-10-23 20:52.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sat, 2010-10-23 19:56.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sat, 2010-10-23 19:00.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sat, 2010-10-23 18:04.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sat, 2010-10-23 17:08.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sat, 2010-10-23 16:12.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sat, 2010-10-23 15:16.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sat, 2010-10-23 14:20.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sat, 2010-10-23 13:24.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sat, 2010-10-23 12:28.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sat, 2010-10-23 11:32.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sat, 2010-10-23 10:36.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sat, 2010-10-23 09:40.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sat, 2010-10-23 08:44.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sat, 2010-10-23 07:52.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sat, 2010-10-23 06:56.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sat, 2010-10-23 06:00.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sat, 2010-10-23 05:04.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sat, 2010-10-23 04:08.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sat, 2010-10-23 03:20.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sat, 2010-10-23 02:28.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sat, 2010-10-23 01:40.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Sat, 2010-10-23 00:48.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Fri, 2010-10-22 23:56.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Fri, 2010-10-22 23:08.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

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

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

Submitted by peter on Fri, 2010-10-22 21:28.

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

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

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments

How to add a vector<MyType> to my typekit?

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

On Friday 22 October 2010 15:26:55 Tinne De Laet wrote:
> Hi all,
>
> In 1.10 we were able to create vectors of our own types. To this end
> Ruben and me wrote StdVectorTemplateTypeComposition.
> How should we handle the vector<MyTypes> in 2.x?

By using SequenceTypeInfo< vector<MyTypes> >("MyTypes")

This will give you size/capacity/[] access to your type. You won't have
constructors or operators.

It's a mistake that the constructors are not present, since we could have
added them in the constructor of SequenceTypeInfo itself. The accessor
functions for these constructors are defined in SequenceConstructor.hpp

For 2.1, you'll need to add in your typekit:

#include <rtt/types/SequenceConstructor.hpp>
#include <rtt/types/TemplateConstructor.hpp>
 
// ...
 
        ti->type("mytypes")->addConstructor( new SequenceBuilder<MyTypes>() );
        // fixed number of args:
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor<MyTypes>() ) );
        ti->type("mytypes")->addConstructor( newConstructor( 
sequence_ctor2<MyTypes>() ) );

It should no longer be necessary to add these in 2.2.

Peter

»

Login or register to post comments