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

#include "MAContainerLockerPrivate.hpp"

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

namespace
{
// Global container lock manager
MCThreadLocalData< MAContainerLockManager> ContainerLockManager(true);

void CheckStaticContainerLockerVariables()
{
  if (!ContainerLockManager.get())
  {
    ContainerLockManager.reset(new MAContainerLockManager);
  }
}
}

MAContainerLockManager::MAContainerLockManager() : ContainerDangerSignal(new ContainerDangerSignalType)
{
}


MAContainerLockManager& MAContainerLockManager::GetInstance()
{
  CheckStaticContainerLockerVariables();
  return *ContainerLockManager;
}


void MAContainerLockManager::RegisterFileName(const std::string& class_name, const std::string& file_name)
{
  ClassFiles[class_name] = FormatFileString(file_name);
}


int MAContainerLockManager::RegisterContainer(const std::string& class_name, const std::string& container_name)
{
  Containers.push_back(class_name+"::"+container_name);
  return Containers.size()-1;
}


void MAContainerLockManager::Lock(int container_id, int line, const char* file_name)
{
  const auto Iter = ContainerLocks.find(container_id);

  // Already locked
  if (Iter != ContainerLocks.end())
  {
    std::string ContainerName = Containers[container_id];
    std::string ClassName = ContainerName.substr(0, ContainerName.find_first_of(':'));
    std::string OriginalFileName = Iter->second.second.empty() ? ClassFiles[ClassName] : Iter->second.second;
    std::string CurrentFileName = file_name == nullptr ? ClassFiles[ClassName] : FormatFileString(std::string(file_name));

    MC_WARNING("Crash danger: The container %s has been locked at %s (line %d), cannot be locked at %s (line %d)",
               Containers[container_id].c_str(), OriginalFileName.c_str(),
               Iter->second.first, CurrentFileName.c_str(), line);
    (*ContainerDangerSignal).Emit();
    return;
  }
  MA::ContainerLockDescriptor Descriptor;

  Descriptor.first = line;
  Descriptor.second = file_name == nullptr ? "" : FormatFileString(std::string(file_name));
  ContainerLocks[container_id] = Descriptor;
}


void MAContainerLockManager::Unlock(int container_id, int line, const char* file_name)
{
  std::string FileName = file_name == nullptr ? "" : FormatFileString(file_name);

  // Exact match is needed for removal
  for (auto iter = ContainerLocks.begin(); iter != ContainerLocks.end(); ++iter)
  {
    if (iter->first == container_id && iter->second.first == line &&
        iter->second.second == FileName)
    {
      ContainerLocks.erase(iter);
      return;
    }
  }
  // Not locked yet when the lock generated a warning already -> Return silently
}


std::string MAContainerLockManager::FormatFileString(const std::string& full_file_name) const
{
  size_t Index = full_file_name.find_last_of('/');

  if (Index == std::string::npos)
  {
    return full_file_name;
  }
  return full_file_name.substr(Index+1, full_file_name.length()-Index);
}


int MAContainerLockManager::GetActiveLockNumber() const
{
  return ContainerLocks.size();
}


MAContainerLocker::MAContainerLocker(const std::string& class_name, const std::string& file_name) :
  ClassName(class_name)
{
  CheckStaticContainerLockerVariables();
  ContainerLockManager->RegisterFileName(ClassName, file_name);
}


int MAContainerLocker::RegisterContainer(const std::string& container_name)
{
  CheckStaticContainerLockerVariables();
  return ContainerLockManager->RegisterContainer(ClassName, container_name);
}


int MAContainerLocker::Lock(int container_id, int line, const char* file_name)
{
  CheckStaticContainerLockerVariables();
  ContainerLockManager->Lock(container_id, line, file_name);
  return 0;
}


int MAContainerLocker::Unlock(int container_id, int line, const char* file_name)
{
  CheckStaticContainerLockerVariables();
  ContainerLockManager->Unlock(container_id, line, file_name);
  return 1;
}