Experiment.h

#pragma once


#include <celero/ExperimentResult.h>
#include <celero/Factory.h>
#include <celero/Statistics.h>

#include <string>

namespace celero
{
    class Benchmark;

    class CELERO_EXPORT Experiment
    {
    public:
        explicit Experiment(std::weak_ptr<celero::Benchmark> benchmark);

        explicit Experiment(std::weak_ptr<celero::Benchmark> benchmark, const std::string& name, uint64_t samples, uint64_t iterations,
                            uint64_t threads, double baselineTarget);

        ~Experiment();

        Experiment(const Experiment&) = delete;
        Experiment& operator=(Experiment const& other) = delete;

        std::shared_ptr<celero::Benchmark> getBenchmark();

        void setName(const std::string& x);

        std::string getName() const;

        void setSamples(uint64_t x);

        uint64_t getSamples() const;

        void setIterations(uint64_t x);

        uint64_t getIterations() const;

        void setThreads(uint64_t x);

        uint64_t getThreads() const;

        operator std::string() const;

        std::string getShort() const;

        void setBaselineTarget(double x);

        double getBaselineTarget() const;

        void incrementTotalRunTime(const uint64_t x);

        uint64_t getTotalRunTime() const;

        void setIsBaselineCase(bool x);

        bool getIsBaselineCase() const;

        void setFactory(std::shared_ptr<celero::Factory> x);

        std::shared_ptr<celero::Factory> getFactory() const;

        void addProblemSpace(std::shared_ptr<celero::TestFixture::ExperimentValue> x, double scale = 1.0);

        size_t getResultSize();

        std::shared_ptr<celero::ExperimentResult> getResult(size_t x);

        std::shared_ptr<celero::ExperimentResult> getResultByValue(int64_t x);

    private:
        Experiment();

        class Impl;

        Pimpl<Impl> pimpl;
    };
} // namespace celero