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

#include <MCLog.hpp>
#include <MCThreadLocalData.hpp>
#include <MCTimer.hpp>

#include <boost/algorithm/string/replace.hpp>
#include <boost/tuple/tuple.hpp>

#include <vector>

namespace
{
typedef boost::tuple<int64_t, std::string, MC::IntList> RandomPointType;
typedef std::vector<RandomPointType> RandomPointList;

// Registered random point list
MCThreadLocalData<RandomPointList> RandomPoints(true);

void CheckStaticRandomnessVariables()
{
  if (unlikely(!RandomPoints.get()))
  {
    RandomPoints.reset(new RandomPointList);
  }
}
}

MC::IntList MARandomness::GenerateRandomPoint(const std::string& id, unsigned int count,
                                              int min, int max)
{
  MC::IntList RandomNumbers;
  unsigned int Count = count == 0 ? 1 : count;

  for (unsigned int i = 0; i < Count; ++i)
  {
    RandomNumbers.push_back(MCRandComplex<int>(min, max));
  }
  LogRandomPoint(id, RandomNumbers);
  return RandomNumbers;
}


void MARandomness::RegisterRandomPoint(int64_t timestamp, const std::string& id,
                                       const int number)
{
  MC::IntList Numbers;

  CheckStaticRandomnessVariables();
  Numbers.push_back(number);
#if defined(__clang__)
  // The clang gives old ABI version (std::string) for __PRETTY_FUNCTION__ thus it needs workaround
  std::string ID(id);

  boost::replace_all(ID, "std::string", "std::__cxx11::string");
  RandomPoints->push_back(RandomPointType(timestamp, ID, Numbers));
#else
  RandomPoints->push_back(RandomPointType(timestamp, id, Numbers));
#endif
}


void MARandomness::RegisterRandomPoint(int64_t timestamp, const std::string& id,
                                       const MC::IntList& numbers)
{
  CheckStaticRandomnessVariables();
#if defined(__clang__)
  // The clang gives old ABI version (std::string) for __PRETTY_FUNCTION__ thus it needs workaround
  std::string ID(id);

  boost::replace_all(ID, "std::string", "std::__cxx11::string");
  RandomPoints->push_back(RandomPointType(timestamp, ID, numbers));
#else
  RandomPoints->push_back(RandomPointType(timestamp, id, numbers));
#endif
}


MC::IntList MARandomness::QueryRandomPoint(const std::string& id, unsigned int count, int min)
{
  int64_t CurrentTime = MCTimer::GetElapsedSystemTime() / 1000;
  unsigned int Count = count == 0 ? 1 : count;
  std::string ID(id);
  ::RandomPointList& RandomPointList = *RandomPoints.get();

#if defined(__clang__)
  // The clang gives old ABI version (std::string) for __PRETTY_FUNCTION__ thus it needs workaround
  boost::replace_all(ID, "std::string", "std::__cxx11::string");
#endif
  CheckStaticRandomnessVariables();
//  printf("Query random point: %s\n", ID.c_str());
  // Remove obsolete random points
  while (!RandomPointList.empty() && RandomPointList.begin()->get<0>() < CurrentTime-5*1000)
  {
    RandomPointList.erase(RandomPointList.begin());
  }
  // Search for the random point
  for (auto iter = RandomPointList.begin(); iter != RandomPointList.end(); ++iter)
  {
    // Unable to find the random point
    if (iter->get<0>() < CurrentTime-5*1000)
    {
//      printf("Query random point: %d < %d\n", (int)iter->get<0>(), (int)CurrentTime);
      MC_WARNING("Unable to find the random point (%s)", ID.c_str());
      return MC::IntList(Count, min);
    }
    if (iter->get<1>() == ID)
    {
      MC::IntList Numbers = iter->get<2>();

      RandomPointList.erase(iter);
      LogRandomPoint(ID, Numbers);
      return Numbers;
    }
  }
  MC_WARNING("Unable to find the random point (%s)", ID.c_str());
  return MC::IntList(Count, min);
}


bool MARandomness::IsAnyRegisteredPoint()
{
  CheckStaticRandomnessVariables();
  return !RandomPoints->empty();
}


void MARandomness::LogRandomPoint(const std::string& id, const MC::IntList& numbers)
{
  std::string LogMessage = "Random point: ["+id+'|';

  for (unsigned int i = 0; i < numbers.size(); ++i)
  {
    LogMessage += MCToStr(numbers[i]);
    if (i < numbers.size()-1)
      LogMessage += ',';
  }
  LogMessage += ']';
  MC_LOG("%s", LogMessage.c_str());
}