Ticket #10063: boost_ublas_msvc8.patch

File boost_ublas_msvc8.patch, 12.9 KB (added by Andrew Medlin <andrew@…>, 8 years ago)

Patch to optionally exclude serialization from certain ublas classes. Also includes fix for "new" being defined in msvc 8 when including type_traits/has_new_operator.hpp

  • numeric/ublas/matrix.hpp

     
    1616#include <boost/numeric/ublas/vector.hpp>
    1717#include <boost/numeric/ublas/matrix_expression.hpp>
    1818#include <boost/numeric/ublas/detail/matrix_assign.hpp>
    19 #include <boost/serialization/collection_size_type.hpp>
    20 #include <boost/serialization/array.hpp>
    21 #include <boost/serialization/nvp.hpp>
     19#ifndef BOOST_UBLAS_DISABLE_SERIALIZATION
     20    #include <boost/serialization/collection_size_type.hpp>
     21    #include <boost/serialization/array.hpp>
     22    #include <boost/serialization/nvp.hpp>
     23#endif // BOOST_UBLAS_DISABLE_SERIALIZATION
    2224
    2325// Iterators based on ideas of Jeremy Siek
    2426
    … …  
    10661068            return reverse_iterator2 (begin2 ());
    10671069        }
    10681070
     1071#ifndef BOOST_UBLAS_DISABLE_SERIALIZATION
    10691072        // Serialization
    10701073        template<class Archive>
    10711074        void serialize(Archive & ar, const unsigned int /* file_version */){
    … …  
    10861089            }
    10871090            ar & serialization::make_nvp("data",data_);
    10881091        }
     1092#endif // BOOST_UBLAS_DISABLE_SERIALIZATION
    10891093
    10901094    private:
    10911095        size_type size1_;
    … …  
    21432147            return reverse_iterator2 (begin2 ());
    21442148        }
    21452149
     2150#ifndef BOOST_UBLAS_DISABLE_SERIALIZATION
    21462151        // Serialization
    21472152        template<class Archive>
    21482153        void serialize(Archive & ar, const unsigned int /* file_version */){
    … …  
    21632168            }
    21642169            ar & serialization::make_nvp("data",data_);
    21652170        }
     2171#endif // BOOST_UBLAS_DISABLE_SERIALIZATION
    21662172
    21672173    private:
    21682174        size_type size1_;
    … …  
    25282534            return const_reverse_iterator2 (begin2 ());
    25292535        }
    25302536
     2537#ifndef BOOST_UBLAS_DISABLE_SERIALIZATION
    25312538         // Serialization
    25322539        template<class Archive>
    25332540        void serialize(Archive & ar, const unsigned int /* file_version */){
    … …  
    25472554                size2_ = s2;
    25482555            }
    25492556        }
     2557#endif // BOOST_UBLAS_DISABLE_SERIALIZATION
    25502558
    25512559    private:
    25522560        size_type size1_;
    … …  
    29392947            return const_reverse_iterator2 (begin2 ());
    29402948        }
    29412949
     2950#ifndef BOOST_UBLAS_DISABLE_SERIALIZATION
    29422951         // Serialization
    29432952        template<class Archive>
    29442953        void serialize(Archive & ar, const unsigned int /* file_version */){
    … …  
    29592968                size_common_ = ((std::min)(size1_, size2_));
    29602969            }
    29612970        }
     2971#endif // BOOST_UBLAS_DISABLE_SERIALIZATION
    29622972
    29632973    private:
    29642974        size_type size1_;
    … …  
    34063416            return const_reverse_iterator2 (begin2 ());
    34073417        }
    34083418
     3419#ifndef BOOST_UBLAS_DISABLE_SERIALIZATION
    34093420         // Serialization
    34103421        template<class Archive>
    34113422        void serialize(Archive & ar, const unsigned int /* file_version */){
    … …  
    34273438
    34283439            ar & serialization::make_nvp("value", value_);
    34293440        }
     3441#endif // BOOST_UBLAS_DISABLE_SERIALIZATION
    34303442
    34313443    private:
    34323444        size_type size1_;
    … …  
    43574369            return reverse_iterator2 (begin2 ());
    43584370        }
    43594371
     4372#ifndef BOOST_UBLAS_DISABLE_SERIALIZATION
    43604373         // Serialization
    43614374        template<class Archive>
    43624375        void serialize(Archive & ar, const unsigned int /* file_version */){
    … …  
    43784391            // could probably use make_array( &(data[0][0]), N*M )
    43794392            ar & serialization::make_array(data_, N);
    43804393        }
     4394#endif // BOOST_UBLAS_DISABLE_SERIALIZATION
    43814395
    43824396    private:
    43834397        size_type size1_;

  • numeric/ublas/storage.hpp

     
    1818#include <boost/shared_array.hpp>
    1919#endif
    2020
    21 #include <boost/serialization/array.hpp>
    22 #include <boost/serialization/collection_size_type.hpp>
    23 #include <boost/serialization/nvp.hpp>
     21#ifndef BOOST_UBLAS_DISABLE_SERIALIZATION
     22    #include <boost/serialization/array.hpp>
     23    #include <boost/serialization/collection_size_type.hpp>
     24    #include <boost/serialization/nvp.hpp>
     25#endif // BOOST_UBLAS_DISABLE_SERIALIZATION
    2426
    2527#include <boost/numeric/ublas/exception.hpp>
    2628#include <boost/numeric/ublas/traits.hpp>
    … …  
    269271        }
    270272
    271273    private:
     274#ifndef BOOST_UBLAS_DISABLE_SERIALIZATION
    272275        friend class boost::serialization::access;
    273276
    274277        // Serialization
    … …  
    282285            }
    283286            ar & serialization::make_array(data_, s);
    284287        }
     288#endif // BOOST_UBLAS_DISABLE_SERIALIZATION
    285289
    286290    private:
    287         // Handle explict destroy on a (possibly indexed) iterator
     291        // Handle explicit destroy on a (possibly indexed) iterator
    288292        BOOST_UBLAS_INLINE
    289293        static void iterator_destroy (iterator &i) {
    290294            (&(*i)) -> ~value_type ();
    … …  
    447451        }
    448452
    449453    private:
     454#ifndef BOOST_UBLAS_DISABLE_SERIALIZATION
    450455        // Serialization
    451456        friend class boost::serialization::access;
    452457
    … …  
    461466            }
    462467            ar & serialization::make_array(data_, s);
    463468        }
     469#endif // BOOST_UBLAS_DISABLE_SERIALIZATION
    464470
    465471    private:
    466472        size_type size_;

  • numeric/ublas/storage_sparse.hpp

     
    1414#define _BOOST_UBLAS_STORAGE_SPARSE_
    1515
    1616#include <map>
    17 #include <boost/serialization/collection_size_type.hpp>
    18 #include <boost/serialization/nvp.hpp>
    19 #include <boost/serialization/array.hpp>
    20 #include <boost/serialization/map.hpp>
    21 #include <boost/serialization/base_object.hpp>
     17#ifndef BOOST_UBLAS_DISABLE_SERIALIZATION
     18    #include <boost/serialization/collection_size_type.hpp>
     19    #include <boost/serialization/nvp.hpp>
     20    #include <boost/serialization/array.hpp>
     21    #include <boost/serialization/map.hpp>
     22    #include <boost/serialization/base_object.hpp>
     23#endif // BOOST_UBLAS_DISABLE_SERIALIZATION
    2224
    2325#include <boost/numeric/ublas/storage.hpp>
    2426

  • numeric/ublas/vector.hpp

     
    1919#include <boost/numeric/ublas/storage.hpp>
    2020#include <boost/numeric/ublas/vector_expression.hpp>
    2121#include <boost/numeric/ublas/detail/vector_assign.hpp>
    22 #include <boost/serialization/collection_size_type.hpp>
    23 #include <boost/serialization/nvp.hpp>
     22#ifndef BOOST_UBLAS_DISABLE_SERIALIZATION
     23    #include <boost/serialization/collection_size_type.hpp>
     24    #include <boost/serialization/nvp.hpp>
     25#endif // BOOST_UBLAS_DISABLE_SERIALIZATION
    2426
    2527
    2628// Iterators based on ideas of Jeremy Siek
    … …  
    776778                return reverse_iterator (begin ());
    777779            }
    778780       
     781#ifndef BOOST_UBLAS_DISABLE_SERIALIZATION
    779782        // -------------
    780783            // Serialization
    781784        // -------------
    … …  
    784787        /// \param ar Archive object. Can be a flat file, an XML file or any other stream
    785788        /// \param file_version Optional file version (not yet used)
    786789        template<class Archive>
    787         void serialize(Archive & ar, const unsigned int /* file_version */){
    788             ar & serialization::make_nvp("data",data_);
    789         }
     790             void serialize(Archive & ar, const unsigned int /* file_version */){
     791                 ar & serialization::make_nvp("data",data_);
     792             }
     793#endif // BOOST_UBLAS_DISABLE_SERIALIZATION
    790794
    791     private:
    792         array_type data_;
     795        private:
     796             array_type data_;
    793797    };
    794798
    795799
    … …  
    10511055        }
    10521056        BOOST_UBLAS_INLINE
    10531057        const_reverse_iterator rend () const {
    1054             return const_reverse_iterator (begin ());
    1055         }
     1058                 return const_reverse_iterator (begin ());
     1059             }
    10561060
    1057          // Serialization
    1058         template<class Archive>
    1059         void serialize(Archive & ar, const unsigned int /* file_version */){
     1061#ifndef BOOST_UBLAS_DISABLE_SERIALIZATION
     1062              // Serialization
     1063             template<class Archive>
     1064             void serialize(Archive & ar, const unsigned int /* file_version */){
    10601065            serialization::collection_size_type s (size_);
    10611066            ar & serialization::make_nvp("size",s);
    10621067            if (Archive::is_loading::value) {
    1063                 size_ = s;
    1064             }
    1065         }
     1068                     size_ = s;
     1069                 }
     1070             }
     1071#endif // BOOST_UBLAS_DISABLE_SERIALIZATION
    10661072
    1067     private:
    1068         size_type size_;
     1073        private:
     1074             size_type size_;
    10691075        typedef const value_type const_value_type;
    10701076        static const_value_type zero_;
    10711077    };
    … …  
    12951301        }
    12961302        BOOST_UBLAS_INLINE
    12971303        const_reverse_iterator rend () const {
    1298             return const_reverse_iterator (begin ());
    1299         }
     1304                 return const_reverse_iterator (begin ());
     1305             }
    13001306
    1301          // Serialization
    1302         template<class Archive>
    1303         void serialize(Archive & ar, const unsigned int /* file_version */){
     1307#ifndef BOOST_UBLAS_DISABLE_SERIALIZATION
     1308              // Serialization
     1309             template<class Archive>
     1310             void serialize(Archive & ar, const unsigned int /* file_version */){
    13041311            serialization::collection_size_type s (size_);
    13051312            ar & serialization::make_nvp("size",s);
    13061313            if (Archive::is_loading::value) {
    13071314                size_ = s;
    1308             }
    1309             ar & serialization::make_nvp("index", index_);
    1310         }
     1315                 }
     1316                 ar & serialization::make_nvp("index", index_);
     1317             }
     1318#endif // BOOST_UBLAS_DISABLE_SERIALIZATION
    13111319
    1312     private:
    1313         size_type size_;
     1320        private:
     1321             size_type size_;
    13141322        size_type index_;
    13151323        typedef const value_type const_value_type;
    13161324        static const_value_type zero_;
    … …  
    15431551        }
    15441552        BOOST_UBLAS_INLINE
    15451553        const_reverse_iterator rend () const {
    1546             return const_reverse_iterator (begin ());
    1547         }
     1554                 return const_reverse_iterator (begin ());
     1555             }
    15481556
    1549          // Serialization
    1550         template<class Archive>
    1551         void serialize(Archive & ar, const unsigned int /* file_version */){
     1557#ifndef BOOST_UBLAS_DISABLE_SERIALIZATION
     1558              // Serialization
     1559             template<class Archive>
     1560             void serialize(Archive & ar, const unsigned int /* file_version */){
    15521561            serialization::collection_size_type s (size_);
    15531562            ar & serialization::make_nvp("size",s);
    15541563            if (Archive::is_loading::value) {
    15551564                size_ = s;
    1556             }
    1557             ar & serialization::make_nvp("value", value_);
    1558         }
     1565                 }
     1566                 ar & serialization::make_nvp("value", value_);
     1567             }
     1568#endif // BOOST_UBLAS_DISABLE_SERIALIZATION
    15591569
    1560     private:
    1561         size_type size_;
     1570        private:
     1571             size_type size_;
    15621572        value_type value_;
    15631573    };
    15641574
    … …  
    20492059        }
    20502060        BOOST_UBLAS_INLINE
    20512061        reverse_iterator rend () {
    2052             return reverse_iterator (begin ());
    2053         }
     2062                 return reverse_iterator (begin ());
     2063             }
    20542064
    2055         // Serialization
    2056         template<class Archive>
    2057         void serialize(Archive & ar, const unsigned int /* file_version */){
     2065#ifndef BOOST_UBLAS_DISABLE_SERIALIZATION
     2066             // Serialization
     2067             template<class Archive>
     2068             void serialize(Archive & ar, const unsigned int /* file_version */){
    20582069            serialization::collection_size_type s (size_);
    20592070            ar & serialization::make_nvp("size",s);
    20602071           
    … …  
    20632074              if (s > N) bad_size("too large size in bounded_vector::load()\n").raise();
    20642075              size_ = s;
    20652076            }
    2066             // ISSUE: this writes the full array
    2067             ar & serialization::make_nvp("data",data_);
    2068         }
     2077                 // ISSUE: this writes the full array
     2078                 ar & serialization::make_nvp("data",data_);
     2079             }
     2080#endif // BOOST_UBLAS_DISABLE_SERIALIZATION
    20692081
    2070     private:
    2071         size_type size_;
     2082        private:
     2083             size_type size_;
    20722084        array_type data_;
    20732085    };
    20742086

  • type_traits/has_new_operator.hpp

     
    1818// should be the last #include
    1919#include <boost/type_traits/detail/bool_trait_def.hpp>
    2020
     21#if defined(new)
     22    #define BOOST_TT_AUX_MACRO_NEW_DEFINED
     23    #if BOOST_WORKAROUND(BOOST_MSVC, >= 1310)
     24        #pragma push_macro("new")
     25    #else
     26        #error Unsupported compiler. Macro "new" must be hidden.
     27    #endif
     28    #undef new
     29#endif
     30
    2131namespace boost {
    2232namespace detail {
    2333    template <class U, U x>
    … …  
    135145
    136146} // namespace boost
    137147
     148#if defined(BOOST_TT_AUX_MACRO_NEW_DEFINED)
     149    #if BOOST_WORKAROUND(BOOST_MSVC, >= 1310)
     150        #pragma pop_macro("new")
     151    #endif
     152    #undef BOOST_TT_AUX_MACRO_NEW_DEFINED
     153#endif
     154
    138155#include <boost/type_traits/detail/bool_trait_undef.hpp>
    139156
    140157#endif // BOOST_TT_HAS_NEW_OPERATOR_HPP_INCLUDED