aboutsummaryrefslogtreecommitdiffstats
path: root/utils/cmdline/ui.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'utils/cmdline/ui.cpp')
-rw-r--r--utils/cmdline/ui.cpp276
1 files changed, 276 insertions, 0 deletions
diff --git a/utils/cmdline/ui.cpp b/utils/cmdline/ui.cpp
new file mode 100644
index 000000000000..a682360a4259
--- /dev/null
+++ b/utils/cmdline/ui.cpp
@@ -0,0 +1,276 @@
+// Copyright 2011 The Kyua Authors.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+// * Neither the name of Google Inc. nor the names of its contributors
+// may be used to endorse or promote products derived from this software
+// without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "utils/cmdline/ui.hpp"
+
+#if defined(HAVE_CONFIG_H)
+# include "config.h"
+#endif
+
+extern "C" {
+#include <sys/param.h>
+#include <sys/ioctl.h>
+
+#if defined(HAVE_TERMIOS_H)
+# include <termios.h>
+#endif
+#include <unistd.h>
+}
+
+#include <iostream>
+
+#include "utils/cmdline/globals.hpp"
+#include "utils/env.hpp"
+#include "utils/format/macros.hpp"
+#include "utils/fs/path.hpp"
+#include "utils/logging/macros.hpp"
+#include "utils/optional.ipp"
+#include "utils/text/operations.ipp"
+#include "utils/text/table.hpp"
+
+namespace cmdline = utils::cmdline;
+namespace text = utils::text;
+
+using utils::none;
+using utils::optional;
+
+
+/// Destructor for the class.
+cmdline::ui::~ui(void)
+{
+}
+
+
+/// Writes a single line to stderr.
+///
+/// The written line is printed as is, without being wrapped to fit within the
+/// screen width. If the caller wants to print more than one line, it shall
+/// invoke this function once per line.
+///
+/// \param message The line to print. Should not include a trailing newline
+/// character.
+/// \param newline Whether to append a newline to the message or not.
+void
+cmdline::ui::err(const std::string& message, const bool newline)
+{
+ LI(F("stderr: %s") % message);
+ if (newline)
+ std::cerr << message << "\n";
+ else {
+ std::cerr << message;
+ std::cerr.flush();
+ }
+}
+
+
+/// Writes a single line to stdout.
+///
+/// The written line is printed as is, without being wrapped to fit within the
+/// screen width. If the caller wants to print more than one line, it shall
+/// invoke this function once per line.
+///
+/// \param message The line to print. Should not include a trailing newline
+/// character.
+/// \param newline Whether to append a newline to the message or not.
+void
+cmdline::ui::out(const std::string& message, const bool newline)
+{
+ LI(F("stdout: %s") % message);
+ if (newline)
+ std::cout << message << "\n";
+ else {
+ std::cout << message;
+ std::cout.flush();
+ }
+}
+
+
+/// Queries the width of the screen.
+///
+/// This information comes first from the COLUMNS environment variable. If not
+/// present or invalid, and if the stdout of the current process is connected to
+/// a terminal the width is deduced from the terminal itself. Ultimately, if
+/// all fails, none is returned. This function shall not raise any errors.
+///
+/// Be aware that the results of this query are cached during execution.
+/// Subsequent calls to this function will always return the same value even if
+/// the terminal size has actually changed.
+///
+/// \todo Install a signal handler for SIGWINCH so that we can readjust our
+/// knowledge of the terminal width when the user resizes the window.
+///
+/// \return The width of the screen if it was possible to determine it, or none
+/// otherwise.
+optional< std::size_t >
+cmdline::ui::screen_width(void) const
+{
+ static bool done = false;
+ static optional< std::size_t > width = none;
+
+ if (!done) {
+ const optional< std::string > columns = utils::getenv("COLUMNS");
+ if (columns) {
+ if (columns.get().length() > 0) {
+ try {
+ width = utils::make_optional(
+ utils::text::to_type< std::size_t >(columns.get()));
+ } catch (const utils::text::value_error& e) {
+ LD(F("Ignoring invalid value in COLUMNS variable: %s") %
+ e.what());
+ }
+ }
+ }
+ if (!width) {
+ struct ::winsize ws;
+ if (::ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) != -1)
+ width = optional< std::size_t >(ws.ws_col);
+ }
+
+ if (width && width.get() >= 80)
+ width.get() -= 5;
+
+ done = true;
+ }
+
+ return width;
+}
+
+
+/// Writes a line to stdout.
+///
+/// The line is wrapped to fit on screen.
+///
+/// \param message The line to print, without the trailing newline character.
+void
+cmdline::ui::out_wrap(const std::string& message)
+{
+ const optional< std::size_t > max_width = screen_width();
+ if (max_width) {
+ const std::vector< std::string > lines = text::refill(
+ message, max_width.get());
+ for (std::vector< std::string >::const_iterator iter = lines.begin();
+ iter != lines.end(); iter++)
+ out(*iter);
+ } else
+ out(message);
+}
+
+
+/// Writes a line to stdout with a leading tag.
+///
+/// If the line does not fit on the current screen width, the line is broken
+/// into pieces and the tag is repeated on every line.
+///
+/// \param tag The leading line tag.
+/// \param message The message to be printed, without the trailing newline
+/// character.
+/// \param repeat If true, print the tag on every line; otherwise, indent the
+/// text of all lines to match the width of the tag on the first line.
+void
+cmdline::ui::out_tag_wrap(const std::string& tag, const std::string& message,
+ const bool repeat)
+{
+ const optional< std::size_t > max_width = screen_width();
+ if (max_width && max_width.get() > tag.length()) {
+ const std::vector< std::string > lines = text::refill(
+ message, max_width.get() - tag.length());
+ for (std::vector< std::string >::const_iterator iter = lines.begin();
+ iter != lines.end(); iter++) {
+ if (repeat || iter == lines.begin())
+ out(F("%s%s") % tag % *iter);
+ else
+ out(F("%s%s") % std::string(tag.length(), ' ') % *iter);
+ }
+ } else {
+ out(F("%s%s") % tag % message);
+ }
+}
+
+
+/// Writes a table to stdout.
+///
+/// \param table The table to write.
+/// \param formatter The table formatter to use to convert the table to a
+/// console representation.
+/// \param prefix Text to prepend to all the lines of the output table.
+void
+cmdline::ui::out_table(const text::table& table,
+ text::table_formatter formatter,
+ const std::string& prefix)
+{
+ if (table.empty())
+ return;
+
+ const optional< std::size_t > max_width = screen_width();
+ if (max_width)
+ formatter.set_table_width(max_width.get() - prefix.length());
+
+ const std::vector< std::string > lines = formatter.format(table);
+ for (std::vector< std::string >::const_iterator iter = lines.begin();
+ iter != lines.end(); ++iter)
+ out(prefix + *iter);
+}
+
+
+/// Formats and prints an error message.
+///
+/// \param ui_ The user interface object used to print the message.
+/// \param message The message to print. Should not end with a newline
+/// character.
+void
+cmdline::print_error(ui* ui_, const std::string& message)
+{
+ LE(message);
+ ui_->err(F("%s: E: %s") % cmdline::progname() % message);
+}
+
+
+/// Formats and prints an informational message.
+///
+/// \param ui_ The user interface object used to print the message.
+/// \param message The message to print. Should not end with a newline
+/// character.
+void
+cmdline::print_info(ui* ui_, const std::string& message)
+{
+ LI(message);
+ ui_->err(F("%s: I: %s") % cmdline::progname() % message);
+}
+
+
+/// Formats and prints a warning message.
+///
+/// \param ui_ The user interface object used to print the message.
+/// \param message The message to print. Should not end with a newline
+/// character.
+void
+cmdline::print_warning(ui* ui_, const std::string& message)
+{
+ LW(message);
+ ui_->err(F("%s: W: %s") % cmdline::progname() % message);
+}