GitCommandRunner.h

Go to the documentation of this file.

 
#ifndef GITCOMMANDRUNNER_H
#define GITCOMMANDRUNNER_H
 
#include "GitCloneData.h"
#include "GitRunner.h"
#include <QElapsedTimer>
#include <QVariant>
 
class Git_clone {
public:
    GitCloneData clonedata_;
    Git_clone(const GitCloneData &clonedata)
        : clonedata_(clonedata)
    {
    }
};
 
class Git_fetch {
public:
    bool prune;
    Git_fetch(bool prune)
        : prune(prune)
    {
    }
};
 
class Git_stage {
public:
    std::vector<std::string> paths;
    Git_stage(std::vector<std::string> const &paths)
        : paths(paths)
    {
    }
};
 
class Git_push {
public:
    bool set_upstream_ = false;
    std::string remote_;
    std::string branch_;
    bool force_ = false;
    int exitcode_ = 0;
    std::string errormsg_;
    Git_push(bool set_upstream, std::string const &remote, std::string const &branch, bool force)
        : set_upstream_(set_upstream)
        , remote_(remote)
        , branch_(branch)
        , force_(force)
    {
    }
};
 
class Git_pull {
public:
    Git_pull()
    {
    }
};
 
class Git_push_tags {
public:
    Git_push_tags()
    {
    }
};
 
class Git_delete_tag {
public:
    std::string name_;
    bool remote_;
    Git_delete_tag(std::string const &name, bool remote)
        : name_(name)
        , remote_(remote)
    {
    }
};
 
class Git_delete_tags {
public:
    std::vector<std::string> tagnames;
    Git_delete_tags(std::vector<std::string> const &tagnames)
        : tagnames(tagnames)
    {
    }
};
 
class Git_add_tag {
public:
    std::string name_;
    GitHash commit_id_;
    Git_add_tag(std::string const &name, const GitHash &commit_id)
        : name_(name)
        , commit_id_(commit_id)
    {
    }
};
 
class Git_submodule_add {
public:
    GitCloneData data_;
    bool force_ = false;
    Git_submodule_add(GitCloneData const &data, bool force)
        : data_(data)
        , force_(force)
    {
    }
};
 
class GitCommandRunner {
public:
    void operator () (Git_clone const &item);
    void operator () (Git_fetch const &item);
    void operator () (Git_stage const &item);
    void operator () (Git_push const &item);
    void operator () (Git_pull const &item);
    void operator () (Git_push_tags const &item);
    void operator () (Git_delete_tag const &item);
    void operator () (Git_delete_tags const &item);
    void operator () (Git_add_tag const &item);
    void operator () (Git_submodule_add const &item);
 
    typedef std::variant<
        Git_clone,
        Git_fetch,
        Git_stage,
        Git_push,
        Git_pull,
        Git_push_tags,
        Git_delete_tag,
        Git_delete_tags,
        Git_add_tag,
        Git_submodule_add
        > variant_t;
 
    typedef unsigned int request_id_t;
 
    struct D {
        GitRunner g;
        AbstractPtyProcess *pty = nullptr;
        request_id_t request_id = 0;
        bool override_wait_cursor = true;
        std::function<void (GitCommandRunner &req)> run;
        QVariant userdata;
        bool update_commit_log = false;
        bool result = false;
        QString process_name;
        QElapsedTimer elapsed;
    } d;
 
    GitRunner git()
    {
        return d.g;
    }
    AbstractPtyProcess *pty()
    {
        return d.pty;
    }
    std::string pty_message() const;
    AbstractPtyProcess const *pty() const
    {
        return d.pty;
    }
    std::function<void (ProcessStatus *status, QVariant const &)> callback;
};
Q_DECLARE_METATYPE(GitCommandRunner)
 
#endif // GITCOMMANDRUNNER_H