ReaderWriterSet.hpp

Go to the documentation of this file.

/**
 * MOAB, a Mesh-Oriented datABase, is a software component for creating,
 * storing and accessing finite element mesh data.
 *
 * Copyright 2004 Sandia Corporation.  Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government
 * retains certain rights in this software.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 */

#ifndef MOAB_READER_WRITER_SET_HPP
#define MOAB_READER_WRITER_SET_HPP

#include 
#include 
#include "moab/Types.hpp"

namespace moab
{

class ReaderIface;
class WriterIface;
class Core;

/**
 *\brief Maintain list of readers and writers.
 *\version 1.00
 *\date 2004-4-23
 *\author Jason Kraftcheck
 */
class ReaderWriterSet
{

  public:
    typedef ReaderIface* ( *reader_factory_t )( Interface* );
    typedef WriterIface* ( *writer_factory_t )( Interface* );

    ReaderWriterSet( Core* mdb );

    ~ReaderWriterSet();

    /**
     * Regiseter a reader and/or writer
     * Either factory function may be NULL, but not both.
     *
     *\param reader_fact  A factory method to create an instance of the reader
     *\param writer_fact  A factory method to create an instance of the reader
     *\param description  A short description of the file format.
     *\param extensions   A null-terminated list of file extensions
     *\param name         File format identifier string.
     */
    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 );

    /**
     * Create a reader object for the passed file name
     * according to the dot-extension of the file name.
     * Caller must delete the object when finished.
     * Returns null if no matching file extension.
     */
    ReaderIface* get_file_extension_reader( const std::string& filename ) const;

    /**
     * Create a writer object for the passed file name
     * according to the dot-extension of the file name.
     * Caller must delete the object when finished.
     * Returns null if no matching file extension.
     */
    WriterIface* get_file_extension_writer( const std::string& filename ) const;

    /**
     * Create a reader object for the passed file format type.
     * Caller is responsible for deletion of returned object.
     * Returns NULL if no match.
     */
    ReaderIface* get_file_reader( const char* format_name ) const;

    /**
     * Create a writer object for the passed file format type.
     * Caller is responsible for deletion of returned object.
     * Returns NULL if no match.
     */
    WriterIface* get_file_writer( const char* format_name ) const;

    /**
     * Get the file extension from a file name
     */
    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;

    std::list< Handler > handlerList;
};

}  // namespace moab

#endif