VirgilOperationHash.h

#ifndef VIRGIL_CRYPTO_VIRGIL_HASH_H
#define VIRGIL_CRYPTO_VIRGIL_HASH_H

#include <virgil/crypto/VirgilByteArray.h>

#include <memory>

namespace virgil { namespace crypto { inline namespace primitive {

class VirgilOperationHash {
private:
    template<class Impl>
    struct Model;

public:
    template<class Impl>
    VirgilOperationHash(Impl impl) : self_(new Model<Impl>(std::move(impl))) {}

    VirgilByteArray hash(const VirgilByteArray& data) {
        self_->doStart();
        self_->doUpdate(data);
        return self_->doFinish();
    }

    void start() {
        self_->doStart();
    }

    void update(const VirgilByteArray& data) {
        self_->doUpdate(data);
    }

    VirgilByteArray finish() {
        return self_->doFinish();
    }

    static VirgilOperationHash getDefault();

    VirgilOperationHash(const VirgilOperationHash& other) : self_(other.self_->doCopy()) {}

    VirgilOperationHash(VirgilOperationHash&& other)noexcept = default;

    VirgilOperationHash& operator=(const VirgilOperationHash& other) {
        VirgilOperationHash tmp(other);
        *this = std::move(tmp);
        return *this;
    }

    VirgilOperationHash& operator=(VirgilOperationHash&& other) noexcept= default;

    ~VirgilOperationHash() noexcept = default;

private:
    struct Concept {
        virtual Concept* doCopy() const = 0;

        virtual void doStart() = 0;

        virtual void doUpdate(const VirgilByteArray& data) = 0;

        virtual VirgilByteArray doFinish() = 0;
    };

    template<class Impl>
    struct Model : Concept {

        explicit Model(Impl impl) : impl_(std::move(impl)) {}

        Concept* doCopy() const override {
            return new Model(*this);
        }

        void doStart() override {
            return impl_.start();
        }

        void doUpdate(const VirgilByteArray& data) override {
            impl_.update(data);
        }

        VirgilByteArray doFinish() override {
            return impl_.finish();
        }

    private:
        Impl impl_;
    };

private:
    std::unique_ptr<Concept> self_;
};

}}}

#endif //VIRGIL_CRYPTO_VIRGIL_HASH_H