# A concurrent variant to the standard `Sequence`
abstract class ConcurrentSequence[E]
	super ConcurrentSequenceRead[E]
	super Sequence[E]

	redef type REAL: Sequence[E]

	redef fun []=(index, e)
	do
		mutex.lock
		real_collection[index] = e
		mutex.unlock
	end

	redef fun add(e)
	do
		mutex.lock
		real_collection.add e
		mutex.unlock
	end

	redef fun append(e)
	do
		mutex.lock
		real_collection.append e
		mutex.unlock
	end

	redef fun first=(e)
	do
		mutex.lock
		real_collection.first = e
		mutex.unlock
	end

	redef fun insert(e, i)
	do
		mutex.lock
		real_collection.insert(e, i)
		mutex.unlock
	end

	redef fun insert_all(from, pos)
	do
		mutex.lock
		real_collection
		mutex.unlock
	end

	redef fun last=(e)
	do
		mutex.lock
		real_collection.last = e
		mutex.unlock
	end

	redef fun pop
	do
		mutex.lock
		var r = real_collection.pop
		mutex.unlock
		return r
	end

	redef fun prepend(e)
	do
		mutex.lock
		real_collection.prepend e
		mutex.unlock
	end

	redef fun push(e)
	do
		mutex.lock
		real_collection.push e
		mutex.unlock
	end

	redef fun remove_at(index)
	do
		mutex.lock
		real_collection.remove_at(index)
		mutex.unlock
	end

	redef fun shift
	do
		mutex.lock
		var r = real_collection.shift
		mutex.unlock
		return r
	end

	redef fun unshift(e)
	do
		mutex.lock
		real_collection.unshift(e)
		mutex.unlock
	end

	redef fun subarray(start, len)
	do
		mutex.lock
		var r = real_collection.subarray(start, len)
		mutex.unlock
		return r
	end
end