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

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

MACollectedData::MACollectedData(const int session_id, const std::string& name, const int id,
                                 const std::string& variable_map) :
  DataStorage(new MCDataStorage(name, true))
{
  MC::DataContainerSPtr Container = DataStorage->CreateContainer("UserData");

  Container->AddData(*new MCDataItem<std::string>(variable_map, "RobotStateVariableMap"));
  Container->AddData(*new MCDataItem<int>(id, "CollectionID"));
  Container->AddData(*new MCDataItem<int>(session_id, "SessionID"));
}


std::string MACollectedData::GetName() const
{
  return DataStorage->GetName();
}


int MACollectedData::GetCollectionID()
{
  MC::DataContainerSPtr Container = DataStorage->GetContainer("UserData");

  return *reinterpret_cast<int*>(Container->GetData("CollectionID")->DataPtr);
}


int MACollectedData::GetSessionID()
{
  MC::DataContainerSPtr Container = DataStorage->GetContainer("UserData");

  return *reinterpret_cast<int*>(Container->GetData("SessionID")->DataPtr);
}


void MACollectedData::SetCustomData(const std::string& data_name, const MCBinaryData& data_value)
{
  if (data_name.empty())
    return;

  MC::DataContainerSPtr Container = DataStorage->GetContainer("UserData");

  Container->AddData(*new MCDataItem<MCBinaryData>(data_value, data_name));
}


MCBinaryData* MACollectedData::GetCustomData(const std::string& data_name)
{
  MC::DataContainerSPtr Container = DataStorage->GetContainer("UserData");
  MCDataItemBase* DataItem = Container->GetData(data_name);

  if (DataItem && MCGetClassName<MCBinaryData>() == DataItem->TypeName)
  {
    MCBinaryData* BinaryData = new MCBinaryData;

    *BinaryData = *reinterpret_cast<MCBinaryData*>(DataItem->DataPtr);
    return BinaryData;
  }
  return nullptr;
}


bool MACollectedData::IsCompact() const
{
  return DataStorage->IsCompact();
}


void MACollectedData::MakeCompact()
{
  DataStorage->OptimizeCachedContainers();
}


void MACollectedData::PrintSummary()
{
  MC::StringList ContainerNames = DataStorage->GetContainerNames();

  for (unsigned int i = 0; i < ContainerNames.size(); ++i)
  {
    MC_LOG("%s: %d items", ContainerNames[i].c_str(),
           DataStorage->GetContainer(ContainerNames[i])->GetAllData().size());
  }
}


const std::string& MACollectedData::GetRobotStateVariableMap() const
{
  MC::DataContainerSPtr Container = DataStorage->GetContainer("UserData");

  return *reinterpret_cast<std::string*>(Container->GetData("RobotStateVariableMap")->DataPtr);
}


void MACollectedData::AddNewData(const std::string& name, int cycle_id, const MCBinaryData& data)
{
  if (name == "UserData")
  {
    MC_WARNING("UserData container cannot store collected data.");
    return;
  }
  MC::DataContainerSPtr DataContainer = DataStorage->GetContainer(name);

  if (!DataContainer.get())
  {
    DataContainer = DataStorage->CreateContainer(name);
  }
  // The data is cloned to avoid any resource handling problem
  DataContainer->AddData(*new MCDataItem<MCBinaryData>(data, MCToStr(cycle_id)));
}


MA::BinaryDataPtrList MACollectedData::GetAllDataByTypeName(const std::string& type_name)
{
  MC::DataContainerSPtr DataContainer = DataStorage->GetContainer(type_name);

  if (!DataContainer.get())
  {
    MC_WARNING("Data type is not collected (%s)\n", type_name.c_str());
    return MA::BinaryDataPtrList();
  }
  MA::BinaryDataPtrList CollectedData;
  const MC::DataItemBasePtrList& DataItems = DataContainer->GetAllData();

  for (auto& item : DataItems)
  {
    if (item->TypeName == "MCBinaryData")
    {
      CollectedData.push_back(reinterpret_cast<MCBinaryData*>(item->DataPtr));
    }
  }
  return CollectedData;
}


MCBinaryData* MACollectedData::Encode() const
{
  return DataStorage->Encode();
}


MACollectedData* MACollectedData::Decode(const MCBinaryData& data)
{
  MCDataStorage* DataStorage = MCDataStorage::Decode(data, true);

  if (DataStorage)
  {
    MACollectedData* CollectedData = new MACollectedData(0, "", 0, "");

    CollectedData->DataStorage.reset(DataStorage);
    return CollectedData;
  }
  return nullptr;
}