public static ICollection <IReference> Decompose(this IClass scope, IReference reference) { var layering = Layering <IClass> .CreateLayers(scope, cl => cl.BaseTypes); var references = new HashSet <IReference>(); references.Add(reference); foreach (var layer in layering) { if (layer.Count > 1) { throw new InvalidOperationException("There is a cycle in the inheritance hierarchy."); } foreach (var cl in layer) { foreach (var r in cl.References) { if (r.Refines != null && references.Contains(r.Refines)) { references.Add(r); } } } } return(references); }
private string QueryResult() { return(string.Join('|', (from comment in SocialNetwork.Descendants().OfType <Comment>() let layering = Layering <IUser> .CreateLayers(comment.LikedBy, u => u.Friends.Where(f => f.Likes.Contains(comment))) orderby layering.Sum(l => Square(l.Count)) select comment.Id).Take(3))); }
private string QueryResult() { return(string.Join('|', (from comment in SocialNetwork.Descendants().OfType <Comment>() let layering = Layering <IUser> .CreateLayers(comment.LikedBy, u => u.Friends.Intersect(comment.LikedBy)) let score = layering.Sum(l => Square(l.Count)) orderby(score, comment.Timestamp) descending select comment.Id).Take(3))); }
public IEnumerator <IEnumerable <T> > GetEnumerator() { if (components == null) { components = Layering <T> .CreateLayers(nodes, edges); } return(components.GetEnumerator()); }
protected override void UpdateLayering() { base.UpdateLayering(); sortingGroup.sortingLayerID = Layering.StoryToSortingLayerID(storyLocation); sortingGroup.sortingOrder = Constants.ENTITY_SORTING_ORDER; visibleLight.m_ApplyToSortingLayers = new int[] { Layering.StoryToSortingLayerID(storyLocation) }; interactionRadius.gameObject.layer = (int)Layering.StoryToPhysicsLayer(storyLocation); }
protected virtual void UpdateLayering() { gameObject.layer = (int)Layering.StoryToPhysicsLayer(storyLocation); if (spriteRenderer) { spriteRenderer.sortingLayerID = Layering.StoryToSortingLayerID(storyLocation); spriteRenderer.sortingOrder = Constants.ENTITY_SORTING_ORDER; } }
protected virtual void ResolveMultipleInheritanceMembers(CodeTypeDeclaration generatedType, HashSet <CodeTypeMember> shadows, CodeConstructor constructor) { Func <CodeTypeDeclaration, IEnumerable <CodeTypeDeclaration> > getBaseTypes = type => { var interfaceType = CodeDomHelper.GetOrCreateUserItem <CodeTypeDeclaration>(type, CodeDomHelper.InterfaceKey); if (interfaceType == null) { interfaceType = type; } return(interfaceType.BaseTypes.Cast <CodeTypeReference>().Select(r => r.GetTypeForReference()).Where(c => c != null)); }; var layering = Layering <CodeTypeDeclaration> .CreateLayers(generatedType, getBaseTypes); CodeTypeDeclaration implBaseType = FindBaseClassAndCreateShadows(generatedType, shadows, layering); IEnumerable <CodeTypeDeclaration> inheritedBaseClasses; if (implBaseType != null) { inheritedBaseClasses = implBaseType.Closure(getBaseTypes); var implementationRef = new CodeTypeReference(); implementationRef.BaseType = implBaseType.Name; var n = implBaseType.GetReferenceForType().Namespace(); if (n != null && n.EndsWith(implBaseType.Name)) { implementationRef.BaseType = n + "." + implBaseType.Name; } else { implementationRef.SetNamespace(n); } generatedType.BaseTypes.Insert(0, implementationRef); } else { inheritedBaseClasses = Enumerable.Empty <CodeTypeDeclaration>(); AddImplementationBaseClass(generatedType); } for (int i = layering.Count - 1; i >= 0; i--) { foreach (var baseType in layering[i]) { if (!inheritedBaseClasses.Contains(baseType) && baseType != generatedType && ShouldContainMembers(generatedType, baseType.GetReferenceForType())) { var dependent = baseType.DependentMembers(false); if (dependent != null) { foreach (var inheritedMember in dependent) { RecursivelyAddDependentMembers(generatedType.Members, constructor.Statements, inheritedMember, shadows); } } } } } }
private void Recompute() { components.Clear(); var layers = Layering <T> .CreateLayers(nodes, GetEdges); foreach (var layer in layers) { foreach (var item in layer) { components.Add(item, layer); } } OnCleared(); }
public void LayeringTest() { #region States var active = new State <SmartPhoneScreenContext>(screen => { }).Named("Active"); var exit = new State <SmartPhoneScreenContext>(screen => { }).Named("Exit"); var paused = new State <SmartPhoneScreenContext>(screen => { }).Named("Paused"); var inactive = new State <SmartPhoneScreenContext>(screen => { }).Named("Inactive"); #endregion #region Transitions active.AddTransition(Transition <SmartPhoneScreenContext> .To(() => paused) .When(screen => screen.Command == PauseCommand) .Named("Pausing")); active.AddTransition(Transition <SmartPhoneScreenContext> .To(() => inactive) .When(screen => screen.Command == EndCommand) .Named("Going inactive")); inactive.AddTransition(Transition <SmartPhoneScreenContext> .To(() => active) .When(screen => screen.Command == BeginCommand) .Named("Activating")); inactive.AddTransition(Transition <SmartPhoneScreenContext> .To(() => exit) .When(screen => screen.Command == ExitCommand) .Named("Exiting")); paused.AddTransition(Transition <SmartPhoneScreenContext> .To(() => inactive) .When(screen => screen.Command == EndCommand) .Named("Going inactive")); paused.AddTransition(Transition <SmartPhoneScreenContext> .To(() => active) .When(screen => screen.Command == ResumeCommand) .Named("Activating")); #endregion var layering = new Layering <SmartPhoneScreenContext>(active); }
private void Part3Button_Click(object sender, RoutedEventArgs e) { if (!_part3Complete) { _rawLayers = Layering.Convert(_colorGroups, _loadedImage.Width, _loadedImage.Height, ImageTracer.Palette); _part3Complete = true; _filteredRawLayers = _rawLayers.Where(cl => cl.Value.Nodes.Any(r => r.Any(n => n.IsLight()))) .ToDictionary(cl => cl.Key, cl => cl.Value); //http://www.wpf-tutorial.com/list-controls/combobox-control/ //http://stackoverflow.com/questions/7719164/databinding-a-color-in-wpf-datatemplate Part3ComboBox.ItemsSource = _filteredRawLayers.Keys.Select((k, i) => new ColorSelectionItem(k, i)).ToList(); Part3Button.IsEnabled = false; LayerCount.Content = _filteredRawLayers.Count; } }
private static IEClass FindBaseClass(IEClass eClass, out IEnumerable <IEStructuralFeature> shadows) { shadows = Enumerable.Empty <IEStructuralFeature>(); var ancestors = eClass.Closure(c => c.ESuperTypes); foreach (var layer in Layering <IEClass> .CreateLayers(eClass, c => Edges(c, ancestors)).Reverse()) { if (layer.Count == 1 && layer.First() != eClass && !shadows.IntersectsWith(AllFeatures(layer.First()))) { return(layer.First()); } foreach (var cl in layer) { shadows = shadows.Union(Refinements(cl)); } } return(null); }
//////////////////////////////////////////////////////////// // Tracing ImageData, then returning PaddedPaletteImage with tracedata in layers private static TracedImage PaddedPaletteImageToTraceData(Bitmap image, Tracing tracing, SvgRendering rendering) { // Selective Gaussian blur preprocessing //if (options.Blur.BlurRadius > 0) //{ // // TODO: This seems to not work currently. // imgd = Blur(imgd, options.Blur.BlurRadius, options.Blur.BlurDelta); //} // 1. Color quantization var colors = image.ChangeFormat(PixelFormat.Format32bppArgb).ToColorReferences(); var colorGroups = ColorGrouping.Convert(colors, image.Width, image.Height, Palette); // 2. Layer separation and edge detection var rawLayers = Layering.Convert(colorGroups, image.Width, image.Height, Palette); // 3. Batch pathscan var pathPointLayers = rawLayers.ToDictionary(cl => cl.Key, cl => new Layer <PathPointPath> { Paths = Pathing.Scan(cl.Value, tracing.PathOmit).ToList() }); // 4. Batch interpollation var interpolationPointLayers = pathPointLayers.ToDictionary(cp => cp.Key, cp => Interpolation.Convert(cp.Value)); // 5. Batch tracing var sequenceLayers = interpolationPointLayers.ToDictionary(ci => ci.Key, ci => new Layer <SequencePath> { Paths = ci.Value.Paths.Select(path => new SequencePath { Path = path, Sequences = Sequencing.Create(path.Points.Select(p => p.Direction).ToList()).ToList() }).ToList() }); var segmentLayers = sequenceLayers.ToDictionary(ci => ci.Key, ci => new Layer <SegmentPath> { Paths = ci.Value.Paths.Select(path => new SegmentPath { Segments = path.Sequences.Select(s => Segmentation.Fit(path.Path.Points, s, tracing, rendering)).SelectMany(s => s).ToList() }).ToList() }); return(new TracedImage(segmentLayers, image.Width, image.Height)); }
private void SetTargetSortingLayers() { light2D.m_ApplyToSortingLayers = new int[] { Layering.StoryToSortingLayerID(storyLocation) }; }
public override void Transform(IClass scope, IReference reference, CodeMemberProperty property, Transformations.Core.ITransformationContext context) { var baseTypes = Layering <IClass> .CreateLayers(scope, c => c.BaseTypes).Select(c => c.Single()).ToList(); if (!baseTypes.Contains((IClass)reference.DeclaringType)) { throw new InvalidOperationException(string.Format("The reference {0} cannot be refined in the scope of class {1} because {1} does not inherit from its declaring class.", reference.Name, scope.Name)); } var classDeclaration = context.Trace.ResolveIn(Rule <Type2Type>(), scope); var originalReference = context.Trace.ResolveIn(Rule <Reference2Property>(), reference); property.Attributes = MemberAttributes.Private; property.Name = originalReference.Name; property.PrivateImplementationType = CreateReference(reference.DeclaringType, false, context); property.Type = originalReference.Type; lock (classDeclaration) { classDeclaration.Shadows(true).Add(originalReference); classDeclaration.DependentMembers(true).Add(property); } var implementations = baseTypes.SelectMany(s => s.References).Where(r => r.Refines == reference).ToList(); var constraints = baseTypes.SelectMany(s => s.ReferenceConstraints).Where(rc => rc.Constrains == reference); foreach (var declClass in implementations.Select(a => a.DeclaringType).OfType <IClass>().Concat(constraints.Select(c => c.DeclaringType)).Distinct()) { if (declClass != scope) { var refinedReference = context.Trace.ResolveIn(this, declClass, reference); if (refinedReference != null) { property.Shadows(true).Add(refinedReference); } } } if (implementations.Count == 0 && !constraints.Any()) { throw new InvalidOperationException( string.Format("The reference {0} can not be refined in the scope of class {1} because no reference refines it. ", reference, scope) ); } var referenceType = CreateReference(reference.Type, true, context); if (reference.UpperBound == 1) { var nullRef = new CodePrimitiveExpression(null); if (!constraints.Any()) { var castedThisVariable = new CodeVariableDeclarationStatement(classDeclaration.GetReferenceForType(), "_this", new CodeThisReferenceExpression()); var castedThisVariableRef = new CodeVariableReferenceExpression("_this"); property.GetStatements.Add(castedThisVariable); property.SetStatements.Add(castedThisVariable); var setRef = new CodePropertySetValueReferenceExpression(); var ifNull = new CodeConditionStatement(); ifNull.Condition = new CodeBinaryOperatorExpression(setRef, CodeBinaryOperatorType.IdentityInequality, nullRef); var foundMatch = false; foreach (var implementation in implementations) { var implementationRef = new CodePropertyReferenceExpression(castedThisVariableRef, context.Trace.ResolveIn(Rule <Reference2Property>(), implementation).Name); if (implementation.Type == reference.Type) { property.GetStatements.Add(new CodeMethodReturnStatement(implementationRef)); property.SetStatements.Add(new CodeAssignStatement(implementationRef, setRef)); foundMatch = true; break; } else { var getIfStmt = new CodeConditionStatement(); getIfStmt.Condition = new CodeBinaryOperatorExpression(implementationRef, CodeBinaryOperatorType.IdentityInequality, nullRef); getIfStmt.TrueStatements.Add(new CodeMethodReturnStatement(implementationRef)); property.GetStatements.Add(getIfStmt); var implementationType = CreateReference(implementation.Type, true, context); var asRef = new CodeMethodReferenceExpression(setRef, "As", implementationType); var localVar = new CodeVariableDeclarationStatement(implementationType, "__" + implementation.Name, new CodeMethodInvokeExpression(asRef)); var localVarRef = new CodeVariableReferenceExpression(localVar.Name); var setIfStmt = new CodeConditionStatement(); setIfStmt.Condition = new CodeBinaryOperatorExpression(localVarRef, CodeBinaryOperatorType.IdentityInequality, nullRef); setIfStmt.TrueStatements.Add(new CodeAssignStatement(implementationRef, localVarRef)); setIfStmt.TrueStatements.Add(new CodeMethodReturnStatement()); ifNull.TrueStatements.Add(localVar); ifNull.TrueStatements.Add(setIfStmt); ifNull.FalseStatements.Add(new CodeAssignStatement(implementationRef, nullRef)); } } ifNull.FalseStatements.Add(new CodeMethodReturnStatement()); if (ifNull.TrueStatements.Count > 0) { property.SetStatements.Add(ifNull); } if (!foundMatch) { property.GetStatements.Add(new CodeMethodReturnStatement(nullRef)); property.SetStatements.Add(new CodeThrowExceptionStatement(new CodeObjectCreateExpression(typeof(System.ArgumentException), new CodePrimitiveExpression("There was no suitable refining reference found for this object")))); } } else { var constraint = constraints.Last(); var ifNotDefault = new CodeConditionStatement(); ifNotDefault.TrueStatements.Add(new CodeThrowExceptionStatement(new CodeObjectCreateExpression(typeof(System.NotSupportedException)))); CodeExpression value; if (constraint.References.Count == 0) { value = nullRef; } else { var refEl = constraint.References[0]; var uri = refEl.AbsoluteUri; if (uri == null) { throw new System.InvalidOperationException(); } var metaRepositoryInstance = new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(typeof(MetaRepository)), "Instance"); var refElExpression = new CodeMethodInvokeExpression(metaRepositoryInstance, "Resolve", new CodePrimitiveExpression(uri.AbsoluteUri)); refElExpression = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(refElExpression, "As", property.Type)); var retrieveValueMethod = new CodeMemberMethod { Name = "Retrieve" + reference.Name.ToPascalCase(), Attributes = MemberAttributes.Private | MemberAttributes.Static, ReturnType = property.Type }; retrieveValueMethod.Statements.Add(new CodeMethodReturnStatement(refElExpression)); property.DependentMembers(true).Add(retrieveValueMethod); var staticField = new CodeMemberField(new CodeTypeReference("Lazy", property.Type), "_" + reference.Name.ToPascalCase()); staticField.Attributes = MemberAttributes.Private | MemberAttributes.Static; staticField.InitExpression = new CodeObjectCreateExpression(staticField.Type, new CodeMethodReferenceExpression(null, retrieveValueMethod.Name)); property.DependentMembers(true).Add(staticField); value = new CodePropertyReferenceExpression(new CodeFieldReferenceExpression(null, staticField.Name), "Value"); } property.GetStatements.Add(new CodeMethodReturnStatement(value)); ifNotDefault.Condition = new CodeBinaryOperatorExpression(new CodePropertySetValueReferenceExpression(), CodeBinaryOperatorType.IdentityInequality, value); property.SetStatements.Add(ifNotDefault); } CreateChangeEvent(property, implementations, context, "Changed"); CreateChangeEvent(property, implementations, context, "Changing"); } else { if (reference.IsUnique) { throw new System.InvalidOperationException("Unique references must not be refined!"); } if (implementations.Count > 0 || constraints.Any(c => c.References.Any())) { var collectionType = context.Trace.ResolveIn(Rule <RefinedReferenceCollectionClassGenerator>(), scope, reference); property.GetStatements.Add(new CodeMethodReturnStatement(new CodeObjectCreateExpression(collectionType.GetReferenceForType(), new CodeThisReferenceExpression()))); property.DependentTypes(true).Add(collectionType); } else { property.GetStatements.Add(new CodeMethodReturnStatement(new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(new CodeTypeReference(typeof(EmptyList <>).Name, referenceType)), "Instance"))); } } }
protected virtual void ResolveMultipleInheritanceMembers(CodeTypeDeclaration generatedType, HashSet <CodeTypeMember> shadows, CodeConstructor constructor) { var allClasses = generatedType.Closure(GetBaseClasses); var layering = Layering <CodeTypeDeclaration> .CreateLayers(generatedType, c => Edges(c, allClasses)); CodeTypeDeclaration implBaseType = null; int layerIndex; for (layerIndex = layering.Count - 1; layerIndex >= 0; layerIndex--) { var layer = layering[layerIndex]; if (layer.Count == 1 && layer.First() != generatedType && !shadows.IntersectsWith(AllFeatures(layer.First()))) { implBaseType = layer.First(); break; } foreach (var cl in layer) { shadows.UnionWith(Refinements(cl)); } } IEnumerable <CodeTypeDeclaration> inheritedBaseClasses; if (implBaseType != null) { inheritedBaseClasses = layering.Take(layerIndex + 1).SelectMany(s => s); var implementationRef = new CodeTypeReference(); implementationRef.BaseType = implBaseType.Name; var n = implBaseType.GetReferenceForType().Namespace(); if (n != null && n.EndsWith(implBaseType.Name)) { implementationRef.BaseType = n + "." + implBaseType.Name; } else { implementationRef.SetNamespace(n); } generatedType.BaseTypes.Insert(0, implementationRef); } else { inheritedBaseClasses = Enumerable.Empty <CodeTypeDeclaration>(); AddImplementationBaseClass(generatedType); } CodeDomHelper.SetUserItem(generatedType, CodeDomHelper.BaseClassesKey, inheritedBaseClasses); for (int i = layerIndex + 1; i < layering.Count; i++) { foreach (var baseType in layering[i]) { if (baseType != generatedType) { var dependent = baseType.DependentMembers(false); if (dependent != null) { foreach (var inheritedMember in dependent) { RecursivelyAddDependentMembers(generatedType.Members, constructor.Statements, inheritedMember, shadows); } } } } } }
/// <summary> /// Initializes the generated code property for the refined attribute /// </summary> /// <param name="scope">The scope in which the attribute is refined</param> /// <param name="attribute">The NMeta attribute that is refined</param> /// <param name="property">The generated code property</param> /// <param name="context">The transformation context</param> public override void Transform(IClass scope, IAttribute attribute, CodeMemberProperty property, ITransformationContext context) { var baseTypes = Layering <IClass> .CreateLayers(scope, c => c.BaseTypes).Select(c => c.Single()).ToList(); if (!baseTypes.Contains((IClass)attribute.DeclaringType)) { throw new InvalidOperationException(string.Format("The attribute {0} cannot be refined in the scope of class {1} because {1} does not inherit from its declaring class.", attribute.Name, scope.Name)); } var classDeclaration = context.Trace.ResolveIn(Rule <Type2Type>(), scope); var originalAttribute = context.Trace.ResolveIn(Rule <Attribute2Property>(), attribute); property.Attributes = MemberAttributes.Private; property.Name = originalAttribute.Name; property.PrivateImplementationType = CreateReference(attribute.DeclaringType, false, context); lock (classDeclaration) { classDeclaration.Shadows(true).Add(originalAttribute); classDeclaration.DependentMembers(true).Add(property); } var implementations = baseTypes.SelectMany(s => s.Attributes).Where(att => att.Refines == attribute).ToList(); var constraints = baseTypes.SelectMany(s => s.AttributeConstraints).Where(rc => rc.Constrains == attribute); foreach (var declClass in implementations.Select(a => a.DeclaringType).OfType <IClass>().Concat(constraints.Select(c => c.DeclaringType)).Distinct()) { if (declClass != scope) { var refinedAttribute = context.Trace.ResolveIn(this, declClass, attribute); if (refinedAttribute != null) { property.Shadows(true).Add(refinedAttribute); } } } if (implementations.Count == 0 && !constraints.Any()) { throw new InvalidOperationException( string.Format("The attribute {0} can not be refined in the scope of class {1} because no reference refines it. ", attribute, scope) ); } var attributeType = CreateReference(attribute.Type, false, context); if (attribute.UpperBound == 1) { property.Type = attributeType; if (implementations.Count > 1) { throw new System.InvalidOperationException("A single value typed attribute may only be refined once!"); } else if (implementations.Count == 1) { if (constraints.Any()) { throw new System.InvalidOperationException("A single values attribute must not be constrained and implemented at the same time!"); } if (implementations[0].Type != attribute.Type) { throw new System.InvalidOperationException("The refining attribute has a different type than the original attribute. Covariance is not supported for attributes!"); } var castedThisVariable = new CodeVariableDeclarationStatement(classDeclaration.GetReferenceForType(), "_this", new CodeThisReferenceExpression()); var castedThisVariableRef = new CodeVariableReferenceExpression("_this"); property.GetStatements.Add(castedThisVariable); property.SetStatements.Add(castedThisVariable); var implProperty = context.Trace.ResolveIn(Rule <Attribute2Property>(), implementations[0]); CodeExpression implementationRef = new CodePropertyReferenceExpression(castedThisVariableRef, implProperty.Name); property.GetStatements.Add(new CodeMethodReturnStatement(implementationRef)); property.SetStatements.Add(new CodeAssignStatement(implementationRef, new CodePropertySetValueReferenceExpression())); } else { var constraint = constraints.Last(); var ifNotDefault = new CodeConditionStatement(); ifNotDefault.TrueStatements.Add(new CodeThrowExceptionStatement(new CodeObjectCreateExpression(typeof(System.NotSupportedException)))); CodeExpression value; if (constraints.Sum(c => c.Values.Count) == 0) { value = new CodeDefaultValueExpression(attributeType); } else { value = CodeDomHelper.CreatePrimitiveExpression(constraint.Values[0], attributeType, attribute.Type is IEnumeration); if (value == null) { throw new InvalidOperationException(string.Format("The value {0} could not be serialized as a value for {1}", constraint.Values[0], attribute)); } } property.GetStatements.Add(new CodeMethodReturnStatement(value)); ifNotDefault.Condition = new CodeBinaryOperatorExpression(new CodePropertySetValueReferenceExpression(), CodeBinaryOperatorType.IdentityInequality, value); property.SetStatements.Add(ifNotDefault); } CreateChangeEvent(property, implementations, context, "Changed"); CreateChangeEvent(property, implementations, context, "Changing"); } else { if (attribute.IsUnique) { throw new System.InvalidOperationException("Unique attributes must not be refined."); } if (implementations.Count > 0 || constraints.Any(c => c.Values.Any())) { var collectionType = context.Trace.ResolveIn(Rule <RefinedAttributeCollectionClassGenerator>(), scope, attribute); property.GetStatements.Add(new CodeMethodReturnStatement(new CodeObjectCreateExpression(collectionType.GetReferenceForType(), new CodeThisReferenceExpression()))); property.DependentTypes(true).Add(collectionType); } else { property.GetStatements.Add(new CodeMethodReturnStatement(new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(new CodeTypeReference(typeof(EmptyList <>).Name, attributeType)), "Instance"))); } } }
private void UpdateCullingMask() { cameraComponent.cullingMask = baseCullingMask + (1 << (int)Layering.StoryToPhysicsLayer(target.storyLocation)); }