Welcome to the Lounge

honey the codewitch wrote:

What's your least favorite part about living in Canada, for those of you that do or have?

public abstract class IndexedSet<TYPE_KEY extends Object,TYPE_DATA extends Object> {
	//this class implements the ArrayList<TYPE_DATA> interface but was omitted due to length

	private HashMap<TYPE_KEY,TYPE_DATA > cells;
}

public abstract class IndexedSequence<TYPE_KEY extends Object,TYPE_DATA extends Object> extends IndexedSet<TYPE_KEY,TYPE_DATA>{
	
	private ArrayList<TYPE_KEY> cellsOrder;

	public Entry<TYPE_KEY, TYPE_DATA> get(int pos) {
		TYPE_KEY k=cellsOrder.get(pos);
		return new Pair<TYPE_KEY, TYPE_DATA>(k,internal().get(k));
	}
}

public abstract class TableCore<TYPE_KEY extends Object,TYPE_DATA extends Object>{
	/**
	 * Method to get the TYPE_DATA key.
	 * Must be overridden by the class that implements a specific table.
	 * 
	 * @param r is the instance of TYPE_DATA
	 * @return the key of the given instance
	 */
	protected abstract TYPE_KEY getKey(TYPE_ROW r);
//the above method is used anywhere a key is needed in this class
}

public class TableBasic<TYPE_DATA extends Object> extends TableCore<Integer, TYPE_DATA>{
	
	@Override
	protected Integer getKey(TYPE_DATA r) {
		return r.hashCode();
	}
}

public class Table extends TableCore<UUID, TYPE_DATA extends MyData>{
	
	@Override
	protected UUID getKey(TYPE_DATA r) {
		return r.id();
	}
}

public struct FATransition : IComparable<FATransition>
{
    public int Min; // -1 for Epsilon
    public int Max; // -1 for Epsilon
    public FA To;
    public FATransition(int min, int max, FA to)
    {
        if (max < min)
            throw new ArgumentOutOfRangeException(nameof(max));
        Min = min;
        Max = max;
        To = to;
    }
    public FATransition(FA to)
    {
        Min = Max = -1;
        To = to;
    }
    public int CompareTo(FATransition other)
    {
        var c = Min.CompareTo(other.Min);
        if (c != 0) return c;
        return Max.CompareTo(other.Max);
    }
}
public class FA : ICollection<FATransition>
{
    List<FATransition> _transitions = new List<FATransition>();

    public bool IsDeterministic { get; private set; } = true;

    int FindIndex(int min)
    {
        int iMin = 0, iMax = _transitions.Count;
        while (iMin + 1 < iMax)
        {
            int i = (iMin + iMax) / 2;
            var t = _transitions[i];

            if (t.Min >= min)
                iMax = i;
            else
                iMin = i;
        }
        return iMin;
    }

    public void Add(FATransition item)
    {
        int start = FindIndex(item.Min);
        for (int i = _transitions.Count - 1; i >= start; i--)
        {
            var t = _transitions[i];
            if (t.To == item.To && t.Min <= item.Max)
            {
                item.Max = t.Max;
                _transitions.RemoveAt(i);
            }
            else if (t.To != item.To && t.Min <= item.Max && t.Max > item.Min)
            {
                IsDeterministic = false;
            }
        }
        _transitions.Insert(start, item);
    }

    bool ICollection<FATransition>.Remove(FATransition item)
        => throw new NotSupportedException();

    public int Count => _transitions.Count;

    bool ICollection<FATransition>.IsReadOnly => false;

    public void Clear()
    {
        _transitions.Clear();
        IsDeterministic = true;
    }

    public bool Contains(FATransition item) => _transitions.Contains(item);

    public void CopyTo(FATransition[] array, int arrayIndex)
        => _transitions.CopyTo(array, arrayIndex);

    public IEnumerator<FATransition> GetEnumerator() => _transitions.GetEnumerator();

    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}