private ObjectContext GetObjectContext(Naked naked)
{
if (naked == null)
{
return(null);
}
var nakedObject = naked as NakedObject;
if (nakedObject != null)
{
IEnumerable <ActionWrapper> actions = nakedObject.getSpecification().GetActionLeafNodes().Where(p => p.isVisible(nakedObject).isAllowed());
IEnumerable <NakedObjectField> properties = nakedObject.getSpecification().getFields().Where(p => !p.isHidden() && p.isVisible(nakedObject).isAllowed());
return(new ObjectContext(nakedObject)
{
VisibleActions = actions.Select(a => new ActionContext {
Action = a,
Target = nakedObject,
VisibleParameters = GetContextParms(a, nakedObject)
}).ToArray(),
VisibleProperties = properties.Select(p => new PropertyContext {
Property = p,
Target = nakedObject
}).ToArray()
});
}
return(new ObjectContext(naked));
}
/// <summary>
/// Construct Fact.
/// </summary>
/// <param name="ID"></param>
/// <param name="Value"></param>
//[System.Diagnostics.DebuggerHidden]
public Fact(string ID, int priority, object value, Type valueType) : base(ID, priority)
{
//naked
IEvidenceValue x = new Naked(value, valueType);
EvidenceValue = x;
}
static void MakeFromScratch(TypeModel model, string caption)
{
var obj = new Naked();
//try
//{
Extensible.AppendValue(model, obj, 1, BinaryDataFormat.Default, "abc");
Extensible.AppendValue(model, obj, 2, BinaryDataFormat.Default, 456.7F);
Extensible.AppendValue(model, obj, 3, BinaryDataFormat.FixedSize, 123);
CanHazData clone;
using (var ms = new MemoryStream())
{
model.Serialize(ms, obj);
string s = Program.GetByteString(ms.ToArray());
Assert.AreEqual("0A 03 61 62 63 15 9A 59 E4 43 1D 7B 00 00 00", s, caption);
ms.Position = 0;
clone = (CanHazData)model.Deserialize(ms, null, typeof(CanHazData));
}
Assert.AreEqual("abc", clone.A, caption);
Assert.AreEqual(456.7F, clone.B, caption);
Assert.AreEqual(123, clone.C, caption);
//}
//catch
//{
// Debug.WriteLine(caption);
// throw;
//}
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="ID"></param>
/// <param name="operatingId">操作ID</param>
/// <param name="equation">方程式</param>
/// <param name="priority">优先级</param>
public ActionExpression(string ID, string operatingId, string equation, int priority) : base(ID, priority)
{
this.equation = equation;
this.operatingId = operatingId;
//determine the dependent facts 依赖事实
ExpressionEvaluator e = new ExpressionEvaluator();
e.Parse(equation); //this method is slow, do it only when needed
string[] dependents = ExpressionEvaluator.RelatedEvidence(e.Infix);
dependentEvidence = dependents;
//assing a value
Naked naked = new Naked(null, typeof(string));
this.EvidenceValue = naked;
//this is expensive and static, so compute now
evaluator = new ExpressionEvaluator();
evaluator.Parse(equation); //this method is slow, do it only when needed
evaluator.InfixToPostfix(); //this method is slow, do it only when needed
evaluator.GetEvidence += delegate(object sender, EvidenceLookupArgs args)
{
return(RaiseEvidenceLookup(sender, args));
};
}
static void MakeFromScratchImpl(TypeModel model, string caption)
{
var obj = new Naked();
try
{
Extensible.AppendValue(model, obj, 1, DataFormat.Default, "abc");
Extensible.AppendValue(model, obj, 2, DataFormat.Default, 456.7F);
Extensible.AppendValue(model, obj, 3, DataFormat.FixedSize, 123);
CanHazData clone;
using (var ms = new MemoryStream())
{
model.Serialize(ms, obj);
string s = Program.GetByteString(ms.ToArray());
Assert.Equal("0A 03 61 62 63 15 9A 59 E4 43 1D 7B 00 00 00", s); //, caption);
ms.Position = 0;
#pragma warning disable CS0618
clone = (CanHazData)model.Deserialize(ms, null, typeof(CanHazData));
#pragma warning restore CS0618
}
Assert.Equal("abc", clone.A); //, caption);
Assert.Equal(456.7F, clone.B); //, caption);
Assert.Equal(123, clone.C); //, caption);
}
catch
{
Debug.WriteLine(caption);
throw;
}
}
private Symbol ParseToSymbol(string s)
{
Symbol sym = new Symbol();
if (IsOpenParanthesis(s))
{
sym.name = s;
sym.type = Type.OpenBracket;
}
else if (IsCloseParanthesis(s))
{
sym.name = s;
sym.type = Type.CloseBracket;
}
else if (IsFunction(s)) //isfunction must come b4 isvariable because its an exact match where the other isnt
{
sym.name = s;
sym.type = Type.Function;
}
else if (IsOperator(s))
{
sym.name = s;
sym.type = Type.Operator;
}
else if (IsBoolean(s))
{
Naked naked = new Naked(Boolean.Parse(s), typeof(bool));
sym.name = s;
sym.value = naked;
sym.type = Type.Value;
}
else if (IsFact(s))
{
sym.name = s;
sym.type = Type.Fact;
}
else if (IsNumber(s))
{
Naked naked = new Naked(Double.Parse(s), typeof(double));
sym.name = s;
sym.value = naked;
sym.type = Type.Value;
}
else if (IsString(s))
{
Naked naked = new Naked(s.Substring(1, s.Length - 2), typeof(string));
sym.name = s;
sym.value = naked;
sym.type = Type.Value;
}
else
{
//who knows what it is so throw an exception
throw new Exception("Invalid tokin: " + s);
}
return(sym);
}
private bool ValidateParameters(ActionContext actionContext, IDictionary <string, object> rawParms)
{
if (rawParms.Any(kvp => !actionContext.Action.GetParameters(actionContext.Target).Select(p => p.getId()).Contains(kvp.Key)))
{
throw new BadRequestNOSException("Malformed arguments");
}
bool isValid = true;
var orderedParms = new Dictionary <string, ParameterContext>();
// setup orderedparms
foreach (NakedObjectActionParameter parm in actionContext.Action.GetParameters(actionContext.Target))
{
orderedParms[parm.getId()] = new ParameterContext();
object value = rawParms.ContainsKey(parm.getId()) ? rawParms[parm.getId()] : null;
orderedParms[parm.getId()].ProposedValue = value;
orderedParms[parm.getId()].Parameter = parm;
orderedParms[parm.getId()].Action = actionContext.Action;
}
//check for individual parameter validity, including parsing of text input
foreach (NakedObjectActionParameter parm in actionContext.Action.GetParameters(actionContext.Target))
{
try {
Naked valueNakedObject = GetValue(parm.getSpecification(), rawParms.ContainsKey(parm.getId()) ? rawParms[parm.getId()] : null);
orderedParms[parm.getId()].ProposedNakedObject = valueNakedObject;
}
catch (Exception) {
isValid = false;
orderedParms[parm.getId()].Reason = "Invalid Entry"; // i18n
}
}
actionContext.VisibleParameters = orderedParms.Select(p => p.Value).ToArray();
// check for validity of whole set, including any 'co-validation' involving multiple parameters
if (isValid)
{
Consent consent = actionContext.Action.isParameterSetValid(actionContext.Target, orderedParms.Select(kvp => kvp.Value.ProposedNakedObject).ToArray());
if (!consent.isAllowed())
{
foreach (ParameterContext p in actionContext.VisibleParameters)
{
p.Reason = consent.getReason();
}
actionContext.Reason = consent.getReason();
actionContext.ErrorCause = Cause.Disabled;
isValid = false;
}
}
return(isValid);
}
public static void AddNakedArmor(HashSet <Armor> headArmor, HashSet <Armor> torsoArmor, HashSet <Armor> armArmor, HashSet <Armor> waistArmor, HashSet <Armor> legArmor)
{
var nakedArmor = new Naked();
headArmor.Add(nakedArmor.Head);
torsoArmor.Add(nakedArmor.Torso);
armArmor.Add(nakedArmor.Arm);
waistArmor.Add(nakedArmor.Waist);
legArmor.Add(nakedArmor.Leg);
}
private ActionResultContextFacade ExecuteAction(ActionContext actionContext, ArgumentsContextFacade arguments)
{
ValidateConcurrency(actionContext.Target, arguments.Digest);
var actionResultContext = new ActionResultContext {
Target = actionContext.Target, ActionContext = actionContext
};
if (ConsentHandler(actionContext.Action.isAvailable(actionContext.Target), actionResultContext, Cause.Disabled))
{
if (ValidateParameters(actionContext, arguments.Values) && !arguments.ValidateOnly)
{
Naked result = actionContext.Action.execute(actionContext.Target, actionContext.VisibleParameters.Select(p => p.ProposedNakedObject).ToArray());
actionResultContext.Result = GetObjectContext(result);
}
}
return(actionResultContext.ToActionResultContextFacade(this));
}
private static bool ClearAssociation(OneToOneAssociation property, NakedObject target)
{
Naked existingValue = property.get(target);
if (existingValue != null)
{
if (existingValue is NakedObject)
{
property.clearAssociation(target, (NakedObject)existingValue);
}
else
{
ClearValue(property, target);
}
return(true);
}
return(false);
}
public Rule(string ID, string equation, List <EvidenceSpecifier> actions, int priority, bool chainable)
: base(ID, priority)
{
if (actions == null || actions.Count < 1)
{
throw new Exception("Rules must have at least one action.");
}
foreach (EvidenceSpecifier action in actions)
{
if (!action.truthality && chainable)
{
throw new Exception("Chainable rules are not allowed to contain actions whos result is false.");
}
}
this.actions = actions;
this.chainable = chainable;
this.equation = equation;
ArrayList al = new ArrayList();
foreach (EvidenceSpecifier es in actions)
{
al.Add(es.evidenceID);
}
this.clauseEvidence = (string[])al.ToArray(typeof(string));
//this is expensive and static, so compute now
ExpressionEvaluator e = new ExpressionEvaluator();
e.Parse(equation); //this method is slow, do it only when needed
e.InfixToPostfix(); //this method is slow, do it only when needed
this.postfixExpression = e.Postfix; //this method is slow, do it only when needed
//determine the dependent facts
string[] dependents = ExpressionEvaluator.RelatedEvidence(e.Postfix);
dependentEvidence = dependents;
//change event could set its value when a model is attached
Naked naked = new Naked(false, typeof(bool));
base.EvidenceValue = naked;
}
public ObjectFacade(Naked nakedObject, IFrameworkFacade frameworkFacade)
{
this.nakedObject = nakedObject;
FrameworkFacade = frameworkFacade;
}
public Naked[] getChoices(Naked nakedObject)
{
return(choices.Select(o => [email protected]().getAdapterFor(o)).Cast <Naked>().ToArray());
}
public ActionParameterFacade(NakedObjectActionParameter nakedObjectActionParameter, Naked target, IFrameworkFacade frameworkFacade) {
this.nakedObjectActionParameter = nakedObjectActionParameter;
this.target = target;
FrameworkFacade = frameworkFacade;
}
public ActionFacade(ActionWrapper action, Naked target, IFrameworkFacade frameworkFacade)
{
this.action = action;
this.target = target;
FrameworkFacade = frameworkFacade;
}
public AssociationFacade(NakedObjectField assoc, Naked target, IFrameworkFacade frameworkFacade) {
this.assoc = assoc;
this.target = target;
FrameworkFacade = frameworkFacade;
}
private static Consent IsAssociationValid(OneToOneAssociation property, NakedObject target, Naked proposed, bool allowDisabled = false)
{
if (allowDisabled && property.isAvailable(target).isVetoed())
{
return(new Allow());
}
if (proposed is NakedObject)
{
return(property.isAssociationValid(target, (NakedObject)proposed));
}
return(property.isValueValid(target, (NakedValue)proposed));
}
public IObjectFacade GetValue(IObjectFacade target)
{
Naked result = assoc.get((NakedObject)((ObjectFacade)target).NakedObject);
return(result == null ? null : new ObjectFacade(result, FrameworkFacade));
}
public ObjectContext(Naked naked)
{
NakedTarget = naked;
}
public TypeFacade(NakedObjectSpecification spec, Naked target, IFrameworkFacade frameworkFacade)
{
this.spec = spec;
this.target = target;
FrameworkFacade = frameworkFacade;
}
public ActionParameterFacade(NakedObjectActionParameter nakedObjectActionParameter, Naked target, IFrameworkFacade frameworkFacade)
{
this.nakedObjectActionParameter = nakedObjectActionParameter;
this.target = target;
FrameworkFacade = frameworkFacade;
}
public Naked getDefault(Naked nakedObject)
{
return(dflt == null ? null : [email protected]().getAdapterFor(dflt));
}
private void SetAssociation(OneToOneAssociation property, NakedObject target, Naked proposed)
{
if (proposed is NakedObject)
{
property.setAssociation(target, (NakedObject)proposed);
}
else
{
MethodInfo m = GetType().GetMethod("SetValue").MakeGenericMethod(proposed.getObject().GetType());
m.Invoke(null, new object[] { property, target, proposed });
}
}
public static void SetValue <T>(OneToOneAssociation property, NakedObject target, Naked proposed)
{
object valueHolder = property.get(target).getObject();
MethodInfo m = valueHolder.GetType().GetMethod("setValue", new[] { typeof(T) });
m.Invoke(valueHolder, new[] { proposed.getObject() });
}
public ObjectContext(Naked naked) {
NakedTarget = naked;
}
public ActionFacade(ActionWrapper action, Naked target, IFrameworkFacade frameworkFacade) {
this.action = action;
this.target = target;
FrameworkFacade = frameworkFacade;
}
public Naked getDefault(Naked nakedObject) {
return dflt == null ? null : [email protected]().getAdapterFor(dflt);
}
public AssociationFacade(NakedObjectField assoc, Naked target, IFrameworkFacade frameworkFacade)
{
this.assoc = assoc;
this.target = target;
FrameworkFacade = frameworkFacade;
}
public Naked[] getChoices(Naked nakedObject) {
return choices.Select(o => [email protected]().getAdapterFor(o)).Cast<Naked>().ToArray();
}