nxlink.hpp

Go to the documentation of this file.

//
// (c) Copyright 2013 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: Jul 22, 2013
//     Author: Eugen Wintersberger <eugen.wintersberger@desy.de>
//

#pragma once

#include <boost/filesystem.hpp>
#include "nxobject_traits.hpp"
#include "nxpath/nxpath.hpp"
#include "nxpath/utils.hpp"
#include "nxlink_type.hpp"
#include "algorithms/get_path.hpp"
#include "algorithms/get_object.hpp"


namespace pni{
namespace io{
namespace nx{
  
    //internal function - should not show up in the official documentation
    //
    // This function throws value_error when the target path contains
    // intermediate ..!
    void __check_target_path(const nxpath &target);
   
    //------------------------------------------------------------------------


    template<
             template<nximp_code> class GTYPE,
             nximp_code IMPID
            > 
    void link(const nxpath &target,const GTYPE<IMPID> &g,
              const pni::core::string &name)
    {

        //determine the utility class perfroming linking
        using link_type = typename nxobject_trait<IMPID>::link_imp_type;


        if(has_file_section(target))
        {
            __check_target_path(target);
            //create an external link
            link_type::create_external_link(target,g.imp(),name);
        }
        else
        {
            nxpath real_target = target;

            if(!is_absolute(real_target))
            {
                GTYPE<IMPID> parent = g;
                while(real_target.front().first=="..")
                {
                    parent = parent.parent();
                    real_target.pop_front();
                }

                real_target = join(nxpath::from_string(get_path(parent)),real_target);
            }
           
            //the target path must not contain any element with ..
            __check_target_path(real_target);

            //create an internal link
            link_type::create_internal_link(real_target,g.imp(),name);
        }
    }

    //-------------------------------------------------------------------------
    template<typename GTYPE>
    void link(const pni::core::string &target,const GTYPE &g,
              const pni::core::string &name)
    {
        nxpath path = nxpath::from_string(target);
        link(path,g,name);
    }

    //-------------------------------------------------------------------------
    template<typename GTYPE>
    void link(const char *target,const GTYPE &g,const pni::core::string &name)
    {
        link(pni::core::string(target),g,name);
    }

    //-------------------------------------------------------------------------
    template< 
             typename STYPE,
             typename GTYPE
            >
    void link(const STYPE &target,const GTYPE &g,const pni::core::string &name)
    {
        link(get_path(target),g,name);
    }

    //-------------------------------------------------------------------------
    template<
             template<nximp_code> class GTYPE,
             nximp_code IMPID
            >
    auto link_type(const GTYPE<IMPID> &parent,const pni::core::string &name)
        -> nxlink_type 
    {
        using link_type =  typename nxobject_trait<IMPID>::link_imp_type;

        return link_type::link_type(parent.imp(),name);
    }

    //-------------------------------------------------------------------------
    template<
             template<nximp_code> class GTYPE,
             nximp_code IMPID
            >
    auto link_name(const GTYPE<IMPID> &parent,size_t index)
        -> pni::core::string
    {
        using link_type = typename nxobject_trait<IMPID>::link_imp_type;

        return link_type::link_name(parent.imp(),index);
    }
    //-------------------------------------------------------------------------
    template<
             template<nximp_code> class GTYPE,
             nximp_code IMPID
            >
    auto link_target(const GTYPE<IMPID> &parent,const pni::core::string &lname)
        -> nxpath
    {
        using link_type = typename nxobject_trait<IMPID>::link_imp_type;

        return link_type::link_target(parent.imp(),lname);
    }

    //-------------------------------------------------------------------------
    template<
             template<nximp_code> class GTYPE,
             nximp_code IMPID
            >
    auto link_target(const GTYPE<IMPID> &parent,size_t index) -> nxpath
    {
        return link_target(parent,link_name(parent,index));
    }


    //-------------------------------------------------------------------------
    template<typename GTYPE>
    bool is_external_link(const GTYPE &parent,const pni::core::string &name)
    {
        return link_type(parent,name)==nxlink_type::EXTERNAL;
    }

    //-------------------------------------------------------------------------
    template<typename GTYPE>
    bool is_soft_link(const GTYPE &parent,const pni::core::string &name)
    {
        return link_type(parent,name) == nxlink_type::SOFT;
    }

    //-------------------------------------------------------------------------
    template<typename GTYPE>
    bool is_hard_link(const GTYPE &parent,const pni::core::string &name)
    {
        return link_type(parent,name) == nxlink_type::HARD;
    }

    //------------------------------------------------------------------------
    template<
             template<nximp_code> class GTYPE,
             nximp_code IMPID
            >
    auto link_status(const GTYPE<IMPID> parent,
                     const pni::core::string &lname)
        -> nxlink_status
    {
        using namespace boost::filesystem;
        using file_type = typename nxobject_trait<IMPID>::file_type;

        auto target = link_target(parent,lname);

        switch(link_type(parent,lname))
        {
            case nxlink_type::HARD: 
                return nxlink_status::VALID;
            case nxlink_type::SOFT:
                try
                {
                    auto object = get_object(parent,target);
                    return nxlink_status::VALID;
                }
                catch(...)
                {
                    return nxlink_status::INVALID;
                }
                break;
            case nxlink_type::EXTERNAL:
                //check if the file exists
                if(!exists(path(target.filename())))
                    return nxlink_status::INVALID;
                
                try
                {
                    //check if the referenced object exists
                    auto f = file_type::open_file(target.filename());
                    auto o = get_object(f.root(),target);
                    return nxlink_status::VALID;
                }
                catch(...)
                {
                    return nxlink_status::INVALID;
                }
                break;
            default:
                return nxlink_status::INVALID;
        }

        return nxlink_status::INVALID;
    }

//end of namespace
}
}
}