public void When_ToString_is_called_Then_it_contains_a_number_of_counted_items()
{
var counter = new RefCounter <Item>();
Assert.That(counter.ToString().Contains("0"), Is.True);
counter.Retain(new Item());
Assert.That(counter.ToString().Contains("1"), Is.True);
}
public void When_few_items_are_retained_Then_count_is_incremented_appropriately()
{
var counter = new RefCounter <Item>();
counter.Retain(new Item());
counter.Retain(new Item());
counter.Retain(new Item());
Assert.That(counter.Count, Is.EqualTo(3));
}
public void Dispose()
{
if (_machine != null)
{
_machine._refCount--;
var count = _machine._refCount;
var machine = _machine;
var evt = _machine.CountChanged;
_machine = null;
evt?.Invoke(machine, count);
}
}
private SharedMemoryStream(object @lock, RefCounter refCounter, MemoryStream internalMemoryStream)
{
_lock = @lock;
lock (_lock)
{
_refCounter = refCounter;
_internalMemoryStream = internalMemoryStream;
_refCounter.Count++;
}
}
public static void ExplodeCommonPic(string commonPicArc, string outDir, SplitCommonPicArgs opFlags)
{
string idxFileName = Path.ChangeExtension(commonPicArc, ".idx");
string pictureDir = null;
RefCounter completionCount = new RefCounter();
if ((opFlags & SplitCommonPicArgs.OutputPngPicture) != 0)
{
pictureDir = Path.Combine(outDir, "pictures");
Directory.CreateDirectory(pictureDir);
}
int numIdxEntries;
using (FileStream packFile = File.OpenRead(commonPicArc))
using (FileStream idxFile = File.OpenRead(idxFileName))
using (BinaryReader idxFileRead = new BinaryReader(idxFile))
{
long packFileSize = packFile.Length;
numIdxEntries = idxFileRead.ReadInt32();
int startPoint = idxFileRead.ReadInt32();
StringBuilder outFileName = new StringBuilder(outDir);
outFileName.Append(Path.DirectorySeparatorChar);
int fileNameStart = outFileName.Length;
for (int i = 0; i < numIdxEntries; ++i)
{
int endPoint = idxFileRead.ReadInt32();
int len = endPoint - startPoint;
byte[] buffer = new byte[len];
packFile.Position = startPoint;
packFile.Read(buffer, 0, len);
outFileName.Length = fileNameStart;
outFileName.Append(i.ToString() + ".gtmp");
AsyncWriteState aws = new AsyncWriteState();
FileStream outFile = new FileStream(outFileName.ToString(), FileMode.Create, FileAccess.ReadWrite, FileShare.None, UInt16.MaxValue, true);
aws.file = outFile;
aws.data = buffer;
aws.ops = opFlags;
aws.completionCount = completionCount;
if ((opFlags & SplitCommonPicArgs.OutputPngPicture) != 0)
{
aws.picFileName = Path.Combine(pictureDir, i.ToString() + ".gtmp.png");
}
outFile.BeginWrite(buffer, 0, len, new AsyncCallback(WriteComplete), aws);
startPoint = endPoint;
}
}
while (!completionCount.HasReached(numIdxEntries))
{
System.Threading.Thread.Sleep(100);
}
}
private void WithUnlock(T name, Func <RefCounter, int> unlockAction)
{
Monitor.Enter(_locks);
{
RefCounter refCounter = null;
_locks.TryGetValue(name, out refCounter);
if (refCounter != null)
{
if (0 == unlockAction(refCounter))
{
_locks.Remove(name);
}
}
}
Monitor.Exit(_locks);
}
private static bool InitializeFromTypeCastParameter(ExpressionSyntax variable, SemanticModel semanticModel, CancellationToken cancellationToken, out IParameterSymbol paramSymbol)
{
paramSymbol = null;
if (variable is CastExpressionSyntax cast)
{
if (cast.Expression is IdentifierNameSyntax id)
{
var symbol = semanticModel.GetSymbolInfo(id, cancellationToken);
if (symbol.Symbol is IParameterSymbol local)
{
paramSymbol = local;
return(!RefCounter.IsAssignableTo(local.Type));
}
}
}
return(false);
}
private IDisposable WithLock(T name, Func <RefCounter, int> lockAction, Func <RefCounter, int> unlockAction)
{
Monitor.Enter(_locks);
RefCounter refCounter = null;
_locks.TryGetValue(name, out refCounter);
if (refCounter == null)
{
refCounter = new RefCounter();
lockAction(refCounter);
_locks.Add(name, refCounter);
Monitor.Exit(_locks);
}
else
{
Monitor.Exit(_locks);
lockAction(refCounter);
}
return(new Token(() => WithUnlock(name, unlockAction)));
}
private static RefCounter <Item> Create()
{
var counter = new RefCounter <Item>();
counter.FirstTimeRetained += i => {
i.FirstTimeRetained++;
};
counter.Incremented += i => {
i.Incremented++;
};
counter.Decremented += i => {
i.Decremented++;
};
counter.Released += i => {
i.Released++;
};
return(counter);
}
public Ref(T item, RefCounter counter)
{
_item = item;
_counter = counter;
}
public void When_RefCounter_is_created_Then_it_is_empty()
{
var counter = new RefCounter <Item>();
Assert.That(counter.Count, Is.Zero);
}
protected EntityMap()
{
_entities = new MyDictionary <EntityKey, IGameEntity>(1024, new EntityKeyComparer());
_refCounter = new RefCounter(OnCleanUp, this);
}
public Handle(RefCounter machine)
{
_machine = machine;
_machine._refCount++;
_machine.CountChanged?.Invoke(_machine, _machine._refCount);
}
public Token(RefCounter <T> counter)
{
this.counter = counter;
lock (counter)
counter.count++;
}
