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....@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....@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.p...@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.p...@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.p...@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....@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 (cont...@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 (cont...@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 (cont...@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 (cont...@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 (cont...@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 (cont...@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 (cont...@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 (cont...@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 (cont...@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 (cont...@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....@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 _______________________________________________ debian-med-commit mailing list debian-med-commit@lists.alioth.debian.org http://lists.alioth.debian.org/cgi-bin/mailman/listinfo/debian-med-commit