/// <summary>
/// Attempts to parse a modification.
/// </summary>
static public bool TryParse(StringSlice inData, out VariantModification outModification)
{
inData = inData.Trim();
VariantModifyOperator op = default(VariantModifyOperator);
int operatorIdx = -1;
int operatorLength = 0;
VariantUtils.TryFindOperator(inData, '=', VariantModifyOperator.Set, ref operatorIdx, ref op, ref operatorLength);
VariantUtils.TryFindOperator(inData, '+', VariantModifyOperator.Add, ref operatorIdx, ref op, ref operatorLength);
VariantUtils.TryFindOperator(inData, '-', VariantModifyOperator.Subtract, ref operatorIdx, ref op, ref operatorLength);
VariantUtils.TryFindOperator(inData, '*', VariantModifyOperator.Multiply, ref operatorIdx, ref op, ref operatorLength);
VariantUtils.TryFindOperator(inData, '/', VariantModifyOperator.Divide, ref operatorIdx, ref op, ref operatorLength);
if (operatorIdx < 0)
{
outModification = default(VariantModification);
return(false);
}
outModification.Operator = op;
StringSlice key = inData.Substring(0, operatorIdx);
StringSlice operand = inData.Substring(operatorIdx + 1);
if (!TableKeyPair.TryParse(key, out outModification.VariableKey))
{
outModification = default(VariantModification);
return(false);
}
return(VariantOperand.TryParse(operand, out outModification.Operand));
}
/// <summary>
/// Attempts to parse data into an operand.
/// </summary>
static public bool TryParse(StringSlice inData, out VariantOperand outOperand)
{
Variant value;
if (Variant.TryParse(inData, out value))
{
outOperand = new VariantOperand(value);
return(true);
}
TableKeyPair tableKey;
if (TableKeyPair.TryParse(inData, out tableKey))
{
outOperand = new VariantOperand(tableKey);
return(true);
}
MethodCall call;
if (MethodCall.TryParse(inData, out call))
{
outOperand = new VariantOperand(call);
return(true);
}
outOperand = default(VariantOperand);
return(false);
}
/// <summary>
/// Removes variable lookup for the given key.
/// </summary>
public CustomVariantResolver ClearVar(TableKeyPair inKey)
{
if (m_FullPathVarLookup != null)
{
m_FullPathVarLookup.Remove(inKey);
m_HasSpecialVariantLookups = CalculateHasSpecialVariants();
}
return(this);
}
/// <summary>
/// Uses a delegate to return a value for the given key.
/// </summary>
public CustomVariantResolver SetVar(TableKeyPair inKey, GetVarWithContextDelegate inGetter)
{
if (inGetter == null)
{
throw new ArgumentNullException("inGetter");
}
MakeFullPathVarRule(inKey).SetDelegate(inGetter);
return(this);
}
/// <summary>
/// Sets up a remap between two full table keys.
/// </summary>
public CustomVariantResolver RemapFullKey(TableKeyPair inKey, TableKeyPair inRemap)
{
m_HasRemaps = true;
if (m_FullKeyRemap == null)
{
m_FullKeyRemap = new Dictionary <TableKeyPair, TableKeyPair>();
}
m_FullKeyRemap[inKey] = inRemap;
return(this);
}
public bool TryGetVariant(object inContext, TableKeyPair inKey, out Variant outVariant)
{
if (m_HasSpecialVariantLookups)
{
if (m_FullPathVarLookup != null)
{
FullPathVarRule rule;
if (m_FullPathVarLookup.TryGetValue(inKey, out rule))
{
outVariant = rule.Resolve(inContext);
return(true);
}
}
if (m_TableVarLookup != null)
{
TableVarRule rule;
if (m_TableVarLookup.TryGetValue(inKey.TableId, out rule))
{
outVariant = rule.Resolve(inKey.VariableId, inContext);
return(true);
}
}
if (m_GetVarWithContextFallback != null)
{
outVariant = m_GetVarWithContextFallback(inKey, inContext);
return(true);
}
if (m_GetVarFallback != null)
{
outVariant = m_GetVarFallback(inKey);
return(true);
}
}
VariantTable table;
if (InternalTryGetTable(inContext, inKey.TableId, out table, false))
{
return(table.TryLookup(inKey.VariableId, out outVariant));
}
if (m_Base != null)
{
return(m_Base.TryGetVariant(inContext, inKey, out outVariant));
}
outVariant = Variant.Null;
return(false);
}
public void RemapKey(ref TableKeyPair ioKey)
{
if (m_HasRemaps)
{
if (m_FullKeyRemap != null)
{
TableKeyPair fullRemap;
if (m_FullKeyRemap.TryGetValue(ioKey, out fullRemap))
{
ioKey = fullRemap;
return;
}
}
if (m_TableIdRemap != null)
{
StringHash32 tableRemap;
if (m_TableIdRemap.TryGetValue(ioKey.TableId, out tableRemap))
{
ioKey.TableId = tableRemap;
}
}
if (m_VariableIdRemap != null)
{
StringHash32 varRemap;
if (m_VariableIdRemap.TryGetValue(ioKey.TableId, out varRemap))
{
ioKey.VariableId = varRemap;
}
}
}
if (m_Base != null)
{
m_Base.RemapKey(ref ioKey);
}
}
private FullPathVarRule MakeFullPathVarRule(TableKeyPair inKey)
{
FullPathVarRule rule;
if (m_FullPathVarLookup == null)
{
m_FullPathVarLookup = new Dictionary <TableKeyPair, FullPathVarRule>();
rule = null;
m_HasSpecialVariantLookups = true;
}
else
{
m_FullPathVarLookup.TryGetValue(inKey, out rule);
}
if (rule == null)
{
rule = new FullPathVarRule();
m_FullPathVarLookup.Add(inKey, rule);
}
return(rule);
}
/// <summary>
/// Attempts to apply a modification.
/// </summary>
static public bool TryModify(this IVariantResolver inResolver, object inContext, TableKeyPair inKey, VariantModifyOperator inOperator, Variant inVariant)
{
inResolver.RemapKey(ref inKey);
VariantTable table;
bool bRetrieved = inResolver.TryGetTable(inContext, inKey.TableId, out table);
if (!bRetrieved || table == null)
{
UnityEngine.Debug.LogErrorFormat("[IVariantResolver] Unable to retrieve table with id '{0}'", inKey.TableId.ToDebugString());
return(false);
}
table.Modify(inKey.VariableId, inOperator, inVariant);
return(true);
}
/// <summary>
/// Attempts to resolve a variable.
/// </summary>
static public bool TryResolve(this IVariantResolver inResolver, object inContext, TableKeyPair inKey, out Variant outVariant)
{
inResolver.RemapKey(ref inKey);
bool bRetrieved = inResolver.TryGetVariant(inContext, inKey, out outVariant);
if (bRetrieved)
{
return(true);
}
VariantTable table;
bool bFoundTable = inResolver.TryGetTable(inContext, inKey.TableId, out table);
if (!bFoundTable || table == null)
{
UnityEngine.Debug.LogErrorFormat("[IVariantResolver] Unable to retrieve table with id '{0}'", inKey.TableId.ToDebugString());
outVariant = Variant.Null;
return(false);
}
return(table.TryLookup(inKey.VariableId, out outVariant));
}
public VariantOperand(TableKeyPair inKey)
: this(Mode.TableKey)
{
m_Data.TableKey = inKey;
}
/// <summary>
/// Sets the value associated with the given key.
/// </summary>
public CustomVariantResolver SetVar(TableKeyPair inKey, Variant inValue)
{
MakeFullPathVarRule(inKey).SetConst(inValue);
return(this);
}
