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));
}
