MyInventoryData

public class MyInventoryData extends AbstractData<MyInventoryData, MyImmutableInventoryData> {
    private Map<Integer, ItemStack> inventory;


    public MyInventoryData(Map<Integer, ItemStack> inventory) {
        this.inventory = inventory;

        // you must call this!
        registerGettersAndSetters();
    }

    @Override
    protected void registerGettersAndSetters() {
        registerFieldGetter(ToolKeys.INVENTORY, () -> this.inventory);
        registerFieldSetter(ToolKeys.INVENTORY, inventory -> this.inventory = inventory);
        registerKeyValue(ToolKeys.INVENTORY, this::inventory);
    }

    public MapValue<Integer, ItemStack> inventory() {
        return Sponge.getRegistry().getValueFactory().createMapValue(ToolKeys.INVENTORY, inventory);
    }

    @Override
    public Optional<MyInventoryData> fill(DataHolder dataHolder, MergeFunction overlap) {
        Optional<MyInventoryData> otherData_ = dataHolder.get(MyInventoryData.class);
        if (otherData_.isPresent()) {
            MyInventoryData otherData = otherData_.get();
            MyInventoryData finalData = overlap.merge(this, otherData);
            this.inventory = finalData.inventory;
        }
        return Optional.of(this);
    }

    // the double method isn't strictly necessary but makes implementing the builder easier
    @Override
    public Optional<MyInventoryData> from(DataContainer container) {
        return from((DataView) container);
    }

    public Optional<MyInventoryData> from(DataView view) {
        if (view.contains(ToolKeys.INVENTORY.getQuery())) {
            DataView invView = view.getView(ToolKeys.INVENTORY.getQuery()).get();
            Map<Integer, ItemStack> map = new HashMap<>();
            for (DataQuery query : invView.getKeys(false)) {
                ItemStack stack = invView.getSerializable(query, ItemStack.class).get();
                int key = Integer.parseInt(query.toString());
                map.put(key, stack);
            }
            this.inventory = map;
            return Optional.of(this);
        } else {
            return Optional.empty();
        }
    }

    @Override
    public MyInventoryData copy() {
        return new MyInventoryData(this.inventory);
    }

    @Override
    public MyImmutableInventoryData asImmutable() {
        return new MyImmutableInventoryData(this.inventory);
    }

    @Override
    public int getContentVersion() {
        return 1;
    }

    // IMPORTANT this is what causes your data to be written to NBT
    @Override
    public DataContainer toContainer() {
        return super.toContainer()
                .set(ToolKeys.INVENTORY.getQuery(), this.inventory);
    }
}