dcapCommon.h

Go to the documentation of this file.

#ifndef __dcapCommon_h__
#define __dcapCommon_h__
#define _REENTRANT
#if defined(_FILE_OFFSET_BITS) &&  _FILE_OFFSET_BITS == 64
#define dcapStat stat64
#else
#define dcapStat stat
#endif
 
 
#include "ioHandle.h"
#include "pathHandler.h"
#include <dcap.h>
#include <throwcall.h>
#include <mutex>
#include <iostream>
 
 
namespace throwcall {
    namespace dcap {
        template <typename T, typename ... Args> inline void good0(T call, const Args& ... args) {
            if (__builtin_expect(call, 0)) {
                std::ostringstream msg;
                conCatString(msg, "dcap error ", dc_errno, " (", dc_strerror(dc_errno), ") ", args...);
                throw std::runtime_error(msg.str());
            }
        };
        template <typename T, typename t, typename ... Args> inline T badval(T call, t badvalue, const Args& ... args) {
            if (__builtin_expect(call == badvalue, false)) {
                std::ostringstream msg;
                conCatString(msg, "dcap error ", dc_errno, " (", dc_strerror(dc_errno), ") ", args...);
                throw std::runtime_error(msg.str());
            }
            return call;
        };
    } // namespace dcap
} // namespace throwcall
 
 
class dCapLock: public std::unique_lock<std::mutex> {
    // because the dcap lib has only one extra option instance we need to us a lock
    // around handling them. can be realeased once dc_bla... returns
  protected:
    static std::mutex extraOptionMutex;
    const char *f;
    const char *F;
    int l;
  public:
    dCapLock(const char *aFunc = __builtin_FUNCTION(),
             int aLine = __builtin_LINE(),
             const char *aFile = __builtin_FILE()): std::unique_lock<std::mutex>(extraOptionMutex) {
 
        f = aFile;
        l = aLine;
        F = aFunc;
        // std::cerr << f << ":" << l << ": " << F << ": lock\n";
        dc_resetExtraOption();
    };
    ~dCapLock() {
        //std::cerr << f << ":" << l << ": " << F << ": unlock\n";
    }
};
 
 
class dcapCommon: virtual public pathHandler {
  public:
    dcapCommon();
    static std::string fixPathUrl(const std::string& path);
    bool pathExists(const std::string& path) override;
    std::unique_ptr<const genericStat> getStat(const std::string& path,
            bool followLink) override;
};
 
class dcapIoCommon: virtual public ioHandle {
  protected:
    const std::string path;
    int fd = -1;
  public:
    dcapIoCommon(const std::string& aPath);
    std::unique_ptr<const genericStat> getStat() override;
};
 
#endif