qwt3d_io.h

#ifndef __qwt3d_io__
#define __qwt3d_io__
 
#include <vector>
#include <algorithm>
 
#include <qstring.h>
#include <qstringlist.h>
#include "qwt3d_global.h"
 
namespace Qwt3D
{
 
class Plot3D;
 
class QWT3D_EXPORT IO
{
 
public:
    // The function type that can be processed by the define... members
    using Function = bool (*)(Plot3D*, QString const& fname);
 
    class Functor
    {
    public:
        virtual ~Functor()
        {
        }
        // Must clone the content of *this for an object of a derived class
        virtual Functor* clone() const = 0;
        // The workhorse of the user-defined implementation
        virtual bool operator()(Plot3D* plot, QString const& fname) = 0;
    };
 
    // Define an input handler for a format with a function
    static bool defineInputHandler(QString const& format, Function func);
    // Define an output handler for a format with a function
    static bool defineOutputHandler(QString const& format, Function func);
    // Define an input handler for a format with a functor
    static bool defineInputHandler(QString const& format, Functor const& func);
    // Define an output handler for a format with a functor
    static bool defineOutputHandler(QString const& format, Functor const& func);
    // Save plot to file in specified format
    static bool save(Plot3D*, QString const& fname, QString const& format);
    // Load plot from file in specified format
    static bool load(Plot3D*, QString const& fname, QString const& format);
    // Returns list of available input formats
    static QStringList inputFormatList();
    // Returns list of available output formats
    static QStringList outputFormatList();
    // Returns output handler for a format
    static Functor* outputHandler(QString const& format);
    // Returns input handler for a format
    static Functor* inputHandler(QString const& format);
 
private:
    IO()
    {
    }
 
    // Lightweight Functor encapsulating an IO::Function
    class Wrapper : public Functor
    {
    public:
        // Performs actual input
        Functor* clone() const
        {
            return new Wrapper(*this);
        }
        // Creates a Wrapper object from a function pointer
        explicit Wrapper(Function h) : hdl(h)
        {
        }
        // Returns a pointer to the wrapped function
        bool operator()(Plot3D* plot, QString const& fname)
        {
            return (hdl) ? (*hdl)(plot, fname) : false;
        }
 
    private:
        Function hdl;
    };
 
    struct Entry
    {
        Entry();
        ~Entry();
 
        Entry(Entry const& e);
        void operator=(Entry const& e);
 
        Entry(QString const& s, Functor const& f);
        Entry(QString const& s, Function f);
 
        QString fmt;
        Functor* iofunc;
    };
 
    struct FormatCompare
    {
        explicit FormatCompare(Entry const& e);
        bool operator()(Entry const& e);
 
        Entry e_;
    };
 
    struct FormatCompare2
    {
        explicit FormatCompare2(QString s);
        bool operator()(Entry const& e);
 
        QString s_;
    };
 
    using Container = std::vector< Entry >;
    using IT        = Container::iterator;
 
    static bool add_unique(Container& l, Entry const& e);
    static IT find(Container& l, QString const& fmt);
    static Container& rlist();
    static Container& wlist();
    static void setupHandler();
};
 
class QWT3D_EXPORT PixmapWriter : public IO::Functor
{
    friend class IO;
 
public:
    PixmapWriter() : quality_(-1)
    {
    }
    // Set output quality
    void setQuality(int val);
 
private:
    IO::Functor* clone() const
    {
        return new PixmapWriter(*this);
    }
    bool operator()(Plot3D* plot, QString const& fname);
    QString fmt_;
    int quality_;
};
 
}  // ns
 
#endif