How to maintain an image/cache in EMA? We are moving from RFA MarketData API to EMA.

After going through the EMA documentation, I am not sure if EMA is providing any mechanism to maintain a cached image and applying updates to it.

We used to do it using only a few lines of code in RFA MarketData. We are subscribing to market price service. In RFA MarketData code we maintain a cached full image in a TibMsg object.

TibMsg m_RawImage;

We populate the TibMsg object when we get an initial image from the RFA callback using the following code:

void ProcessItemImage(const MarketDataItemEvent& event)
{
  const rfa::common::Buffer& buffer = event.getBuffer();
  switch (event.getDataFormat())
    {
      case MarketDataEnums::Marketfeed:
        if (!buffer.isEmpty())
        {
          TibMsg msg;
          TibErr err = msg.UnPack((char*)buffer.c_buf(), buffer.size());
          assert(err.code == TIBMSG_OK);
          CopyTibMsg(m_RawImage, msg);
.
.
.

When we get a update message callback from RFA we apply the update to the cached full image using the following code:

void ProcessItemUpdate(const MarketDataItemEvent& event)
{
  const rfa::common::Buffer& buffer = event.getBuffer();
  switch (event.getDataFormat())
  {
    case MarketDataEnums::Marketfeed:
      if (!buffer.isEmpty())
      {
        TibMsg msg;
        TibErr err = msg.UnPack((char*)buffer.c_buf(), buffer.size());
        assert(err.code == TIBMSG_OK);
        if (err.code != TIBMSG_OK)
          return;
        UpdateTibMsg(m_RawImage, msg);
.
.
}

bool UpdateTibMsg(TibMsg& image, TibMsg& delta)
{
  TibField field;
  bool ret = false;
  for (field.First(&delta); field.status==TIBMSG_OK; field.Next())
  {
    TibErr err = image.Update(&field);
    ret |= (err.code == TIBMSG_OK);
  }
  return ret;
}

What is the equivalent thing to do in EMA? What object can we cache?

The documentation clearly says this:

Warning! The Data class and all classes that inherit from it are designed as temporary and short-lived objects. For this reason, do not use them as storage or caching devices.

Do we need to implement our own classes for caching and applying updates?