ReaderWriterSet.hpp

Go to the documentation of this file.

#ifndef MOAB_READER_WRITER_SET_HPP
#define MOAB_READER_WRITER_SET_HPP

#include <list>
#include <string>
#include "moab/Types.hpp"

namespace moab {

class ReaderIface;
class WriterIface;
class Core;
class Error;

class ReaderWriterSet
{

  public:
    
    typedef ReaderIface* (*reader_factory_t)( Interface* );
    typedef WriterIface* (*writer_factory_t)( Interface* );
  
    ReaderWriterSet( Core* mdb, Error* handler );
  
    ~ReaderWriterSet();
    
    ErrorCode register_factory( reader_factory_t reader_fact,
                                  writer_factory_t writer_fact,
                                  const char* description,
                                  const char* const* extensions,
                                  const char* name );
    ErrorCode register_factory( reader_factory_t reader_fact,
                                  writer_factory_t writer_fact,
                                  const char* description,
                                  const char* extension,
                                  const char* name );
  
    ReaderIface* get_file_extension_reader( const std::string& filename ) const;

    WriterIface* get_file_extension_writer( const std::string& filename ) const;
    
    ReaderIface* get_file_reader( const char* format_name ) const; 
     
    WriterIface* get_file_writer( const char* format_name ) const; 
    
    static std::string extension_from_filename( const std::string& filename );
  
    class Handler {
      
      friend class ReaderWriterSet;
      
      public:
      
      Handler( reader_factory_t read_f,
               writer_factory_t write_f,
               const char* name,
               const char* desc, 
               const char* const* ext, 
               int num_ext );
      
      inline const std::string& name() const { return mName; }
      inline const std::string& description() const { return mDescription; }
      inline void get_extensions( std::vector<std::string>& list_out ) const
        { list_out = mExtensions; }
      
      inline bool have_reader() const { return NULL != mReader; }
      inline bool have_writer() const { return NULL != mWriter; }
      
      inline ReaderIface* make_reader( Interface* iface ) const
        { return have_reader() ? mReader(iface) : NULL; }
      
      inline WriterIface* make_writer( Interface* iface ) const
        { return have_writer() ? mWriter(iface) : NULL; }

      bool reads_extension(const char *ext) const;
      bool writes_extension(const char *ext) const;
      
      bool operator==( const char* name ) const;
      
      private:
      
      reader_factory_t mReader;
      writer_factory_t mWriter;
      
      std::string mName, mDescription;
      std::vector<std::string> mExtensions;
    };
    
    typedef std::list<Handler>::const_iterator iterator;
    
    inline iterator begin() const { return handlerList.begin(); }
    
    inline iterator end()   const { return handlerList.end();   }
    
    
    iterator handler_from_extension( const std::string& extension,
                                      bool with_reader = false, 
                                      bool with_writer = false) const;
    
    iterator handler_by_name( const char* name ) const;
    
  private:
  
    Core* mbCore;
    Error* mbError;
  
    std::list<Handler> handlerList;
};

} // namespace moab 

#endif