/// <summary>
/// Copy constructor which creates identical copy of the given instance.
/// </summary>
/// <param name="other">Instance from which values should be copied.</param>
public CompactArrayFormatInfo(CompactArrayFormatInfo other)
: base(other)
{
InitializeDefaultValues();
_showItemsOnly = other._showItemsOnly;
_showLastDimension = other._showLastDimension;
HeadingIndices = other.HeadingIndices; // This operation copies array; it should not be the simple assignment
_fieldLength = other._fieldLength;
_maxLineLength = other._maxLineLength;
}
/// <summary>
/// Converts the value of a specified object to an equivalent string representation using
/// specified format and culture-specific formatting information.
/// </summary>
/// <param name="sb">String builder to which formatted string should be appended.</param>
/// <param name="format">A format string containing formatting specifications.</param>
/// <param name="arg">An object to format.</param>
/// <param name="formatProvider">An object that supplies format information about the current instance.</param>
/// <param name="maxLength">
/// Maximum number of characters allowed to the formatter. Formatting should fail (and return false)
/// if this number of characters is breached. Multi-lined formatters should ignore this parameter.
/// Negative value indicates that formatter has unlimited space available. On output contains remaining number of characters available.
/// </param>
/// <returns>
/// true if representation of <paramref name="arg" /> has been successfully appended to <paramref name="sb" />
/// within given number of allowed characters; otherwise false.
/// </returns>
internal override bool Format(StringBuilder sb, string format, object arg, IFormatProvider formatProvider, ref int maxLength)
{
var success = true;
var originalLength = sb.Length;
var formatters = new List <VerboseFormatInfoBase>();
var singleLinedFormat = SingleLinedFormat;
if (arg != null || InstanceDataType != null)
{
var type = GetInstanceType(arg);
var sfi = new ScalarFormatInfo(this);
sfi.MaximumFormattedLength = maxLength;
if (sfi.IsFormatApplicable(type))
{
if (IsMultiLinedFormat)
{
var singleLinedSfi = new ScalarFormatInfo(this);
FormatInfoUtils.CopyFormatting(singleLinedFormat, singleLinedSfi);
singleLinedSfi.CombineMaximumFormattedLength(FormatInfoUtils.DefaultMaxFormattedLength);
formatters.Add(singleLinedSfi);
}
formatters.Add(sfi);
}
if (formatters.Count == 0)
{
var dfi = new DictionaryFormatInfo(this);
dfi.MaximumFormattedLength = maxLength;
if (dfi.IsFormatApplicable(type))
{
if (IsMultiLinedFormat)
{
var singleLinedDfi = new DictionaryFormatInfo(this);
FormatInfoUtils.CopyFormatting(singleLinedFormat, singleLinedDfi);
singleLinedDfi.CombineMaximumFormattedLength(FormatInfoUtils.DefaultMaxFormattedLength);
formatters.Add(singleLinedDfi);
}
formatters.Add(dfi);
}
}
if (formatters.Count == 0)
{
var cmfi = new CompactMatrixFormatInfo(this);
cmfi.MaximumFormattedLength = maxLength;
if (cmfi.IsFormatApplicable(type))
{
//if (IsMultiLinedFormat) // Uncomment these lines to enable inlining compactly presented matrices; that operation is not suggested
//{
// CompactMatrixFormatInfo singleLinedCmfi = new CompactMatrixFormatInfo(this);
// FormatInfoUtils.CopyFormatting(singleLinedFormat, singleLinedCmfi);
// singleLinedCmfi.CombineMaximumFormattedLength(FormatInfoUtils.DefaultMaxFormattedLength);
// formatters.Add(singleLinedCmfi);
//}
formatters.Add(cmfi);
}
}
if (formatters.Count == 0)
{
var cafi = new CompactArrayFormatInfo(this);
cafi.MaximumFormattedLength = maxLength;
if (cafi.IsFormatApplicable(type))
{
if (IsMultiLinedFormat)
{
var singleLinedCafi = new CompactArrayFormatInfo(this);
FormatInfoUtils.CopyFormatting(singleLinedFormat, singleLinedCafi);
singleLinedCafi.CombineMaximumFormattedLength(FormatInfoUtils.DefaultMaxFormattedLength);
formatters.Add(singleLinedCafi);
}
formatters.Add(cafi);
}
}
if (formatters.Count == 0)
{
var afi = new ArrayFormatInfo(this);
afi.MaximumFormattedLength = maxLength;
if (afi.IsFormatApplicable(type))
{
if (IsMultiLinedFormat)
{
var singleLinedAfi = new ArrayFormatInfo(this);
FormatInfoUtils.CopyFormatting(singleLinedFormat, singleLinedAfi);
singleLinedAfi.CombineMaximumFormattedLength(FormatInfoUtils.DefaultMaxFormattedLength);
formatters.Add(singleLinedAfi);
}
formatters.Add(afi);
}
}
if (formatters.Count == 0)
{
var efi = new EnumerableFormatInfo(this);
efi.MaximumFormattedLength = maxLength;
if (efi.IsFormatApplicable(type))
{
if (IsMultiLinedFormat)
{
var singleLinedEfi = new EnumerableFormatInfo(this);
FormatInfoUtils.CopyFormatting(singleLinedFormat, singleLinedEfi);
singleLinedEfi.CombineMaximumFormattedLength(FormatInfoUtils.DefaultMaxFormattedLength);
formatters.Add(singleLinedEfi);
}
formatters.Add(efi);
}
}
if (formatters.Count == 0)
{
if (IsMultiLinedFormat)
{
var singleLinedGfi = new GeneralFormatInfo(this);
FormatInfoUtils.CopyFormatting(singleLinedFormat, singleLinedGfi);
singleLinedGfi.CombineMaximumFormattedLength(FormatInfoUtils.DefaultMaxFormattedLength);
formatters.Add(singleLinedGfi);
}
var gfi = new GeneralFormatInfo(this);
gfi.MaximumFormattedLength = maxLength;
formatters.Add(gfi);
}
}
if (formatters.Count > 0)
{
success = success && FormatInfoUtils.BestTryFormat(sb, format, arg, formatters, ref maxLength);
}
if (!success)
{
sb.Length = originalLength;
}
return(success);
}
/// <summary>
/// Converts the value of a specified object to an equivalent string representation using
/// specified format and culture-specific formatting information.
/// </summary>
/// <param name="sb">String builder to which formatted string should be appended.</param>
/// <param name="format">A format string containing formatting specifications.</param>
/// <param name="arg">An object to format.</param>
/// <param name="formatProvider">An object that supplies format information about the current instance.</param>
/// <param name="maxLength">
/// Maximum number of characters allowed to the formatter. Formatting will fail (and return false)
/// if this number of characters is breached. Multi-lined formatters will ignore this parameter.
/// Negative value indicates that formatter has unlimited space available. On output contains remaining number of characters available.
/// </param>
/// <returns>
/// true if representation of <paramref name="arg" /> has been successfully appended to <paramref name="sb" />
/// within given number of allowed characters; otherwise false.
/// </returns>
internal override bool Format(StringBuilder sb, string format, object arg, IFormatProvider formatProvider, ref int maxLength)
{
var success = true;
var originalLength = sb.Length;
if (PushCurrentObject(arg))
{
if (ShowDataType)
{
var instanceType = GetInstanceType(arg);
success = success && AppendFriendlyTypeName(instanceType, arg, sb, ref maxLength);
}
if (sb.Length > originalLength)
{
success = FormatInfoUtils.TryAppendChar(this, sb, ' ', success, ref maxLength);
}
success = FormatInfoUtils.TryAppendString(this, sb, FirstContainedValuePrefix, success, ref maxLength);
if (arg != null)
{
IncIndentationLevel(true);
var array = (Array)arg;
var rows = array.GetLength(0);
var cafi = new CompactArrayFormatInfo(this);
cafi.ShowItemsOnly = true;
cafi.FieldLength = GetMaxValueLength(array);
var rowNumberFormatProvider = new ScalarFormatInfo(VerboseFormatInfo.SingleLinedFormat);
rowNumberFormatProvider.ShowDataType = false;
rowNumberFormatProvider.ShowInstanceName = false;
if (IsMultiLinedFormat)
{
rowNumberFormatProvider.FieldLength = rowNumberFormatProvider.GetValueLength(rows);
}
for (var i = 0; i < rows; i++)
{
if (i == rows - 1)
{
DecIndentationLevel();
IncIndentationLevel(false); // There are no more rows in the matrix
cafi.DecIndentationLevel();
cafi.IncIndentationLevel(false);
}
success = success && FormatLinePrefix(sb, true, i == rows - 1, false, 0, ref maxLength);
success = FormatInfoUtils.TryAppendString(this, sb, "Row ", success, ref maxLength);
success = success && rowNumberFormatProvider.Format(sb, null, i, rowNumberFormatProvider, ref maxLength);
success = FormatInfoUtils.TryAppendChar(this, sb, ' ', success, ref maxLength);
success = FormatInfoUtils.TryAppendString(this, sb, FirstContainedValuePrefix, success, ref maxLength);
// Now we should append row content, which is obtained differently in case of matrix and in case of jagged array
if (array.Rank == 1)
{
// Array is jagged
var row = (Array)array.GetValue(i);
cafi.ShowLastDimension = false;
success = success && cafi.Format(sb, null, row, cafi, ref maxLength);
}
else
{
// Array is a matrix
cafi.HeadingIndices = new[] { i };
cafi.ShowLastDimension = true;
success = success && cafi.Format(sb, null, array, cafi, ref maxLength);
cafi.HeadingIndices = null;
}
success = FormatInfoUtils.TryAppendString(this, sb, LastContainedValueSuffix, success, ref maxLength);
}
DecIndentationLevel();
}
success = FormatInfoUtils.TryAppendString(this, sb, LastContainedValueSuffix, success, ref maxLength);
PopCurrentObject();
}
else
{
success = success && FormatInfoUtils.ReportInfiniteLoop(sb, arg, InstanceName, ref maxLength);
}
if (!success)
{
sb.Length = originalLength;
}
return(success);
}
