#region Copyright notice and license
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// http://github.com/jskeet/dotnet-protobufs/
// Original C++/Java/Python code:
// http://code.google.com/p/protobuf/
//
// 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.
#endregion
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
#if !LITE
using Google.ProtocolBuffers.Collections;
using Google.ProtocolBuffers.Descriptors;
#endif
namespace Google.ProtocolBuffers
{
/// <summary>
/// TODO(jonskeet): Write summary text.
/// </summary>
public sealed class UninitializedMessageException : Exception
{
private readonly IList<string> missingFields;
private UninitializedMessageException(IList<string> missingFields)
: base(BuildDescription(missingFields))
{
this.missingFields = new List<string>(missingFields);
}
/// <summary>
/// Returns a read-only list of human-readable names of
/// required fields missing from this message. Each name
/// is a full path to a field, e.g. "foo.bar[5].baz"
/// </summary>
public IList<string> MissingFields
{
get { return missingFields; }
}
/// <summary>
/// Converts this exception into an InvalidProtocolBufferException.
/// When a parsed message is missing required fields, this should be thrown
/// instead of UninitializedMessageException.
/// </summary>
public InvalidProtocolBufferException AsInvalidProtocolBufferException()
{
return new InvalidProtocolBufferException(Message);
}
/// <summary>
/// Constructs the description string for a given list of missing fields.
/// </summary>
private static string BuildDescription(IEnumerable<string> missingFields)
{
StringBuilder description = new StringBuilder("Message missing required fields: ");
bool first = true;
foreach (string field in missingFields)
{
if (first)
{
first = false;
}
else
{
description.Append(", ");
}
description.Append(field);
}
return description.ToString();
}
/// <summary>
/// For Lite exceptions that do not known how to enumerate missing fields
/// </summary>
public UninitializedMessageException(IMessageLite message)
: base(String.Format("Message {0} is missing required fields", message.GetType()))
{
missingFields = new List<string>();
}
#if !LITE
public UninitializedMessageException(IMessage message)
: this(FindMissingFields(message))
{
}
/// <summary>
/// Returns a list of the full "paths" of missing required
/// fields in the specified message.
/// </summary>
private static IList<String> FindMissingFields(IMessage message)
{
List<String> results = new List<String>();
FindMissingFields(message, "", results);
return results;
}
/// <summary>
/// Recursive helper implementing FindMissingFields.
/// </summary>
private static void FindMissingFields(IMessage message, String prefix, List<String> results)
{
foreach (FieldDescriptor field in message.DescriptorForType.Fields)
{
if (field.IsRequired && !message.HasField(field))
{
results.Add(prefix + field.Name);
}
}
foreach (KeyValuePair<FieldDescriptor, object> entry in message.AllFields)
{
FieldDescriptor field = entry.Key;
object value = entry.Value;
if (field.MappedType == MappedType.Message)
{
if (field.IsRepeated)
{
int i = 0;
foreach (object element in (IEnumerable) value)
{
if (element is IMessage)
{
FindMissingFields((IMessage) element, SubMessagePrefix(prefix, field, i++), results);
}
else
{
results.Add(prefix + field.Name);
}
}
}
else
{
if (message.HasField(field))
{
if (value is IMessage)
{
FindMissingFields((IMessage) value, SubMessagePrefix(prefix, field, -1), results);
}
else
{
results.Add(prefix + field.Name);
}
}
}
}
}
}
private static String SubMessagePrefix(String prefix, FieldDescriptor field, int index)
{
StringBuilder result = new StringBuilder(prefix);
if (field.IsExtension)
{
result.Append('(')
.Append(field.FullName)
.Append(')');
}
else
{
result.Append(field.Name);
}
if (index != -1)
{
result.Append('[')
.Append(index)
.Append(']');
}
result.Append('.');
return result.ToString();
}
#endif
}
}
