cxFileManagerServiceBase.cpp

Go to the documentation of this file.

/*=========================================================================
This file is part of CustusX, an Image Guided Therapy Application.
 
Copyright (c) SINTEF Department of Medical Technology.
All rights reserved.
 
CustusX is released under a BSD 3-Clause license.
 
See Lisence.txt (https://github.com/SINTEFMedtek/CustusX/blob/master/License.txt) for details.
=========================================================================*/
 
#include "cxFileManagerServiceBase.h"
#include <QFileInfo>
#include "cxTypeConversions.h"
#include "cxUtilHelpers.h"
#include "cxNullDeleter.h"
#include "cxLogger.h"
#include "boost/bind.hpp"
#include "cxCoreServices.h"
 
namespace cx
{
FileManagerServiceBase::FileManagerServiceBase()
{}
 
FileManagerServiceBase::~FileManagerServiceBase()
{
}
 
bool FileManagerServiceBase::isNull()
{
        return false;
}
 
QString FileManagerServiceBase::canLoadDataType() const
{
        std::cout << "[TODO] error FileManagerServiceBase::canLoadDataType not implemented yet." << std::endl;
        return QString("TODO");
}
 
bool FileManagerServiceBase::canLoad(const QString &type, const QString &filename)
{
        FileReaderWriterServicePtr reader = this->findReader(filename);
        if (reader)
                return reader->canRead(type, filename);
        else
                return false;
}
 
DataPtr FileManagerServiceBase::load(const QString &uid, const QString &filename)
{
        FileReaderWriterServicePtr reader = this->findReader(filename);
        if (reader)
                return reader->read(uid, filename);
        else
                return DataPtr();
}
 
FileReaderWriterServicePtr FileManagerServiceBase::findReader(const QString& path, const QString& type)
{
        for (std::set<FileReaderWriterServicePtr>::iterator iter = mDataReaders.begin(); iter != mDataReaders.end(); ++iter)
        {
                if ((*iter)->canRead(type, path))
                        return *iter;
        }
        return FileReaderWriterServicePtr();
}
 
FileReaderWriterServicePtr FileManagerServiceBase::findWriter(const QString& path, const QString& type)
{
        //TODO refactor with the findreader function..
        for (std::set<FileReaderWriterServicePtr>::iterator iter = mDataReaders.begin(); iter != mDataReaders.end(); ++iter)
        {
                if ((*iter)->canWrite(type, path))
                        return *iter;
        }
        return FileReaderWriterServicePtr();
}
 
vtkImageDataPtr FileManagerServiceBase::loadVtkImageData(QString filename)
{
        vtkImageDataPtr retval = vtkImageDataPtr();
        FileReaderWriterServicePtr reader = this->findReader(filename);
        if (reader)
        {
                retval = reader->loadVtkImageData(filename);
        }
        return retval;
}
 
vtkPolyDataPtr FileManagerServiceBase::loadVtkPolyData(QString filename)
{
        FileReaderWriterServicePtr reader = this->findReader(filename);
        if (reader)
                return reader->loadVtkPolyData(filename);
        return vtkPolyDataPtr();
}
 
std::vector<FileReaderWriterServicePtr> FileManagerServiceBase::getExportersForDataType(QString dataType)
{
        std::vector<FileReaderWriterServicePtr> retval;
        for (std::set<FileReaderWriterServicePtr>::iterator iter = mDataReaders.begin(); iter != mDataReaders.end(); ++iter)
        {
                if (dataType.compare((*iter)->canWriteDataType()) == 0)
                        retval.push_back(*iter);
        }
 
        return retval;
}
 
std::vector<FileReaderWriterServicePtr> FileManagerServiceBase::getImportersForDataType(QString dataType)
{
        std::vector<FileReaderWriterServicePtr> retval;
        for (std::set<FileReaderWriterServicePtr>::iterator iter = mDataReaders.begin(); iter != mDataReaders.end(); ++iter)
        {
                if (dataType.compare((*iter)->canReadDataType()) == 0)
                        retval.push_back(*iter);
        }
 
        return retval;
 
}
 
QString FileManagerServiceBase::findDataTypeFromFile(QString filename)
{
        FileReaderWriterServicePtr reader = this->findReader(filename);
        if (reader)
                return reader->canReadDataType();
        CX_LOG_WARNING() << "FileManagerServiceBase::findDataTypeFromFile: Cannot find a file reader";
        return "";
}
 
bool FileManagerServiceBase::readInto(DataPtr data, QString path)
{
        bool success = false;
        FileReaderWriterServicePtr reader = this->findReader(path, data->getType());
        if (reader)
                success = reader->readInto(data, path);
 
        if(data)
        {
                QFileInfo fileInfo(qstring_cast(path));
                data->setName(changeExtension(fileInfo.fileName(), ""));
                //data->setFilename(path); // need path even when not set explicitly: nice for testing
        }
        return success;
 
}
 
std::vector<DataPtr> FileManagerServiceBase::read(const QString &filename)
{
        std::vector<DataPtr> retval;
        FileReaderWriterServicePtr reader = this->findReader(filename);
        if (reader)
                retval = reader->read(filename);
        return retval;
}
 
void FileManagerServiceBase::save(DataPtr data, const QString &filename)
{
        FileReaderWriterServicePtr writer = this->findWriter(filename);
        if (writer)
                return writer->write(data, filename);
        else
                CX_LOG_ERROR() << "Could not find writer.";
}
 
void FileManagerServiceBase::addFileReaderWriter(FileReaderWriterService *service)
{
        // adding a service inside a smartpointer... not so smart, think it is fixed with null_deleter
        mDataReaders.insert(FileReaderWriterServicePtr(service, null_deleter()));
        CX_LOG_DEBUG() << "Adding a reader/writer: " << service->objectName() << " to: " << this;
}
 
void FileManagerServiceBase::removeFileReaderWriter(FileReaderWriterService *service)
{
        for(std::set<FileReaderWriterServicePtr>::iterator it = mDataReaders.begin(); it != mDataReaders.end(); )
        {
                if (service->getName() == (*it)->getName())
                {
                        mDataReaders.erase(it++);
                }
                else
                        ++it;
        }
}
 
QString FileManagerServiceBase::getFileReaderName(const QString &filename)
{
        FileReaderWriterServicePtr reader = this->findReader(filename);
        if (reader)
                return reader->getName();
        else
                return QString();
}
 
} // cx