functors.h

Go to the documentation of this file.

//   Copyright 2016-2023 Jean-Francois Poilpret
//
//   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.
 
 
#ifndef FUNCTORS_HH
#define FUNCTORS_HH
 
#include "utilities.h"
#include "types_traits.h"
 
namespace functor
{
    // Private class to hide internals used for public API implementation (declared friend)
    class functor_impl
    {
        // Change endianness of a single integer (T must be an integral type)
        template<typename T> class ChangeEndiannessOneImpl
        {
            using T_TRAIT = types_traits::Type_trait<T>;
            static_assert(T_TRAIT::IS_INT, "T must be an integral type");
            static_assert(T_TRAIT::SIZE > 1, "T must be at least 2 bytes long");
        public:
            using ARG_TYPE = T;
            using RES_TYPE = T;
            T operator()(const T& value) const
            {
                return utils::change_endianness(value);
            }
        };
 
        // Change endianness of a several integers embedded in another type
        template<typename T, typename TT> class ChangeEndiannessManyImpl
        {
            static_assert(sizeof(T) > sizeof(TT), "T must contain at least 2 TT");
            using TT_TRAIT = types_traits::Type_trait<TT>;
            static_assert(TT_TRAIT::IS_INT, "TT must be an integral type");
            static_assert(TT_TRAIT::SIZE > 1, "TT must be at least 2 bytes long");
        public:
            using ARG_TYPE = T;
            using RES_TYPE = T;
            T operator()(const T& value) const
            {
                constexpr uint8_t COUNT = sizeof(T) / sizeof(TT);
                T result = value;
                TT* ptr = reinterpret_cast<TT*>(&result);
                TT* last = ptr + COUNT;
                while (ptr < last)
                    utils::swap_bytes(*ptr++);
                return result;
            }
        };
 
        // Friends
        template<typename T, typename TT> friend class ChangeEndianness;
    };
    
    template<typename T> class Identity
    {
    public:
        using ARG_TYPE = T;
        using RES_TYPE = T;
        RES_TYPE operator()(const ARG_TYPE& value) const
        {
            return value;
        }
    };
 
    template<typename T, T VAL> class Constant
    {
    public:
        using ARG_TYPE = T;
        using RES_TYPE = T;
        RES_TYPE operator()(UNUSED const ARG_TYPE& value) const
        {
            return VAL;
        }
    };
 
    template<typename ARG, typename RES> class Cast
    {
    public:
        using ARG_TYPE = ARG;
        using RES_TYPE = RES;
        RES_TYPE operator()(const ARG_TYPE& value) const
        {
            return (RES_TYPE) value;
        }
    };
 
    template<typename F1, typename F2> class Compose
    {
    public:
        using ARG_TYPE = typename F2::ARG_TYPE;
        using RES_TYPE = typename F1::RES_TYPE;
        RES_TYPE operator()(const ARG_TYPE& value) const
        {
            F1 f1;
            F2 f2;
            return f1(f2(value));
        }
    };
 
    template<typename T, typename TT = T> class ChangeEndianness
    {
    public:
        using ARG_TYPE = T;
        using RES_TYPE = T;
        T operator()(const T& value) const
        {
            return value;
        }
    };
 
    template<typename T> class ChangeEndianness<T, int16_t> : 
        public functor_impl::ChangeEndiannessManyImpl<T, int16_t>{};
    template<typename T> class ChangeEndianness<T, uint16_t> : 
        public functor_impl::ChangeEndiannessManyImpl<T, uint16_t>{};
    template<typename T> class ChangeEndianness<T, int32_t> : 
        public functor_impl::ChangeEndiannessManyImpl<T, int32_t>{};
    template<typename T> class ChangeEndianness<T, uint32_t> : 
        public functor_impl::ChangeEndiannessManyImpl<T, uint32_t>{};
    template<typename T> class ChangeEndianness<T, int64_t> : 
        public functor_impl::ChangeEndiannessManyImpl<T, int64_t>{};
    template<typename T> class ChangeEndianness<T, uint64_t> : 
        public functor_impl::ChangeEndiannessManyImpl<T, uint64_t>{};
    
    template<> class ChangeEndianness<int16_t, int16_t> : 
        public functor_impl::ChangeEndiannessOneImpl<int16_t>{};
    template<> class ChangeEndianness<uint16_t, uint16_t> : 
        public functor_impl::ChangeEndiannessOneImpl<uint16_t>{};
    template<> class ChangeEndianness<int32_t, int32_t> : 
        public functor_impl::ChangeEndiannessOneImpl<int32_t>{};
    template<> class ChangeEndianness<uint32_t, uint32_t> : 
        public functor_impl::ChangeEndiannessOneImpl<uint32_t>{};
    template<> class ChangeEndianness<int64_t, int64_t> : 
        public functor_impl::ChangeEndiannessOneImpl<int64_t>{};
    template<> class ChangeEndianness<uint64_t, uint64_t> : 
        public functor_impl::ChangeEndiannessOneImpl<uint64_t>{};
 
    template<typename FUNCTOR> struct Functor
    {
        using ARG_TYPE = typename FUNCTOR::ARG_TYPE;
        using RES_TYPE = typename FUNCTOR::RES_TYPE;
        static RES_TYPE call(const ARG_TYPE& value)
        {
            return FUNCTOR{}(value);
        }
    };
}
 
#endif /* FUNCTORS_HH */