InputFileFormatRegistry.h

Go to the documentation of this file.

#ifndef __stir_IO_InputFileFormatRegistry_h__
#define __stir_IO_InputFileFormatRegistry_h__
/*
    Copyright (C) 2006-2008, Hammersmith Imanet Ltd
    This file is part of STIR.
    SPDX-License-Identifier: Apache-2.0
 
    See STIR/LICENSE.txt for details
*/
#include "stir/IO/InputFileFormat.h"
#include "stir/shared_ptr.h"
#include <map>
#include <fstream>
#include <string>
#include <memory>
 
START_NAMESPACE_STIR
 
class FileSignature;


template <class DataT>
class InputFileFormatRegistry
{
public:
  typedef DataT data_type;
  // In the future, maybe we'll have a factory type, and let InputFileFormat be derived from it
  // So we will use a typedef to prepare for that.
  typedef InputFileFormat<DataT> Factory;
  typedef shared_ptr<Factory> FactorySPtr;
  typedef InputFileFormatRegistry<DataT> self_type;


  static shared_ptr<self_type>& default_sptr();

  inline InputFileFormatRegistry() {}
 
  inline ~InputFileFormatRegistry() {}

  void add_to_registry(FactorySPtr const& factory, const unsigned ranking);

  void remove_from_registry(const Factory& factory);


  Factory const& find_factory(const FileSignature& signature, std::istream& input) const;


  Factory const& find_factory(const FileSignature& signature, const std::string& filename) const;

  Factory const& find_factory(const std::string& filename) const;

  Factory const& find_factory(std::istream& input) const;


  void list_registered_names(std::ostream& stream) const;
 
private:
  typedef typename std::multimap<unsigned, FactorySPtr> _registry_type;
  typedef typename _registry_type::const_iterator const_iterator;
  typedef typename _registry_type::iterator iterator;
 
  _registry_type _registry;
 
  bool _valid(const_iterator iter) const { return iter != this->_registry.end(); }
 
  // File can be either string or istream
  template <class File>
  inline const_iterator _actual_find_factory(const FileSignature& signature, File& input) const
  {
    const_iterator iter = this->_registry.begin();
    const_iterator const end = this->_registry.end();
    while (iter != end)
      {
        if (iter->second->can_read(signature, input))
          return iter;
        ++iter;
      }
    return end;
  }
};


template <class Format>
struct RegisterInputFileFormat
{
  typedef typename Format::data_type data_type;
  explicit RegisterInputFileFormat(const unsigned ranking)
  {
    shared_ptr<InputFileFormat<data_type>> format_sptr(new Format);
    InputFileFormatRegistry<data_type>::default_sptr()->add_to_registry(format_sptr, ranking);
  }

  ~RegisterInputFileFormat()
  {
    Format format;
    InputFileFormatRegistry<data_type>::default_sptr()->remove_from_registry(format);
  }
};
 
END_NAMESPACE_STIR
 
//#include "stir/IO/InputFileFormatRegistry.inl"
 
#endif