public object __copy__(CodeContext /*!*/ context)
{
if (GetType() == typeof(deque))
{
deque res = new deque(_maxLen);
res.extend(((IEnumerable)this).GetEnumerator());
return(res);
}
else
{
return(PythonCalls.Call(context, DynamicHelpers.GetPythonType(this), ((IEnumerable)this).GetEnumerator()));
}
}
private bool EqualsWorker(deque otherDeque, IEqualityComparer comparer = null)
{
Assert.NotNull(otherDeque);
if (otherDeque._itemCnt != _itemCnt)
{
// number of items is different, deques can't be equal
return(false);
}
else if (otherDeque._itemCnt == 0)
{
// two empty deques are equal
return(true);
}
if (CompareUtil.Check(this))
{
return(true);
}
CompareUtil.Push(this);
try {
int otherIndex = otherDeque._head;
return(WalkDeque(ourIndex => {
bool result;
var ourData = _data[ourIndex];
var otherData = otherDeque._data[otherIndex];
if (comparer == null)
{
result = PythonOps.IsOrEqualsRetBool(ourData, otherData);
}
else
{
result = ReferenceEquals(ourData, otherData) || comparer.Equals(ourData, otherData);
}
if (!result)
{
return false;
}
otherIndex++;
if (otherIndex == otherDeque._data.Length)
{
otherIndex = 0;
}
return true;
}));
} finally {
CompareUtil.Pop(this);
}
}
public _deque_iterator(deque d, int index = 0)
{
lock (d._lockObj) {
// clamp index to range
if (index < 0)
{
index = 0;
}
else if (index > d._itemCnt)
{
index = d._itemCnt;
}
_deque = d;
_curIndex = IndexToRealIndex(index) - 1;
_moveCnt = index;
_version = d._version;
}
}
private bool EqualsWorker(deque other)
{
return(EqualsWorker(other, null));
}
private int CompareToWorker(deque otherDeque, IComparer comparer)
{
Assert.NotNull(otherDeque);
if (otherDeque._itemCnt == 0 && _itemCnt == 0)
{
// comparing two empty deques
return(0);
}
if (CompareUtil.Check(this))
{
return(0);
}
CompareUtil.Push(this);
try {
int otherIndex = otherDeque._head, ourIndex = _head;
for (; ;)
{
int result;
if (comparer == null)
{
result = PythonOps.Compare(_data[ourIndex], otherDeque._data[otherIndex]);
}
else
{
result = comparer.Compare(_data[ourIndex], otherDeque._data[otherIndex]);
}
if (result != 0)
{
return(result);
}
// advance both indexes
otherIndex++;
if (otherIndex == otherDeque._data.Length)
{
otherIndex = 0;
}
if (otherIndex == otherDeque._tail)
{
break;
}
ourIndex++;
if (ourIndex == _data.Length)
{
ourIndex = 0;
}
if (ourIndex == _tail)
{
break;
}
}
// all items are equal, but # of items may be different.
if (otherDeque._itemCnt == _itemCnt)
{
// same # of items, all items are equal
return(0);
}
return(_itemCnt > otherDeque._itemCnt ? 1 : -1);
} finally {
CompareUtil.Pop(this);
}
}
private int CompareToWorker(deque otherDeque)
{
return(CompareToWorker(otherDeque, null));
}
private bool EqualsWorker(deque otherDeque, IEqualityComparer comparer) {
Assert.NotNull(otherDeque);
if (otherDeque._itemCnt != _itemCnt) {
// number of items is different, deques can't be equal
return false;
} else if (otherDeque._itemCnt == 0) {
// two empty deques are equal
return true;
}
if (CompareUtil.Check(this)) return true;
CompareUtil.Push(this);
try {
for (int otherIndex = otherDeque._head, ourIndex = _head; ourIndex != _tail; ) {
bool result;
if (comparer == null) {
result = PythonOps.EqualRetBool(_data[ourIndex], otherDeque._data[otherIndex]);
} else {
result = comparer.Equals(_data[ourIndex], otherDeque._data[otherIndex]);
}
if (!result) {
return false;
}
// advance both indices
otherIndex++;
if (otherIndex == otherDeque._data.Length) {
otherIndex = 0;
}
ourIndex++;
if (ourIndex == _data.Length) {
ourIndex = 0;
}
}
// same # of items, all items are equal
return true;
} finally {
CompareUtil.Pop(this);
}
}
private bool EqualsWorker(deque other) {
return EqualsWorker(other, null);
}
public deque_reverse_iterator(deque d) {
lock (d._lockObj) {
_deque = d;
_curIndex = d._tail;
_version = d._version;
}
}
public DequeIterator(deque d) {
lock (d._lockObj) {
_deque = d;
_curIndex = d._head - 1;
_version = d._version;
}
}
private int CompareToWorker(deque otherDeque, IComparer comparer) {
Assert.NotNull(otherDeque);
if (otherDeque._itemCnt == 0 && _itemCnt == 0) {
// comparing two empty deques
return 0;
}
if (CompareUtil.Check(this)) return 0;
CompareUtil.Push(this);
try {
int otherIndex = otherDeque._head, ourIndex = _head;
for (; ; ) {
int result;
if (comparer == null) {
result = PythonOps.Compare(_data[ourIndex], otherDeque._data[otherIndex]);
} else {
result = comparer.Compare(_data[ourIndex], otherDeque._data[otherIndex]);
}
if (result != 0) {
return result;
}
// advance both indexes
otherIndex++;
if (otherIndex == otherDeque._data.Length) {
otherIndex = 0;
}
if (otherIndex == otherDeque._tail) {
break;
}
ourIndex++;
if (ourIndex == _data.Length) {
ourIndex = 0;
}
if (ourIndex == _tail) {
break;
}
}
// all items are equal, but # of items may be different.
if (otherDeque._itemCnt == _itemCnt) {
// same # of items, all items are equal
return 0;
}
return _itemCnt > otherDeque._itemCnt ? 1 : -1;
} finally {
CompareUtil.Pop(this);
}
}
private int CompareToWorker(deque otherDeque) {
return CompareToWorker(otherDeque, null);
}
public object __copy__(CodeContext/*!*/ context) {
if (GetType() == typeof(deque)) {
deque res = new deque(_maxLen);
res.extend(((IEnumerable)this).GetEnumerator());
return res;
} else {
return PythonCalls.Call(context, DynamicHelpers.GetPythonType(this), ((IEnumerable)this).GetEnumerator());
}
}
