STLSoft: stlsoft/algorithms/pod.hpp Source File

00001 /* /////////////////////////////////////////////////////////////////////////
00002  * File:        stlsoft/algorithms/pod.hpp
00003  *
00004  * Purpose:     Algorithms for Plain-Old Data types.
00005  *
00006  * Created:     17th January 2002
00007  * Updated:     10th August 2009
00008  *
00009  * Home:        http://stlsoft.org/
00010  *
00011  * Copyright (c) 2002-2009, Matthew Wilson and Synesis Software
00012  * All rights reserved.
00013  *
00014  * Redistribution and use in source and binary forms, with or without
00015  * modification, are permitted provided that the following conditions are met:
00016  *
00017  * - Redistributions of source code must retain the above copyright notice, this
00018  *   list of conditions and the following disclaimer.
00019  * - Redistributions in binary form must reproduce the above copyright notice,
00020  *   this list of conditions and the following disclaimer in the documentation
00021  *   and/or other materials provided with the distribution.
00022  * - Neither the name(s) of Matthew Wilson and Synesis Software nor the names of
00023  *   any contributors may be used to endorse or promote products derived from
00024  *   this software without specific prior written permission.
00025  *
00026  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
00027  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00028  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
00029  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
00030  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
00031  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
00032  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
00033  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
00034  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
00035  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
00036  * POSSIBILITY OF SUCH DAMAGE.
00037  *
00038  * ////////////////////////////////////////////////////////////////////// */
00039 
00040 
00047 #ifndef STLSOFT_INCL_STLSOFT_ALGORITHMS_HPP_POD
00048 #define STLSOFT_INCL_STLSOFT_ALGORITHMS_HPP_POD
00049 
00050 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00051 # define STLSOFT_VER_STLSOFT_ALGORITHMS_HPP_POD_MAJOR       3
00052 # define STLSOFT_VER_STLSOFT_ALGORITHMS_HPP_POD_MINOR       5
00053 # define STLSOFT_VER_STLSOFT_ALGORITHMS_HPP_POD_REVISION    1
00054 # define STLSOFT_VER_STLSOFT_ALGORITHMS_HPP_POD_EDIT        88
00055 #endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */
00056 
00057 /* /////////////////////////////////////////////////////////////////////////
00058  * Includes
00059  */
00060 
00061 #ifndef STLSOFT_INCL_STLSOFT_H_STLSOFT
00062 # include <stlsoft/stlsoft.h>
00063 #endif /* !STLSOFT_INCL_STLSOFT_H_STLSOFT */
00064 #ifndef STLSOFT_INCL_STLSOFT_ALGORITHM_STD_HPP_ALT
00065 # include <stlsoft/algorithms/std/alt.hpp>
00066 #endif /* !STLSOFT_INCL_STLSOFT_ALGORITHM_STD_HPP_ALT */
00067 #if defined(STLSOFT_CF_TEMPLATE_PARTIAL_SPECIALISATION_SUPPORT)
00068 # ifndef STLSOFT_INCL_STLSOFT_META_HPP_BASE_TYPE_TRAITS
00069 #  include <stlsoft/meta/base_type_traits.hpp>
00070 # endif /* !STLSOFT_INCL_STLSOFT_META_HPP_BASE_TYPE_TRAITS */
00071 # ifndef STLSOFT_INCL_STLSOFT_UTIL_HPP_CONSTRAINTS
00072 #  include <stlsoft/util/constraints.hpp>
00073 # endif /* !STLSOFT_INCL_STLSOFT_UTIL_HPP_CONSTRAINTS */
00074 #endif /* STLSOFT_CF_TEMPLATE_PARTIAL_SPECIALISATION_SUPPORT */
00075 
00076 #if defined(STLSOFT_COMPILER_IS_BORLAND) || \
00077     defined(STLSOFT_COMPILER_IS_INTEL) || \
00078     defined(STLSOFT_COMPILER_IS_MSVC)
00079 # include <memory.h>                    // for memcpy
00080 #else /* ? compiler */
00081 # include <string.h>                    // for memcpy
00082 #endif /* compiler */
00083 
00084 #ifdef STLSOFT_UNITTEST
00085 # ifndef STLSOFT_INCL_STLSOFT_ERROR_HPP_EXCEPTIONS
00086 #  include <stlsoft/error/exceptions.hpp>      // for null_exception_policy
00087 # endif /* !STLSOFT_INCL_STLSOFT_ERROR_HPP_EXCEPTIONS */
00088 #endif /* STLSOFT_UNITTEST */
00089 
00090 /* /////////////////////////////////////////////////////////////////////////
00091  * Namespace
00092  */
00093 
00094 #ifndef _STLSOFT_NO_NAMESPACE
00095 namespace stlsoft
00096 {
00097 #endif /* _STLSOFT_NO_NAMESPACE */
00098 
00099 /* /////////////////////////////////////////////////////////////////////////
00100  * Algorithms
00101  */
00102 
00129 template<   ss_typename_param_k I
00130         ,   ss_typename_param_k O
00131         >
00132 // [[synesis:function:algorithm: pod_copy(T<I> *first, T<I>* last, T<O>* dest)]]
00133 inline void pod_copy(I* first, I* last, O* dest)
00134 {
00135 #if defined(STLSOFT_COMPILER_IS_BORLAND) || \
00136     defined(STLSOFT_COMPILER_IS_DMC)
00137     std_copy(&first[0], &last[0], &dest[0]);
00138 #else /* ? compiler */
00139     STLSOFT_STATIC_ASSERT(sizeof(*dest) == sizeof(*first));
00140 # if defined(STLSOFT_CF_TEMPLATE_PARTIAL_SPECIALISATION_SUPPORT)
00141         // Both must be non-pointers, or must point to POD types
00142     typedef ss_typename_type_k base_type_traits<I>::base_type   i_base_type;
00143     typedef ss_typename_type_k base_type_traits<O>::base_type   o_base_type;
00144 
00145 #  ifndef _STLSOFT_POD_COPY_ALLOW_NON_POD
00146     stlsoft_constraint_must_be_pod(i_base_type);
00147     stlsoft_constraint_must_be_pod(o_base_type);
00148 #  endif /* !_STLSOFT_POD_COPY_ALLOW_NON_POD */
00149 # endif /* STLSOFT_CF_TEMPLATE_PARTIAL_SPECIALISATION_SUPPORT */
00150 
00151     ss_size_t n = static_cast<ss_size_t>(last - first);
00152 
00153     if(0 != n)
00154     {
00155         ::memcpy(&dest[0], &first[0], n * sizeof(*first));
00156     }
00157 #endif /* compiler */
00158 }
00159 
00185 template<   ss_typename_param_k I
00186         ,   ss_typename_param_k O
00187         >
00188 // [[synesis:function:algorithm: pod_copy_n(T<O>* dest, T<I> *src, size_t n)]]
00189 inline void pod_copy_n(O *dest, I *src, ss_size_t n)
00190 {
00191 #if defined(STLSOFT_COMPILER_IS_BORLAND) || \
00192     defined(STLSOFT_COMPILER_IS_DMC)
00193     std_copy(&src[0], &src[n], &dest[0]);
00194 #else /* ? compiler */
00195     STLSOFT_STATIC_ASSERT(sizeof(*dest) == sizeof(*src));
00196 # if defined(STLSOFT_CF_TEMPLATE_PARTIAL_SPECIALISATION_SUPPORT)
00197         // Both must be non-pointers, or must point to POD types
00198     typedef ss_typename_type_k base_type_traits<I>::base_type   i_base_type;
00199     typedef ss_typename_type_k base_type_traits<O>::base_type   o_base_type;
00200 
00201 #  ifndef _STLSOFT_POD_COPY_N_ALLOW_NON_POD
00202     stlsoft_constraint_must_be_pod(i_base_type);
00203     stlsoft_constraint_must_be_pod(o_base_type);
00204 #  endif /* !_STLSOFT_POD_COPY_N_ALLOW_NON_POD */
00205 # endif /* STLSOFT_CF_TEMPLATE_PARTIAL_SPECIALISATION_SUPPORT */
00206 
00207     if(0 != n)
00208     {
00209         ::memcpy(&dest[0], &src[0], n * sizeof(*dest));
00210     }
00211 #endif /* compiler */
00212 }
00213 
00233 template<   ss_typename_param_k I
00234         ,   ss_typename_param_k O
00235         >
00236 // [[synesis:function:algorithm: pod_move(T<I>* first, T<I>* last, T<O>* dest)]]
00237 inline void pod_move(I* first, I* last, O* dest)
00238 {
00239 #if defined(STLSOFT_COMPILER_IS_BORLAND) || \
00240     defined(STLSOFT_COMPILER_IS_DMC)
00241     std_copy(&first[0], &last[0], &dest[0]);
00242 #else /* ? compiler */
00243     STLSOFT_STATIC_ASSERT(sizeof(*first) == sizeof(*dest));
00244 # if defined(STLSOFT_CF_TEMPLATE_PARTIAL_SPECIALISATION_SUPPORT)
00245         // Both must be non-pointers, or must point to POD types
00246     typedef ss_typename_type_k base_type_traits<I>::base_type   i_base_type;
00247     typedef ss_typename_type_k base_type_traits<O>::base_type   o_base_type;
00248 
00249 #  ifndef _STLSOFT_POD_MOVE_ALLOW_NON_POD
00250     stlsoft_constraint_must_be_pod(i_base_type);
00251     stlsoft_constraint_must_be_pod(o_base_type);
00252 #  endif /* !_STLSOFT_POD_MOVE_ALLOW_NON_POD */
00253 # endif /* STLSOFT_CF_TEMPLATE_PARTIAL_SPECIALISATION_SUPPORT */
00254 
00255     ss_size_t n = static_cast<ss_size_t>(last - first);
00256 
00257     if(0 != n)
00258     {
00259         ::memmove(dest, first, n * sizeof(*first));
00260     }
00261 #endif /* compiler */
00262 }
00263 
00282 template<   ss_typename_param_k I
00283         ,   ss_typename_param_k O
00284         >
00285 // [[synesis:function:algorithm: pod_move_n(T<O> *dest, T<I> *src, size_t n)]]
00286 inline void pod_move_n(O *dest, I *src, ss_size_t n)
00287 {
00288 #if defined(STLSOFT_COMPILER_IS_BORLAND) || \
00289     defined(STLSOFT_COMPILER_IS_DMC)
00290     std_copy(&src[0], &src[n], &dest[0]);
00291 #else /* ? compiler */
00292     STLSOFT_STATIC_ASSERT(sizeof(*dest) == sizeof(*src));
00293 # if defined(STLSOFT_CF_TEMPLATE_PARTIAL_SPECIALISATION_SUPPORT)
00294         // Both must be non-pointers, or must point to POD types
00295     typedef ss_typename_type_k base_type_traits<I>::base_type   i_base_type;
00296     typedef ss_typename_type_k base_type_traits<O>::base_type   o_base_type;
00297 
00298 #  ifndef _STLSOFT_POD_MOVE_N_ALLOW_NON_POD
00299     stlsoft_constraint_must_be_pod(i_base_type);
00300     stlsoft_constraint_must_be_pod(o_base_type);
00301 #  endif /* !_STLSOFT_POD_MOVE_N_ALLOW_NON_POD */
00302 # endif /* STLSOFT_CF_TEMPLATE_PARTIAL_SPECIALISATION_SUPPORT */
00303 
00304     if(0 != n)
00305     {
00306         ::memmove(&dest[0], &src[0], n * sizeof(*dest));
00307     }
00308 #endif /* compiler */
00309 }
00310 
00311 
00337 template<   ss_typename_param_k T
00338         ,   ss_typename_param_k V
00339         >
00340 // [[synesis:function:algorithm: pod_fill_n(T<T> *dest, T<V> const& value)]]
00341 inline void pod_fill_n(T *dest, ss_size_t n, V const& value)
00342 {
00343     // Constrain to POD type:
00344 # if defined(STLSOFT_CF_TEMPLATE_PARTIAL_SPECIALISATION_SUPPORT)
00345     typedef ss_typename_type_k base_type_traits<T>::base_type   base_type;
00346 
00347 #  ifndef _STLSOFT_POD_FILL_N_ALLOW_NON_POD
00348     stlsoft_constraint_must_be_pod(base_type);
00349 #  endif /* !_STLSOFT_POD_FILL_N_ALLOW_NON_POD */
00350 # endif /* STLSOFT_CF_TEMPLATE_PARTIAL_SPECIALISATION_SUPPORT */
00351 
00352     std_fill_n(dest, n, value);
00353 }
00354 
00355 #ifndef STLSOFT_DOCUMENTATION_SKIP_SECTION
00356 // [[synesis:function:algorithm: pod_fill_n(char *dest, int value)]]
00357 inline void pod_fill_n(char *dest, ss_size_t n, int value)
00358 {
00359     ::memset(dest, value, n);
00360 }
00361 // [[synesis:function:algorithm: pod_fill_n(signed char *dest, int value)]]
00362 inline void pod_fill_n(signed char *dest, ss_size_t n, int value)
00363 {
00364     ::memset(dest, value, n);
00365 }
00366 // [[synesis:function:algorithm: pod_fill_n(unsigned char *dest, int value)]]
00367 inline void pod_fill_n(unsigned char *dest, ss_size_t n, int value)
00368 {
00369     ::memset(dest, value, n);
00370 }
00371 #endif /* !STLSOFT_DOCUMENTATION_SKIP_SECTION */
00372 
00374 // Unit-testing
00375 
00376 #ifdef STLSOFT_UNITTEST
00377 # include "./unittest/pod_unittest_.h"
00378 #endif /* STLSOFT_UNITTEST */
00379 
00380 /* ////////////////////////////////////////////////////////////////////// */
00381 
00382 #ifndef _STLSOFT_NO_NAMESPACE
00383 } // namespace stlsoft
00384 #endif /* _STLSOFT_NO_NAMESPACE */
00385 
00386 /* ////////////////////////////////////////////////////////////////////// */
00387 
00388 #endif /* !STLSOFT_INCL_STLSOFT_ALGORITHMS_HPP_POD */
00389 
00390 /* ///////////////////////////// end of file //////////////////////////// */