source: trunk/bindings/cpp/NeXusStream.hpp @ 1822

#ifndef NEXUS_STREAM_HPP
#define NEXUS_STREAM_HPP
//
//  NeXus - Neutron & X-ray Common Data Format
//  
//  IOStream like interface to NeXus C++ Bindings
//
//  Copyright (C) 2008 Freddie Akeroyd, STFC ISIS facility
//  
//  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 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., 59 Temple Place, Suite 330, Boston, 
//  MA  02111-1307  USA
//             
//  For further information, see http://www.nexusformat.org/
//
//

/////////////////// Subversion Repository Details ////////////////////////
// Repository Location     $HeadURL$
// Revision of last commit $LastChangedRevision$ 
// Date of last commit     $LastChangedDate$
// Last changed by         $LastChangedBy$
//////////////////////////////////////////////////////////////////////////

/**
 * \file NeXusStream.hpp
 * Header for IOStream like interface to NeXus files
 * \author Freddie Akeroyd, STFC ISIS Facility, GB
 * \version $LastChangedRevision$
 * \date    $LastChangedDate$
 * \defgroup cpp_stream IOstream like interface
 * \ingroup cpp_main
 */

#include <list>
#include <vector>
#include "NeXusFile.hpp"

namespace NeXus
{
namespace Stream
{
  /**
   * interface implemented by all serialisable NeXus components
   */
    class NXDLL_EXPORT ISerialisable
    {
      public:
        virtual void readFromFile(File& nf) const = 0;
        virtual void writeToFile(File& nf) const = 0;
    };

    /// \ingroup cpp_stream
    enum StreamModifier { Close=0 };

  /**
   * Base class for serialisable named and typed parameter
   */
    class NXDLL_EXPORT HolderBase : public ISerialisable
    {
      protected:
        std::string m_name;

      public:
        HolderBase() : m_name("") {}
        HolderBase(const std::string& name);
        void setName(const std::string& name);
        std::string getName() { return m_name; }
        virtual NXnumtype getType() = 0;
        virtual HolderBase* clone() = 0;
        virtual ~HolderBase() {}
    };

  /**
   * Serialisable NeXus attribute
   */
    template<typename NumT>
    class NXDLL_EXPORT AttrHolder : public HolderBase
    {
      protected:
        const NumT* m_c_value;
        NumT* m_value;
        AttrHolder() : HolderBase(), m_c_value(NULL), m_value(NULL) { }
        AttrHolder(const std::string& name, const NumT* cv, NumT* v) : HolderBase(name), m_c_value(cv), m_value(v) { }

      public:
        AttrHolder(const std::string& name, NumT& value);
        AttrHolder(const std::string& name, const NumT& value);
        AttrHolder(NumT& value);
        AttrHolder(const NumT& value);
        NXnumtype getType();
        virtual void readFromFile(File& nf) const;
        virtual void writeToFile(File& nf) const;
        AttrHolder* clone() { return new AttrHolder(m_name, m_c_value, m_value); }
        virtual ~AttrHolder() { m_value = NULL; m_c_value = NULL; }
    };

  /**
   * Serialisable attribute
   * \ingroup cpp_stream
   */
    class NXDLL_EXPORT Attr : public ISerialisable
    {
      protected:
        HolderBase* m_holder;

      public:
        Attr() : m_holder(NULL) { }
        template <typename NumT>
          Attr(NumT& d) { m_holder = new AttrHolder<NumT>(d); }
        template <typename NumT>
          Attr(const NumT& d) { m_holder = new AttrHolder<NumT>(d); }
        template <typename NumT>
          Attr(const std::string& name, NumT& d) { m_holder = new AttrHolder<NumT>(name, d); }
        template <typename NumT>
          Attr(const std::string& name, const NumT& d) { m_holder = new AttrHolder<NumT>(name, d); }
        Attr(const std::string& name, Attr& d) { m_holder = d.m_holder->clone(); setName(name); }
        Attr(const std::string& name, const Attr& d) { m_holder = d.m_holder->clone(); setName(name); }
        Attr(const Attr& a) : m_holder(NULL) {  m_holder = a.m_holder->clone(); }
        Attr& operator=(const Attr& a) { if (this != &a) { delete m_holder; m_holder = a.m_holder->clone(); } return *this; }
        void setName(const std::string& name) { m_holder->setName(name); }
        virtual void readFromFile(File& nf) const { m_holder->readFromFile(nf); }
        virtual void writeToFile(File& nf) const { m_holder->writeToFile(nf); }
        virtual ~Attr() { delete m_holder; m_holder = NULL; }
    };

  /**
   * Serialisable NeXus class with associated attributes
   */
    class NXDLL_EXPORT ObjectWithAttr : public ISerialisable
    {
       protected:
        std::list<Attr> m_attr;
        
        void processAttr(const std::string& attr1_name, const Attr& attr1_value, const std::string& attr2_name, const Attr& attr2_value)
        {
            if (attr1_name.size() > 0)
            {
                m_attr.push_back(Attr(attr1_name, attr1_value));
            }
            if (attr2_name.size() > 0)
            {
                m_attr.push_back(Attr(attr2_name, attr2_value));
            }
        }
        
      public:

        ObjectWithAttr(const std::string& attr1_name = "", const Attr& attr1_value = Attr(), const std::string& attr2_name = "", const Attr& attr2_value = Attr())
        {
            processAttr(attr1_name, attr1_value, attr2_name, attr2_value);
        }
        
        virtual void readFromFile(File& nf) const
        {
            for(std::list<Attr>::const_iterator it = m_attr.begin(); it != m_attr.end(); it++)
            {
                it->readFromFile(nf);
            }
        }

        virtual void writeToFile(File& nf) const
        {
            for(std::list<Attr>::const_iterator it = m_attr.begin(); it != m_attr.end(); it++)
            {
                it->writeToFile(nf);
            }
        }

        virtual ~ObjectWithAttr() { }
    };
    
  /**
   * Serialisable NeXus group object
   * \ingroup cpp_stream
   */
    class NXDLL_EXPORT Group : public ObjectWithAttr
    {
      protected:
        std::string m_name;
        std::string m_class;

      public:
        Group(const std::string& name, const std::string& nxclass, const std::string& attr1_name = "", const Attr& attr1_value = Attr(),
                        const std::string& attr2_name="", const Attr& attr2_value = Attr()) : 
                ObjectWithAttr(attr1_name, attr1_value, attr2_name, attr2_value), m_name(name), m_class(nxclass)
        {
        }

        virtual void readFromFile(File& nf) const
        {
            nf.openGroup(m_name, m_class);
            ObjectWithAttr::readFromFile(nf);
        }

        virtual void writeToFile(File& nf) const
        {
            nf.makeGroup(m_name, m_class, true);
            ObjectWithAttr::writeToFile(nf);
        }

        virtual ~Group() {}
    };

  /**
   * Serialisable NeXus data
   */
    template<typename NumT>
    class NXDLL_EXPORT DataHolder : public HolderBase
    {
      protected:
        const std::vector<NumT>* m_c_value;
        std::vector<NumT>* m_value;
        DataHolder() : HolderBase(), m_c_value(NULL), m_value(NULL) { }
        DataHolder(const std::string& name, const std::vector<NumT>* cv, std::vector<NumT>* v) : HolderBase(name), m_c_value(cv), m_value(v) { }

      public:
        DataHolder(const std::string& name);
        DataHolder(const std::string& name, std::vector<NumT>& value);
        DataHolder(const std::string& name, const std::vector<NumT>& value);
        DataHolder(std::vector<NumT>& value);
        DataHolder(const std::vector<NumT>& value);
        NXnumtype getType() { return NeXus::getType<NumT>(); }
        virtual void readFromFile(File& nf) const;
        virtual void writeToFile(File& nf) const;
        DataHolder* clone() { return new DataHolder(m_name, m_c_value, m_value); }
        virtual ~DataHolder() {}
    };

  /**
   * Serialisable data object that contains attributes
   * \ingroup cpp_stream
   */
    class NXDLL_EXPORT Data : public ObjectWithAttr
    {
        HolderBase* m_holder;
        
      public:
        Data() : ObjectWithAttr(), m_holder(NULL) {}
        Data(const std::string& name) : ObjectWithAttr()
        {
            m_holder = new DataHolder<int>(name); // TODO: move name out of holder and use  m_holder = NULL
        }
        template <typename NumT>
          Data(const std::string& name, std::vector<NumT>& data, const std::string& attr1_name="", const Attr& attr1_value=Attr(), 
                        const std::string& attr2_name="", const Attr& attr2_value = Attr()) :
                   ObjectWithAttr(attr1_name, attr1_value, attr2_name, attr2_value)
          {
            m_holder = new DataHolder<NumT>(name, data);
          }
        template <typename NumT>
          Data(const std::string& name, const std::vector<NumT>& data, const std::string& attr1_name="", const Attr& attr1_value=Attr(),
                        const std::string& attr2_name="", const Attr& attr2_value = Attr()) :
                ObjectWithAttr(attr1_name, attr1_value, attr2_name, attr2_value)
          {
            m_holder = new DataHolder<NumT>(name, data);
          }
        Data(const Data& d) : ObjectWithAttr(d), m_holder(NULL) { m_holder = d.m_holder->clone(); }
        Data& operator=(const Data& d) { if (this != &d) { delete m_holder; m_holder = d.m_holder->clone(); } return *this; }
        virtual void readFromFile(File& nf) const;
        virtual void writeToFile(File& nf) const;
        virtual ~Data() { delete m_holder; }
    };

    /// \ingroup cpp_stream
   NXDLL_EXPORT File& operator<<(File& nf, const ISerialisable& obj);
    
    /// \ingroup cpp_stream
   NXDLL_EXPORT File& operator>>(File& nf, const ISerialisable& obj);

    /// \ingroup cpp_stream
   NXDLL_EXPORT File& operator<<(File& nf, const StreamModifier sm);
 
    /// \ingroup cpp_stream
   NXDLL_EXPORT File& operator>>(File& nf, const StreamModifier sm);

  } // Stream
} // NeXus

#endif /* NEXUS_STREAM_HPP */