group.h

/*
    OpenMBV - Open Multi Body Viewer.
    Copyright (C) 2009 Markus Friedrich
 
  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. 
   
  This library is distributed in the hope that it will be useful, 
  but WITHOUT ANY WARRANTY; without even the implied warranty of 
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
  Lesser General Public License for more details. 
   
  You should have received a copy of the GNU Lesser General Public 
  License along with this library; if not, write to the Free Software 
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
*/
 
#ifndef _OPENMBV_GROUP_H_
#define _OPENMBV_GROUP_H_
 
#include "hdf5serie/simpledataset.h"
#include <openmbvcppinterface/objectfactory.h>
#include <openmbvcppinterface/object.h>
#include <vector>
#include <map>
 
namespace OpenMBV {
 
  class Group : public Object
#ifndef SWIG
      , public std::enable_shared_from_this<Group>
#endif
    {
    friend class Body;
    friend class Object;
    friend class ObjectFactory;
    protected:
      std::vector<std::shared_ptr<Object> > object;
      std::string expandStr;
      boost::filesystem::path fileName; // the file name of the .ombvx file including the absolute or relatvie path
      std::shared_ptr<H5::File> hdf5File;
      H5::SimpleDataset<int> *rowSize { nullptr };
      std::function<void()> closeRequestCallback;
      std::function<void()> refreshCallback;
      void createHDF5File() override;
      void openHDF5File() override;
 
      Group();
      ~Group() override = default;
 
      std::shared_ptr<xercesc::DOMDocument> writeXMLDoc();
      void writeXML();
 
      void readXML();
 
    public:
      void setExpand(bool expand) { expandStr=(expand)?"true":"false"; }
 
      bool getExpand() { return expandStr=="true"?true:false; }
 
      void addObject(const std::shared_ptr<Object>& newObject);
 
      std::vector<std::shared_ptr<Object> >& getObjects() {
        return object;
      }
      
      std::shared_ptr<H5::File> getHDF5File() const { return hdf5File; }
 
      std::string getFileName() { return fileName.string(); }
 
      std::string getFullName() override;
      
      void setFileName(const boost::filesystem::path &fn) { fileName=fn; }
      
      void write(bool writeXMLFile=true, bool writeH5File=true, bool embedXMLInH5=false);
 
      void read();
 
      void enableSWMR();
 
      void setRowSize(int rs);
 
      int getRowSize();
 
      /* This function should be called periodically for a file opened for writing.
       * It flush's the file (the dataset) of a writer if such a flush was requested by a reader.
       * Does nothing if no reader has requested a flush.
       * If a flush happens postFlushFunc is called immediately after the flush (a shared_ptr of "this" is passed as argument)
       * and than the readers are notified about the flush. */
      void flushIfRequested(const std::function<void(const std::shared_ptr<Group> &)> &postFlushFunc={});
 
      void flush();
 
      void refresh();
 
      /* Called by a reader to request a flush of the writer.
       * This is not blocking. If the writer has flushed the setRefreshCallback is called.
       * If a writer process currently exists true is returned else false. Note that this returned flag cannot change
       * while the calling process has opened the file for reading. */
      bool requestFlush();
 
      void setCloseRequestCallback(const std::function<void()> &closeRequestCallback_) { closeRequestCallback=closeRequestCallback_; }
 
      void setRefreshCallback(const std::function<void()> &refreshCallback_) { refreshCallback=refreshCallback_; }
 
      void initializeUsingXML(xercesc::DOMElement *element) override;
 
      xercesc::DOMElement* writeXMLFile(xercesc::DOMNode *parent) override;
 
      std::shared_ptr<Group> getTopLevelGroup() {
        std::shared_ptr<Group> p=parent.lock();
        return !p?shared_from_this():p->getTopLevelGroup();
      }
  };
 
}
 
#endif