Exemple #1
0
        private static void applyBatchedNonGlobalTransforms(ContentPlan plan, TransformerRequirements requirements)
        {
            var policy = findBatchedTransformerPolicy(requirements);

            if (policy == null)
            {
                return;
            }


            var groups = new AssetGrouper <IContentSource>()
                         .GroupSubjects(plan.GetAllSources(), source => requirements.IsNextPolicy(source, policy));

            groups.Each(group =>
            {
                if (group.Count == 1)
                {
                    plan.ApplyTransform(group.Single(), policy.TransformerType);
                }
                else
                {
                    var combo = plan.Combine(group);
                    plan.ApplyTransform(combo, policy.TransformerType);
                }

                group.Each(s => requirements.DequeueTransformer(s, policy));
            });
        }
        public void simple_group()
        {
            var subjects = new int[] { 1, 2, 3, -4, -5, 6, 7 };
            var grouper  = new AssetGrouper <int>();

            grouper.GroupSubjects(subjects, i => i < 0).Single().ShouldHaveTheSameElementsAs(-4, -5);
        }
        public IEnumerable<AssetFileCombination> DetermineCombinations(AssetTagPlan plan)
        {
            var grouper = new AssetGrouper<IAssetTagSubject>();
            var groups = grouper.GroupSubjects(plan.Subjects, s => s is AssetFile)
                .Where(x => x.Count > 1);

            foreach (var @group in groups)
            {
                yield return new ScriptFileCombination(@group.Cast<AssetFile>().ToList());
            }
        }
        public void multiple_groups()
        {
            var subjects = new int[] { 1, 2, 3, -4, -5, 6, 7, -8, -9, 10, 11, -12 };

            var groups = new AssetGrouper<int>().GroupSubjects(subjects, i => i < 0);
            groups.Count().ShouldEqual(3);

            groups.ElementAt(0).Each(x => Debug.WriteLine(x));

            groups.ElementAt(0).ShouldHaveTheSameElementsAs(-4, -5);
            groups.ElementAt(1).ShouldHaveTheSameElementsAs(-8, -9);
            groups.ElementAt(2).ShouldHaveTheSameElementsAs(-12);
        }
        public void multiple_groups()
        {
            var subjects = new int[] { 1, 2, 3, -4, -5, 6, 7, -8, -9, 10, 11, -12 };

            var groups = new AssetGrouper <int>().GroupSubjects(subjects, i => i < 0);

            groups.Count().ShouldEqual(3);

            groups.ElementAt(0).Each(x => Debug.WriteLine(x));

            groups.ElementAt(0).ShouldHaveTheSameElementsAs(-4, -5);
            groups.ElementAt(1).ShouldHaveTheSameElementsAs(-8, -9);
            groups.ElementAt(2).ShouldHaveTheSameElementsAs(-12);
        }
        public IEnumerable<AssetFileCombination> DetermineCombinations(AssetTagPlan plan)
        {
            var folders = plan.Subjects.OfType<AssetFile>().Select(x => x.ContentFolder()).Distinct();
            foreach (var folder in folders)
            {
                var grouper = new AssetGrouper<IAssetTagSubject>();
                var groups = grouper.GroupSubjects(plan.Subjects, s => s is AssetFile && s.As<AssetFile>().ContentFolder() == folder)
                    .Where(x => x.Count > 1);

                foreach (var @group in groups)
                {
                    yield return new StyleFileCombination(folder, @group.Cast<AssetFile>().ToList());
                }
            }
        }
        private static void applyBatchedNonGlobalTransforms(ContentPlan plan, TransformerRequirements requirements)
        {
            var policy = findBatchedTransformerPolicy(requirements);
            if (policy == null) return;

            var groups = new AssetGrouper<IContentSource>()
                .GroupSubjects(plan.GetAllSources(), source => requirements.IsNextPolicy(source, policy));

            groups.Each(group =>
            {
                if (group.Count == 1)
                {
                    plan.ApplyTransform(group.Single(), policy.TransformerType);
                }
                else
                {
                    var combo = plan.Combine(group);
                    plan.ApplyTransform(combo, policy.TransformerType);
                }

                group.Each(s => requirements.DequeueTransformer(s, policy));
            });
        }
 public void simple_group()
 {
     var subjects = new int[]{1, 2, 3, -4, -5, 6, 7};
     var grouper = new AssetGrouper<int>();
     grouper.GroupSubjects(subjects, i => i < 0).Single().ShouldHaveTheSameElementsAs(-4, -5);
 }