[Orxonox-commit 3929] r8603 - in code/branches/presentation/src/libraries: core core/command util
landauf at orxonox.net
landauf at orxonox.net
Thu May 26 16:34:55 CEST 2011
Author: landauf
Date: 2011-05-26 16:34:54 +0200 (Thu, 26 May 2011)
New Revision: 8603
Modified:
code/branches/presentation/src/libraries/core/ConfigValueContainer.h
code/branches/presentation/src/libraries/core/CoreIncludes.h
code/branches/presentation/src/libraries/core/Super.h
code/branches/presentation/src/libraries/core/command/Functor.h
code/branches/presentation/src/libraries/util/Convert.h
code/branches/presentation/src/libraries/util/MultiTypeValue.h
code/branches/presentation/src/libraries/util/ScopedSingletonManager.h
code/branches/presentation/src/libraries/util/Serialise.h
Log:
removed some parameter names where the parameter is not actually used
Modified: code/branches/presentation/src/libraries/core/ConfigValueContainer.h
===================================================================
--- code/branches/presentation/src/libraries/core/ConfigValueContainer.h 2011-05-26 14:19:25 UTC (rev 8602)
+++ code/branches/presentation/src/libraries/core/ConfigValueContainer.h 2011-05-26 14:34:54 UTC (rev 8603)
@@ -108,7 +108,7 @@
@param value Only needed do determine the right type.
*/
template <class D, class V>
- ConfigValueContainer(ConfigFileType::Value type, Identifier* identifier, const std::string& sectionname, const std::string& varname, const D& defvalue, const V& value)
+ ConfigValueContainer(ConfigFileType::Value type, Identifier* identifier, const std::string& sectionname, const std::string& varname, const D& defvalue, const V&)
{
this->init(type, identifier, sectionname, varname);
this->initValue(static_cast<V>(defvalue));
@@ -124,7 +124,7 @@
@param value Only needed do determine the right type.
*/
template <class D, class V>
- ConfigValueContainer(ConfigFileType::Value type, Identifier* identifier, const std::string& sectionname, const std::string& varname, const std::vector<D>& defvalue, const std::vector<V>& value)
+ ConfigValueContainer(ConfigFileType::Value type, Identifier* identifier, const std::string& sectionname, const std::string& varname, const std::vector<D>& defvalue, const std::vector<V>&)
{
this->init(type, identifier, sectionname, varname);
Modified: code/branches/presentation/src/libraries/core/CoreIncludes.h
===================================================================
--- code/branches/presentation/src/libraries/core/CoreIncludes.h 2011-05-26 14:19:25 UTC (rev 8602)
+++ code/branches/presentation/src/libraries/core/CoreIncludes.h 2011-05-26 14:34:54 UTC (rev 8603)
@@ -170,7 +170,7 @@
@param object Pointer to an OrxonoxClass
*/
template <class T>
- inline Identifier* ClassByObjectType(const T* object)
+ inline Identifier* ClassByObjectType(const T*)
{
return ClassIdentifier<T>::getIdentifier();
}
Modified: code/branches/presentation/src/libraries/core/Super.h
===================================================================
--- code/branches/presentation/src/libraries/core/Super.h 2011-05-26 14:19:25 UTC (rev 8602)
+++ code/branches/presentation/src/libraries/core/Super.h 2011-05-26 14:34:54 UTC (rev 8603)
@@ -99,9 +99,9 @@
SuperFunctionCondition<functionnumber + 1, T, 0, templatehack2>::superCheck(); \
} \
\
- static void apply(void* temp) {} \
+ static void apply(void*) {} \
\
- static void apply(baseclass* temp) \
+ static void apply(baseclass*) \
{ \
ClassIdentifier<T>* identifier = ClassIdentifier<T>::getIdentifier(); \
for (std::set<const Identifier*>::iterator it = identifier->getDirectChildrenIntern().begin(); it != identifier->getDirectChildrenIntern().end(); ++it) \
@@ -311,7 +311,7 @@
template <int functionnumber, class T>
struct SuperFunctionInitialization
{
- static void initialize(ClassIdentifier<T>* identifier) {}
+ static void initialize(ClassIdentifier<T>*) {}
};
/**
@@ -320,7 +320,7 @@
template <int functionnumber, class T>
struct SuperFunctionDestruction
{
- static void destroy(ClassIdentifier<T>* identifier) {}
+ static void destroy(ClassIdentifier<T>*) {}
};
Modified: code/branches/presentation/src/libraries/core/command/Functor.h
===================================================================
--- code/branches/presentation/src/libraries/core/command/Functor.h 2011-05-26 14:19:25 UTC (rev 8602)
+++ code/branches/presentation/src/libraries/core/command/Functor.h 2011-05-26 14:34:54 UTC (rev 8603)
@@ -410,29 +410,29 @@
// Helper class, used to call a function-pointer with a given object and parameters and to return its return-value (if available)
template <class R, class O, bool isconst, class P1, class P2, class P3, class P4, class P5> struct FunctorCaller { static inline MultiType call(typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, P4, P5>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { return (object->*functionPointer)(param1, param2, param3, param4, param5); } };
- template <class R, class O, bool isconst, class P1, class P2, class P3, class P4> struct FunctorCaller<R, O, isconst, P1, P2, P3, P4, void> { static inline MultiType call(typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, P4, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { return (object->*functionPointer)(param1, param2, param3, param4); } };
- template <class R, class O, bool isconst, class P1, class P2, class P3> struct FunctorCaller<R, O, isconst, P1, P2, P3, void, void> { static inline MultiType call(typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { return (object->*functionPointer)(param1, param2, param3); } };
- template <class R, class O, bool isconst, class P1, class P2> struct FunctorCaller<R, O, isconst, P1, P2, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<R, O, isconst, P1, P2, void, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { return (object->*functionPointer)(param1, param2); } };
- template <class R, class O, bool isconst, class P1> struct FunctorCaller<R, O, isconst, P1, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<R, O, isconst, P1, void, void, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { return (object->*functionPointer)(param1); } };
- template <class R, class O, bool isconst> struct FunctorCaller<R, O, isconst, void, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<R, O, isconst, void, void, void, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { return (object->*functionPointer)(); } };
+ template <class R, class O, bool isconst, class P1, class P2, class P3, class P4> struct FunctorCaller<R, O, isconst, P1, P2, P3, P4, void> { static inline MultiType call(typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, P4, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType&) { return (object->*functionPointer)(param1, param2, param3, param4); } };
+ template <class R, class O, bool isconst, class P1, class P2, class P3> struct FunctorCaller<R, O, isconst, P1, P2, P3, void, void> { static inline MultiType call(typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType&, const MultiType&) { return (object->*functionPointer)(param1, param2, param3); } };
+ template <class R, class O, bool isconst, class P1, class P2> struct FunctorCaller<R, O, isconst, P1, P2, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<R, O, isconst, P1, P2, void, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType&, const MultiType&, const MultiType&) { return (object->*functionPointer)(param1, param2); } };
+ template <class R, class O, bool isconst, class P1> struct FunctorCaller<R, O, isconst, P1, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<R, O, isconst, P1, void, void, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { return (object->*functionPointer)(param1); } };
+ template <class R, class O, bool isconst> struct FunctorCaller<R, O, isconst, void, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<R, O, isconst, void, void, void, void, void>::Type functionPointer, O* object, const MultiType&, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { return (object->*functionPointer)(); } };
template <class O, bool isconst, class P1, class P2, class P3, class P4, class P5> struct FunctorCaller<void, O, isconst, P1, P2, P3, P4, P5> { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, P3, P4, P5>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (object->*functionPointer)(param1, param2, param3, param4, param5); return MT_Type::Null; } };
- template <class O, bool isconst, class P1, class P2, class P3, class P4> struct FunctorCaller<void, O, isconst, P1, P2, P3, P4, void> { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, P3, P4, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (object->*functionPointer)(param1, param2, param3, param4); return MT_Type::Null; } };
- template <class O, bool isconst, class P1, class P2, class P3> struct FunctorCaller<void, O, isconst, P1, P2, P3, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, P3, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (object->*functionPointer)(param1, param2, param3); return MT_Type::Null; } };
- template <class O, bool isconst, class P1, class P2> struct FunctorCaller<void, O, isconst, P1, P2, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, void, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (object->*functionPointer)(param1, param2); return MT_Type::Null; } };
- template <class O, bool isconst, class P1> struct FunctorCaller<void, O, isconst, P1, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, void, void, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (object->*functionPointer)(param1); return MT_Type::Null; } };
- template <class O, bool isconst> struct FunctorCaller<void, O, isconst, void, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, void, void, void, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (object->*functionPointer)(); return MT_Type::Null; } };
+ template <class O, bool isconst, class P1, class P2, class P3, class P4> struct FunctorCaller<void, O, isconst, P1, P2, P3, P4, void> { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, P3, P4, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType&) { (object->*functionPointer)(param1, param2, param3, param4); return MT_Type::Null; } };
+ template <class O, bool isconst, class P1, class P2, class P3> struct FunctorCaller<void, O, isconst, P1, P2, P3, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, P3, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType&, const MultiType&) { (object->*functionPointer)(param1, param2, param3); return MT_Type::Null; } };
+ template <class O, bool isconst, class P1, class P2> struct FunctorCaller<void, O, isconst, P1, P2, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, void, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType&, const MultiType&, const MultiType&) { (object->*functionPointer)(param1, param2); return MT_Type::Null; } };
+ template <class O, bool isconst, class P1> struct FunctorCaller<void, O, isconst, P1, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, void, void, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { (object->*functionPointer)(param1); return MT_Type::Null; } };
+ template <class O, bool isconst> struct FunctorCaller<void, O, isconst, void, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, void, void, void, void, void>::Type functionPointer, O* object, const MultiType&, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { (object->*functionPointer)(); return MT_Type::Null; } };
template <class R, bool isconst, class P1, class P2, class P3, class P4, class P5> struct FunctorCaller<R, void, isconst, P1, P2, P3, P4, P5> { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, P1, P2, P3, P4, P5>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { return (*functionPointer)(param1, param2, param3, param4, param5); } };
- template <class R, bool isconst, class P1, class P2, class P3, class P4> struct FunctorCaller<R, void, isconst, P1, P2, P3, P4, void> { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, P1, P2, P3, P4, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { return (*functionPointer)(param1, param2, param3, param4); } };
- template <class R, bool isconst, class P1, class P2, class P3> struct FunctorCaller<R, void, isconst, P1, P2, P3, void, void> { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, P1, P2, P3, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { return (*functionPointer)(param1, param2, param3); } };
- template <class R, bool isconst, class P1, class P2> struct FunctorCaller<R, void, isconst, P1, P2, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, P1, P2, void, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { return (*functionPointer)(param1, param2); } };
- template <class R, bool isconst, class P1> struct FunctorCaller<R, void, isconst, P1, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, P1, void, void, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { return (*functionPointer)(param1); } };
- template <class R, bool isconst> struct FunctorCaller<R, void, isconst, void, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, void, void, void, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { return (*functionPointer)(); } };
+ template <class R, bool isconst, class P1, class P2, class P3, class P4> struct FunctorCaller<R, void, isconst, P1, P2, P3, P4, void> { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, P1, P2, P3, P4, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType&) { return (*functionPointer)(param1, param2, param3, param4); } };
+ template <class R, bool isconst, class P1, class P2, class P3> struct FunctorCaller<R, void, isconst, P1, P2, P3, void, void> { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, P1, P2, P3, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType&, const MultiType&) { return (*functionPointer)(param1, param2, param3); } };
+ template <class R, bool isconst, class P1, class P2> struct FunctorCaller<R, void, isconst, P1, P2, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, P1, P2, void, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType&, const MultiType&, const MultiType&) { return (*functionPointer)(param1, param2); } };
+ template <class R, bool isconst, class P1> struct FunctorCaller<R, void, isconst, P1, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, P1, void, void, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { return (*functionPointer)(param1); } };
+ template <class R, bool isconst> struct FunctorCaller<R, void, isconst, void, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, void, void, void, void, void>::Type functionPointer, void*, const MultiType&, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { return (*functionPointer)(); } };
template <bool isconst, class P1, class P2, class P3, class P4, class P5> struct FunctorCaller<void, void, isconst, P1, P2, P3, P4, P5> { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, P3, P4, P5>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (*functionPointer)(param1, param2, param3, param4, param5); return MT_Type::Null; } };
- template <bool isconst, class P1, class P2, class P3, class P4> struct FunctorCaller<void, void, isconst, P1, P2, P3, P4, void> { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, P3, P4, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (*functionPointer)(param1, param2, param3, param4); return MT_Type::Null; } };
- template <bool isconst, class P1, class P2, class P3> struct FunctorCaller<void, void, isconst, P1, P2, P3, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, P3, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (*functionPointer)(param1, param2, param3); return MT_Type::Null; } };
- template <bool isconst, class P1, class P2> struct FunctorCaller<void, void, isconst, P1, P2, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, void, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (*functionPointer)(param1, param2); return MT_Type::Null; } };
- template <bool isconst, class P1> struct FunctorCaller<void, void, isconst, P1, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, void, void, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (*functionPointer)(param1); return MT_Type::Null; } };
- template <bool isconst> struct FunctorCaller<void, void, isconst, void, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, void, void, void, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (*functionPointer)(); return MT_Type::Null; } };
+ template <bool isconst, class P1, class P2, class P3, class P4> struct FunctorCaller<void, void, isconst, P1, P2, P3, P4, void> { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, P3, P4, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType&) { (*functionPointer)(param1, param2, param3, param4); return MT_Type::Null; } };
+ template <bool isconst, class P1, class P2, class P3> struct FunctorCaller<void, void, isconst, P1, P2, P3, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, P3, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType&, const MultiType&) { (*functionPointer)(param1, param2, param3); return MT_Type::Null; } };
+ template <bool isconst, class P1, class P2> struct FunctorCaller<void, void, isconst, P1, P2, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, void, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType&, const MultiType&, const MultiType&) { (*functionPointer)(param1, param2); return MT_Type::Null; } };
+ template <bool isconst, class P1> struct FunctorCaller<void, void, isconst, P1, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, void, void, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { (*functionPointer)(param1); return MT_Type::Null; } };
+ template <bool isconst> struct FunctorCaller<void, void, isconst, void, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, void, void, void, void, void>::Type functionPointer, void*, const MultiType&, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { (*functionPointer)(); return MT_Type::Null; } };
// Helper class, used to identify the header of a function-pointer (independent of its class)
template <class R, class P1, class P2, class P3, class P4, class P5>
Modified: code/branches/presentation/src/libraries/util/Convert.h
===================================================================
--- code/branches/presentation/src/libraries/util/Convert.h 2011-05-26 14:19:25 UTC (rev 8602)
+++ code/branches/presentation/src/libraries/util/Convert.h 2011-05-26 14:34:54 UTC (rev 8603)
@@ -142,7 +142,7 @@
template <class FromType, class ToType>
struct ConverterFallback
{
- ORX_FORCEINLINE static bool convert(ToType* output, const FromType& input)
+ ORX_FORCEINLINE static bool convert(ToType* /*output*/, const FromType& /*input*/)
{
COUT(2) << "Could not convert value of type " << typeid(FromType).name()
<< " to type " << typeid(ToType).name() << std::endl;
Modified: code/branches/presentation/src/libraries/util/MultiTypeValue.h
===================================================================
--- code/branches/presentation/src/libraries/util/MultiTypeValue.h 2011-05-26 14:19:25 UTC (rev 8602)
+++ code/branches/presentation/src/libraries/util/MultiTypeValue.h 2011-05-26 14:34:54 UTC (rev 8603)
@@ -254,11 +254,11 @@
{
return 4*returnSize(this->value_.x);
}
- template <> inline void MT_Value<void*>::importData( uint8_t*& mem )
+ template <> inline void MT_Value<void*>::importData( uint8_t*& /*mem*/ )
{
assert(0);
}
- template <> inline void MT_Value<void*>::exportData( uint8_t*& mem ) const
+ template <> inline void MT_Value<void*>::exportData( uint8_t*& /*mem*/ ) const
{
assert(0);
}
Modified: code/branches/presentation/src/libraries/util/ScopedSingletonManager.h
===================================================================
--- code/branches/presentation/src/libraries/util/ScopedSingletonManager.h 2011-05-26 14:19:25 UTC (rev 8602)
+++ code/branches/presentation/src/libraries/util/ScopedSingletonManager.h 2011-05-26 14:34:54 UTC (rev 8603)
@@ -246,12 +246,12 @@
}
//! Destroys the singleton instance - overloaded for OrxonoxClass, calls OrxonoxClass::destroy()
- void destroy(OrxonoxClass* ptr)
+ void destroy(OrxonoxClass*)
{
singletonPtr_->destroy();
}
//! Destroys the singleton instance - overloaded for void*, calls delete
- void destroy(void* ptr)
+ void destroy(void*)
{
delete singletonPtr_;
}
Modified: code/branches/presentation/src/libraries/util/Serialise.h
===================================================================
--- code/branches/presentation/src/libraries/util/Serialise.h 2011-05-26 14:19:25 UTC (rev 8602)
+++ code/branches/presentation/src/libraries/util/Serialise.h 2011-05-26 14:34:54 UTC (rev 8603)
@@ -86,7 +86,7 @@
// =========== bool
- template <> inline uint32_t returnSize( const bool& variable )
+ template <> inline uint32_t returnSize( const bool& )
{
return sizeof(uint8_t);
}
@@ -110,7 +110,7 @@
// =========== char
- template <> inline uint32_t returnSize( const char& variable )
+ template <> inline uint32_t returnSize( const char& )
{
return sizeof(uint8_t);
}
@@ -134,7 +134,7 @@
// =========== unsigned char
- template <> inline uint32_t returnSize( const unsigned char& variable )
+ template <> inline uint32_t returnSize( const unsigned char& )
{
return sizeof(uint8_t);
}
@@ -158,7 +158,7 @@
// =========== short
- template <> inline uint32_t returnSize( const short& variable )
+ template <> inline uint32_t returnSize( const short& )
{
return sizeof(int16_t);
}
@@ -182,7 +182,7 @@
// =========== unsigned short
- template <> inline uint32_t returnSize( const unsigned short& variable )
+ template <> inline uint32_t returnSize( const unsigned short& )
{
return sizeof(uint16_t);
}
@@ -206,7 +206,7 @@
// =========== int
- template <> inline uint32_t returnSize( const int& variable )
+ template <> inline uint32_t returnSize( const int& )
{
return sizeof(int32_t);
}
@@ -230,7 +230,7 @@
// =========== unsigned int
- template <> inline uint32_t returnSize( const unsigned int& variable )
+ template <> inline uint32_t returnSize( const unsigned int& )
{
return sizeof(uint32_t);
}
@@ -254,7 +254,7 @@
// =========== long
- template <> inline uint32_t returnSize( const long& variable )
+ template <> inline uint32_t returnSize( const long& )
{
return sizeof(int32_t);
}
@@ -278,7 +278,7 @@
// =========== unsigned long
- template <> inline uint32_t returnSize( const unsigned long& variable )
+ template <> inline uint32_t returnSize( const unsigned long& )
{
return sizeof(uint32_t);
}
@@ -302,7 +302,7 @@
// =========== long long
- template <> inline uint32_t returnSize( const long long& variable )
+ template <> inline uint32_t returnSize( const long long& )
{
return sizeof(int64_t);
}
@@ -326,7 +326,7 @@
// =========== unsigned long long
- template <> inline uint32_t returnSize( const unsigned long long& variable )
+ template <> inline uint32_t returnSize( const unsigned long long& )
{
return sizeof(uint64_t);
}
@@ -350,7 +350,7 @@
// =========== float
- template <> inline uint32_t returnSize( const float& variable )
+ template <> inline uint32_t returnSize( const float& )
{
return sizeof(uint32_t);
}
@@ -374,7 +374,7 @@
// =========== double
- template <> inline uint32_t returnSize( const double& variable )
+ template <> inline uint32_t returnSize( const double& )
{
return sizeof(uint64_t);
}
@@ -398,7 +398,7 @@
// =========== long double
- template <> inline uint32_t returnSize( const long double& variable )
+ template <> inline uint32_t returnSize( const long double& )
{
return sizeof(uint64_t);
}
@@ -451,7 +451,7 @@
// =========== Degree
- template <> inline uint32_t returnSize( const Degree& variable )
+ template <> inline uint32_t returnSize( const Degree& )
{
return sizeof(Ogre::Real);
}
@@ -478,7 +478,7 @@
// =========== Radian
- template <> inline uint32_t returnSize( const Radian& variable )
+ template <> inline uint32_t returnSize( const Radian& )
{
return sizeof(Ogre::Real);
}
More information about the Orxonox-commit
mailing list