DataBlock.h

#ifndef ROSE_Partitioner2_DataBlock_H
#define ROSE_Partitioner2_DataBlock_H

#include <Partitioner2/BasicTypes.h>

#include <boost/serialization/access.hpp>
#include <Sawyer/Attribute.h>
#include <Sawyer/SharedPointer.h>

#include <string>

namespace Rose {
namespace BinaryAnalysis {
namespace Partitioner2 {

class DataBlock: public Sawyer::SharedObject, public Sawyer::Attribute::Storage<> {
public:
    typedef Sawyer::SharedPointer<DataBlock> Ptr;

private:
    bool isFrozen_;                                     // true if object is read-only because it's in the CFG
    rose_addr_t startVa_;                               // starting address
    size_t size_;                                       // size in bytes; FIXME[Robb P. Matzke 2014-08-12]: replace with type
    size_t nAttachedOwners_;                            // number of attached basic blocks and functions that own this data

#ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
private:
    friend class boost::serialization::access;

    template<class S>
    void serialize(S &s, const unsigned version) {
        // s & boost::serialization::base_object<Sawyer::Attribute::Storage>(*this); -- not serialized
        s & BOOST_SERIALIZATION_NVP(isFrozen_);
        s & BOOST_SERIALIZATION_NVP(startVa_);
        s & BOOST_SERIALIZATION_NVP(size_);
        s & BOOST_SERIALIZATION_NVP(nAttachedOwners_);
    }
#endif
    
protected:
    // needed for serialization
    DataBlock(): isFrozen_(false), startVa_(0), size_(0), nAttachedOwners_(0) {}

    // use instance() instead
    DataBlock(rose_addr_t startVa, size_t size): startVa_(startVa), size_(size), nAttachedOwners_(0) {
        ASSERT_require(size_ > 0);
    }

public:
    static Ptr instance(rose_addr_t startVa, size_t size) {
        return Ptr(new DataBlock(startVa, size));
    }

    virtual Ptr create(rose_addr_t startVa, size_t size) const {
        return instance(startVa, size);
    }

    bool isFrozen() const { return isFrozen_; }

    rose_addr_t address() const { return startVa_; }

    size_t size() const { return size_; }

    void size(size_t nBytes);

    size_t nAttachedOwners() const { return nAttachedOwners_; }

    AddressInterval extent() const { return AddressInterval::baseSize(address(), size()); }

    std::string printableName() const;

private:
    friend class Partitioner;
    void freeze() { isFrozen_ = true; }
    void thaw() { isFrozen_ = false; }
    size_t incrementOwnerCount();
    size_t decrementOwnerCount();
};


} // namespace
} // namespace
} // namespace

#endif