ewmscp.h

Go to the documentation of this file.

#ifndef __ewmscp_h__
#define __ewmscp_h__
 
/*
  ewmscp: copy program with extended functionality
    Copyright (C) 2018  Juergen Hannappel
 
    This program 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.
 
    This program 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 this program.  If not, see <https://www.gnu.org/licenses/>.
*/
 
 
#include <chrono>
#include <atomic>
#include <Options.h>
 
#include <forward_list>
#include <sys/stat.h>
#include <sys/types.h>
#include <system_error>
 
#include "checksumBase.h"
#include "inputHandler.h"
#include "messageQueue.h"
#include "outputHandler.h"
#include "throttle.h"
 
#define defineStatic(var,...) decltype(var) var(__VA_ARGS__)
#define defineStaticNoArg(var) decltype(var) var
 
class modeBitType : public options::fundamental_wrapper<mode_t> {
  public:
    modeBitType(unsigned int aBits = 0): fundamental_wrapper(aBits) {};
    friend std::ostream& operator<<(std::ostream& out, const modeBitType& item) {
        const mode_t& bits(item);
        auto flags = out.flags();
        out << std::oct << bits;
        out.flags(flags);
        return out;
    }
    friend std::istream& operator>>(std::istream& in, modeBitType& item) {
        mode_t& bits(item);
        auto flags = in.flags();
        in >> std::oct >> bits;
        in.flags(flags);
        return in;
    }
};
 
class preservables {
  public:
    preservables() noexcept :
        mode(false),
        ownership(false),
        timestamps(false),
        attrs(false),
        acls(false) {};
    bool mode;
    bool ownership;
    bool timestamps;
    bool attrs;
    bool acls;
    void set(const std::string& opt);
 
};
 
 
extern options::single<int> uid;
extern options::single<int> gid;
extern preservables preserve;  
extern options::single<bool> noCopy;
extern options::single<bool> dereference;
extern options::single<bool> verbose;
extern options::single<bool> quiet;
extern options::single<std::string> workDir;
extern options::single<bool> continueOnError;
extern options::single<unsigned int> nThreads;
extern throttle::watch readRateLimit;
extern throttle::watch writeRateLimit;
extern throttle::watch fileRateLimit;
extern options::single<modeBitType> modeBits;
extern options::single<std::string> statPrefix;
extern options::single<std::string> requestProviderName;
extern options::single<bool> printStatAnyway;
#ifdef WithJsonCpp
extern options::single<std::string> prefixJsonName;
extern options::map<std::string> jsonExtraFields;
#endif
 
extern options::single<std::string> outputHandlerName;
extern options::single<std::string> inputHandlerName;
extern std::forward_list<const checksum::base::factoryClass*> checksumCreators;
 
extern messageQueue::queue* resultOutput;
 
class stopRequest {
  public:
    enum class handlerIdType {
        unhandled,
        undefined,
        requestProvider,
        processLoop
    };
  private:
    static handlerIdType handlerId;
    static std::string reason;
    static void sigHandler(int);
    static volatile std::atomic<bool> stopRequested;
  public:
    static void instantiate(handlerIdType id);
    static bool Requested();
    static bool Requested(handlerIdType id);
    static void RequestStop(const std::string& aReason);
    static void ThrowUpReasonably();
};
 
#endif