pathops.hpp

Go to the documentation of this file.

/*
 * Copyright 2008,2009,2010,2011,2012 Stephan Ossowski, Korbinian Schneeberger,
 * Felix Ott, Joerg Hagmann, Alf Scotland, Sebastian Bender
 * 
 * This file is part of SHORE.
 * 
 * SHORE 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 3 of the License, or
 * (at your option) any later version.
 * 
 * SHORE 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 SHORE.  If not, see <http://www.gnu.org/licenses/>.
 */


#ifndef SHORE_MISC_PATHOPS_HPP__
#define SHORE_MISC_PATHOPS_HPP__

#include <stdexcept>
#include <string>
#include <utility>
#include <vector>

#include <glob.h>

#include <boost/cstdint.hpp>

#include "shore/base/stringops.hpp"

namespace shore {

std::string home();

std::string config_home();

std::string expand_home(const std::string& path);

std::string path_parent(const std::string& path);

std::string path_leaf(const std::string& path);

std::string path_trunk(const std::string& path);

std::string path_clean(const std::string& path);

std::string path_enum(const std::string& path,const std::string& suffix,
                      int& num_ofs,const char sep='_');

std::string path_enum(const std::string& path,
                      const std::string& suffix=std::string());

bool is_executable(const std::string& fn);

std::string mktempdir(const std::string& prefix);

std::string which_nofail(const std::string& command,
                         const std::string& env=std::string());

uint64_t file_size(const std::string &fn);

// Forward declaration for which().
void toupper(std::string& str);

template<class Ex>
std::string which_fail(const std::string& command,
                       const std::string& env=std::string())
{
        const std::string ret=which_nofail(command,env);
        if(ret.empty())
        {
                std::string msg="Program not found: "+command+"\n\n";
                msg+="\tPlease make sure that "+command+" is in your path";
                if(!env.empty())
                {
                        std::string uccmd=command;
                        toupper(uccmd);

                        msg+=",\n\tor set the environment variable '"+env
                                +"' to the folder with the "+command+" binary."\
                                "\n\n\tFor example, bash users type or permantely set in ~/.bashrc:"\
                                "\n\n\t\texport "+env+"=FOLDER_TO_"+uccmd+"\n\n";

                }
                throw Ex(msg);
        }
        return ret;
}

std::string which(const std::string& command,const std::string& env=std::string());

template<class Iter>
void glob(Iter b,Iter e,std::vector<std::string> &ret)
{
        for(Iter i=b;i!=e;++i)
        {
                glob_t globbuf;
#ifdef GLOB_TILDE
                const int e=glob(to_string(*i).c_str(),GLOB_TILDE,0,&globbuf);
#else
                const int e=glob(to_string(*i).c_str(),0,0,&globbuf);
#endif
                
                if(e==0)
                {
                        for(size_t j=0;j<globbuf.gl_pathc;++j)
                        {
                                ret.push_back(globbuf.gl_pathv[j]);
                        }
                }

                globfree(&globbuf);
                
                if(e!=0)
                {
                        if(e!=GLOB_NOMATCH)
                                throw std::runtime_error("glob error");
                }
        }
}

template<class Iter>
std::vector<std::string> glob(Iter b,Iter e)
{
        std::vector<std::string> ret;
        glob(b,e,ret);
        return ret;
}

void glob(const std::string& pattern,std::vector<std::string> &ret);

std::vector<std::string> glob(const std::string& pattern);

typedef boost::uint64_t uint64_t;

uint64_t get_mtime(const std::string &path);

bool is_older(const std::string &path1,const std::string &path2);

} // namespace shore

#endif // SHORE_MISC_PATHOPS_HPP__