--- /dev/null
+/*
+ * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+/// \ingroup tag_NS_UtilityCenter
+/// \brief This file contains declaration of common APIs for NS_UtilityCenter.
+///
+////////////////////////////////////////////////////////////////////////////////////////////////////
+//@{
+/**
+ * @file ns_utility.hpp
+ * @brief \~english This file contains declaration of common APIs for NS_UtilityCenter.
+ *
+ */
+/** @addtogroup BaseSystem
+ * @{
+ */
+/** @addtogroup native_service
+ * @ingroup BaseSystem
+ * @{
+ */
+/** @addtogroup framework_unified
+ * @ingroup native_service
+ * @{
+ */
+/** @addtogroup native
+ * @ingroup framework_unified
+ * @{
+ */
+#ifndef __NSFRAMEWORK_NSUTILITY_NSUTILITY__ // NOLINT (build/header_guard)
+#define __NSFRAMEWORK_NSUTILITY_NSUTILITY__
+
+#include <native_service/frameworkunified_types.h>
+#include <new>
+#include <exception>
+#include <algorithm>
+#include <iterator>
+
+#ifdef AGL_STUB
+#include <stdexcept>
+#endif
+
+// Macros ///////////////////////////////////////////////////////////////
+
+#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
+ TypeName(const TypeName&); \
+ void operator=(const TypeName& )
+
+#define DEFINE_EXCEPTION( name, base ) \
+class name : public base \
+{ \
+public: \
+ name ( const char* str = "" ) : base ( str ) \
+ {} \
+}
+
+// Helpful type definitions ////////////////////////////////////////////////
+template <int v>
+struct Int2Type {
+ enum { value = v }; // NOLINT (readability/nolint)
+};
+
+template <class T>
+struct Type2Type {
+ typedef T Type;
+};
+
+// Helpful Fucntions /////////////////////////////////////////////////////////
+template< class T, UI_32 N >
+const T *ArrBeg(const T(&arr)[ N ]) {
+ return &arr[ 0 ];
+}
+
+template< class T, UI_32 N >
+const T *ArrEnd(const T(&arr)[ N ]) {
+ return &arr[ 0 ] + N;
+}
+
+template< class O, class I >
+O SimpleCast(I i) {
+ return static_cast< O >(i);
+}
+
+template< class R, class B >
+R UnalignedRet(B *b) {
+ return *reinterpret_cast< R volatile * >(b);
+}
+
+template< class Cont, class Gen >
+Cont genRange(UI_32 N, Gen genFn) {
+ Cont c;
+ std::generate_n(std::back_inserter(c), N, genFn);
+ return c;
+}
+
+template< class OCont, class IIter, class MapFn >
+OCont mapRange(const IIter &begin, const IIter &end, MapFn fn) {
+ OCont c;
+ std::transform(begin, end, std::inserter(c, c.begin()), fn);
+ return c;
+}
+// Static Compile-time list creation /////////////////////////////////////////
+
+#ifdef AGL_STUB
+#else
+////////////////////////
+#include <_pack1.h> //
+//////////////////////////
+#endif
+
+template< class T, UI_32 N >
+struct TList {
+ T datum;
+ TList < T, N - 1 > data;
+
+ T *operator&() { // NOLINT (readability/nolint)
+ return reinterpret_cast< T * >(this);
+ }
+ const T *operator&() const { // NOLINT (readability/nolint)
+ return reinterpret_cast< const T * >(this);
+ }
+ static const UI_32 count = N; // NOLINT (readability/nolint)
+
+};
+
+template< class T >
+struct TList< T, 1 > {
+ T datum;
+
+ T *operator&() { // NOLINT (readability/nolint)
+ return reinterpret_cast< T * >(this);
+ }
+ const T *operator&() const { // NOLINT (readability/nolint)
+ return reinterpret_cast< const T * >(this);
+ }
+ static const UI_32 count = 1; // NOLINT (readability/nolint)
+
+};
+
+#ifdef AGL_STUB
+#else
+/////////////////////////
+#include <_packpop.h> //
+///////////////////////
+#endif
+
+// Function Decomposition ///////////////////////////////////////////////////
+
+template< class Sig >
+struct FSig {
+};
+
+template<class R>
+struct FSig< R(*)() > {
+ typedef R RType;
+ static const UI_32 argCount = 0; // NOLINT (readability/nolint)
+};
+
+template<class R, class T1>
+struct FSig< R(*)(T1) > {
+ typedef R RType;
+ typedef T1 TArg1;
+ static const UI_32 argCount = 1; // NOLINT (readability/nolint)
+};
+
+template<class R, class T1, class T2>
+struct FSig< R(*)(T1, T2) > {
+ typedef R RType;
+ typedef T1 TArg1;
+ typedef T2 TArg2;
+ static const UI_32 argCount = 2; // NOLINT (readability/nolint)
+};
+
+template<class R, class T1, class T2, class T3>
+struct FSig< R(*)(T1, T2, T3) > {
+ typedef R RType;
+ typedef T1 TArg1;
+ typedef T2 TArg2;
+ typedef T3 TArg3;
+ static const UI_32 argCount = 3; // NOLINT (readability/nolint)
+};
+
+template<class R, class T1, class T2, class T3, class T4>
+struct FSig< R(*)(T1, T2, T3, T4) > {
+ typedef R RType;
+ typedef T1 TArg1;
+ typedef T2 TArg2;
+ typedef T3 TArg3;
+ typedef T4 TArg4;
+ static const UI_32 argCount = 4; // NOLINT (readability/nolint)
+};
+
+template<class R, class T1, class T2, class T3, class T4, class T5>
+struct FSig< R(*)(T1, T2, T3, T4, T5) > {
+ typedef R RType;
+ typedef T1 TArg1;
+ typedef T2 TArg2;
+ typedef T3 TArg3;
+ typedef T4 TArg4;
+ typedef T5 TArg5;
+ static const UI_32 argCount = 5; // NOLINT (readability/nolint)
+};
+
+template<class R, class T1, class T2, class T3, class T4, class T5, class T6>
+struct FSig< R(*)(T1, T2, T3, T4, T5, T6) > {
+ typedef R RType;
+ typedef T1 TArg1;
+ typedef T2 TArg2;
+ typedef T3 TArg3;
+ typedef T4 TArg4;
+ typedef T5 TArg5;
+ typedef T6 TArg6;
+ static const UI_32 argCount = 6; // NOLINT (readability/nolint)
+};
+
+template<class R, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
+struct FSig< R(*)(T1, T2, T3, T4, T5, T6, T7) > {
+ typedef R RType;
+ typedef T1 TArg1;
+ typedef T2 TArg2;
+ typedef T3 TArg3;
+ typedef T4 TArg4;
+ typedef T5 TArg5;
+ typedef T6 TArg6;
+ typedef T7 TArg7;
+ static const UI_32 argCount = 7; // NOLINT (readability/nolint)
+};
+
+
+
+// Accumulator definition //////////////////////////////////////////////////
+
+/// \brief Accumultor type
+///
+/// An accumulator is an object that keeps an internal counter, and will increment its
+/// counter by n, which defaults to 1, each time operator() is called on it. Eample usage:
+///
+/// Accumulator< int > a( 42 ); // initialize a to 42
+/// int v1 = a(); // <-- v1 == 43
+/// int v2 = a(); // <-- v2 == 44
+/// int v4 = a(10); // <-- v4 == 54
+/// int v5 = a(); // <-- v5 == 55
+template<typename T>
+class Accumulator {
+ public:
+ Accumulator(T n) : n(n) {}
+
+ template<typename U>
+ Accumulator(const Accumulator<U> &u) : n(u.n) {}
+
+ T operator()(T i = 1) { // NOLINT (readability/nolint)
+ return operator()< T >(i);
+ }
+
+ template<typename U>
+ T operator()(U i) {
+ return n += i;
+ }
+
+ template< typename U >
+ friend class Accumulator;
+
+ private:
+ T n;
+};
+
+
+/// \brief Accumulator utility function
+///
+/// Given a value n of type T, returns an accumulator of type Accumulator<T> initialized to value n
+template<typename T>
+Accumulator<T> MakeAccumulator(T n) {
+ return Accumulator<T>(n);
+}
+
+// Rsrc Management helper class /////////////////////////////////////////////
+
+template< class T >
+class MemTraits {
+ public:
+ typedef T *Type;
+ typedef std::bad_alloc Exception;
+ static void Release(Type rsrc) {
+ delete rsrc;
+ }
+
+ static BOOL BadValue(Type rsrc) {
+ return NULL == rsrc;
+ }
+};
+
+template< class RsrcTraits >
+class RaiseExceptionPolicy {
+ public:
+ typedef typename RsrcTraits::Type Type;
+ static Type check(Type t) { // NOLINT (readability/nolint)
+ if (RsrcTraits::BadValue(t)) {
+ throw typename RsrcTraits::Exception();
+ }
+
+ return t;
+ }
+};
+
+template< class RsrcTraits >
+class CheckForErrorPolicy { // no exceptions
+ public:
+ typedef typename RsrcTraits::Type Type;
+
+ static Type check(Type t) { // NOLINT (readability/nolint)
+ return t;
+ }
+
+ static bool isValid(Type t) { // NOLINT (readability/nolint)
+ return ! RsrcTraits::BadValue(t);
+ }
+};
+
+template < class T,
+ class RsrcTraits = MemTraits< T >,
+ template <class> class ErrorPolicy = RaiseExceptionPolicy >
+class ResourceMgr : public RsrcTraits {
+ public:
+ typedef typename RsrcTraits::Type Type;
+ typedef ErrorPolicy< RsrcTraits > TFullErrorPolicy;
+
+ ResourceMgr(Type rsrc) : m_rsrc(TFullErrorPolicy::check(rsrc)) {}
+
+ ~ResourceMgr() {
+ RsrcTraits::Release(m_rsrc);
+ }
+
+ operator Type() { // NOLINT (readability/nolint)
+ return m_rsrc;
+ }
+
+ operator const Type() const { // NOLINT (readability/nolint)
+ return m_rsrc;
+ }
+
+ bool isValid() const { // NOLINT (readability/nolint)
+ return TFullErrorPolicy::isValid(m_rsrc);
+ }
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(ResourceMgr);
+
+ Type m_rsrc;
+};
+
+// Functor Helper classes /////////////////////////////////////
+template< class R >
+class IFunctor {
+ public:
+ IFunctor() {}
+ virtual ~IFunctor() {}
+
+ virtual R operator()() const = 0; // NOLINT (readability/nolint)
+ virtual UI_32 size() const = 0; // NOLINT (readability/nolint)
+};
+
+template< class TFn >
+class CFunctor0 : public IFunctor< typename FSig< TFn >::RType > {
+ public:
+ CFunctor0(TFn fn) : m_function(fn) {}
+ typename FSig< TFn >::RType operator()() const { // NOLINT (readability/nolint)
+ return m_function();
+ }
+ UI_32 size() const { // NOLINT (readability/nolint)
+ return sizeof(TFn);
+ }
+
+ private:
+ TFn m_function;
+};
+
+template< class TFn, class Arg1 >
+class CFunctor1 : public IFunctor< typename FSig< TFn >::RType > {
+ public:
+
+ CFunctor1(TFn fn, Arg1 arg1) : m_function(fn), m_arg1(arg1) {}
+ typename FSig< TFn >::RType operator()() const { // NOLINT (readability/nolint)
+ return m_function(m_arg1);
+ }
+ UI_32 size() const { // NOLINT (readability/nolint)
+ return sizeof(TFn) + sizeof(Arg1);
+ }
+
+ private:
+ TFn m_function;
+ Arg1 m_arg1;
+};
+
+template< class TFn, class Arg1, class Arg2 >
+class CFunctor2 : public IFunctor< typename FSig< TFn >::RType > {
+ public:
+
+ CFunctor2(TFn fn, Arg1 arg1, Arg2 arg2) : m_function(fn), m_arg1(arg1), m_arg2(arg2) {}
+ typename FSig< TFn >::RType operator()() const { // NOLINT (readability/nolint)
+ return m_function(m_arg1, m_arg2);
+ }
+ UI_32 size() const { // NOLINT (readability/nolint)
+ return sizeof(TFn) + sizeof(Arg1) + sizeof(Arg2);
+ }
+ private:
+ TFn m_function;
+ Arg1 m_arg1;
+ Arg2 m_arg2;
+};
+
+template< class TFn, class Arg1, class Arg2, class Arg3 >
+class CFunctor3 : public IFunctor< typename FSig< TFn >::RType > {
+ public:
+
+ CFunctor3(TFn fn, Arg1 arg1, Arg2 arg2, Arg3 arg3) : m_function(fn), m_arg1(arg1), m_arg2(arg2), m_arg3(arg3) {}
+ typename FSig< TFn >::RType operator()() const { // NOLINT (readability/nolint)
+ return m_function(m_arg1, m_arg2, m_arg3);
+ }
+ UI_32 size() const { // NOLINT (readability/nolint)
+ return sizeof(TFn) + sizeof(Arg1) + sizeof(Arg2) + sizeof(Arg3);
+ }
+ private:
+ TFn m_function;
+ Arg1 m_arg1;
+ Arg2 m_arg2;
+ Arg3 m_arg3;
+};
+
+template< class TFn, class Arg1, class Arg2, class Arg3, class Arg4 >
+class CFunctor4 : public IFunctor< typename FSig< TFn >::RType > {
+ public:
+ CFunctor4(TFn fn, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4) : m_function(fn), m_arg1(arg1), m_arg2(arg2),
+ m_arg3(arg3), m_arg4(arg4) {}
+ typename FSig< TFn >::RType operator()() const { // NOLINT (readability/nolint)
+ return m_function(m_arg1, m_arg2, m_arg3, m_arg4);
+ }
+ UI_32 size() const { // NOLINT (readability/nolint)
+ return sizeof(TFn) + sizeof(Arg1) + sizeof(Arg2) + sizeof(Arg3) + sizeof(Arg4);
+ }
+ private:
+ TFn m_function;
+ Arg1 m_arg1;
+ Arg2 m_arg2;
+ Arg3 m_arg3;
+ Arg4 m_arg4;
+};
+
+template< class TFn, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5 >
+class CFunctor5 : public IFunctor< typename FSig< TFn >::RType > {
+ public:
+ CFunctor5(TFn fn, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5) : m_function(fn), m_arg1(arg1), m_arg2(arg2),
+ m_arg3(arg3), m_arg4(arg4), m_arg5(arg5) {}
+ typename FSig< TFn >::RType operator()() const { // NOLINT (readability/nolint)
+ return m_function(m_arg1, m_arg2, m_arg3, m_arg4, m_arg5);
+ }
+ UI_32 size() const { // NOLINT (readability/nolint)
+ return sizeof(TFn) + sizeof(Arg1) + sizeof(Arg2) + sizeof(Arg3) + sizeof(Arg4) + sizeof(Arg5);
+ }
+ private:
+ TFn m_function;
+ Arg1 m_arg1;
+ Arg2 m_arg2;
+ Arg3 m_arg3;
+ Arg4 m_arg4;
+ Arg5 m_arg5;
+};
+
+template< class TFn, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6 >
+class CFunctor6 : public IFunctor< typename FSig< TFn >::RType > {
+ public:
+ CFunctor6(TFn fn, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5, Arg6 arg6) : m_function(fn), m_arg1(arg1),
+ m_arg2(arg2), m_arg3(arg3), m_arg4(arg4), m_arg5(arg5), m_arg6(arg6) {}
+ typename FSig< TFn >::RType operator()() const { // NOLINT (readability/nolint)
+ return m_function(m_arg1, m_arg2, m_arg3, m_arg4, m_arg5, m_arg6);
+ }
+ UI_32 size() const { // NOLINT (readability/nolint)
+ return sizeof(TFn) + sizeof(Arg1) + sizeof(Arg2) + sizeof(Arg3) + sizeof(Arg4) + sizeof(Arg5) + sizeof(Arg6);
+ }
+ private:
+ TFn m_function;
+ Arg1 m_arg1;
+ Arg2 m_arg2;
+ Arg3 m_arg3;
+ Arg4 m_arg4;
+ Arg5 m_arg5;
+ Arg6 m_arg6;
+};
+
+template< class TFn, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7 >
+class CFunctor7 : public IFunctor< typename FSig< TFn >::RType > {
+ public:
+ CFunctor7(TFn fn, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5, Arg6 arg6, Arg7 arg7)
+ : m_function(fn), m_arg1(arg1), m_arg2(arg2), m_arg3(arg3), m_arg4(arg4), m_arg5(arg5), m_arg6(arg6), m_arg7(arg7) {}
+ typename FSig< TFn >::RType operator()() const { // NOLINT (readability/nolint)
+ return m_function(m_arg1, m_arg2, m_arg3, m_arg4, m_arg5, m_arg6, m_arg7);
+ }
+ UI_32 size() const { // NOLINT (readability/nolint)
+ return sizeof(TFn) + sizeof(Arg1) + sizeof(Arg2) + sizeof(Arg3) + sizeof(Arg4) + sizeof(Arg5) + sizeof(Arg6) + sizeof(Arg7);
+ }
+ private:
+ TFn m_function;
+ Arg1 m_arg1;
+ Arg2 m_arg2;
+ Arg3 m_arg3;
+ Arg4 m_arg4;
+ Arg5 m_arg5;
+ Arg6 m_arg6;
+ Arg7 m_arg7;
+};
+
+
+template<class TFn>
+CFunctor0<TFn> functor(TFn fn) {
+ return CFunctor0<TFn>(fn);
+}
+
+template<class TFn, class Arg1>
+CFunctor1<TFn, Arg1> functor(TFn fn, Arg1 arg1) {
+ return CFunctor1<TFn, Arg1>(fn, arg1);
+}
+
+template<class TFn, class Arg1, class Arg2>
+CFunctor2<TFn, Arg1, Arg2> functor(TFn fn, Arg1 arg1, Arg2 arg2) {
+ return CFunctor2<TFn, Arg1, Arg2>(fn, arg1, arg2);
+}
+
+template<class TFn, class Arg1, class Arg2, class Arg3>
+CFunctor3<TFn, Arg1, Arg2, Arg3> functor(TFn fn, Arg1 arg1, Arg2 arg2, Arg3 arg3) {
+ return CFunctor3<TFn, Arg1, Arg2, Arg3>(fn, arg1, arg2, arg3);
+}
+
+template<class TFn, class Arg1, class Arg2, class Arg3, class Arg4>
+CFunctor4<TFn, Arg1, Arg2, Arg3, Arg4> functor(TFn fn, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4) {
+ return CFunctor4<TFn, Arg1, Arg2, Arg3, Arg4>(fn, arg1, arg2, arg3, arg4);
+}
+
+template<class TFn, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5>
+CFunctor5<TFn, Arg1, Arg2, Arg3, Arg4, Arg5> functor(TFn fn, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5) {
+ return CFunctor5<TFn, Arg1, Arg2, Arg3, Arg4, Arg5>(fn, arg1, arg2, arg3, arg4, arg5);
+}
+
+template<class TFn, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6>
+CFunctor6<TFn, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6> functor(TFn fn, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4,
+ Arg5 arg5, Arg6 arg6) {
+ return CFunctor6<TFn, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6>(fn, arg1, arg2, arg3, arg4, arg5, arg6);
+}
+
+template<class TFn, class Arg1, class Arg2, class Arg3, class Arg4, class Arg5, class Arg6, class Arg7>
+CFunctor7<TFn, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7> functor(TFn fn, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4,
+ Arg5 arg5, Arg6 arg6, Arg7 arg7) {
+ return CFunctor7<TFn, Arg1, Arg2, Arg3, Arg4, Arg5, Arg6, Arg7>(fn, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+}
+
+#endif // __NSFRAMEWORK_NSUTILITY_NSUTILITY__ NOLINT (build/header_guard)
+/** @}*/
+/** @}*/
+/** @}*/
+/** @}*/
+//@}
Code Review / staging / basesystem.git / blobdiff