public EditableMethodCallExpression(EditableExpressionCollection arguments, MethodInfo method, EditableExpression theObject, ExpressionType nodeType)
{
Arguments = arguments;
Method = method;
Object = theObject;
NodeType = nodeType;
}
/// <summary>
/// Query the server for contracts using a predicate
/// </summary>
/// <param name="pred">Predicate to match instruments against</param>
/// <returns>A list of instruments matching these features.</returns>
public List <Instrument> FindInstruments(Expression <Func <Instrument, bool> > pred)
{
if (!Connected)
{
RaiseEvent(Error, this, new ErrorArgs(-1, "Could not request instruments - not connected."));
return(new List <Instrument>());
}
using (var s = new RequestSocket(_instrumentServerConnectionString))
{
using (var ms = new MemoryStream())
{
EditableExpression mutable = EditableExpression.CreateEditableExpression(pred);
XmlSerializer xs = new XmlSerializer(typeof(EditableExpression),
new[] { typeof(MetaLinq.Expressions.EditableLambdaExpression) });
xs.Serialize(ms, mutable);
//Send the request
s.SendMoreFrame(MessageType.PredicateSearch);
s.SendFrame(ms.ToArray());
}
//And return the result
return(ReceiveInstrumentSearchResults(s));
}
}
public IEnumerable <IValidationIssue> ValidateNonNegative(EditableExpression expression)
{
return(this.ValidateNonNegative(
expression.Name,
expression.EditedValue
));
}
public void ExpressionSearchIsTransmittedCorrectly()
{
//send the expression, then test it against the one received to make sure they're identical
Expression <Func <Instrument, bool> > exp = x => x.Symbol == "SPY" && x.Type == InstrumentType.CFD && !x.IsContinuousFuture;
var ms = new MemoryStream();
EditableExpression editableExpr = EditableExpression.CreateEditableExpression(exp);
XmlSerializer xs = new XmlSerializer(editableExpr.GetType());
xs.Serialize(ms, editableExpr);
Expression <Func <Instrument, bool> > receivedExpr = null;
_instrumentSourceMock.Setup(x =>
x.FindInstruments(It.IsAny <Expression <Func <Instrument, bool> > >(), It.IsAny <MyDBContext>()))
.Callback <Expression <Func <Instrument, bool> >, MyDBContext>((x, y) => receivedExpr = x);
_client.FindInstruments(exp);
Thread.Sleep(100);
Assert.IsNotNull(receivedExpr);
var ms2 = new MemoryStream();
EditableExpression receivedEditableExpr = EditableExpression.CreateEditableExpression(exp);
xs.Serialize(ms2, receivedEditableExpr);
Assert.AreEqual(Encoding.UTF8.GetString(ms.ToArray()), Encoding.UTF8.GetString(ms2.ToArray()));
}
public EditableConditionalExpression(ExpressionType nodeType, EditableExpression test, EditableExpression ifTrue, EditableExpression ifFalse)
{
NodeType = nodeType;
Test = test;
IfTrue = ifTrue;
IfFalse = ifFalse;
}
public EditableConditionalExpression(ConditionalExpression condEx)
{
NodeType = condEx.NodeType;
Test = EditableExpression.CreateEditableExpression(condEx.Test);
IfTrue = EditableExpression.CreateEditableExpression(condEx.IfTrue);
IfFalse = EditableExpression.CreateEditableExpression(condEx.IfFalse);
}
public void PopulateEditableExpression(JsonReader reader, EditableExpression expression)
{
expression.InitialValue = expression.Adapter.Give(new JsonPropertyValueGiver(JsonNames.InitialValue, reader));
expression.EditedValue = expression.Adapter.Give(new JsonPropertyValueGiver(JsonNames.EditedValue, reader));
expression.LastOneModified = reader.ReadAsBoolean(JsonNames.LastOneModified);
expression.Comment = reader.ReadAsNullableString(JsonNames.Comment);
}
private static EditableExpression CheckSerializationInternal(EditableExpression mutableLambda)
{
DataContractSerializer dcs = new DataContractSerializer(mutableLambda.GetType());
MemoryStream ms = new MemoryStream();
XmlDictionaryWriter xdw = XmlDictionaryWriter.CreateTextWriter(ms, Encoding.UTF8, true);
//dcs.WriteObject(xdw, mutableLambda);
XmlSerializer xs = new XmlSerializer(mutableLambda.GetType());
xs.Serialize(ms, mutableLambda);
xdw.Flush();
ms.Flush();
string str = Encoding.UTF8.GetString(ms.ToArray());
MemoryStream ms2 = new MemoryStream(Encoding.UTF8.GetBytes(str));
//Object o = dcs.ReadObject(ms2);
object o = xs.Deserialize(ms2);
if (o is EditableExpression)
{
return(o as EditableExpression);
}
else
{
return(null);
}
}
public ItemModel(
BottomUpPortfolio bottomUpPortfolio,
EditableExpression overlayFactor
)
{
this.BottomUpPortfolio = bottomUpPortfolio;
this.OverlayFactor = overlayFactor;
}
public IEnumerable <IValidationIssue> ValidateBaseExpression(EditableExpression expression)
{
var issues = new List <IValidationIssue>();
issues.AddRange(this.commonParts.ValidateComment(expression));
issues.AddRange(this.commonParts.ValidateNonNegativeOrNull(expression));
return(issues);
}
protected IEnumerable <IValidationIssue> ValidateInputExpression(EditableExpression expression)
{
var issues = new List <IValidationIssue>();
issues.AddRange(this.ValidateComment(expression));
issues.AddRange(this.ValidateNonNegativeOrNull(expression.Name, expression.EditedValue));
return(issues);
}
public ItemModel(
ISecurity security,
EditableExpression targetExpression
)
{
this.Security = security;
this.Target = targetExpression;
}
/// <summary>
/// Initializes a new instance of the <see cref="EditableElementInit" /> class.
/// </summary>
/// <param name="elmInit">
/// The <see cref="ElementInit" /> .
/// </param>
public EditableElementInit(ElementInit elmInit) : this()
{
AddMethod = elmInit.AddMethod;
foreach (Expression ex in elmInit.Arguments)
{
Arguments.Add(EditableExpression.CreateEditableExpression(ex));
}
}
public EditableInvocationExpression(InvocationExpression invocEx)
: this()
{
Expression = EditableExpression.CreateEditableExpression(invocEx.Expression);
foreach (Expression ex in invocEx.Arguments)
{
Arguments.Add(EditableExpression.CreateEditableExpression(ex));
}
}
public ItemModel CreateItem(
ISecurity security,
EditableExpression targetExpression
)
{
var result = new ItemModel(security, targetExpression);
return(result);
}
public BasketRegionModel CreateBasketRegionModel(
ManagingBaskets.RegionBasket basket,
IEnumerable <CountryModel> countries,
Computations computations,
EditableExpression baseExpression,
EditableExpression portfolioAdjustmentExpression
)
{
var result = new BasketRegionModel(
basket,
new SumExpression(
ValueNames.Benchmark,
countries.Select(x => x.Benchmark),
this.defaultValues.DefaultBenchmark,
this.commonParts.ValidateWhatever
),
baseExpression,
self => new ModelFormulaExpression <IModel, Decimal?>(
ValueNames.BaseActive,
self,
computations.BaseActiveFormula,
this.commonParts.NullableDecimalValueAdapter,
this.commonParts.ValidateWhatever
),
new SumExpression(
ValueNames.Overlay,
countries.Select(x => x.Overlay),
this.defaultValues.DefaultOverlay,
this.commonParts.ValidateWhatever
),
portfolioAdjustmentExpression,
self => new ModelFormulaExpression <IModel, Decimal?>(
ValueNames.PortfolioScaled,
self,
computations.PortfolioScaledFormula,
this.commonParts.NullableDecimalValueAdapter,
this.commonParts.ValidateWhatever
),
self => new ModelFormulaExpression <IModel, Decimal?>(
ValueNames.TrueExposure,
self,
computations.TrueExposureFormula,
this.commonParts.NullableDecimalValueAdapter,
this.commonParts.ValidateWhatever
),
self => new ModelFormulaExpression <IModel, Decimal?>(
ValueNames.TrueActive,
self,
computations.TrueActiveFormula,
this.commonParts.NullableDecimalValueAdapter,
this.commonParts.ValidateWhatever
),
countries
);
return(result);
}
private PortfolioTargetModel SerializePortfolioTarget(EditableExpression baseExpression, Core.PortfolioTargetModel model)
{
var result = new PortfolioTargetModel(
this.serializer.SerializeBroadGlobalActivePorfolio(model.BroadGlobalActivePortfolio),
this.serializer.SerializeEditableExpression(model.Target, baseExpression.EditedValue)
);
return(result);
}
public EditableListInitExpression(ListInitExpression listInit)
: this()
{
NewExpression = EditableExpression.CreateEditableExpression(listInit.NewExpression);
foreach (ElementInit e in listInit.Initializers)
{
Initializers.Add(new EditableElementInit(e));
}
}
public BasketCountryModel CreateBasketCountryModel(
ManagingBaskets.CountryBasket basket,
Computations computations,
EditableExpression baseExpression,
EditableExpression portfolioAdjustmentExpression
)
{
var result = new BasketCountryModel(
basket,
new UnchangableExpression <Decimal>(
ValueNames.Benchmark,
this.defaultValues.DefaultBenchmark,
this.commonParts.DecimalValueAdapter,
this.commonParts.ValidateWhatever
),
baseExpression,
self => new ModelFormulaExpression <IModel, Decimal?>(
ValueNames.BaseActive,
self,
computations.BaseActiveFormula,
this.commonParts.NullableDecimalValueAdapter,
this.commonParts.ValidateWhatever
),
new UnchangableExpression <Decimal>(
ValueNames.Overlay,
this.defaultValues.DefaultOverlay,
this.commonParts.DecimalValueAdapter,
this.commonParts.ValidateWhatever
),
portfolioAdjustmentExpression,
self => new ModelFormulaExpression <IModel, Decimal?>(
ValueNames.PortfolioScaled,
self,
computations.PortfolioScaledFormula,
this.commonParts.NullableDecimalValueAdapter,
this.commonParts.ValidateWhatever
),
self => new ModelFormulaExpression <IModel, Decimal?>(
ValueNames.TrueExposure,
self,
computations.TrueExposureFormula,
this.commonParts.NullableDecimalValueAdapter,
this.commonParts.ValidateWhatever
),
self => new ModelFormulaExpression <IModel, Decimal?>(
ValueNames.TrueActive,
self,
computations.TrueActiveFormula,
this.commonParts.NullableDecimalValueAdapter,
this.commonParts.ValidateWhatever
),
this.commonParts
);
return(result);
}
public EditableLambdaExpression(LambdaExpression lambEx)
: base(lambEx.Type)
{
Parameters = new EditableExpressionCollection();
Body = EditableExpression.CreateEditableExpression(lambEx.Body);
foreach (ParameterExpression param in lambEx.Parameters)
{
Parameters.Add(EditableExpression.CreateEditableExpression(param));
}
}
public void StackReferenceExpressionSerializationTest()
{
ISimpleService service = Simply.Do[ConfigKey].Resolve <ISimpleService>();
int hh = 42;
Expression <Predicate <int> > pred = i => i == hh;
EditableExpression expr = EditableExpression.Create(Funcletizer.PartialEval(pred));
service.TestExpression(expr, 41).Should().Be.False();
service.TestExpression(expr, 42).Should().Be.True();
}
public void TestGeneratedQuoteSerialization()
{
Expression <Func <int, int> > original = x => x * 2;
var expr1 = EditableExpression.Create(Expression.Quote(original));
var bytes = SimpleSerializer.Binary().Serialize(expr1);
var expr2 = (EditableExpression)SimpleSerializer.Binary().Deserialize(bytes);
expr2.Should().Not.Be.Null();
}
public EditableExpression CreatePortfolioTargetExpression(String porfolioName)
{
var result = new EditableExpression(
String.Format(ValueNames.PortfolioTargetFormat, porfolioName),
this.defaultValues.DefaultPortfolioTarget,
commonParts.NullableDecimalValueAdapter,
this.ValidatePortfolioTargetExpression
);
return(result);
}
public EditableExpression CreateBaseExpression()
{
var result = new EditableExpression(
ValueNames.Base,
this.defaultValues.DefaultBase,
this.commonParts.NullableDecimalValueAdapter,
this.ValidateBaseExpression
);
return(result);
}
public static string Serialize <T>(this Expression <T> expression)
{
using (var stream = new StringWriter())
{
EditableExpression mutable = EditableExpression.CreateEditableExpression(expression);
XmlSerializer xs = new XmlSerializer(typeof(EditableExpression),
new[] { typeof(MetaLinq.Expressions.EditableLambdaExpression) });
xs.Serialize(stream, mutable);
return(stream.ToString());
}
}
public void SerializeEditable(EditableExpression expression, String name, IJsonWriter writer)
{
writer.Write(name, delegate
{
expression.Adapter.Take(new Write_NamedValueAdapter(JsonNames.InitialValue, writer), expression.InitialValue);
expression.Adapter.Take(new Write_NamedValueAdapter(JsonNames.EditedValue, writer), expression.EditedValue);
writer.Write(expression.LastOneModified, JsonNames.LastOneModified);
writer.Write(expression.Comment, JsonNames.Comment);
var issues = expression.Validate();
this.validationSerializer.SerializeValidationIssuesIfAny(issues, writer);
});
}
public void SimpleExpressionSerializationTest()
{
using (Simply.KeyContext(ConfigKey))
{
ISimpleService service = Simply.Do.Resolve <ISimpleService>();
Expression <Predicate <int> > pred = i => i == 42;
EditableExpression expr = EditableExpression.Create(Funcletizer.PartialEval(pred));
service.TestExpression(expr, 41).Should().Be.False();
service.TestExpression(expr, 42).Should().Be.True();
}
}
/// <summary>
/// Create a new SerializableExpression.
/// </summary>
/// <param name="expression">Expression to serialize.</param>
public SerializableFunc(Expression <Func <TOut> > expression)
{
var editableExpression = EditableExpression.CreateEditableExpression(expression);
var ms = new MemoryStream();
var serializer = new XmlSerializer(editableExpression.GetType());
serializer.Serialize(ms, editableExpression);
ms.Flush();
_xmlString = Encoding.UTF8.GetString(ms.ToArray());
_type = editableExpression.GetType();
}
public void Serialize(EditableExpression expression, String name, IJsonWriter writer, Decimal?displayValue)
{
writer.Write(name, delegate
{
writer.Write(expression.InitialValue, JsonNames.InitialValue);
writer.Write(expression.EditedValue, JsonNames.EditedValue);
writer.Write(displayValue, JsonNames.DisplayValue);
writer.Write(expression.LastOneModified, JsonNames.LastOneModified);
writer.Write(expression.Comment, JsonNames.Comment);
var issues = expression.Validate();
this.validationSerializer.SerializeValidationIssuesIfAny(issues, writer);
});
}
//return all the nodes in a given expression tree
public static IEnumerable <EditableExpression> Nodes(this EditableExpression source)
{
//i.e. left, right, body, etc.
foreach (EditableExpression linkNode in source.LinkNodes())
{
//recursive call to get the nodes from the tree, until you hit terminals
foreach (EditableExpression subNode in linkNode.Nodes())
{
yield return(subNode);
}
}
yield return(source); //return the root of this most recent call
}
