gsReadFile.h

Go to the documentation of this file.

 
/*
  Notes:
  QEPCAD:
  http://opus.bath.ac.uk/29503/
  http://opus.bath.ac.uk/29503/9/QEPCADexamplebank.txt
 
*/
 
#pragma once
 
#include <string>
 
#include <gsCore/gsDebug.h>
 
namespace gismo
{
 
template< class T>  class gsMultiPatch;
 
template<class T = real_t >
class gsReadFile
{
public:
 
    gsReadFile(std::string const & fn)
    : m_id(-1)
    {
        m_data.read(fn);
    }
 
    gsReadFile(std::string const & fn, index_t id)
    : m_id(id)
    {
        m_data.read(fn);
    }
 
    template<class Obj>
    gsReadFile(std::string const & fn, Obj & result)
    : m_id(-1)
    {
        GISMO_ENSURE(m_data.read(fn), "Error reading file.");
        m_data.getAnyFirst(result);
    }
 
    gsReadFile(std::string const & fn, gsMultiPatch<T> & result)
    : m_id(-1)
    {
        GISMO_ENSURE(m_data.read(fn), "Error reading file.");
        result.clear();
        memory::unique_ptr< gsMultiPatch<T> > mp =
            this->operator memory::unique_ptr< gsMultiPatch<T> >();
        if(mp)
            result = give(*mp);
    }
 
    ~gsReadFile() { m_data.clear(); }
 
private:
 
    gsFileData<T> m_data;
 
    index_t m_id;
 
public:
 
    template<class Obj>
    operator memory::unique_ptr<Obj> ()
    {
        // Get the first object in the file
        if ( this->m_data.template hasAny< Obj >() )
            return  this->m_data.template getAnyFirst< Obj >();
 
        gsWarn<< "Failed to read object from file (not found).\n";
        return memory::unique_ptr<Obj>();
    }
 
    operator memory::unique_ptr< gsGeometry<T> > ()
    {
        // Get the first geometry in the file
        if ( this->m_data.template hasAny< gsGeometry<T>  >() )
            return  this->m_data.template getAnyFirst< gsGeometry<T>  >();
 
        gsWarn<< "Failed to read gsGeometry from file (not found).\n";
        return memory::unique_ptr< gsGeometry<T> >();
    }
 
    operator memory::unique_ptr< gsCurve<T> > ()
    {
        // Get the first curve in the file
        if ( this->m_data.template hasAny< gsCurve<T>  >() )
            return  this->m_data.template getAnyFirst< gsCurve<T>  >();
 
        gsWarn<< "Failed to read gsCurve from file (not found).\n";
        return memory::unique_ptr< gsCurve<T> >();
    }
 
    operator memory::unique_ptr< gsBasis<T> > ()
    {
        // Get the first basis in the file
        if ( this->m_data.template hasAny< gsBasis<T>  >() )
            return  this->m_data.template getAnyFirst< gsBasis<T> >();
 
        gsWarn<< "Failed to read gsBasis from file (not found).\n";
        return memory::unique_ptr< gsBasis<T> >();
    }
 
    operator memory::unique_ptr< gsFunctionExpr<T> > () const
    {
 
        if ( this->m_data.template hasAny< gsFunctionExpr<T> >() )
        {
            if ( -1==m_id )        // Get the first one in the file
                return  this->m_data.template getAnyFirst< gsFunctionExpr<T> >();
            else
                return  this->m_data.template getId<gsFunctionExpr<T> >(m_id);
        }
 
        gsWarn<< "Failed to read gsFunctionExpr from file (not found).\n";
        return memory::unique_ptr< gsFunctionExpr<T> >();
    }
 
    operator memory::unique_ptr< gsPlanarDomain<T> > ()
    {
        // Get the first basis in the file
        if ( this->m_data.template hasAny< gsPlanarDomain<T>  >() )
            return  this->m_data.template getAnyFirst< gsPlanarDomain<T> >();
 
        gsWarn<< "Failed to read gsPlanarDomain from file (not found).\n";
        return memory::unique_ptr< gsPlanarDomain<T> >();
    }
 
    operator memory::unique_ptr< gsMultiPatch<T> > ()
    {
        // Get the first MultiPatch tag, if one exists
        if ( this->m_data.template has< gsMultiPatch<T> >() )
            return  this->m_data.template getFirst< gsMultiPatch<T> >();
 
        // Else get all geometries and make a multipatch out of that
        if ( this->m_data.template has< gsGeometry<T> >() )
        {
            std::vector< memory::unique_ptr<gsGeometry<T> > > patches =
                this->m_data.template getAll< gsGeometry<T> >();
            std::vector< gsGeometry<T>* > releasedPatches = memory::release(patches);
            return memory::make_unique(new gsMultiPatch<T>( releasedPatches ));
        }
 
        gsWarn<< "Failed to read gsMultiPatch from file (not found).\n";
        return memory::unique_ptr< gsMultiPatch<T> >();
    }
 
    operator memory::unique_ptr< gsMesh<T> > ()
    {
        // Get the first Mesh, if one exists
        if ( this->m_data.template has< gsMesh<T>  >() )
            return  this->m_data.template getFirst< gsMesh<T>  >();
 
        gsWarn<< "Failed to read gsMesh from file (not found).\n";
        return memory::unique_ptr< gsMesh<T> >();
    }
 
    operator std::vector< memory::unique_ptr< gsBasis<T> > > ()
    {
        // Get all bases
        return  this->m_data.template getAll< gsBasis<T> >();
    }
 
    operator memory::unique_ptr< gsPde<T> > ()
    {
        if ( this->m_data.template has< gsPde<T>  >() )
            return  this->m_data.template getFirst< gsPde<T>  >();
 
        gsWarn<< "Failed to read gsPde from file (not found).\n";
        return memory::unique_ptr< gsPde<T> >();
    }
 
    operator memory::unique_ptr< gsPoissonPde<T> > ()
    {
        if ( this->m_data.template has< gsPoissonPde<T>  >() )
            return  this->m_data.template getFirst< gsPoissonPde<T>  >();
 
        gsWarn<< "Failed to read gsPoissonPde from file (not found).\n";
        return memory::unique_ptr< gsPoissonPde<T> >();
    }
 
    template<class Obj>
    operator memory::shared_ptr<Obj> ()
    {
        return (memory::unique_ptr<Obj>)(*this);
    }
 
};  // class gsReadFile
 
#ifdef GISMO_WITH_PYBIND11
 
  void pybind11_init_gsReadFile(pybind11::module &m);
 
#endif // GISMO_WITH_PYBIND11
 
 
template <typename Object>
void gsWrite(const Object& obj, const std::string& fname)
{
    gsFileData<real_t> fd;
    fd << obj;
    fd.dump(fname);
}
 
} // namespace gismo