private void ReadFormat04(string line)
{
string[] format = line.Split('=');
if (AliasTypes.Contains(format[0]))
{
return;
}
if (format[0].Contains("C*") && format[1].Contains("%C%*") && format[1].Contains("|") && format[1].Contains("{") && format[1].Contains("}"))
{
string n = format[0];
string f = format[1].Split('|')[0];
string s = format[1].Split('|')[1];
s = s.Substring(s.IndexOf('{') + 1, s.Length - s.IndexOf('}'));
for (int i = 0; i < MULTICONSONANT_LIMIT; i++)
{
var final_n = n.Replace("C*", String.Concat(Enumerable.Repeat("C", i + 1)));
var final_f = f.Replace("%C%*", string.Join(s, Enumerable.Repeat("%C%", i + 1)));
Format[final_n] = final_f;
AliasTypes.Add(final_n);
}
}
else
{
Format[format[0]] = format[1];
AliasTypes.Add(format[0]);
}
}
private string GetAliasedValue2(Entity entity, string AttributeName, AliasTypes AliasType = AliasTypes.String)
{
string Value = "";
if (entity.Attributes.ContainsKey(AttributeName))
{
// AliasedValue Alias = entity.GetAttributeValue<AliasedValue>(AttributeName); //(AliasedValue) entity.Attributes[AttributeName];
if (entity.Attributes.Contains(AttributeName))
{
if (AliasType == AliasTypes.String)
{
Value = entity.Attributes[AttributeName].ToString();
}
else if (AliasType == AliasTypes.DateTime)
{
Value = ((DateTime)entity.Attributes[AttributeName]).ToString("yyyy-MM-dd");
}
else if (AliasType == AliasTypes.OptionSet)
{
Value = ((OptionSetValue)entity.Attributes[AttributeName]).Value.ToString();
}
else if (AliasType == AliasTypes.EntityReference)
{
Value = ((EntityReference)entity.Attributes[AttributeName]).Name.ToString();
}
}
}
else
{
//Logger.LogException(new ArgumentNullException(), PriorityLevel.MEDIUM, AttributeName + " has no value", IOrganizationService);
}
return(Value);
}
private void ReadFormat(string line)
{
string[] format = line.Split('=');
if (AliasTypes.Contains(format[0]))
{
return;
}
Format[format[0]] = format[1];
AliasTypes.Add(format[0]);
}
/// <summary>Registers specified types using Type.Name and Type.FullName as alias.</summary>
/// <param name="types">A variable-length parameters list containing types to register.</param>
/// <returns>An Fluent EvalContext.</returns>
public EvalContext RegisterType(params Type[] types)
{
foreach (var type in types)
{
AliasTypes.AddOrUpdate(type.Name, type, (s, t) => type);
AliasTypes.AddOrUpdate(type.FullName, type, (s, t) => type);
}
return(this);
}
/// <summary>Unregisters specified types using Type.Name and Type.FullName as alias.</summary>
/// <param name="types">A variable-length parameters list containing types to unregister.</param>
/// <returns>A Fluent EvalContext.</returns>
public EvalContext UnregisterType(params Type[] types)
{
foreach (var type in types)
{
Type outType;
AliasTypes.TryRemove(type.Name, out outType);
AliasTypes.TryRemove(type.FullName, out outType);
}
return(this);
}
/// <summary>Unregisters all kind of alias (Extension Methods, Names, Static Members, Types and Values).</summary>
/// <returns>An Fluent EvalContext.</returns>
public EvalContext UnregisterAll()
{
AliasExtensionMethods.Clear();
AliasGlobalConstants.Clear();
AliasGlobalVariables.Clear();
AliasNames.Clear();
AliasStaticMembers.Clear();
AliasTypes.Clear();
return(this);
}
/// <summary>Unregisters member from specified types.</summary>
/// <param name="members">A variable-length parameters list containing members.</param>
/// <returns>An Fluent EvalContext.</returns>
public EvalContext UnregisterMember(params MemberInfo[] members)
{
foreach (var member in members)
{
if (member.DeclaringType != null)
{
if (AliasTypes.ContainsKey(member.DeclaringType.FullName))
{
UnregisterType(member.DeclaringType);
RegisterMember(member.DeclaringType);
}
}
ConcurrentDictionary <MemberInfo, byte> values;
if (AliasMembers.TryGetValue(member.Name, out values))
{
byte outByte;
values.TryRemove(member, out outByte);
}
}
return(this);
}
public void ReadAtlas()
{
string[] atlas = File.ReadAllLines(GetAtlasPath(), Encoding.UTF8);
int i = 0;
if (atlas[0] != "[MAIN]")
{
throw new Exception("Can't find main section");
}
;
i++;
while (!atlas[i].StartsWith("["))
{
if (atlas[i].StartsWith("Version"))
{
ReadVersion(atlas[i]);
}
if (atlas[i].StartsWith("Vowels"))
{
ReadVowels(atlas[i]);
}
if (atlas[i].StartsWith("Consonants"))
{
ReadConsonants(atlas[i]);
}
if (atlas[i].StartsWith("Rests"))
{
ReadRest(atlas[i]);
}
if (atlas[i].StartsWith("ExampleWord"))
{
ExampleWord = atlas[i].Substring("ExampleWord=".Length).Trim().ToLower();
}
i++;
}
if (Rests == null)
{
throw new Exception("Can't find Rests definition");
}
if (Consonants == null)
{
throw new Exception("Can't find Consonants definition");
}
if (Vowels == null)
{
throw new Exception("Can't find Vowels definition");
}
BuildPatterns();
// Read02();
if (Version == "0.3")
{
Read03(atlas, i);
}
else if (Version == "0.4")
{
Read04(atlas, i);
}
else
{
throw new Exception($"{VoicebankType} {Version}\n\nCurrent plugin version requests 0.3 or higher Atlas version.");
}
FormatRegex = new Dictionary <string, string>();
foreach (var alias_type in AliasTypes)
{
string pattern = Format[alias_type].Replace("%V%", VowelPattern);
pattern = pattern.Replace("%C%", ConsonantPattern);
pattern = pattern.Replace("%R%", RestPattern);
FormatRegex[alias_type] = pattern;
}
AliasTypes = AliasTypes.OrderBy(n => n.Length).ToList();
}
public bool CanGenerateOnPosition(AliasType aliasType, int position)
{
return(AliasTypes.ContainsKey(aliasType) ? AliasTypes[aliasType].IsAllowedOnPosition(position) : false);
}
