bdlb_variantprinter

Detailed Description

Provide a suite of helper classes for printing bsl::variant.

Outline

• Purpose
• Classes
• Description
  • Usage
    • Example 1: Printing bsl::variant to a Stream

Purpose

Provide a suite of helper classes for printing bsl::variant.

Classes

• bdlb::VariantPrinter: utility for printing bsl::variant
• bdlb::VariantPrinterUtil: factory for constructing bdlb::VariantPrinter

Description

This component provides utility classes bdlb::VariantPrinter and bdlb::VariantPrinterUtil for printing bsl::variant.

The class bdlb::VariantPrinter can also be used with bsl::format (it defines the bslfmt::EnableStreamedFormatter trait). For information about the supported format options see the `bslfmt` package documentation .

Usage

This section illustrates intended use of this component.

Example 1: Printing bsl::variant to a Stream

In this example, we demonstrate how to use bdlb::VariantPrinterUtil to print bsl::variant to a stream.

First, we create a streamable type that throws int on copies. This will enable us to put a variant into a valueless state by copying one into it:

 struct ThrowOnCopy {
     // DATA
     int d_ii;
 
     // CREATORS
     ThrowOnCopy(int ii)
     : d_ii(ii)
     {}
 
     ThrowOnCopy(const ThrowOnCopy& original)
     : d_ii(original.d_ii)
     {
         BSLS_THROW(0);
     }
 
     // MANIPULATORS
     ThrowOnCopy& operator=(const ThrowOnCopy& rhs)
     {
         d_ii = rhs.d_ii;
 
         BSLS_THROW(0);
 
         return *this;
     }
 };
 
 bsl::ostream& operator<<(bsl::ostream&      stream,
                          const ThrowOnCopy& value)
 {
     return stream << value.d_ii;
 }

Next, we create a shorthand for VariantPrinterUtil and our variant type:

 typedef bdlb::VariantPrinterUtil                    Util;
 typedef bsl::variant<int, bsl::string, ThrowOnCopy> VariantIST;

Then, we declare a variable of variant type, which can hold, among other types, a ThrowOnCopy:

 VariantIST        mV(107);
 const VariantIST& V = mV;
 
 ThrowOnCopy toc(4);

Next, we start doing some output:

 cout << toc << endl;  // prints "4\n"
 
 cout << Util::makePrinter(V) << endl;  // prints "107\n"
 
 mV = bsl::string("woof");
 cout << Util::makePrinter(V) << endl;  // prints "woof\n"
 
 mV = 27;
 cout << Util::makePrinter(V) << endl;  // prints "27\n"

Then, we see that the type VariantPrinter<...> returned by makePrinter has a standard BDE-style print accessor that will control formatting and indenting:

 mV = bsl::string("bow");
 Util::makePrinter(V).print(cout, 3, -2);  // prints "      bow"
 mV = bsl::string("wow");
 Util::makePrinter(V).print(cout, 1, 1);  // prints " wow\n"

Now, we assign a ThrowOnCopy to the variant, which will throw when copied, leaving mV in a valueless state, and we observe what happens when we then print it.

 assert(!V.valueless_by_exception());
 BSLS_TRY
 {
     mV = toc;
     assert(false);
 }
 BSLS_CATCH(...)
 {
 }
 assert(V.valueless_by_exception());
 
 cout << Util::makePrinter(V) << endl;  // prints "(valueless)\n"

Finally, we see the output created by all this:

 4
 107
 woof
 27
       bow wow
 (valueless)