// Toposort 2, node rescanning using a view.
// Uses no method call stack and no extra data structures, but slower.
public static IList <MyNode <T> > Toposort2 <T>(params MyNode <T>[] starts)
{
var sorted = new HashedLinkedList <MyNode <T> >();
foreach (MyNode <T> start in starts)
{
if (!sorted.Contains(start))
{
sorted.InsertLast(start);
using (IList <MyNode <T> > cursor = sorted.View(sorted.Count - 1, 1))
{
do
{
MyNode <T> child;
while ((child = PendingChild(sorted, cursor.First)) != null)
{
cursor.InsertFirst(child);
cursor.Slide(0, 1);
}
}while (cursor.TrySlide(+1));
}
}
}
return(sorted);
}
/*
* This is the central method of the whole Dataflow engine as it executes the patches.
*
* A breath first search over the entire graph is done, starting from the rootSet.
* All patches that have no connected inlets are part of the rootSet.
*
* The algorith is the follow
*
* 1) push all elements from the root set into the execution queue
*
* 2) dequeue a patch from the execution queue
* 3) if execution criteria is met execute it *1
* 4) propagate the values of all changed outlets and add the receiving patches to the discovered set *2 *3
* 5) goto to step 2 if the execution queue is not empty
* 6) move all elements from the discovered set to the execution queue
* 7) goto step 2 if the execution queue is not empty
* 8) finish the frame
*
* *1 right now the only criteria is 'execute allways'
* *2 outlet values propagation and patch enqueuing are done from first to last outlet.
* *3 order of discovery is maintained during execution.
*/
public void StepFrame()
{
LinkedList <IPatchContainer> executionQueue = new LinkedList <IPatchContainer> ();
HashedLinkedList <IPatchContainer> discoveredSet = new HashedLinkedList <IPatchContainer> ();
executionQueue.AddAll(this.rootSet);
do
{
while (executionQueue.Count > 0)
{
IPatchContainer patch = executionQueue.RemoveFirst();
patch.ExecutePatch();
foreach (IOutlet outlet in patch.Outlets)
{
outlet.PropagateChanges(discoveredSet);
}
}
if (discoveredSet.Count > 0)
{
executionQueue.AddAll(discoveredSet);
discoveredSet.Clear();
}
} while (executionQueue.Count > 0);
}
public RendezvousCluster(IConfigurationStorage <RendezvousClusterConfiguration> configurationStorage)
{
this.configurationStorage = configurationStorage;
config = new HashedLinkedList <RendezvousEndpoint>();
config.AddAll(configurationStorage.Read().Cluster);
}
public RendezvousCluster(IConfigurationStorage<RendezvousClusterConfiguration> configurationStorage)
{
this.configurationStorage = configurationStorage;
config = new HashedLinkedList<RendezvousEndpoint>();
config.AddAll(configurationStorage.Read().Cluster);
}
public void Update(RendezvousClusterConfiguration newConfig)
{
var tmp = new HashedLinkedList <RendezvousEndpoint>();
tmp.AddAll(SelectEndpointsDistinct(newConfig.Cluster));
config = tmp;
}
public static void Main()
{
HashedLinkedList <int> .Test(5);
HashedLinkedList <long> list = new HashedLinkedList <long> ();
list.Test(list);
}
public HashedLinkedList <T> CopyToHashedLinkedList <T>(ICollection <T> lst)
{
HashedLinkedList <T> lstCopy = new HashedLinkedList <T>();
foreach (var item in lst)
{
lstCopy.Add((T)item);
}
return(lstCopy);
}
// --- Other view patterns --------------------------------------
// Replace the first occurrence of each x from xs by y in list:
public static void ReplaceXsByY <T>(HashedLinkedList <T> list, T[] xs, T y)
{
foreach (T x in xs)
{
using (IList <T> view = list.ViewOf(x)) {
if (view != null)
{
view.Remove();
view.Add(y);
}
}
}
}
// Toposort 0, adding each node when finished, after its descendants.
// Classic depth-first search. Does not terminate on cyclic graphs.
public static IList <Node <T> > Toposort0 <T>(params Node <T>[] starts)
{
HashedLinkedList <Node <T> > sorted = new HashedLinkedList <Node <T> >();
foreach (Node <T> start in starts)
{
if (!sorted.Contains(start))
{
AddNode0(sorted, start);
}
}
return(sorted);
}
private static IEnumerable <RendezvousEndpoint> SelectEndpointsDistinct(IEnumerable <RendezvousEndpoint> initialConfiguration)
{
var tmp = new HashedLinkedList <RendezvousEndpoint>();
tmp.AddAll(initialConfiguration);
if (tmp.Count < initialConfiguration.Count())
{
throw new DuplicatedKeyException("Initial Rendezvous configuration contains duplicated endpoints!");
}
return(tmp);
}
private void MapMessageToNode(ExternalRouteRegistration routeRegistration, ReceiverIdentifier nodeIdentifier)
{
var messageIdentifier = routeRegistration.Route.Message;
if (!messageToNodeMap.TryGetValue(messageIdentifier, out var nodes))
{
nodes = new HashedLinkedList <ReceiverIdentifier>();
messageToNodeMap[messageIdentifier] = nodes;
}
if (!nodes.Contains(nodeIdentifier))
{
nodes.InsertLast(nodeIdentifier);
}
}
private void MapMessageToActor(InternalRouteRegistration routeRegistration, MessageContract messageContract)
{
if (!messageToActorMap.TryGetValue(messageContract.Message, out var actors))
{
actors = new HashedLinkedList <ReceiverIdentifier>();
messageToActorMap[messageContract.Message] = actors;
}
if (!actors.Contains(routeRegistration.ReceiverIdentifier))
{
var registration = new ReceiverIdentifierRegistration(routeRegistration.ReceiverIdentifier,
messageContract.KeepRegistrationLocal);
actors.InsertLast(registration);
}
}
// Toposort 1, using hash index to add each node before its descendants.
// Terminates also on cyclic graphs.
public static IList <MyNode <T> > Toposort1 <T>(params MyNode <T>[] starts)
{
var sorted = new HashedLinkedList <MyNode <T> >();
foreach (var start in starts)
{
if (!sorted.Contains(start))
{
sorted.InsertLast(start);
AddNode1(sorted, start);
}
}
return(sorted);
}
private static T Get <T>(HashedLinkedList <T> hashSet)
{
var count = hashSet.Count;
if (count > 0)
{
var first = (count > 1) ? hashSet.RemoveFirst() : hashSet.First;
if (count > 1)
{
hashSet.InsertLast(first);
}
return(first);
}
return(default(T));
}
public void Main()
{
var list = new HashedLinkedList <int> {
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59
};
// View of item
list.ViewOf(2);
// Last view of item
list.LastViewOf(11);
// View in range
var view = list.View(0, 3);
// Slide with offset
view.Slide(3);
// Slide with offset and set lenght
view.Slide(-3, 3);
// Try slide with offset and set lenght
var hasSucceed = view.TrySlide(-10, 3);
// Try slide with offset and set lenght
view.TrySlide(3, -3);
var view2 = list.View(0, 3);
var view3 = list.View(1, 3);
// Check if views overlap
Overlap(view2, view3);
// Check if views contained in each other
ContainsView(view2, view3);
// Span views
var spannedView = view2.Span(view3);
// Invalidate all views by shuffle
list.Shuffle();
// Check if view is valid
Console.WriteLine($"View is valid? {view.IsValid}");
}
public static void Main(String[] args) {
HashedLinkedList<int> test = new HashedLinkedList<int>();
for (int i = 0; i < 33; i++) {
test.Add(i);
} // for
// Fails after 7 removals
for (int i = 0; i < 33; i++) {
Console.WriteLine(i);
test.Remove(i);
} // for
// Fails after 23 removals
// for (int i = 32; i >= 0; i--) {
// Console.WriteLine(i);
// test.Remove(i);
// } // for
}
public override void CreateNewInstanceOfInternalC5DataStructure(C5DataStructure dataStructure)
{
switch (dataStructure)
{
case C5DataStructure.ArrayList:
InternalC5DataStructure = new ArrayList <T>();
break;
case C5DataStructure.LinkedList:
InternalC5DataStructure = new LinkedList <T>();
break;
case C5DataStructure.HashBag:
InternalC5DataStructure = new HashBag <T>();
break;
case C5DataStructure.TreeBag:
InternalC5DataStructure = new TreeBag <T>();
break;
case C5DataStructure.HashedArrayList:
InternalC5DataStructure = new HashedArrayList <T>();
break;
case C5DataStructure.HashedLinkedList:
InternalC5DataStructure = new HashedLinkedList <T>();
break;
case C5DataStructure.SortedArray:
InternalC5DataStructure = new SortedArray <T>();
break;
case C5DataStructure.HashSet:
InternalC5DataStructure = new HashSet <T>();
break;
case C5DataStructure.TreeSet:
InternalC5DataStructure = new TreeSet <T>();
break;
default: throw new ArgumentException("Unknown C5 Collection name");
}
}
public void Add(T item, int priority = 0)
{
int oldPriority;
if (sub.UpdateOrAdd(item, priority, out oldPriority))
{
RemoveMain(oldPriority, item);
}
if (reserveList == null)
{
reserveList = new HashedLinkedList <T>(cmp);
}
var list = reserveList;
if (!main.FindOrAdd(priority, ref list))
{
reserveList = null;
}
list.Add(item);
}
public DetailConfiguration()
{
var columns = new ColumnCollection( this.DataGridControl, this );
this.SetColumns( columns );
this.Columns.CollectionChanged += new NotifyCollectionChangedEventHandler( this.OnColumnsCollectionChanged );
VisibilityChangedEventManager.AddListener( this.Columns, this );
this.SetVisibleColumns( new ReadOnlyColumnCollection() );
m_columnsByVisiblePosition = new HashedLinkedList<ColumnBase>();
m_columnSynchronizationManager = new ColumnSynchronizationManager( this );
this.SetHeaders( new ObservableCollection<DataTemplate>() );
this.SetFooters( new ObservableCollection<DataTemplate>() );
this.SetGroupLevelDescriptions( new GroupLevelDescriptionCollection() );
this.SetDetailConfigurations( new DetailConfigurationCollection( this.DataGridControl, this ) );
CollectionChangedEventManager.AddListener( this.DetailConfigurations, this );
}
public static void Main(String[] args)
{
HashedLinkedList <int> test = new HashedLinkedList <int>();
for (int i = 0; i < 33; i++)
{
test.Add(i);
} // for
// Fails after 7 removals
for (int i = 0; i < 33; i++)
{
Console.WriteLine(i);
test.Remove(i);
} // for
// Fails after 23 removals
// for (int i = 32; i >= 0; i--) {
// Console.WriteLine(i);
// test.Remove(i);
// } // for
}
public static void Main()
{
var test = new HashedLinkedList <int>();
for (var i = 0; i < 33; i++)
{
test.Add(i);
}
// Fails after 7 removals
for (var i = 0; i < 33; i++)
{
Console.WriteLine(i);
test.Remove(i);
}
// Fails after 23 removals
for (var i = 32; i >= 0; i--)
{
Console.WriteLine(i);
test.Remove(i);
}
}
public RoundRobinDestinationList(ILogger logger)
{
this.logger = logger;
destinations = new HashedLinkedList <IDestination>();
}
// Returns the visible index of a column by its visible position
internal static int CalculateVisibleIndex( int visiblePosition, HashedLinkedList<ColumnBase> columnsByVisiblePosition )
{
if( columnsByVisiblePosition == null )
return -1;
int visibleIndex = 0;
LinkedListNode<ColumnBase> tempNode = columnsByVisiblePosition.First;
for( int i = 0; i < visiblePosition; i++ )
{
if( tempNode == null )
break;
if( tempNode.Value.Visible )
{
visibleIndex++;
}
tempNode = tempNode.Next;
}
return visibleIndex;
}
public RendezvousClusterConfigurationReadonlyStorage(IEnumerable <RendezvousEndpoint> initialConfiguration)
{
config = new HashedLinkedList <RendezvousEndpoint>();
config.AddAll(SelectEndpointsDistinct(initialConfiguration));
}
public HashedQueue(int maxQueueLength)
{
this.maxQueueLength = maxQueueLength;
collection = new HashedLinkedList <T>();
}
public Recording()
{
Keyframes = new HashedLinkedList <Keyframe>();
}
public bool SelectItemCells(
int itemIndex,
object item,
HashedLinkedList<ColumnBase> columnsByVisiblePosition,
bool preserveSelection )
{
bool selectionDone = true;
int columnsCount = columnsByVisiblePosition.Count;
m_toDeferSelect.Clear();
SelectionCellRangeWithItems rangeWithItemsToSelect =
new SelectionCellRangeWithItems(
new SelectionRange( itemIndex ),
new object[] { item },
new SelectionRange( 0, columnsCount - 1 ) );
SelectionCellRange cellRange = rangeWithItemsToSelect.CellRange;
m_cellsToSelect.Clear();
SelectedCellsStorage selectedCellsInChange = m_owner.SelectedCellsStore;
// Remove all currently selected Cells from the new selectionRange
// to avoid duplicate SelectionCellRange
SelectedCellsStorage tempStorage = new SelectedCellsStorage( null, 1 );
tempStorage.Add( rangeWithItemsToSelect );
for( int i = 0; i < selectedCellsInChange.Count; i++ )
{
tempStorage.Remove( selectedCellsInChange[ i ] );
}
foreach( ColumnBase column in columnsByVisiblePosition )
{
if( !column.Visible )
tempStorage.Remove( new SelectionCellRangeWithItems( itemIndex, item, column.VisiblePosition ) );
}
int tempStorageCount = tempStorage.Count;
// All Cells are already selected
if( tempStorageCount == 0 )
{
if( !m_cellsToUnselect.Contains( cellRange ) )
selectionDone = false;
m_cellsToUnselect.Clear();
if( !preserveSelection )
{
foreach( SelectionCellRangeWithItems selectedCellRangeWithItems in selectedCellsInChange )
{
m_cellsToUnselect.Add( selectedCellRangeWithItems );
}
}
m_cellsToUnselect.Remove( rangeWithItemsToSelect );
}
else
{
// Add each range to selection
for( int i = 0; i < tempStorageCount; i++ )
{
m_cellsToSelect.Add( tempStorage[ i ] );
}
m_cellsToUnselect.Clear();
if( !preserveSelection )
{
foreach( SelectionCellRangeWithItems selectedCellRangeWithItems in selectedCellsInChange )
{
tempStorage = new SelectedCellsStorage( null, 1 );
tempStorage.Add( selectedCellRangeWithItems );
tempStorage.Remove( rangeWithItemsToSelect );
tempStorageCount = tempStorage.Count;
for( int i = 0; i < tempStorageCount; i++ )
{
m_cellsToUnselect.Add( tempStorage[ i ] );
}
}
}
}
if( !preserveSelection )
this.UnselectAllItems();
return selectionDone;
}
public void Test(HashedLinkedList <T> view)
{
view.Offset--;
}
public void Main()
{
// Construct hashed array list using collection initializer
var list = new HashedLinkedList <int> {
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59
};
// Chose from list
list.Choose();
var array = new int[list.Count];
// Copy list to array
list.CopyTo(array, 0);
// Add item to the end of list
list.Add(61);
// Add range to list
array = new[] { 67, 71, 73, 79, 83 };
list.AddRange(array);
// Check if list contains an item
list.Contains(list.Choose());
// Check if list contains all items in enumerable
list.ContainsRange(array);
// Count all occuerence of an item
list.CountDuplicates(list.Choose());
// Find an item in list
var itemToFind = list.Last;
list.Find(ref itemToFind);
// Return all occurence of an item
list.FindDuplicates(itemToFind);
// Remove within range
list.RemoveIndexRange(0, 3);
var range = new[] { list.First, list.Last };
// Remove all items in enumerable from list
list.RemoveRange(range);
// Retain all items in enumarable from list
list.RetainRange(list.ToArray());
var lastItem = list.Last;
// Find last index of an item
list.LastIndexOf(lastItem);
// Insert at the end of list
list.InsertLast(100);
// Insert at the beginning of list
list.InsertFirst(-100);
// Reverse list
list.Reverse();
// Shuffle list
list.Shuffle();
// Sort list
list.Sort();
// Check if list is sorted
var isSorted = list.IsSorted();
// Print all items in list by indexer
var index = 0;
foreach (var item in list)
{
Console.WriteLine($"list[{index++}] = {item}");
}
// Clear list
list.Clear();
}
