public void AllEntriesArePresent()
{
var builder = new EnumBuilder("TestEnum");
builder.PushEntry("A", 1);
builder.PushEntry("B", 2);
Assert.True(builder.HasEntry("A"));
Assert.True(builder.HasEntry("B"));
Assert.True(builder.HasEntry(1));
Assert.True(builder.HasEntry(2));
var enumDefinition = builder.Build();
Assert.True(enumDefinition.HasEntry("A"));
Assert.True(enumDefinition.HasEntry("B"));
Assert.True(enumDefinition.HasEntry(1));
Assert.True(enumDefinition.HasEntry(2));
}
private static void MapEntry(this Context context, EnumBuilder builder, JToken entryToken)
{
if (context == null)
throw new ArgumentNullException(nameof(context));
if (builder == null)
throw new ArgumentNullException(nameof(builder));
if (entryToken == null)
throw new ArgumentNullException(nameof(entryToken));
var parsedName = ParseName();
if (string.IsNullOrEmpty(parsedName))
{
context.Logger?.LogTrace("Skipping entry without name");
return;
}
context.Logger?.LogDebug($"Parsed entry-name: {parsedName}");
var parsedValue = ParseValue();
context.Logger?.LogDebug($"Parsed entry-value: {parsedValue}");
var parsedComment = ParseComment();
if (!string.IsNullOrEmpty(parsedComment))
context.Logger?.LogDebug($"Parsed entry-comment: {parsedComment}");
builder.PushEntry(parsedName, parsedValue, parsedComment);
string ParseName()
{
var nameToken = entryToken.SelectToken(context.EntryNameJPath);
if (nameToken == null)
{
context.Logger?.LogError($"Unable to find entry-name at path: '{context.EntryNameJPath}'");
return null;
}
string name;
try
{
name = nameToken.Value<string>();
}
catch
{
context.Logger?.LogError($"Entry-name at path: '{context.EntryNameJPath}' is not of type 'string'");
return null;
}
context.Logger?.LogTrace($"Entry name-token found: '{name}'");
// Create identifier out of the name.
if (!IdentifierCreator.TryCreateIdentifier(name, out var nameId))
{
context.Logger?.LogError($"Unable to convert name '{name}' into a valid identifier");
return null;
}
// Unduplicate name.
var duplicationCount = 1;
var unduplicatedName = nameId;
while (builder.HasEntry(unduplicatedName))
{
context.Logger?.LogTrace($"Duplicate name '{unduplicatedName}', adding number to unduplicate");
unduplicatedName = $"{nameId}_{duplicationCount++}";
}
return unduplicatedName;
}
long ParseValue()
{
var valueToken = string.IsNullOrEmpty(context.EntryValueJPath) ?
null :
entryToken.SelectToken(context.EntryValueJPath);
if (valueToken == null)
{
context.Logger?.LogTrace(
$"No value found at: '{context.EntryValueJPath}' using count '{builder.EntryCount}' as value");
return builder.EntryCount;
}
try
{
return valueToken.Value<long>();
}
catch
{
context.Logger?.LogWarning($"Value found at: '{context.EntryValueJPath}' is not of type 'number'");
return builder.EntryCount;
}
}
string ParseComment()
{
var commentToken = string.IsNullOrEmpty(context.EntryCommentJPath) ?
null :
entryToken.SelectToken(context.EntryCommentJPath);
if (commentToken == null)
return null;
try
{
return commentToken.Value<string>();
}
catch
{
context.Logger?.LogWarning($"Comment at path: '{context.EntryValueJPath}' is not of type 'string'");
return null;
}
}
}
