Display the source code in std/variant.d from which this page was generated on github.

If you spot a problem with this page, click here to create a Bugzilla issue.

Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using local clone.

Class `std.variant.VariantException`

Thrown in three cases:


						
				class VariantException
				
  : Exception
				;

An uninitialized Variant is used in any way except assignment and hasValue;
A get or coerce is attempted with an incompatible target type;
A comparison between Variant objects of incompatible types is attempted.

Fields

Name	Type	Description
`source`	`TypeInfo`	The source type in the conversion or comparison
`target`	`TypeInfo`	The target type in the conversion or comparison
`file`	`string`	The file name of the D source code corresponding with where the error was thrown from.
`info`	`object.Throwable.TraceInfo`	The stack trace of where the error happened. This is an opaque object that can either be converted to `string`, or iterated over with `foreach` to extract the items in the stack trace (as strings).
`line`	`ulong`	The line number of the D source code corresponding with where the error was thrown from.
`msg`	`string`	A message describing the error.

Properties

Name	Type	Description
`next`[get]	`inout(Throwable)`
`next`[set]	`Throwable`	Replace next in chain with `tail`. Use `chainTogether` instead if at all possible.

Methods

Name	Description
`chainTogether` (e1, e2)	Append `e2` to chain of exceptions that starts with `e1`.
`factory` (classname)	Create instance of class specified by the fully qualified name classname. The class must either have no constructors or have a default constructor.
`message` ()	Get the message describing the error. Base behavior is to return the `Throwable.msg` field. Override to return some other error message.
`opApply` (dg)	Loop over the chain of Throwables.
`opCmp` (o)	Compare with another Object obj.
`opEquals` (o)	Test whether `this` is equal to `o`. The default implementation only compares by identity (using the `is` operator). Generally, overrides for `opEquals` should attempt to compare objects by their contents.
`refcount` ()
`toHash` ()	Compute hash function for Object.
`toString` ()	Overrides `Object.toString` and returns the error message. Internally this forwards to the `toString` overload that takes a sink delegate.
`toString` ()	The Throwable hierarchy uses a toString overload that takes a sink delegate to avoid GC allocations, which cannot be performed in certain error situations. Override this `toString` method to customize the error message.

Example

import std.exception : assertThrown;

Variant v;

// uninitialized use
assertThrown!VariantException(v + 1);
assertThrown!VariantException(v.length);

// .get with an incompatible target type
assertThrown!VariantException(Variant("a").get!int);

// comparison between incompatible types
assertThrown!VariantException(Variant(3) < Variant("a"));

Authors

Andrei Alexandrescu

License

Boost License 1.0.