mlDICOMCachedIOFileHandle.h

Go to the documentation of this file.

// Copyright (c) Fraunhofer MEVIS, Germany. All rights reserved.
// **InsertLicense** code
//----------------------------------------------------------------------------------
 
//----------------------------------------------------------------------------------
 
#pragma once
 
#include "MLDICOMCachedIOSystem.h"
#include "mlDICOMCachedIOFileHandlePlugin.h"
#include "mlDICOMCachedIOFileHandleProvider.h"
 
#include <mlUtilsSystemC.h>
#include <mlFileSystem.h>
#include <FMEThirdPartyWarningsDisable.h>
#include <string>
#include <vector>
#include <FMEThirdPartyWarningsRestore.h>
 
ML_START_NAMESPACE
 
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
template<typename CT>
class MLDICOMCachedIO_EXPORT DICOMCachedIOFileHandleBase :
public std::basic_string<CT>
{
  
public:
  inline DICOMCachedIOFileHandleBase() {}
  
  inline DICOMCachedIOFileHandleBase(const std::basic_string<CT>& str) 
  {
    (*this).erase();
    (*this).assign(str);       
  }
  
  inline bool isMultiFrameHandle() const 
  {
    // Do emptiness check and check for "*" to speed up the check in normal cases.
    return !this->empty() && ((*this)[0] == '*') && (_getMLintFrameIndex() >= 0);
  }
  
  inline bool fileExists(bool allowEmpty) const 
  {
    if (this->empty() && allowEmpty) {
      return true;
    }
    return MLFileExists((this->isMultiFrameHandle() ? getOriginalFrameHandle() : *this).c_str()) != 0;
  }
  
  inline DICOMCachedIOFileHandleBase getOriginalFrameHandle() const
  {
    DICOMCachedIOFileHandleBase retHandle = *this;
    
    // Extract original handle if it is a multi-frame handle.
    if (_getMLintFrameIndex() >= 0){
      const size_t hashPos = this->rfind('#');
      retHandle = this->substr(1, hashPos - 1);
    }
    return retHandle;
  }
  
  inline unsigned int getFrameIndex() const 
  {
    const MLint index = _getMLintFrameIndex();
    return index < 0 ? 0u : static_cast<unsigned int>(index);
  }
  
  inline std::basic_string<CT> getFilename() const 
  {
    std::basic_string<CT> filename = "";
    if(!this->empty()) {
      const DICOMCachedIOFileHandleProvider& fileHandleProvider = DICOMCachedIOFileHandleProvider::singleton();
      const std::vector<DICOMCachedIOFileHandlePlugin *> &plugins = fileHandleProvider.getConstFileHandlePlugins();
      std::vector<DICOMCachedIOFileHandlePlugin *>::const_iterator iter = plugins.begin(),endIt=plugins.end();
      for( ; iter!=endIt; ++iter) {
        if (*iter) {
          filename = (*iter)->resolveFilename(*this);
          if (!filename.empty()) {
            break;
          }
        }
      }
    }
    return filename;
  }
 
  private:
 
  inline MLint _getMLintFrameIndex() const 
  {
    // Extract original handle if it is a multi-frame handle.
    MLint index = -1;
    if (!this->empty() && ((*this)[0] == '*')){
      const size_t hashPos = this->rfind('#');
      if (hashPos != this->npos){
        // Looks like a multi-frame handle, extract its index as string.
        const std::string idxStr = this->substr(hashPos + 1);
        if (1 != sscanf(idxStr.c_str(), "%lld", &index)) {
          // We expect exactly one scanned argument so we failed if we 
          // reach here. Reset returned index to 0 in this case.
          index = -1;
        }
        // Check for valid range.
        if ((index < 0) || (index > ML_UINT32_MAX)){ 
          index = -1; 
        }
      }
    }
    return index;
  }
};
 
typedef DICOMCachedIOFileHandleBase<char> DICOMCachedIOFileHandle;
 
ML_END_NAMESPACE