public ItemVersion(ItemVersions container, CrawlType crawlType, DateTime asOfDate) { this.LocationType = container.LocationType; this.Name = container.Name; this.CrawlType = crawlType; this.AsOfDate = asOfDate; }
/// <summary> /// Returns result type of binary expression. This may be the error type. /// </summary> public static CrawlType EvaluateBinaryType(CrawlType operand1, ExpressionType oprator, CrawlType operand2) { //Valid binary expressions are stored in BinaryExpressionDict. //To avoid redundancy, {tal > kommatal => bool} is saved, //but {kommatal > tal => bool} is not. //Instead we check if either of the two possible combinations //of two operators are stored in the dictionary. var firstPossibleMatch = new Tuple <CrawlType, CrawlType, ExpressionType>(operand1, operand2, oprator); if (BinaryExpressionDict.ContainsKey(firstPossibleMatch)) { return(BinaryExpressionDict[firstPossibleMatch]); } var secondPossibleMatch = new Tuple <CrawlType, CrawlType, ExpressionType>(operand2, operand1, oprator); if (BinaryExpressionDict.ContainsKey(secondPossibleMatch)) { return(BinaryExpressionDict[secondPossibleMatch]); } else { return(CrawlType.ErrorType); } }
public ItemVersion(LocationType locationType, string tableName, CrawlType crawlType, DateTime asOfDate) { this.LocationType = locationType; this.Name = tableName; this.CrawlType = crawlType; this.AsOfDate = asOfDate; }
protected override CrawlSyntaxNode VisitSingleVariableDecleration(SingleVariableDeclerationNode singleVariableDecleration) { var node = (SingleVariableDeclerationNode)base.VisitSingleVariableDecleration(singleVariableDecleration); CrawlType resultType = node.DefaultValue?.ResultType ?? node.Identifier.ResultType; VariableNode newIdentifier = (VariableNode)node.Identifier.WithResultType(resultType); return(node.WithIdentifier(newIdentifier)); }
public TypeInformation(CrawlType type, ProtectionLevel protectionLevel, int declarationLocation, DeclaringScope declaringScope = DeclaringScope.MethodLike, NeedsABetterNameType needsABetterNameType = NeedsABetterNameType.Variable) { Type = type; ProtectionLevel = protectionLevel; DeclarationLocation = declarationLocation; DeclaringScope = declaringScope; NeedsABetterNameType = needsABetterNameType; }
public static CrawlType UnaryNot(CrawlType operand) { if (operand.Equals(CrawlSimpleType.Bool)) { return(CrawlSimpleType.Bool); } return(CrawlType.ErrorType); }
public static CrawlType UnaryNegate(CrawlType operand) { //If operand is tal, return tal; if operand is kommatal, return kommatal if (operand.Equals(CrawlSimpleType.Tal) || operand.Equals(CrawlSimpleType.Kommatal)) { return(operand); } return(CrawlType.ErrorType); }
protected override CrawlSyntaxNode VisitVariable(VariableNode variable) { var expr = (VariableNode)base.VisitVariable(variable); CrawlType resultType = expr.FindFirstScope().FindSymbol(variable.Name)?.FirstOrDefault()?.Type; var result = expr.WithResultType(resultType ?? CrawlType.ErrorType); return(result); }
protected override CrawlSyntaxNode VisitCall(CallNode call) { CallNode expr = (CallNode)base.VisitCall(call); CrawlType resultType = CrawlType.ErrorType; List <CrawlType> actualParameters = expr.Arguments.Select(x => x.Value.ResultType).ToList(); //Three posibilities exist: //Method type is provided as method name in specific scope. MemberAccessNode asMem = expr.Target as MemberAccessNode; //Method type is provided as a method name. Find candidates and choose best fit. VariableNode asVar = expr.Target as VariableNode; if (expr.Target.ResultType is CrawlStatusType) { return(expr.WithResultType(expr.Target.ResultType)); } else if (asVar != null) { var foo = asVar .FindFirstScope(); var bar = foo .FindSymbol(asVar.Name); List <CrawlMethodType> candidates = bar .SelectMany(GetMethodTypesFromTypeInformation) .ToList(); resultType = BestParameterMatch(candidates, actualParameters); } else if (asMem != null) { List <CrawlMethodType> candidates = asMem .Target.ResultType .FindSymbol(asMem.Member.Value) .SelectMany(GetMethodTypesFromTypeInformation) .ToList(); resultType = BestParameterMatch(candidates, actualParameters); } //Method type is provided by some other expression. In this case it either matches or does not. else { CrawlMethodType methodSignature = expr.Target.ResultType as CrawlMethodType; if (methodSignature != null) { resultType = Call(methodSignature, actualParameters); } } return(expr.WithResultType(resultType)); }
public IEnumerable <ItemVersion> VersionsInRange(CrawlType crawlType, DateTime startDateTime, DateTime asOfDateTime, bool startInclusive = false) { if (startInclusive) { return(this.Versions.Where((v) => (v.CrawlType == crawlType && v.AsOfDate >= startDateTime && v.AsOfDate <= asOfDateTime))); } else { return(this.Versions.Where((v) => (v.CrawlType == crawlType && v.AsOfDate > startDateTime && v.AsOfDate <= asOfDateTime))); } }
protected override CrawlSyntaxNode VisitBinaryExpression(BinaryExpressionNode binaryExpression) { BinaryExpressionNode newExpressoinNode = (BinaryExpressionNode)(base.VisitBinaryExpression(binaryExpression)); CrawlType leftOperand = newExpressoinNode.LeftHandSide.ResultType; CrawlType rightOperand = newExpressoinNode.RightHandSide.ResultType; ExpressionType oprator = newExpressoinNode.ExpressionType; CrawlType expressionTypeResult = EvaluateBinaryType(leftOperand, oprator, rightOperand); CrawlSyntaxNode result = newExpressoinNode.WithResultType(expressionTypeResult); return(result); }
private static CrawlType ParseCrawlTypeOrDefault(string[] args, int index, CrawlType defaultValue) { if (args.Length <= index) { return(defaultValue); } CrawlType type; if (!Enum.TryParse <CrawlType>(args[index], out type)) { throw new UsageException($"Unknown SourceType '{args[index]}'; valid types: {String.Join(", ", Enum.GetValues(typeof(CrawlType)))}."); } return(type); }
protected override CrawlSyntaxNode VisitType(TypeNode type) { IScope scope = type.FindFirstScope(); try { CrawlType actualType = CrawlType.ParseDecleration(scope, type.TypeName); var v = type.WithActualType(actualType); return(v); } catch (TypeNotFoundException tnfe) { _messages.Add(CompilationMessage.Create(_tokens, type.Interval, MessageCode.TypeNotFound, _file)); return(type); } }
protected override CrawlSyntaxNode VisitMemberAccess(MemberAccessNode memberAccess) { var expr = (MemberAccessNode)base.VisitMemberAccess(memberAccess); if (expr.Target.ResultType is CrawlStatusType) { return(expr.WithResultType(expr.Target.ResultType)); } var results = expr.Target.ResultType.FindSymbol(expr.Member.Value); if (results == null || results.Length == 0) { return(expr.WithResultType(CrawlType.ErrorType)); } CrawlType resultType = expr.Target.ResultType.FindSymbol(expr.Member.Value)[0].Type; return(expr.WithResultType(resultType)); }
private void AddVersions(ItemVersions versions, CrawlType crawlType) { string sourceFullPath = this.Path(versions.LocationType, versions.Name, crawlType); foreach (StreamAttributes version in Enumerate(sourceFullPath, EnumerateTypes.Folder, false)) { DateTime versionAsOf; // If it's not a DateTime folder, it's not a table version if (!DateTime.TryParseExact(System.IO.Path.GetFileName(version.Path), StreamProviderExtensions.DateTimeFolderFormat, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal, out versionAsOf)) { continue; } // If we're looking at tables, verify there's a Schema.csv if (versions.LocationType == LocationType.Table && !Attributes(Path.Combine(version.Path, "Schema.csv")).Exists) { continue; } versions.AddVersion(crawlType, versionAsOf); } }
public IEnumerable <ItemVersion> VersionsInRange(CrawlType crawlType, DateTime startDateTime, DateTime asOfDateTime) { return(this.Versions.Where((v) => (v.CrawlType == crawlType && v.AsOfDate > startDateTime && v.AsOfDate <= asOfDateTime))); }
public ItemVersion LatestBeforeCutoff(CrawlType crawlType, DateTime cutoff) { return(this.Versions.LastOrDefault((v) => (v.CrawlType == crawlType && v.AsOfDate <= cutoff))); }
public void AddVersion(CrawlType crawlType, DateTime asOfDate) { this.Versions.Add(new ItemVersion(this, crawlType, asOfDate)); }
public override int GetHashCode() { return(LocationType.GetHashCode() ^ Name.GetHashCode() ^ CrawlType.GetHashCode() ^ AsOfDate.GetHashCode()); }
public static void Add(this IStreamProvider streamProvider, string sourceFileOrFolderPath, string tableName, CrawlType crawlType, DateTime asOfDateTime = default(DateTime)) { // If the 'asOfDateTime' wasn't passed, use the File Write Time if (asOfDateTime == default(DateTime)) { asOfDateTime = File.GetLastWriteTimeUtc(sourceFileOrFolderPath); } string desiredFolderPath = streamProvider.Path(LocationType.Source, tableName, crawlType, asOfDateTime); if (Directory.Exists(sourceFileOrFolderPath)) { foreach (string filePath in Directory.GetFiles(sourceFileOrFolderPath, "*.*", SearchOption.AllDirectories)) { streamProvider.Copy(File.OpenRead(filePath), System.IO.Path.Combine(desiredFolderPath, System.IO.Path.GetFileName(filePath))); } } else { streamProvider.Copy(File.OpenRead(sourceFileOrFolderPath), System.IO.Path.Combine(desiredFolderPath, System.IO.Path.GetFileName(sourceFileOrFolderPath))); } }
public static string Path(this IStreamProvider streamProvider, LocationType type, string tableName, CrawlType crawlType, DateTime version) { return(System.IO.Path.Combine(type.ToString(), tableName, crawlType.ToString(), version.ToUniversalTime().ToString(DateTimeFolderFormat))); }
public static string Path(this IStreamProvider streamProvider, LocationType type, string tableName, CrawlType crawlType) { return(System.IO.Path.Combine(type.ToString(), tableName, crawlType.ToString())); }