public void Actor_to_actor()
{
var one = system.FreshActorOf<TestInsideActor>();
var another = system.FreshActorOf<TestActor>();
Assert.Throws<ApplicationException>(async () =>
{
var message = new Throw {Exception = new ApplicationException("a-a")};
await one.Tell(new DoTell {Target = another, Message = message});
});
}
private DrawableComposite(IMagickImage image)
{
Throw.IfNull(nameof(image), image);
_image = image;
}
// TODO: in addition to the treatment done by base.VisitThrow, transform rethrown -> throw stack_0.
public override Statement VisitThrow(Throw thrw)
{
Statement stat = base.VisitThrow(thrw);
thrw = stat as Throw;
if (thrw == null) return stat;
/* TODO: see if the following lines are correct
if (thrw.Expression == null)
thrw.Expression = get_stack_var(0);
*/
return thrw;
}
void case_981()
#line 6528 "cs-parser.jay"
{
Error_SyntaxError (yyToken);
yyVal = new Throw (null, GetLocation (yyVals[-1+yyTop]));
}
public override Statement VisitThrow(Throw Throw) {
this.lastBranchWasUnconditional = true;
return Throw;
}
private static string RethrowToString(Throw thrw)
{
return "rethrow";
}
protected virtual void VisitThrow(Throw Throw){
if (Throw == null) return;
if (Throw.NodeType == NodeType.Rethrow)
this.ILGenerator.Emit(OpCodes.Rethrow);
else{
this.Visit(Throw.Expression);
this.ILGenerator.Emit(OpCodes.Throw);
}
}
void QueueDieThrow(string diceType, int quantity, string description)
{
Debug.Log(string.Format("Queueing a dice throw"));
Throw newThrow = new Throw();
newThrow.description = description;
for(int i=0; i<quantity; i++)
{
newThrow.Add(diceType);
}
throws.Add(newThrow);
}
/// <summary>
/// Creates a MonitorTraceListener instance.
/// </summary>
/// <param name="grandOutput">The <see cref="Monitoring.GrandOutput"/> to send traces to.</param>
/// <param name="failFast">
/// When true <see cref="Environment.FailFast(string)"/> will terminate the application on <see cref="Debug.Assert(bool)"/>, <see cref="Trace.Assert(bool)"/>,
/// <see cref="Debug.Fail(string)"/> and <see cref="Trace.Fail(string)"/>.
/// See this <see cref="MonitorTraceListener"/>'s remarks section to understand why this should be false.
/// </param>
public MonitorTraceListener(GrandOutput grandOutput, bool failFast)
{
Throw.CheckNotNullArgument(grandOutput);
GrandOutput = grandOutput;
FailFast = failFast;
}
internal void SetResultForHash(Hash hash, byte[] result)
{
Throw.IfNull(result, nameof(result));
Throw.If(result.Length > 32 * 1024, "transaction result is too large");
_resultMap[hash] = result;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="exception"></param>
public WebSocketManagerErrorEventArgs(WebSocketManagerException exception)
{
Throw.IfNull(exception, nameof(exception));
Exception = exception;
}
/// <summary>
/// Creates a DataType for a collection of the given type.
/// </summary>
/// <param name="elementType">The DataType of the elements of the collection.</param>
/// <returns>A new DataType for a collection.</returns>
public static DataType Collection(DataType elementType)
{
Throw.IfArgumentNull(elementType, nameof(elementType));
return(new DataType($"Collection({elementType})"));
}
public async Task <List <SqsMessage <T> > > ConsumeAsync(CancellationToken cancellationToken)
{
if (_currentConsumerOptions is null || _client is null)
{
Throw.Exception(MisconfiguredConsumerMessage);
}
var request = new ReceiveMessageRequest
{
QueueUrl = _currentConsumerOptions.QueueUrl,
MaxNumberOfMessages = _currentConsumerOptions.MaxNumberOfMessages,
WaitTimeSeconds = _currentConsumerOptions.WaitTimeSeconds,
AttributeNames = _currentConsumerOptions.SQSMessageAttributes,
MessageAttributeNames = _currentConsumerOptions.CustomMessageAttributes
};
if (_currentConsumerOptions.VisibilityTimeout.HasValue)
{
request.VisibilityTimeout = _currentConsumerOptions.VisibilityTimeout.Value;
}
var response = await _client.ReceiveMessageAsync(request, cancellationToken);
if (response is null || response.HttpStatusCode != HttpStatusCode.OK || response.Messages is null || response.Messages.Count == 0)
{
return(_emptyList);
}
var result = new List <SqsMessage <T> >(response.Messages.Count);
foreach (var message in response.Messages)
{
var properties = new Dictionary <string, string>(message.Attributes.Count + message.MessageAttributes.Count, StringComparer.Ordinal);
foreach (var attribute in message.Attributes)
{
properties[attribute.Key] = attribute.Value;
}
foreach (var msgAttribute in message.MessageAttributes)
{
properties[msgAttribute.Key] = msgAttribute.Value.StringValue;
}
var contentType = ContentTypes.Json;
if (message.MessageAttributes.TryGetValue(KnownProperties.ContentType, out var cta))
{
contentType = cta.StringValue;
}
var messageType = default(string);
if (message.MessageAttributes.TryGetValue(KnownProperties.ValueTypeName, out var vtn))
{
messageType = vtn.StringValue;
}
if (_acknowledgementAction is null)
{
Throw.Exception("Acknowledgement action cannot be null for SQS message");
}
try
{
result.Add(new SqsMessage <T>(_acknowledgementAction)
{
Id = message.MessageId,
Properties = properties,
ReceiptHandle = message.ReceiptHandle,
QueueUrl = _currentConsumerOptions.QueueUrl,
Value = _deserializationProvider.From <T>(message.Body, contentType, messageType ?? string.Empty)
});
}
catch (Exception e)
{
// Swallow deserialization exception to prevent blocking the pipeline and processing of subsequent messages.
_logger.LogError(e, $"Error deserializing message body. {e.Message}. {nameof(message.MessageId)}:{message.MessageId}. {nameof(message.MD5OfBody)}:{message.MD5OfBody}");
}
}
return(result);
}
private static HasCustomDebugInformationTag ToHasCustomDebugInformationTag(HandleKind kind)
{
switch (kind)
{
case HandleKind.MethodDefinition: return(HasCustomDebugInformationTag.MethodDef);
case HandleKind.FieldDefinition: return(HasCustomDebugInformationTag.Field);
case HandleKind.TypeReference: return(HasCustomDebugInformationTag.TypeRef);
case HandleKind.TypeDefinition: return(HasCustomDebugInformationTag.TypeDef);
case HandleKind.Parameter: return(HasCustomDebugInformationTag.Param);
case HandleKind.InterfaceImplementation: return(HasCustomDebugInformationTag.InterfaceImpl);
case HandleKind.MemberReference: return(HasCustomDebugInformationTag.MemberRef);
case HandleKind.ModuleDefinition: return(HasCustomDebugInformationTag.Module);
case HandleKind.DeclarativeSecurityAttribute: return(HasCustomDebugInformationTag.DeclSecurity);
case HandleKind.PropertyDefinition: return(HasCustomDebugInformationTag.Property);
case HandleKind.EventDefinition: return(HasCustomDebugInformationTag.Event);
case HandleKind.StandaloneSignature: return(HasCustomDebugInformationTag.StandAloneSig);
case HandleKind.ModuleReference: return(HasCustomDebugInformationTag.ModuleRef);
case HandleKind.TypeSpecification: return(HasCustomDebugInformationTag.TypeSpec);
case HandleKind.AssemblyDefinition: return(HasCustomDebugInformationTag.Assembly);
case HandleKind.AssemblyReference: return(HasCustomDebugInformationTag.AssemblyRef);
case HandleKind.AssemblyFile: return(HasCustomDebugInformationTag.File);
case HandleKind.ExportedType: return(HasCustomDebugInformationTag.ExportedType);
case HandleKind.ManifestResource: return(HasCustomDebugInformationTag.ManifestResource);
case HandleKind.GenericParameter: return(HasCustomDebugInformationTag.GenericParam);
case HandleKind.GenericParameterConstraint: return(HasCustomDebugInformationTag.GenericParamConstraint);
case HandleKind.MethodSpecification: return(HasCustomDebugInformationTag.MethodSpec);
case HandleKind.Document: return(HasCustomDebugInformationTag.Document);
case HandleKind.LocalScope: return(HasCustomDebugInformationTag.LocalScope);
case HandleKind.LocalVariable: return(HasCustomDebugInformationTag.LocalVariable);
case HandleKind.LocalConstant: return(HasCustomDebugInformationTag.LocalConstant);
case HandleKind.ImportScope: return(HasCustomDebugInformationTag.ImportScope);
default:
Throw.InvalidArgument_UnexpectedHandleKind(kind);
return(0);
}
}
public virtual OrderBookTop Deserialize(string json)
{
Throw.IfNullOrWhiteSpace(json, nameof(json));
return(DeserializeOrderBookTop(JObject.Parse(json)));
}
public override Node VisitQueryTransact(QueryTransact qt) {
if (qt == null || qt.Source == null || qt.Source.Type == null) return null;
Block block = new Block(new StatementList(10));
qt.Transaction = this.NewClosureLocal(SystemTypes.IDbTransaction, this.currentMethod.Body.Scope);
Expression locCommit = this.NewClosureLocal(SystemTypes.Boolean, this.currentMethod.Body.Scope);
TypeNode txType = null;
if (this.GetTypeView(qt.Source.Type).IsAssignableTo(SystemTypes.IDbConnection)) {
txType = SystemTypes.IDbConnection;
}
else if (this.GetTypeView(qt.Source.Type).IsAssignableTo(SystemTypes.IDbTransactable)) {
txType = SystemTypes.IDbTransactable;
}
Expression source = this.typeSystem.ExplicitCoercion(qt.Source, txType, this.TypeViewer);
if (qt.Isolation != null) {
Method mBegin = this.GetTypeView(txType).GetMethod(idBeginTransaction, SystemTypes.IsolationLevel);
MethodCall mcBegin = new MethodCall(new MemberBinding(source, mBegin), new ExpressionList(qt.Isolation));
mcBegin.Type = mBegin.ReturnType;
mcBegin.NodeType = NodeType.Callvirt;
block.Statements.Add(new AssignmentStatement(qt.Transaction, mcBegin));
}
else {
Method mBegin = this.GetTypeView(txType).GetMethod(idBeginTransaction);
MethodCall mcBegin = new MethodCall(new MemberBinding(source, mBegin), null);
mcBegin.Type = mBegin.ReturnType;
mcBegin.NodeType = NodeType.Callvirt;
block.Statements.Add(new AssignmentStatement(qt.Transaction, mcBegin));
}
block.Statements.Add(new AssignmentStatement(locCommit, Literal.True));
// prepare finally block
Block finBlock = new Block(new StatementList(10));
Method mRollback = SystemTypes.IDbTransaction.GetMethod(idRollback);
MethodCall mcRollback = new MethodCall(new MemberBinding(qt.Transaction, mRollback), null);
mcRollback.Type = mRollback.ReturnType;
mcRollback.NodeType = NodeType.Callvirt;
Method mCommit = SystemTypes.IDbTransaction.GetMethod(idCommit);
MethodCall mcCommit = new MethodCall(new MemberBinding(qt.Transaction, mCommit), null);
mcCommit.Type = mCommit.ReturnType;
mcCommit.NodeType = NodeType.Callvirt;
Method mDispose = SystemTypes.IDisposable.GetMethod(StandardIds.Dispose);
MethodCall mcDispose = new MethodCall(new MemberBinding(qt.Transaction, mDispose), null);
mcDispose.Type = mDispose.ReturnType;
mcDispose.NodeType = NodeType.Callvirt;
Block bCommitStart = new Block();
Block bCommitBody = new Block(qt.CommitBody.Statements);
Block bRollbackBody = new Block(qt.RollbackBody.Statements);
Block finExit = new Block();
finBlock.Statements.Add(new Branch(locCommit, bCommitStart));
finBlock.Statements.Add(new ExpressionStatement(mcRollback));
finBlock.Statements.Add(bRollbackBody);
finBlock.Statements.Add(new Branch(null, finExit));
finBlock.Statements.Add(bCommitStart);
finBlock.Statements.Add(new ExpressionStatement(mcCommit));
finBlock.Statements.Add(bCommitBody);
finBlock.Statements.Add(finExit);
finBlock.Statements.Add(new ExpressionStatement(mcDispose));
finBlock.Statements.Add(new AssignmentStatement(qt.Transaction, Literal.Null));
// prepare catcher
Local locEx = new Local(SystemTypes.Object);
Block catchBlock = new Block(new StatementList(2));
catchBlock.Statements.Add(new AssignmentStatement(locCommit, Literal.False));
Throw _throw = new Throw(locEx);
_throw.NodeType = NodeType.Rethrow;
catchBlock.Statements.Add(_throw);
CatchList catchers = new CatchList(1);
catchers.Add(new Catch(catchBlock, locEx, SystemTypes.Object));
// prepare try block
Block tryBlock = new Block(new StatementList(4));
qt.CommitBody.Statements = null;;
qt.RollbackBody.Statements = null;
tryBlock.Statements.Add(qt.Body);
tryBlock.Statements.Add(new Branch(null, qt.CommitBody));
tryBlock.Statements.Add(qt.RollbackBody);
tryBlock.Statements.Add(new AssignmentStatement(locCommit, Literal.False));
tryBlock.Statements.Add(qt.CommitBody);
this.exceptionBlockFor[qt.CommitBody.UniqueKey] = tryBlock;
this.exceptionBlockFor[qt.RollbackBody.UniqueKey] = tryBlock;
// add try-finally to block
block.Statements.Add(new Try(tryBlock, catchers, null, null, new Finally(finBlock)));
this.currentTransaction = qt;
Node result = this.VisitBlock(block);
this.currentTransaction = null;
return result;
}
public void Handle(Throw cmd)
{
throw cmd.Exception;
}
public virtual OrderBook Deserialize(string json)
{
Throw.IfNullOrWhiteSpace(json, nameof(json));
return(JsonConvert.DeserializeObject <OrderBook>(json, _settings));
}
public void Add(Throw newThrow)
{
throwQueue.Add(newThrow);
}
public virtual string Serialize(OrderBook orderBook)
{
Throw.IfNull(orderBook, nameof(orderBook));
return(JsonConvert.SerializeObject(orderBook, _settings));
}
public virtual object Visit (Throw throwStatement)
{
return null;
}
public override Statement VisitThrow(Throw Throw)
{
this.lastBranchWasUnconditional = true;
return(Throw);
}
public override Statement VisitThrow(Throw Throw)
{
throw new ApplicationException("unimplemented");
}
public static Channel Build(RSS rss)
{
Throw.IfIsNull(rss, nameof(rss));
return(BuildCore(rss, rss.Raw.Element(ElementName)));
}
void case_979()
#line 6518 "cs-parser.jay"
{
yyVal = new Throw ((Expression) yyVals[-1+yyTop], GetLocation (yyVals[-2+yyTop]));
lbag.AddStatement (yyVal, GetLocation (yyVals[0+yyTop]));
}
/// <summary>
/// Performs compression on the specified the file. With some formats the image will be decoded
/// and encoded and this will result in a small quality reduction. If the new file size is not
/// smaller the file won't be overwritten.
/// </summary>
/// <param name="file">The image file to compress.</param>
/// <param name="quality">The jpeg quality.</param>
public void Compress(FileInfo file, int quality)
{
Throw.IfNull(nameof(file), file);
DoCompress(file, false, quality);
}
public virtual void Throw(VariableBase Exception)
{
Throw TempCommand = new Throw(Exception);
TempCommand.Setup();
Commands.Add(TempCommand);
}
/// <summary>
/// Performs lossless compression on the specified the file. If the new file size is not smaller
/// the file won't be overwritten.
/// </summary>
/// <param name="file">The jpeg file to compress.</param>
public void LosslessCompress(FileInfo file)
{
Throw.IfNull(nameof(file), file);
DoCompress(file, true, 0);
}
public override object Visit (Throw throwStatement)
{
var result = new ThrowStatement ();
var location = LocationsBag.GetLocations (throwStatement);
result.AddChild (new CSharpTokenNode (Convert (throwStatement.loc), ThrowStatement.ThrowKeywordRole), ThrowStatement.ThrowKeywordRole);
if (throwStatement.Expr != null)
result.AddChild ((Expression)throwStatement.Expr.Accept (this), Roles.Expression);
if (location != null)
result.AddChild (new CSharpTokenNode (Convert (location [0]), Roles.Semicolon), Roles.Semicolon);
return result;
}
public object Any(Throw request) => HttpError.Conflict("Conflict message");
public virtual Statement MarkAsInstrumentationCode(Block block){
Throw rethrow = new Throw();
rethrow.NodeType = NodeType.Rethrow;
Catch catchClause = new Catch(new Block(new StatementList(rethrow)), new Local(SystemTypes.ContractMarkerException), SystemTypes.ContractMarkerException);
CatchList catchers = new CatchList(1);
catchers.Add(catchClause);
return new Try(block, catchers, null, null, null);
}
private static Expression Translate(ParameterExpression parameter, ODataExpression expression)
{
switch (expression.Kind)
{
case ODataExpressionKind.BinaryOp:
var binaryOp = (ODataBinaryOpExpression)expression;
var originalLeft = Translate(parameter, binaryOp.Left);
var originalRight = Translate(parameter, binaryOp.Right);
// MA: nullability negotiation comes up with an expression like "NullableDoubleProp eq 0.1"
var left = originalLeft.NegotiateNullabilityWith(originalRight);
var right = originalRight.NegotiateNullabilityWith(originalLeft);
switch (binaryOp.Operator)
{
case ODataBinaryOp.Or:
return Expression.OrElse(left, right);
case ODataBinaryOp.And:
return Expression.AndAlso(left, right);
case ODataBinaryOp.Add:
return Expression.Add(left, right);
case ODataBinaryOp.Subtract:
return Expression.Subtract(left, right);
case ODataBinaryOp.Multiply:
return Expression.Multiply(left, right);
case ODataBinaryOp.Divide:
return Expression.Divide(left, right);
case ODataBinaryOp.Modulo:
return Expression.Modulo(left, right);
case ODataBinaryOp.Equal:
return Expression.Equal(left, right);
case ODataBinaryOp.NotEqual:
return Expression.NotEqual(left, right);
case ODataBinaryOp.GreaterThan:
return Expression.GreaterThan(left, right);
case ODataBinaryOp.GreaterThanOrEqual:
return Expression.GreaterThanOrEqual(left, right);
case ODataBinaryOp.LessThan:
return Expression.LessThan(left, right);
case ODataBinaryOp.LessThanOrEqual:
return Expression.LessThanOrEqual(left, right);
default:
throw Throw.UnexpectedCase(binaryOp.Operator);
}
case ODataExpressionKind.Call:
var call = (ODataCallExpression)expression;
var arguments = call.Arguments.Select(a => Translate(parameter, a))
.ToArray();
switch (call.Function)
{
// TODO FUTURE: rethink how we apply functions to nullables NullReferenceExceptions
case ODataFunction.Cast:
return Expression.Convert(arguments[0], (Type)((ConstantExpression)arguments[1]).Value);
case ODataFunction.Ceiling:
return Expression.Call(typeof(Math), "Ceiling", Type.EmptyTypes, ValueOf(arguments.Single()));
case ODataFunction.Floor:
return Expression.Call(typeof(Math), "Floor", Type.EmptyTypes, ValueOf(arguments.Single()));
case ODataFunction.Concat:
return Expression.Call(Helpers.GetMethod(() => string.Concat(default(string), default(string))), arguments);
case ODataFunction.Length:
return Expression.MakeMemberAccess(ValueOf(arguments.Single()), Helpers.GetProperty((string s) => s.Length));
case ODataFunction.EndsWith:
return Expression.Call(arguments[0], "EndsWith", Type.EmptyTypes, arguments[1]);
case ODataFunction.StartsWith:
return Expression.Call(arguments[0], "StartsWith", Type.EmptyTypes, arguments[1]);
// MA: I'm not 100% sure that EF supports these properties because they also have the SqlFunctions. However, if they
// don't we can always apply a custom post-translator to replace them
case ODataFunction.Day:
return Expression.MakeMemberAccess(ValueOf(arguments.Single()), Helpers.GetProperty((DateTime dt) => dt.Day));
//return Expression.Call(typeof(SqlFunctions), "DatePart", Type.EmptyTypes, Expression.Constant("d"), arguments.Single());
case ODataFunction.Hour:
return Expression.MakeMemberAccess(ValueOf(arguments.Single()), Helpers.GetProperty((DateTime dt) => dt.Hour));
//return Expression.Call(typeof(SqlFunctions), "DatePart", Type.EmptyTypes, Expression.Constant("h"), arguments.Single());
case ODataFunction.Month:
return Expression.MakeMemberAccess(ValueOf(arguments.Single()), Helpers.GetProperty((DateTime dt) => dt.Month));
//return Expression.Call(typeof(SqlFunctions), "DatePart", Type.EmptyTypes, Expression.Constant("m"), arguments.Single());
case ODataFunction.Minute:
return Expression.MakeMemberAccess(ValueOf(arguments.Single()), Helpers.GetProperty((DateTime dt) => dt.Minute));
//return Expression.Call(typeof(SqlFunctions), "DatePart", Type.EmptyTypes, Expression.Constant("mi"), arguments.Single());
case ODataFunction.Second:
return Expression.MakeMemberAccess(ValueOf(arguments.Single()), Helpers.GetProperty((DateTime dt) => dt.Second));
//return Expression.Call(typeof(SqlFunctions), "DatePart", Type.EmptyTypes, Expression.Constant("s"), arguments.Single());
case ODataFunction.Year:
return Expression.MakeMemberAccess(ValueOf(arguments.Single()), Helpers.GetProperty((DateTime dt) => dt.Year));
//return Expression.Call(typeof(SqlFunctions), "DatePart", Type.EmptyTypes, Expression.Constant("yy"), arguments.Single());
case ODataFunction.IndexOf:
return Expression.Call(arguments[0], "IndexOf", Type.EmptyTypes, arguments[1]);
case ODataFunction.IsOf:
return arguments.Length == 1
? Expression.TypeIs(parameter, (Type)((ConstantExpression)arguments.Single()).Value)
: Expression.TypeIs(arguments[0], (Type)((ConstantExpression)arguments[1]).Value);
case ODataFunction.Replace:
return Expression.Call(arguments[0], "Replace", Type.EmptyTypes, arguments[1], arguments[2]);
case ODataFunction.Round:
return Expression.Call(typeof(Math), "Round", Type.EmptyTypes, ValueOf(arguments.Single()));
case ODataFunction.Substring:
return arguments.Length == 2
? Expression.Call(arguments[0], "Substring", Type.EmptyTypes, arguments[1])
: Expression.Call(arguments[0], "Substring", Type.EmptyTypes, arguments[1], arguments[2]);
case ODataFunction.SubstringOf:
// http://services.odata.org/Northwind/Northwind.svc/Customers?$filter=substringof('Alfreds', CompanyName) eq true&$format=application/json
// returns an entry with "CompanyName":"Alfreds Futterkiste". Thus, this is interpreted as "is the first argument a substring of the second"
// or second.Contains(first)
return Expression.Call(arguments[1], "Contains", Type.EmptyTypes, arguments[0]);
case ODataFunction.ToLower:
return Expression.Call(arguments.Single(), "ToLower", Type.EmptyTypes);
case ODataFunction.ToUpper:
return Expression.Call(arguments.Single(), "ToUpper", Type.EmptyTypes);
case ODataFunction.Trim:
return Expression.Call(arguments.Single(), "Trim", Type.EmptyTypes);
default:
throw Throw.UnexpectedCase(call.Function);
}
case ODataExpressionKind.Constant:
// note that we don't pass a type here but instead rely on the value being the right type (guaranteed by the static factory)
// that also allows this to work better with nulls
return Expression.Constant(((ODataConstantExpression)expression).Value);
case ODataExpressionKind.Convert:
var toConvert = Translate(parameter, ((ODataConvertExpression)expression).Expression);
var convertToType = expression.ClrType;
return Expression.Convert(toConvert, toConvert.Type.CanBeNull() && !convertToType.CanBeNull() ? typeof(Nullable<>).MakeGenericType(convertToType) : convertToType);
case ODataExpressionKind.MemberAccess:
var memberAccess = (ODataMemberAccessExpression)expression;
return Expression.MakeMemberAccess(memberAccess.Expression != null ? Translate(parameter, memberAccess.Expression) : parameter, memberAccess.Member);
case ODataExpressionKind.UnaryOp:
var unaryOp = (ODataUnaryOpExpression)expression;
switch (unaryOp.Operator)
{
case ODataUnaryOp.Not:
return Expression.Not(Translate(parameter, unaryOp.Operand));
default:
throw Throw.UnexpectedCase(unaryOp);
}
default:
throw Throw.UnexpectedCase(expression.Kind, "Cannot translate " + expression.Kind + " to LINQ");
}
}
// Instead of overriding VisitRequiresPlain or VisitRequiresOtherwise, just process the list.
// Almost all of the code is the same for both plain and otherwise requires.
// This could be done by overriding VisitRequires -- but would depend upon introducing
// a VisitRequires method in StandardVisitor.
public override RequiresList VisitRequiresList(RequiresList Requires){
// add a default precondition here and not earlier in the pipeline so it doesn't confuse
// the contract inheritance checks.
// REVIEW: probably better to add it earlier and have a HasCompilerGeneratedSignature on it
// so it can be ignored in the inheritance checks.
bool addDefaultPrecondition =
this.currentMethod != null
&& !this.currentMethod.IsStatic
&& !this.currentMethod.IsAbstract
&& this.currentMethod.Body != null && this.currentMethod.Body.Statements != null
&& !(this.currentMethod.HasCompilerGeneratedSignature && !this.currentMethod.Name.Name.StartsWith("get_") && !this.currentMethod.Name.Name.StartsWith("set_"))
&& this.currentMethod.NodeType != NodeType.InstanceInitializer
&& this.currentMethod.NodeType != NodeType.StaticInitializer
&& (this.currentType != null && this.currentType.Contract != null && this.currentType.Contract.FramePropertyGetter != null)
&& this.currentMethod.GetAttribute(SystemTypes.NoDefaultContractAttribute) == null
;
RequiresList newRequires = new RequiresList();
if (addDefaultPrecondition){
Method frameGetter = this.currentType.Contract.FramePropertyGetter;
Method m = null;
// We used to use "get_CanStartWriting" for non-virtual methods. But Rustan and I decided
// that it should be fine to use the transitive one for all methods. It is more liberal
// but still prevents re-entrance into a method in a frame that is exposed.
m = SystemTypes.Guard.GetMethod(Identifier.For("get_CanStartWritingTransitively"), null);
// default precondition is (as normalized IR):
// requires this.get_FrameGuard().get_CanStartWriting(); if it is a non-virtual method
// requires this.get_FrameGuard().get_CanStartWritingTransitively(); if it is a virtual method
if (frameGetter != null && m != null){
SourceContext sc = this.currentMethod.Name.SourceContext;
MethodCall getFrameGuard = new MethodCall(new MemberBinding(this.currentThisParameter, frameGetter), null, NodeType.MethodCall, SystemTypes.Guard, sc);
Requires r = new RequiresOtherwise(
new MethodCall(
new MemberBinding(getFrameGuard,m),
null,
NodeType.MethodCall,
SystemTypes.Boolean),
new Construct(new MemberBinding(null, SystemTypes.RequiresException.GetConstructor(SystemTypes.String)), new ExpressionList(new Literal("The target object of this call must be exposable.", SystemTypes.String)), SystemTypes.RequiresException)
);
r.SourceContext = sc;
newRequires.Add(r);
}
}
if ((this.currentMethod.IsPublic || this.currentMethod.IsFamilyOrAssembly) &&
!(this.currentCompilation != null && this.currentCompilation.CompilerParameters != null &&
((CompilerOptions)this.currentCompilation.CompilerParameters).DisableNullParameterValidation)){
ParameterList parameters = this.currentMethod.Parameters;
for (int i = 0, n = parameters == null ? 0 : parameters.Count; i < n; i++){
Parameter parameter = parameters[i];
if (parameter != null && !parameter.IsOut && this.typeSystem.IsNonNullType(parameter.Type)){
RequiresOtherwise r;
Reference rtype = parameter.Type as Reference;
if (rtype == null) {
TypeNode parameterType = TypeNode.StripModifier(parameter.Type, SystemTypes.NonNullType);
Expression e = null;
if (this.useGenerics && (parameterType is TypeParameter || parameterType is ClassParameter)) {
e = new BinaryExpression(parameter, new MemberBinding(null, parameterType), NodeType.Box, SystemTypes.Object, parameter.SourceContext);
} else {
e = new ParameterBinding(parameter, parameter.SourceContext);
}
r =
new RequiresOtherwise(
new BinaryExpression(e, new Literal(null, TypeNode.StripModifiers(parameter.Type)), NodeType.Ne, SystemTypes.Boolean, parameter.SourceContext),
new Construct(new MemberBinding(null, SystemTypes.ArgumentNullException.GetConstructor(SystemTypes.String)), new ExpressionList(new Literal(parameter.Name.Name, SystemTypes.String)), SystemTypes.ArgumentNullException));
}
else {
// have to perform deref
r =
new RequiresOtherwise(
new BinaryExpression(new AddressDereference(new ParameterBinding(parameter, parameter.SourceContext), rtype.ElementType), new Literal(null, TypeNode.StripModifiers(rtype.ElementType)), NodeType.Ne, SystemTypes.Boolean, parameter.SourceContext),
new Construct(new MemberBinding(null, SystemTypes.ArgumentNullException.GetConstructor(SystemTypes.String)), new ExpressionList(new Literal(parameter.Name.Name, SystemTypes.String)), SystemTypes.ArgumentNullException));
}
r.SourceContext = parameter.SourceContext;
newRequires.Add(r);
}
}
}
for (int i = 0, n = Requires == null ? 0 : Requires.Count; i < n; i++){
newRequires.Add(Requires[i]);
}
if (newRequires.Count == 0)
return Requires;
Block preConditionBlock = new Block(new StatementList());
preConditionBlock.HasLocals = true;
for (int i = 0, n = newRequires.Count; i < n; i++)
{
Requires r = newRequires[i];
if (r == null) continue;
if (r.Condition == null) continue;
// Code generation for preconditions needs to be such that the
// data flow analysis will "see" the consequences. If the value
// of the precondition is assigned to a local, then the information
// is lost.
//
// try {
// if re goto pre_i_holds;
// }
// catch { throw new ErrorDuringPreConditionEvaluation(...); }
// throw new PreConditionException(...);
// pre_i_holds: nop
bool noAllocationAllowed = this.currentMethod.GetAttribute(SystemTypes.BartokNoHeapAllocationAttribute) != null;
Local exceptionDuringPreCondition = new Local(Identifier.For("SS$exceptionDuringPreCondition" + i),SystemTypes.Exception);
Local exceptionDuringPreCondition3 = new Local(Identifier.For("SS$objectExceptionDuringPreCondition" + i),SystemTypes.Object);
Expression cond = r.Condition;
string condition = cond != null && cond.SourceContext.SourceText != null && cond.SourceContext.SourceText.Length > 0 ?
cond.SourceContext.SourceText : "<unknown condition>";
Expression ec2;
Expression ec3;
if (noAllocationAllowed) {
ec2 = ec3 = new MemberBinding(null, SystemTypes.PreAllocatedExceptions.GetField(Identifier.For("InvalidContract")));
}
else {
MemberBinding excBinding2 = new MemberBinding(null, SystemTypes.InvalidContractException.GetConstructor(SystemTypes.String, SystemTypes.Exception));
MemberBinding excBinding3 = new MemberBinding(null, SystemTypes.InvalidContractException.GetConstructor(SystemTypes.String));
string msg2 = "Exception occurred during evaluation of precondition '" + condition + "' in method '" + currentMethod.FullName + "'";
ec2 = new Construct(excBinding2, new ExpressionList(new Literal(msg2, SystemTypes.String), exceptionDuringPreCondition));
ec3 = new Construct(excBinding3, new ExpressionList(new Literal(msg2, SystemTypes.String)));
}
#region If the precondition fails, throw an exception
Expression throwExpression = null;
#region Create the expression to throw. Deal with different subtypes of Requires
if (noAllocationAllowed) {
throwExpression = new MemberBinding(null, SystemTypes.PreAllocatedExceptions.GetField(Identifier.For("Requires")));
}
else {
if (r is RequiresPlain) {
MemberBinding excBinding = new MemberBinding(null, SystemTypes.RequiresException.GetConstructor(SystemTypes.String));
Construct ec = new Construct(excBinding, new ExpressionList());
string msg = "Precondition '" + condition + "' violated from method '" + currentMethod.FullName + "'";
ec.Operands.Add(new Literal(msg, SystemTypes.String));
throwExpression = ec;
}
else if (r is RequiresOtherwise) {
RequiresOtherwise otherwise = (RequiresOtherwise)r;
if (otherwise.ThrowException is Literal) {
// it was "requires P otherwise E" where E is a type name of an exception class
Literal l = (Literal)otherwise.ThrowException;
Class exceptionClass = (Class)l.Value;
MemberBinding excBinding = new MemberBinding(null, this.GetTypeView(exceptionClass).GetConstructor());
// what to do if there is no nullary constructor? I guess that should have been checked in the context checker
Construct ec = new Construct(excBinding, new ExpressionList());
throwExpression = ec;
}
else {
// it was "requires P otherwise new E(...)" (or some other expression whose value is an exception)
throwExpression = this.VisitExpression(otherwise.ThrowException);
}
}
else {
Debug.Assert(false, "Expecting only RequiresOtherwise and RequiresPlain as subtypes of Requires");
}
}
#endregion
Throw t = new Throw(throwExpression,r.SourceContext);
#endregion
Block pre_i_holds = new Block();
//CatchList cl = new CatchList(2);
//cl.Add(new Catch(new Block(new StatementList(new Throw(ec2,r.Condition.SourceContext))),exceptionDuringPreCondition,SystemTypes.Exception));
//cl.Add(new Catch(new Block(new StatementList(new Throw(ec3,r.Condition.SourceContext))),exceptionDuringPreCondition3,SystemTypes.Object));
//Try tryPre = new Try(new Block(new StatementList(new If(r.Condition,new Block(new StatementList(new Branch(null,pre_i_holds))),null))),cl,null,null,null);
//preConditionBlock.Statements.Add(tryPre);
preConditionBlock.Statements.Add(new If(r.Condition,new Block(new StatementList(new Branch(null,pre_i_holds))),null));
preConditionBlock.Statements.Add(t);
preConditionBlock.Statements.Add(pre_i_holds);
}
preConditionBlock = this.VisitBlock(preConditionBlock);
this.currentContractPrelude.Statements.Add(preConditionBlock);
return Requires;
}
public SettingsViewModel(Library library, ViewSettings viewSettings, CoreSettings coreSettings, IWindowManager windowManager, Guid accessToken, MobileApiInfo mobileApiInfo)
{
if (library == null)
Throw.ArgumentNullException(() => library);
if (viewSettings == null)
Throw.ArgumentNullException(() => viewSettings);
if (coreSettings == null)
Throw.ArgumentNullException(() => coreSettings);
if (mobileApiInfo == null)
throw new ArgumentNullException("mobileApiInfo");
this.library = library;
this.viewSettings = viewSettings;
this.coreSettings = coreSettings;
this.windowManager = windowManager;
this.accessToken = accessToken;
this.canCreateAdmin = this
.WhenAnyValue(x => x.CreationPassword, x => !string.IsNullOrWhiteSpace(x) && !this.isAdminCreated)
.ToProperty(this, x => x.CanCreateAdmin);
this.CreateAdminCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.CanCreateAdmin),
ImmediateScheduler.Instance); // Immediate execution, because we set the password to an empty string afterwards
this.CreateAdminCommand.Subscribe(p =>
{
this.library.LocalAccessControl.SetLocalPassword(this.accessToken, this.CreationPassword);
this.isAdminCreated = true;
});
this.ChangeToPartyCommand = ReactiveCommand.Create(this.CreateAdminCommand.Select(x => true).StartWith(false));
this.ChangeToPartyCommand.Subscribe(p =>
{
this.library.LocalAccessControl.DowngradeLocalAccess(this.accessToken);
this.ShowSettings = false;
});
this.canLogin = this.WhenAnyValue(x => x.LoginPassword, x => !string.IsNullOrWhiteSpace(x))
.ToProperty(this, x => x.CanLogin);
this.LoginCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.CanLogin),
ImmediateScheduler.Instance); // Immediate execution, because we set the password to an empty string afterwards
this.LoginCommand.Subscribe(p =>
{
try
{
this.library.LocalAccessControl.UpgradeLocalAccess(this.accessToken, this.LoginPassword);
this.IsWrongPassword = false;
this.ShowLogin = false;
this.ShowSettings = true;
}
catch (WrongPasswordException)
{
this.IsWrongPassword = true;
}
});
this.OpenLinkCommand = ReactiveCommand.Create();
this.OpenLinkCommand.Cast<string>().Subscribe(x =>
{
try
{
Process.Start(x);
}
catch (Win32Exception ex)
{
this.Log().ErrorException(String.Format("Could not open link {0}", x), ex);
}
});
this.ReportBugCommand = ReactiveCommand.Create();
this.ReportBugCommand.Subscribe(p => this.windowManager.ShowWindow(new BugReportViewModel()));
this.ChangeAccentColorCommand = ReactiveCommand.Create();
this.ChangeAccentColorCommand.Subscribe(x => this.viewSettings.AccentColor = (string)x);
this.ChangeAppThemeCommand = ReactiveCommand.Create();
this.ChangeAppThemeCommand.Subscribe(x => this.viewSettings.AppTheme = (string)x);
this.UpdateLibraryCommand = ReactiveCommand.Create(this.library.WhenAnyValue(x => x.IsUpdating, x => !x)
.ObserveOn(RxApp.MainThreadScheduler)
.CombineLatest(this.library.WhenAnyValue(x => x.SongSourcePath).Select(x => !String.IsNullOrEmpty(x)), (x1, x2) => x1 && x2));
this.UpdateLibraryCommand.Subscribe(_ => this.library.UpdateNow());
this.librarySource = this.library.WhenAnyValue(x => x.SongSourcePath)
.ToProperty(this, x => x.LibrarySource);
this.port = this.coreSettings.Port;
this.ChangePortCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.Port, NetworkHelpers.IsPortValid));
this.ChangePortCommand.Subscribe(_ => this.coreSettings.Port = this.Port);
this.remoteControlPassword = this.coreSettings.RemoteControlPassword;
this.ChangeRemoteControlPasswordCommand = ReactiveCommand.Create(this.WhenAnyValue(x => x.RemoteControlPassword)
.Select(x => !String.IsNullOrWhiteSpace(x)));
this.ChangeRemoteControlPasswordCommand.Subscribe(x =>
this.library.RemoteAccessControl.SetRemotePassword(this.accessToken, this.RemoteControlPassword));
this.showRemoteControlPasswordError = this.WhenAnyValue(x => x.RemoteControlPassword, x => x.LockRemoteControl,
(password, lockRemoteControl) => String.IsNullOrWhiteSpace(password) && lockRemoteControl)
.ToProperty(this, x => x.ShowRemoteControlPasswordError);
this.isRemoteAccessReallyLocked = this.library.RemoteAccessControl.WhenAnyValue(x => x.IsRemoteAccessReallyLocked)
.ToProperty(this, x => x.IsRemoteAccessReallyLocked);
this.isPortOccupied = mobileApiInfo.IsPortOccupied.ToProperty(this, x => x.IsPortOccupied);
this.enableChangelog = this.viewSettings.WhenAnyValue(x => x.EnableChangelog)
.ToProperty(this, x => x.EnableChangelog);
this.defaultPlaybackEngine = this.coreSettings.WhenAnyValue(x => x.DefaultPlaybackEngine)
.ToProperty(this, x => x.DefaultPlaybackEngine);
}
public void Send(string argument)
{
Throw.IfNullOrWhiteSpace(argument, nameof(argument));
this.process.StandardInput.WriteLine(argument);
}
/// <summary>
/// Returns a unique key for the specified <paramref name="item"/>.
/// </summary>
/// <param name="item">The item in the collection a key is needed for.</param>
/// <returns>Returns the <see cref="VstMidiCategory.Name"/> property.</returns>
protected override string GetKeyForItem(VstMidiCategory item)
{
Throw.IfArgumentIsNull(item, nameof(item));
return(item.Name);
}
void ThrowDice(Throw dieThrow, Vector3 startPosition, Vector3 endPosition)
{
if(null == dieThrow)
if(null == lastThrow) return;
else dieThrow = lastThrow;
else lastThrow = dieThrow;
foreach(string dieType in dieThrow.dice)
{
GameObject die = CreateDie(dieType);
// rigidbody.angularVelocity = Random.insideUnitSphere * randomSpin;
// rigidbody.velocity = Random.insideUnitSphere * randomVelocity;
transform.rotation = Quaternion.LookRotation(Random.onUnitSphere);
die.transform.position = startPosition;
die.transform.LookAt(endPosition);
die.rigidbody.velocity = Camera.main.transform.forward * -10 + Camera.main.transform.right * 5;
die.rigidbody.angularVelocity = Vector3.right * 10;
startPosition = startPosition + new Vector3(die.transform.localScale.x + 1, 0, 0);
//Camera.main.GetComponent<CamControl>().LookAtDice(die.transform);
}
}
public static IServiceCollection AddWebAuthentication(this IServiceCollection services, ResultsAndCertificationConfiguration config, ILogger logger, IWebHostEnvironment env)
{
double cookieAndSessionTimeout = 5;
var overallSessionTimeout = TimeSpan.FromMinutes(cookieAndSessionTimeout);
var cookieSecurePolicy = env.IsDevelopment() ? CookieSecurePolicy.SameAsRequest : CookieSecurePolicy.Always;
services.AddAntiforgery(options =>
{
options.Cookie.SecurePolicy = cookieSecurePolicy;
});
services.AddAuthentication(options =>
{
options.DefaultSignInScheme = CookieAuthenticationDefaults.AuthenticationScheme;
options.DefaultAuthenticateScheme = CookieAuthenticationDefaults.AuthenticationScheme;
options.DefaultChallengeScheme = OpenIdConnectDefaults.AuthenticationScheme;
})
.AddCookie(options =>
{
options.Cookie.Name = "tl-rc-auth-cookie";
options.Cookie.SecurePolicy = CookieSecurePolicy.Always;
options.SlidingExpiration = true;
options.ExpireTimeSpan = TimeSpan.FromMinutes(cookieAndSessionTimeout);
options.LogoutPath = config.DfeSignInSettings.LogoutPath;
options.AccessDeniedPath = "/home/accessdenied";
//options.EventsType = typeof(CustomCookieAuthenticationEvents);
})
.AddOpenIdConnect(options =>
{
options.SignInScheme = CookieAuthenticationDefaults.AuthenticationScheme;
options.MetadataAddress = config.DfeSignInSettings.MetadataAddress;
options.RequireHttpsMetadata = false;
options.ClientId = config.DfeSignInSettings.ClientId;
options.ClientSecret = config.DfeSignInSettings.ClientSecret;
options.ResponseType = OpenIdConnectResponseType.Code;
options.GetClaimsFromUserInfoEndpoint = true;
options.Scope.Clear();
options.Scope.Add("openid");
options.Scope.Add("email");
options.Scope.Add("profile");
options.Scope.Add("organisation");
//options.Scope.Add("offline_access");
// Prompt=consent is required to be issued with a refresh token
//options.Prompt = "consent";
// When we expire the session, ensure user is prompted to sign in again at DfE Sign In
options.MaxAge = overallSessionTimeout;
options.SaveTokens = true;
options.CallbackPath = new PathString(config.DfeSignInSettings.CallbackPath);
options.SignedOutCallbackPath = new PathString(config.DfeSignInSettings.SignedOutCallbackPath);
options.SignedOutRedirectUri = "/signin/signoutcomplete";
options.SecurityTokenValidator = new JwtSecurityTokenHandler
{
InboundClaimTypeMap = new Dictionary <string, string>(),
TokenLifetimeInMinutes = int.Parse(cookieAndSessionTimeout.ToString()),
SetDefaultTimesOnTokenCreation = true,
};
options.ProtocolValidator = new OpenIdConnectProtocolValidator
{
RequireSub = true,
RequireStateValidation = false,
NonceLifetime = TimeSpan.FromMinutes(cookieAndSessionTimeout)
};
options.DisableTelemetry = true;
options.Events = new OpenIdConnectEvents
{
// Sometimes, problems in the OIDC provider (such as session timeouts)
// Redirect the user to the /auth/cb endpoint. ASP.NET Core middleware interprets this by default
// as a successful authentication and throws in surprise when it doesn't find an authorization code.
// This override ensures that these cases redirect to the root.
OnMessageReceived = context =>
{
var isSpuriousAuthCbRequest =
context.Request.Path == options.CallbackPath &&
context.Request.Method == "GET" &&
!context.Request.Query.ContainsKey("code");
if (isSpuriousAuthCbRequest)
{
logger.LogWarning("Spurious log in attempt received for DFE sign in");
context.HandleResponse();
context.Response.StatusCode = 302;
context.Response.Headers["Location"] = "/";
}
return(Task.CompletedTask);
},
// Sometimes the auth flow fails. The most commonly observed causes for this are
// Cookie correlation failures, caused by obscure load balancing stuff.
// In these cases, rather than send user to a 500 page, prompt them to re-authenticate.
// This is derived from the recommended approach: https://github.com/aspnet/Security/issues/1165
OnRemoteFailure = ctx =>
{
logger.LogWarning("Remote failure for DFE-sign in");
ctx.HandleResponse();
return(Task.FromException(ctx.Failure));
},
OnRedirectToIdentityProvider = context =>
{
return(Task.CompletedTask);
},
// that event is called after the OIDC middleware received the authorisation code,
// redeemed it for an access token and a refresh token,
// and validated the identity token
OnTokenValidated = async x =>
{
//logger.LogMethodEnter();
logger.LogWarning("User has been authorised by DFE");
var cliendId = config.DfeSignInSettings.ClientId;
var issuer = config.DfeSignInSettings.Issuer;
var audience = config.DfeSignInSettings.Audience;
var apiSecret = config.DfeSignInSettings.APISecret;
var apiUri = config.DfeSignInSettings.APIUri;
Throw.IfNull(issuer, nameof(issuer));
Throw.IfNull(audience, nameof(audience));
Throw.IfNull(apiSecret, nameof(apiSecret));
Throw.IfNull(apiUri, nameof(apiUri));
var token = new JwtBuilder()
.WithAlgorithm(new HMACSHA256Algorithm())
.Issuer(issuer)
.Audience(audience)
.WithSecret(apiSecret)
.Encode();
//Gather user/org details
var identity = (ClaimsIdentity)x.Principal.Identity;
Organisation organisation;
try
{
organisation = JsonConvert.DeserializeObject <Organisation>(
identity.Claims.Where(c => c.Type == "organisation")
.Select(c => c.Value).FirstOrDefault());
}
catch
{
throw new SystemException("Unable to get organisation details from DFE. Please clear session cookies, or try using private browsing mode.");
}
var userClaims = new DfeClaims()
{
UserId = Guid.Parse(identity.Claims.Where(c => c.Type == "sub").Select(c => c.Value).SingleOrDefault()),
ServiceId = Guid.Parse(identity.Claims.Where(c => c.Type == "sid").Select(c => c.Value).SingleOrDefault()),
};
var client = new HttpClient();
client.SetBearerToken(token);
var response = await client.GetAsync($"{apiUri}/services/{cliendId}/organisations/{organisation.Id}/users/{userClaims.UserId}");
if (response.IsSuccessStatusCode)
{
var json = response.Content.ReadAsStringAsync().Result;
userClaims = JsonConvert.DeserializeObject <DfeClaims>(json);
userClaims.RoleName = userClaims.Roles.Select(r => r.Name).FirstOrDefault();
userClaims.UKPRN = organisation.UKPRN.HasValue ? organisation.UKPRN.Value.ToString() : string.Empty;
userClaims.UserName = identity.Claims.Where(c => c.Type == "email").Select(c => c.Value).SingleOrDefault();
}
else
{
//throw new SystemException("Could not get Role Type for User");
}
logger.LogError("User " + userClaims.UserName + " has been authenticated by DFE");
List <Claim> roleClaims = new List <Claim>();
if (userClaims.Roles != null && userClaims.Roles.Any())
{
foreach (var role in userClaims.Roles)
{
roleClaims.Add(new Claim(ClaimTypes.Role, role.Name));
}
if (roleClaims.Count > 0)
{
identity.AddClaims(roleClaims);
}
}
// store both access and refresh token in the claims - hence in the cookie
identity.AddClaims(new[]
{
//new Claim("access_token", x.TokenEndpointResponse.AccessToken),
//new Claim("refresh_token", x.TokenEndpointResponse.RefreshToken),
new Claim("UKPRN", userClaims.UKPRN),
new Claim("user_id", userClaims.UserId.ToString()),
new Claim("OrganisationId", organisation.Id.ToString().ToUpper())
});
// so that we don't issue a session cookie but one with a fixed expiration
x.Properties.IsPersistent = true;
x.Properties.ExpiresUtc = DateTime.UtcNow.Add(overallSessionTimeout);
}
};
});
return(services);
}
protected internal override Node TransformThrow(Throw @throw)
{
return Dispatch(@throw);
}
/// <summary>
/// Initializes a new instance of the <see cref="T:Geocrest.Web.Mvc.Syndication.PublicationCategory" /> class.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="label">The label.</param>
public PublicationCategory(string name, string label = null)
{
Throw.IfArgumentNullOrEmpty(name, "name");
Name = name;
Label = label;
}
public virtual Statement VisitThrow(Throw Throw1, Throw Throw2)
{
if (Throw1 == null) return null;
if (Throw2 == null)
Throw1.Expression = this.VisitExpression(Throw1.Expression, null);
else
Throw1.Expression = this.VisitExpression(Throw1.Expression, Throw2.Expression);
return Throw1;
}
private void Awake()
{
sortZ = GetComponent <SortZ>();
spr = GetComponent <SpriteRenderer>();
throwAction = GetComponent <Throw>();
}
private static string ThrowToString(Throw thrw) {
return
(thrw.Expression != null) ? ("throw " + expression2str(thrw.Expression)) : "rethrow";
}
public UserDataKeepAliveTimerProvider(IServiceProvider services)
{
Throw.IfNull(services, nameof(services));
_services = services;
}
public object Any(Throw request)
{
if (request.StatusCode.HasValue)
{
throw new HttpError(
request.StatusCode.Value,
typeof(NotImplementedException).Name,
request.Message);
}
throw new NotImplementedException(request.Message + " is not implemented");
}
public KeyEqualityComparer(Func <T, object> keyExtractor)
{
Throw.IfArgumentNull(keyExtractor, nameof(keyExtractor));
_keyExtractor = keyExtractor;
}
protected internal override void TraverseThrow(Throw @throw)
{
Dispatch(@throw);
}
protected internal override Statement VisitThrow(Throw inst)
{
return(new ThrowStatement(exprBuilder.Translate(inst.Argument)));
}
public override Statement VisitThrow(Throw Throw) {
if (Throw == null) return null;
TypeNode thrownType = null;
if (Throw.Expression == null) {
if (!this.insideCatchClause) {
this.HandleError(Throw, Error.BadEmptyThrow);
return null;
}
Throw.NodeType = NodeType.Rethrow;
thrownType = this.currentCatchClause.Type != null ? this.currentCatchClause.Type : SystemTypes.Object;
} else {
Expression e = Throw.Expression = this.VisitExpression(Throw.Expression);
if (e == null || e.Type == null) return null;
thrownType = e.Type;
if (thrownType != null)
thrownType = this.typeSystem.Unwrap(thrownType);
if (!this.GetTypeView(thrownType).IsAssignableTo(SystemTypes.Exception)) {
this.HandleError(e, Error.BadExceptionType);
return null;
}
e = Throw.Expression = this.typeSystem.ImplicitCoercion(e, thrownType, this.TypeViewer);
}
#region Dealing with checked/unchecked exceptions
if (this.GetTypeView(thrownType).IsAssignableTo(SystemTypes.ICheckedException)) {
int i = 0;
int n = this.allowedExceptions.Count;
while (i < n) {
TypeNode t = this.allowedExceptions[i];
if (this.GetTypeView(thrownType).IsAssignableTo(t))
break;
i++;
}
if (i == n) // no allowed exception covers this one
this.HandleError(Throw, Error.CheckedExceptionNotInThrowsClause, this.GetTypeName(thrownType), this.GetMethodSignature(this.currentMethod));
} else if (
(this.currentPreprocessorDefinedSymbols == null || !this.currentPreprocessorDefinedSymbols.ContainsKey("compatibility"))
&&
!this.currentOptions.DisableDefensiveChecks
) {
// if we can't be sure the thrown exception's *dynamic* type is an unchecked exception, then need to
// insert a runtime check. Just because its static type is not a subtype of ICheckedException
// doesn't mean its runtime type isn't, since CheckedException is a subtype of Exception.
//
// BUT: do this only if compiler options say to! This is to preserve C# backwards compatibility.
if (Throw.Expression == null) {
// if Throw.Expression == null ==> this was "throw;" in a catch block, definitely need the check
// need to know if there is a variable because it could have been "catch {}" or "catch (Exception){}"
Block b = new Block(new StatementList(2));
b.HasLocals = true;
// now the really bad case: need to transform "catch" or "catch (Exception){}" into "catch (Exception e)"
if (this.currentCatchClause.Type == null)
this.currentCatchClause.Type = SystemTypes.Exception;
if (this.currentCatchClause.Variable == null) {
Local e = new Local(Identifier.For("SS$exception local"), this.currentCatchClause.Type, b);
this.currentCatchClause.Variable = e;
}
b.Statements.Add(new Assertion(
new UnaryExpression(
new BinaryExpression(this.currentCatchClause.Variable, new MemberBinding(null, SystemTypes.ICheckedException), NodeType.Is, SystemTypes.Boolean),
NodeType.LogicalNot)));
b.Statements.Add(Throw);
return b;
} else if (Throw.Expression.NodeType != NodeType.Construct) {
// if it is "throw new T" where T is not a checked exception, then we don't need the assert
Block b = new Block(new StatementList(3));
b.HasLocals = true;
// Exception e = Throw.Expression;
// Assert(!(e is ICheckedException) );
// throw e;
Local e = new Local(Identifier.For("SS$exception local"), SystemTypes.Exception, b);
b.Statements.Add(new AssignmentStatement(e, Throw.Expression));
b.Statements.Add(new Assertion(
new UnaryExpression(
new BinaryExpression(e, new MemberBinding(null, SystemTypes.ICheckedException), NodeType.Is, SystemTypes.Boolean),
NodeType.LogicalNot)));
Throw.Expression = e;
b.Statements.Add(Throw);
return b;
}
}
#endregion Dealing with checked/unchecked exceptions
return Throw;
}
public override void EndVisit(Throw node)
{
currentStatement = null;
}
void case_980()
#line 6523 "cs-parser.jay"
{
Error_SyntaxError (yyToken);
yyVal = new Throw ((Expression) yyVals[-1+yyTop], GetLocation (yyVals[-2+yyTop]));
}
public override bool Visit(Throw node)
{
currentStatement = node;
return(true);
}
protected internal virtual void TraverseThrow(Throw @throw) { @throw.Unsupported(); }
/// <summary>
/// Performs lossless compression on the specified file. If the new file size is not smaller
/// the file won't be overwritten.
/// </summary>
/// <param name="file">The gif file to compress.</param>
/// <returns>True when the image could be compressed otherwise false.</returns>
public bool LosslessCompress(FileInfo file)
{
Throw.IfNull(nameof(file), file);
return(DoLosslessCompress(file));
}
public override Statement VisitThrow(Throw thrw)
{
base.VisitThrow(thrw);
// when a throw occurs, the entire evaluation stack is flushed out.
depth = 0;
return thrw;
}
/// <summary>
/// Initializes a new instance of the <see cref="DrawableFillColor"/> class.
/// </summary>
/// <param name="color">The color to use.</param>
public DrawableFillColor(MagickColor color)
{
Throw.IfNull(nameof(color), color);
Color = color;
}
public virtual Differences VisitThrow(Throw throw1, Throw throw2){
Differences differences = new Differences(throw1, throw2);
if (throw1 == null || throw2 == null){
if (throw1 != throw2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++;
return differences;
}
Throw changes = (Throw)throw2.Clone();
Throw deletions = (Throw)throw2.Clone();
Throw insertions = (Throw)throw2.Clone();
Differences diff = this.VisitExpression(throw1.Expression, throw2.Expression);
if (diff == null){Debug.Assert(false); return differences;}
changes.Expression = diff.Changes as Expression;
deletions.Expression = diff.Deletions as Expression;
insertions.Expression = diff.Insertions as Expression;
Debug.Assert(diff.Changes == changes.Expression && diff.Deletions == deletions.Expression && diff.Insertions == insertions.Expression);
differences.NumberOfDifferences += diff.NumberOfDifferences;
differences.NumberOfSimilarities += diff.NumberOfSimilarities;
if (differences.NumberOfDifferences == 0){
differences.Changes = null;
differences.Deletions = null;
differences.Insertions = null;
}else{
differences.Changes = changes;
differences.Deletions = deletions;
differences.Insertions = insertions;
}
return differences;
}
public Block MarkAsInstrumentationCodeNormalized(Method method, Block normalizedCode) {
Throw t = new Throw();
t.NodeType = NodeType.Rethrow;
return CreateTryCatchBlock(
method,
normalizedCode, // try body
new Block(new StatementList(t)), // catch: just rethrow
new Local(Identifier.For("SS$Contract Marker"), SystemTypes.ContractMarkerException)
);
}
public virtual Statement VisitThrow(Throw Throw, Throw changes, Throw deletions, Throw insertions){
this.UpdateSourceContext(Throw, changes);
if (Throw == null) return changes;
if (changes != null){
if (deletions == null || insertions == null)
Debug.Assert(false);
else{
}
}else if (deletions != null)
return null;
return Throw;
}
/// <summary>
/// Get the deposit history.
/// </summary>
/// <param name="client"></param>
/// <param name="user"></param>
/// <param name="asset"></param>
/// <param name="status"></param>
/// <param name="startTime"></param>
/// <param name="endTime"></param>
/// <param name="recvWindow"></param>
/// <param name="token"></param>
/// <returns></returns>
public static async Task <string> GetDepositsAsync(this IBinanceHttpClient client, IBinanceApiUser user, string asset = null, DepositStatus?status = null, DateTime startTime = default, DateTime endTime = default, long recvWindow = default, CancellationToken token = default)
{
Throw.IfNull(client, nameof(client));
Throw.IfNull(user, nameof(user));
if (recvWindow == default)
{
recvWindow = client.DefaultRecvWindow;
}
if (client.RateLimiter != null)
{
await client.RateLimiter.DelayAsync(token : token)
.ConfigureAwait(false);
}
var request = new BinanceHttpRequest("/wapi/v3/depositHistory.html")
{
ApiKey = user.ApiKey
};
if (!string.IsNullOrWhiteSpace(asset))
{
request.AddParameter("asset", asset.FormatSymbol());
}
if (status.HasValue)
{
request.AddParameter("status", (int)status);
}
if (startTime != default)
{
if (startTime.Kind != DateTimeKind.Utc)
{
throw new ArgumentException("Date/Time must be UTC.", nameof(startTime));
}
request.AddParameter("startTime", startTime.ToTimestamp());
}
if (endTime != default)
{
if (endTime.Kind != DateTimeKind.Utc)
{
throw new ArgumentException("Date/Time must be UTC.", nameof(endTime));
}
request.AddParameter("endTime", endTime.ToTimestamp());
}
if (recvWindow > 0)
{
request.AddParameter("recvWindow", recvWindow);
}
await client.SignAsync(request, user, token)
.ConfigureAwait(false);
return(await client.GetAsync(request, token)
.ConfigureAwait(false));
}
