[med-svn] [camp] 04/04: Support new upstream version, c++11, and fix some EOL
Corentin Desfarges
corentin-guest at moszumanska.debian.org
Tue Jan 12 11:28:21 UTC 2016
This is an automated email from the git hooks/post-receive script.
corentin-guest pushed a commit to branch master
in repository camp.
commit ccd4e8f90fdcf5ee12d721893de47217260b4795
Author: Corentin Desfarges <corentin.desfarges.dev at gmail.com>
Date: Tue Jan 12 12:25:01 2016 +0100
Support new upstream version, c++11, and fix some EOL
---
debian/changelog | 3 +
debian/patches/add_soname.patch | 2 +-
debian/patches/hide_boost_from_qt4moc.patch | 110 +--
debian/patches/orig_change.patch | 1199 +++++++++++++++++++++++++++
debian/patches/series | 2 +
debian/patches/support_c++11.patch | 38 +
debian/rules | 2 +
7 files changed, 1300 insertions(+), 56 deletions(-)
diff --git a/debian/changelog b/debian/changelog
index 519c20a..5fe41f0 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -2,6 +2,9 @@ camp (0.7.1.3-1) unstable; urgency=medium
* New upstream version
* Fix end of line issues
+ * Support of c++11
+
+ -- Corentin Desfarges <corentin.desfarges.dev at gmail.com> Tue, 12 Jan 2016 12:11:51 +0100
camp (0.7.1.1-2) unstable; urgency=medium
diff --git a/debian/patches/add_soname.patch b/debian/patches/add_soname.patch
index c53f3c5..0862cc9 100644
--- a/debian/patches/add_soname.patch
+++ b/debian/patches/add_soname.patch
@@ -6,7 +6,7 @@ Add no version
# define the export macro
if(BUILD_SHARED_LIBS)
- set_target_properties(camp PROPERTIES DEFINE_SYMBOL CAMP_EXPORTS)
-+ set_target_properties(camp PROPERTIES DEFINE_SYMBOL CAMP_EXPORTS SOVERSION 0.7 VERSION 0.7.1.1)
++ set_target_properties(camp PROPERTIES DEFINE_SYMBOL CAMP_EXPORTS SOVERSION 0.7 VERSION 0.7.1.3)
else()
add_definitions(-DCAMP_STATIC)
endif()
diff --git a/debian/patches/hide_boost_from_qt4moc.patch b/debian/patches/hide_boost_from_qt4moc.patch
index 81fba6d..2fca873 100644
--- a/debian/patches/hide_boost_from_qt4moc.patch
+++ b/debian/patches/hide_boost_from_qt4moc.patch
@@ -64,7 +64,7 @@ Author: Robert Bruce Park <robert.park at canonical.com>
+#ifndef Q_MOC_RUN
#include <boost/utility/enable_if.hpp>
+#endif
-
+ #include <type_traits>
namespace camp
--- camp.orig/include/camp/detail/objecttraits.hpp
@@ -533,20 +533,20 @@ Author: Robert Bruce Park <robert.park at canonical.com>
--- camp.orig/include/camp/class.hpp
+++ camp/include/camp/class.hpp
@@ -36,12 +36,14 @@
- #include <camp/userobject.hpp>
- #include <camp/detail/classmanager.hpp>
- #include <camp/detail/typeid.hpp>
-+#ifndef Q_MOC_RUN
- #include <boost/noncopyable.hpp>
- #include <boost/shared_ptr.hpp>
- #include <boost/multi_index_container.hpp>
- #include <boost/multi_index/mem_fun.hpp>
- #include <boost/multi_index/ordered_index.hpp>
- #include <boost/multi_index/random_access_index.hpp>
-+#endif
- #include <string>
-
-
+ #include <camp/userobject.hpp>
+ #include <camp/detail/classmanager.hpp>
+ #include <camp/detail/typeid.hpp>
++#ifndef Q_MOC_RUN
+ #include <boost/noncopyable.hpp>
+ //#include <boost/shared_ptr.hpp>
+ #include <boost/multi_index_container.hpp>
+ #include <boost/multi_index/mem_fun.hpp>
+ #include <boost/multi_index/ordered_index.hpp>
+ #include <boost/multi_index/random_access_index.hpp>
++#endif
+ #include <string>
+
+
--- camp.orig/include/camp/classbuilder.hpp
+++ camp/include/camp/classbuilder.hpp
@@ -31,9 +31,11 @@
@@ -576,49 +576,49 @@ Author: Robert Bruce Park <robert.park at canonical.com>
--- camp.orig/include/camp/enum.hpp
+++ camp/include/camp/enum.hpp
@@ -30,11 +30,13 @@
- #include <camp/enumget.hpp>
- #include <camp/detail/enummanager.hpp>
- #include <camp/detail/typeid.hpp>
-+#ifndef Q_MOC_RUN
- #include <boost/noncopyable.hpp>
- #include <boost/multi_index_container.hpp>
- #include <boost/multi_index/member.hpp>
- #include <boost/multi_index/ordered_index.hpp>
- #include <boost/multi_index/random_access_index.hpp>
-+#endif
- #include <string>
-
-
+ #include <camp/enumget.hpp>
+ #include <camp/detail/enummanager.hpp>
+ #include <camp/detail/typeid.hpp>
++#ifndef Q_MOC_RUN
+ #include <boost/noncopyable.hpp>
+ #include <boost/multi_index_container.hpp>
+ #include <boost/multi_index/member.hpp>
+ #include <boost/multi_index/ordered_index.hpp>
+ #include <boost/multi_index/random_access_index.hpp>
++#endif
+ #include <string>
+
+
--- camp.orig/include/camp/detail/enummanager.hpp
+++ camp/include/camp/detail/enummanager.hpp
@@ -27,11 +27,13 @@
-
- #include <camp/config.hpp>
- #include <camp/detail/observernotifier.hpp>
-+#ifndef Q_MOC_RUN
- #include <boost/noncopyable.hpp>
- #include <boost/shared_ptr.hpp>
- #include <boost/multi_index_container.hpp>
- #include <boost/multi_index/member.hpp>
- #include <boost/multi_index/ordered_index.hpp>
-+#endif
- #include <string>
-
-
+
+ #include <camp/config.hpp>
+ #include <camp/detail/observernotifier.hpp>
++#ifndef Q_MOC_RUN
+ #include <boost/noncopyable.hpp>
+ #include <boost/shared_ptr.hpp>
+ #include <boost/multi_index_container.hpp>
+ #include <boost/multi_index/member.hpp>
+ #include <boost/multi_index/ordered_index.hpp>
++#endif
+ #include <string>
+
+
--- camp.orig/include/camp/detail/classmanager.hpp
+++ camp/include/camp/detail/classmanager.hpp
@@ -27,12 +27,14 @@
-
- #include <camp/config.hpp>
- #include <camp/detail/observernotifier.hpp>
-+#ifndef Q_MOC_RUN
- #include <boost/noncopyable.hpp>
- #include <boost/shared_ptr.hpp>
- #include <boost/shared_ptr.hpp>
- #include <boost/multi_index_container.hpp>
- #include <boost/multi_index/member.hpp>
- #include <boost/multi_index/ordered_index.hpp>
-+#endif
- #include <string>
-
-
+
+ #include <camp/config.hpp>
+ #include <camp/detail/observernotifier.hpp>
++#ifndef Q_MOC_RUN
+ #include <boost/noncopyable.hpp>
+ #include <boost/shared_ptr.hpp>
+ #include <boost/shared_ptr.hpp>
+ #include <boost/multi_index_container.hpp>
+ #include <boost/multi_index/member.hpp>
+ #include <boost/multi_index/ordered_index.hpp>
++#endif
+ #include <string>
+
+
diff --git a/debian/patches/orig_change.patch b/debian/patches/orig_change.patch
new file mode 100644
index 0000000..fa333a2
--- /dev/null
+++ b/debian/patches/orig_change.patch
@@ -0,0 +1,1199 @@
+Description: <short summary of the patch>
+ TODO: Put a short summary on the line above and replace this paragraph
+ with a longer explanation of this change. Complete the meta-information
+ with other relevant fields (see below for details). To make it easier, the
+ information below has been extracted from the changelog. Adjust it or drop
+ it.
+ .
+ camp (0.7.1.3-1) unstable; urgency=medium
+ .
+ * New upstream version
+ * Fix end of line issues
+Author: Corentin Desfarges <corentin.desfarges.dev at gmail.com>
+
+---
+The information above should follow the Patch Tagging Guidelines, please
+checkout http://dep.debian.net/deps/dep3/ to learn about the format. Here
+are templates for supplementary fields that you might want to add:
+
+Origin: <vendor|upstream|other>, <url of original patch>
+Bug: <url in upstream bugtracker>
+Bug-Debian: https://bugs.debian.org/<bugnumber>
+Bug-Ubuntu: https://launchpad.net/bugs/<bugnumber>
+Forwarded: <no|not-needed|url proving that it has been forwarded>
+Reviewed-By: <name and email of someone who approved the patch>
+Last-Update: <YYYY-MM-DD>
+
+--- camp-0.7.1.3.orig/test/function.hpp
++++ camp-0.7.1.3/test/function.hpp
+@@ -1,177 +1,177 @@
+-/****************************************************************************
+-**
+-** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+-** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+-**
+-** This file is part of the CAMP library.
+-**
+-** CAMP is free software: you can redistribute it and/or modify
+-** it under the terms of the GNU Lesser General Public License as published by
+-** the Free Software Foundation, either version 3 of the License, or
+-** (at your option) any later version.
+-**
+-** CAMP is distributed in the hope that it will be useful,
+-** but WITHOUT ANY WARRANTY; without even the implied warranty of
+-** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+-** GNU Lesser General Public License for more details.
+-**
+-** You should have received a copy of the GNU Lesser General Public License
+-** along with CAMP. If not, see <http://www.gnu.org/licenses/>.
+-**
+-****************************************************************************/
+-
+-#ifndef CAMPTEST_FUNCTION_HPP
+-#define CAMPTEST_FUNCTION_HPP
+-
+-#include <camp/camptype.hpp>
+-#include <camp/enum.hpp>
+-#include <camp/class.hpp>
+-#include <camp/value.hpp>
+-#include <boost/shared_ptr.hpp>
+-#include <string>
+-
+-namespace FunctionTest
+-{
+- enum MyEnum
+- {
+- Zero = 0,
+- One = 1,
+- Two = 2
+- };
+-
+- struct MyType
+- {
+- MyType(int x_) : x(x_) {}
+- int x;
+- };
+-
+- bool operator==(const MyType& left, const MyType& right) {return left.x == right.x;}
+- bool operator<(const MyType& left, const MyType& right) {return left.x < right.x;}
+- std::ostream& operator<<(std::ostream& stream, const MyType& object) {return stream << object.x;}
+-
+- struct MyBase
+- {
+- void f6() {}
+- char padding[10];
+- };
+-
+- struct MyClass : MyBase
+- {
+- MyClass()
+- : p1(true)
+- , p2(2)
+- , p3("3")
+- , p4(MyType(4))
+- , p5(MyType(5))
+- , innerPtr(&inner)
+- , innerSmartPtr(new Inner)
+- {
+- }
+-
+- bool p1;
+- int p2;
+- std::string p3;
+-
+- MyType p4; const MyType& f4() {return p4;}
+- MyType p5; const MyType& f5() const {return p5;}
+- // f6 is inherited
+- camp::Value f7(camp::Value v) {return v;}
+-
+- void f8() {}
+- void f9(bool) {}
+- void f10(float, double) {}
+- void f11(short, int, long) {}
+- void f12(const std::string&, std::string, const std::string&, std::string) {}
+- void f13(MyEnum, MyEnum, MyEnum, MyEnum, MyEnum) {}
+-
+- struct Inner
+- {
+- void f14() {}
+- void f15() const {}
+- int f16() {return 16;}
+- void f17(int) {}
+- void f18() {}
+- void f19() {}
+- };
+- Inner inner;
+- const Inner& getInner() const {return inner;}
+- Inner* innerPtr;
+- const Inner* getInnerPtr() const {return innerPtr;}
+- boost::shared_ptr<Inner> innerSmartPtr;
+- const boost::shared_ptr<Inner> getInnerSmartPtr() {return innerSmartPtr;}
+-
+- int f20(int x) {return x;}
+- int f21(int x, int y) {return x + y;}
+- int f22(int x, int y, int z) {return x + y + z;}
+- };
+-
+- void f1(MyClass& object)
+- {
+- object.p1 = true;
+- }
+-
+- int f2(MyClass object, int x)
+- {
+- return object.p2 + x;
+- }
+-
+- const std::string& f3(const MyClass* object)
+- {
+- return object->p3;
+- }
+-
+- void declare()
+- {
+- camp::Enum::declare<MyEnum>("FunctionTest::MyEnum")
+- .value("Zero", Zero)
+- .value("One", One)
+- .value("Two", Two);
+-
+- camp::Class::declare<MyType>("FunctionTest::MyType");
+-
+- camp::Class::declare<MyBase>("FunctionTest::MyBase");
+-
+- camp::Class::declare<MyClass>("FunctionTest::MyClass")
+- .base<MyBase>()
+-
+- // ***** non-member functions *****
+- .function("f1", &f1) // object by reference
+- .function("f2", &f2) // object by value + parameter
+- .function("f3", &f3) // object by pointer
+-
+- // ***** member functions *****
+- .function("f4", &MyClass::f4) // non-const
+- .function("f5", &MyClass::f5) // const
+- .function("f6", &MyClass::f6) // inherited
+- .function("f7", &MyClass::f7) // camp::Value as return and argument types
+-
+- // ***** arguments count ******
+- .function("f8", &MyClass::f8) // 0 argument
+- .function("f9", &MyClass::f9) // 1 argument
+- .function("f10", &MyClass::f10) // 2 arguments
+- .function("f11", &MyClass::f11) // 3 arguments
+- .function("f12", &MyClass::f12) // 4 arguments
+- .function("f13", &MyClass::f13) // 5 arguments
+-
+- // ***** nested functions *****
+- // TOFIX .function("f14", &MyClass::Inner::f14, &MyClass::inner) // object
+- .function("f15", &MyClass::Inner::f15, &MyClass::getInner) // getter returning an object
+- .function("f16", &MyClass::Inner::f16, &MyClass::innerPtr) // raw pointer
+- // TOFIX .function("f17", &MyClass::Inner::f17, &MyClass::getInnerPtr) // getter returning a raw pointer
+- .function("f18", &MyClass::Inner::f18, &MyClass::innerSmartPtr) // smart pointer
+- .function("f19", &MyClass::Inner::f19, &MyClass::getInnerSmartPtr) // getter returning a smart pointer
+-
+- // ***** boost::function *****
+- .function("f20", boost::function<int (MyClass&, int)>(boost::bind(&MyClass::f20, _1, _2)))
+- .function("f21", boost::function<int (MyClass&, int)>(boost::bind(&MyClass::f21, _1, _2, 20)))
+- .function("f22", boost::function<int (MyClass&, int)>(boost::bind(boost::bind(&MyClass::f22, _1, _2, _3, 30), _1, _2, 20)))
+- ;
+- }
+-}
+-
+-CAMP_AUTO_TYPE(FunctionTest::MyEnum, &FunctionTest::declare)
+-CAMP_AUTO_TYPE(FunctionTest::MyType, &FunctionTest::declare)
+-CAMP_AUTO_TYPE(FunctionTest::MyClass, &FunctionTest::declare)
+-CAMP_AUTO_TYPE(FunctionTest::MyBase, &FunctionTest::declare)
+-
+-#endif // CAMPTEST_FUNCTION_HPP
++/****************************************************************************
++**
++** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
++** Contact: Technogerma Systems France Information (contact at technogerma.fr)
++**
++** This file is part of the CAMP library.
++**
++** CAMP is free software: you can redistribute it and/or modify
++** it under the terms of the GNU Lesser General Public License as published by
++** the Free Software Foundation, either version 3 of the License, or
++** (at your option) any later version.
++**
++** CAMP is distributed in the hope that it will be useful,
++** but WITHOUT ANY WARRANTY; without even the implied warranty of
++** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++** GNU Lesser General Public License for more details.
++**
++** You should have received a copy of the GNU Lesser General Public License
++** along with CAMP. If not, see <http://www.gnu.org/licenses/>.
++**
++****************************************************************************/
++
++#ifndef CAMPTEST_FUNCTION_HPP
++#define CAMPTEST_FUNCTION_HPP
++
++#include <camp/camptype.hpp>
++#include <camp/enum.hpp>
++#include <camp/class.hpp>
++#include <camp/value.hpp>
++#include <boost/shared_ptr.hpp>
++#include <string>
++
++namespace FunctionTest
++{
++ enum MyEnum
++ {
++ Zero = 0,
++ One = 1,
++ Two = 2
++ };
++
++ struct MyType
++ {
++ MyType(int x_) : x(x_) {}
++ int x;
++ };
++
++ bool operator==(const MyType& left, const MyType& right) {return left.x == right.x;}
++ bool operator<(const MyType& left, const MyType& right) {return left.x < right.x;}
++ std::ostream& operator<<(std::ostream& stream, const MyType& object) {return stream << object.x;}
++
++ struct MyBase
++ {
++ void f6() {}
++ char padding[10];
++ };
++
++ struct MyClass : MyBase
++ {
++ MyClass()
++ : p1(true)
++ , p2(2)
++ , p3("3")
++ , p4(MyType(4))
++ , p5(MyType(5))
++ , innerPtr(&inner)
++ , innerSmartPtr(new Inner)
++ {
++ }
++
++ bool p1;
++ int p2;
++ std::string p3;
++
++ MyType p4; const MyType& f4() {return p4;}
++ MyType p5; const MyType& f5() const {return p5;}
++ // f6 is inherited
++ camp::Value f7(camp::Value v) {return v;}
++
++ void f8() {}
++ void f9(bool) {}
++ void f10(float, double) {}
++ void f11(short, int, long) {}
++ void f12(const std::string&, std::string, const std::string&, std::string) {}
++ void f13(MyEnum, MyEnum, MyEnum, MyEnum, MyEnum) {}
++
++ struct Inner
++ {
++ void f14() {}
++ void f15() const {}
++ int f16() {return 16;}
++ void f17(int) {}
++ void f18() {}
++ void f19() {}
++ };
++ Inner inner;
++ const Inner& getInner() const {return inner;}
++ Inner* innerPtr;
++ const Inner* getInnerPtr() const {return innerPtr;}
++ boost::shared_ptr<Inner> innerSmartPtr;
++ const boost::shared_ptr<Inner> getInnerSmartPtr() {return innerSmartPtr;}
++
++ int f20(int x) {return x;}
++ int f21(int x, int y) {return x + y;}
++ int f22(int x, int y, int z) {return x + y + z;}
++ };
++
++ void f1(MyClass& object)
++ {
++ object.p1 = true;
++ }
++
++ int f2(MyClass object, int x)
++ {
++ return object.p2 + x;
++ }
++
++ const std::string& f3(const MyClass* object)
++ {
++ return object->p3;
++ }
++
++ void declare()
++ {
++ camp::Enum::declare<MyEnum>("FunctionTest::MyEnum")
++ .value("Zero", Zero)
++ .value("One", One)
++ .value("Two", Two);
++
++ camp::Class::declare<MyType>("FunctionTest::MyType");
++
++ camp::Class::declare<MyBase>("FunctionTest::MyBase");
++
++ camp::Class::declare<MyClass>("FunctionTest::MyClass")
++ .base<MyBase>()
++
++ // ***** non-member functions *****
++ .function("f1", &f1) // object by reference
++ .function("f2", &f2) // object by value + parameter
++ .function("f3", &f3) // object by pointer
++
++ // ***** member functions *****
++ .function("f4", &MyClass::f4) // non-const
++ .function("f5", &MyClass::f5) // const
++ .function("f6", &MyClass::f6) // inherited
++ .function("f7", &MyClass::f7) // camp::Value as return and argument types
++
++ // ***** arguments count ******
++ .function("f8", &MyClass::f8) // 0 argument
++ .function("f9", &MyClass::f9) // 1 argument
++ .function("f10", &MyClass::f10) // 2 arguments
++ .function("f11", &MyClass::f11) // 3 arguments
++ .function("f12", &MyClass::f12) // 4 arguments
++ .function("f13", &MyClass::f13) // 5 arguments
++
++ // ***** nested functions *****
++ // TOFIX .function("f14", &MyClass::Inner::f14, &MyClass::inner) // object
++ .function("f15", &MyClass::Inner::f15, &MyClass::getInner) // getter returning an object
++ .function("f16", &MyClass::Inner::f16, &MyClass::innerPtr) // raw pointer
++ // TOFIX .function("f17", &MyClass::Inner::f17, &MyClass::getInnerPtr) // getter returning a raw pointer
++ .function("f18", &MyClass::Inner::f18, &MyClass::innerSmartPtr) // smart pointer
++ .function("f19", &MyClass::Inner::f19, &MyClass::getInnerSmartPtr) // getter returning a smart pointer
++
++ // ***** boost::function *****
++ .function("f20", boost::function<int (MyClass&, int)>(boost::bind(&MyClass::f20, _1, _2)))
++ .function("f21", boost::function<int (MyClass&, int)>(boost::bind(&MyClass::f21, _1, _2, 20)))
++ .function("f22", boost::function<int (MyClass&, int)>(boost::bind(boost::bind(&MyClass::f22, _1, _2, _3, 30), _1, _2, 20)))
++ ;
++ }
++}
++
++CAMP_AUTO_TYPE(FunctionTest::MyEnum, &FunctionTest::declare)
++CAMP_AUTO_TYPE(FunctionTest::MyType, &FunctionTest::declare)
++CAMP_AUTO_TYPE(FunctionTest::MyClass, &FunctionTest::declare)
++CAMP_AUTO_TYPE(FunctionTest::MyBase, &FunctionTest::declare)
++
++#endif // CAMPTEST_FUNCTION_HPP
+--- camp-0.7.1.3.orig/test/functionaccess.hpp
++++ camp-0.7.1.3/test/functionaccess.hpp
+@@ -1,65 +1,65 @@
+-/****************************************************************************
+-**
+-** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+-** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+-**
+-** This file is part of the CAMP library.
+-**
+-** CAMP is free software: you can redistribute it and/or modify
+-** it under the terms of the GNU Lesser General Public License as published by
+-** the Free Software Foundation, either version 3 of the License, or
+-** (at your option) any later version.
+-**
+-** CAMP is distributed in the hope that it will be useful,
+-** but WITHOUT ANY WARRANTY; without even the implied warranty of
+-** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+-** GNU Lesser General Public License for more details.
+-**
+-** You should have received a copy of the GNU Lesser General Public License
+-** along with CAMP. If not, see <http://www.gnu.org/licenses/>.
+-**
+-****************************************************************************/
+-
+-#ifndef CAMPTEST_FUNCTIONACCESS_HPP
+-#define CAMPTEST_FUNCTIONACCESS_HPP
+-
+-#include <camp/camptype.hpp>
+-#include <camp/class.hpp>
+-
+-namespace FunctionAccessTest
+-{
+- struct MyClass
+- {
+- MyClass(bool b = true)
+- : m_b(b)
+- {
+- }
+-
+- void f() {}
+-
+- bool m_b;
+- bool b1() {return true;}
+- bool b2() const {return false;}
+- };
+-
+- void declare()
+- {
+- camp::Class::declare<MyClass>("FunctionAccessTest::MyClass")
+-
+- // ***** constant value *****
+- .function("f0", &MyClass::f).callable(false)
+- .function("f1", &MyClass::f).callable(true)
+-
+- // ***** function *****
+- .function("f2", &MyClass::f).callable(&MyClass::b1)
+- .function("f3", &MyClass::f).callable(&MyClass::b2)
+- .function("f4", &MyClass::f).callable(boost::bind(&MyClass::b1, _1))
+- .function("f5", &MyClass::f).callable(&MyClass::m_b)
+- .function("f6", &MyClass::f).callable(boost::function<bool (MyClass&)>(&MyClass::m_b))
+- ;
+- }
+-}
+-
+-CAMP_AUTO_TYPE(FunctionAccessTest::MyClass, &FunctionAccessTest::declare);
+-
+-#endif // CAMPTEST_FUNCTIONACCESS_HPP
++/****************************************************************************
++**
++** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
++** Contact: Technogerma Systems France Information (contact at technogerma.fr)
++**
++** This file is part of the CAMP library.
++**
++** CAMP is free software: you can redistribute it and/or modify
++** it under the terms of the GNU Lesser General Public License as published by
++** the Free Software Foundation, either version 3 of the License, or
++** (at your option) any later version.
++**
++** CAMP is distributed in the hope that it will be useful,
++** but WITHOUT ANY WARRANTY; without even the implied warranty of
++** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++** GNU Lesser General Public License for more details.
++**
++** You should have received a copy of the GNU Lesser General Public License
++** along with CAMP. If not, see <http://www.gnu.org/licenses/>.
++**
++****************************************************************************/
++
++#ifndef CAMPTEST_FUNCTIONACCESS_HPP
++#define CAMPTEST_FUNCTIONACCESS_HPP
++
++#include <camp/camptype.hpp>
++#include <camp/class.hpp>
++
++namespace FunctionAccessTest
++{
++ struct MyClass
++ {
++ MyClass(bool b = true)
++ : m_b(b)
++ {
++ }
++
++ void f() {}
++
++ bool m_b;
++ bool b1() {return true;}
++ bool b2() const {return false;}
++ };
++
++ void declare()
++ {
++ camp::Class::declare<MyClass>("FunctionAccessTest::MyClass")
++
++ // ***** constant value *****
++ .function("f0", &MyClass::f).callable(false)
++ .function("f1", &MyClass::f).callable(true)
++
++ // ***** function *****
++ .function("f2", &MyClass::f).callable(&MyClass::b1)
++ .function("f3", &MyClass::f).callable(&MyClass::b2)
++ .function("f4", &MyClass::f).callable(boost::bind(&MyClass::b1, _1))
++ .function("f5", &MyClass::f).callable(&MyClass::m_b)
++ .function("f6", &MyClass::f).callable(boost::function<bool (MyClass&)>(&MyClass::m_b))
++ ;
++ }
++}
++
++CAMP_AUTO_TYPE(FunctionAccessTest::MyClass, &FunctionAccessTest::declare);
++
++#endif // CAMPTEST_FUNCTIONACCESS_HPP
+--- camp-0.7.1.3.orig/test/inheritance.hpp
++++ camp-0.7.1.3/test/inheritance.hpp
+@@ -1,115 +1,115 @@
+-/****************************************************************************
+-**
+-** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+-** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+-**
+-** This file is part of the CAMP library.
+-**
+-** CAMP is free software: you can redistribute it and/or modify
+-** it under the terms of the GNU Lesser General Public License as published by
+-** the Free Software Foundation, either version 3 of the License, or
+-** (at your option) any later version.
+-**
+-** CAMP is distributed in the hope that it will be useful,
+-** but WITHOUT ANY WARRANTY; without even the implied warranty of
+-** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+-** GNU Lesser General Public License for more details.
+-**
+-** You should have received a copy of the GNU Lesser General Public License
+-** along with CAMP. If not, see <http://www.gnu.org/licenses/>.
+-**
+-****************************************************************************/
+-
+-#ifndef CAMPTEST_INHERITANCE_HPP
+-#define CAMPTEST_INHERITANCE_HPP
+-
+-#include <camp/camptype.hpp>
+-#include <camp/class.hpp>
+-
+-namespace InheritanceTest
+-{
+- struct MyClass1
+- {
+- MyClass1() : p1(10), po1(10) {}
+- virtual ~MyClass1() {}
+- int p1;
+- int f1() const {return 1;}
+- int po1;
+- int fo1() {return 1;}
+- CAMP_RTTI();
+- };
+-
+- struct MyClass2
+- {
+- MyClass2() : p2(20), po2(20) {}
+- virtual ~MyClass2() {}
+- int p2;
+- int f2() const {return 2;}
+- virtual int fv() const {return p2;}
+- int po2;
+- int fo2() {return 2;}
+- CAMP_RTTI();
+- };
+-
+- struct MyClass3 : public MyClass1, public MyClass2
+- {
+- MyClass3() : p3(30), po3(30) {}
+- virtual ~MyClass3() {}
+- int p3;
+- int f3() const {return 3;}
+- virtual int fv() const {return p3;}
+- int po3;
+- int fo3() {return 3;}
+- CAMP_RTTI();
+- };
+-
+- struct MyClass4 : public MyClass3
+- {
+- MyClass4() : p4(40), po4(40) {}
+- virtual ~MyClass4() {}
+- int p4;
+- int f4() const {return 4;}
+- virtual int fv() const {return p4;}
+- int po4;
+- int fo4() {return 4;}
+- CAMP_RTTI();
+- };
+-
+- void declare()
+- {
+- camp::Class::declare<MyClass1>("InheritanceTest::MyClass1")
+- .function("f1", &MyClass1::f1)
+- .property("p1", &MyClass1::p1)
+- .function("overridden", &MyClass1::fo1)
+- .property("overridden", &MyClass1::po1);
+-
+- camp::Class::declare<MyClass2>("InheritanceTest::MyClass2")
+- .function("f2", &MyClass2::f2)
+- .property("p2", &MyClass2::p2)
+- .function("virtual", &MyClass2::fv)
+- .function("overridden", &MyClass2::fo2)
+- .property("overridden", &MyClass2::po2);
+-
+- camp::Class::declare<MyClass3>("InheritanceTest::MyClass3")
+- .base<MyClass1>()
+- .base<MyClass2>()
+- .function("f3", &MyClass3::f3)
+- .property("p3", &MyClass3::p3)
+- .function("overridden", &MyClass3::fo3)
+- .property("overridden", &MyClass3::po3);
+-
+- camp::Class::declare<MyClass4>("InheritanceTest::MyClass4")
+- .base<MyClass3>()
+- .function("f4", &MyClass4::f4)
+- .property("p4", &MyClass4::p4)
+- .function("overridden", &MyClass4::fo4)
+- .property("overridden", &MyClass4::po4);
+- }
+-}
+-
+-CAMP_AUTO_TYPE(InheritanceTest::MyClass1, &InheritanceTest::declare)
+-CAMP_AUTO_TYPE(InheritanceTest::MyClass2, &InheritanceTest::declare)
+-CAMP_AUTO_TYPE(InheritanceTest::MyClass3, &InheritanceTest::declare)
+-CAMP_AUTO_TYPE(InheritanceTest::MyClass4, &InheritanceTest::declare)
+-
+-#endif // CAMPTEST_INHERITANCE_HPP
++/****************************************************************************
++**
++** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
++** Contact: Technogerma Systems France Information (contact at technogerma.fr)
++**
++** This file is part of the CAMP library.
++**
++** CAMP is free software: you can redistribute it and/or modify
++** it under the terms of the GNU Lesser General Public License as published by
++** the Free Software Foundation, either version 3 of the License, or
++** (at your option) any later version.
++**
++** CAMP is distributed in the hope that it will be useful,
++** but WITHOUT ANY WARRANTY; without even the implied warranty of
++** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++** GNU Lesser General Public License for more details.
++**
++** You should have received a copy of the GNU Lesser General Public License
++** along with CAMP. If not, see <http://www.gnu.org/licenses/>.
++**
++****************************************************************************/
++
++#ifndef CAMPTEST_INHERITANCE_HPP
++#define CAMPTEST_INHERITANCE_HPP
++
++#include <camp/camptype.hpp>
++#include <camp/class.hpp>
++
++namespace InheritanceTest
++{
++ struct MyClass1
++ {
++ MyClass1() : p1(10), po1(10) {}
++ virtual ~MyClass1() {}
++ int p1;
++ int f1() const {return 1;}
++ int po1;
++ int fo1() {return 1;}
++ CAMP_RTTI();
++ };
++
++ struct MyClass2
++ {
++ MyClass2() : p2(20), po2(20) {}
++ virtual ~MyClass2() {}
++ int p2;
++ int f2() const {return 2;}
++ virtual int fv() const {return p2;}
++ int po2;
++ int fo2() {return 2;}
++ CAMP_RTTI();
++ };
++
++ struct MyClass3 : public MyClass1, public MyClass2
++ {
++ MyClass3() : p3(30), po3(30) {}
++ virtual ~MyClass3() {}
++ int p3;
++ int f3() const {return 3;}
++ virtual int fv() const {return p3;}
++ int po3;
++ int fo3() {return 3;}
++ CAMP_RTTI();
++ };
++
++ struct MyClass4 : public MyClass3
++ {
++ MyClass4() : p4(40), po4(40) {}
++ virtual ~MyClass4() {}
++ int p4;
++ int f4() const {return 4;}
++ virtual int fv() const {return p4;}
++ int po4;
++ int fo4() {return 4;}
++ CAMP_RTTI();
++ };
++
++ void declare()
++ {
++ camp::Class::declare<MyClass1>("InheritanceTest::MyClass1")
++ .function("f1", &MyClass1::f1)
++ .property("p1", &MyClass1::p1)
++ .function("overridden", &MyClass1::fo1)
++ .property("overridden", &MyClass1::po1);
++
++ camp::Class::declare<MyClass2>("InheritanceTest::MyClass2")
++ .function("f2", &MyClass2::f2)
++ .property("p2", &MyClass2::p2)
++ .function("virtual", &MyClass2::fv)
++ .function("overridden", &MyClass2::fo2)
++ .property("overridden", &MyClass2::po2);
++
++ camp::Class::declare<MyClass3>("InheritanceTest::MyClass3")
++ .base<MyClass1>()
++ .base<MyClass2>()
++ .function("f3", &MyClass3::f3)
++ .property("p3", &MyClass3::p3)
++ .function("overridden", &MyClass3::fo3)
++ .property("overridden", &MyClass3::po3);
++
++ camp::Class::declare<MyClass4>("InheritanceTest::MyClass4")
++ .base<MyClass3>()
++ .function("f4", &MyClass4::f4)
++ .property("p4", &MyClass4::p4)
++ .function("overridden", &MyClass4::fo4)
++ .property("overridden", &MyClass4::po4);
++ }
++}
++
++CAMP_AUTO_TYPE(InheritanceTest::MyClass1, &InheritanceTest::declare)
++CAMP_AUTO_TYPE(InheritanceTest::MyClass2, &InheritanceTest::declare)
++CAMP_AUTO_TYPE(InheritanceTest::MyClass3, &InheritanceTest::declare)
++CAMP_AUTO_TYPE(InheritanceTest::MyClass4, &InheritanceTest::declare)
++
++#endif // CAMPTEST_INHERITANCE_HPP
+--- camp-0.7.1.3.orig/test/mapper.hpp
++++ camp-0.7.1.3/test/mapper.hpp
+@@ -1,148 +1,148 @@
+-/****************************************************************************
+-**
+-** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+-** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+-**
+-** This file is part of the CAMP library.
+-**
+-** CAMP is free software: you can redistribute it and/or modify
+-** it under the terms of the GNU Lesser General Public License as published by
+-** the Free Software Foundation, either version 3 of the License, or
+-** (at your option) any later version.
+-**
+-** CAMP is distributed in the hope that it will be useful,
+-** but WITHOUT ANY WARRANTY; without even the implied warranty of
+-** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+-** GNU Lesser General Public License for more details.
+-**
+-** You should have received a copy of the GNU Lesser General Public License
+-** along with CAMP. If not, see <http://www.gnu.org/licenses/>.
+-**
+-****************************************************************************/
+-
+-#ifndef CAMPTEST_MAPPER_HPP
+-#define CAMPTEST_MAPPER_HPP
+-
+-#include <camp/camptype.hpp>
+-#include <camp/class.hpp>
+-#include <camp/simpleproperty.hpp>
+-#include <camp/function.hpp>
+-#include <map>
+-#include <string>
+-
+-namespace MapperTest
+-{
+- struct MyClass
+- {
+- enum
+- {
+- propertyCount = 5,
+- functionCount = 3
+- };
+-
+- static std::string property(std::size_t index)
+- {
+- const char* names[] = {"prop0", "prop1", "prop2", "prop3", "prop4"};
+- return names[index];
+- }
+-
+- static std::string function(std::size_t index)
+- {
+- const char* names[] = {"func0", "func1", "func2"};
+- return names[index];
+- }
+-
+- MyClass()
+- {
+- m_props[property(0)] = 0;
+- m_props[property(1)] = 10;
+- m_props[property(2)] = 20;
+- m_props[property(3)] = 30;
+- m_props[property(4)] = 40;
+- }
+-
+- int& prop(const std::string& name)
+- {
+- return m_props[name];
+- }
+-
+- std::string func(const std::string& name)
+- {
+- return name + "_called";
+- }
+-
+- std::map<std::string, int> m_props;
+- };
+-
+- template <typename T>
+- struct MyMapper
+- {
+- std::size_t propertyCount()
+- {
+- return T::propertyCount;
+- }
+-
+- camp::Property* property(std::size_t index)
+- {
+- return new MyProperty(T::property(index));
+- }
+-
+- std::size_t functionCount()
+- {
+- return T::functionCount;
+- }
+-
+- camp::Function* function(std::size_t index)
+- {
+- return new MyFunction(T::function(index));
+- }
+-
+- struct MyProperty : public camp::SimpleProperty
+- {
+- public:
+-
+- MyProperty(const std::string& name)
+- : camp::SimpleProperty(name, camp::intType)
+- {
+- }
+-
+- virtual camp::Value getValue(const camp::UserObject& object) const
+- {
+- T& t = object.get<T>();
+- return t.prop(name());
+- }
+-
+- virtual void setValue(const camp::UserObject& object, const camp::Value& value) const
+- {
+- T& t = object.get<T>();
+- t.prop(name()) = value.to<int>();
+- }
+- };
+-
+- class MyFunction : public camp::Function
+- {
+- public:
+-
+- MyFunction(const std::string& name)
+- : camp::Function(name, camp::stringType)
+- {
+- }
+-
+- virtual camp::Value execute(const camp::UserObject& object, const camp::Args&) const
+- {
+- T& t = object.get<T>();
+- return t.func(name());
+- }
+- };
+- };
+-
+- void declare()
+- {
+- camp::Class::declare<MyClass>("MapperTest::MyClass")
+- .external<MyMapper>();
+- }
+-}
+-
+-CAMP_AUTO_TYPE(MapperTest::MyClass, &MapperTest::declare)
+-
+-#endif // CAMPTEST_MAPPER_HPP
++/****************************************************************************
++**
++** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
++** Contact: Technogerma Systems France Information (contact at technogerma.fr)
++**
++** This file is part of the CAMP library.
++**
++** CAMP is free software: you can redistribute it and/or modify
++** it under the terms of the GNU Lesser General Public License as published by
++** the Free Software Foundation, either version 3 of the License, or
++** (at your option) any later version.
++**
++** CAMP is distributed in the hope that it will be useful,
++** but WITHOUT ANY WARRANTY; without even the implied warranty of
++** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++** GNU Lesser General Public License for more details.
++**
++** You should have received a copy of the GNU Lesser General Public License
++** along with CAMP. If not, see <http://www.gnu.org/licenses/>.
++**
++****************************************************************************/
++
++#ifndef CAMPTEST_MAPPER_HPP
++#define CAMPTEST_MAPPER_HPP
++
++#include <camp/camptype.hpp>
++#include <camp/class.hpp>
++#include <camp/simpleproperty.hpp>
++#include <camp/function.hpp>
++#include <map>
++#include <string>
++
++namespace MapperTest
++{
++ struct MyClass
++ {
++ enum
++ {
++ propertyCount = 5,
++ functionCount = 3
++ };
++
++ static std::string property(std::size_t index)
++ {
++ const char* names[] = {"prop0", "prop1", "prop2", "prop3", "prop4"};
++ return names[index];
++ }
++
++ static std::string function(std::size_t index)
++ {
++ const char* names[] = {"func0", "func1", "func2"};
++ return names[index];
++ }
++
++ MyClass()
++ {
++ m_props[property(0)] = 0;
++ m_props[property(1)] = 10;
++ m_props[property(2)] = 20;
++ m_props[property(3)] = 30;
++ m_props[property(4)] = 40;
++ }
++
++ int& prop(const std::string& name)
++ {
++ return m_props[name];
++ }
++
++ std::string func(const std::string& name)
++ {
++ return name + "_called";
++ }
++
++ std::map<std::string, int> m_props;
++ };
++
++ template <typename T>
++ struct MyMapper
++ {
++ std::size_t propertyCount()
++ {
++ return T::propertyCount;
++ }
++
++ camp::Property* property(std::size_t index)
++ {
++ return new MyProperty(T::property(index));
++ }
++
++ std::size_t functionCount()
++ {
++ return T::functionCount;
++ }
++
++ camp::Function* function(std::size_t index)
++ {
++ return new MyFunction(T::function(index));
++ }
++
++ struct MyProperty : public camp::SimpleProperty
++ {
++ public:
++
++ MyProperty(const std::string& name)
++ : camp::SimpleProperty(name, camp::intType)
++ {
++ }
++
++ virtual camp::Value getValue(const camp::UserObject& object) const
++ {
++ T& t = object.get<T>();
++ return t.prop(name());
++ }
++
++ virtual void setValue(const camp::UserObject& object, const camp::Value& value) const
++ {
++ T& t = object.get<T>();
++ t.prop(name()) = value.to<int>();
++ }
++ };
++
++ class MyFunction : public camp::Function
++ {
++ public:
++
++ MyFunction(const std::string& name)
++ : camp::Function(name, camp::stringType)
++ {
++ }
++
++ virtual camp::Value execute(const camp::UserObject& object, const camp::Args&) const
++ {
++ T& t = object.get<T>();
++ return t.func(name());
++ }
++ };
++ };
++
++ void declare()
++ {
++ camp::Class::declare<MyClass>("MapperTest::MyClass")
++ .external<MyMapper>();
++ }
++}
++
++CAMP_AUTO_TYPE(MapperTest::MyClass, &MapperTest::declare)
++
++#endif // CAMPTEST_MAPPER_HPP
+--- camp-0.7.1.3.orig/test/propertyaccess.hpp
++++ camp-0.7.1.3/test/propertyaccess.hpp
+@@ -1,74 +1,74 @@
+-/****************************************************************************
+-**
+-** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
+-** Contact: Technogerma Systems France Information (contact at technogerma.fr)
+-**
+-** This file is part of the CAMP library.
+-**
+-** CAMP is free software: you can redistribute it and/or modify
+-** it under the terms of the GNU Lesser General Public License as published by
+-** the Free Software Foundation, either version 3 of the License, or
+-** (at your option) any later version.
+-**
+-** CAMP is distributed in the hope that it will be useful,
+-** but WITHOUT ANY WARRANTY; without even the implied warranty of
+-** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+-** GNU Lesser General Public License for more details.
+-**
+-** You should have received a copy of the GNU Lesser General Public License
+-** along with CAMP. If not, see <http://www.gnu.org/licenses/>.
+-**
+-****************************************************************************/
+-
+-#ifndef CAMPTEST_PROPERTYACCESS_HPP
+-#define CAMPTEST_PROPERTYACCESS_HPP
+-
+-#include <camp/camptype.hpp>
+-#include <camp/class.hpp>
+-
+-namespace PropertyAccessTest
+-{
+- struct MyClass
+- {
+- MyClass(bool b = true)
+- : m_b(b)
+- {
+- }
+-
+- void set(int x) {p = x;}
+- int get() const {return p;}
+- int& ref() {return p;}
+- int p;
+-
+- bool m_b;
+- bool b1() {return true;}
+- bool b2() const {return false;}
+- };
+-
+- void declare()
+- {
+- camp::Class::declare<MyClass>("PropertyAccessTest::MyClass")
+-
+- // ***** constant value *****
+- .property("p0", &MyClass::p).readable(false).writable(true)
+- .property("p1", &MyClass::p).readable(true).writable(false)
+- .property("p2", &MyClass::p).readable(false).writable(false)
+-
+- // ***** function *****
+- .property("p3", &MyClass::p).readable(&MyClass::b1)
+- .property("p4", &MyClass::p).readable(&MyClass::b2)
+- .property("p5", &MyClass::p).readable(boost::bind(&MyClass::b1, _1))
+- .property("p6", &MyClass::p).readable(&MyClass::m_b)
+- .property("p7", &MyClass::p).readable(boost::function<bool (MyClass&)>(&MyClass::m_b))
+-
+- // ***** implicit - based on the availability of a getter/setter *****
+- .property("p8", &MyClass::get)
+- .property("p9", &MyClass::ref)
+- .property("p10", &MyClass::get, &MyClass::set)
+- ;
+- }
+-}
+-
+-CAMP_AUTO_TYPE(PropertyAccessTest::MyClass, &PropertyAccessTest::declare)
+-
+-#endif // CAMPTEST_PROPERTYACCESS_HPP
++/****************************************************************************
++**
++** Copyright (C) 2009-2010 TECHNOGERMA Systems France and/or its subsidiary(-ies).
++** Contact: Technogerma Systems France Information (contact at technogerma.fr)
++**
++** This file is part of the CAMP library.
++**
++** CAMP is free software: you can redistribute it and/or modify
++** it under the terms of the GNU Lesser General Public License as published by
++** the Free Software Foundation, either version 3 of the License, or
++** (at your option) any later version.
++**
++** CAMP is distributed in the hope that it will be useful,
++** but WITHOUT ANY WARRANTY; without even the implied warranty of
++** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++** GNU Lesser General Public License for more details.
++**
++** You should have received a copy of the GNU Lesser General Public License
++** along with CAMP. If not, see <http://www.gnu.org/licenses/>.
++**
++****************************************************************************/
++
++#ifndef CAMPTEST_PROPERTYACCESS_HPP
++#define CAMPTEST_PROPERTYACCESS_HPP
++
++#include <camp/camptype.hpp>
++#include <camp/class.hpp>
++
++namespace PropertyAccessTest
++{
++ struct MyClass
++ {
++ MyClass(bool b = true)
++ : m_b(b)
++ {
++ }
++
++ void set(int x) {p = x;}
++ int get() const {return p;}
++ int& ref() {return p;}
++ int p;
++
++ bool m_b;
++ bool b1() {return true;}
++ bool b2() const {return false;}
++ };
++
++ void declare()
++ {
++ camp::Class::declare<MyClass>("PropertyAccessTest::MyClass")
++
++ // ***** constant value *****
++ .property("p0", &MyClass::p).readable(false).writable(true)
++ .property("p1", &MyClass::p).readable(true).writable(false)
++ .property("p2", &MyClass::p).readable(false).writable(false)
++
++ // ***** function *****
++ .property("p3", &MyClass::p).readable(&MyClass::b1)
++ .property("p4", &MyClass::p).readable(&MyClass::b2)
++ .property("p5", &MyClass::p).readable(boost::bind(&MyClass::b1, _1))
++ .property("p6", &MyClass::p).readable(&MyClass::m_b)
++ .property("p7", &MyClass::p).readable(boost::function<bool (MyClass&)>(&MyClass::m_b))
++
++ // ***** implicit - based on the availability of a getter/setter *****
++ .property("p8", &MyClass::get)
++ .property("p9", &MyClass::ref)
++ .property("p10", &MyClass::get, &MyClass::set)
++ ;
++ }
++}
++
++CAMP_AUTO_TYPE(PropertyAccessTest::MyClass, &PropertyAccessTest::declare)
++
++#endif // CAMPTEST_PROPERTYACCESS_HPP
diff --git a/debian/patches/series b/debian/patches/series
index acf7eb8..ebdc00a 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -3,3 +3,5 @@ rm_boost_version.patch
remove_licences_files.patch
fix_unit_tests_execution.patch
hide_boost_from_qt4moc.patch
+orig_change.patch
+support_c++11.patch
diff --git a/debian/patches/support_c++11.patch b/debian/patches/support_c++11.patch
new file mode 100644
index 0000000..0d021ac
--- /dev/null
+++ b/debian/patches/support_c++11.patch
@@ -0,0 +1,38 @@
+Description: <short summary of the patch>
+ TODO: Put a short summary on the line above and replace this paragraph
+ with a longer explanation of this change. Complete the meta-information
+ with other relevant fields (see below for details). To make it easier, the
+ information below has been extracted from the changelog. Adjust it or drop
+ it.
+ .
+ camp (0.7.1.3-1) unstable; urgency=medium
+ .
+ * New upstream version
+ * Fix end of line issues
+Author: Corentin Desfarges <corentin.desfarges.dev at gmail.com>
+
+---
+The information above should follow the Patch Tagging Guidelines, please
+checkout http://dep.debian.net/deps/dep3/ to learn about the format. Here
+are templates for supplementary fields that you might want to add:
+
+Origin: <vendor|upstream|other>, <url of original patch>
+Bug: <url in upstream bugtracker>
+Bug-Debian: https://bugs.debian.org/<bugnumber>
+Bug-Ubuntu: https://launchpad.net/bugs/<bugnumber>
+Forwarded: <no|not-needed|url proving that it has been forwarded>
+Reviewed-By: <name and email of someone who approved the patch>
+Last-Update: <YYYY-MM-DD>
+
+--- camp-0.7.1.3.orig/CMakeLists.txt
++++ camp-0.7.1.3/CMakeLists.txt
+@@ -30,6 +30,9 @@ project(CAMP)
+ include(${CMAKE_SOURCE_DIR}/cmake/Config.cmake)
+ include(${CMAKE_SOURCE_DIR}/cmake/PackageFilename.cmake)
+
++set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11"
++ CACHE STRING "Flags used by the compiler during all build types." FORCE)
++
+ # all source files
+ set(CAMP_SRCS
+ include/camp/userproperty.hpp
diff --git a/debian/rules b/debian/rules
index 4067ba0..32938f5 100755
--- a/debian/rules
+++ b/debian/rules
@@ -1,4 +1,6 @@
#!/usr/bin/make -f
+CPPFLAGS:=-std=c++11
+
%:
dh $@
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-med/camp.git
More information about the debian-med-commit
mailing list