public static PhonemeDefinition Get(string text)
{
text = text.ToLower();
if (text.Last().IsNumeric())
{
//Stress = int.Parse(text.Last().ToString());
text = text.Substring(0, text.Length - 1);
//Id = Text + Stress;
}
else
{
//Stress = -1;
//Id = Text;
}
lock (Definitions) {
if (!Definitions.ContainsKey(text))
{
Definitions.Add(text, new PhonemeDefinition(text));
}
return(Definitions[text]);
}
}
/// <summary>
/// Find an entity in the dictionaries
/// </summary>
/// <remarks>Throws a KeyNotFoundException if entity hasn't been found</remarks>
/// <param name="definition_uid">Identifier of an entity</param>
/// <returns>The entity to find</returns>
public IDefinition Find(UInt32 definition_uid)
{
if (!Definitions.ContainsKey(definition_uid))
{
throw new KeyNotFoundException("EntityFactory.find : given definition of id " + definition_uid.ToString() + " hasn't been found");
}
return(Definitions[definition_uid]);
}
public override DataItem LoadData(XElement element, UndoRedoManager undoRedo)
{
var key = element.Attribute(MetaNS + "RefKey")?.Value?.ToString();
if (key == null)
{
key = element.Attribute("RefKey")?.Value?.ToString();
}
if (key == null && Definitions.Count == 1 && !IsNullable)
{
key = Definitions.First().Key;
}
ReferenceItem item = null;
if (key != null && Definitions.ContainsKey(key))
{
var def = Definitions[key];
item = new ReferenceItem(this, undoRedo);
item.ChosenDefinition = def;
var loaded = def.LoadData(element, undoRedo);
item.WrappedItem = loaded;
}
else
{
item = CreateData(undoRedo) as ReferenceItem;
}
foreach (var att in Attributes)
{
var el = element.Attribute(att.Name);
DataItem attItem = null;
if (el != null)
{
attItem = att.LoadData(new XElement(el.Name, el.Value.ToString()), undoRedo);
}
else
{
attItem = att.CreateData(undoRedo);
}
item.Attributes.Add(attItem);
}
return(item);
}
/// <summary>
/// Remove an entity from the internal dictionaries
/// </summary>
/// <remarks>
/// Throws an InvalidOperationException if trying to remove default added entity
/// Throws a KeyNotFoundException if an entity is not identified by the given id
/// </remarks>
/// <param name="definition_uid">Identifier of the entity to remove</param>
public void RemoveEntity(UInt32 definition_uid)
{
if (definition_uid <= 5)
{
throw new InvalidOperationException("EntityFactory.remove : cannot remove base entities");
}
if (!Definitions.ContainsKey(definition_uid))
{
throw new KeyNotFoundException("EntityFactory.remove : given definition uid hasn't been found");
}
ids.Remove(Definitions[definition_uid]);
Definitions.Remove(definition_uid);
}
public Schema GetOrRegister(Type type)
{
var schema = CreateInlineSchema(type);
// Ensure Schema's have been fully generated for all referenced types
while (_referencedTypes.Any(entry => entry.Value.Schema == null))
{
var typeMapping = _referencedTypes.First(entry => entry.Value.Schema == null);
var schemaInfo = typeMapping.Value;
schemaInfo.Schema = CreateDefinitionSchema(typeMapping.Key);
if (!Definitions.ContainsKey(schemaInfo.SchemaId))
{
Definitions.Add(schemaInfo.SchemaId, schemaInfo.Schema);
}
}
return(schema);
}
private Maybe <IParamNode> ParseParam(MergeableGenerator <Token> tokens, ImmutableStack <Closure> scopes, bool expandDefs = true)
{
Token head = tokens.Current;
switch (tokens.Current.Type)
{
case TokenType.OPEN_BRACKET:
return(new Just <IParamNode>(new ListNode(head.Location, ParseList(tokens, scopes)).Simplify()));
case TokenType.STRING:
tokens.MoveNext();
return(new Just <IParamNode>(new StringNode(head)));
case TokenType.MAYBE_MACRO:
//TODO: Move this and the one in ExpandId to a separate ParseMacroNode that may return an Invocation.
if (expandDefs && ExpandIdentifier(tokens, scopes))
{
return(ParseParam(tokens, scopes));
}
else
{
tokens.MoveNext();
IList <IList <Token> > param = ParseMacroParamList(tokens);
//TODO: Smart errors if trying to redefine a macro with the same num of params.
return(new Just <IParamNode>(new MacroInvocationNode(this, head, param, scopes)));
}
case TokenType.IDENTIFIER:
if (expandDefs && Definitions.ContainsKey(head.Content) && ExpandIdentifier(tokens, scopes))
{
return(ParseParam(tokens, scopes, expandDefs));
}
else
{
return(ParseAtom(tokens, scopes, expandDefs).Fmap((IAtomNode x) => (IParamNode)x.Simplify()));
}
default:
return(ParseAtom(tokens, scopes, expandDefs).Fmap((IAtomNode x) => (IParamNode)x.Simplify()));
}
}
public Schema GetOrRegister(Type type)
{
var schema = CreateInlineSchema(type);
// Iterate outstanding work items (i.e. referenced types) and generate the corresponding definition
while (_workItems.Any(entry => entry.Value.Schema == null && !entry.Value.InProgress))
{
var typeMapping = _workItems.First(entry => entry.Value.Schema == null && !entry.Value.InProgress);
var workItem = typeMapping.Value;
workItem.InProgress = true;
workItem.Schema = CreateDefinitionSchema(typeMapping.Key);
if (!Definitions.ContainsKey(workItem.SchemaId))
{
Definitions.Add(workItem.SchemaId, workItem.Schema);
}
workItem.InProgress = false;
}
return(schema);
}
/***
* Precondition: tokens.Current.Type == TokenType.IDENTIFIER || MAYBE_MACRO
* Postcondition: tokens.Current is fully reduced (i.e. not a macro, and not a definition)
* Returns: true iff tokens was actually expanded.
*/
public bool ExpandIdentifier(MergeableGenerator <Token> tokens, ImmutableStack <Closure> scopes)
{
bool ret = false;
//Macros and Definitions.
if (tokens.Current.Type == TokenType.MAYBE_MACRO && Macros.ContainsName(tokens.Current.Content))
{
Token head = tokens.Current;
tokens.MoveNext();
IList <IList <Token> > parameters = ParseMacroParamList(tokens);
if (Macros.HasMacro(head.Content, parameters.Count))
{
tokens.PrependEnumerator(Macros.GetMacro(head.Content, parameters.Count).ApplyMacro(head, parameters, scopes).GetEnumerator());
}
else
{
Error(head.Location, System.String.Format("No overload of {0} with {1} parameters.", head.Content, parameters.Count));
}
return(true);
}
else if (tokens.Current.Type == TokenType.MAYBE_MACRO)
{
Token head = tokens.Current;
tokens.MoveNext();
tokens.PutBack(new Token(TokenType.IDENTIFIER, head.Location, head.Content));
return(true);
}
else if (Definitions.ContainsKey(tokens.Current.Content))
{
Token head = tokens.Current;
tokens.MoveNext();
tokens.PrependEnumerator(Definitions[head.Content].ApplyDefinition(head).GetEnumerator());
return(true);
}
return(ret);
}
public override DataItem LoadData(XElement element, UndoRedoManager undoRedo)
{
var key = element.Attribute(DataDefinition.MetaNS + "RefKey")?.Value?.ToString();
if (key == null)
{
key = element.Attribute("RefKey")?.Value?.ToString();
}
GraphReferenceItem item = null;
if (!element.HasElements)
{
item = new GraphReferenceItem(this, undoRedo);
item.GuidToResolve = element.Value?.ToString();
item.m_LinkType = LinkType.Reference;
}
else if (key != null && Definitions.ContainsKey(key))
{
var def = Definitions[key];
item = new GraphReferenceItem(this, undoRedo);
item.ChosenDefinition = def;
var loaded = def.LoadData(element, undoRedo) as GraphNodeItem;
item.WrappedItem = loaded;
}
else
{
item = CreateData(undoRedo) as GraphReferenceItem;
}
foreach (var att in Attributes)
{
var el = element.Attribute(att.Name);
DataItem attItem = null;
if (el != null)
{
attItem = att.LoadData(new XElement(el.Name, el.Value.ToString()), undoRedo);
}
else
{
attItem = att.CreateData(undoRedo);
}
item.Attributes.Add(attItem);
}
var controlPoints = element.Attribute(DataDefinition.MetaNS + "ControlPoints")?.Value;
if (controlPoints != null)
{
var points = controlPoints.Split('|');
foreach (var point in points)
{
var split = point.Split(',');
var x = double.Parse(split[0]);
var y = double.Parse(split[1]);
var flip = split.Length == 3 ? bool.Parse(split[2]) : false;
item.ControlPoints.Add(new GraphReferenceControlPoint(item, new System.Windows.Point(x, y), flip));
}
}
return(item);
}
public bool IsValidDefinitionName(string name)
{
return(!(Definitions.ContainsKey(name) || IsReservedName(name)));
}
public bool HasPluginFor(Type type)
{
return(type.IsConcrete() ||
Definitions.ContainsKey(type) ||
(type.IsGenericType && Definitions.ContainsKey(type.GetGenericTypeDefinition())));
}
private void Parse(List <string> rawBlock)
{
int i = 0;
while (i < rawBlock.Count)
{
string item = rawBlock[i];
if (item.Contains(KeyValDelimiter))
{
List <KeyValuePair <string, string> > rawKeyVals = ExtractKeyVals(item);
string classname = rawKeyVals.Find(s => s.Key == "classname").Value;
foreach (KeyValuePair <string, string> rawKeyVal in rawKeyVals)
{
Option newOption;
if (Definitions.ContainsKey(classname) && Definitions[classname].KeyValsTemplate.ContainsKey(rawKeyVal.Key))
{
newOption = new Option(Definitions[classname].KeyValsTemplate[rawKeyVal.Key]);
}
else
{
newOption = new Option();
}
newOption.Value = rawKeyVal.Value;
if (!KeyVals.ContainsKey(rawKeyVal.Key))
{
KeyVals.Add(rawKeyVal.Key, newOption);
}
else
{
KeyVals[rawKeyVal.Key] = newOption;
}
}
++i;
}
// An open delimiter that's the first item in the raw block is just the
// start of the top level block; any others indicate children.
else if (item == OpenDelimiter && i != 0)
{
int childOpenBraceIndex = i + 1;
var childBlock = new QuakeBlock(rawBlock, childOpenBraceIndex, Definitions);
Children.Add(childBlock);
i = childBlock.RawStartIndex + childBlock.RawLength;
}
else if (item.StartsWith("(", StringComparison.OrdinalIgnoreCase))
{
string solid = item;
int j = i + 1;
while (rawBlock[j] != CloseDelimiter)
{
solid += rawBlock[j];
j++;
}
Solids.Add(new Solid(ExtractSides(solid)));
i += j;
}
else
{
i++;
}
}
}