Defining a type owning a std::vector<double> in orocos-toolchain

Hi all,

I am trying to define a structure Foo, containing a std::vector<double> :

class Foo {
public:
int i;
double d;
char c;
std::string s;
float f;
std::vector<double> v;
};

I have defined its serialisation function, using for its 'v' attribute
either:
ar & make_nvp("v", foo.v);
or:
ar & make_array<double>(foo.v.data(), foo.v.size()));

The first case does not compile (std::vector<double> has no member named
serialize).
The second one compiles but 'v' type is unknown in scripting :

In Task HelloWorld[S]
(type 'ls' for context info) :foo.v
Got :foo.v
= (unknown_t)

How could I link the 'v' type (std::vector<double>) to the corresponding
scripting type (array)?

Thanks,

Charles.

PS: In case someone answers typegen is the solution, I do not want to
use it ;) Actually, this code correspond to a test case for the Yarp
transport!

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

Hi all,

I am trying to define a structure Foo, containing a std::vector<double> :

class Foo {
public:
int i;
double d;
char c;
std::string s;
float f;
std::vector<double> v;
};

I have defined its serialisation function, using for its 'v' attribute
either:
ar & make_nvp("v", foo.v);
or:
ar & make_array<double>(foo.v.data(), foo.v.size()));

The first case does not compile (std::vector<double> has no member named
serialize).
The second one compiles but 'v' type is unknown in scripting :

In Task HelloWorld[S]
(type 'ls' for context info) :foo.v
Got :foo.v
= (unknown_t)

How could I link the 'v' type (std::vector<double>) to the corresponding
scripting type (array)?

Thanks,

Charles.

PS: In case someone answers typegen is the solution, I do not want to
use it ;) Actually, this code correspond to a test case for the Yarp
transport!

Defining a type owning a std::vector<double> in orocos-toolchain

Hi all,

I am trying to define a structure Foo, containing a std::vector<double> :

class Foo {
public:
int i;
double d;
char c;
std::string s;
float f;
std::vector<double> v;
};

I have defined its serialisation function, using for its 'v' attribute
either:
ar & make_nvp("v", foo.v);
or:
ar & make_array<double>(foo.v.data(), foo.v.size()));

The first case does not compile (std::vector<double> has no member named
serialize).
The second one compiles but 'v' type is unknown in scripting :

In Task HelloWorld[S]
(type 'ls' for context info) :foo.v
Got :foo.v
= (unknown_t)

How could I link the 'v' type (std::vector<double>) to the corresponding
scripting type (array)?

Thanks,

Charles.

PS: In case someone answers typegen is the solution, I do not want to
use it ;) Actually, this code correspond to a test case for the Yarp
transport!

Defining a type owning a std::vector<double> in orocos-toolchain

Hi all,

I am trying to define a structure Foo, containing a std::vector<double> :

class Foo {
public:
int i;
double d;
char c;
std::string s;
float f;
std::vector<double> v;
};

I have defined its serialisation function, using for its 'v' attribute
either:
ar & make_nvp("v", foo.v);
or:
ar & make_array<double>(foo.v.data(), foo.v.size()));

The first case does not compile (std::vector<double> has no member named
serialize).
The second one compiles but 'v' type is unknown in scripting :

In Task HelloWorld[S]
(type 'ls' for context info) :foo.v
Got :foo.v
= (unknown_t)

How could I link the 'v' type (std::vector<double>) to the corresponding
scripting type (array)?

Thanks,

Charles.

PS: In case someone answers typegen is the solution, I do not want to
use it ;) Actually, this code correspond to a test case for the Yarp
transport!

Defining a type owning a std::vector<double> in orocos-toolchain

Hi all,

I am trying to define a structure Foo, containing a std::vector<double> :

class Foo {
public:
int i;
double d;
char c;
std::string s;
float f;
std::vector<double> v;
};

I have defined its serialisation function, using for its 'v' attribute
either:
ar & make_nvp("v", foo.v);
or:
ar & make_array<double>(foo.v.data(), foo.v.size()));

The first case does not compile (std::vector<double> has no member named
serialize).
The second one compiles but 'v' type is unknown in scripting :

In Task HelloWorld[S]
(type 'ls' for context info) :foo.v
Got :foo.v
= (unknown_t)

How could I link the 'v' type (std::vector<double>) to the corresponding
scripting type (array)?

Thanks,

Charles.

PS: In case someone answers typegen is the solution, I do not want to
use it ;) Actually, this code correspond to a test case for the Yarp
transport!

Defining a type owning a std::vector<double> in orocos-toolchain

Hi all,

I am trying to define a structure Foo, containing a std::vector<double> :

class Foo {
public:
int i;
double d;
char c;
std::string s;
float f;
std::vector<double> v;
};

I have defined its serialisation function, using for its 'v' attribute
either:
ar & make_nvp("v", foo.v);
or:
ar & make_array<double>(foo.v.data(), foo.v.size()));

The first case does not compile (std::vector<double> has no member named
serialize).
The second one compiles but 'v' type is unknown in scripting :

In Task HelloWorld[S]
(type 'ls' for context info) :foo.v
Got :foo.v
= (unknown_t)

How could I link the 'v' type (std::vector<double>) to the corresponding
scripting type (array)?

Thanks,

Charles.

PS: In case someone answers typegen is the solution, I do not want to
use it ;) Actually, this code correspond to a test case for the Yarp
transport!

Defining a type owning a std::vector<double> in orocos-toolchain

Hi all,

I am trying to define a structure Foo, containing a std::vector<double> :

class Foo {
public:
int i;
double d;
char c;
std::string s;
float f;
std::vector<double> v;
};

I have defined its serialisation function, using for its 'v' attribute
either:
ar & make_nvp("v", foo.v);
or:
ar & make_array<double>(foo.v.data(), foo.v.size()));

The first case does not compile (std::vector<double> has no member named
serialize).
The second one compiles but 'v' type is unknown in scripting :

In Task HelloWorld[S]
(type 'ls' for context info) :foo.v
Got :foo.v
= (unknown_t)

How could I link the 'v' type (std::vector<double>) to the corresponding
scripting type (array)?

Thanks,

Charles.

PS: In case someone answers typegen is the solution, I do not want to
use it ;) Actually, this code correspond to a test case for the Yarp
transport!

Defining a type owning a std::vector<double> in orocos-toolchain

Hi all,

I am trying to define a structure Foo, containing a std::vector<double> :

class Foo {
public:
int i;
double d;
char c;
std::string s;
float f;
std::vector<double> v;
};

I have defined its serialisation function, using for its 'v' attribute
either:
ar & make_nvp("v", foo.v);
or:
ar & make_array<double>(foo.v.data(), foo.v.size()));

The first case does not compile (std::vector<double> has no member named
serialize).
The second one compiles but 'v' type is unknown in scripting :

In Task HelloWorld[S]
(type 'ls' for context info) :foo.v
Got :foo.v
= (unknown_t)

How could I link the 'v' type (std::vector<double>) to the corresponding
scripting type (array)?

Thanks,

Charles.

PS: In case someone answers typegen is the solution, I do not want to
use it ;) Actually, this code correspond to a test case for the Yarp
transport!

Defining a type owning a std::vector<double> in orocos-toolchain

Hi all,

I am trying to define a structure Foo, containing a std::vector<double> :

class Foo {
public:
int i;
double d;
char c;
std::string s;
float f;
std::vector<double> v;
};

I have defined its serialisation function, using for its 'v' attribute
either:
ar & make_nvp("v", foo.v);
or:
ar & make_array<double>(foo.v.data(), foo.v.size()));

The first case does not compile (std::vector<double> has no member named
serialize).
The second one compiles but 'v' type is unknown in scripting :

In Task HelloWorld[S]
(type 'ls' for context info) :foo.v
Got :foo.v
= (unknown_t)

How could I link the 'v' type (std::vector<double>) to the corresponding
scripting type (array)?

Thanks,

Charles.

PS: In case someone answers typegen is the solution, I do not want to
use it ;) Actually, this code correspond to a test case for the Yarp
transport!

Defining a type owning a std::vector<double> in orocos-toolchain

Hi all,

I am trying to define a structure Foo, containing a std::vector<double> :

class Foo {
public:
int i;
double d;
char c;
std::string s;
float f;
std::vector<double> v;
};

I have defined its serialisation function, using for its 'v' attribute
either:
ar & make_nvp("v", foo.v);
or:
ar & make_array<double>(foo.v.data(), foo.v.size()));

The first case does not compile (std::vector<double> has no member named
serialize).
The second one compiles but 'v' type is unknown in scripting :

In Task HelloWorld[S]
(type 'ls' for context info) :foo.v
Got :foo.v
= (unknown_t)

How could I link the 'v' type (std::vector<double>) to the corresponding
scripting type (array)?

Thanks,

Charles.

PS: In case someone answers typegen is the solution, I do not want to
use it ;) Actually, this code correspond to a test case for the Yarp
transport!

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

Hi all,

I am trying to define a structure Foo, containing a std::vector<double> :

class Foo {
public:
int i;
double d;
char c;
std::string s;
float f;
std::vector<double> v;
};

I have defined its serialisation function, using for its 'v' attribute
either:
ar & make_nvp("v", foo.v);
or:
ar & make_array<double>(foo.v.data(), foo.v.size()));

The first case does not compile (std::vector<double> has no member named
serialize).
The second one compiles but 'v' type is unknown in scripting :

In Task HelloWorld[S]
(type 'ls' for context info) :foo.v
Got :foo.v
= (unknown_t)

How could I link the 'v' type (std::vector<double>) to the corresponding
scripting type (array)?

Thanks,

Charles.

PS: In case someone answers typegen is the solution, I do not want to
use it ;) Actually, this code correspond to a test case for the Yarp
transport!

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

Hi all,

I am trying to define a structure Foo, containing a std::vector<double> :

class Foo {
public:
int i;
double d;
char c;
std::string s;
float f;
std::vector<double> v;
};

I have defined its serialisation function, using for its 'v' attribute
either:
ar & make_nvp("v", foo.v);
or:
ar & make_array<double>(foo.v.data(), foo.v.size()));

The first case does not compile (std::vector<double> has no member named
serialize).
The second one compiles but 'v' type is unknown in scripting :

In Task HelloWorld[S]
(type 'ls' for context info) :foo.v
Got :foo.v
= (unknown_t)

How could I link the 'v' type (std::vector<double>) to the corresponding
scripting type (array)?

Thanks,

Charles.

PS: In case someone answers typegen is the solution, I do not want to
use it ;) Actually, this code correspond to a test case for the Yarp
transport!

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

Hi all,

I am trying to define a structure Foo, containing a std::vector<double> :

class Foo {
public:
int i;
double d;
char c;
std::string s;
float f;
std::vector<double> v;
};

I have defined its serialisation function, using for its 'v' attribute
either:
ar & make_nvp("v", foo.v);
or:
ar & make_array<double>(foo.v.data(), foo.v.size()));

The first case does not compile (std::vector<double> has no member named
serialize).
The second one compiles but 'v' type is unknown in scripting :

In Task HelloWorld[S]
(type 'ls' for context info) :foo.v
Got :foo.v
= (unknown_t)

How could I link the 'v' type (std::vector<double>) to the corresponding
scripting type (array)?

Thanks,

Charles.

PS: In case someone answers typegen is the solution, I do not want to
use it ;) Actually, this code correspond to a test case for the Yarp
transport!

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

Hi all,

I am trying to define a structure Foo, containing a std::vector<double> :

class Foo {
public:
int i;
double d;
char c;
std::string s;
float f;
std::vector<double> v;
};

I have defined its serialisation function, using for its 'v' attribute
either:
ar & make_nvp("v", foo.v);
or:
ar & make_array<double>(foo.v.data(), foo.v.size()));

The first case does not compile (std::vector<double> has no member named
serialize).
The second one compiles but 'v' type is unknown in scripting :

In Task HelloWorld[S]
(type 'ls' for context info) :foo.v
Got :foo.v
= (unknown_t)

How could I link the 'v' type (std::vector<double>) to the corresponding
scripting type (array)?

Thanks,

Charles.

PS: In case someone answers typegen is the solution, I do not want to
use it ;) Actually, this code correspond to a test case for the Yarp
transport!

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

Hi all,

I am trying to define a structure Foo, containing a std::vector<double> :

class Foo {
public:
int i;
double d;
char c;
std::string s;
float f;
std::vector<double> v;
};

I have defined its serialisation function, using for its 'v' attribute
either:
ar & make_nvp("v", foo.v);
or:
ar & make_array<double>(foo.v.data(), foo.v.size()));

The first case does not compile (std::vector<double> has no member named
serialize).
The second one compiles but 'v' type is unknown in scripting :

In Task HelloWorld[S]
(type 'ls' for context info) :foo.v
Got :foo.v
= (unknown_t)

How could I link the 'v' type (std::vector<double>) to the corresponding
scripting type (array)?

Thanks,

Charles.

PS: In case someone answers typegen is the solution, I do not want to
use it ;) Actually, this code correspond to a test case for the Yarp
transport!

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter

Defining a type owning a std::vector<double> in orocos-toolchain

On Thursday 21 October 2010 08:48:15 Charles Lesire-Cabaniols wrote:
> Hi all,
>
> I am trying to define a structure Foo, containing a std::vector<double> :
>
> class Foo {
> public:
> int i;
> double d;
> char c;
> std::string s;
> float f;
> std::vector<double> v;
> };
>
> I have defined its serialisation function, using for its 'v' attribute
> either:
> ar & make_nvp("v", foo.v);
> or:
> ar & make_array<double>(foo.v.data(), foo.v.size()));
>
> The first case does not compile (std::vector<double> has no member named
> serialize).

You'll need to include the header:

#include <boost/serialization/vector.hpp>

And it will work fine. It defines the serialize() function for std::vector. Do
likewise for other STL types.

Peter