public void LazyAddTest() { var lazyList = new LazyList<string>(); lazyList.Add("item"); var initialized = lazyList.IsInitialized; Assert.True(initialized); }
public Order(string orderNumber, string userName) { this.OrderNumber = orderNumber; this.UserName = userName; this.Status = OrderStatus.NotCheckoutOut; this.Items=new LazyList<OrderItem>(); this.IncentivesUsed = new LazyList<IIncentive>(); this.ID = Guid.NewGuid(); this.DiscountAmount = 0; this.DiscountReason = "--"; }
public IAsyncOperation<IList<SynchronizedView>> GetViewsAsync(IList<string> viewNames) { if (viewNames.IsNullOrEmpty()) { throw new ArgumentException("viewNames"); } return AsyncInfo.Run<IList<SynchronizedView>>(async cancelToken => { LazyList<SynchronizedView> views = new LazyList<SynchronizedView>(); foreach(string viewName in viewNames) { SynchronizedView view = await this.GetViewAsync(viewName, cancelToken); if (view != null) { views.Add(view); } } return views.HasValue ? views.Value : null; }); }
public void ShouldNotCallFactoryOnConstruction() { bool called = false; var list = new LazyList<int>(() => { called = true; return new List<int>(); }); Assert.False(called); }
public void ShouldReturnInnerElements() { var innerList = new List<int> { 1, 2, 3 }; var list = new LazyList<int>(() => innerList); Assert.True(innerList.SequenceEqual(list)); }
public override LazyList <string> Visit(NumLitNode node, Precedence parentPrecedence) { Contracts.AssertValue(node); NumLitToken nlt = node.Value; return(LazyList <string> .Of("#$number$#")); }
public UserProfile(string userName) { LastProductsViewed = new LazyList<Product>(); LastCategoriesViewed = new LazyList<Category>(); Recommended = new LazyList<Product>(); AddressBook=new LazyList<Address>(); this.UserName = userName; }
public void GivenLazyListWhenAddShouldNotLoad() { var lazyList = new LazyList <Stub>(_lazyLoadResolverMock.Object); lazyList.Add(new Stub()); _lazyLoadResolverMock.Verify(x => x.Resolve(It.IsAny <LazyLoadParameter>()), Times.Never()); }
private ImmutableEnumerator(LazyList next, Last last) { this.next = next; this.last = last; // Use the default hashCode on the single mutable LazyList // instance for this position in the enumerator. this.hashCode = next.GetHashCode(); }
/// <summary> /// A string representation of the list of MetricTableInfo objects including indentation /// </summary> /// <param name="metricTableInfos">The list of MetricTableInfo objects</param> /// <param name="indentationTabs">The number of tabs to insert in front of each member</param> /// <returns>A string representation of the list of MetricTableInfo objects including indentation</returns> public static string ToString(this LazyList <MetricTableInfo> metricTableInfos, int indentationTabs) { StringBuilder output = new StringBuilder(); metricTableInfos.ForEach(metricTableInfo => output.Append(metricTableInfo.ToString(indentationTabs))); return(output.ToString()); }
public static NeuralNetwork initWithSeed(int seed, int[] layers) { FSharpList <int> ls = ListModule.OfSeq(layers); LazyList <LazyList <Neuron.Neuron> > _contents = NeuralNetworkModule.initWithSeed(seed, ls); return(new NeuralNetwork(_contents)); }
/// <summary> /// Constructor /// </summary> /// <param name="locals">All locals that will be owned by this instance</param> public LocalList(IEnumerable <Local> locals) { this.locals = new LazyList <Local>(this); foreach (var local in locals.GetSafeEnumerable()) { this.locals.Add(local); } }
public void LazyAddTest() { var lazyList = new LazyList <string>(); lazyList.Add("item"); var initialized = lazyList.IsInitialized; Assert.True(initialized); }
public void Constructor() { // ReSharper disable once CollectionNeverUpdated.Local var lazy = new LazyList <int>(); lazy.Should().NotBeNull(); lazy.Count.Should().Be(0); lazy.IsReadOnly.Should().BeFalse(); }
/// <inheritdoc/> public override void InitIfNeeded(IOSA iAdapter) { base.InitIfNeeded(iAdapter); if (Data == null) // this will only be null at init. When scrollview's size changes, the data should remain the same { Data = new LazyList <TData>(NewModelCreator, 0); } }
public void Constructor_ThreadSafetyMode() { // ReSharper disable once CollectionNeverUpdated.Local var lazy = new LazyList <int>(LazyThreadSafetyMode.ExecutionAndPublication); lazy.Should().NotBeNull(); lazy.Count.Should().Be(0); lazy.IsReadOnly.Should().BeFalse(); }
public void Constructor_FromFactory() { // ReSharper disable once CollectionNeverUpdated.Local var lazy = new LazyList <int>(() => _Int32TestData.ToList()); lazy.Should().NotBeNull(); lazy.Count.Should().Be(5); lazy.IsReadOnly.Should().BeFalse(); }
public void RemoveBean(object obj) { if (_listeners != null) { for (int i = 0; i < LazyList.Size(_listeners); i++) { LazyList.Get <IContainerListener>(_listeners, i).RemoveBean(obj); } } }
/// <summary> /// Constructor /// </summary> /// <param name="name">Method name</param> /// <param name="methodSig">Method sig</param> /// <param name="implFlags">Impl flags</param> /// <param name="flags">Flags</param> public MethodDefUser(UTF8String name, MethodSig methodSig, MethodImplAttributes implFlags, MethodAttributes flags) { this.name = name; this.signature = methodSig; this.implFlags = implFlags; this.flags = flags; this.parameters = new LazyList <ParamDef>(this); this.genericParams = new LazyList <GenericParam>(this); this.parameterList = new ParameterList(this); }
public void ShouldReturnInnerElements() { var innerList = new List <int> { 1, 2, 3 }; var list = new LazyList <int>(() => innerList); Assert.True(innerList.SequenceEqual(list)); }
public LazyPaginatedMessage(IUserMessage message, LazyList <T> items, TimeSpan timeout, SocketCommandContext context, string title, Action <T, EmbedBuilder> build) { _message = message; _items = items; _title = title; _build = build; Timeout = timeout; Context = context; }
/// <summary> /// Reads the directory header and initializes <see cref="ResourceDirectory.directories"/> and /// <see cref="ResourceDirectory.data"/>. /// </summary> /// <param name="reader"></param> void Initialize(IBinaryReader reader) { if (depth > MAX_DIR_DEPTH || !reader.CanRead(16)) { InitializeDefault(); return; } characteristics = reader.ReadUInt32(); timeDateStamp = reader.ReadUInt32(); majorVersion = reader.ReadUInt16(); minorVersion = reader.ReadUInt16(); ushort numNamed = reader.ReadUInt16(); ushort numIds = reader.ReadUInt16(); int total = numNamed + numIds; if (!reader.CanRead(total * 8)) { InitializeDefault(); return; } dataInfos = new List <EntryInfo>(); dirInfos = new List <EntryInfo>(); long offset = reader.Position; for (int i = 0; i < total; i++, offset += 8) { reader.Position = offset; uint nameOrId = reader.ReadUInt32(); uint dataOrDirectory = reader.ReadUInt32(); ResourceName name; if ((nameOrId & 0x80000000) != 0) { name = new ResourceName(ReadString(reader, nameOrId & 0x7FFFFFFF) ?? string.Empty); } else { name = new ResourceName((int)nameOrId); } if ((dataOrDirectory & 0x80000000) == 0) { dataInfos.Add(new EntryInfo(name, dataOrDirectory)); } else { dirInfos.Add(new EntryInfo(name, dataOrDirectory & 0x7FFFFFFF)); } } directories = new LazyList <ResourceDirectory>(dirInfos.Count, null, (ctx, i) => ReadResourceDirectory((int)i)); data = new LazyList <ResourceData>(dataInfos.Count, null, (ctx, i) => ReadResourceData((int)i)); }
public void GivenLazyListWhenGetEnumeratorShouldLoad() { _lazyLoadResolverMock.Setup(x => x.Resolve(It.IsAny <LazyLoadParameter>())) .Returns(new[] { new Stub(), new Stub() }) .Verifiable(); var lazyList = new LazyList <Stub>(_lazyLoadResolverMock.Object); lazyList.GetEnumerator().Should().NotBeNull(); _lazyLoadResolverMock.VerifyAll(); }
public void LazyByDefaultTest() { // Arrange var lazyList = new LazyList <string>(); // Act var initialized = lazyList.IsInitialized; // Assert Assert.False(initialized); }
/// <summary> /// Constructor /// </summary> /// <param name="name">Method name</param> /// <param name="methodSig">Method sig</param> /// <param name="implFlags">Impl flags</param> /// <param name="flags">Flags</param> public MethodDefUser(UTF8String name, MethodSig methodSig, MethodImplAttributes implFlags, MethodAttributes flags) { this.name = name; signature = methodSig; paramDefs = new LazyList <ParamDef>(this); genericParameters = new LazyList <GenericParam>(this); implAttributes = (int)implFlags; attributes = (int)flags; parameterList = new ParameterList(this, null); semAttrs = 0 | SEMATTRS_INITD; }
public void TestCloneToString() { List <object> l = new List <object>(); l.Add("a"); l.Add("b"); Assert.AreEqual("[]", LazyList.ToString(LazyList.Clone(null))); Assert.AreEqual("[a]", LazyList.ToString(LazyList.Clone("a"))); Assert.AreEqual("[a, b]", LazyList.ToString(LazyList.Clone(l))); }
private static LazyList <Token> ParseNormal(IEnumerator <UChar> inputStream) { UStringBuilder _textFragment = new UStringBuilder(1024); UStringBuilder _tentativeParent = new UStringBuilder(16); ParentType type = _none; while (inputStream.MoveNext()) { var c = inputStream.Current; if (c == SpecialCharacters.BeforeRubyInitiater) { _textFragment.Append(_tentativeParent.ToUString()); _tentativeParent.Clear(); var token = new NormalToken(_textFragment.ToUString()); _textFragment.Clear(); _textFragment = null; _tentativeParent = null; return(LazyList <Token> .New(token, () => ParseRubyParent(inputStream))); } else if (c == SpecialCharacters.RubyOpen) { var token = new NormalToken(_textFragment.ToUString()); _textFragment.Clear(); _textFragment = null; UString parent = _tentativeParent.ToUString(); _tentativeParent.Clear(); _tentativeParent = null; return(LazyList <Token> .New(token, () => ParseRubyText(inputStream, parent))); } else { //暫定親字の継続検証 if (type.IsContinuous(c)) { _tentativeParent.Append(c); } else { _textFragment.Append(_tentativeParent.ToUString()); _tentativeParent.Clear(); _tentativeParent.Append(c); type = RubyParser.ClassifyParentType(c); } } } { _textFragment.Append(_tentativeParent.ToUString()); _tentativeParent.Clear(); var token = new NormalToken(_textFragment.ToUString()); return(LazyList <Token> .New(token)); } }
public static IEnumerable <A> Enumerable <A>(this LazyList <A> list) { foreach (var a in list.Head.Enumerable()) { yield return(a); } foreach (var a in list.Tail.Enumerable().SelectMany(tail => tail.Enumerable())) { yield return(a); } }
public void ShouldReturnTotalCountWhenEnumerationIsNonEmpty() { MockEnumerable source = new MockEnumerable(3); var list = new LazyList <int>(source); Assert.AreEqual(3, list.Count, "Should return size of enumeration."); Assert.AreEqual(3, source.TotalElementsReturned, "Should have fetched all elements."); Assert.AreEqual(3, list.Count, "Should return the same count the second time also."); Assert.AreEqual(3, source.TotalElementsReturned, "Should not have fetched any additional elements."); }
void InitInterfaceImpls_NoLock() { var mdi = readerModule.MetaDataImport; uint token = OriginalToken.Raw; interfaces?.Clear(); var itemTokens = MDAPI.GetInterfaceImplTokens(mdi, token); interfaces = new LazyList <InterfaceImpl, uint[]>(itemTokens.Length, itemTokens, (itemTokens2, index) => readerModule.ResolveInterfaceImpl(itemTokens2[index], new GenericParamContext(this))); }
public void LazyByDefaultTest() { // Arrange var lazyList = new LazyList<string>(); // Act var initialized = lazyList.IsInitialized; // Assert Assert.False(initialized); }
public void LazyAddTest() { // Arrange var lazyList = new LazyList <string>(); // Act lazyList.Add("item"); var initialized = lazyList.IsInitialized; // Assert Assert.True(initialized); }
void InitGenericParamConstraints_NoLock() { var mdi2 = readerModule.MetaDataImport2; uint token = OriginalToken.Raw; // Don't clear the list to prevent recursive init //genericParamConstraints?.Clear(); var itemTokens = MDAPI.GetGenericParamConstraintTokens(mdi2, token); genericParamConstraints = new LazyList <GenericParamConstraint>(itemTokens.Length, this, itemTokens, (itemTokens2, index) => readerModule.ResolveGenericParamConstraintDontCache(itemTokens[index], GetGenericParamContext(owner))); }
protected override void InnerSetValue(TEntity instance, object value, ISession session) { if (IsLazy) { var proxy = new LazyList <TListMember>(() => Load(session, instance)); setter.Invoke(instance, new[] { proxy }); } else { base.InnerSetValue(instance, Load(session, instance), session); } }
public void GivenLazyListWhenSetIndexShouldLoad() { _lazyLoadResolverMock.Setup(x => x.Resolve(It.IsAny <LazyLoadParameter>())) .Returns(new[] { new Stub(), new Stub() }) .Verifiable(); var lazyList = new LazyList <Stub>(_lazyLoadResolverMock.Object); lazyList[0] = new Stub(); _lazyLoadResolverMock.VerifyAll(); }
public void LazyAddTest() { // Arrange var lazyList = new LazyList<string>(); // Act lazyList.Add("item"); var initialized = lazyList.IsInitialized; // Assert Assert.True(initialized); }
private LazyList <string> ApplyPrecedence(Precedence parentPrecedence, Precedence precedence, LazyList <string> strings) { if (parentPrecedence > precedence) { var result = LazyList <string> .Of(TexlLexer.PunctuatorParenOpen); result = result.With(strings); result = result.With(TexlLexer.PunctuatorParenClose); return(result); } return(strings); }
public void GivenLazyListWhenLoadShouldNotFailIfLazyParameterIsNull() { _lazyLoadResolverMock.Setup(x => x.Resolve(It.IsAny <LazyLoadParameter>())) .Returns(new[] { new Stub(), new Stub() }) .Verifiable(); var lazyList = new LazyList <Stub>(_lazyLoadResolverMock.Object, null); lazyList.Should().HaveCount(2); _lazyLoadResolverMock.VerifyAll(); }
public void Index_get_test() { // arrange storage[0] = new Dictionary<string, object> { {"List", new List<int> {1,2,3 } } }; var list = new LazyList<int>(dbCollectionMock.Object, 0, "List"); // act and assert list[0].Should().Be(1); list[1].Should().Be(2); list[2].Should().Be(3); dbCollectionMock.Verify(x => x.ArrayElem(0, "List", It.IsAny<int>()) , Times.Exactly(3)); }
public void Index_set_does_not_change_storage() { // arrange storage[0] = new Dictionary<string, object> { {"List", new List<int> {1,2,3 } } }; var list = new LazyList<int>(dbCollectionMock.Object, 0, "List"); // act list[1] = 69; // assert list[1].Should().Be(69); ((storage[0]["List"]) as IEnumerable<int>) .ElementAt(1) .Should().Be(2); }
public Order(Customer customer, string orderNumber) { ValidateCustomer(customer); this.UserName = customer.UserName; this.OrderNumber = orderNumber; this.ID = Guid.NewGuid(); this.DiscountAmount = 0; this.DiscountReason = "--"; this.DateCreated = DateTime.Now; this.CurrentState = new NewOrder(this); //new up the lists Items = new LazyList<OrderLine>(); Transactions = new LazyList<Transaction>(); //add the items AddCartItemsToOrder(customer.Cart); this.ShippingAmount = customer.Cart.ShippingAmount; this.ShippingAddress = customer.Cart.ShippingAddress; this.ShippingService = customer.Cart.ShippingService; }
public void Commit_test() { // arrange storage[0] = new Dictionary<string, object> { {"List", new List<int> {1,2,3 } } }; var list = new LazyList<int>(dbCollectionMock.Object, 0, "List"); // act list[0] = 69; list[1] = 69; list[2] = 69; list.Commit(); // assert var storageList = ((storage[0]["List"]) as IEnumerable<int>); storageList.ElementAt(0).Should().Be(69); storageList.ElementAt(1).Should().Be(69); storageList.ElementAt(2).Should().Be(69); dbCollectionMock.Verify(x => x.ArrayElem(0, "List", It.IsAny<int>()), Times.Never); }
void InitInterfaceImpls_NoLock() { var mdi = readerModule.MetaDataImport; uint token = OriginalToken.Raw; interfaces?.Clear(); var itemTokens = MDAPI.GetInterfaceImplTokens(mdi, token); interfaces = new LazyList<InterfaceImpl>(itemTokens.Length, itemTokens, (itemTokens2, index) => readerModule.ResolveInterfaceImpl(itemTokens[index], new GenericParamContext(this))); }
protected override void InitializeNestedTypes() { var list = readerModule.GetTypeDefNestedClassRids(this); var tmp = new LazyList<TypeDef>(list.Length, this, list, (list2, index) => readerModule.ResolveTypeDef(((uint[])list2)[index])); Interlocked.CompareExchange(ref nestedTypes, tmp, null); }
public IAsyncOperation<IList<IItemDataTyped>> EnsureItemsAvailableAndGetAsync(int startAt, int count) { if (!m_data.HasKeys) { return null; } m_data.ValidateIndex(startAt); count = m_data.Keys.GetCorrectedCount(startAt, count); return AsyncInfo.Run<IList<IItemDataTyped>>( async cancelToken => { var items = new LazyList<IItemDataTyped>(); for (int i = startAt, max = startAt + count; i < max; ++i) { IItemDataTyped item = await EnsureItemAvailableAndGetAsync(i).AsTask(cancelToken); items.Add(item); } return items.HasValue ? items.Value : null; }); }
void InitGenericParams_NoLock() { var mdi2 = readerModule.MetaDataImport2; uint token = OriginalToken.Raw; var gps = genericParameters; if (gps != null) gps.Clear(); var itemTokens = MDAPI.GetGenericParamTokens(mdi2, token); var newItems = new MemberInfo<CorGenericParam>[itemTokens.Length]; for (int i = 0; i < itemTokens.Length; i++) { uint itemRid = itemTokens[i] & 0x00FFFFFF; newItems[i] = readerModule.Register(new CorGenericParam(readerModule, itemRid, this), cmd => cmd.Initialize()); } genericParameters = new LazyList<GenericParam>(itemTokens.Length, this, itemTokens, (itemTokens2, index) => newItems[index].Item); }
void InitParamDefs_NoLock() { var mdi = readerModule.MetaDataImport; uint token = OriginalToken.Raw; var mds = paramDefs; if (mds != null) mds.Clear(); var itemTokens = MDAPI.GetParamTokens(mdi, token); var newItems = new MemberInfo<CorParamDef>[itemTokens.Length]; for (int i = 0; i < itemTokens.Length; i++) { uint itemRid = itemTokens[i] & 0x00FFFFFF; newItems[i] = readerModule.Register(new CorParamDef(readerModule, itemRid, this), cmd => cmd.Initialize()); } paramDefs = new LazyList<ParamDef>(itemTokens.Length, this, itemTokens, (itemTokens2, index) => newItems[index].Item); }
internal async Task<IList<RecordItem>> GetItemsAsyncImpl(IEnumerable<ItemKey> keys, bool includeNullItems) { var items = new LazyList<RecordItem>(); foreach (ItemKey key in keys) { key.Validate(); RecordItem item = await GetItemAsyncImpl(key); if (includeNullItems) { items.Add(item); } else if (item != null) { items.Add(item); } } return (items.Count > 0) ? items.Value : null; }
internal async Task<IList<IItemDataTyped>> GetItemsAsync(int startAt, int count, bool shouldAwaitRefresh, CancellationToken cancelToken) { if (!m_data.HasKeys) { return null; } m_data.ValidateIndex(startAt); count = m_data.Keys.GetCorrectedCount(startAt, count); var items = new LazyList<IItemDataTyped>(); for (int i = startAt, max = startAt + count; i < max; ++i) { IItemDataTyped item = await GetItemAsync(i, shouldAwaitRefresh, cancelToken); items.Add(item); } return items.HasValue ? items.Value : null; }
internal async Task<IList<IItemDataTyped>> EnsureItemsAvailableAndGetAsync(int startAt, int count, CancellationToken cancelToken) { if (!m_data.HasKeys) { return null; } m_data.ValidateIndex(startAt); count = m_data.Keys.GetCorrectedCount(startAt, count); var items = new LazyList<IItemDataTyped>(); for (int i = startAt, max = startAt + count; i < max; ++i) { IItemDataTyped item = await EnsureItemAvailableAndGetAsync(i).AsTask(cancelToken); items.Add(item); } return items.HasValue ? items.Value : null; }
// Returns null if no matches public IAsyncOperation<IList<ItemKey>> GetKeysForItemsNeedingDownload(int startAt, int count) { return AsyncInfo.Run<IList<ItemKey>>(async cancelToken => { IList<ItemKey> keys = this.Keys.SelectItemKeys(startAt, count); LazyList<ItemKey> candidates = new LazyList<ItemKey>(); foreach(ItemKey key in keys) { if (await this.LoadLocalItemAsync(key) == null) { candidates.Add(key); } } return candidates.HasValue ? candidates.Value : null; }); }
void InitializeDefault() { directories = new LazyList<ResourceDirectory>(); data = new LazyList<ResourceData>(); }
void InitFields_NoLock() { var mdi = readerModule.MetaDataImport; uint token = OriginalToken.Raw; fieldRidToFieldOffset = CalculateFieldOffsets(); fields?.Clear(); var itemTokens = MDAPI.GetFieldTokens(mdi, token); var newItems = new MemberInfo<CorFieldDef>[itemTokens.Length]; for (int i = 0; i < itemTokens.Length; i++) { uint itemRid = itemTokens[i] & 0x00FFFFFF; newItems[i] = readerModule.Register(new CorFieldDef(readerModule, itemRid, this), cmd => cmd.Initialize()); } fields = new LazyList<FieldDef>(itemTokens.Length, this, itemTokens, (itemTokens2, index) => newItems[index].Item); }
private IList<ItemKey> CollectKeysNeedingDownload(int startAt, int keyCount) { IList<ViewKey> viewKeys = m_data.Keys.SelectKeysNotAlreadyLoading(startAt, keyCount); if (viewKeys.IsNullOrEmpty()) { return null; } var keys = new LazyList<ItemKey>(); for (int i = 0, count = viewKeys.Count; i < count; ++i) { ViewKey viewKey = viewKeys[i]; viewKey.IsLoadPending = true; keys.Add(viewKey.Key); } return keys.HasValue ? keys.Value : null; }
// Collect queries for those views that can be synchronized. Return the list of views async Task<IList<ISynchronizedView>> CollectSynchronizableViews(IList<ISynchronizedView> views) { LazyList<ISynchronizedView> synchronizableViews = new LazyList<ISynchronizedView>(); foreach (ISynchronizedView view in views) { ItemQuery query = await this.GetSyncQuery(view); m_syncQueries.Add(query); if (query != null) { m_queriesToRun.Add(query); synchronizableViews.Add(view); } } return synchronizableViews.HasValue ? synchronizableViews.Value : null; }
/// <inheritdoc/> protected override void InitializeExportedTypes() { var list = MetaData.GetExportedTypeRidList(); var tmp = new LazyList<ExportedType>((int)list.Length, list, (list2, i) => ResolveExportedType(((RidList)list2)[i])); Interlocked.CompareExchange(ref exportedTypes, tmp, null); }
public void LazyByDefaultTest() { var lazyList = new LazyList<string>(); var initialized = lazyList.IsInitialized; Assert.False(initialized); }
void InitGenericParamConstraints_NoLock() { var mdi2 = readerModule.MetaDataImport2; uint token = OriginalToken.Raw; // Don't clear the list to prevent recursive init // var gpcs = genericParamConstraints; // if (gpcs != null) // gpcs.Clear(); var itemTokens = MDAPI.GetGenericParamConstraintTokens(mdi2, token); genericParamConstraints = new LazyList<GenericParamConstraint>(itemTokens.Length, this, itemTokens, (itemTokens2, index) => readerModule.ResolveGenericParamConstraintDontCache(itemTokens[index], GetGenericParamContext(owner))); }
/// <inheritdoc/> protected override void InitializeTypes() { var list = MetaData.GetNonNestedClassRidList(); var tmp = new LazyList<TypeDef>((int)list.Length, this, list, (list2, index) => ResolveTypeDef(((RidList)list2)[index])); Interlocked.CompareExchange(ref types, tmp, null); }
/// <summary> /// Reads the directory header and initializes <see cref="ResourceDirectory.directories"/> and /// <see cref="ResourceDirectory.data"/>. /// </summary> /// <param name="reader"></param> void Initialize(IBinaryReader reader) { if (depth > MAX_DIR_DEPTH || !reader.CanRead(16)) { InitializeDefault(); return; } characteristics = reader.ReadUInt32(); timeDateStamp = reader.ReadUInt32(); majorVersion = reader.ReadUInt16(); minorVersion = reader.ReadUInt16(); ushort numNamed = reader.ReadUInt16(); ushort numIds = reader.ReadUInt16(); int total = numNamed + numIds; if (!reader.CanRead(total * 8)) { InitializeDefault(); return; } dataInfos = new List<EntryInfo>(); dirInfos = new List<EntryInfo>(); long offset = reader.Position; for (int i = 0; i < total; i++, offset += 8) { reader.Position = offset; uint nameOrId = reader.ReadUInt32(); uint dataOrDirectory = reader.ReadUInt32(); ResourceName name; if ((nameOrId & 0x80000000) != 0) name = new ResourceName(ReadString(reader, nameOrId & 0x7FFFFFFF) ?? string.Empty); else name = new ResourceName((int)nameOrId); if ((dataOrDirectory & 0x80000000) == 0) dataInfos.Add(new EntryInfo(name, dataOrDirectory)); else dirInfos.Add(new EntryInfo(name, dataOrDirectory & 0x7FFFFFFF)); } directories = new LazyList<ResourceDirectory>(dirInfos.Count, null, (ctx, i) => ReadResourceDirectory((int)i)); data = new LazyList<ResourceData>(dataInfos.Count, null, (ctx, i) => ReadResourceData((int)i)); }