load.hpp

Go to the documentation of this file.

/*
Copyrightc 2014 Akihiro Nishimura

This software is released under the MIT License.
http://opensource.org/licenses/mit-license.php
*/

#ifndef SIG_UTIL_LOAD_HPP
#define SIG_UTIL_LOAD_HPP

#include "../helper/helper_modules.hpp"
#include "../helper/maybe.hpp"

#include <fstream>
#include <locale>



namespace sig
{

namespace impl
{
template <class T>
using IfsSelector = typename SameIf<
    T, std::string,
    std::ifstream,
    typename SameIf<
        T, std::wstring,
        std::wifstream,
        std::basic_ifstream<T>
    >::type
>::type;

}   // impl



template <
    class IFS_CHAR, 
    class C, 
    class R = typename impl::container_traits<C>::value_type
>
bool load_line(
    C& empty_dest,
    std::basic_ifstream<IFS_CHAR>& ifs)
{
    std::basic_string<IFS_CHAR> line;

    SIG_FILE_LOCALE_INIT

    while (ifs && std::getline(ifs, line)){
        impl::container_traits<C>::add_element(empty_dest, std::move(line));
    }
    return static_cast<bool>(ifs);
}


template <
    class C,
    class R = typename impl::container_traits<C>::value_type
>
bool load_line(
    C& empty_dest,
    FilepassString const& file_pass)
{
    impl::IfsSelector<R> ifs(file_pass);

    if (!ifs){
        //FileOpenErrorPrint(file_pass);
        return false;
    }
    return load_line(empty_dest, ifs);
}



/*
// ファイルから1行ずつ読み込み、結果を返す（ifstreamを指定）
// R: 返す文字列型(std::string or std::wstring)
// ifs: std::ifstream or std::wifstream
// 読込失敗: return -> nothing (boost非使用時は空のコンテナ)
template <class IST, class R = IST, class C = std::vector<R>>
auto load_line(impl::IfsSelector<IST>& ifs) ->Maybe<C>
{
C tmp;
load_line(tmp, ifs);
return tmp.size() ? Just<C>(std::move(tmp)) : Nothing(std::move(tmp));
}
*/


template <
    class ISTR = std::string,
    class C = std::vector<ISTR>
>
auto load_line(FilepassString const& file_pass) ->Maybe<C>
{
    C tmp;
    impl::IfsSelector<ISTR> ifs(file_pass);

    if (!ifs){
        //FileOpenErrorPrint(file_pass);
        return Nothing(C());
    }

    load_line(tmp, ifs);

    return tmp.empty() ? Nothing(tmp) : Just<C>(std::move(tmp));
}

template <
    class ISTR = std::string,
    class R = ISTR,
    class C = std::vector<R>
>
auto load_line(FilepassStringC file_pass) ->Maybe<C>
{
    return load_line<ISTR, C>(static_cast<impl::string_t<FilepassStringC>>(file_pass));
}




template <
    class IFS_CHAR,
    class F,
    class C,
    class R = typename impl::container_traits<C>::value_type
>
bool load_line(
    C& empty_dest,
    std::basic_ifstream<IFS_CHAR>& ifs,
    F const& conv)
{
    std::basic_string<IFS_CHAR> line;

    SIG_FILE_LOCALE_INIT

    while (ifs && std::getline(ifs, line)){
        impl::container_traits<C>::add_element(empty_dest, conv(std::move(line)));
    }
    return static_cast<bool>(ifs);
}


template <
    class ISTR = std::string,
    class F,
    class C,
    class R = typename impl::container_traits<C>::value_type
>
bool load_line(
    C& empty_dest,
    FilepassString const& file_pass,
    F const& conv)
{
    impl::IfsSelector<
        typename impl::SameIf<R, std::string, R,
        typename impl::SameIf<R, std::wstring, R, ISTR>::type
        >::type
    > ifs(file_pass);

    if (!ifs){
        //FileOpenErrorPrint(file_pass);
        return false;
    }
    return load_line(empty_dest, ifs, conv);
}




template <
    class C,
    class RT = typename impl::container_traits<C>::value_type, typename std::enable_if<!impl::container_traits<typename impl::container_traits<C>::value_type>::exist>::type*& = enabler
>
bool load_num(
    C& empty_dest,
    FilepassString const& file_pass,
    std::string delimiter = "\n")
{
    auto read_str = load_line<std::string>(file_pass);

    if (!isJust(read_str)) return false;

    if (delimiter == "\n"){
        for (auto const& line : fromJust(read_str)){
            impl::container_traits<C>::add_element(empty_dest, impl::Str2NumSelector<RT>()(line));
        }
    }
    else{
        auto sp = split(fromJust(read_str)[0], delimiter);
        for (auto v : sp) impl::container_traits<C>::add_element(empty_dest, impl::Str2NumSelector<RT>()(v));
    }
    return true;
}


template <
    class R,
    class C = std::vector<R>, typename std::enable_if<impl::container_traits<C>::exist && !impl::container_traits<typename impl::container_traits<C>::value_type>::exist>::type*& = enabler
>
auto load_num(
    FilepassString const& file_pass,
    std::string delimiter = "\n"
    ) ->Maybe<C>
{
    C tmp;
    load_num(tmp, file_pass, delimiter);
    return tmp.size() ? Just<C>(std::move(tmp)) : Nothing(std::move(tmp));
}




template <
    class CC,
    class RC = typename impl::container_traits<CC>::value_type,
    class RT = typename impl::container_traits<RC>::value_type
>
bool load_num2d(
    CC& empty_dest,
    FilepassString const& file_pass,
    std::string delimiter)
{
    auto read_str = load_line<std::string>(file_pass);
    if (!isJust(read_str)) return false;

    for (auto const& line : fromJust(read_str)){
        RC tmp;
        auto sp = split(line, delimiter);

        for (auto const& v : sp){
            impl::container_traits<RC>::add_element(tmp, impl::Str2NumSelector<RT>()(v));
        }
        impl::container_traits<CC>::add_element(empty_dest, std::move(tmp));
    }
    return true;
}



template <
    class R,
    class CC = std::vector<std::vector<R>>,
    typename std::enable_if<impl::container_traits<typename impl::container_traits<CC>::value_type>::exist>::type*& = enabler
>
auto load_num2d(
    FilepassString const& file_pass,
    std::string delimiter
    ) ->Maybe<CC>
{
    CC tmp;
    load_num2d(tmp, file_pass, delimiter);
    return tmp.size() ? Just<CC>(std::move(tmp)) : Nothing(std::move(tmp));
}


}
#endif