public IHasBits AND(IHasBits item)
{
Condition.Requires(item).IsNotNull();
var itemAsInt = item.Bits.GetIntFromBitArray();
var andVal = this._bv.Data & itemAsInt;
return(new NaturalBitVectorHasBits(andVal));
}
public IHasBits AND(IHasBits item)
{
Condition.Requires(item).IsNotNull();
var itemAsInt = item.Bits.GetIntFromBitArray();
var andVal = this._bv.Data & itemAsInt;
return new NaturalBitVectorHasBits(andVal);
}
public IHasBits AND(IHasBits item)
{
Condition.Requires(item).IsNotNull();
var clone = item.Bits.Clone() as BitArray; //we have to clone because the BitArray.And() implementation changes instance state of the BitArray
var andBits = clone.And(item.Bits);
return(new NaturalBitArrayHasBits(andBits));
}
public IHasBits AND(IHasBits item)
{
Condition.Requires(item).IsNotNull();
var clone = item.Bits.Clone() as BitArray; //we have to clone because the BitArray.And() implementation changes instance state of the BitArray
var andBits = clone.And(item.Bits);
return new NaturalBitArrayHasBits(andBits);
}
public static Func <IHasBits, bool> BuildIsEquivalentToLogic(this IHasBits hasbits)
{
Func <IHasBits, bool> filter = (x) =>
{
return(x.Bits.AreEquivalent_IntCompare(hasbits.Bits));
};
return(filter);
}
public IHasBits AND(IHasBits item)
{
Condition.Requires(item).IsNotNull();
var clone = this.Bits.Clone() as BitArray;
var andBits = clone.And(item.Bits);
return(new NaturalBoolArrayHasBits(andBits));
}
public IHasBits AND(IHasBits item)
{
Condition.Requires(item).IsNotNull();
var clone = this.Bits.Clone() as BitArray;
var andBits = clone.And(item.Bits);
return new NaturalBoolArrayHasBits(andBits);
}
/// <summary>
/// returns true if the (item AND hasBits) == hasbits. In other words, if the original mask has an ON bit
/// @ position N, and the item shares this ON bit at the same position, the ANDed bit is also ON at position N.
/// This is a masking function. It returns those things that share the same ON bits as the mask. This is not equivalence,
/// which is when things share the same ON bits and OFF bits as the mask.
/// </summary>
/// <param name="hasbits"></param>
/// <returns></returns>
public static Func <IHasBits, bool> BuildANDLogic(this IHasBits hasbits)
{
Func <IHasBits, bool> filter = (x) =>
{
var newBits = x.AND(hasbits);
return(hasbits.Bits.AreEquivalent_IntCompare(newBits.Bits));
};
return(filter);
}
private IHasBits _hasBits; //uses backing field to wrap
#endregion
#region Ctor
/// <summary>
///
/// </summary>
/// <param name="decorated"></param>
/// <param name="hasBits">if null will default to 32bit BitArrayHasBits instance</param>
public HasBitsIHasIdDecoration(IHasId decorated, IHasBits hasBits = null)
: base(decorated)
{
if (hasBits != null)
{
this._hasBits = hasBits;
}
else
{
this._hasBits = NaturalBitArrayHasBits.New(new BitArray(32));
}
}
private IHasBits _hasBits; //uses backing field to wrap
#endregion
#region Ctor
/// <summary>
///
/// </summary>
/// <param name="decorated"></param>
/// <param name="hasBits">if null will default to 32bit BitArrayHasBits instance</param>
public HasBitsIHasIdDecoration(IHasId decorated, IHasBits hasBits = null)
: base(decorated)
{
if (hasBits != null)
{
this._hasBits = hasBits;
}
else
{
this._hasBits = NaturalBitArrayHasBits.New(new BitArray(32));
}
}
public void Func()
{
for (int i = Start; i < End; i++)
{
IHasBits item = this.SourceList[i];
if (Filter(item))
{
//lock (this._stateLock)
//{
Accumulator.Add(item);
//}
}
}
}
public IHasBits AND(IHasBits item)
{
Condition.Requires(item).IsNotNull();
//var andBits = item.Bits.And(item.Bits);
if (item is NaturalIntHasBits)
{
var itemAsInt = item.Bits.GetIntFromBitArray();
var andVal = this._val & (item as NaturalIntHasBits)._val;
return(new NaturalIntHasBits(andVal));
}
else
{
var itemAsInt = item.Bits.GetIntFromBitArray();
var andVal = this._val & itemAsInt;
return(new NaturalIntHasBits(andVal));
}
}
public IHasBits AND(IHasBits item)
{
Condition.Requires(item).IsNotNull();
//var andBits = item.Bits.And(item.Bits);
if (item is NaturalIntHasBits)
{
var itemAsInt = item.Bits.GetIntFromBitArray();
var andVal = this._val & (item as NaturalIntHasBits)._val;
return new NaturalIntHasBits(andVal);
}
else
{
var itemAsInt = item.Bits.GetIntFromBitArray();
var andVal = this._val & itemAsInt;
return new NaturalIntHasBits(andVal);
}
}
/// <summary>
/// decorates with bits
/// </summary>
/// <param name="decorated"></param>
/// <param name="bits"></param>
/// <returns></returns>
public static HasBitsIHasIdDecoration HasBits(this IHasId decorated, IHasBits bits = null)
{
Condition.Requires(decorated).IsNotNull();
return(new HasBitsIHasIdDecoration(decorated, bits));
}
/// <summary>
/// decorates with bits
/// </summary>
/// <param name="decorated"></param>
/// <param name="bits"></param>
/// <returns></returns>
public static HasBitsIHasIdDecoration HasBits(this IHasId decorated, IHasBits bits = null)
{
Condition.Requires(decorated).IsNotNull();
return new HasBitsIHasIdDecoration(decorated, bits);
}
IHasBits IHasBits.AND(IHasBits bits) { return this._hasBits.AND(bits); }
protected HasBitsIHasIdDecoration(SerializationInfo info, StreamingContext context)
: base(info, context)
{
this._hasBits = NaturalBitArrayHasBits.New(new BitArray(info.GetValue("_hasBits", typeof(bool[])) as bool[]));
}
IHasBits IHasBits.AND(IHasBits bits)
{
return(this._hasBits.AND(bits));
}
protected HasBitsIHasIdDecoration(SerializationInfo info, StreamingContext context)
: base(info, context)
{
this._hasBits = NaturalBitArrayHasBits.New(new BitArray(info.GetValue("_hasBits", typeof(bool[])) as bool[]));
}
