public static BOOL DrawEdge(HandleRef hdc, ref RECT qrc, EDGE edge, BF grfFlags)
{
BOOL result = DrawEdge(hdc.Handle, ref qrc, edge, grfFlags);
GC.KeepAlive(hdc.Wrapper);
return(result);
}
public uint LockDetectCount()
{
uint data = m_hmc.ReadRegister(HMC704LP4E_REGS.REG7_LockDetect);
m_allRegs.regLockDetect = BF.CreateBitField <REG7_LockDetect>(data);
return(m_allRegs.regLockDetect.lkd_wincnt_max);
}
private void generateButt_Click(object sender, RoutedEventArgs e)
{
long p, g;
getRandPG(out p, out g);
PField.Text = p.ToString();
GField.Text = g.ToString();
alise = new DH_Exschange(p, g);
bob = new DH_Exschange(p, g);
ASKey.Text = alise.getSecretKey().ToString();
BSKey.Text = bob.getSecretKey().ToString();
long AM, BM;
AM = alise.getMiddleKey();
BM = bob.getMiddleKey();
AMKey.Text = AM.ToString();
BMKey.Text = BM.ToString();
long AF, BF;
AF = alise.getFinKey(BM);
BF = bob.getFinKey(AM);
AFKey.Text = AF.ToString();
BFKey.Text = BF.ToString();
}
public void LockDetectCount(int count)
{
uint data = m_hmc.ReadRegister(HMC704LP4E_REGS.REG7_LockDetect);
m_allRegs.regLockDetect = BF.CreateBitField <REG7_LockDetect>(data);
//m_allRegs.reg1Rst.EnFromSPI = (uint)mode;
m_hmc.WriteRegister(HMC704LP4E_REGS.REG7_LockDetect, m_allRegs.regLockDetect.ToUInt32());
}
public int Add(BF bf)
{
return(ExecuteNonQuery(@"insert into backup(auto,`interval`,save_path,save_days) values(@auto,@interval,@save_path,@save_days)",
new MySqlParameter("@auto", bf.Zdbf), new MySqlParameter("@interval", bf.Sj),
new MySqlParameter("@save_path", bf.Lj),
new MySqlParameter("@save_days", bf.Blts)
));
}
public void Power(PowerMode mode)
{
uint data = m_hmc.ReadRegister(HMC704LP4E_REGS.RST);
m_allRegs.reg1Rst = BF.CreateBitField <REG1_RST>(data);
//m_allRegs.reg1Rst.EnFromSPI = (uint)mode;
m_hmc.WriteRegister(HMC704LP4E_REGS.RST, m_allRegs.reg1Rst.ToUInt32());
}
void SetRFDevideBy2(bool devide)
{
uint data = m_hmc.ReadRegister(HMC704LP4E_REGS.REG8_AnalogEN);
m_allRegs.regAnalogEn = BF.CreateBitField <REG8_AnalogEN>(data);
m_allRegs.regAnalogEn._8GHzDivideBy2En = (uint)(devide == true ? 1 : 0);
m_hmc.WriteRegister(HMC704LP4E_REGS.REG8_AnalogEN, m_allRegs.regAnalogEn.ToUInt32());
}
static void Main(string[] args)
{
int n, h, t;
string input = Console.ReadLine();
BF bf = new BF();
List <string> students = new List <string>();
n = int.Parse(input);
for (int i = 0; i < n; i++)
{
input = Console.ReadLine();
string[] splitString = input.Split(new char[] { ' ' }, StringSplitOptions.None);
students.Add(splitString[0]);
bf.AddPath(splitString[0], splitString[0]);
//V.Add(splitString[0], new BF.City());
}
input = Console.ReadLine();
h = int.Parse(input);
for (int i = 0; i < h; i++)
{
input = Console.ReadLine();
string[] splitString = input.Split(new char[] { ' ' }, StringSplitOptions.None);
bf.AddPath(splitString[0], splitString[1]);
//bf.E.Add(new Path(splitString[0], splitString[1], students[splitString[1]]));
//bf.D.Add(splitString[0], E);
}
input = Console.ReadLine();
t = int.Parse(input);
List <string> trips = new List <string>();
for (int i = 0; i < t; i++)
{
input = Console.ReadLine();
//string[] splitString = input.Split(new char[] { ' ' }, StringSplitOptions.None);
trips.Add(input);
//trips.Add(splitString[0]);
//trips.Add(splitString[1]);
}
double result;
for (int i = 0; i < trips.Count; i++)
{
result = bf.BellmanFord(trips[i]);
if (result == int.MaxValue)
{
Console.WriteLine("NO");
}
else
{
Console.WriteLine(result);
}
}
}
public async Task <long> DeleteAsync(string symbol)
{
var rtn = await _segments.DeleteManyAsync(BF.Eq("symbol", symbol));
//Log.Information ("Deleted {count} segments for {symbol}", rtn.DeletedCount, symbol);
rtn = await _versions.DeleteManyAsync(BF.Eq("symbol", symbol));
//Log.Information ("Deleted {count} versions for {symbol}", rtn.DeletedCount, symbol);
return(rtn.DeletedCount);
}
public object SerializeToolboxItem(ToolboxItem toolboxItem)
{
MemoryStream ms = new MemoryStream();
BF.Serialize(ms, toolboxItem);
byte[] retval = ms.ToArray();
ms.Close();
return(retval);
}
static void Main(string[] args)
{
int n, h, t;
string input = Console.ReadLine();
BF bf = new BF();
Dictionary <string, double> cities = new Dictionary <string, double>();
n = int.Parse(input);
for (int i = 0; i < n; i++)
{
input = Console.ReadLine();
string[] splitString = input.Split(new char[] { ' ' }, StringSplitOptions.None);
cities.Add(splitString[0], Convert.ToDouble(splitString[1]));
bf.AddHighway(splitString[0], splitString[0], Convert.ToDouble(splitString[1]));
//V.Add(splitString[0], new BF.City());
}
input = Console.ReadLine();
h = int.Parse(input);
for (int i = 0; i < h; i++)
{
input = Console.ReadLine();
string[] splitString = input.Split(new char[] { ' ' }, StringSplitOptions.None);
bf.AddHighway(splitString[0], splitString[1], cities[splitString[1]]);
//bf.E.Add(new Highway(splitString[0], splitString[1], cities[splitString[1]]));
//bf.D.Add(splitString[0], E);
}
input = Console.ReadLine();
t = int.Parse(input);
List <string> trips = new List <string>();
for (int i = 0; i < t; i++)
{
input = Console.ReadLine();
string[] splitString = input.Split(new char[] { ' ' }, StringSplitOptions.None);
trips.Add(splitString[0]);
trips.Add(splitString[1]);
}
double result;
for (int i = 0; i < trips.Count; i += 2)
{
result = bf.BellmanFord(trips[i], trips[i + 1]);
if (result == int.MaxValue)
{
Console.WriteLine("NO");
}
else
{
Console.WriteLine(result);
}
}
}
public bool CheckLockDetect()
{
uint data = m_hmc.ReadRegister(HMC704LP4E_REGS.REG12_GPO2);
m_allRegs.regGP02 = BF.CreateBitField <REG18_GPO2>(data);
if (m_allRegs.regGP02.LockDetect == 1)
{
return(true);
}
return(false);
}
public BF Query()
{
DataTable table = ExecuteDataTable(@"select * from backup");
if (table.Rows.Count > 0)
{
BF bf = new BF();
bf.Zdbf = int.Parse(table.Rows[0]["auto"] + "");
bf.Sj = int.Parse(table.Rows[0]["interval"] + "");
bf.Lj = (string)table.Rows[0]["save_path"];
bf.Blts = int.Parse(table.Rows[0]["save_days"] + "");
return(bf);
}
return(null);
}
private void ExpandFaces()
{
PFace[] CFaces = new PFace[MaxNVert];
int NRefl = Group.Length;
int p, q = BaseFaces.Length;
for (int i = 0; i < q; i++)
{
BaseFaces[i].Id = i;
CFaces[i] = new PFace(BaseFaces[i]);
}
for (p = 0; p < q; p++)
{
foreach (double [] G in Group)
{
double[] v = PGeom.ApplyTwist(G, CFaces[p].Pole);
int j;
for (j = 0; j < q; j++)
{
if (PGeom.VertEqual(v, CFaces[j].Pole))
{
double[,] mf = PGeom.ApplyTwist(G, CFaces[p].Matrix);
CFaces[p].Base.AddSMatrix(mf, CFaces[j].Matrix);
break;
}
}
if (j == q)
{
if (q == MaxNVert)
{
throw new Exception("Too many vertices");
}
CFaces[q] = new PFace(CFaces[p], G);
q++;
}
}
}
Faces = new PFace[q];
for (int i = 0; i < q; i++)
{
Faces[i] = CFaces[i];
Faces[i].Id = i;
}
foreach (PBaseFace BF in BaseFaces)
{
BF.CloseSMatrixSet();
}
}
internal void RefreshBFValue()
{
BigInteger value = CurrentRegisterValue;
foreach (var BF in mCurrentBitFields)
{
//BF.Value = ((value << (63-BF.EndBit)) >> (63 - BF.EndBit + BF.StartBit));
BigInteger bits = value >> BF.StartBit;
BigInteger mask = 1;
mask = (mask << BF.Size) - 1;
bits &= mask;
BF.Value = bits;
BF.RefreshDisplay();
}
NotifyPropertyChanged(() => CurrentRegsiterBitFields);
}
public ToolboxItem DeserializeToolboxItem(object serializedObject)
{
if (!(serializedObject is byte[]))
{
return(null);
}
MemoryStream ms = new MemoryStream((byte[])serializedObject);
object obj = BF.Deserialize(ms);
ms.Close();
if (!(obj is ToolboxItem))
{
return(null);
}
return((ToolboxItem)obj);
}
public void SetOperationMode(OperationModes mode)
{
if (mode == OperationModes.Integer)
{
uint data = m_hmc.ReadRegister(HMC704LP4E_REGS.REG6_SD_CFG);
m_allRegs.reg6SdCfg = BF.CreateBitField <REG6_SDCFG>(data);
m_allRegs.reg6SdCfg.frac_rstb = 0;
m_allRegs.reg6SdCfg.frac_bypass = 1;
m_hmc.WriteRegister(HMC704LP4E_REGS.REG6_SD_CFG, m_allRegs.reg6SdCfg.ToUInt32());
data = m_hmc.ReadRegister(HMC704LP4E_REGS.FrequencyRegisterFractionalPart);
m_allRegs.regFreqFrac = BF.CreateBitField <REG4_FrequencyFractionaPart>(data);
m_allRegs.regFreqFrac.frac = 1;
m_hmc.WriteRegister(HMC704LP4E_REGS.FrequencyRegisterFractionalPart, m_allRegs.regFreqFrac.ToUInt32());
// R = 1 - we will use the default which set to 1 already
}
m_operationMode = mode;
}
public async Task <BsonDocument> GetNewVersion(string symbol, BsonDocument version = null)
{
version = version ?? new BsonDocument();
var version_num = await _version_numbers.FindOneAndUpdateAsync(
BF.Eq("symbol", symbol),
BU.Inc("version", 1),
new FindOneAndUpdateOptions <BsonDocument> {
IsUpsert = true,
ReturnDocument = ReturnDocument.After
}
);
version ["version"] = version_num.Unwrap(v => v["version"], 1);
if (version.GetValue("_id", null) == null)
{
version ["_id"] = new BsonObjectId(ObjectId.GenerateNewId());
}
version ["symbol"] = symbol;
return(version);
}
public static partial BOOL DrawEdge(Gdi32.HDC hdc, ref RECT qrc, EDGE edge, BF grfFlags);
public async Task <BsonDocument> AppendAsync(string symbol, DataFrame df, int chunksize = 0, bool skipAlreadyWrittenDates = true)
{
if (df.Index == null)
{
throw new ArgumentException("Please specify DataFrame.Index column before saving");
}
if (chunksize > 0 && df.Rows.Count > chunksize)
{
var rng = Range.R(0, chunksize);
BsonDocument ver = null;
int chunkscount = 0;
while (rng.First < df.Rows.Count)
{
var chunk = df[rng];
ver = await AppendAsync(symbol, chunk);
rng = Range.R(rng.First + chunksize, rng.Last + chunksize);
chunkscount++;
}
return(ver);
}
int attemptNo = 0;
for (;;)
{
var previous_version = await ReadVersionAsync(symbol);
var version = await GetNewVersion(symbol, previous_version);
/*var previous_version = await (_versions.AsQueryable ()
* .Where (v => v ["symbol"] == symbol && v ["version"] < version ["version"])
* .OrderByDescending (v => v ["version"]) as IAsyncCursorSource<BsonDocument>)
* .FirstOrDefaultAsync ();*/
var dtype = version.GetValue("dtype", "").ToString();
Log.Debug("loaded dtype {0}", dtype);
if (dtype != "" && df.DType.ToString() != dtype)
{
// dtype changed. need reload old data and repack it.
throw new NotImplementedException("old dtype {0}, new dtype {1}: not implemented".Args(dtype, df.DType));
}
var sdt = df.DType.ToString();
version["metadata"] = df.Metadata;
version["dtype"] = sdt;
Log.Debug("saved dtype {0}", sdt);
version["shape"] = new BsonArray {
{ -1 }
};
version["dtype_metadata"] = new BsonDocument {
{ "index", new BsonArray {
{ df.Index.Name }
} },
{ "columns", new BsonArray(df.Columns.Select(c => c.Name).ToList()) }
};
version["type"] = "pandasdf";
version["segment_count"] = previous_version != null ? previous_version["segment_count"].AsInt32 + 1 : 1;
version["append_count"] = previous_version != null ? previous_version["append_count"].AsInt32 + 1 : 0;
var seg_ind_buf = new ByteBuffer();
int segment_offset = 0;
bool is_date_time_index = DType.DateTime64.ToString().Equals(df.Index.DType.ToString());
//version ["base_sha"] = version ["sha"];
if (previous_version != null)
{
var seg_ind = previous_version["segment_index"].AsByteArray;
seg_ind_buf.AppendDecompress(seg_ind);
segment_offset = previous_version["up_to"].AsInt32;
if (is_date_time_index && skipAlreadyWrittenDates)
{
long date = seg_ind_buf.Read <long>(seg_ind_buf.Length - 16);
DateTime dt = DateTime64.ToDateTime(date);
var range = df.Index.AsDateTime().RangeOf(dt, 0, df.FilledCount - 1, Location.GT);
if (range.Last <= range.First)
{
Log.Information($"Skipped DataFrame.Append because date {dt} already written for {symbol}");
return(null); // Hey all was skipped
}
else if (range.First != 0)
{
Log.Information($"Skipped DataFrame.Append initial {range.First} elements date {dt} already written for {symbol}");
}
df = df[range];
}
}
var up_to = segment_offset + df.Rows.Count;
var buf = new ByteBuffer();
// add index that is last datetime + 0-based int64 index of last appended record like (segment_count-1)
if (is_date_time_index && df.Rows.Count > 0)
{
var date = df.Index.AsDateTime().Source[-1];
seg_ind_buf.Append <long>(date);
seg_ind_buf.Append <long>(up_to - 1);
}
var seg_ind_buf2 = new ByteBuffer();
seg_ind_buf2.AppendCompress(seg_ind_buf.GetBytes());
version["segment_index"] = seg_ind_buf2.GetBytes();
version["up_to"] = up_to;
var bin = df.ToBuffer();
buf.AppendCompress(bin);
var sha1 = SHA1.Create();
var sha = version.GetValue("sha", null);
if (sha == null)
{
byte[] hashBytes = sha1.ComputeHash(bin);
version["sha"] = new BsonBinaryData(hashBytes);
}
#if false
var buf2 = new ByteBuffer();
buf2.AppendDecompress(buf.GetBytes());
var bin2 = buf2.GetBytes();
if (!bin.SequenceEqual(bin2))
{
throw new InvalidOperationException();
}
var df2 = DataFrame.FromBuffer(bin2, df.DType, df.Rows.Count);
#endif
var segment = new BsonDocument {
{ "symbol", symbol },
{ "data", new BsonBinaryData(buf.GetBytes()) },
{ "compressed", true },
{ "segment", segment_offset + df.Rows.Count - 1 },
{ "parent", new BsonArray {
version["_id"]
} },
};
var hash = new ByteBuffer();
hash.Append(Encoding.ASCII.GetBytes(symbol));
foreach (var key in segment.Names.OrderByDescending(x => x))
{
var value = segment.GetValue(key);
if (value is BsonBinaryData)
{
hash.Append(value.AsByteArray);
}
else
{
var str = value.ToString();
hash.Append(Encoding.ASCII.GetBytes(str));
}
}
segment["sha"] = sha1.ComputeHash(hash.GetBytes());
//await _versions.InsertOneAsync(version);
try {
await _versions.ReplaceOneAsync(BF.Eq("symbol", symbol), version, Upsert);
}catch (MongoWriteException e)
{
Log.Information("Retrying append symbol {symbol}, attempt {attemptNo}", symbol, attemptNo++);
continue;
}
await _segments.InsertOneAsync(segment);
//Log.Information ("inserted new segment {segment} for symbol {symbol}", segment["_id"], symbol);
//Log.Information ("replaced version {0} for symbol {symbol} sha1 {sha}", version["_id"], symbol, sha);
// update parents in versions
//var res = await _segments.UpdateManyAsync (BF.Eq("symbol", symbol), BU.Set ("parent", new BsonArray{ version ["_id"] }));
//Log.Debug ("updated segments parents {0}".Args(res.MatchedCount));
return(version);
}
}
public static extern BOOL DrawEdge(Gdi32.HDC hdc, ref RECT qrc, EDGE edge, BF grfFlags);
public async Task <DataFrame> ReadAsync(string symbol, DateRange range = null, BsonDocument version = null)
{
version = version ?? await ReadVersionAsync(symbol);
if (version == null)
{
return(null);
}
Log.Debug("version: {0}".Args(version));
var buf = new ByteBuffer();
var index = GetSegmentsIndex(version);
var id = version["_id"];
var parent = version.GetValue("base_version_id", null);
if (parent == null)
{
parent = id;
}
var filter = BF.Eq("symbol", symbol) & BF.Eq("parent", parent);
int start_segment = 0;
int end_segment = -1;
if (range != null)
{
foreach (var t in index)
{
if (range.StartDate != default(DateTime) && range.StartDate > t.Item1) // t.Item1 is inclusive end date of segment
{
start_segment = (int)t.Item2 + 1; // should start from next segment
}
if (range.StopDate != default(DateTime) && range.StopDate <= t.Item1 && end_segment == -1)
{
end_segment = (int)t.Item2; // should stop at this segment
}
}
if (start_segment != 0)
{
filter = filter & BF.Gte("segment", start_segment);
}
if (end_segment != -1)
{
filter = filter & BF.Lte("segment", end_segment);
}
}
if (end_segment == -1)
{
end_segment = version["up_to"].AsInt32 - 1;
}
var segments = await this._segments.FindAsync(filter);
int segcount = 0;
while (await segments.MoveNextAsync())
{
foreach (var segment in segments.Current)
{
#if DEBUG
//Log.Debug ("read segment: {0}".Args(segment));
#endif
var chunk = segment["data"].AsByteArray;
if (segment ["compressed"].AsBoolean)
{
buf.AppendDecompress(chunk);
}
else
{
buf.Append(chunk);
}
segcount++;
}
}
var metadata = version.GetValue("metadata", new BsonDocument()).AsBsonDocument;
if (segcount == 0)
{
//var df1 = new DataFrame();
//df1.Metadata = metadata;
//return df1;
//throw new InvalidOperationException("No segments found for {0}".Args(version));
}
var nrows = end_segment - start_segment + 1;
var dtype = version ["dtype"].AsString;
var buftype = new DType(dtype);
var bytes = buf.GetBytes();
Log.Debug("converting to dataframe up_to={0} dtype={1} len={2}".Args(nrows, dtype, bytes.Length));
var df = DataFrame.FromBuffer(buf.GetBytes(), buftype, nrows);
var meta = version["dtype_metadata"].AsBsonDocument;
var index_name = meta.GetValue("index", new BsonArray()).AsBsonArray[0];
if (index_name != null)
{
df.Index = df.Columns[index_name.AsString];
}
df.Metadata = metadata;
df.Name = symbol;
df.FilledCount = df.Rows.Count;
// TODO: Filter first/last segment
return(df);
}
void ReadAllRegisters()
{
uint data;
data = m_hmc.ReadRegister(HMC704LP4E_REGS.ID);
m_allRegs.chipId = BF.CreateBitField <CHIP_ID>(data);
Console.WriteLine("m_allRegs.ID {0:X}", m_allRegs.chipId.ToUInt32());
if (m_allRegs.chipId.ToUInt32() != 0xA7975)
{
throw (new SystemException("Chip ID expected to be 0xA7975"));
}
data = m_hmc.ReadRegister(HMC704LP4E_REGS.RST);
m_allRegs.reg1Rst = BF.CreateBitField <REG1_RST>(data);
Console.WriteLine("m_allRegs.reg1Rst {0:X}", m_allRegs.reg1Rst.ToUInt32());
data = m_hmc.ReadRegister(HMC704LP4E_REGS.REFDIV);
m_allRegs.regRefDiv = BF.CreateBitField <REG2_REFDIV>(data);
Console.WriteLine("m_allRegs.regRefDiv {0:X}", m_allRegs.regRefDiv.ToUInt32());
data = m_hmc.ReadRegister(HMC704LP4E_REGS.FrequencyRegisterIntegerPart);
m_allRegs.regFreqInt = BF.CreateBitField <REG3_FrequencyIntegerPart>(data);
Console.WriteLine("m_allRegs.regFreqInt {0:X}", m_allRegs.regFreqInt.ToUInt32());
data = m_hmc.ReadRegister(HMC704LP4E_REGS.FrequencyRegisterFractionalPart);
m_allRegs.regFreqFrac = BF.CreateBitField <REG4_FrequencyFractionaPart>(data);
Console.WriteLine("m_allRegs.regFreqFrac {0:X}", m_allRegs.regFreqFrac.ToUInt32());
data = m_hmc.ReadRegister(HMC704LP4E_REGS.REG5_Seed);
m_allRegs.regAuxSPI = BF.CreateBitField <REG5_AuxSPI>(data);
Console.WriteLine("m_allRegs.regSeed {0:X}", m_allRegs.regAuxSPI.ToUInt32());
data = m_hmc.ReadRegister(HMC704LP4E_REGS.REG6_SD_CFG);
m_allRegs.reg6SdCfg = BF.CreateBitField <REG6_SDCFG>(data);
Console.WriteLine("m_allRegs.regSdCfg {0:X}", m_allRegs.reg6SdCfg.ToUInt32());
data = m_hmc.ReadRegister(HMC704LP4E_REGS.REG7_LockDetect);
m_allRegs.regLockDetect = BF.CreateBitField <REG7_LockDetect>(data);
Console.WriteLine("m_allRegs.regLockDetect {0:X}", m_allRegs.regLockDetect.ToUInt32());
data = m_hmc.ReadRegister(HMC704LP4E_REGS.REG8_AnalogEN);
m_allRegs.regAnalogEn = BF.CreateBitField <REG8_AnalogEN>(data);
Console.WriteLine("m_allRegs.regAnalogEn {0:X}", m_allRegs.regAnalogEn.ToUInt32());
data = m_hmc.ReadRegister(HMC704LP4E_REGS.REG9_ChargePump);
m_allRegs.regChargePump = BF.CreateBitField <REG9_ChargePump>(data);
Console.WriteLine("m_allRegs.regChargePump {0:X}", m_allRegs.regChargePump.ToUInt32());
data = m_hmc.ReadRegister(HMC704LP4E_REGS.REGA_AuxSPITrigger);
m_allRegs.regAuxSPITrigger = BF.CreateBitField <REG10_AuxSPITrigger>(data);
Console.WriteLine("m_allRegs.regModulationStep {0:X}", m_allRegs.regAuxSPITrigger.ToUInt32());
data = m_hmc.ReadRegister(HMC704LP4E_REGS.REGB_PD);
m_allRegs.regPd = BF.CreateBitField <REG11_PD>(data);
Console.WriteLine("m_allRegs.regPd {0:X}", m_allRegs.regPd.ToUInt64());
data = m_hmc.ReadRegister(HMC704LP4E_REGS.REGF_GPO);
m_allRegs.regGPO = BF.CreateBitField <REG15_GPO>(data);
Console.WriteLine("m_allRegs.regGPO {0:X}", m_allRegs.regGPO.ToUInt32());
data = m_hmc.ReadRegister(HMC704LP4E_REGS.REG12_GPO2);
m_allRegs.regGP02 = BF.CreateBitField <REG18_GPO2>(data);
Console.WriteLine("m_allRegs.regGP02 {0:X}", m_allRegs.regGP02.ToUInt32());
data = m_hmc.ReadRegister(HMC704LP4E_REGS.REG13_BISTStatus);
m_allRegs.regBitsStatus = BF.CreateBitField <REG19_BISTStatus>(data);
Console.WriteLine("m_allRegs.regBitsStatus {0:X}", m_allRegs.regBitsStatus.ToUInt32());
}
private static extern BOOL DrawEdge(IntPtr hdc, ref RECT qrc, EDGE edge, BF grfFlags);
protected override void BinaryFormatterCore(Stream stream)
{
BF.Serialize(stream, this.input);
}
