Adobe Open Source: gil_config.hpp Source File

00001 /*
00002     Copyright 2005-2006 Adobe Systems Incorporated
00003     Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt
00004     or a copy at http://opensource.adobe.com/licenses.html)
00005 */
00006 
00007 /*************************************************************************************************/
00008 
00009 #ifndef GIL_CONFIG_H
00010 #define GIL_CONFIG_H
00011 
00021 
00022 #ifdef MSVC
00023     #define GIL_FORCEINLINE __forceinline
00024 #else
00025     #define GIL_FORCEINLINE inline
00026 #endif
00027 
00028 #ifndef NO_ASL
00029 
00030 #include <adobe/config.hpp>
00031 #define GIL adobe::gil
00032 #define ADOBE_GIL_NAMESPACE_BEGIN  namespace adobe { namespace gil {
00033 #define ADOBE_GIL_NAMESPACE_END    } }
00034 
00035 #include <adobe/functional.hpp>
00036 #include <adobe/algorithm/copy.hpp>
00037 #include <adobe/iterator.hpp>
00038 
00039 #else
00040 
00041 #define GIL gil
00042 #define ADOBE_GIL_NAMESPACE_BEGIN  namespace GIL {
00043 #define ADOBE_GIL_NAMESPACE_END    }
00044 
00045 #include <functional>
00046 #include <boost/iterator/iterator_adaptor.hpp>
00047 
00048 namespace adobe {
00049 
00050 #if !defined(ADOBE_NO_DOCUMENTATION)
00051 namespace fn { }
00052 using namespace fn;
00053 namespace fn {
00054 #endif
00055 
00061 
00062 namespace detail {
00063     template <class InputIter, class Size, class OutputIter>
00064     std::pair<InputIter, OutputIter> _copy_n(InputIter first, Size count,
00065                                            OutputIter result,
00066                                            std::input_iterator_tag) {
00067        for ( ; count > 0; --count) {
00068           *result = *first;
00069           ++first;
00070           ++result;
00071        }
00072        return std::pair<InputIter, OutputIter>(first, result);
00073     }
00074 
00075     template <class RAIter, class Size, class OutputIter>
00076     inline std::pair<RAIter, OutputIter>
00077     _copy_n(RAIter first, Size count, OutputIter result, std::random_access_iterator_tag) {
00078        RAIter last = first + count;
00079        return std::pair<RAIter, OutputIter>(last, std::copy(first, last, result));
00080     }
00081 
00082     template <class InputIter, class Size, class OutputIter>
00083     inline std::pair<InputIter, OutputIter>
00084     _copy_n(InputIter first, Size count, OutputIter result) {
00085        return _copy_n(first, count, result, typename std::iterator_traits<InputIter>::iterator_category());
00086     }
00087 }
00088 
00089 template <class InputIter, class Size, class OutputIter>
00090 inline std::pair<InputIter, OutputIter>
00091 copy_n(InputIter first, Size count, OutputIter result) {
00092     return detail::_copy_n(first, count, result);
00093 }
00094 
00097 //                  STEP ITERATOR ADAPTOR
00106 
00107 template <typename DERIVED, // type of the derived class
00108         typename IT,    // Models Iterator
00109         typename S_FN>  // A policy object that can compute the distance between two iterators of type IT
00110                         // and can advance an iterator of type IT a given number of IT's units  
00111 class step_iterator_adaptor : public boost::iterator_adaptor<DERIVED, IT, boost::use_default, boost::use_default, boost::use_default, typename S_FN::difference_type> {
00112 public:
00113     typedef boost::iterator_adaptor<DERIVED, IT, boost::use_default, boost::use_default, boost::use_default, typename S_FN::difference_type> parent_t;
00114     typedef typename std::iterator_traits<IT>::difference_type base_difference_type;
00115     typedef typename S_FN::difference_type                     difference_type;
00116     typedef typename std::iterator_traits<IT>::reference       reference;
00117 
00118     step_iterator_adaptor() {}
00119     step_iterator_adaptor(const IT& it, S_FN step_fn=S_FN()) : parent_t(it), _step_fn(step_fn) {}
00120 
00121     difference_type step() const { return _step_fn.step(); }
00122 
00123 protected:
00124     S_FN _step_fn;
00125 private:
00126     friend class boost::iterator_core_access;
00127 
00128     void increment() { _step_fn.advance(this->base_reference(),1); }
00129     void decrement() { _step_fn.advance(this->base_reference(),-1); }
00130     void advance(base_difference_type d) { _step_fn.advance(this->base_reference(),d); }
00131     difference_type distance_to(const step_iterator_adaptor& it) const { return _step_fn.difference(this->base_reference(),it.base_reference()); }
00132 };
00133 
00134 // although boost::iterator_adaptor defines these, the default implementation computes distance and compares for zero.
00135 // it is often faster to just apply the relation operator to the base
00136 template <typename D,typename IT,typename S_FN> inline
00137 bool operator>(const step_iterator_adaptor<D,IT,S_FN>& p1, const step_iterator_adaptor<D,IT,S_FN>& p2) { 
00138     return p1.step()>0 ? p1.base()> p2.base() : p1.base()< p2.base(); 
00139 }
00140 
00141 template <typename D,typename IT,typename S_FN> inline
00142 bool operator<(const step_iterator_adaptor<D,IT,S_FN>& p1, const step_iterator_adaptor<D,IT,S_FN>& p2) { 
00143     return p1.step()>0 ? p1.base()< p2.base() : p1.base()> p2.base(); 
00144 }
00145 
00146 template <typename D,typename IT,typename S_FN> inline
00147 bool operator>=(const step_iterator_adaptor<D,IT,S_FN>& p1, const step_iterator_adaptor<D,IT,S_FN>& p2) { 
00148     return p1.step()>0 ? p1.base()>=p2.base() : p1.base()<=p2.base(); 
00149 }
00150 
00151 template <typename D,typename IT,typename S_FN> inline
00152 bool operator<=(const step_iterator_adaptor<D,IT,S_FN>& p1, const step_iterator_adaptor<D,IT,S_FN>& p2) { 
00153     return p1.step()>0 ? p1.base()<=p2.base() : p1.base()>=p2.base(); 
00154 }
00155 
00156 template <typename D,typename IT,typename S_FN> inline
00157 bool operator==(const step_iterator_adaptor<D,IT,S_FN>& p1, const step_iterator_adaptor<D,IT,S_FN>& p2) { 
00158     return p1.base()==p2.base(); 
00159 }
00160 
00161 template <typename D,typename IT,typename S_FN> inline
00162 bool operator!=(const step_iterator_adaptor<D,IT,S_FN>& p1, const step_iterator_adaptor<D,IT,S_FN>& p2) { 
00163     return p1.base()!=p2.base(); 
00164 }
00165 
00166 /*************************************************************************************************/
00167 
00169 template <typename T1, typename T2>
00170 struct plus_asymmetric : public std::binary_function<T1,T2,T1> 
00171 {
00172     T1 operator()(T1 f1, T2 f2) const {
00173         return f1+f2;
00174     }
00175 };
00176 
00177 /*************************************************************************************************/
00178 
00180 template <typename T>
00181 struct inc : public std::unary_function<T,T> 
00182 {
00183     T operator()(T x) const { return ++x; }
00184 };
00185 
00186 /*************************************************************************************************/
00187 
00189 template <typename T>
00190 struct dec : public std::unary_function<T,T> 
00191 {
00192     T operator()(T x) const { return --x; }
00193 };
00194 
00195 
00196 #if !defined(ADOBE_NO_DOCUMENTATION)
00197 } // namespace fn
00198 #endif
00199 
00200 } // namespace adobe
00201 
00202 /*************************************************************************************************/
00203 
00204 #endif // NO_ASL
00205 
00206 #include <boost/type_traits.hpp>
00207 ADOBE_GIL_NAMESPACE_BEGIN
00208 namespace detail {
00211     template <typename T>
00212     struct homogeneous_color_base {
00213         template <int N> struct kth_element_t { 
00214             typedef typename boost::add_reference<T>::type                                  reference; 
00215             typedef typename boost::add_reference<typename boost::add_const<T>::type>::type const_reference;
00216         };
00217     };
00218 }
00219 ADOBE_GIL_NAMESPACE_END
00220 
00221 #endif
Information

Media

Support

RSS

Other Adobe Projects

Other Resources

gil_config.hpp
