ConcurrentOrderedList.cs System::Collections::Concurrent::ConcurrentOrderedList System::Collections::Concurrent::ConcurrentOrderedList::Node System System::Collections System::Collections::Concurrent //ConcurrentOrderedList.cs // //Copyright(c)2010Jérémie"Garuma"Laval // //Permissionisherebygranted,freeofcharge,toanypersonobtainingacopy //ofthissoftwareandassociateddocumentationfiles(the"Software"),todeal //intheSoftwarewithoutrestriction,includingwithoutlimitationtherights //touse,copy,modify,merge,publish,distribute,sublicense,and/orsell //copiesoftheSoftware,andtopermitpersonstowhomtheSoftwareis //furnishedtodoso,subjecttothefollowingconditions: // //Theabovecopyrightnoticeandthispermissionnoticeshallbeincludedin //allcopiesorsubstantialportionsoftheSoftware. // //THESOFTWAREISPROVIDED"ASIS",WITHOUTWARRANTYOFANYKIND,EXPRESSOR //IMPLIED,INCLUDINGBUTNOTLIMITEDTOTHEWARRANTIESOFMERCHANTABILITY, //FITNESSFORAPARTICULARPURPOSEANDNONINFRINGEMENT.INNOEVENTSHALLTHE //AUTHORSORCOPYRIGHTHOLDERSBELIABLEFORANYCLAIM,DAMAGESOROTHER //LIABILITY,WHETHERINANACTIONOFCONTRACT,TORTOROTHERWISE,ARISINGFROM, //OUTOFORINCONNECTIONWITHTHESOFTWAREORTHEUSEOROTHERDEALINGSIN //THESOFTWARE. // // #ifNET_4_0||UNITY_5_3_OR_NEWER usingSystem; usingSystem.Threading; usingSystem.Collections; usingSystem.Collections.Generic; usingSystem.Runtime.Serialization; #ifINSIDE_MONO_PARALLEL usingSystem.Collections.Concurrent; namespaceMono.Collections.Concurrent #else namespaceSystem.Collections.Concurrent #endif { #ifINSIDE_MONO_PARALLEL public #endif classConcurrentOrderedList<T>:ICollection<T>,IEnumerable<T> { classNode { publicTData; publicintKey; publicNodeNext; publicboolMarked; publicNode() { } publicNode(Nodewrapped) { Marked=true; Next=wrapped; } } Nodehead; Nodetail; IEqualityComparer<T>comparer; intcount; publicConcurrentOrderedList():this(EqualityComparer<T>.Default) { } publicConcurrentOrderedList(IEqualityComparer<T>comparer) { if(comparer==null) thrownewArgumentNullException("comparer"); this.comparer=comparer; head=newNode(); tail=newNode(); head.Next=tail; } publicboolTryAdd(Tdata) { Nodenode=newNode(); node.Data=data; node.Key=comparer.GetHashCode(data); if(ListInsert(node)){ Interlocked.Increment(refcount); returntrue; } returnfalse; } publicboolTryRemove(Tdata) { Tdummy; returnTryRemoveHash(comparer.GetHashCode(data),outdummy); } publicboolTryRemoveHash(intkey,outTdata) { if(ListDelete(key,outdata)){ Interlocked.Decrement(refcount); returntrue; } returnfalse; } publicboolTryPop(outTdata) { returnListPop(outdata); } publicboolContains(Tdata) { returnContainsHash(comparer.GetHashCode(data)); } publicboolContainsHash(intkey) { Nodenode; if(!ListFind(key,outnode)) returnfalse; returntrue; } publicboolTryGetFromHash(intkey,outTdata) { data=default(T); Nodenode; if(!ListFind(key,outnode)) returnfalse; data=node.Data; returntrue; } publicvoidClear() { head.Next=tail; } publicvoidCopyTo(T[]array,intstartIndex) { if(array==null) thrownewArgumentNullException("array"); if(startIndex<0) thrownewArgumentOutOfRangeException("startIndex"); if(count>array.Length-startIndex) thrownewArgumentException("array","ThenumberofelementsisgreaterthantheavailablespacefromstartIndextotheendofthedestinationarray."); foreach(Titeminthis){ if(startIndex>=array.Length) break; array[startIndex++]=item; } } publicIEqualityComparer<T>Comparer{ get{ returncomparer; } } publicintCount{ get{ returncount; } } NodeListSearch(intkey,refNodeleft) { NodeleftNodeNext=null,rightNode=null; do{ Nodet=head; NodetNext=t.Next; do{ if(!tNext.Marked){ left=t; leftNodeNext=tNext; } t=tNext.Marked?tNext.Next:tNext; if(t==tail) break; tNext=t.Next; }while(tNext.Marked||t.Key<key); rightNode=t; if(leftNodeNext==rightNode){ if(rightNode!=tail&&rightNode.Next.Marked) continue; else returnrightNode; } if(AotInterlocked.CompareExchange(refleft.Next,rightNode,leftNodeNext)==leftNodeNext){ if(rightNode!=tail&&rightNode.Next.Marked) continue; else returnrightNode; } }while(true); } boolListDelete(intkey,outTdata) { NoderightNode=null,rightNodeNext=null,leftNode=null; data=default(T); do{ rightNode=ListSearch(key,refleftNode); if(rightNode==tail||rightNode.Key!=key) returnfalse; data=rightNode.Data; rightNodeNext=rightNode.Next; if(!rightNodeNext.Marked) if(AotInterlocked.CompareExchange(refrightNode.Next,newNode(rightNodeNext),rightNodeNext)==rightNodeNext) break; }while(true); if(AotInterlocked.CompareExchange(refleftNode.Next,rightNodeNext,rightNode)!=rightNodeNext) ListSearch(rightNode.Key,refleftNode); returntrue; } boolListPop(outTdata) { NoderightNode=null,rightNodeNext=null,leftNode=head; data=default(T); do{ rightNode=head.Next; if(rightNode==tail) returnfalse; data=rightNode.Data; rightNodeNext=rightNode.Next; if(!rightNodeNext.Marked) if(AotInterlocked.CompareExchange(refrightNode.Next,newNode(rightNodeNext),rightNodeNext)==rightNodeNext) break; }while(true); if(AotInterlocked.CompareExchange(refleftNode.Next,rightNodeNext,rightNode)!=rightNodeNext) ListSearch(rightNode.Key,refleftNode); returntrue; } boolListInsert(NodenewNode) { intkey=newNode.Key; NoderightNode=null,leftNode=null; do{ rightNode=ListSearch(key,refleftNode); if(rightNode!=tail&&rightNode.Key==key) returnfalse; newNode.Next=rightNode; if(AotInterlocked.CompareExchange(refleftNode.Next,newNode,rightNode)==rightNode) returntrue; }while(true); } boolListFind(intkey,outNodedata) { NoderightNode=null,leftNode=null; data=null; data=rightNode=ListSearch(key,refleftNode); returnrightNode!=tail&&rightNode.Key==key; } IEnumerator<T>IEnumerable<T>.GetEnumerator() { returnGetEnumeratorInternal(); } IEnumeratorIEnumerable.GetEnumerator() { returnGetEnumeratorInternal(); } IEnumerator<T>GetEnumeratorInternal() { Nodenode=head.Next; while(node!=tail){ while(node.Marked){ node=node.Next; if(node==tail) yieldbreak; } yieldreturnnode.Data; node=node.Next; } } boolICollection<T>.IsReadOnly{ get{ returnfalse; } } voidICollection<T>.Add(Titem) { TryAdd(item); } boolICollection<T>.Remove(Titem) { returnTryRemove(item); } } } #endif