nxfile.hpp

Go to the documentation of this file.

//
// (c) Copyright 2011 DESY, Eugen Wintersberger <eugen.wintersberger@desy.de>
//
// This file is part of libpniio.
//
// libpniio is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 2 of the License, or
// (at your option) any later version.
//
// libpniio 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with libpniio.  If not, see <http://www.gnu.org/licenses/>.
// ===========================================================================
//
// Created on: Jun 30, 2011
//     Author: Eugen Wintersberger <eugen.wintersberger@desy.de>
//

#pragma once

#include <pni/core/types.hpp>
#include <pni/core/utilities.hpp>

#include "nximp_map.hpp"
#include "nxobject_traits.hpp"
#include "nxgroup.hpp"
#include "nxdate_time.hpp"


namespace pni{
namespace io{
namespace nx{

    using namespace pni::core;
    //need this here to avoid name collisions with tango headers.
    using pni::core::string;
    using pni::core::exception;

    template<nximp_code IMPID> class nxfile
    {
        public:
            typedef typename nximp_map<IMPID>::file_imp imp_type;
            typedef nxfile<IMPID>              file_type;
        private:
            imp_type _imp; 
        public:
            //===============constructors and destructor========================
            explicit nxfile():_imp() { }

            //-----------------------------------------------------------------
            nxfile(const file_type &file):_imp(file._imp) { }
            
            //-----------------------------------------------------------------
            nxfile(file_type &&f):_imp(std::move(f._imp)) { }
            
            //-----------------------------------------------------------------
            explicit nxfile(imp_type &&imp):_imp(std::move(imp)){ }

            //-----------------------------------------------------------------
            ~nxfile()
            {
                if((_imp.is_valid())&&(!_imp.is_readonly()))
                {
                    auto r = root();
                    r.attributes.template create<string>("file_update_time",true)
                        .write(nxdate_time::get_date_time_str());
                    r.close();
                }
            }
                
            //================assigment operator===============================
            file_type &operator=(const file_type &f)
            {
                if(this == &f) return *this;
                
                _imp = f._imp;

                return *this;
            } 

            //----------------------------------------------------------------
            file_type &operator=(file_type &&f)
            {
                if(this == &f) return *this;

                _imp = std::move(f._imp);
                return *this;
            }

            //================factory methods==================================
            static file_type open_file(const string &n,bool ro=true)
            {
                return file_type(imp_type::open(n,ro));
            }

            //-----------------------------------------------------------------
            static file_type
            create_files(const string &n,ssize_t ssize,bool ow=false)
            {
                file_type file = file_type(imp_type::create(n,ow,ssize));

                auto root_group = file.root();
                
                //set file specific attributes
                root_group.attributes.template
                    create<string>("NX_class",true).write(string("NXroot"));
                root_group.attributes.template 
                    create<string>("file_time",true).write(nxdate_time::get_date_time_str());
                root_group.attributes.template 
                    create<string>("file_update_time",true).write(nxdate_time::get_date_time_str());
                root_group.attributes.template create<string>("file_name",true).write(n);

                //this should be taken from a configuration
                root_group.attributes.template
                    create<string>("NeXus_version",true).write(string("4.3.0"));

                //flush the files content
                file.flush();

                return file;
            }

            //-----------------------------------------------------------------
            static file_type
            create_file(const string &n,bool ow=false)
            {
                return create_files(n,0,ow);
            }

            //-----------------------------------------------------------------
            void flush() const{ _imp.flush(); }
            
            //-----------------------------------------------------------------
            bool is_readonly() const { return _imp.is_readonly(); }


            //-----------------------------------------------------------------
            void close()
            {
                if((this->is_valid())&&(!this->is_readonly()))
                {
                    auto r = root();
                    r.attributes.template create<string>("file_update_time",true)
                        .write(nxdate_time::get_date_time_str());
                    r.close();
                }
                
                _imp.close();
            }


            //------------------------------------------------------------------
            typename nxobject_trait<IMPID>::group_type root() const
            {
                typedef typename nximp_map<IMPID>::group_imp group_imp_type;
                typedef typename nxobject_trait<IMPID>::group_type group_type;

                return group_type(group_imp_type(_imp.root()));
            }

            //----------------------------------------------------------------
            bool is_valid() const noexcept
            {
                return _imp.is_valid(); 
            }

    };


//end of namespace
}
}
}