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

#include <boost/math/constants/constants.hpp>

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

#include "MADevice.hpp"
#include "MARandomness.hpp"

MAGeneratorBase::MAGeneratorBase(float min, float max) : MinValue(min), MaxValue(max),
  Duration(0), Timer(new MCTimer), Function(Linear)
{
}


MAGeneratorBase::~MAGeneratorBase()
{
}


MAGeneratorBase::FunctionType MAGeneratorBase::GetRandomFunction()
{
  MA_RANDOM_POINT_1(TransferFunction, (int)MAGeneratorBase::FunctionTypeMin,
                    (int)MAGeneratorBase::FunctionTypeMax);

  return (FunctionType)TransferFunction;
}


bool MAGeneratorBase::IsAbsolute() const
{
  return !MCIsFloatInfinity(MinValue) && !MCIsFloatInfinity(MaxValue);
}


int MAGeneratorBase::GetStartTime() const
{
  return Timer->GetStartTime();
}


int MAGeneratorBase::GetElapsedTime() const
{
  return Timer->GetElapsedTime();
}


int MAGeneratorBase::GetDuration() const
{
  return Duration;
}


void MAGeneratorBase::ScaleDuration(float scale)
{
  if (scale <= 0 || scale == 1.0 || Duration < 0)
    return;

  Duration = (int)((float)Duration*scale);
}


float MAGeneratorBase::GetMinValue() const
{
  return MinValue;
}


void MAGeneratorBase::SetMinValue(float min_value)
{
  if (MCIsFloatInfinity(min_value))
    return;

  MinValue = min_value;
}


float MAGeneratorBase::GetMaxValue() const
{
  return MaxValue;
}


void MAGeneratorBase::SetMaxValue(float max_value)
{
  if (MCIsFloatInfinity(max_value))
    return;

  MaxValue = max_value;
}


void MAGeneratorBase::SetTransferFunction(FunctionType function)
{
  Function = function;
}


bool MAGeneratorBase::IsStarted() const
{
  return Timer->IsStarted();
}


void MAGeneratorBase::Start()
{
  if (unlikely(MCIsFloatInfinity(GetMinValue())))
  {
    MC_WARNING("The minimum (start) value of the value generator has not been initialized yet.");
    return;
  }
  if (unlikely(MCIsFloatInfinity(GetMaxValue())))
  {
    MC_WARNING("The maximum (target) value of the value generator has not been initialized yet.");
    return;
  }

  // It does not matter how we start the timer as we are interested only
  // in the elapsed time for the value generation
  Timer->Start();
}


void MAGeneratorBase::Start(float value)
{
  if (unlikely(MCIsFloatInfinity(GetMinValue())))
  {
    MC_WARNING("The minimum (start) value of the value generator has not been initialized yet.");
    return;
  }
  if (unlikely(MCIsFloatInfinity(GetMaxValue())))
  {
    MC_WARNING("The maximum (target) value of the value generator has not been initialized yet.");
    return;
  }
  if (!CheckValueRange(value, true))
  {
    // It does not matter how the timer is started as we are interested only
    // in the elapsed time for the value generation.
    Timer->Start();
    return;
  }
  int StartTime = 0;

  StartTime = (int)((float)(value-GetMinValue()) / (GetMaxValue()-GetMinValue())*Duration);
  Timer->Start(StartTime);
}


void MAGeneratorBase::StartFromTime(int start_time)
{
  if (unlikely(MCIsFloatInfinity(GetMinValue())))
  {
    MC_WARNING("The minimum (start) value of the value generator has not been initialized yet.");
    return;
  }
  if (unlikely(MCIsFloatInfinity(GetMaxValue())))
  {
    MC_WARNING("The maximum (target) value of the value generator has not been initialized yet.");
    return;
  }

  Timer->StartFromTime(start_time);
}


bool MAGeneratorBase::IsExpired() const
{
  return GetOverTime() > 0;
}


float MAGeneratorBase::GetTransformedValue(float value) const
{
  if (likely(Function == Linear || MinValue == MaxValue))
    return value;

  // Normalize the value interval to [0; π / 2]
  float NormalizedValue = (value-GetMinValue())*(boost::math::constants::pi<float>() / 2) /
                          (GetMaxValue()-GetMinValue());

  if (Function == DeceleratingSines)
  {
    return MinValue+sinf(NormalizedValue)*(GetMaxValue()-GetMinValue());
  }

  // Function == AcceleratingSines
  return MinValue+(1.0-sinf(boost::math::constants::pi<float>() / 2+NormalizedValue))*
         (GetMaxValue()-GetMinValue());
}


bool MAGeneratorBase::CheckValueRange(float value, bool verbose)
{
  if (!MCRangeCheck(value, MinValue, MaxValue))
  {
    if (verbose)
    {
      MC_WARNING("The value is out of the generator range %1.2f ∉ [%1.2f, %1.2f]",
                 value, MinValue, MaxValue);
    }
    return false;
  }
  return true;
}


MADelayGenerator::MADelayGenerator(int duration) : MAGeneratorBase()
{
  Duration = duration;
}


void MADelayGenerator::SetMinValue(float min_value)
{
  MAGeneratorBase::SetMinValue(min_value);
  MAGeneratorBase::SetMaxValue(min_value);
}


void MADelayGenerator::SetMaxValue(float max_value)
{
  MAGeneratorBase::SetMinValue(max_value);
  MAGeneratorBase::SetMaxValue(max_value);
}


void MADelayGenerator::Start()
{
  Timer->Start();
}


void MADelayGenerator::Start(float value)
{
  MC_UNUSED(value)

  Timer->Start();
}


void MADelayGenerator::StartFromTime(int start_time)
{
  Timer->StartFromTime(start_time);
}


float MADelayGenerator::GetCurrentValue()
{
  // The minimal and maximal values are the same
  return GetMinValue();
}


int MADelayGenerator::GetOverTime() const
{
  if (Duration < 0 || !IsStarted())
  {
    return 0;
  }
  int ElapsedTime = (int)Timer->GetElapsedTime();

  if (ElapsedTime >= Duration)
  {
    return ElapsedTime-Duration;
  }
  return 0;
}


MASimpleGenerator::MASimpleGenerator(float min, float max, int duration) :
  MAGeneratorBase(min, max)
{
  Duration = duration;
}


MASimpleGenerator::MASimpleGenerator(float max, int duration) :
  MAGeneratorBase(MCFloatInfinity(), max)
{
  Duration = duration;
}


float MASimpleGenerator::GetCurrentValue()
{
  if (unlikely(MCIsFloatInfinity(GetMinValue()) || MCIsFloatInfinity(GetMaxValue())))
  {
    return MCFloatInfinity();
  }
  int ElapsedTime = Timer->GetElapsedTime();
  float Ret = 0.0;

  if (ElapsedTime >= Duration)
  {
    Ret = GetMaxValue();
  } else {
    Ret = GetTransformedValue(GetMinValue()+(float)ElapsedTime / Duration*(GetMaxValue()-GetMinValue()));
  }
  return Ret;
}


int MASimpleGenerator::GetOverTime() const
{
  if (!IsStarted())
  {
    return 0;
  }
  int ElapsedTime = (int)Timer->GetElapsedTime();

  if (ElapsedTime >= Duration)
  {
    return ElapsedTime-Duration;
  }
  return 0;
}


MAPeriodicGenerator::MAPeriodicGenerator(float min, float max, int dur1, int dur2, int dur3,
                                         int dur4, int dur5, bool loop) :
  MAGeneratorBase(min, max)
{
  Duration1 = dur1;
  Duration2 = dur2;
  Duration3 = dur3;
  Duration4 = dur4;
  Duration5 = dur5;
  Loop = loop;
  if (Loop)
  {
    Duration = -2;
  } else {
    Duration = Duration1+Duration2+Duration3+Duration4+Duration5;
  }
  Timer->SetDuration(Duration);
}


MAPeriodicGenerator::MAPeriodicGenerator(float max, int dur1, int dur2, int dur3, int dur4,
                                         int dur5, bool loop) :
  MAGeneratorBase(MCFloatInfinity(), max)
{
  Duration1 = dur1;
  Duration2 = dur2;
  Duration3 = dur3;
  Duration4 = dur4;
  Duration5 = dur5;
  Loop = loop;
  if (Loop)
  {
    Duration = -2;
  } else {
    Duration = Duration1+Duration2+Duration3+Duration4+Duration5;
  }
  Timer->SetDuration(Duration);
}


void MAPeriodicGenerator::Start(float value)
{
  if (unlikely(MCIsFloatInfinity(GetMinValue())))
  {
    MC_WARNING("The minimum (start) value of the value generator has not been initialized yet.");
    return;
  }
  if (unlikely(MCIsFloatInfinity(GetMaxValue())))
  {
    MC_WARNING("The maximum (target) value of the value generator has not been initialized yet.");
    return;
  }

  if (!CheckValueRange(value, true))
  {
    // It does not matter how we start the timer as we are interested only
    // in the elapsed time for the value generation
    Timer->Start();
    return;
  }
  int StartTime = 0;

  StartTime = (int)((float)(value-GetMinValue()) / (GetMaxValue()-GetMinValue())*Duration2);
  Timer->Start(StartTime+Duration1);
}


void MAPeriodicGenerator::ScaleDuration(float scale)
{
  if (scale <= 0 || scale == 1.0 || Duration < 0)
    return;

  Duration1 = (int)((float)Duration1*scale);
  Duration2 = (int)((float)Duration2*scale);
  Duration3 = (int)((float)Duration3*scale);
  Duration4 = (int)((float)Duration4*scale);
  Duration5 = (int)((float)Duration5*scale);
  Duration = Duration1+Duration2+Duration3+Duration4+Duration5;
}


float MAPeriodicGenerator::GetCurrentValue()
{
  if (unlikely(MCIsFloatInfinity(GetMinValue()) || MCIsFloatInfinity(GetMaxValue())))
    return MCFloatInfinity();

  int ElapsedTime = Timer->GetElapsedTime();
  float Ret = 0.0;
  int CurrentPeriod;

  if (Loop)
  {
    CurrentPeriod = ElapsedTime % (Duration1+Duration2+Duration3+Duration4+Duration5);
  } else {
    CurrentPeriod = ElapsedTime;
  }

  if (CurrentPeriod < Duration1)
  {
    Ret = GetMinValue();
  } else
  if (CurrentPeriod < Duration1+Duration2)
  {
    Ret = GetTransformedValue(GetMinValue()+(float)(CurrentPeriod-Duration1) /
                              Duration2*(GetMaxValue()-GetMinValue()));
  } else
  if (CurrentPeriod < Duration1+Duration2+Duration3)
  {
    Ret = GetMaxValue();
  } else
  if (CurrentPeriod < Duration1+Duration2+Duration3+Duration4)
  {
    Ret = GetTransformedValue(GetMinValue()+(float)(1.0-((float)CurrentPeriod-Duration1-Duration2-Duration3) /
                              Duration4)*(GetMaxValue()-GetMinValue()));
  } else {
    Ret = GetMinValue();
  }
  return Ret;
}


int MAPeriodicGenerator::GetOverTime() const
{
  if (Loop || !IsStarted())
  {
    return 0;
  }
  int ElapsedTime = (int)Timer->GetElapsedTime();

  if (ElapsedTime >= Duration)
  {
    return ElapsedTime-Duration;
  }
  return 0;
}

namespace
{
// Generator containers
MCThreadLocalData<MA::GeneratorContainerList> Containers(true);
// Verbose mode
MCThreadLocalData<bool> Verbose(true);

void CheckStaticGeneratorContainerVariables()
{
  if (unlikely(!Containers.get()))
  {
    Containers.reset(new MA::GeneratorContainerList);
    Verbose.reset(new bool);
    *Verbose = false;
  }
}
}

MAGeneratorContainer::MAGeneratorContainer(MAGeneratorBase& generator) : ExpiredSignal(new ExpiredSignalType),
  Device(nullptr), StartingValue(generator.GetMinValue()), CurrentValue(MCFloatInfinity()), TransitionName(""),
  AlreadyExpired(false), ExpiredSignalBlockRefCount(0)
{
  CheckStaticGeneratorContainerVariables();
  Containers->push_back(this);
  Generators.push_back(&generator);
  if (*Verbose)
  {
    MC_LOG(std::string("Create container: "+MCToStr(this)).c_str());
  }
}


MAGeneratorContainer::~MAGeneratorContainer()
{
  if (*Verbose)
  {
    if (Device)
    {
      MC_LOG(std::string("Delete container ("+MCToStr(this)+", transition: "+
                         TransitionName+", owner: "+Device->GetDisplayName()+')').c_str());
    } else {
      MC_LOG(std::string("Delete container ("+MCToStr(this)+", transition: "+TransitionName+')').c_str());
    }
 }
  if (!AlreadyExpired && !IsExpiredSignalBlocked())
  {
    (*ExpiredSignal).Emit(*this);
  }

  // Remove the current instance from the global generator container list
  Containers->erase(std::find(Containers->begin(), Containers->end(), this));

  for (unsigned int i = 0; i < Generators.size(); ++i)
  {
    delete Generators[i];
  }
  Generators.clear();
}


void MAGeneratorContainer::DumpAllContainers()
{
  MC_LOG("----- Generatorcontainer list BEGIN -----");
  MA::GeneratorContainerList& ContainerList = *Containers.get();

  for (auto& container : ContainerList)
  {
    MC_LOG(std::string("Container:"+MCToStr(container)).c_str());
  }
  for (auto& container : ContainerList)
  {
    // Block the "Expired" notification to avoid recursions/iterator problems
    container->BlockExpiredSignal();
    container->Dump();
    container->UnblockExpiredSignal();
  }
  MC_LOG("----- Generatorcontainer list END -----");
}


void MAGeneratorContainer::SetVerbose(bool new_state)
{
  CheckStaticGeneratorContainerVariables();
  *Verbose = new_state;
}


void MAGeneratorContainer::SetOwnerDevice(MADevice& owner)
{
  Device = &owner;
  if (*Verbose)
  {
    if (Device)
    {
      MC_LOG(std::string("New owner for the container ("+MCToStr(this)+", transition: "+
                         TransitionName+", owner: "+Device->GetDisplayName()+')').c_str());
    } else {
      MC_LOG(std::string("New owner for the container ("+MCToStr(this)+", transition: "+
                         TransitionName+')').c_str());
    }
  }
}


void MAGeneratorContainer::BlockExpiredSignal()
{
  ExpiredSignalBlockRefCount++;
}


void MAGeneratorContainer::UnblockExpiredSignal()
{
  ExpiredSignalBlockRefCount--;
}


bool MAGeneratorContainer::IsExpiredSignalBlocked() const
{
  return ExpiredSignalBlockRefCount > 0;
}


void MAGeneratorContainer::SetTransitionName(const std::string& name)
{
  TransitionName = name;
}


std::string MAGeneratorContainer::GetTransitionName() const
{
  return TransitionName;
}


bool MAGeneratorContainer::IsAbsolute() const
{
  for (auto& generator : Generators)
  {
    // Search for the first non-delay generator and determinate if it is absolute or not
    // Note: This check relies on the fact that only absolute generator can be added to an
    // absolute container and non-absolute to a non-absolute container.
    if (!dynamic_cast<MADelayGenerator*>(generator))
      return generator->IsAbsolute();
  }
  // Case: The container contains only delay generators
  return false;
}


int MAGeneratorContainer::GetDuration() const
{
  int Duration = 0;

  for (auto& generator : Generators)
  {
    if (generator->GetDuration() < 0)
    {
      return -1;
    }
    Duration += generator->GetDuration();
  }
  return Duration;
}


void MAGeneratorContainer::ScaleDuration(float scale)
{
  if (scale <= 0 || scale == 1.0)
    return;

  for (auto& generator : Generators)
  {
    if (generator->GetDuration() > 0)
    {
      generator->ScaleDuration(scale);
    }
  }
}


bool MAGeneratorContainer::IsFinite() const
{
  return GetDuration() >= 0;
}


bool MAGeneratorContainer::IsPermanent() const
{
  return !IsFinite();
}


bool MAGeneratorContainer::IsStarted() const
{
  return Generators.size() > 0 && Generators[0]->IsStarted();
}


bool MAGeneratorContainer::IsExpired()
{
  if (!IsStarted() || !IsFinite())
  {
    return false;
  }
  bool Expired = Generators.size() == 1 && Generators[0]->IsExpired();

  if (Expired && !AlreadyExpired && !IsExpiredSignalBlocked())
  {
    AlreadyExpired = true;
    BlockExpiredSignal();
    if (*Verbose)
    {
      if (Device)
      {
        MC_LOG(std::string("Container expired ("+MCToStr(this)+", transition: "+
                           TransitionName+", owner: "+Device->GetDisplayName()+')').c_str());
      } else {
        MC_LOG(std::string("Container expired ("+MCToStr(this)+", transition: "+TransitionName+')').c_str());
      }
    }
    (*ExpiredSignal).Emit(*this);
    UnblockExpiredSignal();
  }
  return Expired;
}


bool MAGeneratorContainer::HasOneGenerator() const
{
  return Generators.size() == 1;
}


bool MAGeneratorContainer::HasRealGenerator() const
{
  for (auto& generator : Generators)
  {
    if (!dynamic_cast<MADelayGenerator*>(generator))
      return true;
  }
  return false;
}


void MAGeneratorContainer::AddGenerator(MAGeneratorBase& generator, bool in_front)
{
  if (IsPermanent())
  {
    MC_WARNING("It is not allowed to add new generators to a permanent container.");
    return;
  }
  // Set the start value of the new generator if needs be
  if (!in_front && MCIsFloatInfinity(generator.GetMinValue()) && !MCIsFloatInfinity(GetTargetValue()))
  {
    generator.SetMinValue(GetTargetValue());
  }
  if (HasRealGenerator() && !IsAbsolute() && generator.IsAbsolute() &&
      !dynamic_cast<MADelayGenerator*>(&generator) &&
      GetTargetValue() != generator.GetMinValue())
  {
    MC_WARNING("It is not allowed to add an absolute generator to a relative container.");
    return;
  }
  if (HasRealGenerator() && IsAbsolute() && !generator.IsAbsolute())
  {
    MC_WARNING("It is not allowed to add a relative generator to an absolute container.");
    return;
  }
  if (in_front)
  {
    Generators.insert(Generators.begin(), &generator);
  } else {
    Generators.push_back(&generator);
  }
}


void MAGeneratorContainer::ScaleGenerators(float min, float max, float new_max)
{
  for (auto& generator : Generators)
  {
    float NewMinValue = MCScaleValue(generator->GetMinValue(), min, max, new_max);
    float NewMaxValue = MCScaleValue(generator->GetMaxValue(), min, max, new_max);

    generator->SetMinValue(NewMinValue);
    generator->SetMaxValue(NewMaxValue);
  }
}


void MAGeneratorContainer::Start(float device_value)
{
  if (Generators[0]->IsStarted())
    return;

  if (unlikely(MCIsFloatInfinity(StartingValue)))
  {
    if (MCIsFloatInfinity(Generators[0]->GetMinValue()))
    {
      StartingValue = device_value;
    } else {
      StartingValue = Generators[0]->GetMinValue();
    }
  }

  if (!(dynamic_cast<MADelayGenerator*>(Generators[0]) && MCIsFloatInfinity(CurrentValue)))
  {
    if (unlikely(MCIsFloatInfinity(Generators[0]->GetMinValue())))
    {
      Generators[0]->SetMinValue(device_value);
    }
    if (unlikely(MCIsFloatInfinity(Generators[0]->GetMaxValue())))
    {
      Generators[0]->SetMaxValue(device_value);
    }
  }
  Generators[0]->Start();
  if (*Verbose)
  {
    if (Device)
    {
      MC_LOG(std::string("Container started ("+MCToStr(this)+", transition: "+
                         TransitionName+", owner: "+Device->GetDisplayName()+')').c_str());
    } else {
      MC_LOG(std::string("Container started ("+MCToStr(this)+", transition: "+TransitionName+')').c_str());
    }
  }
}


void MAGeneratorContainer::CalculateCurrentValue(float device_value)
{
  if (!IsStarted() || IsExpired())
    return;
  float OldValue = MCFloatInfinity();

  // Remove the expired top generator if possible
  while (Generators[0]->IsExpired() && Generators.size() > 1)
  {
    // Store the last generated value
    OldValue = Generators[0]->GetCurrentValue();
    if (MCIsFloatInfinity(Generators[1]->GetMinValue()))
    {
      if (MCIsFloatInfinity(OldValue) && !dynamic_cast<MADelayGenerator*>(Generators[1]))
      {
        // Case: Delay generator in the first position -> it keeps infinite min/max values
        Generators[1]->SetMinValue(device_value);
      } else {
        Generators[1]->SetMinValue(OldValue);
      }
    }
    if (MCIsFloatInfinity(Generators[1]->GetMaxValue()))
    {
      if (MCIsFloatInfinity(OldValue) && !dynamic_cast<MADelayGenerator*>(Generators[1]))
      {
        // Case: Delay generator in the first position -> it keeps infinite min/max values
        Generators[1]->SetMaxValue(device_value);
      } else {
        Generators[1]->SetMaxValue(OldValue);
      }
    }
    Generators[1]->StartFromTime(Generators[0]->GetStartTime()+Generators[0]->GetDuration());
    delete Generators[0];
    Generators.erase(Generators.begin());
  }
  if (!Generators[0]->IsStarted())
  {
    if (MCIsFloatInfinity(OldValue))
    {
      Start(device_value);
    } else {
      // Use the old generator last value
      Start(OldValue);
    }
  }
  CurrentValue = Generators[0]->GetCurrentValue();
}


float MAGeneratorContainer::GetCurrentValue()
{
  if (IsExpired())
  {
    return GetTargetValue();
  }
  if (MCIsFloatInfinity(CurrentValue))
  {
    return Generators[0]->GetMinValue();
  }
  return CurrentValue;
}


float MAGeneratorContainer::GetStartingValue() const
{
  return StartingValue;
}


float MAGeneratorContainer::GetDesiredStartingValue() const
{
  return !MCIsFloatInfinity(StartingValue) ? StartingValue : Generators[0]->GetMaxValue();
}


float MAGeneratorContainer::GetTargetValue() const
{
  MAGeneratorBase* Generator = Generators.back();

  // It is a simple generator
  if (dynamic_cast<MASimpleGenerator*>(Generator))
  {
    return Generator->GetMaxValue();
  }
  // Otherwise a periodic generator or a delay generator
  return Generator->GetMinValue();
}


void MAGeneratorContainer::MakePermanent()
{
  AddGenerator(*new MADelayGenerator(-1));
}


void MAGeneratorContainer::Dump()
{
  std::string LogMessage;

  LogMessage = "Container ("+MCToStr(this)+", transition: "+TransitionName+"): ";
  LogMessage += "start - "+MCToStr(GetStartingValue())+", ";
  LogMessage += "target - "+MCToStr(GetTargetValue())+", ";
  LogMessage += "permanent - "+MCToStr(IsPermanent())+", ";
  LogMessage += "duration - "+MCToStr(GetDuration())+", ";
  LogMessage += "started/expired - "+MCToStr(IsStarted())+'/'+MCToStr(IsExpired())+", ";
  LogMessage += '(';
  int i = 0;

  for (auto iter = Generators.begin(); iter != Generators.end(); ++iter)
  {
    i++;
    LogMessage += MCToStr(i)+": ";
    LogMessage += "min - "+MCToStr((*iter)->GetMinValue())+", ";
    LogMessage += "max - "+MCToStr((*iter)->GetMaxValue())+", ";
    LogMessage += "duration - "+MCToStr((*iter)->GetDuration())+", ";
    LogMessage += "elapsed - "+MCToStr((*iter)->GetElapsedTime())+", ";
    LogMessage += "started/expired - "+MCToStr((*iter)->IsStarted())+'/'+MCToStr((*iter)->IsExpired());
    if (iter+1 != Generators.end())
      LogMessage += " || ";
  }
  LogMessage += ')';
  MC_LOG("%s", LogMessage.c_str());
}