public async Task <bool> Contains(OfferCancel of, bool first = true, int limit = 20, int count = 0)
{
if (count == limit)
{
return(false);
}
count++;
if (first && await Pool.Contains(of))
{
return(true);
}
if (CurrentBlock != null)
{
if (CurrentBlock.OffersCancelDictionary.ContainsKey(of.HashStr))
{
return(true);
}
if (Previous != null)
{
return(await Previous.Contains(of, false, limit, count));
}
}
return(false);
}
public async Task <bool> Contains(Withdrawal wd, bool first = true, int limit = 20, int count = 0)
{
if (count == limit)
{
return(false);
}
count++;
if (first && await Pool.Contains(wd))
{
return(true);
}
if (CurrentBlock != null)
{
if (CurrentBlock.WithdrawalsDictionary.ContainsKey(wd.HashStr))
{
return(true);
}
if (Previous != null)
{
return(await Previous.Contains(wd, false, limit, count));
}
}
return(false);
}
public async Task <bool> Contains(Deposit dp, bool first = true, int limit = 20, int count = 0)
{
if (count == limit)
{
return(false);
}
count++;
if (first && await Pool.Contains(dp))
{
return(true);
}
if (CurrentBlock != null)
{
if (CurrentBlock.DepositsDictionary.ContainsKey(dp.HashStr))
{
return(true);
}
if (Previous != null)
{
return(await Previous.Contains(dp, false, limit, count));
}
}
return(false);
}
public void SetPreviousProcessor(IProcessor prev)
{
if (!Previous.Contains(prev) && prev != null)
{
Previous.Add(prev);
}
}
public void AddPrevious(List <T> previous)
{
for (int i = 0; i < previous.Count; i++)
{
if (!Previous.Contains(previous[i]))
{
Previous.Add(previous[i]);
}
}
}
public void AddPrevious(params T[] previous)
{
for (int i = 0; i < previous.Length; i++)
{
if (!Previous.Contains(previous[i]))
{
Previous.Add(previous[i]);
}
}
}
public void SetPreviousProcessor(IProcessor prev)
{
if (Previous == null)
{
Previous = new List <IProcessor>();
}
if (prev != null && prev is IProcessor && !Previous.Contains(prev as IProcessor))
{
Previous.Add(prev as IProcessor);
}
}
public bool Contains(Block block)
{
if (CurrentBlock != null)
{
if (CurrentBlock.HashStr == block.HashStr)
{
return(true);
}
if (Previous != null)
{
return(Previous.Contains(block));
}
}
return(false);
}
public async Task <bool> Contains(Withdrawal wd, bool first = true)
{
if (first && await Pool.Contains(wd))
{
return(true);
}
if (CurrentBlock != null)
{
if (CurrentBlock.WithdrawalsDictionary.ContainsKey(wd.HashStr))
{
return(true);
}
if (Previous != null)
{
return(await Previous.Contains(wd, false));
}
}
return(false);
}
public async Task <bool> Contains(OfferCancel of, bool first = true)
{
if (first && await Pool.Contains(of))
{
return(true);
}
if (CurrentBlock != null)
{
if (CurrentBlock.OffersCancelDictionary.ContainsKey(of.HashStr))
{
return(true);
}
if (Previous != null)
{
return(await Previous.Contains(of, false));
}
}
return(false);
}
public async Task <bool> Contains(Offer of, bool first = true)
{
if (first && (await Pool.Contains(of) || BookManager.ContainsOffer(of)))
{
return(true);
}
if (CurrentBlock != null)
{
if (CurrentBlock.OffersDictionary.ContainsKey(of.HashStr))
{
return(true);
}
if (Previous != null)
{
return(await Previous.Contains(of, false));
}
}
return(false);
}
public async Task <bool> Contains(Deposit dp, bool first = true)
{
if (first && await Pool.Contains(dp))
{
return(true);
}
if (CurrentBlock != null)
{
if (CurrentBlock.DepositsDictionary.ContainsKey(dp.HashStr))
{
return(true);
}
if (Previous != null)
{
return(await Previous.Contains(dp, false));
}
}
return(false);
}
public async Task <bool> Contains(Transaction tx, bool first = true)
{
if (first && await Pool.Contains(tx))
{
return(true);
}
if (CurrentBlock != null)
{
if (CurrentBlock.TransactionsDictionary.ContainsKey(tx.HashStr))
{
return(true);
}
if (Previous != null)
{
return(await Previous.Contains(tx, false));
}
}
return(false);
}
public bool Contains(Block block, int limit = 20, int count = 0)
{
if (count == limit)
{
return(false);
}
count++;
if (CurrentBlock != null)
{
if (CurrentBlock.HashStr == block.HashStr)
{
return(true);
}
if (Previous != null)
{
return(Previous.Contains(block, limit, count));
}
}
return(false);
}
