Структурированные типы данных: смена записей местами - C++ - Ответ 8598498

#include <cctype>
#include <locale>
#include <string>
#include <algorithm>
#include <functional>
 
#include <iostream>
#include <fstream>
#include <limits>
#include <list>
 
#include <random>
#include <chrono>
 
// ----------------------------------------------------------------
// ----------------------------------------------------------------
 
// удаляет пробелы слева от текста
inline std::string& ltrim(std::string& s)
{
    s.erase(s.begin(), 
        std::find_if(s.begin(), s.end(), 
            std::ptr_fun<int, int>(std::isgraph)
        )
    );
    return s;
}
 
// удаляет пробелы справа от текста
inline std::string& rtrim(std::string& s)
{
    s.erase(std::find_if(
            s.rbegin(), s.rend(), std::ptr_fun<int, int>(std::isgraph)
        ).base(), s.end()
    );
    return s;
}
 
// удаляет пробелы слева и справа от текста
inline std::string& trim(std::string& s) { return ltrim(rtrim(s)); }
 
// ----------------------------------------------------------------
// ------------------- random`s staff -----------------------------
 
// генератор псевдослучайных чисел
 
#define dT \
    typename std::common_type<T1,T2>::type
 
namespace detailRandom{
 
    template<class T> struct property_
    {
        enum { eIS_BOOL = std::is_same<T, bool>::value };
 
        //TODO: как насчет wchar_t ???
        //ANSWER: матерная брань
        enum {
            eIS_CHAR
             = std::is_same<T, char>::value
            || std::is_same<T, unsigned char>::value
            || std::is_same<T, signed char>::value
        };
 
        enum { eIS_INTEGRAL = std::is_integral<T>::value && !eIS_CHAR && !eIS_BOOL };
        enum { eIS_FLOATING = std::is_floating_point<T>::value };
        enum { eIS_OTHER = !eIS_CHAR && !eIS_INTEGRAL && !eIS_FLOATING };
    };
 
    template<class T>
    using for_integer
        = typename std::enable_if< property_<T>::eIS_INTEGRAL >::type*;
 
    template<class T>
    using for_char
        = typename std::enable_if< property_<T>::eIS_CHAR >::type*;
 
    template<class T>
    using for_bool
        = typename std::enable_if< property_<T>::eIS_BOOL >::type*;
 
    template<class T>
    using for_floating
        = typename std::enable_if< property_<T>::eIS_FLOATING >::type*;
 
    template<class T>
    using for_other
        = typename std::enable_if< property_<T>::eIS_OTHER >::type*;
 
 
    std::default_random_engine& rnd_()
    {
        static std::default_random_engine gen(
            static_cast<unsigned>(
                std::chrono::system_clock::now().time_since_epoch().count()
            )
        );
        return gen;
    }
 
} // namespace detailRandom
 
template<class T1, class T2, detailRandom::for_integer<dT> = nullptr> inline
dT random(const T1& a, const T2& b)
{
    std::uniform_int_distribution<dT> distribution(a, b);
    return distribution(detailRandom::rnd_());
}
 
template<class T1, class T2, detailRandom::for_floating<dT> = nullptr> inline
dT random(const T1& a, const T2& b)
{
    std::uniform_real_distribution<dT> distribution(a, b);
    return distribution(detailRandom::rnd_());
}
 
template<class T1, class T2, detailRandom::for_char<dT> = nullptr> inline
dT random(const T1& a, const T2& b)
{
    enum { eIS_SIGNED = std::is_signed<dT>::value };
 
    typedef typename std::conditional< eIS_SIGNED, int, unsigned >::type
        type;
 
    const auto a_ = static_cast<type>(a);
    const auto b_ = static_cast<type>(b);
    return static_cast<dT>(random(a_, b_));
}
 
 
template<class T1, class T2, detailRandom::for_bool<dT> = nullptr> inline
dT random(const T1& a, const T2& b)
{
    const auto a_ = static_cast<int>(a);
    const auto b_ = static_cast<int>(b);
    return static_cast<dT>(random(a_, b_));
}
#undef dT
 
 
// ----------------------------------------------------------------
// ----------------------------------------------------------------
 
// макросы нужны, что бы не писать каждый раз 
// одно и тоже для очередного класса
 
// отвечают за умение класса выводится в поток 
// и вводится оттуда же
 
#ifndef OUT_TO_STREAM
#define OUT_TO_STREAM(type_)  \
        template<class T>friend   \
        ::std::basic_ostream<T>&  \
        operator<<(::std::basic_ostream<T>& os, const type_& obj )
#endif
 
#ifndef FROM_STREAM
#define FROM_STREAM(type_)  \
        template<class T>friend   \
        ::std::basic_istream<T>&  \
        operator>>(::std::basic_istream<T>& is, type_& obj )
#endif
 
// ----------------------------------------------------------------
// ----------------------------------------------------------------
 
// утилита для ввода циферок
// с проверкой результата
inline void input(const char* msg, int& dst, const int min, const int max)
{
    for (;;)
    {
        std::cout << msg;
        std::cin >> dst;
        if ( !dst ||  min<0 || max<0 ||   ((dst<min || dst > max) && (max!=min!=0))  )
            std::cout << "enter the numbers[" << min << " : " << max << "]\n",
            std::cin.clear(),
            std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
        else
            break;
    }
    std::cin.clear();
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
}
 
// ----------------------------------------------------------------
// ----------------------------------------------------------------
 
// --- разбирает входную строку на токены, 
// которые помещает в указанный контейнер
template <class ContainerT>
void tokenize(const std::string& text, ContainerT& tokens, 
    const std::string& delimiters = " ", bool trimEmpty = false)
{
    std::string::size_type pos, lastPos = 0;
    for (;;)
    {
        pos = text.find_first_of(delimiters, lastPos);
        if (pos == std::string::npos)
        {
            pos = text.length();
            if (pos != lastPos || !trimEmpty)
                tokens.emplace_back(text.data() + lastPos, pos - lastPos);
            break;
        }
        else
        {
            if (pos != lastPos || !trimEmpty)
                tokens.emplace_back(text.data() + lastPos, pos - lastPos);
        }
        lastPos = pos + 1;
    }
}
 
// ----------------------------------------------------------------
// ----------------------------------------------------------------
 
inline const char* sys()        { return "forking system: "; }
inline const char* filenameBD() { return "database.txt";     }
 
// ----------------------------------------------------------------
// ----------------------------------------------------------------
 
 
struct person{
 
    OUT_TO_STREAM(person)
    {
        return os << obj.name << " : " << obj.sname << " : " << obj.tname << " : " 
            << obj.scienseD << " : " << obj.post << " : " << obj.rang;
    }
    FROM_STREAM(person)
    {
        std::string line;
        std::getline(is, line);
        std::vector<std::string> record;
        tokenize(line, record, ":", true);
 
        if (record.size() != 6)
            return std::cout
                << sys() << "total collapse!"
                << sys() << "file of database is nonconsistent\n"
                << sys() << "skip record\n", is;
 
        #define get_(n) (trim(record[n]), record[n]);
 
        obj.name     = get_(0);
        obj.sname    = get_(1);
        obj.tname    = get_(2);
        obj.scienseD = get_(3);
        obj.post     = get_(4);
        obj.rang     = get_(5);
        #undef get_
 
        return is;
    }
 
    
    static void input(const char* msg, std::string& dst)
    {
        std::cout << msg; std::cin >> dst;
        std::cin.clear(),
        std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
    }
 
    void input()
    {
        input("enter name: "          , name);
        input("enter surename: "      , sname);
        input("enter patronymic: "    , tname);
        input("enter sciense degree: ", scienseD);
        input("enter post: "          , post);
        input("enter rang: "          , rang);
    }
 
    std::string name;
    std::string sname;
    std::string tname;
    std::string scienseD;
    std::string post;
    std::string rang;
};
 
 
template<size_t N> inline void genDB(person(&arr)[N]);
template<size_t N> inline void genmanDB(person(&arr)[N]);
template<size_t N> inline void loadDB(person(&arr)[N]);
template<size_t N> inline void saveDB(const person(&arr)[N]);
template<size_t N> inline void cnahgeDB(person(&arr)[N]);
template<size_t N> inline void viewDB(const person(&arr)[N]);
 
int main()
{
    const size_t count = 4;
    person bd[count];
 
    int answer = 0;
    for (;;)
    {
        std::cout << sys() << "what would you like?\n"
            << "1) auto generate database\n"
            << "2) manual generate database\n"
            << "3) load database\n"
            << "4) save database\n"
            << "5) change records\n"
            << "6) exit from this program\n";
 
        input("enter number [1: 5]: ", answer, 1, 6);
 
        switch (answer)
        {
            case 1: genDB(bd);    break;
            case 2: genmanDB(bd); break;
            case 3: loadDB(bd);   break;
            case 4: saveDB(bd);   break;
            case 5: cnahgeDB(bd); break;
            case 6: return 0;
        }
    }
}
 
template<size_t N> inline void viewDB(const person(&bd)[N])
{
    std::cout << sys() << " current content:\n";
    size_t n = 0;
    for (const auto& record : bd)
        ++n, std::cout << n << ") " << record << '\n';
    std::cout << std::endl;
}
 
template<size_t N> inline void genDB(person(&bd)[N])
{
    #define COUNT_(arr) sizeof(arr)/sizeof(arr[0]) - 1
 
    #define INIT_(member) \
            bd[n].member = member##s[random(0, COUNT_(member##s))]
 
    const char*  names[] = { "Pedro" , "Conchita", "Hulion", "Fedora"  , "Bubunt", "Julio"      };
    const char* snames[] = { "Pupkin", "Stewart"  , "Buldog", "Karas"   , "Funker", "Pizza"      };
    const char* tnames[] = { "arab" , "wombat"  , "salat" , "colloquium", "guepard" , "deer"       };
    const char*  posts[] = { "newbie", "junior"  , "middle", "senior"  , "expert", "Straustrup" };
 
    const char* scienseDs[] = { "professor", "big professor", "senior lecturer", "assistant" };
 
    const char* rangs[] = { "hacker", "hardhacker", "stinger",
        "brave-hacker", "digga-hacker", "slacker" };
 
    for (size_t n = 0; n < N; ++n)
        INIT_(name), INIT_(sname), INIT_(tname), INIT_(post), INIT_(scienseD), INIT_(rang);
 
    #undef COUNT_
    #undef INIT_
 
    std::cout << sys() << " generate database...success!\n";
    viewDB(bd);
}
 
template<size_t N> inline void genmanDB(person(&bd)[N])
{
    for (size_t n = 0; n < N; ++n)
        std::cout << n + 1 << ") person:\n",
        bd[n].input(),
        std::cout << "=========================================\n";
}
 
template<size_t N> inline void loadDB(person (&bd)[N] )
{
    std::cout << sys() << " load database... \n";
    std::ifstream infile(filenameBD());
    if (!infile)
        return std::cout << "\nOh dear! Something has gone wrong way!\n\n",
        void();
    for (size_t i = 0; i < N; ++i)
        infile >> bd[i];
    std::cout << " success!\n";
    viewDB(bd);
}
 
template<size_t N> inline void saveDB(const person(&bd)[N])
{
    std::cout << sys() << " save database... ";
    std::ofstream outfile(filenameBD());
    if (!outfile)
        return std::cout << "\nOh dear! Something has gone wrong way!\n\n", 
            void();
    for (size_t i = 0; i < N; ++i)
        outfile << bd[i] << '\n';
    std::cout << " success!\n\n";
}
template<size_t N> inline void cnahgeDB(person(&bd)[N])
{
    using std::swap;
    int f = 0, s = 0;
    std::cout << sys() << "change records...\n";
 
    input("input number of first record: " , f, 0, 0);
    input("input number of second record: ", s, 0, 0);
    swap(bd[f-1], bd[s-1]);
    viewDB(bd);
    std::cout << "\n\n";
}