public static CodegenExpression Codegen(
EnumDistinctEventsForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var innerType = Boxing.GetBoxedType(forge.InnerExpression.EvaluationType);
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope.MakeChildWithScope(
typeof(FlexCollection),
typeof(EnumDistinctEventsForgeEval),
scope,
codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var block = methodNode.Block
.IfCondition(Relational(ExprDotName(EnumForgeCodegenNames.REF_ENUMCOLL, "Count"), LE, Constant(1)))
.BlockReturn(EnumForgeCodegenNames.REF_ENUMCOLL)
.DeclareVar<IDictionary<object, EventBean>>("distinct", NewInstance(typeof(LinkedHashMap<object, EventBean>)));
block.ForEach(typeof(EventBean), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("next"))
.DeclareVar(
innerType,
"comparable",
forge.InnerExpression.EvaluateCodegen(innerType, methodNode, scope, codegenClassScope))
.IfCondition(Not(ExprDotMethod(Ref("distinct"), "CheckedContainsKey", Ref("comparable"))))
.Expression(ExprDotMethod(Ref("distinct"), "Put", Ref("comparable"), Ref("next")))
.BlockEnd();
block.MethodReturn(FlexWrap(ExprDotName(Ref("distinct"), "Values")));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
protected override EPType InitAndNoParamsReturnType(
EventType inputEventType,
Type collectionComponentType)
{
aggMethodFactory = GetAggregatorFactory(collectionComponentType);
return(EPTypeHelper.SingleValue(Boxing.GetBoxedType(aggMethodFactory.ValueType)));
}
/// <summary>
/// 会有变更
/// </summary>
public void SetBoxingProp()
{
BoxingPropIndex = -1;
if (Boxing.Contains("HMI"))
{
//if(Comment.Contains())
return;
}
if (Boxing.Contains("LR"))
{
// TODO
return;
}
if (Boxing.Contains("PB"))
{
// TODO
return;
}
if (Boxing.Contains("DPB"))
{
//todo
return;
}
if (Boxing.Contains("GPB"))
{
//TODO
}
}
public override CodegenExpression Codegen(
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var innerTypeBoxed = Boxing.GetBoxedType(EPTypeHelper.GetCodegenReturnType(_resultType));
var paramTypes = EnumForgeCodegenNames.PARAMS;
var block = codegenMethodScope
.MakeChild(innerTypeBoxed, typeof(EnumMinMaxEventsForgeEval), codegenClassScope)
.AddParam(paramTypes)
.Block
.DeclareVar(innerTypeBoxed, "minKey", ConstantNull());
var forEach = block.ForEach(typeof(object), "value", EnumForgeCodegenNames.REF_ENUMCOLL)
.IfRefNull("value")
.BlockContinue();
forEach.IfCondition(EqualsNull(Ref("minKey")))
.AssignRef("minKey", Cast(innerTypeBoxed, Ref("value")))
.IfElse()
.IfCondition(
Relational(ExprDotMethod(Unbox(Ref("minKey"), innerTypeBoxed), "CompareTo", Ref("value")), _max ? LT : GT, Constant(0)))
.AssignRef("minKey", Cast(innerTypeBoxed, Ref("value")));
var method = block.MethodReturn(Ref("minKey"));
return LocalMethod(method, args.Expressions);
}
public override EnumForge GetEnumForge(StreamTypeService streamTypeService,
string enumMethodUsedName,
IList<ExprDotEvalParam> bodiesAndParameters,
EventType inputEventType,
Type collectionComponentType,
int numStreamsIncoming,
bool disablePropertyExpressionEventCollCache,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
var max = EnumMethodEnum == EnumMethodEnum.MAX;
if (bodiesAndParameters.IsEmpty()) {
var returnTypeX = Boxing.GetBoxedType(collectionComponentType);
TypeInfo = EPTypeHelper.SingleValue(returnTypeX);
return new EnumMinMaxScalarForge(numStreamsIncoming, max, TypeInfo);
}
var first = (ExprDotEvalParamLambda) bodiesAndParameters[0];
var returnType = Boxing.GetBoxedType(first.BodyForge.EvaluationType);
TypeInfo = EPTypeHelper.SingleValue(returnType);
if (inputEventType == null) {
return new EnumMinMaxScalarLambdaForge(
first.BodyForge,
first.StreamCountIncoming,
max,
(ObjectArrayEventType) first.GoesToTypes[0]);
}
return new EnumMinMaxEventsForge(first.BodyForge, first.StreamCountIncoming, max);
}
void Start()
{
monster = gameObject.GetComponent <Monster>();
search = gameObject.GetComponent <SearchFood>();
stats = gameObject.GetComponent <MonsterStats>();
fetch = gameObject.GetComponent <Fetch>();
boxing = gameObject.GetComponent <Boxing>();
audioSource = gameObject.GetComponent <AudioSource>();
fetch.stats = stats;
fetch.state = this;
fetch.monster = monster;
search.monster = monster;
search.fetch = fetch;
search.state = this;
search.player = GameObject.Find("Player").GetComponent <Valve.VR.InteractionSystem.Player>();
stats.state = this;
stats.monster = monster;
boxing.monster = monster;
boxing.player = monster.mainPlayer;
boxing.obstacleMask = monster.ObstacleMask;
boxing.stats = stats;
boxing.state = this;
stats.DisplayStats();
Vector3 temphPos = hatchObject.transform.position;
temphPos.y = monster.GroundLevel;
gameObject.transform.position = temphPos;
EventManager.instance.Fetching += OnFetching;
EventManager.instance.Pointing += OnPointing;
}
public static ObjectArrayEventType MakeTransientOAType(
string enumMethod,
string propertyName,
Type type,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
IDictionary<string, object> propsResult = new Dictionary<string, object>();
propsResult.Put(propertyName, Boxing.GetBoxedType(type));
var eventTypeName =
services.EventTypeNameGeneratorStatement.GetAnonymousTypeNameEnumMethod(enumMethod, propertyName);
var metadata = new EventTypeMetadata(
eventTypeName,
statementRawInfo.ModuleName,
EventTypeTypeClass.ENUMDERIVED,
EventTypeApplicationType.OBJECTARR,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
var oatype = BaseNestableEventUtil.MakeOATypeCompileTime(
metadata,
propsResult,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(oatype);
return oatype;
}
public EnumMinMaxByEvents(
ExprDotEvalParamLambda lambda,
bool max) : base(lambda)
{
this._max = max;
this._innerTypeBoxed = Boxing.GetBoxedType(InnerExpression.EvaluationType);
}
public static ExcludePlanHint GetHint(
string[] streamNames,
StatementRawInfo rawInfo,
StatementCompileTimeServices services)
{
IList<string> hints = HintEnum.EXCLUDE_PLAN.GetHintAssignedValues(rawInfo.Annotations);
if (hints == null) {
return null;
}
IList<ExprEvaluator> filters = new List<ExprEvaluator>();
foreach (string hint in hints) {
if (string.IsNullOrWhiteSpace(hint)) {
continue;
}
ExprForge forge = ExcludePlanHintExprUtil.ToExpression(hint, rawInfo, services);
if (Boxing.GetBoxedType(forge.EvaluationType) != typeof(bool?)) {
throw new ExprValidationException(
"Expression provided for hint " + HintEnum.EXCLUDE_PLAN + " must return a boolean value");
}
filters.Add(forge.ExprEvaluator);
}
return new ExcludePlanHint(streamNames, filters, services);
}
private void RunAssertionPropertiesWGetter(
RegressionEnvironment env,
string typename,
FunctionSendEventIntString send,
RegressionPath path)
{
var epl = "@Name('s0') select MyInt, exists(MyInt) as exists_MyInt, MyString, exists(MyString) as exists_MyString from " + typename;
env.CompileDeploy(epl, path).AddListener("s0");
var fields = "MyInt,exists_MyInt,MyString,exists_MyString".SplitCsv();
var eventType = env.Statement("s0").EventType;
Assert.AreEqual(typeof(int?), Boxing.GetBoxedType(eventType.GetPropertyType("MyInt")));
Assert.AreEqual(typeof(string), eventType.GetPropertyType("MyString"));
Assert.AreEqual(typeof(bool?), eventType.GetPropertyType("exists_MyInt"));
Assert.AreEqual(typeof(bool?), eventType.GetPropertyType("exists_MyString"));
send.Invoke(typename, env, 3, "some string");
var @event = env.Listener("s0").AssertOneGetNewAndReset();
RunAssertionEventInvalidProp(@event);
EPAssertionUtil.AssertProps(@event, fields, new object[] { 3, true, "some string", true });
send.Invoke(typename, env, 4, "other string");
@event = env.Listener("s0").AssertOneGetNewAndReset();
EPAssertionUtil.AssertProps(@event, fields, new object[] { 4, true, "other string", true });
env.UndeployModuleContaining("s0");
}
protected override CodegenExpression CodegenEvaluateInternal(
CodegenMethodScope parent,
SubselectForgeNRSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(bool?), this.GetType(), classScope);
var left = symbols.GetAddLeftResult(method);
method.Block.DeclareVar<bool>("hasNullRow", ConstantFalse());
var @foreach = method.Block.ForEach(typeof(EventBean), "theEvent", symbols.GetAddMatchingEvents(method));
{
@foreach.AssignArrayElement(NAME_EPS, Constant(0), Ref("theEvent"));
if (filterEval != null) {
CodegenLegoBooleanExpression.CodegenContinueIfNotNullAndNotPass(
@foreach,
filterEval.EvaluationType,
filterEval.EvaluateCodegen(typeof(bool?), method, symbols, classScope));
}
@foreach.IfRefNullReturnNull(left);
Type valueRightType;
if (selectEval != null) {
valueRightType = Boxing.GetBoxedType(selectEval.EvaluationType);
@foreach.DeclareVar(
valueRightType,
"valueRight",
selectEval.EvaluateCodegen(valueRightType, method, symbols, classScope));
}
else {
valueRightType = subselect.RawEventType.UnderlyingType;
@foreach.DeclareVar(
valueRightType,
"valueRight",
Cast(valueRightType, ExprDotUnderlying(ArrayAtIndex(symbols.GetAddEPS(method), Constant(0)))));
}
var ifRight = @foreach.IfCondition(NotEqualsNull(Ref("valueRight")));
{
if (coercer == null) {
ifRight.IfCondition(ExprDotMethod(left, "Equals", Ref("valueRight")))
.BlockReturn(Constant(!isNotIn));
}
else {
ifRight.DeclareVar<object>("left", coercer.CoerceCodegen(left, symbols.LeftResultType))
.DeclareVar<object>("right", coercer.CoerceCodegen(Ref("valueRight"), valueRightType))
.DeclareVar<bool>("eq", ExprDotMethod(Ref("left"), "Equals", Ref("right")))
.IfCondition(Ref("eq"))
.BlockReturn(Constant(!isNotIn));
}
}
ifRight.IfElse().AssignRef("hasNullRow", ConstantTrue());
}
method.Block
.IfCondition(Ref("hasNullRow"))
.BlockReturn(ConstantNull())
.MethodReturn(Constant(isNotIn));
return LocalMethod(method);
}
public static CodegenExpression Codegen(
EnumMinMaxByScalarLambdaForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var innerType = forge.InnerExpression.EvaluationType;
var innerTypeBoxed = Boxing.GetBoxedType(innerType);
var resultTypeBoxed = Boxing.GetBoxedType(EPTypeHelper.GetCodegenReturnType(forge.resultType));
var resultTypeMember = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(ObjectArrayEventType),
Cast(
typeof(ObjectArrayEventType),
EventTypeUtility.ResolveTypeCodegen(forge.resultEventType, EPStatementInitServicesConstants.REF)));
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope
.MakeChildWithScope(
resultTypeBoxed,
typeof(EnumMinMaxByScalarLambdaForgeEval),
scope,
codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var block = methodNode.Block
.DeclareVar(innerTypeBoxed, "minKey", ConstantNull())
.DeclareVar(resultTypeBoxed, "result", ConstantNull())
.DeclareVar<ObjectArrayEventBean>(
"resultEvent",
NewInstance<ObjectArrayEventBean>(NewArrayByLength(typeof(object), Constant(1)), resultTypeMember))
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("resultEvent"))
.DeclareVar<object[]>("props", ExprDotName(Ref("resultEvent"), "Properties"));
var forEach = block.ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement("props", Constant(0), Ref("next"))
.DeclareVar(
innerTypeBoxed,
"value",
forge.InnerExpression.EvaluateCodegen(innerTypeBoxed, methodNode, scope, codegenClassScope))
.IfRefNull("value")
.BlockContinue();
forEach.IfCondition(EqualsNull(Ref("minKey")))
.AssignRef("minKey", Ref("value"))
.AssignRef("result", Cast(resultTypeBoxed, Ref("next")))
.IfElse()
.IfCondition(
Relational(
ExprDotMethod(Unbox(Ref("minKey"), innerTypeBoxed), "CompareTo", Ref("value")),
forge.max ? LT : GT,
Constant(0)))
.AssignRef("minKey", Ref("value"))
.AssignRef("result", Cast(resultTypeBoxed, Ref("next")));
block.MethodReturn(Ref("result"));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
private Type[] GetPropertyTypes(IList<QueryGraphValueEntryHashKeyedForge> hashKeys)
{
var types = new Type[hashKeys.Count];
for (var i = 0; i < hashKeys.Count; i++) {
types[i] = Boxing.GetBoxedType(hashKeys[i].KeyExpr.Forge.EvaluationType);
}
return types;
}
public EnumMinMaxEventPlus(
ExprDotEvalParamLambda lambda,
ObjectArrayEventType indexEventType,
int numParameters,
bool max) : base(lambda, indexEventType, numParameters)
{
this._max = max;
this._innerTypeBoxed = Boxing.GetBoxedType(InnerExpression.EvaluationType);
}
public static void Main()
{
PrimitiveDemo();
BoxingDemo();
ReferenceVsValue.Go();
Boxing.Go();
BoxingForInterfaceMethod.Go();
MutateViaInterface.Go();
}
public static CodegenExpression Codegen(
EnumMostLeastFrequentScalarLamdaForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var resultTypeMember = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(ObjectArrayEventType),
Cast(
typeof(ObjectArrayEventType),
EventTypeUtility.ResolveTypeCodegen(forge.resultEventType, EPStatementInitServicesConstants.REF)));
var returnType = Boxing.GetBoxedType(forge.InnerExpression.EvaluationType);
var scope = new ExprForgeCodegenSymbol(false, null);
var paramTypes = EnumForgeCodegenNames.PARAMS;
var methodNode = codegenMethodScope
.MakeChildWithScope(
returnType,
typeof(EnumMostLeastFrequentScalarLamdaForgeEval),
scope,
codegenClassScope)
.AddParam(paramTypes);
var block = methodNode.Block
.IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty"))
.BlockReturn(ConstantNull())
.DeclareVar<IDictionary<object, int>>("items", NewInstance(typeof(HashMap<object, int>)))
.DeclareVar<ObjectArrayEventBean>(
"resultEvent",
NewInstance<ObjectArrayEventBean>(NewArrayByLength(typeof(object), Constant(1)), resultTypeMember))
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("resultEvent"))
.DeclareVar<object[]>("props", ExprDotName(Ref("resultEvent"), "Properties"));
block.ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement("props", Constant(0), Ref("next"))
.DeclareVar<object>(
"item",
forge.InnerExpression.EvaluateCodegen(typeof(object), methodNode, scope, codegenClassScope))
.DeclareVar<int?>("existing", ExprDotMethod(Ref("items"), "GetBoxed", Ref("item")))
.IfCondition(EqualsNull(Ref("existing")))
.AssignRef("existing", Constant(1))
.IfElse()
.Increment("existing")
.BlockEnd()
.ExprDotMethod(Ref("items"), "Put", Ref("item"), Unbox(Ref("existing")));
block.MethodReturn(
Cast(
returnType,
StaticMethod(
typeof(EnumMostLeastFrequentEventForgeEval),
"GetEnumMostLeastFrequentResult",
Ref("items"),
Constant(forge.isMostFrequent))));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
protected override Func <ExprDotEvalParamLambda, EPType> InitAndSingleParamReturnType(
EventType inputEventType,
Type collectionComponentType)
{
return(lambda => {
aggMethodFactory = GetAggregatorFactory(lambda.BodyForge.EvaluationType);
var returnType = Boxing.GetBoxedType(aggMethodFactory.ValueType);
return EPTypeHelper.SingleValue(returnType);
});
}
private Type[] GetPropertyTypes(
EventType eventType,
string[] properties)
{
var types = new Type[properties.Length];
for (var i = 0; i < properties.Length; i++) {
types[i] = Boxing.GetBoxedType(eventType.GetPropertyType(properties[i]));
}
return types;
}
private static void HandleBox(Boxing boxing, StringBuilder bodySb, TypeDescriptionTable typeTable, ClosureEntities closureEntities)
{
TypeDescription typeDescription = boxing.Right.ComputedType();
bodySb
.AppendFormat("{0} = box_value<{2}>({1}, {3});",
boxing.AssignedTo.Name,
boxing.Right.Name,
typeDescription.GetClrType(closureEntities).ToDeclaredVariableType(EscapingMode.Stack),
typeTable.GetTypeId(typeDescription.GetClrType(closureEntities)));
}
public EnumMinMaxByScalar(
ExprDotEvalParamLambda lambda,
ObjectArrayEventType fieldEventType,
int numParameters,
bool max,
EPType resultType) : base(lambda, fieldEventType, numParameters)
{
this._max = max;
this._resultType = resultType;
this._innerTypeBoxed = Boxing.GetBoxedType(InnerExpression.EvaluationType);
this._resultTypeBoxed = Boxing.GetBoxedType(EPTypeHelper.GetCodegenReturnType(resultType));
}
private static void ValidateBuiltin(
CreateIndexItem columnDesc,
EventType eventType,
IList<IndexedPropDesc> hashProps,
IList<IndexedPropDesc> btreeProps,
ISet<string> indexedColumns)
{
if (columnDesc.Expressions.IsEmpty()) {
throw new ExprValidationException("Invalid empty list of index expressions");
}
if (columnDesc.Expressions.Count > 1) {
throw new ExprValidationException(
"Invalid multiple index expressions for index type '" + columnDesc.IndexType + "'");
}
ExprNode expression = columnDesc.Expressions[0];
if (!(expression is ExprIdentNode)) {
throw new ExprValidationException(
"Invalid index expression '" +
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(expression) +
"'");
}
var identNode = (ExprIdentNode) expression;
if (identNode.FullUnresolvedName.Contains(".")) {
throw new ExprValidationException(
"Invalid index expression '" +
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(expression) +
"'");
}
var columnName = identNode.FullUnresolvedName;
Type type = Boxing.GetBoxedType(eventType.GetPropertyType(columnName));
if (type == null) {
throw new ExprValidationException("Property named '" + columnName + "' not found");
}
if (!indexedColumns.Add(columnName)) {
throw new ExprValidationException(
"Property named '" + columnName + "' has been declared more then once");
}
var desc = new IndexedPropDesc(columnName, type);
string indexType = columnDesc.IndexType;
if (indexType.Equals(CreateIndexType.HASH.GetName(), StringComparison.InvariantCultureIgnoreCase)) {
hashProps.Add(desc);
}
else {
btreeProps.Add(desc);
}
}
private void HandAttachedUpdate(Hand hand)
{
// send signal for monster to dodge
if (hand.GetTrackedObjectVelocity().magnitude > 2)
{
RaycastHit hit;
if (Physics.Raycast(transform.position, transform.forward * 1.3f, out hit, 1))
{
hit.transform.gameObject.SendMessage("Dodge", SendMessageOptions.DontRequireReceiver);
StartCoroutine("HitRefresh");
}
}
if (canBeHit)
{
for (int i = 0; i < monsterColls.Length; i++)
{
if (coll.bounds.Intersects(monsterColls[i].bounds))
{
Boxing mBoxing = monster.GetComponent <Boxing>();
if (mBoxing)
{
mBoxing.GetHit(true);
StartCoroutine("HitRefresh");
}
}
}
//if (otherColl)
//{
// if (coll.bounds.Intersects(otherColl.bounds))
// {
// Collider[] colls = otherColl.GetComponentsInChildren<Collider>();
// for (int i = 0; i < colls.Length; i++)
// {
// if (coll.bounds.Intersects(colls[i].bounds))
// {
// Boxing mBoxing = colls[i].GetComponentInParent<Boxing>();
// if (mBoxing)
// {
// mBoxing.GetHit(true);
// StartCoroutine("HitRefresh");
// }
// }
// }
// }
//}
}
}
private static void ValidateFieldTypes(
Type declaredClass,
IDictionary <string, FieldInfo> targetFields,
IDictionary <string, object> insertedFields)
{
foreach (var inserted in insertedFields)
{
var insertedName = inserted.Key;
var insertedType = inserted.Value;
var field = targetFields.Get(insertedName);
if (field == null)
{
throw new ExprValidationException("Failed to find public field '" + insertedName + "' on class '" + declaredClass.Name + "'");
}
var fieldClass = Boxing.GetBoxedType(field.FieldType);
if (insertedType is Type)
{
var insertedClass = ((Type)insertedType).GetBoxedType();
if (!TypeHelper.IsSubclassOrImplementsInterface(insertedClass, fieldClass))
{
throw MakeInvalidField(insertedName, insertedClass, declaredClass, field);
}
}
else if (insertedType is TypeBeanOrUnderlying || insertedType is EventType)
{
var eventType = (insertedType is TypeBeanOrUnderlying) ? ((TypeBeanOrUnderlying)insertedType).EventType : (EventType)insertedType;
if (!TypeHelper.IsSubclassOrImplementsInterface(eventType.UnderlyingType, fieldClass))
{
throw MakeInvalidField(insertedName, eventType.UnderlyingType, declaredClass, field);
}
}
else if (insertedType is TypeBeanOrUnderlying[] || insertedType is EventType[])
{
var eventType = (insertedType is TypeBeanOrUnderlying[])
? ((TypeBeanOrUnderlying[])insertedType)[0].EventType
: ((EventType[])insertedType)[0];
if (!fieldClass.IsArray || !TypeHelper.IsSubclassOrImplementsInterface(eventType.UnderlyingType, fieldClass.GetElementType()))
{
throw MakeInvalidField(insertedName, eventType.UnderlyingType, declaredClass, field);
}
}
else
{
throw new IllegalStateException("Unrecognized type '" + insertedType + "'");
}
}
}
public ExprFilterSpecLookupable(
String expression,
ExprEventEvaluator eval,
ExprEvaluator expr,
Type returnType,
bool isNonPropertyEval,
DataInputOutputSerde valueSerde)
{
_expression = expression;
_eval = eval;
_expr = expr;
_returnType = Boxing.GetBoxedType(returnType); // For type consistency for recovery and serde define as boxed type
_isNonPropertyEval = isNonPropertyEval;
_valueSerde = valueSerde;
}
protected override CodegenExpression CodegenEvaluateInternal(
CodegenMethodScope parent,
SubselectForgeNRSymbol symbols,
CodegenClassScope classScope)
{
var method = parent.MakeChild(typeof(bool?), this.GetType(), classScope);
var eps = symbols.GetAddEPS(method);
var evalCtx = symbols.GetAddExprEvalCtx(method);
var left = symbols.GetAddLeftResult(method);
method.Block.IfNullReturnNull(symbols.GetAddLeftResult(method));
if (havingEval != null) {
CodegenExpression having = LocalMethod(
CodegenLegoMethodExpression.CodegenExpression(havingEval, method, classScope, true),
eps,
ConstantTrue(),
evalCtx);
CodegenLegoBooleanExpression.CodegenReturnValueIfNullOrNotPass(
method.Block,
havingEval.EvaluationType,
having,
ConstantNull());
}
CodegenExpression select = LocalMethod(
CodegenLegoMethodExpression.CodegenExpression(selectEval, method, classScope, true),
eps,
ConstantTrue(),
evalCtx);
var rightEvalType = Boxing.GetBoxedType(selectEval.EvaluationType);
method.Block
.DeclareVar(rightEvalType, "rhs", select)
.IfRefNullReturnNull("rhs");
if (coercer == null) {
method.Block.IfCondition(ExprDotMethod(left, "Equals", Ref("rhs"))).BlockReturn(Constant(!isNotIn));
}
else {
method.Block.DeclareVar<object>("left", coercer.CoerceCodegen(left, symbols.LeftResultType))
.DeclareVar<object>("right", coercer.CoerceCodegen(Ref("valueRight"), rightEvalType))
.DeclareVar<bool>("eq", StaticMethod<object>("Equals", Ref("left"), Ref("right")))
.IfCondition(Ref("eq"))
.BlockReturn(Constant(!isNotIn));
}
method.Block.MethodReturn(Constant(isNotIn));
return LocalMethod(method);
}
public ExprFilterSpecLookupableForge(
string expression,
ExprEventEvaluatorForge optionalEventEvalForge,
ExprForge optionalExprForge,
Type returnType,
bool isNonPropertyGetter,
DataInputOutputSerdeForge valueSerde)
{
// prefixing the expression ensures the expression resolves to either the event-eval or the expr-eval
_expression = optionalExprForge != null ? "." + expression : expression;
_optionalEventEvalForge = optionalEventEvalForge;
_optionalExprForge = optionalExprForge;
_returnType = Boxing.GetBoxedType(returnType); // For type consistency for recovery and serde define as boxed type
_isNonPropertyGetter = isNonPropertyGetter;
_valueSerde = valueSerde;
}
public void Box(Type operand)
{
var valueToBox = _evaluator.Pop();
var result = SetNewVReg();
//The type of the value on the stack is not necessarily the boxing type
valueToBox.FixedType = new TypeDescription(operand);
result.FixedType = new TypeDescription(typeof(object));
var boxing = new Boxing
{
AssignedTo = result,
Right = valueToBox
};
AddOperation(boxing);
}
public static CodegenExpression Codegen(
EnumMostLeastFrequentEventForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var returnType = Boxing.GetBoxedType(forge.InnerExpression.EvaluationType);
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope.MakeChildWithScope(
returnType,
typeof(EnumMostLeastFrequentEventForgeEval),
scope,
codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var block = methodNode.Block
.IfCondition(ExprDotMethod(EnumForgeCodegenNames.REF_ENUMCOLL, "IsEmpty"))
.BlockReturn(ConstantNull())
.DeclareVar<IDictionary<object, int>>(
"items",
NewInstance(typeof(HashMap<object, int>)));
var forEach = block
.ForEach(typeof(EventBean), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("next"))
.DeclareVar<object>( // type erasure issue
"item",
forge.InnerExpression.EvaluateCodegen(typeof(object), methodNode, scope, codegenClassScope))
.DeclareVar<int?>(
"existing",
ExprDotMethod(Ref("items"), "GetBoxed", Ref("item")))
.IfCondition(EqualsNull(Ref("existing")))
.AssignRef("existing", Constant(1))
.IfElse()
.Increment("existing")
.BlockEnd()
.ExprDotMethod(Ref("items"), "Put", Ref("item"), Unbox(Ref("existing")));
block.MethodReturn(
Cast(
returnType,
StaticMethod(
typeof(EnumMostLeastFrequentEventForgeEval),
"GetEnumMostLeastFrequentResult",
Ref("items"),
Constant(forge.isMostFrequent))));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
private static void TryAssertionNewWRepresentation(
RegressionEnvironment env,
EventRepresentationChoice rep,
AtomicLong milestone)
{
var epl = rep.GetAnnotationTextWJsonProvided <MyLocalJsonProvided>() +
"@Name('s0') select new { TheString = 'x' || TheString || 'x', IntPrimitive = IntPrimitive + 2} as val0 from SupportBean as sb";
env.CompileDeploy(epl).AddListener("s0").Milestone(milestone.GetAndIncrement());
Assert.AreEqual(
rep.IsAvroEvent() ? typeof(GenericRecord) : typeof(IDictionary <string, object>),
env.Statement("s0").EventType.GetPropertyType("val0"));
var fragType = env.Statement("s0").EventType.GetFragmentType("val0");
if (rep == EventRepresentationChoice.JSONCLASSPROVIDED)
{
Assert.IsNull(fragType);
}
else
{
Assert.IsFalse(fragType.IsIndexed);
Assert.IsFalse(fragType.IsNative);
Assert.AreEqual(typeof(string), fragType.FragmentType.GetPropertyType("TheString"));
Assert.AreEqual(typeof(int?), Boxing.GetBoxedType(fragType.FragmentType.GetPropertyType("IntPrimitive")));
}
var fieldsInner = "TheString,IntPrimitive".SplitCsv();
env.SendEventBean(new SupportBean("E1", -5));
var @event = env.Listener("s0").AssertOneGetNewAndReset();
if (rep.IsAvroEvent())
{
SupportAvroUtil.AvroToJson(@event);
GenericRecord inner = (GenericRecord)@event.Get("val0");
Assert.AreEqual("xE1x", inner.Get("TheString"));
Assert.AreEqual(-3, inner.Get("IntPrimitive"));
}
else
{
EPAssertionUtil.AssertPropsMap((IDictionary <string, object>)@event.Get("val0"), fieldsInner, "xE1x", -3);
}
env.UndeployAll();
}
public static CodegenExpression Codegen(
EnumDistinctScalarLambdaForge forge,
EnumForgeCodegenParams args,
CodegenMethodScope codegenMethodScope,
CodegenClassScope codegenClassScope)
{
var resultTypeMember = codegenClassScope.AddDefaultFieldUnshared(
true,
typeof(ObjectArrayEventType),
Cast(
typeof(ObjectArrayEventType),
EventTypeUtility.ResolveTypeCodegen(forge.resultEventType, EPStatementInitServicesConstants.REF)));
var innerType = Boxing.GetBoxedType(forge.InnerExpression.EvaluationType);
var scope = new ExprForgeCodegenSymbol(false, null);
var methodNode = codegenMethodScope
.MakeChildWithScope(
typeof(FlexCollection),
typeof(EnumDistinctScalarLambdaForgeEval),
scope,
codegenClassScope)
.AddParam(EnumForgeCodegenNames.PARAMS);
var block = methodNode.Block
.IfCondition(Relational(ExprDotName(EnumForgeCodegenNames.REF_ENUMCOLL, "Count"), LE, Constant(1)))
.BlockReturn(EnumForgeCodegenNames.REF_ENUMCOLL)
.DeclareVar<IDictionary<object, object>>("distinct", NewInstance(typeof(LinkedHashMap<object, object>)))
.DeclareVar<ObjectArrayEventBean>(
"resultEvent",
NewInstance<ObjectArrayEventBean>(NewArrayByLength(typeof(object), Constant(1)), resultTypeMember))
.AssignArrayElement(EnumForgeCodegenNames.REF_EPS, Constant(forge.StreamNumLambda), Ref("resultEvent"))
.DeclareVar<object[]>("props", ExprDotName(Ref("resultEvent"), "Properties"));
block.ForEach(typeof(object), "next", EnumForgeCodegenNames.REF_ENUMCOLL)
.AssignArrayElement("props", Constant(0), Ref("next"))
.DeclareVar(
innerType,
"comparable",
forge.InnerExpression.EvaluateCodegen(innerType, methodNode, scope, codegenClassScope))
.IfCondition(Not(ExprDotMethod(Ref("distinct"), "CheckedContainsKey", Ref("comparable"))))
.Expression(ExprDotMethod(Ref("distinct"), "Put", Ref("comparable"), Ref("next")))
.BlockEnd();
block.MethodReturn(FlexWrap(ExprDotName(Ref("distinct"), "Values")));
return LocalMethod(methodNode, args.Eps, args.Enumcoll, args.IsNewData, args.ExprCtx);
}
