Remove gil_config.hpp as unnecessary

Move BOOST_GIL_CONFIG_HAS_UNALIGNED_ACCESS define setting and
documentation comment to channel.hpp where solely used.

Trim trailing whitespaces.

include/boost/gil.hpp

@@ -9,7 +9,6 @@
 #define boost_gil_hpp_
 
 #include <boost/gil/version.hpp>
-#include <boost/gil/gil_config.hpp>
 #include <boost/gil/channel_algorithm.hpp>
 #include <boost/gil/algorithm.hpp>
 #include <boost/gil/pixel.hpp>

include/boost/gil/algorithm.hpp

@@ -26,7 +26,6 @@
 #include <boost/mpl/and.hpp>
 #include <boost/mpl/or.hpp>
 
-#include "gil_config.hpp"
 #include "gil_concept.hpp"
 #include "color_base_algorithm.hpp"
 #include "image_view.hpp"

include/boost/gil/bit_aligned_pixel_iterator.hpp

@@ -27,7 +27,6 @@
 #include <boost/config.hpp>
 #include <boost/iterator/iterator_facade.hpp>
 
-#include "gil_config.hpp"
 #include "bit_aligned_pixel_reference.hpp"
 #include "pixel_iterator.hpp"
 

include/boost/gil/bit_aligned_pixel_reference.hpp

@@ -33,7 +33,6 @@
 #include <boost/mpl/push_back.hpp>
 #include <boost/mpl/vector.hpp>
 
-#include "gil_config.hpp"
 #include "pixel.hpp"
 #include "channel.hpp"
 

include/boost/gil/channel.hpp

@@ -1,6 +1,6 @@
 /*
     Copyright 2005-2007 Adobe Systems Incorporated
-   
+
     Use, modification and distribution are subject to the Boost Software License,
     Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
     http://www.boost.org/LICENSE_1_0.txt).
@@ -14,7 +14,7 @@
 #define GIL_CHANNEL_HPP
 
 ////////////////////////////////////////////////////////////////////////////////////////
-/// \file               
+/// \file
 /// \brief Channel utilities
 /// \author Lubomir Bourdev and Hailin Jin \n
 ///         Adobe Systems Incorporated
@@ -24,41 +24,71 @@
 ///
 ////////////////////////////////////////////////////////////////////////////////////////
 
+#include "utilities.hpp"
+
+#include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+#include <boost/integer/integer_mask.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+
 #include <limits>
 #include <cassert>
 #include <cstdint>
 
-#include <boost/config.hpp>
-#include <boost/integer/integer_mask.hpp>
-#include <boost/type_traits/remove_cv.hpp>
-
-#include "gil_config.hpp"
-#include "utilities.hpp"
+#if defined(BOOST_GIL_DOXYGEN_ONLY)
+/// \def BOOST_GIL_CONFIG_HAS_UNALIGNED_ACCESS
+/// \brief Define to allow unaligned memory access for models of packed channel value.
+/// Theoretically (or historically?) on platforms which support dereferencing on
+/// non-word memory boundary, unaligned access may result in performance improvement.
+/// \warning Unfortunately, this optimization may be a C/C++ strict aliasing rules
+/// violation, if accessed data buffer has effective type that cannot be aliased
+/// without leading to undefined behaviour.
+#define BOOST_GIL_CONFIG_HAS_UNALIGNED_ACCESS
+#endif
 
+#if defined(BOOST_GIL_CONFIG_HAS_UNALIGNED_ACCESS)
+#if defined(sun) || defined(__sun) || \             // SunOS
+    defined(__osf__) || defined(__osf) || \         // Tru64
+    defined(_hpux) || defined(hpux) || \            // HP-UX
+    defined(__arm__) || defined(__ARM_ARCH) || \    // ARM
+    defined(_AIX)                                   // AIX
+#error Unaligned access strictly disabled for some UNIX platforms or ARM architecture
+#elif defined(__i386__) || defined(__x86_64__) || defined(__vax__)
+    // The check for little-endian architectures that tolerate unaligned memory
+    // accesses is just an optimization. Nothing will break if it fails to detect
+    // a suitable architecture.
+    //
+    // Unfortunately, this optimization may be a C/C++ strict aliasing rules violation
+    // if accessed data buffer has effective type that cannot be aliased
+    // without leading to undefined behaviour.
+BOOST_PRAGMA_MESSAGE("CAUTION: Unaligned access tolerated on little-endian may cause undefined behaviour")
+#else
+#error Unaligned access disabled for unknown platforms and architectures
+#endif
+#endif // defined(BOOST_GIL_CONFIG_HAS_UNALIGNED_ACCESS)
 
 namespace boost { namespace gil {
 
-
 ///////////////////////////////////////////
 ////  channel_traits
-////  
+////
 ////  \ingroup ChannelModel
 ////  \class channel_traits
 ////  \brief defines properties of channels, such as their range and associated types
 ////
 ////  The channel traits must be defined for every model of ChannelConcept
 ////  Default traits are provided. For built-in types the default traits use
-////  built-in pointer and reference and the channel range is the physical 
+////  built-in pointer and reference and the channel range is the physical
 ////  range of the type. For classes, the default traits forward the associated types
 ////  and range to the class.
-//// 
+////
 ///////////////////////////////////////////
 
 namespace detail {
     template <typename T, bool is_class> struct channel_traits_impl;
 
     // channel traits for custom class
-    template <typename T> 
+    template <typename T>
     struct channel_traits_impl<T, true> {
         typedef typename T::value_type      value_type;
         typedef typename T::reference       reference;
@@ -71,7 +101,7 @@ namespace detail {
     };
 
     // channel traits implementation for built-in integral or floating point channel type
-    template <typename T> 
+    template <typename T>
     struct channel_traits_impl<T, false> {
         typedef T           value_type;
         typedef T&          reference;
@@ -84,7 +114,7 @@ namespace detail {
     };
 
     // channel traits implementation for constant built-in scalar or floating point type
-    template <typename T> 
+    template <typename T>
     struct channel_traits_impl<const T, false> : public channel_traits_impl<T, false> {
         typedef const T&    reference;
         typedef const T*    pointer;
@@ -103,7 +133,7 @@ struct channel_traits {
     typedef ... pointer;
     typedef ... const_reference;
     typedef ... const_pointer;
-    
+
     static const bool is_mutable;
     static value_type min_value();
     static value_type max_value();
@@ -212,12 +242,12 @@ struct float_point_one
 namespace detail {
     // returns the smallest fast unsigned integral type that has at least NumBits bits
     template <int NumBits>
-    struct min_fast_uint : public mpl::if_c< (NumBits<=8), 
-            uint_least8_t, 
-            typename mpl::if_c< (NumBits<=16), 
-                    uint_least16_t, 
-                    typename mpl::if_c< (NumBits<=32), 
-                            uint_least32_t, 
+    struct min_fast_uint : public mpl::if_c< (NumBits<=8),
+            uint_least8_t,
+            typename mpl::if_c< (NumBits<=16),
+                    uint_least16_t,
+                    typename mpl::if_c< (NumBits<=32),
+                            uint_least32_t,
                             uintmax_t
                     >::type
             >::type
@@ -340,10 +370,10 @@ protected:
 
     typedef  typename detail::num_value_fn< NumBits >::type num_value_t;
     typedef  typename detail::max_value_fn< NumBits >::type max_value_t;
-    
+
     static const num_value_t num_values = static_cast< num_value_t >( 1 ) << NumBits ;
     static const max_value_t max_val    = static_cast< max_value_t >( num_values - 1 );
-    
+
 #if defined(BOOST_GIL_CONFIG_HAS_UNALIGNED_ACCESS)
     const bitfield_t& get_data()                      const { return *static_cast<const bitfield_t*>(_data_ptr); }
     void              set_data(const bitfield_t& val) const {        *static_cast<      bitfield_t*>(_data_ptr) = val; }
@@ -360,7 +390,7 @@ protected:
 
 private:
     void set(integer_t value) const {     // can this be done faster??
-        this->derived().set_unsafe(((value % num_values) + num_values) % num_values); 
+        this->derived().set_unsafe(((value % num_values) + num_values) % num_values);
     }
     integer_t get() const { return derived().get(); }
     const Derived& derived() const { return static_cast<const Derived&>(*this); }
@@ -384,19 +414,19 @@ assert(data == 6);                                          // == 3<<1 == 6
 */
 
 template <typename BitField,        // A type that holds the bits of the pixel from which the channel is referenced. Typically an integral type, like std::uint16_t
-          int FirstBit, int NumBits,// Defines the sequence of bits in the data value that contain the channel 
-          bool Mutable>             // true if the reference is mutable 
+          int FirstBit, int NumBits,// Defines the sequence of bits in the data value that contain the channel
+          bool Mutable>             // true if the reference is mutable
 class packed_channel_reference;
 
 template <typename BitField,        // A type that holds the bits of the pixel from which the channel is referenced. Typically an integral type, like std::uint16_t
-          int NumBits,              // Defines the sequence of bits in the data value that contain the channel 
-          bool Mutable>             // true if the reference is mutable 
+          int NumBits,              // Defines the sequence of bits in the data value that contain the channel
+          bool Mutable>             // true if the reference is mutable
 class packed_dynamic_channel_reference;
 
 /// \ingroup PackedChannelReferenceModel
 /// \brief A constant subbyte channel reference whose bit offset is fixed at compile time. Models ChannelConcept
 template <typename BitField, int FirstBit, int NumBits>
-class packed_channel_reference<BitField,FirstBit,NumBits,false> 
+class packed_channel_reference<BitField,FirstBit,NumBits,false>
    : public detail::packed_channel_reference_base<packed_channel_reference<BitField,FirstBit,NumBits,false>,BitField,NumBits,false> {
     typedef detail::packed_channel_reference_base<packed_channel_reference<BitField,FirstBit,NumBits,false>,BitField,NumBits,false> parent_t;
     friend class packed_channel_reference<BitField,FirstBit,NumBits,true>;
@@ -421,7 +451,7 @@ public:
 /// \ingroup PackedChannelReferenceModel
 /// \brief A mutable subbyte channel reference whose bit offset is fixed at compile time. Models ChannelConcept
 template <typename BitField, int FirstBit, int NumBits>
-class packed_channel_reference<BitField,FirstBit,NumBits,true> 
+class packed_channel_reference<BitField,FirstBit,NumBits,true>
    : public detail::packed_channel_reference_base<packed_channel_reference<BitField,FirstBit,NumBits,true>,BitField,NumBits,true> {
     typedef detail::packed_channel_reference_base<packed_channel_reference<BitField,FirstBit,NumBits,true>,BitField,NumBits,true> parent_t;
     friend class packed_channel_reference<BitField,FirstBit,NumBits,false>;
@@ -455,7 +485,7 @@ private:
 
 namespace std {
 // We are forced to define swap inside std namespace because on some platforms (Visual Studio 8) STL calls swap qualified.
-// swap with 'left bias': 
+// swap with 'left bias':
 // - swap between proxy and anything
 // - swap between value type and proxy
 // - swap between proxy and proxy
@@ -463,24 +493,23 @@ namespace std {
 /// \ingroup PackedChannelReferenceModel
 /// \brief swap for packed_channel_reference
 template <typename BF, int FB, int NB, bool M, typename R> inline
-void swap(const boost::gil::packed_channel_reference<BF,FB,NB,M> x, R& y) { 
-    boost::gil::swap_proxy<typename boost::gil::packed_channel_reference<BF,FB,NB,M>::value_type>(x,y); 
+void swap(const boost::gil::packed_channel_reference<BF,FB,NB,M> x, R& y) {
+    boost::gil::swap_proxy<typename boost::gil::packed_channel_reference<BF,FB,NB,M>::value_type>(x,y);
 }
 
 
 /// \ingroup PackedChannelReferenceModel
 /// \brief swap for packed_channel_reference
 template <typename BF, int FB, int NB, bool M> inline
-void swap(typename boost::gil::packed_channel_reference<BF,FB,NB,M>::value_type& x, const boost::gil::packed_channel_reference<BF,FB,NB,M> y) { 
-    boost::gil::swap_proxy<typename boost::gil::packed_channel_reference<BF,FB,NB,M>::value_type>(x,y); 
+void swap(typename boost::gil::packed_channel_reference<BF,FB,NB,M>::value_type& x, const boost::gil::packed_channel_reference<BF,FB,NB,M> y) {
+    boost::gil::swap_proxy<typename boost::gil::packed_channel_reference<BF,FB,NB,M>::value_type>(x,y);
 }
 
-
 /// \ingroup PackedChannelReferenceModel
 /// \brief swap for packed_channel_reference
 template <typename BF, int FB, int NB, bool M> inline
-void swap(const boost::gil::packed_channel_reference<BF,FB,NB,M> x, const boost::gil::packed_channel_reference<BF,FB,NB,M> y) { 
-    boost::gil::swap_proxy<typename boost::gil::packed_channel_reference<BF,FB,NB,M>::value_type>(x,y); 
+void swap(const boost::gil::packed_channel_reference<BF,FB,NB,M> x, const boost::gil::packed_channel_reference<BF,FB,NB,M> y) {
+    boost::gil::swap_proxy<typename boost::gil::packed_channel_reference<BF,FB,NB,M>::value_type>(x,y);
 }
 }   // namespace std
 
@@ -506,7 +535,7 @@ assert(data == 6);                                                  // == (3<<1)
 /// \brief Models a constant subbyte channel reference whose bit offset is a runtime parameter. Models ChannelConcept
 ///        Same as packed_channel_reference, except that the offset is a runtime parameter
 /// \ingroup PackedChannelDynamicReferenceModel
-template <typename BitField, int NumBits> 
+template <typename BitField, int NumBits>
 class packed_dynamic_channel_reference<BitField,NumBits,false>
    : public detail::packed_channel_reference_base<packed_dynamic_channel_reference<BitField,NumBits,false>,BitField,NumBits,false> {
     typedef detail::packed_channel_reference_base<packed_dynamic_channel_reference<BitField,NumBits,false>,BitField,NumBits,false> parent_t;
@@ -526,7 +555,7 @@ public:
 
     unsigned first_bit() const { return _first_bit; }
 
-    integer_t get() const { 
+    integer_t get() const {
         const BitField channel_mask = static_cast< integer_t >( parent_t::max_val ) <<_first_bit;
         return static_cast< integer_t >(( this->get_data()&channel_mask ) >> _first_bit );
     }
@@ -535,7 +564,7 @@ public:
 /// \brief Models a mutable subbyte channel reference whose bit offset is a runtime parameter. Models ChannelConcept
 ///        Same as packed_channel_reference, except that the offset is a runtime parameter
 /// \ingroup PackedChannelDynamicReferenceModel
-template <typename BitField, int NumBits> 
+template <typename BitField, int NumBits>
 class packed_dynamic_channel_reference<BitField,NumBits,true>
    : public detail::packed_channel_reference_base<packed_dynamic_channel_reference<BitField,NumBits,true>,BitField,NumBits,true> {
     typedef detail::packed_channel_reference_base<packed_dynamic_channel_reference<BitField,NumBits,true>,BitField,NumBits,true> parent_t;
@@ -556,26 +585,26 @@ public:
     const packed_dynamic_channel_reference& operator=(const const_reference&   ref) const {  set_unsafe(ref.get()); return *this; }
 
     template <typename BitField1, int FirstBit1, bool Mutable1>
-    const packed_dynamic_channel_reference& operator=(const packed_channel_reference<BitField1, FirstBit1, NumBits, Mutable1>& ref) const 
+    const packed_dynamic_channel_reference& operator=(const packed_channel_reference<BitField1, FirstBit1, NumBits, Mutable1>& ref) const
         {  set_unsafe(ref.get()); return *this; }
 
     unsigned first_bit() const { return _first_bit; }
 
-    integer_t get() const { 
+    integer_t get() const {
         const BitField channel_mask = static_cast< integer_t >( parent_t::max_val ) << _first_bit;
         return static_cast< integer_t >(( this->get_data()&channel_mask ) >> _first_bit );
     }
 
-    void set_unsafe(integer_t value) const { 
+    void set_unsafe(integer_t value) const {
         const BitField channel_mask = static_cast< integer_t >( parent_t::max_val ) << _first_bit;
-        this->set_data((this->get_data() & ~channel_mask) | value<<_first_bit); 
+        this->set_data((this->get_data() & ~channel_mask) | value<<_first_bit);
     }
 };
 } }  // namespace boost::gil
 
 namespace std {
 // We are forced to define swap inside std namespace because on some platforms (Visual Studio 8) STL calls swap qualified.
-// swap with 'left bias': 
+// swap with 'left bias':
 // - swap between proxy and anything
 // - swap between value type and proxy
 // - swap between proxy and proxy
@@ -584,24 +613,23 @@ namespace std {
 /// \ingroup PackedChannelDynamicReferenceModel
 /// \brief swap for packed_dynamic_channel_reference
 template <typename BF, int NB, bool M, typename R> inline
-void swap(const boost::gil::packed_dynamic_channel_reference<BF,NB,M> x, R& y) { 
-    boost::gil::swap_proxy<typename boost::gil::packed_dynamic_channel_reference<BF,NB,M>::value_type>(x,y); 
+void swap(const boost::gil::packed_dynamic_channel_reference<BF,NB,M> x, R& y) {
+    boost::gil::swap_proxy<typename boost::gil::packed_dynamic_channel_reference<BF,NB,M>::value_type>(x,y);
 }
 
 
 /// \ingroup PackedChannelDynamicReferenceModel
 /// \brief swap for packed_dynamic_channel_reference
 template <typename BF, int NB, bool M> inline
-void swap(typename boost::gil::packed_dynamic_channel_reference<BF,NB,M>::value_type& x, const boost::gil::packed_dynamic_channel_reference<BF,NB,M> y) { 
-    boost::gil::swap_proxy<typename boost::gil::packed_dynamic_channel_reference<BF,NB,M>::value_type>(x,y); 
+void swap(typename boost::gil::packed_dynamic_channel_reference<BF,NB,M>::value_type& x, const boost::gil::packed_dynamic_channel_reference<BF,NB,M> y) {
+    boost::gil::swap_proxy<typename boost::gil::packed_dynamic_channel_reference<BF,NB,M>::value_type>(x,y);
 }
 
-
 /// \ingroup PackedChannelDynamicReferenceModel
 /// \brief swap for packed_dynamic_channel_reference
 template <typename BF, int NB, bool M> inline
-void swap(const boost::gil::packed_dynamic_channel_reference<BF,NB,M> x, const boost::gil::packed_dynamic_channel_reference<BF,NB,M> y) { 
-    boost::gil::swap_proxy<typename boost::gil::packed_dynamic_channel_reference<BF,NB,M>::value_type>(x,y); 
+void swap(const boost::gil::packed_dynamic_channel_reference<BF,NB,M> x, const boost::gil::packed_dynamic_channel_reference<BF,NB,M> y) {
+    boost::gil::swap_proxy<typename boost::gil::packed_dynamic_channel_reference<BF,NB,M>::value_type>(x,y);
 }
 }   // namespace std
 
@@ -616,7 +644,7 @@ struct is_integral<gil::packed_channel_reference<BitField,FirstBit,NumBits,IsMut
 template <typename BitField, int NumBits, bool IsMutable>
 struct is_integral<gil::packed_dynamic_channel_reference<BitField,NumBits,IsMutable> > : public mpl::true_ {};
 
-template <typename BaseChannelValue, typename MinVal, typename MaxVal> 
+template <typename BaseChannelValue, typename MinVal, typename MaxVal>
 struct is_integral<gil::scoped_channel_value<BaseChannelValue,MinVal,MaxVal> > : public is_integral<BaseChannelValue> {};
 
 } // namespace boost

include/boost/gil/channel_algorithm.hpp

@@ -29,7 +29,6 @@
 #include <boost/mpl/greater.hpp>
 #include <boost/type_traits.hpp>
 
-#include "gil_config.hpp"
 #include "channel.hpp"
 #include "promote_integral.hpp"
 #include "typedefs.hpp"

include/boost/gil/cmyk.hpp

@@ -27,7 +27,6 @@
 #include <boost/mpl/range_c.hpp>
 #include <boost/mpl/vector_c.hpp>
 
-#include "gil_config.hpp"
 #include "metafunctions.hpp"
 
 namespace boost { namespace gil {

include/boost/gil/color_base.hpp

@@ -31,7 +31,6 @@
 #include <boost/type_traits.hpp>
 #include <boost/utility/enable_if.hpp>
 
-#include "gil_config.hpp"
 #include "utilities.hpp"
 #include "gil_concept.hpp"
 

include/boost/gil/color_base_algorithm.hpp

@@ -30,7 +30,6 @@
 #include <boost/mpl/contains.hpp>
 #include <boost/mpl/at.hpp>
 
-#include "gil_config.hpp"
 #include "gil_concept.hpp"
 #include "utilities.hpp"
 

include/boost/gil/color_convert.hpp

@@ -28,7 +28,6 @@
 
 #include <boost/config.hpp>
 
-#include "gil_config.hpp"
 #include "channel_algorithm.hpp"
 #include "pixel.hpp"
 #include "gray.hpp"

include/boost/gil/device_n.hpp

@@ -28,7 +28,6 @@
 #include <boost/mpl/range_c.hpp>
 #include <boost/mpl/vector_c.hpp>
 
-#include "gil_config.hpp"
 #include "utilities.hpp"
 #include "metafunctions.hpp"
 

include/boost/gil/extension/dynamic_image/apply_operation_base.hpp

@@ -13,7 +13,6 @@
 #ifndef GIL_APPLY_OPERATION_BASE_HPP
 #define GIL_APPLY_OPERATION_BASE_HPP
 
-#include "../../gil_config.hpp"
 #include "../../utilities.hpp"
 #include <boost/mpl/begin.hpp>
 #include <boost/mpl/next.hpp>

include/boost/gil/extension/dynamic_image/dynamic_at_c.hpp

@@ -13,7 +13,6 @@
 #ifndef GIL_DYNAMIC_AT_C_HPP
 #define GIL_DYNAMIC_AT_C_HPP
 
-#include "../../gil_config.hpp"
 #include <cassert>
 #include <stdexcept>
 #include <boost/mpl/at.hpp>

include/boost/gil/extension/dynamic_image/variant.hpp

@@ -22,7 +22,6 @@
 ///
 ////////////////////////////////////////////////////////////////////////////////////////
 
-#include "../../gil_config.hpp"
 #include "../../utilities.hpp"
 #include <cstddef>
 #include <cassert>

include/boost/gil/extension/numeric/algorithm.hpp

@@ -24,7 +24,6 @@
 #include <algorithm>
 #include <numeric>
 
-#include <boost/gil/gil_config.hpp>
 #include <boost/gil/pixel_iterator.hpp>
 #include <boost/gil/metafunctions.hpp>
 

include/boost/gil/extension/numeric/channel_numeric_operations.hpp

@@ -27,9 +27,6 @@
 
 #include <functional>
 
-#include <boost/gil/gil_config.hpp>
-#include <boost/gil/channel.hpp>
-
 namespace boost { namespace gil {
 
 /// \ingroup ChannelNumericOperations

include/boost/gil/extension/numeric/convolve.hpp

@@ -27,7 +27,6 @@
 #include <vector>
 #include <functional>
 
-#include <boost/gil/gil_config.hpp>
 #include <boost/gil/image_view_factory.hpp>
 #include <boost/gil/algorithm.hpp>
 #include <boost/gil/metafunctions.hpp>

include/boost/gil/extension/numeric/kernel.hpp

@@ -26,7 +26,6 @@
 #include <vector>
 #include <memory>
 
-#include <boost/gil/gil_config.hpp>
 #include <boost/gil/utilities.hpp>
 
 namespace boost { namespace gil {

include/boost/gil/extension/numeric/pixel_numeric_operations.hpp

@@ -26,7 +26,6 @@
 
 #include <functional>
 
-#include <boost/gil/gil_config.hpp>
 #include <boost/gil/pixel.hpp>
 #include <boost/gil/color_base_algorithm.hpp>
 

include/boost/gil/extension/toolbox/color_spaces/gray_alpha.hpp

@@ -21,7 +21,6 @@
 
 #include <boost/mpl/contains.hpp>
 
-#include <boost/gil/gil_config.hpp>
 #include <boost/gil/color_convert.hpp>
 #include <boost/gil/gray.hpp>
 #include <boost/gil/typedefs.hpp>

include/boost/gil/extension/toolbox/dynamic_images.hpp

@@ -23,7 +23,6 @@
 
 #include <boost/mpl/at.hpp>
 #include <boost/mpl/size.hpp>
-#include <boost/gil/gil_config.hpp>
 #include <boost/gil/extension/dynamic_image/dynamic_image_all.hpp>
 
 namespace boost { namespace gil {

include/boost/gil/gil_all.hpp

@@ -22,7 +22,6 @@
 ///
 ////////////////////////////////////////////////////////////////////////////////////////
 
-#include "gil_config.hpp"
 #include "channel_algorithm.hpp"
 #include "algorithm.hpp"
 #include "pixel.hpp"

include/boost/gil/gil_concept.hpp

@@ -34,8 +34,6 @@
 #include <iterator>
 #include <utility>
 
-#include "gil_config.hpp"
-
 namespace boost { namespace gil {
 
 #if defined(__GNUC__) && (__GNUC__ >= 4)

include/boost/gil/gil_config.hpp

@@ -1,60 +0,0 @@
-/*
-    Copyright 2005-2007 Adobe Systems Incorporated
-    Copyright 2018 Mateusz Loskot <mateusz at loskot dot net>
-
-    Use, modification and distribution are subject to the Boost Software License,
-    Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
-    http://www.boost.org/LICENSE_1_0.txt).
-
-    See http://opensource.adobe.com/gil for most recent version including documentation.
-*/
-
-/*************************************************************************************************/
-
-#ifndef GIL_CONFIG_HPP
-#define GIL_CONFIG_HPP
-
-////////////////////////////////////////////////////////////////////////////////////////
-/// \file
-/// \brief GIL configuration file
-/// \author Lubomir Bourdev and Hailin Jin \n
-///         Adobe Systems Incorporated
-///
-////////////////////////////////////////////////////////////////////////////////////////
-
-#include <boost/config.hpp>
-#include <boost/config/pragma_message.hpp>
-
-#if defined(BOOST_GIL_DOXYGEN_ONLY)
-/// \def BOOST_GIL_CONFIG_HAS_UNALIGNED_ACCESS
-/// \brief Define to allow unaligned memory access
-/// Theoretically (or historically?) on platforms which support dereferencing on
-/// non-word memory boundary, unaligned access may result in performance improvement.
-/// \warning Unfortunately, this optimization may be a C/C++ strict aliasing rules
-/// violation, if accessed data buffer has effective type that cannot be aliased
-/// without leading to undefined behaviour.
-#define BOOST_GIL_CONFIG_HAS_UNALIGNED_ACCESS
-#endif
-
-#if defined(BOOST_GIL_CONFIG_HAS_UNALIGNED_ACCESS)
-#if defined(sun) || defined(__sun) || \             // SunOS
-    defined(__osf__) || defined(__osf) || \         // Tru64
-    defined(_hpux) || defined(hpux) || \            // HP-UX
-    defined(__arm__) || defined(__ARM_ARCH) || \    // ARM
-    defined(_AIX)                                   // AIX
-#error Unaligned access strictly disabled for some UNIX platforms or ARM architecture
-#elif defined(__i386__) || defined(__x86_64__) || defined(__vax__)
-    // The check for little-endian architectures that tolerate unaligned memory
-    // accesses is just an optimization. Nothing will break if it fails to detect
-    // a suitable architecture.
-    //
-    // Unfortunately, this optimization may be a C/C++ strict aliasing rules violation
-    // if accessed data buffer has effective type that cannot be aliased
-    // without leading to undefined behaviour.
-BOOST_PRAGMA_MESSAGE("CAUTION: Unaligned access tolerated on little-endian may cause undefined behaviour")
-#else
-#error Unaligned access disabled for unknown platforms and architectures
-#endif
-#endif // defined(BOOST_GIL_CONFIG_HAS_UNALIGNED_ACCESS)
-
-#endif

include/boost/gil/gray.hpp

@@ -21,7 +21,6 @@
 /// \date 2005-2007 \n Last updated on March 8, 2006
 ////////////////////////////////////////////////////////////////////////////////////////
 
-#include "gil_config.hpp"
 #include "utilities.hpp"
 #include <boost/type_traits.hpp>
 #include <boost/mpl/range_c.hpp>

include/boost/gil/image.hpp

@@ -29,7 +29,6 @@
 #include <boost/mpl/arithmetic.hpp>
 
 
-#include "gil_config.hpp"
 #include "image_view.hpp"
 #include "metafunctions.hpp"
 #include "algorithm.hpp"

include/boost/gil/image_view.hpp

@@ -23,7 +23,6 @@
 
 #include <cstddef>
 #include <iterator>
-#include "gil_config.hpp"
 #include "iterator_from_2d.hpp"
 
 //#ifdef _MSC_VER

include/boost/gil/image_view_factory.hpp

@@ -26,7 +26,6 @@
 
 #include <cassert>
 #include <cstddef>
-#include "gil_config.hpp"
 #include "metafunctions.hpp"
 #include "gray.hpp"
 #include "color_convert.hpp"

include/boost/gil/io/dynamic_io_new.hpp

@@ -21,7 +21,6 @@
 
 #include <boost/mpl/at.hpp>
 #include <boost/mpl/size.hpp>
-#include <boost/gil/gil_config.hpp>
 #include <boost/gil/io/error.hpp>
 #include <boost/gil/extension/dynamic_image/dynamic_image_all.hpp>
 

include/boost/gil/iterator_from_2d.hpp

@@ -24,7 +24,6 @@
 #include <cassert>
 #include <boost/iterator/iterator_facade.hpp>
 #include "gil_concept.hpp"
-#include "gil_config.hpp"
 #include "pixel_iterator.hpp"
 #include "locator.hpp"
 

include/boost/gil/metafunctions.hpp

@@ -34,7 +34,6 @@
 #include <boost/mpl/vector.hpp>
 #include <boost/mpl/vector_c.hpp>
 #include <boost/type_traits.hpp>
-#include "gil_config.hpp"
 #include "gil_concept.hpp"
 #include "channel.hpp"
 

include/boost/gil/packed_pixel.hpp

@@ -27,7 +27,6 @@
 #include <boost/utility/enable_if.hpp>
 #include <boost/mpl/bool.hpp>
 #include <boost/mpl/front.hpp>
-#include "gil_config.hpp"
 #include "pixel.hpp"
 
 namespace boost { namespace gil {

include/boost/gil/pixel.hpp

@@ -27,7 +27,6 @@
 #include <boost/mpl/bool.hpp>
 #include <boost/mpl/front.hpp>
 #include <boost/type_traits.hpp>
-#include "gil_config.hpp"
 #include "color_base.hpp"
 #include "gil_concept.hpp"
 #include "channel.hpp"

include/boost/gil/pixel_iterator.hpp

@@ -24,7 +24,6 @@
 
 #include <cassert>
 #include <iterator>
-#include "gil_config.hpp"
 #include "gil_concept.hpp"
 #include "utilities.hpp"
 #include "pixel.hpp"

include/boost/gil/pixel_iterator_adaptor.hpp

@@ -24,7 +24,6 @@
 
 #include <iterator>
 #include <boost/iterator/iterator_facade.hpp>
-#include "gil_config.hpp"
 #include "gil_concept.hpp"
 #include "pixel_iterator.hpp"
 

include/boost/gil/planar_pixel_iterator.hpp

@@ -25,7 +25,6 @@
 #include <cassert>
 #include <iterator>
 #include <boost/iterator/iterator_facade.hpp>
-#include "gil_config.hpp"
 #include "pixel.hpp"
 #include "step_iterator.hpp"
 

include/boost/gil/planar_pixel_reference.hpp

@@ -23,7 +23,6 @@
 ////////////////////////////////////////////////////////////////////////////////////////
 
 #include <boost/mpl/range_c.hpp>
-#include "gil_config.hpp"
 #include "gil_concept.hpp"
 #include "color_base.hpp"
 #include "channel.hpp"

include/boost/gil/rgb.hpp

@@ -24,7 +24,6 @@
 #include <cstddef>
 #include <boost/mpl/range_c.hpp>
 #include <boost/mpl/vector_c.hpp>
-#include "gil_config.hpp"
 #include "metafunctions.hpp"
 #include "planar_pixel_iterator.hpp"
 

include/boost/gil/rgba.hpp

@@ -21,7 +21,6 @@
 ////////////////////////////////////////////////////////////////////////////////////////
 
 #include <cstddef>
-#include "gil_config.hpp"
 #include <boost/mpl/contains.hpp>
 #include "rgb.hpp"
 #include "planar_pixel_iterator.hpp"

include/boost/gil/step_iterator.hpp

@@ -25,7 +25,6 @@
 #include <cstddef>
 #include <iterator>
 #include <boost/iterator/iterator_facade.hpp>
-#include "gil_config.hpp"
 #include "utilities.hpp"
 #include "pixel_iterator.hpp"
 #include "pixel_iterator_adaptor.hpp"

include/boost/gil/typedefs.hpp

@@ -14,8 +14,6 @@
 /// \author Lubomir Bourdev and Hailin Jin \n
 ///         Adobe Systems Incorporated
 
-#include "gil_config.hpp"
-
 #include <cstdint>
 #include <memory>
 

include/boost/gil/utilities.hpp

@@ -13,7 +13,6 @@
 #ifndef GIL_UTILITIES_H
 #define GIL_UTILITIES_H
 
-#include "gil_config.hpp"
 #include <functional>
 #include <boost/config/no_tr1/cmath.hpp>
 #include <cstddef>

test/channel.cpp

@@ -13,8 +13,6 @@
 #include <cstdint>
 #include <exception>
 #include <iostream>
-#include <boost/gil/gil_config.hpp>
-#include <boost/gil/gil_concept.hpp>
 #include <boost/gil/channel.hpp>
 #include <boost/gil/channel_algorithm.hpp>
 #include <boost/gil/typedefs.hpp>