deleted file mode 100755

@@ -1,125 +0,0 @@

-#ifndef BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP

-#define BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP

-

-// (C) Copyright 2005  Matthias Troyer

-// (C) Copyright 2020  Robert Ramey

-

-// Use, modification and distribution is 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)

-

-#include <cstddef> // size_t

-#include <boost/assert.hpp>

-#include <boost/operators.hpp>

-#include <boost/serialization/level.hpp>

-#include <boost/serialization/is_bitwise_serializable.hpp>

-

-namespace boost {

-namespace serialization {

-

-template<typename T> // T is the basic type holding the integer

-struct cardinal_number : private

-    boost::totally_ordered<cardinal_number<T> >,

-    boost::additive<cardinal_number<T> >,

-    boost::unit_steppable<cardinal_number<T> >

-{

-private:

-    template<typename CharType, typename Traits>

-    friend std::basic_ostream<CharType, Traits> & operator<<(

-        const std::basic_ostream<CharType, Traits> & bos,

-        const cardinal_number & rhs

-    );

-    template<typename CharType, typename Traits>

-    friend std::basic_istream<CharType, Traits> & operator>>(

-        std::basic_istream<CharType, Traits> & bis,

-        const cardinal_number & rhs

-    );

-public:

-    T m_t;

-    cardinal_number(T t = 0) :

-        m_t(t)

-    {}

-    cardinal_number(unsigned int t) :

-        m_t(t)

-    {}

-    cardinal_number(int t) :

-        m_t(t)

-    {

-        BOOST_ASSERT(t >= 0);

-    }

-    operator const T (){

-        return m_t;

-    }

-    // assignment operator

-    cardinal_number & operator=(const cardinal_number & rhs){

-        m_t = rhs.m_t;

-        return *this;

-    }

-    // basic operations upon which others depend

-    // totally ordered / less_than_comparable

-    bool operator<(const cardinal_number & rhs) const {

-        return m_t < rhs.m_t;

-    }

-    bool operator==(const cardinal_number & rhs) const {

-        return m_t == rhs.m_t;

-    }

-    // additive

-    cardinal_number & operator+=(const cardinal_number & rhs){

-        m_t += rhs.m_t;

-        return *this;

-    }

-    // subtractive

-    cardinal_number & operator-=(const cardinal_number & rhs){

-        BOOST_ASSERT(m_t >= rhs.m_t);

-        m_t -= rhs.m_t;

-        return *this;

-    }

-    // increment

-    cardinal_number operator++(){

-        ++m_t;

-        return *this;

-     }

-     // decrement

-    cardinal_number operator--(){

-        BOOST_ASSERT(m_t > T(0));

-        --m_t;

-        return *this;

-     }

-};

-

-typedef cardinal_number<std::size_t> collection_size_type;

-

-} } // end namespace boost::serialization

-

-#include <ostream>

-#include <istream>

-

-namespace std {

-

-template<typename CharType, typename Traits>

-basic_ostream<CharType, Traits> & operator<<(

-    std::basic_ostream<CharType, Traits> & bos,

-    const boost::serialization::collection_size_type & rhs

-){

-    bos << rhs.m_t;

-    return bos;

-}

-

-template<typename CharType, typename Traits>

-basic_istream<CharType, Traits> & operator>>(

-    std::basic_istream<CharType, Traits> & bis,

-    boost::serialization::collection_size_type & rhs

-){

-    bis >> rhs.m_t;

-    return bis;

-}

-

-} // std

-

-BOOST_CLASS_IMPLEMENTATION(                     \

-    boost::serialization::collection_size_type, \

-    primitive_type                              \

-)

-BOOST_IS_BITWISE_SERIALIZABLE(boost::serialization::collection_size_type)

-

-#endif //BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP