/// <summary>
/// Sets the given flag to be true.
/// <summary>
public void SetFlag(FlagEnum flag, bool value)
{
if (flag_dict.ContainsKey(flag))
{
flag_dict.TryUpdate(flag, value, !value);
}
}
/// <summary>
/// Lets you know if the given flag is true.
/// <summary>
public bool IsFlag(FlagEnum flag)
{
bool value;
flag_dict.TryGetValue(flag, out value);
return(value);
}
public void GetFlagsReturnsTheMultipleFlagsSet()
{
const FlagEnum multipleFlags = FlagEnum.BitOne | FlagEnum.BitFive | FlagEnum.BitThree;
var actual = Enum <FlagEnum> .GetFlags(multipleFlags);
CollectionAssert.AreEquivalent(new[] { FlagEnum.BitOne, FlagEnum.BitFive, FlagEnum.BitThree }, actual.ToArray());
}
public void SetFlagsShouldReturnCombinationFlagFromIndividualMasks()
{
const FlagEnum expected = FlagEnum.BitsTwoAndFour;
var actual = Enum <FlagEnum> .SetFlags(new[] { FlagEnum.BitFour, FlagEnum.BitTwo });
Assert.Equal(expected, actual);
}
public void WriteFlagEnumAsString(FlagEnum enumValue)
{
var enumAsStringResult = MsgPackSerializer.Serialize(enumValue);
var enumAsStringExpected = MsgPackSerializer.Serialize(enumValue.ToString());
enumAsStringResult.ShouldBe(enumAsStringExpected);
}
public void FlagEnum_ValueConstructor_SingleValue()
{
var value = new FlagEnum <TreeNodeDifference>(TreeNodeDifference.Name);
Assert.IsTrue(value == TreeNodeDifference.Name);
Assert.IsTrue(value.GetValues().Single() == TreeNodeDifference.Name);
}
public void FlagEnum_ArrayConstructor_EmptyList()
{
var value = new FlagEnum <TreeNodeDifference>(new TreeNodeDifference[] { });
Assert.IsTrue(value == TreeNodeDifference.None);
Assert.IsTrue(value.GetValues().Single() == TreeNodeDifference.None);
}
public void FlagEnum_ArrayConstructor_SingleValue()
{
var value = new FlagEnum <TreeNodeDifference>(new[] { TreeNodeDifference.Name });
Assert.IsTrue(value.Equals(TreeNodeDifference.Name));
Assert.IsTrue(value.GetValues().Single() == TreeNodeDifference.Name);
}
public void FlagEnum_ArrayConstructor_NegateCombined_Two()
{
var value = new FlagEnum <TreeParseOption>(TreeParseOption.Common, ~TreeParseOption.Sensors, ~TreeParseOption.Probes);
Assert.AreEqual(2, value.GetValues().Count);
Assert.IsTrue(value == (TreeParseOption.Devices | TreeParseOption.Groups));
}
/// <summary>
/// 获取总记录数
/// </summary>
/// <returns></returns>
public int GetCount(DateTime beginTime, DateTime endTime, FlagEnum hasDeal)
{
var where = new StringBuilder(" where HasDeal=@HasDeal and IsDel=@IsDel ");
if (beginTime > new DateTime(1900, 1, 1))
{
where.Append(" and CreateTime>=@BeginTime ");
}
if (endTime > new DateTime(1900, 1, 1))
{
where.Append(" and CreateTime<@EndTime ");
}
var param = new
{
IsDel = FlagEnum.HadZore.GetHashCode(),
HasDeal = hasDeal.GetHashCode(),
BeginTime = beginTime,
EndTime = endTime
};
using (var conn = SqlConnectionHelper.GetOpenConnection())
{
return(conn.RecordCount <CustomercommentModel>(where.ToString(), param));
}
}
public void GetFlagsReturnsTheMultipleFlagsSetIgnoringUndefined()
{
const FlagEnum multipleFlags = (FlagEnum)255;
var actual = Enum <FlagEnum> .GetFlags(multipleFlags);
Assert.Equal(new[] { FlagEnum.BitOne, FlagEnum.BitTwo, FlagEnum.BitThree, FlagEnum.BitFour, FlagEnum.BitsTwoAndFour, FlagEnum.BitFive, FlagEnum.BitSix }, actual.ToArray());
}
public void GetFlagsReturnsTheMultipleFlagsSetIncludingCombinedMasks()
{
const FlagEnum combinedFlags = FlagEnum.BitsTwoAndFour;
var actual = Enum <FlagEnum> .GetFlags(combinedFlags);
Assert.Equal(new[] { FlagEnum.BitTwo, FlagEnum.BitFour, FlagEnum.BitsTwoAndFour }, actual.ToArray());
}
public void GetFlagsReturnsTheMultipleFlagsSet()
{
const FlagEnum multipleFlags = FlagEnum.BitOne | FlagEnum.BitFive | FlagEnum.BitThree;
var actual = Enum <FlagEnum> .GetFlags(multipleFlags);
Assert.Equal(new[] { FlagEnum.BitOne, FlagEnum.BitThree, FlagEnum.BitFive }, actual.ToArray());
}
public void FlagEnum_ArrayConstructor_Null()
{
var value = new FlagEnum <TreeNodeDifference>(null);
Assert.IsTrue(value == TreeNodeDifference.None);
Assert.IsTrue(value.GetValues().Single() == TreeNodeDifference.None);
}
public void SetFlagsShouldDefaultWhenGivenNoValues()
{
const FlagEnum expected = default(FlagEnum);
var actual = Enum <FlagEnum> .SetFlags(Enumerable.Empty <FlagEnum>());
Assert.Equal(expected, actual);
}
public void ReadFlagEnumAsString(FlagEnum enumValue)
{
var bytes = MsgPackSerializer.Serialize(enumValue.ToString());
var enumResult = MsgPackSerializer.Deserialize <FlagEnum>(bytes);
enumResult.ShouldBe(enumValue);
}
public void ReadFlagEnum(FlagEnum enumValue)
{
var intEnumContext = new MsgPackContext(convertEnumsAsStrings: false);
var bytes = MsgPackSerializer.Serialize((int)enumValue, intEnumContext);
var enumResult = MsgPackSerializer.Deserialize <FlagEnum>(bytes, intEnumContext);
enumResult.ShouldBe(enumValue);
}
public void FlagEnum_Create_IEnumerable()
{
IEnumerable <TreeNodeDifference> enumerable = new[] { TreeNodeDifference.ParentId, TreeNodeDifference.Position };
var value = FlagEnum.Create(enumerable);
Assert.AreEqual(TreeNodeDifference.ParentId | TreeNodeDifference.Position, value.Value);
}
static void Main(string[] args)
{
LegacyClass.PropB = true;
FlagEnum result = LegacyClass.PropA ? FlagEnum.EnumValue1 : 0;
result |= LegacyClass.PropB ? FlagEnum.EnumValue2 : 0;
result |= LegacyClass.PropC ? FlagEnum.EnumValue3 : 0;
}
public void WriteFlagEnum(FlagEnum enumValue)
{
var intEnumContext = new MsgPackContext(convertEnumsAsStrings: false);
var enumResult = MsgPackSerializer.Serialize(enumValue, intEnumContext);
var valueResult = MsgPackSerializer.Serialize((int)enumValue, intEnumContext);
enumResult.ShouldBe(valueResult);
}
public void FlagEnum_Operators_BitwiseAnd()
{
FlagEnum <TreeNodeDifference> first = TreeNodeDifference.Name | TreeNodeDifference.NumberOfChildren;
var value = first & TreeNodeDifference.Name;
Assert.IsTrue(value == TreeNodeDifference.Name);
}
/// 按下符号时进行计算
private void Flag_mul_Click(object sender, EventArgs e)
{
numStr.Clear(); ///清空里面的东西
double result = 0; //保存返回的结果
string text = ((Button)sender).Text;
switch (text)
{
case "+":
nextFlag = prevFlag; ///保存前一个
prevFlag = FlagEnum.ADD;
break;
case "-":
nextFlag = prevFlag;
prevFlag = FlagEnum.SUB;
break;
case "*":
nextFlag = prevFlag;
prevFlag = FlagEnum.MUL;
break;
case "/":
nextFlag = prevFlag;
prevFlag = FlagEnum.DIV;
break;
case "Mod":
nextFlag = prevFlag;
prevFlag = FlagEnum.MOD;
break;
case "=":
nextFlag = prevFlag;
prevFlag = FlagEnum.EQ;
break;
case "CE":
//nextFlag = prevFlag;
//prevFlag = FlagEnum.CE;
caculate.ClearStack();
return; ///end
break;
}
///进行计算操作
if (flag)
{
flag = false;
return;///第一次遇到符号不操作
}
else
{
result = CaculateCore(nextFlag);
}
text_show_caclute.Text = "" + result;
}
public void FlagEnum_Operators_BitwiseComplement()
{
var original = new FlagEnum <TreeParseOption>(TreeParseOption.Common);
var complement = ~original;
Assert.IsTrue((TreeParseOption.Triggers | TreeParseOption.Properties) == complement);
Assert.AreEqual(2, complement.GetValues().Count);
}
public void FlagEnum_Implicit_FromFlagEnum()
{
var value = new FlagEnum <TreeNodeDifference>(TreeNodeDifference.Name | TreeNodeDifference.NumberOfChildren);
TreeNodeDifference enumValue = value;
Assert.IsTrue((enumValue & TreeNodeDifference.Name) == TreeNodeDifference.Name);
Assert.IsTrue((enumValue & TreeNodeDifference.NumberOfChildren) == TreeNodeDifference.NumberOfChildren);
}
public void FlagEnum_ArrayConstructor_NegationOnly_Two_Array()
{
var value = new FlagEnum <TreeParseOption>(~TreeParseOption.Probes, ~TreeParseOption.Sensors);
var expected = TreeParseOption.Devices | TreeParseOption.Groups | TreeParseOption.Triggers | TreeParseOption.Properties;
Assert.IsTrue(expected == value);
Assert.AreEqual(4, value.GetValues().Count);
}
public void FlagEnum_ValueConstructor_FlagValue()
{
var value = new FlagEnum <TreeNodeDifference>(TreeNodeDifference.Name | TreeNodeDifference.NumberOfChildren);
Assert.AreEqual(2, value.GetValues().Count);
Assert.IsTrue(value.Equals(TreeNodeDifference.Name | TreeNodeDifference.NumberOfChildren));
Assert.IsTrue(value.Contains(TreeNodeDifference.Name));
Assert.IsTrue(value.Contains(TreeNodeDifference.NumberOfChildren));
}
public void FlagEnum_ArrayConstructor_IndividualValues()
{
var value = new FlagEnum <TreeNodeDifference>(new[] { TreeNodeDifference.Name, TreeNodeDifference.NumberOfChildren });
Assert.IsTrue(value == (TreeNodeDifference.Name | TreeNodeDifference.NumberOfChildren));
Assert.AreEqual(2, value.GetValues().Count);
Assert.IsTrue(TreeNodeDifference.Name == value.GetValues()[0]);
Assert.IsTrue(TreeNodeDifference.NumberOfChildren == value.GetValues()[1]);
}
public void FlagEnum_ArrayConstructor_FlagValue()
{
var both = TreeNodeDifference.Name | TreeNodeDifference.NumberOfChildren;
var value = new FlagEnum <TreeNodeDifference>(new[] { both });
Assert.IsTrue(both == value);
Assert.IsTrue(value.GetValues().Count() == 2);
}
public void FlagEnum_Implicit_ToFlagEnum()
{
FlagEnum <TreeNodeDifference> value = TreeNodeDifference.Name | TreeNodeDifference.NumberOfChildren;
Assert.IsTrue(value == (TreeNodeDifference.Name | TreeNodeDifference.NumberOfChildren));
Assert.AreEqual(2, value.GetValues().Count);
Assert.IsTrue(TreeNodeDifference.Name == value.GetValues()[0]);
Assert.IsTrue(TreeNodeDifference.NumberOfChildren == value.GetValues()[1]);
}
internal TreeBuilder(PrtgClient client, FlagEnum <TreeParseOption>?options, ITreeProgressCallback progressCallback, FlagEnum <TreeRequestType> requestType, CancellationToken token)
{
ProgressManager = new TreeProgressManager(progressCallback);
ObjectManager = new ObjectManager(client);
Token = token;
Options = options ?? TreeParseOption.Common;
RequestType = requestType;
this.client = client;
}
private void ReadValues()
{
if (!Helper.SeekTo(_reader, HeaderGuids.File_Properties))
{
throw new InvalidOperationException("Reader is not at the file properties");
}
_objectStreamPosition = _reader.BaseStream.Position;
Size = _reader.ReadInt64();
FileId = new Guid(_reader.ReadBytes(16));
FileSize = _reader.ReadInt64();
CreationDate = new DateTime(_reader.ReadInt64());
DataPacketsCount = _reader.ReadInt64();
PlayDuration = new TimeSpan(_reader.ReadInt64());
SendDuration = new TimeSpan(_reader.ReadInt64());
Preroll = new TimeSpan(_reader.ReadInt64());
var flags = _reader.ReadBytes(4);
var f = flags[0];
_flagValue = (FlagEnum)BitConverter.ToInt32(flags, 0);
MinimumDataPacketSize = _reader.ReadInt32();
MaximumDataPacketSize = _reader.ReadInt32();
MaximumBitrate = _reader.ReadInt32();
}
public void WriteFlags(bool isBroadcast)
{
var currentPosition = _reader.BaseStream.Position;
var stream = _reader.BaseStream;
var writer = new BinaryWriter(_reader.BaseStream);
stream.Position = _objectStreamPosition + 72/*Skip the properties until Flag*/;
var newFlag = (byte)(isBroadcast ? 9/*Broadcast-Live*/ : 2/*Seekable*/);
writer.Write(newFlag);
writer.Flush();
stream.Position = currentPosition;
_flagValue = (FlagEnum)newFlag;
}
