Code:
/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / whidbey / netfxsp / ndp / fx / src / Xml / System / Xml / schema / BitSet.cs / 1 / BitSet.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
//-----------------------------------------------------------------------------
namespace System.Xml.Schema {
using System.Text;
using System.Diagnostics;
internal sealed class BitSet {
private const int bitSlotShift = 5;
private const int bitSlotMask = (1 << bitSlotShift) - 1;
private int count;
private uint[] bits;
private BitSet() {
}
public BitSet(int count) {
this.count = count;
bits = new uint[Subscript(count + bitSlotMask)];
}
public int Count {
get { return count; }
}
public bool this[int index] {
get {
return Get(index);
}
}
public void Clear() {
int bitsLength = bits.Length;
for (int i = bitsLength; i-- > 0 ;) {
bits[i] = 0;
}
}
public void Clear(int index) {
int nBitSlot = Subscript(index);
EnsureLength(nBitSlot + 1);
bits[nBitSlot] &= ~((uint)1 << (index & bitSlotMask));
}
public void Set(int index) {
int nBitSlot = Subscript(index);
EnsureLength(nBitSlot + 1);
bits[nBitSlot] |= (uint)1 << (index & bitSlotMask);
}
public bool Get(int index) {
bool fResult = false;
if (index < count) {
int nBitSlot = Subscript(index);
fResult = ((bits[nBitSlot] & (1 << (index & bitSlotMask))) != 0);
}
return fResult;
}
public int NextSet(int startFrom) {
Debug.Assert(startFrom >= -1 && startFrom <= count);
int offset = startFrom + 1;
if (offset == count) {
return -1;
}
int nBitSlot = Subscript(offset);
offset &= bitSlotMask;
uint word = bits[nBitSlot] >> offset;
// locate non-empty slot
while (word == 0) {
if ((++ nBitSlot) == bits.Length ) {
return -1;
}
offset = 0;
word = bits[nBitSlot];
}
while ((word & (uint)1) == 0) {
word >>= 1;
offset ++;
}
return (nBitSlot << bitSlotShift) + offset;
}
public void And(BitSet other) {
/*
* Need to synchronize both this and other->
* This might lead to deadlock if one thread grabs them in one order
* while another thread grabs them the other order.
* Use a trick from Doug Lea's book on concurrency,
* somewhat complicated because BitSet overrides hashCode().
*/
if (this == other) {
return;
}
int bitsLength = bits.Length;
int setLength = other.bits.Length;
int n = (bitsLength > setLength) ? setLength : bitsLength;
for (int i = n ; i-- > 0 ;) {
bits[i] &= other.bits[i];
}
for (; n < bitsLength ; n++) {
bits[n] = 0;
}
}
public void Or(BitSet other) {
if (this == other) {
return;
}
int setLength = other.bits.Length;
EnsureLength(setLength);
for (int i = setLength; i-- > 0 ;) {
bits[i] |= other.bits[i];
}
}
public override int GetHashCode() {
int h = 1234;
for (int i = bits.Length; --i >= 0;) {
h ^= (int)bits[i] * (i + 1);
}
return(int)((h >> 32) ^ h);
}
public override bool Equals(object obj) {
// assume the same type
if (obj != null) {
if (this == obj) {
return true;
}
BitSet other = (BitSet) obj;
int bitsLength = bits.Length;
int setLength = other.bits.Length;
int n = (bitsLength > setLength) ? setLength : bitsLength;
for (int i = n ; i-- > 0 ;) {
if (bits[i] != other.bits[i]) {
return false;
}
}
if (bitsLength > n) {
for (int i = bitsLength ; i-- > n ;) {
if (bits[i] != 0) {
return false;
}
}
}
else {
for (int i = setLength ; i-- > n ;) {
if (other.bits[i] != 0) {
return false;
}
}
}
return true;
}
return false;
}
public BitSet Clone() {
BitSet newset = new BitSet();
newset.count = count;
newset.bits = (uint[])bits.Clone();
return newset;
}
public bool IsEmpty {
get {
uint k = 0;
for (int i = 0; i < bits.Length; i++) {
k |= bits[i];
}
return k == 0;
}
}
public bool Intersects(BitSet other) {
int i = Math.Min(this.bits.Length, other.bits.Length);
while (--i >= 0) {
if ((this.bits[i] & other.bits[i]) != 0) {
return true;
}
}
return false;
}
private int Subscript(int bitIndex) {
return bitIndex >> bitSlotShift;
}
private void EnsureLength(int nRequiredLength) {
/* Doesn't need to be synchronized because it's an internal method. */
if (nRequiredLength > bits.Length) {
/* Ask for larger of doubled size or required size */
int request = 2 * bits.Length;
if (request < nRequiredLength)
request = nRequiredLength;
uint[] newBits = new uint[request];
Array.Copy(bits, newBits, bits.Length);
bits = newBits;
}
}
#if DEBUG
public void Dump(StringBuilder bb) {
for (int i = 0; i < count; i ++) {
bb.Append( Get(i) ? "1" : "0");
}
}
#endif
};
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
//-----------------------------------------------------------------------------
namespace System.Xml.Schema {
using System.Text;
using System.Diagnostics;
internal sealed class BitSet {
private const int bitSlotShift = 5;
private const int bitSlotMask = (1 << bitSlotShift) - 1;
private int count;
private uint[] bits;
private BitSet() {
}
public BitSet(int count) {
this.count = count;
bits = new uint[Subscript(count + bitSlotMask)];
}
public int Count {
get { return count; }
}
public bool this[int index] {
get {
return Get(index);
}
}
public void Clear() {
int bitsLength = bits.Length;
for (int i = bitsLength; i-- > 0 ;) {
bits[i] = 0;
}
}
public void Clear(int index) {
int nBitSlot = Subscript(index);
EnsureLength(nBitSlot + 1);
bits[nBitSlot] &= ~((uint)1 << (index & bitSlotMask));
}
public void Set(int index) {
int nBitSlot = Subscript(index);
EnsureLength(nBitSlot + 1);
bits[nBitSlot] |= (uint)1 << (index & bitSlotMask);
}
public bool Get(int index) {
bool fResult = false;
if (index < count) {
int nBitSlot = Subscript(index);
fResult = ((bits[nBitSlot] & (1 << (index & bitSlotMask))) != 0);
}
return fResult;
}
public int NextSet(int startFrom) {
Debug.Assert(startFrom >= -1 && startFrom <= count);
int offset = startFrom + 1;
if (offset == count) {
return -1;
}
int nBitSlot = Subscript(offset);
offset &= bitSlotMask;
uint word = bits[nBitSlot] >> offset;
// locate non-empty slot
while (word == 0) {
if ((++ nBitSlot) == bits.Length ) {
return -1;
}
offset = 0;
word = bits[nBitSlot];
}
while ((word & (uint)1) == 0) {
word >>= 1;
offset ++;
}
return (nBitSlot << bitSlotShift) + offset;
}
public void And(BitSet other) {
/*
* Need to synchronize both this and other->
* This might lead to deadlock if one thread grabs them in one order
* while another thread grabs them the other order.
* Use a trick from Doug Lea's book on concurrency,
* somewhat complicated because BitSet overrides hashCode().
*/
if (this == other) {
return;
}
int bitsLength = bits.Length;
int setLength = other.bits.Length;
int n = (bitsLength > setLength) ? setLength : bitsLength;
for (int i = n ; i-- > 0 ;) {
bits[i] &= other.bits[i];
}
for (; n < bitsLength ; n++) {
bits[n] = 0;
}
}
public void Or(BitSet other) {
if (this == other) {
return;
}
int setLength = other.bits.Length;
EnsureLength(setLength);
for (int i = setLength; i-- > 0 ;) {
bits[i] |= other.bits[i];
}
}
public override int GetHashCode() {
int h = 1234;
for (int i = bits.Length; --i >= 0;) {
h ^= (int)bits[i] * (i + 1);
}
return(int)((h >> 32) ^ h);
}
public override bool Equals(object obj) {
// assume the same type
if (obj != null) {
if (this == obj) {
return true;
}
BitSet other = (BitSet) obj;
int bitsLength = bits.Length;
int setLength = other.bits.Length;
int n = (bitsLength > setLength) ? setLength : bitsLength;
for (int i = n ; i-- > 0 ;) {
if (bits[i] != other.bits[i]) {
return false;
}
}
if (bitsLength > n) {
for (int i = bitsLength ; i-- > n ;) {
if (bits[i] != 0) {
return false;
}
}
}
else {
for (int i = setLength ; i-- > n ;) {
if (other.bits[i] != 0) {
return false;
}
}
}
return true;
}
return false;
}
public BitSet Clone() {
BitSet newset = new BitSet();
newset.count = count;
newset.bits = (uint[])bits.Clone();
return newset;
}
public bool IsEmpty {
get {
uint k = 0;
for (int i = 0; i < bits.Length; i++) {
k |= bits[i];
}
return k == 0;
}
}
public bool Intersects(BitSet other) {
int i = Math.Min(this.bits.Length, other.bits.Length);
while (--i >= 0) {
if ((this.bits[i] & other.bits[i]) != 0) {
return true;
}
}
return false;
}
private int Subscript(int bitIndex) {
return bitIndex >> bitSlotShift;
}
private void EnsureLength(int nRequiredLength) {
/* Doesn't need to be synchronized because it's an internal method. */
if (nRequiredLength > bits.Length) {
/* Ask for larger of doubled size or required size */
int request = 2 * bits.Length;
if (request < nRequiredLength)
request = nRequiredLength;
uint[] newBits = new uint[request];
Array.Copy(bits, newBits, bits.Length);
bits = newBits;
}
}
#if DEBUG
public void Dump(StringBuilder bb) {
for (int i = 0; i < count; i ++) {
bb.Append( Get(i) ? "1" : "0");
}
}
#endif
};
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- PolicyChain.cs
- IImplicitResourceProvider.cs
- XmlResolver.cs
- Vector.cs
- FindCriteria.cs
- GenerateTemporaryTargetAssembly.cs
- Configuration.cs
- TextFormatter.cs
- ExpressionCopier.cs
- HttpHandlersSection.cs
- UInt64Storage.cs
- PropertyFilter.cs
- DataSetUtil.cs
- FrameworkElementAutomationPeer.cs
- EdmItemCollection.cs
- ArgumentNullException.cs
- CatalogZone.cs
- ColorInterpolationModeValidation.cs
- FontStretchConverter.cs
- WebCategoryAttribute.cs
- NodeLabelEditEvent.cs
- MsmqIntegrationSecurityElement.cs
- PtsPage.cs
- SqlSupersetValidator.cs
- ItemsChangedEventArgs.cs
- StringExpressionSet.cs
- HtmlString.cs
- DependencyPropertyKind.cs
- ConfigurationManagerInternal.cs
- x509store.cs
- BaseTreeIterator.cs
- SQLInt32.cs
- StringBlob.cs
- PointLight.cs
- AxisAngleRotation3D.cs
- UniqueEventHelper.cs
- HttpModulesSection.cs
- CfgSemanticTag.cs
- ScriptIgnoreAttribute.cs
- LaxModeSecurityHeaderElementInferenceEngine.cs
- MultiBinding.cs
- ProfileService.cs
- XmlLoader.cs
- DesignTimeParseData.cs
- AppDomainShutdownMonitor.cs
- SplineKeyFrames.cs
- SpeechEvent.cs
- OdbcConnectionStringbuilder.cs
- DBSchemaTable.cs
- TableCellCollection.cs
- Debug.cs
- TemplateColumn.cs
- odbcmetadatacolumnnames.cs
- ToolStripStatusLabel.cs
- GridViewPageEventArgs.cs
- CheckPair.cs
- RuleRefElement.cs
- _ListenerRequestStream.cs
- GAC.cs
- ColumnHeaderConverter.cs
- SequentialOutput.cs
- FileDialog_Vista.cs
- ContractMethodInfo.cs
- WindowsToolbarItemAsMenuItem.cs
- PartialCachingAttribute.cs
- parserscommon.cs
- ipaddressinformationcollection.cs
- PropertyDescriptorCollection.cs
- Marshal.cs
- BoolLiteral.cs
- FixedSOMTextRun.cs
- OleDbException.cs
- CompositionCommandSet.cs
- WebPartHeaderCloseVerb.cs
- RelationshipFixer.cs
- TextTreePropertyUndoUnit.cs
- ListComponentEditor.cs
- Imaging.cs
- ImageListUtils.cs
- ConcatQueryOperator.cs
- TraceContextEventArgs.cs
- Figure.cs
- VariantWrapper.cs
- SystemBrushes.cs
- OdbcError.cs
- ComboBox.cs
- TemplateBindingExpression.cs
- SelectedCellsChangedEventArgs.cs
- ExtensionQuery.cs
- ExitEventArgs.cs
- XmlILModule.cs
- EventMap.cs
- EdmSchemaError.cs
- HandoffBehavior.cs
- DataAdapter.cs
- SoapExtensionTypeElementCollection.cs
- AxisAngleRotation3D.cs
- PagesChangedEventArgs.cs
- Style.cs
- ToolZone.cs