MAPacketCache.cpp

/*
 *  This file is part of the AiBO+ project
 *
 *  Copyright (C) 2005-2016 Csaba Kertész (csaba.kertesz@gmail.com)
 *
 *  AiBO+ is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  AiBO+ is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
 *
 */

#include "MAPacketCache.hpp"

#include <MCBinaryData.hpp>
#include <MCLog.hpp>

MAPacketCache::MAPacketCache(unsigned int storage_size_limit) : CurrentStorageSize(0),
  StorageSizeLimit(storage_size_limit < 100000 ? 100000 : storage_size_limit)
{
}


MAPacketCache::~MAPacketCache()
{
  Release();
}


void MAPacketCache::AddPacket(int index, MCBinaryData& packet)
{
  const auto Iter = Packets.find(index);

  if (Iter != Packets.end())
  {
    CurrentStorageSize -= Iter->second->GetSize();
    delete Iter->second;
    Iter->second = &packet;
  } else {
    Packets[index] = &packet;
  }
  CurrentStorageSize += packet.GetSize();
  // Note: It is a race condition to add a new item with the lowest index and
  // delete it instantly if the storage is full. -> The packet IDs must increase and
  // not decrease so it is not a real case.
  while (CurrentStorageSize > StorageSizeLimit)
  {
    auto Iter2 = Packets.begin();

    CurrentStorageSize -= Iter2->second->GetSize();
    delete Iter2->second;
    Packets.erase(Iter2);
  }
  Add(index, packet);
}


MCBinaryData* MAPacketCache::GetPacket(int index)
{
  if (index < Packets.begin()->first || index > Packets.rbegin()->first)
  {
    MC_WARNING("Packet index out of range (%d -> min. %d max. %d)", index, Packets.begin()->first,
               Packets.rbegin()->first);
    return nullptr;
  }
  return Packets[index];
}


int MAPacketCache::GetCurrentStorageSize() const
{
  return CurrentStorageSize;
}


bool MAPacketCache::UploadPacket(int index)
{
  MCBinaryData* Packet = GetPacket(index);

//  MC_LOG("Upload - id: %d size: %d\n", index, Packet->GetSize());
  if (!Packet)
  {
    return false;
  }
  return Upload(index, *Packet);
}


void MAPacketCache::Release()
{
  for (auto& packet : Packets)
  {
    delete packet.second;
  }
  Packets.clear();
  CurrentStorageSize = 0;
}