public override void Initialize(
DotMethodFP footprint,
EnumMethodEnum enumMethod,
string enumMethodUsedName,
EventType inputEventType,
Type collectionComponentType,
IList<ExprNode> parameters,
StreamTypeService streamTypeService,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
// validate
var ctx = new EnumMethodValidateContext(
footprint,
inputEventType,
collectionComponentType,
streamTypeService,
enumMethod,
parameters,
statementRawInfo);
var enumMethodMode = _forgeFactory.Validate(ctx);
if (!(enumMethodMode is EnumMethodModeStaticMethod)) {
throw new ExprValidationException("Unexpected EnumMethodMode implementation, expected a provided implementation");
}
Mode = (EnumMethodModeStaticMethod) enumMethodMode;
}
public EnumMethodMode Validate(EnumMethodValidateContext context)
{
var stateClass = typeof(MyLocalEnumMethodMedianState); // the class providing state
var serviceClass = typeof(MyLocalEnumMethodMedianService); // the class providing the processing method
var methodName = "Next"; // the name of the method for processing an item of input values
EPType returnType = new ClassEPType(typeof(double?)); // indicate that we are returning a Double-type value
var earlyExit = false;
var mode = new EnumMethodModeStaticMethod(stateClass, serviceClass, methodName, returnType, earlyExit);
// we allow 1, 2 or 3 parameters
mode.LambdaParameters = descriptor => {
if (descriptor.LambdaParameterNumber == 1)
{
return(EnumMethodLambdaParameterTypeIndex.INSTANCE);
}
if (descriptor.LambdaParameterNumber == 2)
{
return(EnumMethodLambdaParameterTypeSize.INSTANCE);
}
return(EnumMethodLambdaParameterTypeValue.INSTANCE);
};
return(mode);
}
public EnumMethodMode Validate(EnumMethodValidateContext context)
{
return(new EnumMethodModeStaticMethod(
typeof(MyLocalEnumMethodForgeTwoLambdaState),
typeof(MyLocalEnumMethodForgeTwoLambdaState),
"Next",
new ClassEPType(typeof(int?)),
false));
}
public EnumMethodMode Validate(EnumMethodValidateContext context)
{
return(new EnumMethodModeStaticMethod(
typeof(MyLocalEnumMethodForgeEarlyExitState),
typeof(MyLocalEnumMethodForgeEarlyExitState),
"Next",
new ClassEPType(typeof(int?)),
true));
}
public EnumMethodMode Validate(EnumMethodValidateContext context)
{
var type = new EventEPType(context.InputEventType);
return(new EnumMethodModeStaticMethod(
typeof(MyLocalEnumMethodForgePredicateReturnSingleEventState),
typeof(MyLocalEnumMethodForgePredicateReturnSingleEvent),
"Next",
type,
true));
}
public EnumMethodMode Validate(EnumMethodValidateContext context)
{
var type = EPTypeHelper.CollectionOfEvents(context.InputEventType);
return(new EnumMethodModeStaticMethod(
typeof(MyLocalEnumMethodForgePredicateReturnEventsState),
typeof(MyLocalEnumMethodForgePredicateReturnEvents),
"Next",
type,
false));
}
public EnumMethodMode Validate(EnumMethodValidateContext context)
{
var mode = new EnumMethodModeStaticMethod(
typeof(MyLocalEnumMethodForgeStateWValueState),
typeof(MyLocalEnumMethodForgeStateWValueState),
"Next",
new ClassEPType(typeof(string)),
false);
mode.LambdaParameters =
descriptor => {
if (descriptor.LambdaParameterNumber == 0)
{
return(new EnumMethodLambdaParameterTypeStateGetter(typeof(string), "Result"));
}
return(EnumMethodLambdaParameterTypeValue.INSTANCE);
};
return(mode);
}
public EnumMethodMode Validate(EnumMethodValidateContext context)
{
var mode = new EnumMethodModeStaticMethod(
typeof(MyLocalEnumMethodForgeThreeState),
typeof(MyLocalEnumMethodForgeThree),
"Next",
new ClassEPType(typeof(int?)),
false);
mode.LambdaParameters =
descriptor => {
if (descriptor.LambdaParameterNumber == 0)
{
return(EnumMethodLambdaParameterTypeValue.INSTANCE);
}
return(EnumMethodLambdaParameterTypeIndex.INSTANCE);
};
return(mode);
}
