Code:
/ Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / whidbey / NetFxQFE / ndp / fx / src / CompMod / System / Collections / Specialized / BitVector32.cs / 1 / BitVector32.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace System.Collections.Specialized {
using System.Diagnostics;
using System.Text;
using System;
using Microsoft.Win32;
///
/// Provides a simple light bit vector with easy integer or Boolean access to
/// a 32 bit storage.
///
public struct BitVector32 {
private uint data;
///
/// Initializes a new instance of the BitVector32 structure with the specified internal data.
///
public BitVector32(int data) {
this.data = (uint)data;
}
///
/// Initializes a new instance of the BitVector32 structure with the information in the specified
/// value.
///
public BitVector32(BitVector32 value) {
this.data = value.data;
}
///
/// Gets or sets a value indicating whether all the specified bits are set.
///
public bool this[int bit] {
get {
return (data & bit) == (uint)bit;
}
set {
if (value) {
data |= (uint)bit;
}
else {
data &= ~(uint)bit;
}
}
}
///
/// Gets or sets the value for the specified section.
///
public int this[Section section] {
get {
return (int)((data & (uint)(section.Mask << section.Offset)) >> section.Offset);
}
set {
#if DEBUG
if ((value & section.Mask) != value) {
Debug.Fail("Value out of bounds on BitVector32 Section Set!");
}
#endif
value <<= section.Offset;
int offsetMask = (0xFFFF & (int)section.Mask) << section.Offset;
data = (data & ~(uint)offsetMask) | ((uint)value & (uint)offsetMask);
}
}
///
/// returns the raw data stored in this bit vector...
///
public int Data {
get {
return (int)data;
}
}
private static short CountBitsSet(short mask) {
// yes, I know there are better algorithms, however, we know the
// bits are always right aligned, with no holes (i.e. always 00000111,
// never 000100011), so this is just fine...
//
short value = 0;
while ((mask & 0x1) != 0) {
value++;
mask >>= 1;
}
return value;
}
///
/// Creates the first mask in a series.
///
public static int CreateMask() {
return CreateMask(0);
}
///
/// Creates the next mask in a series.
///
public static int CreateMask(int previous) {
if (previous == 0) {
return 1;
}
if (previous == unchecked((int)0x80000000)) {
throw new InvalidOperationException(SR.GetString(SR.BitVectorFull));
}
return previous << 1;
}
///
/// Given a highValue, creates the mask
///
private static short CreateMaskFromHighValue(short highValue) {
short required = 16;
while ((highValue & 0x8000) == 0) {
required--;
highValue <<= 1;
}
ushort value = 0;
while (required > 0) {
required--;
value <<= 1;
value |= 0x1;
}
return unchecked((short) value);
}
///
/// Creates the first section in a series, with the specified maximum value.
///
public static Section CreateSection(short maxValue) {
return CreateSectionHelper(maxValue, 0, 0);
}
///
/// Creates the next section in a series, with the specified maximum value.
///
public static Section CreateSection(short maxValue, Section previous) {
return CreateSectionHelper(maxValue, previous.Mask, previous.Offset);
}
private static Section CreateSectionHelper(short maxValue, short priorMask, short priorOffset) {
if (maxValue < 1) {
throw new ArgumentException(SR.GetString(SR.Argument_InvalidValue, "maxValue", 0), "maxValue");
}
#if DEBUG
int maskCheck = CreateMaskFromHighValue(maxValue);
int offsetCheck = priorOffset + CountBitsSet(priorMask);
Debug.Assert(maskCheck <= short.MaxValue && offsetCheck < 32, "Overflow on BitVector32");
#endif
short offset = (short)(priorOffset + CountBitsSet(priorMask));
if (offset >= 32) {
throw new InvalidOperationException(SR.GetString(SR.BitVectorFull));
}
return new Section(CreateMaskFromHighValue(maxValue), offset);
}
public override bool Equals(object o) {
if (!(o is BitVector32)) {
return false;
}
return data == ((BitVector32)o).data;
}
public override int GetHashCode() {
return base.GetHashCode();
}
///
///
public static string ToString(BitVector32 value) {
StringBuilder sb = new StringBuilder(/*"BitVector32{".Length*/12 + /*32 bits*/32 + /*"}".Length"*/1);
sb.Append("BitVector32{");
int locdata = (int)value.data;
for (int i=0; i<32; i++) {
if ((locdata & 0x80000000) != 0) {
sb.Append("1");
}
else {
sb.Append("0");
}
locdata <<= 1;
}
sb.Append("}");
return sb.ToString();
}
///
///
public override string ToString() {
return BitVector32.ToString(this);
}
///
///
/// Represents an section of the vector that can contain a integer number.
///
public struct Section {
private readonly short mask;
private readonly short offset;
internal Section(short mask, short offset) {
this.mask = mask;
this.offset = offset;
}
public short Mask {
get {
return mask;
}
}
public short Offset {
get {
return offset;
}
}
public override bool Equals(object o) {
if (o is Section)
return Equals((Section)o);
else
return false;
}
public bool Equals(Section obj)
{
return obj.mask == mask && obj.offset == offset;
}
public static bool operator ==(Section a, Section b)
{
return a.Equals(b);
}
public static bool operator !=(Section a, Section b)
{
return !(a == b);
}
public override int GetHashCode() {
return base.GetHashCode();
}
///
///
public static string ToString(Section value) {
return "Section{0x" + Convert.ToString(value.Mask, 16) + ", 0x" + Convert.ToString(value.Offset, 16) + "}";
}
///
///
public override string ToString() {
return Section.ToString(this);
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace System.Collections.Specialized {
using System.Diagnostics;
using System.Text;
using System;
using Microsoft.Win32;
///
/// Provides a simple light bit vector with easy integer or Boolean access to
/// a 32 bit storage.
///
public struct BitVector32 {
private uint data;
///
/// Initializes a new instance of the BitVector32 structure with the specified internal data.
///
public BitVector32(int data) {
this.data = (uint)data;
}
///
/// Initializes a new instance of the BitVector32 structure with the information in the specified
/// value.
///
public BitVector32(BitVector32 value) {
this.data = value.data;
}
///
/// Gets or sets a value indicating whether all the specified bits are set.
///
public bool this[int bit] {
get {
return (data & bit) == (uint)bit;
}
set {
if (value) {
data |= (uint)bit;
}
else {
data &= ~(uint)bit;
}
}
}
///
/// Gets or sets the value for the specified section.
///
public int this[Section section] {
get {
return (int)((data & (uint)(section.Mask << section.Offset)) >> section.Offset);
}
set {
#if DEBUG
if ((value & section.Mask) != value) {
Debug.Fail("Value out of bounds on BitVector32 Section Set!");
}
#endif
value <<= section.Offset;
int offsetMask = (0xFFFF & (int)section.Mask) << section.Offset;
data = (data & ~(uint)offsetMask) | ((uint)value & (uint)offsetMask);
}
}
///
/// returns the raw data stored in this bit vector...
///
public int Data {
get {
return (int)data;
}
}
private static short CountBitsSet(short mask) {
// yes, I know there are better algorithms, however, we know the
// bits are always right aligned, with no holes (i.e. always 00000111,
// never 000100011), so this is just fine...
//
short value = 0;
while ((mask & 0x1) != 0) {
value++;
mask >>= 1;
}
return value;
}
///
/// Creates the first mask in a series.
///
public static int CreateMask() {
return CreateMask(0);
}
///
/// Creates the next mask in a series.
///
public static int CreateMask(int previous) {
if (previous == 0) {
return 1;
}
if (previous == unchecked((int)0x80000000)) {
throw new InvalidOperationException(SR.GetString(SR.BitVectorFull));
}
return previous << 1;
}
///
/// Given a highValue, creates the mask
///
private static short CreateMaskFromHighValue(short highValue) {
short required = 16;
while ((highValue & 0x8000) == 0) {
required--;
highValue <<= 1;
}
ushort value = 0;
while (required > 0) {
required--;
value <<= 1;
value |= 0x1;
}
return unchecked((short) value);
}
///
/// Creates the first section in a series, with the specified maximum value.
///
public static Section CreateSection(short maxValue) {
return CreateSectionHelper(maxValue, 0, 0);
}
///
/// Creates the next section in a series, with the specified maximum value.
///
public static Section CreateSection(short maxValue, Section previous) {
return CreateSectionHelper(maxValue, previous.Mask, previous.Offset);
}
private static Section CreateSectionHelper(short maxValue, short priorMask, short priorOffset) {
if (maxValue < 1) {
throw new ArgumentException(SR.GetString(SR.Argument_InvalidValue, "maxValue", 0), "maxValue");
}
#if DEBUG
int maskCheck = CreateMaskFromHighValue(maxValue);
int offsetCheck = priorOffset + CountBitsSet(priorMask);
Debug.Assert(maskCheck <= short.MaxValue && offsetCheck < 32, "Overflow on BitVector32");
#endif
short offset = (short)(priorOffset + CountBitsSet(priorMask));
if (offset >= 32) {
throw new InvalidOperationException(SR.GetString(SR.BitVectorFull));
}
return new Section(CreateMaskFromHighValue(maxValue), offset);
}
public override bool Equals(object o) {
if (!(o is BitVector32)) {
return false;
}
return data == ((BitVector32)o).data;
}
public override int GetHashCode() {
return base.GetHashCode();
}
///
///
public static string ToString(BitVector32 value) {
StringBuilder sb = new StringBuilder(/*"BitVector32{".Length*/12 + /*32 bits*/32 + /*"}".Length"*/1);
sb.Append("BitVector32{");
int locdata = (int)value.data;
for (int i=0; i<32; i++) {
if ((locdata & 0x80000000) != 0) {
sb.Append("1");
}
else {
sb.Append("0");
}
locdata <<= 1;
}
sb.Append("}");
return sb.ToString();
}
///
///
public override string ToString() {
return BitVector32.ToString(this);
}
///
///
/// Represents an section of the vector that can contain a integer number.
///
public struct Section {
private readonly short mask;
private readonly short offset;
internal Section(short mask, short offset) {
this.mask = mask;
this.offset = offset;
}
public short Mask {
get {
return mask;
}
}
public short Offset {
get {
return offset;
}
}
public override bool Equals(object o) {
if (o is Section)
return Equals((Section)o);
else
return false;
}
public bool Equals(Section obj)
{
return obj.mask == mask && obj.offset == offset;
}
public static bool operator ==(Section a, Section b)
{
return a.Equals(b);
}
public static bool operator !=(Section a, Section b)
{
return !(a == b);
}
public override int GetHashCode() {
return base.GetHashCode();
}
///
///
public static string ToString(Section value) {
return "Section{0x" + Convert.ToString(value.Mask, 16) + ", 0x" + Convert.ToString(value.Offset, 16) + "}";
}
///
///
public override string ToString() {
return Section.ToString(this);
}
}
}
}
// 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
- ServiceContractViewControl.Designer.cs
- FileEnumerator.cs
- XmlLoader.cs
- Camera.cs
- NetNamedPipeBinding.cs
- InputScopeConverter.cs
- SQLSingleStorage.cs
- HostingEnvironment.cs
- NativeRightsManagementAPIsStructures.cs
- UserMapPath.cs
- DeferredRunTextReference.cs
- SafeCertificateStore.cs
- ReadOnlyDictionary.cs
- BinaryExpression.cs
- ScriptingJsonSerializationSection.cs
- XhtmlBasicListAdapter.cs
- EdmScalarPropertyAttribute.cs
- NetCodeGroup.cs
- RegexCharClass.cs
- MessageHeaderException.cs
- DataGridViewAutoSizeModeEventArgs.cs
- Compiler.cs
- Hex.cs
- ResourceDescriptionAttribute.cs
- _NegotiateClient.cs
- SelfSignedCertificate.cs
- StatusBarAutomationPeer.cs
- SubqueryRules.cs
- TileBrush.cs
- SqlCacheDependencySection.cs
- TreeNode.cs
- WebControlParameterProxy.cs
- DataSourceXmlAttributeAttribute.cs
- HttpRuntimeSection.cs
- ItemsControl.cs
- ToolStripLocationCancelEventArgs.cs
- FamilyMap.cs
- Nodes.cs
- HostedElements.cs
- StringUtil.cs
- MenuStrip.cs
- SchemaElementLookUpTable.cs
- XmlIlTypeHelper.cs
- DaylightTime.cs
- XamlNamespaceHelper.cs
- SqlClientWrapperSmiStreamChars.cs
- TraceUtils.cs
- TextRunTypographyProperties.cs
- Row.cs
- ComProxy.cs
- TargetConverter.cs
- CurrentChangedEventManager.cs
- TraceSection.cs
- ClassData.cs
- HotSpotCollection.cs
- BamlCollectionHolder.cs
- Buffer.cs
- FastPropertyAccessor.cs
- HandleCollector.cs
- HostedImpersonationContext.cs
- XamlPointCollectionSerializer.cs
- BuildProviderAppliesToAttribute.cs
- ObjectStateEntryDbDataRecord.cs
- Mappings.cs
- Rotation3DAnimationBase.cs
- FilterException.cs
- DataTableMappingCollection.cs
- DataTableCollection.cs
- dbdatarecord.cs
- ColumnWidthChangedEvent.cs
- SolidBrush.cs
- TagElement.cs
- SplitterCancelEvent.cs
- DataError.cs
- RegexParser.cs
- ReaderWriterLock.cs
- RemotingSurrogateSelector.cs
- TrustExchangeException.cs
- LinkDescriptor.cs
- BinaryNegotiation.cs
- WindowsFormsSynchronizationContext.cs
- StackBuilderSink.cs
- OptimizedTemplateContentHelper.cs
- ZipIOLocalFileBlock.cs
- ResourcePool.cs
- PartialTrustVisibleAssembly.cs
- FixUpCollection.cs
- InvalidOperationException.cs
- VectorAnimation.cs
- CompleteWizardStep.cs
- FlowDocumentPage.cs
- GeneralTransformCollection.cs
- OdbcConnectionStringbuilder.cs
- SizeAnimation.cs
- Pen.cs
- PagedDataSource.cs
- FrameSecurityDescriptor.cs
- MostlySingletonList.cs
- DbConnectionPoolCounters.cs
- Models.cs