EmbreeTargetManager.cpp

Go to the documentation of this file.

#include <QtGlobal>
#include <QCoreApplication>

#include "FileName.h"
#include "IException.h"

#include "EmbreeTargetManager.h"

using namespace std;

namespace Isis {

  EmbreeTargetManager *EmbreeTargetManager::m_maker = 0;


  EmbreeTargetManager::EmbreeTargetManager()
    : m_maxCacheSize(10) {
    // This ensures this singleton is shut down when the application exists
    qAddPostRoutine(DieAtExit);
    return;
  }


  EmbreeTargetManager::~EmbreeTargetManager() {
    QList<QString> targetFiles = m_targeCache.keys();
    for (int i = 0; i < targetFiles.size(); i++) {
      removeTargetShape(targetFiles[i]);
    }
  }


  void EmbreeTargetManager::DieAtExit() {
    delete  m_maker;
    m_maker = 0;
    return;
  }


  EmbreeTargetManager *EmbreeTargetManager::getInstance() {
    if (!m_maker) {
      m_maker = new EmbreeTargetManager();
    }
    return (m_maker);
  }


  QString EmbreeTargetManager::fullFilePath(const QString &filePath) const {
    FileName fileName(filePath);
    return fileName.expanded();
  }


  EmbreeTargetShape *EmbreeTargetManager::create(const QString &shapeFile) {
    // Get the full path to the file
    QString fullPath = fullFilePath(shapeFile);

    // If the an EmbreeTargetShape already exists, increment its reference count
    // and return a pointer.
    if ( inCache(fullPath) ) {
      ++(m_targeCache[fullPath].m_referenceCount);
      return ( m_targeCache[fullPath].m_targetShape );
    }

    // Otherwise, make a new EmbreeTargetShape

    // First check how many already exist
    if ( m_targeCache.size() >= maxCacheSize() ) {
      QString msg = "Failed creating EmbreeTargetShape for [" + fullPath
                    + "] Too many EmbreeTargetShapes are already open.";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    // If there's still space make a new one
    EmbreeTargetShape *targetShape = new EmbreeTargetShape(fullPath);
    EmbreeTargetShapeContainer targetShapeContainer(fullPath, targetShape);
    ++(targetShapeContainer.m_referenceCount);
    m_targeCache.insert(fullPath, targetShapeContainer);
    return ( targetShapeContainer.m_targetShape );
  }


  void EmbreeTargetManager::free(const QString &shapeFile) {
    // Get the full path to the file
    QString fullPath = fullFilePath(shapeFile);

    // Sanity check
    if ( !inCache(fullPath) ) {
      QString msg = "Cannot free EmbreeTargetShape for file ["
                    + fullPath + "] because it is not stored in the cache.";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    // Get the container for the shapeFile
    EmbreeTargetShapeContainer targetContainer = m_targeCache[fullPath];

    // Decrement the reference count
    int newCount = --(m_targeCache[fullPath].m_referenceCount);

    // if the EmbreeTargetShape is no longer in use, delete it
    if ( newCount < 1 ) {
      removeTargetShape(fullPath);
    }
  }


  void EmbreeTargetManager::removeTargetShape(const QString &shapeFile) {
    // Get the full path to the file
    QString fullPath = fullFilePath(shapeFile);

    // Sanity check
    if ( !inCache(fullPath) ) {
      QString msg = "Cannot free EmbreeTargetShape for file ["
                    + fullPath + "] because it is not stored in the cache.";
      throw IException(IException::Programmer, msg, _FILEINFO_);
    }

    // Get the container for the shapeFile
    EmbreeTargetShapeContainer targetContainer = m_targeCache[fullPath];
    delete targetContainer.m_targetShape;
    m_targeCache.remove(fullPath);
  }


  int EmbreeTargetManager::currentCacheSize() const {
    return m_targeCache.size();
  }


  int EmbreeTargetManager::maxCacheSize() const {
    return m_maxCacheSize;
  }


  void EmbreeTargetManager::setMaxCacheSize(const int &numShapes) {
    m_maxCacheSize = numShapes;
  }


  bool EmbreeTargetManager::inCache(const QString &shapeFile) const{
    return m_targeCache.contains( fullFilePath(shapeFile) );
  }
}