EmbreeTargetManager.cpp

 
/* SPDX-License-Identifier: CC0-1.0 */
 
#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 [" + shapeFile
                    + "] 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) );
  }
}