Buffer.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_Buffer_H
#define Sawyer_Buffer_H
 
#include <Sawyer/Sawyer.h>
#include <Sawyer/SharedPointer.h>
#include <string>
 
namespace Sawyer {
namespace Container {
 
template<class A, class T>
class Buffer: public SharedObject {
    std::string name_;
    bool copyOnWrite_;
 
protected:
    explicit Buffer(const std::string &name = ""): name_(generateSequentialName()+name), copyOnWrite_(false) {}
 
#ifdef SAWYER_HAVE_BOOST_SERIALIZATION
private:
    friend class boost::serialization::access;
 
    template<class S>
    void serialize(S &s, const unsigned /*version*/) {
        s & BOOST_SERIALIZATION_NVP(name_);
        s & BOOST_SERIALIZATION_NVP(copyOnWrite_);
    }
#endif
 
#ifdef SAWYER_HAVE_CEREAL
private:
    friend class cereal::access;
 
    template<class Archive>
    void CEREAL_SAVE_FUNCTION_NAME(Archive &archive) const {
        archive(CEREAL_NVP(name_));
        archive(CEREAL_NVP(copyOnWrite_));
    }
 
    template<class Archive>
    void CEREAL_LOAD_FUNCTION_NAME(Archive &archive) {
        archive(CEREAL_NVP(name_));
        archive(CEREAL_NVP(copyOnWrite_));
    }
#endif
 
public:
    typedef SharedPointer<Buffer> Ptr;
 
    typedef A Address;
 
    typedef T Value;
 
public:
    virtual ~Buffer() {}
 
    virtual Ptr copy() const = 0;
 
    virtual std::vector<Value> to_vector() const = 0;
 
    virtual Address available(Address address) const = 0;
    
    virtual Address size() const { return available(Address(0)); }
 
    virtual void resize(Address n) = 0;
 
    virtual void sync() {}
 
    const std::string& name() const { return name_; }
    void name(const std::string &s) { name_ = s; }
    virtual Address read(Value *buf, Address address, Address n) const = 0;
 
    virtual Address write(const Value *buf, Address address, Address n) = 0;
 
    virtual const Value* data() const = 0;
 
    bool copyOnWrite() const { return copyOnWrite_; }
    void copyOnWrite(bool b) { copyOnWrite_ = b; }
};
 
} // namespace
} // namespace
 
#endif