/// <summary>
        /// Creates a Dictionary that stores values containing embedded keys.
        /// </summary>
        /// <typeparam name="TKey">The type of keys in the collection.</typeparam>
        /// <typeparam name="TItem">The type of items in the collection.</typeparam>
        /// <param name="items">The items to populate the dictionary with.</param>
        /// <param name="keyExtractor">A delegate that extracts the embedded key from each item.</param>
        /// <param name="comparer">The comparer to use.</param>
        /// <param name="dictionaryCreationThreshold">The number of elements the collection can hold without creating a lookup dictionary.
        /// (0 creates the lookup dictionary when the first item is added), or –1 to specify that a lookup dictionary is never created.
        /// </param>
        /// <returns>An instance of the Dictionary.</returns>
        public static KeyedCollection <TKey, TItem> Create <TKey, TItem>(IEnumerable <TItem> items, Func <TItem, TKey> keyExtractor, IEqualityComparer <TKey> comparer, int dictionaryCreationThreshold)
        {
            if (items == null)
            {
                throw new ArgumentNullException(nameof(items));
            }
            if (keyExtractor == null)
            {
                throw new ArgumentNullException(nameof(keyExtractor));
            }
            if (comparer == null)
            {
                throw new ArgumentNullException(nameof(comparer));
            }
            if (dictionaryCreationThreshold < -1)
            {
                throw new ArgumentOutOfRangeException(nameof(dictionaryCreationThreshold));
            }

            var impl = new KeyedCollectionImpl <TKey, TItem>(keyExtractor, comparer, dictionaryCreationThreshold);

            foreach (var item in items)
            {
                impl.Add(item);
            }

            return(impl);
        }
Exemple #2
0
        internal void Initialize(ArmatureData data)
        {
            FrameRate = data.FrameRate;

            if (data.Bones.Any())
            {
                Bones.Add(new DbBone(this, data.Bones[0]));
                for (var i = 1; i < data.Bones.Length; i++)
                {
                    var bone       = data.Bones[i];
                    var parentBone = Bones[bone.Parent];
                    parentBone.AddBone(new DbBone(this, bone));
                }
            }

            foreach (var slot in data.Slots)
            {
                var parentBone = Bones[slot.Parent];
                parentBone.AddSlot(new DbSlot(this, slot));
            }

            foreach (var fill in data.Skins[0].SlotFills)
            {
                var slot = Slots[fill.SlotName];
                foreach (var display in fill.Displays)
                {
                    slot.AddDisplay(display);
                }
            }

            foreach (var animation in data.Animations)
            {
                Animations.Add(new DbAnimation(this, animation));
            }

            foreach (var ik in data.InverseKinematics)
            {
                IkConstraints.Add(new DbIkConstraint(ik)); // TODO
            }
            SortSlots();
            ResetBones();
            // load DefaultActions into Dictionary
            DefaultActions = data.DefaultActions[0];
            if (DefaultActions.ContainsKey("gotoAndPlay") && Animations.Contains(DefaultActions["gotoAndPlay"]))
            {
                GotoAndPlay(DefaultActions["gotoAndPlay"]);
            }
        }
        /// <summary>
        /// Creates a Dictionary that stores values containing embedded keys.
        /// </summary>
        /// <typeparam name="TKey">The type of keys in the collection.</typeparam>
        /// <typeparam name="TItem">The type of items in the collection.</typeparam>
        /// <param name="items">The items to populate the dictionary with.</param>
        /// <param name="keyExtractor">A delegate that extracts the embedded key from each item.</param>
        /// </param>
        /// <returns>An instance of the Dictionary.</returns>
        public static KeyedCollection <TKey, TItem> Create <TKey, TItem>(IEnumerable <TItem> items, Func <TItem, TKey> keyExtractor)
        {
            if (keyExtractor == null)
            {
                throw new ArgumentNullException(nameof(keyExtractor));
            }

            var impl = new KeyedCollectionImpl <TKey, TItem>(keyExtractor);

            foreach (var item in items)
            {
                impl.Add(item);
            }

            return(impl);
        }
Exemple #4
0
    public static ConfigurationPackage CreatePackage(IEnumerable <KeyValuePair <string, string> > configurationParameters)
    {
        var package    = CreateUninitialized <ConfigurationPackage>();
        var settings   = CreateUninitialized <ConfigurationSettings>();
        var sections   = new KeyedCollectionImpl <string, ConfigurationSection>(s => s.Name);
        var section    = CreateUninitialized <ConfigurationSection>();
        var parameters = new KeyedCollectionImpl <string, ConfigurationProperty>(p => p.Name);

        sections.Add(section);

        foreach (var keyValuePair in configurationParameters)
        {
            var parameter = CreateUninitialized <ConfigurationProperty>();
            typeof(ConfigurationProperty)
            .GetProperty("Name")
            .SetValue(parameter, keyValuePair.Key);
            typeof(ConfigurationProperty)
            .GetProperty("Value")
            .SetValue(parameter, keyValuePair.Value);
            parameters.Add(parameter);
        }

        typeof(ConfigurationPackage)
        .GetProperty("Settings")
        .SetValue(package, settings);
        typeof(ConfigurationSettings)
        .GetProperty("Sections")
        .SetValue(settings, sections);
        typeof(ConfigurationSection)
        .GetProperty("Parameters")
        .SetValue(section, parameters);
        typeof(ConfigurationSection)
        .GetProperty("Name")
        .SetValue(section, "Configuration");

        return(package);
    }
Exemple #5
0
        private bool mergeDirectoryListing(string path, ArrayList fileArrList)
        {
            bool found = false;
            KeyedCollectionImpl<string, FileInformation> directoryItems = new KeyedCollectionImpl<string, FileInformation>(delegate(FileInformation itemInfo)
            {
                return itemInfo.FileName;
            });

            Trace.TraceInformation(String.Format("Creating merged directory listing for " + path));
            foreach (Member m in this.members)
            {
                if(m.GetFileSystemObjectKind(path) != FileSystemObjectKind.Directory)
                {
                    continue;
                }
                string realPath = m.GetRootedPath(path);
                found = true;
                foreach (FileSystemInfo fsInfo in new DirectoryInfo(realPath).GetFileSystemInfos())
                {
                    FileInformation fi = new FileInformation();
                    fi.Attributes = fsInfo.Attributes;
                    fi.CreationTime = fsInfo.CreationTime;
                    fi.FileName = fsInfo.Name;
                    fi.LastAccessTime = fsInfo.LastAccessTime;
                    fi.LastWriteTime = fsInfo.LastWriteTime;
                    if (fsInfo is FileInfo)
                    {
                        fi.Length = (fsInfo as FileInfo).Length;
                    }
                    else
                    {
                        fi.Length = 0;
                    }
                    if (!directoryItems.Contains(fi.FileName))
                    {
                        directoryItems.Add(fi);
                        Trace.TraceInformation(String.Format("Found object {0}, size {1} bytes", fi.FileName, fi.Length));
                    }
                }
            }
            foreach (FileInformation fi in directoryItems)
            {
                fileArrList.Add(fi);
            }
            return found;
        }
Exemple #6
0
 /// <summary>
 /// Add a slot to this armature.
 /// </summary>
 /// <param name="slot"></param>
 public void AddSlot(DbSlot slot)
 {
     Slots.Add(slot);
 }