be_memory_autoarrayutility.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_AUTOARRAYUTILITY_H__
#define __BE_MEMORY_AUTOARRAYUTILITY_H__
 
#include <cstdarg>
#include <cstdio>
#include <string>
#include <type_traits>
 
#include <be_error_exception.h>
#include <be_memory_autoarray.h>
 
namespace BiometricEvaluation
{
        namespace Memory
        {
                namespace AutoArrayUtility
                {
                        template <typename T, typename = typename
                            std::enable_if<std::is_same<T, uint8_t>::value ||
                            std::is_same<T, char>::value>::type>
                        inline char *
                        cstr(
                            const AutoArray<T> &rahc)
                        {
                                return ((char *)&(*rahc));
                        }
 
                        template <typename T, typename = typename
                            std::enable_if<std::is_same<T, uint8_t>::value ||
                            std::is_same<T, char>::value>::type>
                        inline std::string
                        getString(
                            const AutoArray<T> &aa,
                            typename AutoArray<T>::size_type count)
                        {
                                if (count > aa.size())
                                        throw Error::MemoryError();
 
                                return (std::string(cstr(aa), count));
                        }
 
                        template <typename T, typename = typename
                            std::enable_if<std::is_same<T, uint8_t>::value ||
                            std::is_same<T, char>::value>::type>
                        inline void
                        setString(
                            AutoArray<T> &aa,
                            const std::string &str)
                        {
                                aa.resize(str.size() + 1);
                                ::snprintf(cstr(aa), aa.size(), "%s",
                                    str.c_str());
                        }
 
                        template <typename T, typename = typename
                            std::enable_if<std::is_same<T, uint8_t>::value ||
                            std::is_same<T, char>::value>::type>
                        inline void
                        setString(
                            AutoArray<T> &aa,
                            const char *str,
                            ...)
                        {
                                aa.resize(strlen(str) + 1);
 
                                va_list args;
                                va_start(args, str);
                                ::vsnprintf(cstr(aa), aa.size(), str, args);
                                va_end(args);
                        }
                }
        }
}
 
template <typename T, typename = typename
    std::enable_if<std::is_same<T, uint8_t>::value ||
    std::is_same<T, char>::value>::type>
inline std::string
to_string(
    const BiometricEvaluation::Memory::AutoArray<T> &aa)
{
        return (std::string(
            BiometricEvaluation::Memory::AutoArrayUtility::cstr(aa),
            aa.size() - 1));
}
 
#endif /* __BE_MEMORY_AUTOARRAYUTILITY_H__ */