gsFileData.h

Go to the documentation of this file.

 
#pragma once
 
#include <iostream>
#include <string>
#include <list>
 
#include <gsIO/gsXml.h>
#include <gsIO/gsFileManager.h>
 
namespace gismo
{
 
template<class T>
class gsFileData
{
public:
    typedef internal::gsXmlTree         FileData;
    typedef internal::gsXmlNode         gsXmlNode;
    typedef internal::gsXmlAttribute    gsXmlAttribute;
    typedef std::string                 String;
 
    typedef gsVector3d<T>               Point_3;
 
public:
 
    gsFileData();
 
    explicit gsFileData(String const & fn, bool recursive=false);
 
    bool read(String const & fn, bool recursive=false) ;
 
    ~gsFileData();
 
    void clear();
 
    int numData() const { return data->numNodes();}
 
    void save(String const & fname = "dump", bool compress = false) const;
 
    void writeIges(String const & fname);
 
    void saveCompressed(String const & fname = "dump") const;
 
    void dump(String const & fname = "dump") const;
 
    void addComment(String const & message);
 
    // Returns the path of the last file where data was read from
    //
    // If the corresponding file did not exist, the return value is an
    // empty string.
    String lastPath() const { return m_lastPath; }
 
    void setFloatPrecision(const unsigned k) { data->setFloatPrecision(k); }
 
    unsigned getFloatPrecision() const { return data->getFloatPrecision(); }
 
private:
    FileData * data;
 
    // Used to hold parsed data of native gismo XML files
    std::list<std::vector<char> > m_buffer;
 
    // Holds the last path that was used in an I/O operation
    mutable String m_lastPath;
 
protected:
 
/*
 * File readers
 */
 
    bool readXmlFile( String const & fn, bool recursive=false);
 
    bool readXmlGzFile( String const & fn, bool recursive=false);
 
    bool readGismoXmlStream(std::istream & is, bool recursive=false);
 
    bool readAxelFile(String const & fn);
    bool readAxelSurface( gsXmlNode * node );
    bool readAxelCurve  ( gsXmlNode * node );
    bool readAxelMesh   ( gsXmlNode * node );
 
    bool readGeompFile( String const & fn );
 
    bool readGoToolsFile(String const & fn);
 
    bool readOffFile(String const & fn);
 
    bool readStlFile(String const & fn);
 
    bool readObjFile(String const & fn);
 
    bool readBrepFile(String const & fn);
 
    bool readIgesFile(String const & fn);
 
    bool readX3dFile(String const & fn);
 
    bool read3dmFile(String const & fn);
 
    bool readParasolidFile(String const & fn);
 
    bool readCsvFile(String const & fn);
 
    // Show the line number where something went wrong
    void ioError(int lineNumber,const String& str);
 
public:
 
    // Generic functions to fetch Gismo object
    // template<class Object>
    // inline Object * get( gsXmlNode * node)
    // {
    //     return internal::gsXml<Object>::get(node);// Using gsXmlUtils
    // }
 
    template<class Object>
    inline memory::unique_ptr<Object> getId( const int & id)  const
    {
        return memory::make_unique( internal::gsXml<Object>::getId( getXmlRoot(), id ) );
    }
 
    template<class Object>
    inline void getId( const int & id, Object& result)  const
    {
        memory::unique_ptr<Object> obj = getId<Object>(id);
        result = give(*obj);
    }
 
    template<class Object>
    inline memory::unique_ptr<Object> getLabel(const std::string & name)  const
    {
        return memory::make_unique( internal::gsXml<Object>::getLabel( getXmlRoot(), name ) );
    }
 
    template<class Object>
    inline void getLabel(const std::string & name, Object& result)  const
    {
        memory::unique_ptr<Object> obj = getLabel<Object>(name);
        result = give(*obj);
    }
 
    template<class Object>
    inline String tag() const
    { return internal::gsXml<Object>::tag(); }
 
    template<class Object>
    inline String type() const
    { return internal::gsXml<Object>::type(); }
 
    template<class Object>
    inline bool has() const
    {
        return getFirstNode( internal::gsXml<Object>::tag(),
                             internal::gsXml<Object>::type() ) != 0 ;
    }
 
    inline bool hasId(int id) const {
      gsXmlNode* root = getXmlRoot();
      // const gsXmlAttribute * id_at;
      gsXmlNode* nd = internal::searchId(id, root, NULL, false);
      return (bool)nd;
    }
 
    inline bool hasLabel(std::string label) const {
      gsXmlNode* root = getXmlRoot();
      // const gsXmlAttribute * id_at;
      gsXmlNode* nd = internal::searchLabel(label, root, NULL, false);
      return (bool)nd;
    }
 
    inline bool hasTag(std::string tag) const
    {
       return getAnyFirstNode(tag.c_str());
    }
 
    template<class Object>
    inline bool hasAny() const
    {
        return getAnyFirstNode( internal::gsXml<Object>::tag(),
                                internal::gsXml<Object>::type() ) != 0 ;
    }
 
    template<class Object>
    inline int count() const
    {
        int i(0);
        for (gsXmlNode * child = getFirstNode( internal::gsXml<Object>::tag(),
                                               internal::gsXml<Object>::type() ) ;
             child; child = getNextSibling(child, internal::gsXml<Object>::tag(),
                                           internal::gsXml<Object>::type() ))
            ++i;
        return i;
    }
 
 
    template<class Object>
    void operator<<(const Object & obj)
    {
        this->add<Object>(obj);
    }
 
    template<class Object>
    void add (const Object & obj, int id = -1)
    {
        gsXmlNode* node =
            internal::gsXml<Object>::put(obj, *data);
        if ( ! node )
        {
            gsInfo<<"gsFileData: Trouble inserting "<<internal::gsXml<Object>::tag()
                         <<" to the XML tree. is \"put\" implemented ??\n";
        }
        else
        {
            data->appendToRoot(node,id);
        }
    }
 
    template<class Object>
    void addWithLabel (const Object & obj, std::string label)
    {
        gsXmlNode* node =
            internal::gsXml<Object>::put(obj, *data);
        if ( ! node )
        {
            gsInfo<<"gsFileData: Trouble inserting "<<internal::gsXml<Object>::tag()
                         <<" to the XML tree. is \"put\" implemented ??\n";
        }
        else
        {
            data->appendToRoot(node,-1,label);
        }
    }
 
    void addString (const std::string & s)
    {
        gsXmlNode* node = internal::makeNode("string",s,*data);
        data->appendToRoot(node);
    }
 
    void addString (const std::string & s, const std::string & label)
    {
        gsXmlNode* node = internal::makeNode("string",s,*data);
        node->append_attribute(internal::makeAttribute("label", label, *data));
        data->appendToRoot(node);
    }
 
    void addInclude( const std::string & filename, const real_t & time=-1.,
                     const index_t & id=-1, const std::string & label="");
 
protected:
    void getInclude(gsFileData & res, index_t id, real_t time, std::string label);
 
public:
    void getIncludeById(gsFileData & res, index_t id)
    {
        return getInclude(res, id, -1., "");
    }
 
    void getIncludeByTime(gsFileData & res, real_t time)
    {
        return getInclude(res, -1,time, "");
    }
 
    void getIncludeByLabel(gsFileData & res, std::string label)
    {
        return getInclude(res, -1,-1.,label);
    }
 
    std::string getString () const
    {
 
        gsXmlNode * node = getFirstNode("string");
        //node = getNextSibling(node, "string");
        std::string res( node->value() );
        return res;
    }
 
    std::string getString(index_t id) const
    {
        //GISMO_ASSERT(id < 0, "Id " << id << " should be >= 0!");
 
        gsXmlNode * root = getXmlRoot();
        gsXmlNode * nd = internal::searchId(id, root, "string");
        if (nd)
        {
            std::string res(nd->value());
            return res;
        }
        GISMO_ERROR("String with id " << id << " does not exist!");
    }
 
    std::string getStringByLabel (const std::string & label) const
    {
        //GISMO_ASSERT(id < 0, "Id " << id << " should be >= 0!");
 
        gsXmlNode * root = getXmlRoot();
        gsXmlNode * nd = internal::searchNode( root, "label", label, "string");
        if (nd)
        {
            std::string res(nd->value());
            return res;
        }
        GISMO_ERROR("String with label " << label << " does not exist!");
    }
 
    size_t bufferSize() const { return m_buffer.front().size(); };
 
    std::ostream &print(std::ostream &os) const;
 
/*
    template<class Object>
    bool operator>>(Object * obj)
    {
        gsWarn<< "getting "<< typeid(Object).name() <<"\n";
        gsXmlNode* node = getFirstNode(internal::gsXml<Object>::tag(),
                                       internal::gsXml<Object>::type() );
        if ( !node )
        {
            gsWarn<<"gsFileData: false!\n";
            return false;
        }
        else
        {
            obj = internal::gsXml<Object>::get(node);
            this->deleteXmlSubtree( node );
            return true;
        }
    }
*/
 
    template<class Object>
    inline memory::unique_ptr<Object> getFirst() const
    {
        gsXmlNode* node = getFirstNode(internal::gsXml<Object>::tag(),
                                       internal::gsXml<Object>::type() );
        if ( !node )
        {
            gsWarn<<"gsFileData: getFirst: Didn't find any "<<
                internal::gsXml<Object>::type()<<" "<<
                internal::gsXml<Object>::tag() <<". Error.\n";
            return memory::unique_ptr<Object>();
        }
        return memory::make_unique( internal::gsXml<Object>::get(node) );// Using gsXmlUtils
    }
 
    template<class Object>
    bool getFirst(Object & result) const
    {
        gsXmlNode* node = getFirstNode(internal::gsXml<Object>::tag(),
                                       internal::gsXml<Object>::type() );
        if ( !node )
        {
            gsWarn<<"gsFileData: getFirst: Didn't find any "<<
                internal::gsXml<Object>::type()<<" "<<
                internal::gsXml<Object>::tag() <<". Error.\n";
            return false;
        }
        internal::gsXml<Object>::get_into(node, result);// Using gsXmlUtils
        return true;
    }
 
    template<class Object>
    inline std::vector< memory::unique_ptr<Object> > getAll()  const
    {
        std::vector< memory::unique_ptr<Object> > result;
 
        for (gsXmlNode * child = getFirstNode( internal::gsXml<Object>::tag(),
                                               internal::gsXml<Object>::type() ) ;
             child; child = getNextSibling(child, internal::gsXml<Object>::tag(),
                                           internal::gsXml<Object>::type() ))
        {
            result.push_back( memory::make_unique(internal::gsXml<Object>::get(child)) );
        }
        return result;
    }
 
    template<class Object>
    inline memory::unique_ptr<Object> getAnyFirst() const
    {
        gsXmlNode* node = getAnyFirstNode(internal::gsXml<Object>::tag(),
                                          internal::gsXml<Object>::type() );
        if ( !node )
        {
            gsWarn <<"gsFileData: getAnyFirst: Didn't find any "<<
                internal::gsXml<Object>::type()<<" "<<
                internal::gsXml<Object>::tag() <<". Error.\n";
            return memory::unique_ptr<Object>();
      }
        return memory::make_unique( internal::gsXml<Object>::get(node) );// Using gsXmlUtils
    }
 
    template<class Object>
    bool getAnyFirst(Object & result) const
    {
        gsXmlNode* node = getAnyFirstNode(internal::gsXml<Object>::tag(),
                                          internal::gsXml<Object>::type() );
        if ( !node )
        {
            gsWarn <<"gsFileData: getAnyFirst: Didn't find any "<<
                internal::gsXml<Object>::type()<<" "<<
                internal::gsXml<Object>::tag() <<". Error.\n";
            return false;
        }
        internal::gsXml<Object>::get_into(node, result);// Using gsXmlUtils
        return true;
    }
 
    String contents () const;
 
    int numTags () const;
 
private:
 
    gsXmlNode * getXmlRoot() const;
    static void deleteXmlSubtree (gsXmlNode* node);
 
    // getFirst ? (tag and or type)
    gsXmlNode * getFirstNode  ( const String & name = "",
                                const String & type = "" ) const;
 
    // getAny
    gsXmlNode * getAnyFirstNode( const String & name = "",
                                 const String & type = "" ) const;
 
    // getNext
    static gsXmlNode * getNextSibling( gsXmlNode* const & node,
                                       const String & name = "",
                                       const String & type = "" );
 
    // Helpers for X3D files
    void addX3dShape(gsXmlNode * shape);
    void addX3dTransform(gsXmlNode * shape);
 
}; // class gsFileData
 
// Print out operator
template<class T>
std::ostream &operator<<(std::ostream &os, const gsFileData<T> & fd)
{return fd.print(os); }
 
#ifdef GISMO_WITH_PYBIND11
 
  void pybind11_init_gsFileData(pybind11::module &m);
  
#endif // GISMO_WITH_PYBIND11
  
} // namespace gismo
 
#ifndef GISMO_BUILD_LIB
 
#include GISMO_HPP_HEADER(gsFileData.hpp)
#endif