/// <summary>
/// Initializes a new instance of the <see cref="SpotPriceTrigger" /> class.
/// </summary>
/// <param name="price">Trigger price (required).</param>
/// <param name="rule">Price trigger condition - >=: triggered when market price larger than or equal to `price` field - <=: triggered when market price less than or equal to `price` field (required).</param>
/// <param name="expiration">How many seconds will the order wait for the condition being triggered. Order will be cancelled on timed out (required).</param>
public SpotPriceTrigger(string price = default(string), RuleEnum rule = default(RuleEnum), int expiration = default(int))
{
// to ensure "price" is required (not null)
this.Price = price ?? throw new ArgumentNullException("price", "price is a required property for SpotPriceTrigger and cannot be null");
this.Rule = rule;
this.Expiration = expiration;
}
public void Create_WhenRuleType_ShouldUseExpectedTransformRule(RuleEnum ruleType, Type expectedTansformRuletype)
{
var factory = new MathAssistantApplicationFactory(null);
var application = factory.Create(ruleType);
Assert.IsNotNull(application);
Assert.That(factory.TransformRule.GetType(), Is.EqualTo(expectedTansformRuletype));
}
public void Create_WhenRuleType_ShouldUseExpectedTransformRule(RuleEnum ruleType, Type expectedTansformRuletype)
{
var factory = new MathAssistantApplicationFactory(null);
var application = factory.Create(ruleType);
Assert.IsNotNull(application);
Assert.That(factory.TransformRule.GetType(), Is.EqualTo(expectedTansformRuletype));
}
public MathAssistantApplication Create(RuleEnum ruleType)
{
ITransformRule transformRule = new FizzBuzzRule();
if (ruleType == RuleEnum.Monkey)
{
transformRule = new MonkeyRule();
}
return(Create(transformRule));
}
/// <summary>
/// Creates the specified audience.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="audienceName">Name of the audience.</param>
/// <param name="description">The description.</param>
/// <param name="rule">The rule.</param>
/// <param name="owner">The owner.</param>
/// <param name="update">if set to <c>true</c> [update].</param>
/// <returns></returns>
internal static Audience Create(SPServiceContext context, string audienceName, string description, RuleEnum? rule, string owner, bool update)
{
AudienceManager manager = new AudienceManager(context);
AudienceCollection auds = manager.Audiences;
Audience audience;
if (auds.AudienceExist(audienceName))
{
if (update)
{
audience = auds[audienceName];
audience.AudienceDescription = description ?? "";
}
else
throw new SPException("Audience name already exists");
}
else
audience = auds.Create(audienceName, description??"");// IMPORTANT: the create method does not do a null check but the methods that load the resultant collection assume not null.
if (update && rule.HasValue && audience.GroupOperation != AudienceGroupOperation.AUDIENCE_MIX_OPERATION)
{
if (rule.Value == RuleEnum.Any && audience.GroupOperation != AudienceGroupOperation.AUDIENCE_OR_OPERATION)
audience.GroupOperation = AudienceGroupOperation.AUDIENCE_OR_OPERATION;
else if (rule.Value == RuleEnum.All && audience.GroupOperation != AudienceGroupOperation.AUDIENCE_AND_OPERATION)
audience.GroupOperation = AudienceGroupOperation.AUDIENCE_AND_OPERATION;
}
else
{
if (audience.GroupOperation != AudienceGroupOperation.AUDIENCE_MIX_OPERATION)
{
if (rule.HasValue)
{
if (rule == RuleEnum.Any)
audience.GroupOperation = AudienceGroupOperation.AUDIENCE_OR_OPERATION;
else if (rule == RuleEnum.All)
audience.GroupOperation = AudienceGroupOperation.AUDIENCE_AND_OPERATION;
}
else
audience.GroupOperation = AudienceGroupOperation.AUDIENCE_OR_OPERATION;
}
}
if (!string.IsNullOrEmpty(owner))
{
audience.OwnerAccountName = owner;
}
else
{
audience.OwnerAccountName = string.Empty;
}
audience.Commit();
return audience;
}
private static LinkRule GetDbsmRule(RuleEnum key)
{
switch (key)
{
case RuleEnum.adRICascade:
return(LinkRule.Cascade);
case RuleEnum.adRISetNull:
return(LinkRule.SetNull);
case RuleEnum.adRISetDefault:
return(LinkRule.SetDefault);
default:
return(LinkRule.None);
}
}
public RuleEnum TileNeighborsToMask <T>(T tile) where T : BaseTile <T>
{
RuleEnum ruleMask = 0;
tile.EastNeighbor.Filter(n => tile.IsRightEdge || tile.SameTileCategory(n))
.Match(some: (n) => ruleMask |= RuleEnum.HasEastNeighbor,
none: () => ruleMask |= RuleEnum.NotHasEastNeighbor);
tile.WestNeighbor.Filter(n => tile.IsLeftEdge || tile.SameTileCategory(n))
.Match(some: (n) => ruleMask |= RuleEnum.HasWestNeighbor,
none: () => ruleMask |= RuleEnum.NotHasWestNeighbor);
tile.SouthNeighbor.Filter(n => tile.IsBottomEdge || tile.SameTileCategory(n))
.Match(some: (n) => ruleMask |= RuleEnum.HasSouthNeighbor,
none: () => ruleMask |= RuleEnum.NotHasSouthNeighbor);
tile.NorthNeighbor.Filter(n => tile.IsTopEdge || tile.SameTileCategory(n))
.Match(some: (n) => ruleMask |= RuleEnum.HasNorthNeighbor,
none: () => ruleMask |= RuleEnum.NotHasNorthNeighbor);
tile.SouthEastNeighbor.Filter(n => tile.IsBottomEdge || tile.IsRightEdge || tile.SameTileCategory(n))
.Match(some: (n) => ruleMask |= RuleEnum.HasSouthEastNeighbor,
none: () => ruleMask |= RuleEnum.NotHasSouthEastNeighbor);
tile.SouthWestNeighbor.Filter(n => tile.IsBottomEdge || tile.IsLeftEdge || tile.SameTileCategory(n))
.Match(some: (n) => ruleMask |= RuleEnum.HasSouthWestNeighbor,
none: () => ruleMask |= RuleEnum.NotHasSouthWestNeighbor);
tile.NorthEastNeighbor.Filter(n => tile.IsTopEdge || tile.IsRightEdge || tile.SameTileCategory(n))
.Match(some: (n) => ruleMask |= RuleEnum.HasNorthEastNeighbor,
none: () => ruleMask |= RuleEnum.NotHasNorthEastNeighbor);
tile.NorthWestNeighbor.Filter(n => tile.IsTopEdge || tile.IsLeftEdge || tile.SameTileCategory(n))
.Match(some: (n) => ruleMask |= RuleEnum.HasNorthWestNeighbor,
none: () => ruleMask |= RuleEnum.NotHasNorthWestNeighbor);
return(ruleMask);
}
/// <summary>
/// 对于前缀后缀匹配规则，必须是前缀后缀为一组。
/// </summary>
/// <param name="ruleEnum">枚举规则</param>
/// <param name="ruleArray">候选规则，可以配置多个，仅用于JsonPath, PrefixSuffix</param>
public FindDataAttr(RuleEnum ruleEnum, params string[] ruleArray)
{
RuleEnum = ruleEnum;
RuleArray = ruleArray;
}
public void AddRule(RuleEnum rulemask, Sprite outputSprite)
{
rules.Add(new TileRule(rulemask, outputSprite));
}
public string GetString(RuleEnum r)
{
switch (r)
{
case RuleEnum.PLINE0:
return("PLINE0");
case RuleEnum.P0:
return("P0");
case RuleEnum.LDE0:
return("LDE0");
case RuleEnum.LDE1:
return("LDE1");
case RuleEnum.DE0:
return("DE0");
case RuleEnum.DE1:
return("DE1");
case RuleEnum.T0:
return("T0");
case RuleEnum.T1:
return("T1");
case RuleEnum.T2:
return("T2");
case RuleEnum.T3:
return("T3");
case RuleEnum.T4:
return("T4");
case RuleEnum.DT0:
return("DT0");
case RuleEnum.DT1:
return("DT1");
case RuleEnum.DT2:
return("DT2");
case RuleEnum.DC0:
return("DC0");
case RuleEnum.DC1:
return("DC1");
case RuleEnum.DF0:
return("DF0");
case RuleEnum.LP0:
return("LP0");
case RuleEnum.LP1:
return("LP1");
case RuleEnum.B0:
return("B0");
case RuleEnum.LDV0:
return("LDV0");
case RuleEnum.LDV1:
return("LDV1");
case RuleEnum.LS0:
return("LS0");
case RuleEnum.LS1:
return("LS1");
case RuleEnum.DV0:
return("DV0");
case RuleEnum.LI0:
return("LI0");
case RuleEnum.LI1:
return("LI1");
case RuleEnum.S0:
return("S0");
case RuleEnum.S1:
return("S1");
case RuleEnum.U0:
return("U0");
case RuleEnum.U1:
return("U1");
case RuleEnum.M0:
return("M0");
case RuleEnum.M1:
return("M1");
case RuleEnum.M2:
return("M2");
case RuleEnum.M3:
return("M3");
case RuleEnum.M4:
return("M4");
case RuleEnum.M5:
return("M5");
case RuleEnum.M6:
return("M6");
case RuleEnum.E0:
return("E0");
case RuleEnum.E1:
return("E1");
case RuleEnum.E2:
return("E2");
case RuleEnum.L0:
return("L0");
case RuleEnum.L1:
return("L1");
case RuleEnum.L2:
return("L2");
case RuleEnum.L3:
return("L3");
case RuleEnum.L4:
return("L4");
case RuleEnum.L5:
return("L5");
case RuleEnum.L6:
return("L6");
case RuleEnum.R0:
return("R0");
case RuleEnum.R1:
return("R1");
case RuleEnum.R2:
return("R2");
case RuleEnum.Y0:
return("Y0");
case RuleEnum.Y1:
return("Y1");
case RuleEnum.Y2:
return("Y2");
case RuleEnum.F0:
return("F0");
case RuleEnum.F1:
return("F1");
case RuleEnum.F2:
return("F2");
case RuleEnum.F3:
return("F3");
case RuleEnum.F4:
return("F4");
case RuleEnum.F5:
return("F5");
case RuleEnum.F6:
return("F6");
case RuleEnum.F7:
return("F7");
case RuleEnum.F8:
return("F8");
case RuleEnum.F9:
return("F9");
case RuleEnum.F10:
return("F10");
case RuleEnum.F11:
return("F11");
case RuleEnum.F12:
return("F12");
case RuleEnum.F13:
return("F13");
case RuleEnum.LE0:
return("LE0");
case RuleEnum.LE1:
return("LE1");
case RuleEnum.LV0:
return("LV0");
case RuleEnum.LV1:
return("LV1");
case RuleEnum.LV2:
return("LV2");
case RuleEnum.IDD0:
return("IDD0");
case RuleEnum.IDU0:
return("IDU0");
case RuleEnum.ID0:
return("ID0");
case RuleEnum.TRUE0:
return("TRUE0");
case RuleEnum.FALSE0:
return("FALSE0");
case RuleEnum.CHR0:
return("CHR0");
case RuleEnum.STR0:
return("STR0");
case RuleEnum.NUM0:
return("NUM0");
case RuleEnum.NB0:
return("NB0");
case RuleEnum.MF0:
return("MF0");
case RuleEnum.MC0:
return("MC0");
case RuleEnum.NF0:
return("NF0");
case RuleEnum.MT0:
return("MT0");
case RuleEnum.ME0:
return("ME0");
case RuleEnum.MW0:
return("MW0");
default:
return("");
}
}
// Parse performs a semantical reduction rule parsing logic
public void Parse(ref SemanticalAnalyser analyser, int r) {
RuleEnum rule = Rule(r);
switch (rule) {
case RuleEnum.P0:
break;
case RuleEnum.LDE0:
break;
case RuleEnum.LDE1:
break;
case RuleEnum.DE0:
break;
case RuleEnum.DE1:
break;
case RuleEnum.T0: // T-> 'integer'
var t = TStatic.Attribute.(T);
t.Type = scope.PIntObj;
TStatic.Size = 1;
TStatic.Type = nonterminals.T;
TStatic.Attribute = t;
a.Push(TStatic);
break;
case RuleEnum.T1: // T -> 'char'
var t = TStatic.Attribute.(T);
t.Type = scope.PCharObj;
TStatic.Size = 1;
TStatic.Type = nonterminals.T;
TStatic.Attribute = t;
a.Push(TStatic);
break;
case RuleEnum.T2: // T -> 'boolean'
var t = TStatic.Attribute.(T);
t.Type = scope.PBoolObj;
TStatic.Size = 1;
TStatic.Type = nonterminals.T;
TStatic.Attribute = t;
a.Push(TStatic);
break;
case RuleEnum.T3: // T -> 'string'
var t = TStatic.Attribute.(T);
t.Type = scope.PStringObj;
TStatic.Size = 1;
TStatic.Type = nonterminals.T;
TStatic.Attribute = t;
a.Push(TStatic);
break;
case RuleEnum.T4: // T -> IDU
IDUStatic = a.Top();
var id = IDUStatic.Attribute.(ID);
p = id.Object;
a.Pop();
if (p.Kind.IsType() || p.Kind == scope.KindUniversal) {
var t = TStatic.Attribute.(T);
t.Type = p;
TStatic.Attribute = t;
if (p.Kind == scope.KindAliasType) {
var alias = p.T.(scope.Alias);
TStatic.Size = alias.Size;
} else if (p.Kind == scope.KindArrayType) {
var arr = p.T.(scope.Array);
TStatic.Size = arr.Size;
} else if (p.Kind == scope.KindStructType) {
strcvar t = p.T.(scope.Struct);
TStatic.Size = strct.Size;
}
} else {
var t = TStatic.Attribute.(T);
t.Type = scope.PUniversalObj;
TStatic.Attribute = t;
TStatic.Size = 0;
}
TStatic.Type = nonterminals.T;
a.Push(TStatic);
break;
case RuleEnum.DT0: // DT -> 'type' IDD '=' 'array' '[' NUM ']' 'of' T
TStatic = a.Top();
a.Pop();
NUMStatic = a.Top();
a.Pop();
IDDStatic = a.Top();
a.Pop();
var id = IDDStatic.Attribute.(ID);
var num = NUMStatic.Attribute.(NUM);
var typ = TStatic.Attribute.(T);
p = id.Object;
n = num.Val;
t = typ.Type;
p.Kind = scope.KindArrayType;
break;
case RuleEnum.DT1: // DT -> 'type' IDD '=' 'struct' NB '{' DC '}'
DCStatic = a.Top();
a.Pop();
IDDStatic = a.Top();
a.Pop();
var obj = IDDStatic.Attribute.(ID);
var dc = DCStatic.Attribute.(DC);
p = obj.Object;
p.Kind = scope.KindStructType;
a.scope.EndBlock();
break;
case RuleEnum.DT2: // DT -> 'type' IDD '=' T
TStatic = a.Top();
a.Pop();
IDDStatic = a.Top();
a.Pop();
var id = IDDStatic.Attribute.(ID);
var typ = TStatic.Attribute.(T);
p = id.Object;
t = typ.Type;
p.Kind = scope.KindAliasType;
break;
case RuleEnum.DC0: // DC -> DC ';' LI ':' T
TStatic = a.Top();
a.Pop();
LIStatic = a.Top();
a.Pop();
DC1Static = a.Top();
a.Pop();
var li = LIStatic.Attribute.(LI);
var typ = TStatic.Attribute.(T);
p = li.List;
t = typ.Type;
n = DC1Static.Size;
}
}
private static LinkRule GetDbsmRule(RuleEnum key)
{
switch (key)
{
case RuleEnum.adRICascade:
return LinkRule.Cascade;
case RuleEnum.adRISetNull:
return LinkRule.SetNull;
case RuleEnum.adRISetDefault:
return LinkRule.SetDefault;
default:
return LinkRule.None;
}
}
public void GivenIHaveTransformationRuleOf(string ruleType)
{
this.ruleType = Util.ParseEnum <RuleEnum>(ruleType);
}
