VirgilOperationRandom.h

#ifndef VIRGIL_CRYPTO_VIRGIL_RANDOM_H
#define VIRGIL_CRYPTO_VIRGIL_RANDOM_H

#include "../VirgilByteArray.h"

#include <memory>

namespace virgil { namespace crypto { inline namespace primitive {

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

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

    VirgilByteArray randomize(size_t bytesNum) {
        return self_->doRandomize(bytesNum);
    }

    static VirgilOperationRandom getDefault();

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

    VirgilOperationRandom(VirgilOperationRandom&& other) noexcept = default;

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

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

    ~VirgilOperationRandom() noexcept = default;

private:
    struct Concept {
        virtual VirgilByteArray doRandomize(size_t bytesNum) = 0;

        virtual Concept* doCopy() const = 0;

        virtual ~Concept() noexcept = default;
    };

    template<class Random>
    struct Model : Concept {
        explicit Model(Random randomImpl) : impl_(std::move(randomImpl)) {}

        VirgilByteArray doRandomize(size_t bytesNum) override {
            return impl_.randomize(bytesNum);
        }

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

    private:
        Random impl_;
    };

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

}}}

#endif //VIRGIL_CRYPTO_VIRGIL_RANDOM_H