{

BoolPromptOption(Resource::StringId labelId, char hotkey, bool value)

: Label(labelId), Hotkey(std::string(1, hotkey)), Value(value) {}

Utility::LocIndString Hotkey;

Resource::LocString Label;

// Value associated with this option.

bool Value;

{

// The channel that the reporter is targeting.

// Based on commands/arguments, only one of these channels can be chosen.

enum class Channel

{

Output,

Completion,

Disabled,

};

// The level for the Output channel.

enum class Level : uint32_t

{

None = 0x0,

Verbose = 0x1,

Info = 0x2,

Warning = 0x4,

Error = 0x8,

All = Verbose | Info | Warning | Error,

};

Reporter(std::ostream& outStream, std::istream& inStream);

Reporter(const Reporter&) = delete;

Reporter& operator=(const Reporter&) = delete;

Reporter(Reporter&&) = default;

Reporter& operator=(Reporter&&) = default;

// Request that a clone be constructed from the given reporter.

struct clone_t {};

Reporter(const Reporter& other, clone_t);

~Reporter();

// Get a stream for verbose output.

OutputStream Verbose() { return GetOutputStream(Level::Verbose); }

// Get a stream for informational output.

OutputStream Info() { return GetOutputStream(Level::Info); }

// Get a stream for warning output.

OutputStream Warn() { return GetOutputStream(Level::Warning); }

// Get a stream for error output.

OutputStream Error() { return GetOutputStream(Level::Error); }

// Get a stream for outputting completion words.

OutputStream Completion() { return OutputStream(*m_out, m_channel == Channel::Completion, false); }

// Gets a stream for output of the given level.

OutputStream GetOutputStream(Level level);

void EmptyLine() { GetBasicOutputStream() << std::endl; }

// Sets the channel that will be reported to.

// Only do this once and as soon as the channel is determined.

void SetChannel(Channel channel);

// Sets the visual style (mostly for progress currently)

void SetStyle(AppInstaller::Settings::VisualStyle style);

// Prompts the user, return true if they consented.

bool PromptForBoolResponse(Resource::LocString message, Level level = Level::Info, bool resultIfDisabled = false);

// Prompts the user, continues when Enter is pressed

void PromptForEnter(Level level = Level::Info);

// Prompts the user for a path.

std::filesystem::path PromptForPath(Resource::LocString message, Level level = Level::Info, std::filesystem::path resultIfDisabled = std::filesystem::path::path());

// Used to show indefinite progress. Currently an indefinite spinner is the form of

// showing indefinite progress.

// running: shows indefinite progress if set to true, stops indefinite progress if set to false

void ShowIndefiniteProgress(bool running);

// IProgressSink

void BeginProgress() override;

void OnProgress(uint64_t current, uint64_t maximum, ProgressType type) override;

void SetProgressMessage(std::string_view message) override;

void EndProgress(bool hideProgressWhenDone) override;

// Contains the objects used for async progress and the lifetime of said progress.

struct AsyncProgressScope

{

AsyncProgressScope(Reporter& reporter, IProgressSink* sink, bool hideProgressWhenDone);

~AsyncProgressScope();

AsyncProgressScope(const AsyncProgressScope&) = delete;

AsyncProgressScope& operator=(const AsyncProgressScope&) = delete;

AsyncProgressScope(AsyncProgressScope&&) = delete;

AsyncProgressScope& operator=(AsyncProgressScope&&) = delete;

ProgressCallback& Callback();

IProgressCallback* operator->();

bool HideProgressWhenDone() const;

void HideProgressWhenDone(bool value);

private:

std::reference_wrapper<Reporter> m_reporter;

ProgressCallback m_callback;

std::atomic_bool m_hideProgressWhenDone;

};

// Runs the given callable of type: auto(IProgressCallback&)

template <typename F>

auto ExecuteWithProgress(F&& f, bool hideProgressWhenDone = false)

{

auto progressScope = BeginAsyncProgress(hideProgressWhenDone);

return f(progressScope->Callback());

}

// Begins an asynchronous progress operation.

std::unique_ptr<AsyncProgressScope> BeginAsyncProgress(bool hideProgressWhenDone = false);

// Sets the in progress callback.

void SetProgressCallback(ProgressCallback* callback);

// Cancels the in progress task.

void CancelInProgressTask(bool force, CancelReason reason);

void CloseOutputStream(bool forceDisable = false);

void SetProgressSink(IProgressSink* sink)

{

m_progressSink = sink;

}

bool IsLevelEnabled(Level reporterLevel)

{

return WI_AreAllFlagsSet(m_enabledLevels, reporterLevel);

}

void SetLevelMask(Level reporterLevel, bool setEnabled = true);

private:

Reporter(std::shared_ptr<BaseStream> outStream, std::istream& inStream);

// Gets a stream for output for internal use.

OutputStream GetBasicOutputStream();

Channel m_channel = Channel::Output;

std::shared_ptr<BaseStream> m_out;

std::istream& m_in;

std::optional<AppInstaller::Settings::VisualStyle> m_style;

std::optional<IndefiniteSpinner> m_spinner;

std::optional<ProgressBar> m_progressBar;

wil::srwlock m_progressCallbackLock;

std::atomic<ProgressCallback*> m_progressCallback;

std::atomic<IProgressSink*> m_progressSink;

// Enable all levels by default

Level m_enabledLevels = Level::All;