MCDataContainer.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 "MCDataContainer.hpp"

#include "MCBinaryData.hpp"
#include "MCDataStorage.hpp"
#include "MCLog.hpp"
#include "MCTypes.hpp"

#include <boost/iostreams/device/back_inserter.hpp>
#include <boost/iostreams/stream.hpp>

MCDataItemBase::MCDataItemBase() : DataPtr(nullptr)
{
}


MCDataItemBase::~MCDataItemBase()
{
}


void MCDataItemBase::LoadFromArchive(boost::archive::binary_iarchive& archive)
{
  MC_UNUSED(archive)
}


void MCDataItemBase::SaveToArchive(boost::archive::binary_oarchive& archive) const
{
  MC_UNUSED(archive)
}


void MCDataItemBase::LoadFromArchive(eos::portable_iarchive& archive)
{
  MC_UNUSED(archive)
}


void MCDataItemBase::SaveToArchive(eos::portable_oarchive& archive) const
{
  MC_UNUSED(archive)
}


void MCDataItemBase::DeleteData()
{
}


MCDataContainer::MCDataContainer(const std::string& name, bool portable) : Name(name),
  Portable(portable)
{
  if (unlikely(MCDataStorage::IsVerbose()))
  {
    MC_LOG("Container: %s - ctor", Name.c_str());
  }
}


MCDataContainer::~MCDataContainer()
{
  if (unlikely(MCDataStorage::IsVerbose()))
  {
    MC_LOG("Container: %s - dtor", Name.c_str());
  }
  Clear();
}


bool MCDataContainer::IsPortable() const
{
  return Portable;
}


void MCDataContainer::Clear()
{
  for (auto& item : Items)
  {
    item->DeleteData();
    delete item;
  }
  Items.clear();
}


std::string MCDataContainer::GetName() const
{
  return Name;
}


MCBinaryData* MCDataContainer::Encode() const
{
  // Huh, idea is from:
  // http://boost.2283326.n4.nabble.com/in-memory-stream-binary-archive-serialization-td2578880.html
  std::vector<char> TempBuffer;

  boost::iostreams::stream<boost::iostreams::back_insert_device<std::vector<char> > > OutStream(TempBuffer);
  {
    if (Portable)
    {
      eos::portable_oarchive OutputArchive(OutStream);

      OutputArchive << *this;
    } else {
      boost::archive::binary_oarchive OutputArchive(OutStream);

      OutputArchive << *this;
    }
  }
  MCBinaryData* BinaryData = new MCBinaryData((int)TempBuffer.size());

  memcpy(BinaryData->GetData(), &TempBuffer[0], TempBuffer.size());
  return BinaryData;
}


MCDataContainer* MCDataContainer::Decode(const MCBinaryData& data, bool portable,
                                         MCDataContainer* instance)
{
  boost::iostreams::basic_array_source<char> Source((char*)data.GetData(), (std::size_t)data.GetSize());
  boost::iostreams::stream<boost::iostreams::basic_array_source<char> > InStream(Source);
  MCDataContainer* DataContainer = instance ? instance : new MCDataContainer("SpecialNameLoad", portable);

  if (portable)
  {
    MC_TRY_BEGIN_1(1)
      eos::portable_iarchive InputArchive(InStream);

      InputArchive >> *DataContainer;
    MC_CATCH_BEGIN_1(1)
      // Destroy the newly allocated container
      if (!instance)
      {
        delete DataContainer;
        DataContainer = nullptr;
      }
      return nullptr;
    MC_CATCH_END_1(1)
  } else {
    MC_TRY_BEGIN_1(2)
      boost::archive::binary_iarchive InputArchive(InStream);

      InputArchive >> *DataContainer;
    MC_CATCH_BEGIN_1(2)
      // Destroy the newly allocated container
      if (!instance)
      {
        delete DataContainer;
        DataContainer = nullptr;
      }
      return nullptr;
    MC_CATCH_END_1(2)
  }
  return DataContainer;
}


void MCDataContainer::Dump() const
{
  printf("Data container: %s\n", Name.c_str());
  std::string DebugStr = "Data: ";

  for (auto& item : Items)
  {
    DebugStr += item->DataName+", ";
  }
  DebugStr.erase(DebugStr.size()-2, 2);
  printf("%s\n", DebugStr.c_str());
}


MC::StringList MCDataContainer::GetDataNames() const
{
  MC::StringList DataNames;

  for (auto& item : Items)
  {
    DataNames.push_back(item->DataName);
  }
  return DataNames;
}


void MCDataContainer::AddData(MCDataItemBase& item)
{
  // Remove an old data with the same name
  for (auto iter = Items.begin(); iter != Items.end(); ++iter)
  {
    if ((*iter)->DataName == item.DataName)
    {
      (*iter)->DeleteData();
      delete *iter;
      Items.erase(iter);
      break;
    }
  }
  Items.push_back(&item);
}


MCDataItemBase* MCDataContainer::GetData(const std::string& data_name)
{
  for (auto item : Items)
  {
    if (item->DataName == data_name)
    {
      return item;
    }
  }
  return nullptr;
}


const MC::DataItemBasePtrList& MCDataContainer::GetAllData() const
{
  return Items;
}


void MCDataContainer::RemoveData(const std::string& data_name)
{
  for (auto iter = Items.begin(); iter != Items.end(); ++iter)
  {
    if ((*iter)->DataName == data_name)
    {
      (*iter)->DeleteData();
      Items.erase(iter);
      return;
    }
  }
}


MCDataItemBase* MCDataContainer::GetInputArchiveDataType(const std::string& type_name,
                                                         const std::string& data_name)
{
  MC_UNUSED(type_name);
  MC_UNUSED(data_name);
  return nullptr;
}


template<class Archive>
void MCDataContainer::load(Archive& archive, const unsigned int version)
{
  MC_UNUSED(version);
  // Container ID
  std::string ContainerID;

  archive & ContainerID;
  if (ContainerID != "DataContainer")
  {
    MC_WARNING("The archive does not contain a data container.");
    return;
  }
  // Name
  archive & Name;
  // Number of items
  int ItemCount = 0;

  archive & ItemCount;
  for (int i = 0; i < ItemCount; ++i)
  {
    std::string DataName;
    std::string TypeName;
    MCDataItemBase* NewItem = nullptr;

    archive & DataName;
    archive & TypeName;

#define MA_DATA_ITEM_LOAD(_basic_type) \
  if (TypeName == std::string(#_basic_type)) \
  { \
    NewItem = new MCDataItem<_basic_type>(*new _basic_type, DataName, false); \
  } else
#define MA_DATA_ITEM_CONTAINER_LOAD(_container, _basic_type) \
  if (TypeName == std::string(#_container)+'<'+#_basic_type+", std::allocator<"+#_basic_type+"> >") \
  { \
    NewItem = new MCDataItem<_container<_basic_type> >(*new _container<_basic_type>, DataName, false); \
  } else
#define MA_DATA_ITEM_TABLE_LOAD(_container, _basic_type) \
  if (TypeName == std::string(#_container)+'<'+#_container+'<'+#_basic_type+", std::allocator<"+#_basic_type+"> >"+ \
      ", std::allocator<"+#_container+'<'+#_basic_type+", std::allocator<"+#_basic_type+"> > > >") \
  { \
    NewItem = new MCDataItem<_container<_container<_basic_type> > >(*new _container<_container<_basic_type> >, DataName, false); \
  } else
#define MA_DATA_ITEM_MAP_CONTAINER_LOAD(_map_container, _key_type, _value_type) \
  if (TypeName == std::string(#_map_container)+'<'+#_key_type+", "+#_value_type+ \
      ", std::less<"+#_key_type+">, std::allocator<std::pair<"+#_key_type+" const, "+#_value_type+"> > >") \
  { \
    NewItem = new MCDataItem<_map_container<_key_type, _value_type> > \
                    (*new _map_container<_key_type, _value_type>, DataName, false); \
  } else
#define MA_DATA_ITEM_CONTAINER_LOAD_BASIC_TYPES(_container) \
  MA_DATA_ITEM_CONTAINER_LOAD(_container, bool) \
  MA_DATA_ITEM_CONTAINER_LOAD(_container, int) \
  MA_DATA_ITEM_CONTAINER_LOAD(_container, float) \
  MA_DATA_ITEM_CONTAINER_LOAD(_container, double) \
  MA_DATA_ITEM_CONTAINER_LOAD(_container, char)

#define MA_DATA_ITEM_CONTAINER_LOAD_OTHER_TYPES(_container) \
  MA_DATA_ITEM_CONTAINER_LOAD(_container, short) \
  MA_DATA_ITEM_CONTAINER_LOAD(_container, unsigned char) \
  MA_DATA_ITEM_CONTAINER_LOAD(_container, unsigned short) \
  MA_DATA_ITEM_CONTAINER_LOAD(_container, unsigned int) \
  MA_DATA_ITEM_CONTAINER_LOAD(_container, uint8_t) \
  MA_DATA_ITEM_CONTAINER_LOAD(_container, uint16_t) \
  MA_DATA_ITEM_CONTAINER_LOAD(_container, uint32_t) \
  MA_DATA_ITEM_CONTAINER_LOAD(_container, int8_t) \
  MA_DATA_ITEM_CONTAINER_LOAD(_container, int16_t) \
  MA_DATA_ITEM_CONTAINER_LOAD(_container, int32_t)

#define MA_DATA_ITEM_TABLE_LOAD_BASIC_TYPES(_container) \
  MA_DATA_ITEM_TABLE_LOAD(_container, bool) \
  MA_DATA_ITEM_TABLE_LOAD(_container, int) \
  MA_DATA_ITEM_TABLE_LOAD(_container, float) \
  MA_DATA_ITEM_TABLE_LOAD(_container, double) \
  MA_DATA_ITEM_TABLE_LOAD(_container, char)

#define MA_DATA_ITEM_TABLE_LOAD_OTHER_TYPES(_container) \
  MA_DATA_ITEM_TABLE_LOAD(_container, short) \
  MA_DATA_ITEM_TABLE_LOAD(_container, unsigned char) \
  MA_DATA_ITEM_TABLE_LOAD(_container, unsigned short) \
  MA_DATA_ITEM_TABLE_LOAD(_container, unsigned int) \
  MA_DATA_ITEM_TABLE_LOAD(_container, uint8_t) \
  MA_DATA_ITEM_TABLE_LOAD(_container, uint16_t) \
  MA_DATA_ITEM_TABLE_LOAD(_container, uint32_t) \
  MA_DATA_ITEM_TABLE_LOAD(_container, int8_t) \
  MA_DATA_ITEM_TABLE_LOAD(_container, int16_t) \
  MA_DATA_ITEM_TABLE_LOAD(_container, int32_t)

    MA_DATA_ITEM_LOAD(bool)
    MA_DATA_ITEM_LOAD(int)
    MA_DATA_ITEM_LOAD(float)
    MA_DATA_ITEM_LOAD(double)
    MA_DATA_ITEM_LOAD(char)
    // std::string must be handled separately because of the new C++ ABI since GCC 5.x
    if (TypeName == MCGetClassName<std::string>() || TypeName == "std::string")
    {
      NewItem = new MCDataItem<std::string>(*new std::string, DataName, false);
    } else
    MA_DATA_ITEM_LOAD(MCBinaryData)
    MA_DATA_ITEM_CONTAINER_LOAD_BASIC_TYPES(std::vector)
    // std::string must be handled separately because of the new C++ ABI since GCC 5.x
    if (TypeName == "std::vector<"+MCGetClassName<std::string>()+", std::allocator<"+MCGetClassName<std::string>()+" > >" ||
        TypeName == "std::vector<std::string, std::allocator<std::string> >")
    {
      NewItem = new MCDataItem<std::vector<std::string> >(*new std::vector<std::string>, DataName, false);
    } else
    MA_DATA_ITEM_TABLE_LOAD_BASIC_TYPES(std::vector)
    // std::string must be handled separately because of the new C++ ABI since GCC 5.x
    if (TypeName == std::string("std::vector<std::vector<"+MCGetClassName<std::string>()+", std::allocator<"+MCGetClassName<std::string>()+" > >")+
        ", std::allocator<std::vector<"+MCGetClassName<std::string>()+", std::allocator<"+MCGetClassName<std::string>()+" > > > >" ||
        TypeName == std::string("std::vector<std::vector<std::string, std::allocator<std::string> >")+
        ", std::allocator<std::vector<std::string, std::allocator<std::string> > > >")
    {
      NewItem = new MCDataItem<std::vector<std::vector<std::string> > >(*new std::vector<std::vector<std::string> >, DataName, false);
    } else
    MA_DATA_ITEM_MAP_CONTAINER_LOAD(std::map, float, float)
    // Note: Comment these types to avoid any performance hits
//    MA_DATA_ITEM_MAP_CONTAINER_LOAD(std::map, double, double)
//    MA_DATA_ITEM_MAP_CONTAINER_LOAD(std::map, int, float)
//    MA_DATA_ITEM_MAP_CONTAINER_LOAD(std::map, int, double)
//    MA_DATA_ITEM_MAP_CONTAINER_LOAD(std::map, int, int)
//    MA_DATA_ITEM_MAP_CONTAINER_LOAD(std::map, std::__cxx11::string, std::__cxx11::string)
//    MA_DATA_ITEM_MAP_CONTAINER_LOAD(std::map, std::__cxx11::string, int)
//    MA_DATA_ITEM_MAP_CONTAINER_LOAD(std::map, std::__cxx11::string, float)
//    MA_DATA_ITEM_MAP_CONTAINER_LOAD(std::map, std::__cxx11::string, double)
//    MA_DATA_ITEM_LOAD(short)
//    MA_DATA_ITEM_LOAD(unsigned char)
//    MA_DATA_ITEM_LOAD(unsigned short)
//    MA_DATA_ITEM_LOAD(unsigned int)
//    MA_DATA_ITEM_LOAD(uint8_t)
//    MA_DATA_ITEM_LOAD(uint16_t)
//    MA_DATA_ITEM_LOAD(uint32_t)
//    MA_DATA_ITEM_LOAD(int8_t)
//    MA_DATA_ITEM_LOAD(int16_t)
//    MA_DATA_ITEM_LOAD(int32_t)
//    MA_DATA_ITEM_CONTAINER_LOAD_OTHER_TYPES(std::vector)
//    MA_DATA_ITEM_TABLE_LOAD_OTHER_TYPES(std::vector)
//    MA_DATA_ITEM_CONTAINER_LOAD_BASIC_TYPES(std::list)
//    MA_DATA_ITEM_CONTAINER_LOAD_OTHER_TYPES(std::list)
//    MA_DATA_ITEM_TABLE_LOAD_BASIC_TYPES(std::list)
    {
      NewItem = GetInputArchiveDataType(TypeName, DataName);
    }
#undef MA_DATA_ITEM_LOAD
#undef MA_DATA_ITEM_CONTAINER_LOAD
#undef MA_DATA_ITEM_CONTAINER_LOAD_BASIC_TYPES
#undef MA_DATA_ITEM_CONTAINER_LOAD_OTHER_TYPES
#undef MA_DATA_ITEM_TABLE_LOAD
#undef MA_DATA_ITEM_TABLE_LOAD_BASIC_TYPES
#undef MA_DATA_ITEM_TABLE_LOAD_OTHER_TYPES

    if (!NewItem)
    {
      MC_WARNING("Not supported type: %s -> Abort loading", TypeName.c_str());
      return;
    } else {
      NewItem->LoadFromArchive(archive);
      Items.push_back(NewItem);
      NewItem = nullptr;
    }
  }
}


template<class Archive>
void MCDataContainer::save(Archive& archive, const unsigned int version) const
{
  MC_UNUSED(version);
  // Container ID
  std::string ContainerID = "DataContainer";

  archive & ContainerID;
  // Name
  archive & Name;
  // Number of items
  int ItemCount = Items.size();

  archive & ItemCount;
  for (auto& item : Items)
  {
    archive & item->DataName;
    archive & item->TypeName;
    item->SaveToArchive(archive);
  }
}

// Explicit template instantiation
// http://stackoverflow.com/questions/2152002/how-do-i-force-a-particular-instance-of-a-c-template-to-instantiate
// Post by Alexander Poluektov
template void MCDataContainer::load<boost::archive::binary_iarchive>(boost::archive::binary_iarchive&,
                                                                     const unsigned int);
template void MCDataContainer::save<boost::archive::binary_oarchive>(boost::archive::binary_oarchive&,
                                                                     const unsigned int) const;
template void MCDataContainer::load<eos::portable_iarchive>(eos::portable_iarchive&, const unsigned int);
template void MCDataContainer::save<eos::portable_oarchive>(eos::portable_oarchive&, const unsigned int) const;