be_memory.h

Go to the documentation of this file.

/*
 * This software was developed at the National Institute of Standards and
 * Technology (NIST) by employees of the Federal Government in the course
 * of their official duties. Pursuant to title 17 Section 105 of the
 * United States Code, this software is not subject to copyright protection
 * and is in the public domain. NIST assumes no responsibility whatsoever for
 * its use by other parties, and makes no guarantees, expressed or implied,
 * about its quality, reliability, or any other characteristic.
 */
 
#ifndef __BE_MEMORY__
#define __BE_MEMORY__
 
#include <memory>
#include <type_traits>
 
namespace BiometricEvaluation {
        namespace Memory
        {
                template<class T>
                struct unique_if
                {
                        using unique_single = std::unique_ptr<T>;
                };
 
                template<class T>
                struct unique_if<T[]>
                {
                        using unique_array_unknown_bound = std::unique_ptr<T[]>;
                };
 
                template<class T, size_t S>
                struct unique_if<T[S]>
                {
                        using unique_array_known_bound = void;
                };
 
                template<typename T, typename... Ts>
                typename unique_if<T>::unique_single
                make_unique(Ts&&... params)
                {
                        return (std::unique_ptr<T>
                            (new T(std::forward<Ts>(params)...)));
                }
 
                template<class T>
                typename unique_if<T>::unique_array_unknown_bound
                make_unique(size_t size)
                {
                        typedef typename std::remove_extent<T>::type U;
                        return (std::unique_ptr<T>(new U[size]()));
                }
 
                template<class T, class... Ts>
                typename unique_if<T>::unique_array_known_bound
                make_unique(Ts&&...) = delete;
 
                inline bool
                isLittleEndian()
                {
                        /* Anonymous union */
                        union { uint32_t i; uint8_t c; } u;
                        u.i = 1;
 
                        /*
                         * Explore contents of octet 1 via properties of union.
                         *
                         *              i = 0x00000001
                         *
                         *              |1      |2      |3      |4
                         *              |-------|-------|-------|-------
                         * Little Endian|01     |00     |00     |00
                         *    Big Endian|00     |00     |00     |01
                         */
                        return (u.c == 1);
                }
        }
}
#endif /* __BE_MEMORY__ */