AddressSegment.h

// WARNING: Changes to this file must be contributed back to Sawyer or else they will
//          be clobbered by the next update from Sawyer.  The Sawyer repository is at
//          https://gitlab.com/charger7534/sawyer.git.
 
 
 
 
#ifndef Sawyer_AddressSegment_H
#define Sawyer_AddressSegment_H
 
#include <Sawyer/Access.h>
#include <Sawyer/AllocatingBuffer.h>
#include <Sawyer/MappedBuffer.h>
#include <Sawyer/NullBuffer.h>
#include <Sawyer/StaticBuffer.h>
#include <Sawyer/Sawyer.h>
 
#include <boost/cstdint.hpp>
 
#ifdef SAWYER_HAVE_BOOST_SERIALIZATION
#include <boost/serialization/string.hpp>
#endif
 
#ifdef SAWYER_HAVE_CEREAL
#include <cereal/types/string.hpp>
#endif
 
namespace Sawyer {
namespace Container {
 
template<class A = size_t, class T = boost::uint8_t>
class AddressSegment {
    typename Buffer<A, T>::Ptr buffer_;                 // reference counted buffer
    A offset_;                                          // initial offset into buffer
    unsigned accessibility_;                            // uninterpreted bit mask
    std::string name_;                                  // for debugging
 
public:
    typedef A Address;                                  
    typedef T Value;                                    
    //-------------------------------------------------------------------------------------------------------------------
    // Serialization
    //-------------------------------------------------------------------------------------------------------------------
#ifdef SAWYER_HAVE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    // Users: You'll need to register the subclass once you know its type, such as
    // BOOST_CLASS_REGISTER(Sawyer::Container::AddressSegment<size_t,uint8_t>);
    // You'll also need to register the most-derived buffer type.
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        s & BOOST_SERIALIZATION_NVP(buffer_);
        s & BOOST_SERIALIZATION_NVP(offset_);
        s & BOOST_SERIALIZATION_NVP(accessibility_);
        s & BOOST_SERIALIZATION_NVP(name_);
    }
#endif
 
#ifdef SAWYER_HAVE_CEREAL
private:
    friend class cereal::access;
 
    template<class Archive>
    void CEREAL_SERIALIZE_FUNCTION_NAME(Archive &archive) {
        archive(CEREAL_NVP(buffer_));
        archive(CEREAL_NVP(offset_));
        archive(CEREAL_NVP(accessibility_));
        archive(CEREAL_NVP(name_));
    }
#endif
 
    //-------------------------------------------------------------------------------------------------------------------
    // Constructors
    //-------------------------------------------------------------------------------------------------------------------
public:
 
    AddressSegment(): offset_(0), accessibility_(0) {}
 
    AddressSegment(const AddressSegment &other)
        : buffer_(other.buffer_), offset_(other.offset_), accessibility_(other.accessibility_), name_(other.name_) {}
 
    explicit AddressSegment(const typename Buffer<Address, Value>::Ptr &buffer, Address offset=0, unsigned accessBits=0,
                            const std::string &name="")
        : buffer_(buffer), offset_(offset), accessibility_(accessBits), name_(name) {}
 
    AddressSegment& operator=(const AddressSegment &other) {
        buffer_ = other.buffer_;
        offset_ = other.offset_;
        accessibility_ = other.accessibility_;
        name_ = other.name_;
        return *this;
    }
 
    //-------------------------------------------------------------------------------------------------------------------
    // The following static methods are convenience wrappers around various buffer types.
    //-------------------------------------------------------------------------------------------------------------------
public:
 
    static AddressSegment nullInstance(Address size, unsigned accessBits=0, const std::string &name="") {
        return AddressSegment(NullBuffer<A, T>::instance(size), 0, accessBits, name);
    }
 
    static AddressSegment anonymousInstance(Address size, unsigned accessBits=0, const std::string &name="") {
        return AddressSegment(AllocatingBuffer<A, T>::instance(size), 0, accessBits, name);
    }
 
    static AddressSegment staticInstance(Value *buffer, Address size, unsigned accessBits=0, const std::string &name="") {
        return AddressSegment(StaticBuffer<A, T>::instance(buffer, size), 0, accessBits, name);
    }
    static AddressSegment staticInstance(const Value *buffer, Address size, unsigned accessBits=0, const std::string &name="") {
        return AddressSegment(StaticBuffer<A, T>::instance(buffer, size), 0, accessBits|Access::IMMUTABLE, name);
    }
    static AddressSegment fileInstance(const std::string &fileName, unsigned accessBits=Access::READABLE,
                                       const std::string &name="") {
        boost::iostreams::mapped_file::mapmode mode = (accessBits & Access::PRIVATE ? boost::iostreams::mapped_file::priv
                                                       : (accessBits & Access::WRITABLE ? boost::iostreams::mapped_file::readwrite
                                                          : boost::iostreams::mapped_file::readonly));
        return AddressSegment(MappedBuffer<A, T>::instance(fileName, mode), 0, accessBits, name);
    }
 
    //-------------------------------------------------------------------------------------------------------------------
    // Properties
    //-------------------------------------------------------------------------------------------------------------------
public:
    typename Buffer<A, T>::Ptr buffer() const { return buffer_; }
    AddressSegment& buffer(const typename Buffer<A, T>::Ptr &b) { buffer_ = b; return *this; }
    A offset() const { return offset_; }
    AddressSegment& offset(A n) { offset_ = n; return *this; }
    unsigned accessibility() const { return accessibility_; }
    AddressSegment& accessibility(unsigned bits) { accessibility_ = bits; return *this; }
    const std::string &name() const { return name_; }
    AddressSegment& name(const std::string &s) { name_ = s; return *this; }
    //-------------------------------------------------------------------------------------------------------------------
    // Other methods
    //-------------------------------------------------------------------------------------------------------------------
public:
    bool isAccessible(unsigned requiredAccess, unsigned prohibitedAccess) const {
        return requiredAccess==(accessibility_ & requiredAccess) && 0==(accessibility_ & prohibitedAccess);
    }
    
};
 
} // namespace
} // namespace
 
#endif