internal override void ReadField(RecordReader reader)
{
while (!reader.IsEndOfSegment)
{
List.Add(reader.ReadReference(FormKindSet.Any));
}
}
internal UnknownRecordField(UnknownRecord record, ref RecordReader reader)
: base(record, reader.Field.Type)
{
RecordField field = reader.Field;
Data = reader.Reader.ReadBytes(field.Size);
}
public FormLoader(Plugin plugin, RecordReader stockReader, bool lazyLoading, int backgroundJobs)
{
if (backgroundJobs < 0)
throw new ArgumentException("Number of bakcground jobs must be a positive integer or zero");
sharedData = new SharedData()
{
Plugin = plugin,
StockReader = stockReader,
LazyLoading = lazyLoading,
FormsToLoad = new BlockingCollection<Form>(new ConcurrentQueue<Form>(), 1024),
WorkerCompleteEvent = new AutoResetEvent(false)
};
this.stockReader = stockReader;
asyncLoading = backgroundJobs > 0;
bool useStockReader = true;
while (backgroundJobs-- > 0)
{
Worker worker = new Worker(sharedData, useStockReader);
worker.RunWorkerCompleted += Worker_RunWorkerCompleted;
worker.RunWorkerAsync();
workers.Add(new WorkerInfo()
{
Worker = worker
});
// Only the first worker can use the stock reader
useStockReader = false;
}
}
internal UnknownRecord(Module module, RecordReader reader)
: base(module, reader)
{
while (reader.ReadField()) {
new UnknownRecordField(this, ref reader);
}
}
public RecordKEY(RecordReader rr)
{
FLAGS = rr.ReadUInt16();
PROTOCOL = rr.ReadByte();
ALGORITHM = rr.ReadByte();
PUBLICKEY = rr.ReadString();
}
public RecordNXT(RecordReader rr)
{
ushort length = rr.ReadUInt16(-2);
NEXTDOMAINNAME = rr.ReadDomainName();
length -= (ushort)rr.Position;
BITMAP = new byte[length];
BITMAP = rr.ReadBytes(length);
}
///<summary>
///</summary>
///<param name="rr"></param>
public RecordA(RecordReader rr)
{
IPAddress.TryParse(string.Format("{0}.{1}.{2}.{3}",
rr.ReadByte(),
rr.ReadByte(),
rr.ReadByte(),
rr.ReadByte()), out Address);
}
///<summary>
///</summary>
///<param name="rr"></param>
public RecordNULL(RecordReader rr)
{
rr.Position -= 2;
// re-read length
var rdlength = rr.ReadUInt16();
Anything = new byte[rdlength];
Anything = rr.ReadBytes(rdlength);
}
///<summary>
///</summary>
///<param name="rr"></param>
public RecordNAPTR(RecordReader rr)
{
Order = rr.ReadUInt16();
Preference = rr.ReadUInt16();
Flags = rr.ReadString();
Services = rr.ReadString();
Regexp = rr.ReadString();
Replacement = rr.ReadDomainName();
}
/// <summary>
/// Randomize the split order, then take the specified number of keys from
/// each split sampled, where each key is selected with the specified
/// probability and possibly replaced by a subsequently selected key when
/// the quota of keys from that split is satisfied.
/// </summary>
/// <exception cref="System.IO.IOException"/>
public virtual K[] GetSample(InputFormat <K, V> inf, JobConf job)
{
// ArrayList::toArray doesn't preserve type
InputSplit[] splits = inf.GetSplits(job, job.GetNumMapTasks());
AList <K> samples = new AList <K>(numSamples);
int splitsToSample = Math.Min(maxSplitsSampled, splits.Length);
Random r = new Random();
long seed = r.NextLong();
r.SetSeed(seed);
Log.Debug("seed: " + seed);
// shuffle splits
for (int i = 0; i < splits.Length; ++i)
{
InputSplit tmp = splits[i];
int j = r.Next(splits.Length);
splits[i] = splits[j];
splits[j] = tmp;
}
// our target rate is in terms of the maximum number of sample splits,
// but we accept the possibility of sampling additional splits to hit
// the target sample keyset
for (int i_1 = 0; i_1 < splitsToSample || (i_1 < splits.Length && samples.Count <
numSamples); ++i_1)
{
RecordReader <K, V> reader = inf.GetRecordReader(splits[i_1], job, Reporter.Null);
K key = reader.CreateKey();
V value = reader.CreateValue();
while (reader.Next(key, value))
{
if (r.NextDouble() <= freq)
{
if (samples.Count < numSamples)
{
samples.AddItem(key);
}
else
{
// When exceeding the maximum number of samples, replace a
// random element with this one, then adjust the frequency
// to reflect the possibility of existing elements being
// pushed out
int ind = r.Next(numSamples);
if (ind != numSamples)
{
samples.Set(ind, key);
}
freq *= (numSamples - 1) / (double)numSamples;
}
key = reader.CreateKey();
}
}
reader.Close();
}
return((K[])Sharpen.Collections.ToArray(samples));
}
/// <exception cref="System.IO.IOException"/>
/// <exception cref="System.Exception"/>
public MapRunner(Chain _enclosing, Mapper <KEYIN, VALUEIN, KEYOUT, VALUEOUT> mapper
, Mapper.Context mapperContext, RecordReader <KEYIN, VALUEIN> rr, RecordWriter <KEYOUT
, VALUEOUT> rw)
{
this._enclosing = _enclosing;
this.mapper = mapper;
this.rr = rr;
this.rw = rw;
this.chainContext = mapperContext;
}
public NSAPPTRRecord(RR rr, RecordReader recordReader)
: base(rr)
{
if (recordReader == null)
{
throw new ArgumentNullException("recordReader");
}
m_owner = recordReader.ReadString();
}
public RecordTxt(RecordReader rr, int length)
{
int pos = rr.Position;
Txt = new List <string>();
while ((rr.Position - pos) < length)
{
Txt.Add(rr.ReadString());
}
}
public RecordSOA(RecordReader rr)
{
MNAME = rr.ReadDomainName();
RNAME = rr.ReadDomainName();
SERIAL = rr.ReadUInt32();
REFRESH = rr.ReadUInt32();
RETRY = rr.ReadUInt32();
EXPIRE = rr.ReadUInt32();
MINIMUM = rr.ReadUInt32();
}
public X25Record(RR rr, RecordReader recordReader)
: base(rr)
{
if (recordReader == null)
{
throw new ArgumentNullException("recordReader");
}
m_psdnAddress = recordReader.ReadString();
}
public RecordLOC(RecordReader rr)
{
VERSION = rr.ReadByte(); // must be 0!
SIZE = rr.ReadByte();
HORIZPRE = rr.ReadByte();
VERTPRE = rr.ReadByte();
LATITUDE = rr.ReadUInt32();
LONGITUDE = rr.ReadUInt32();
ALTITUDE = rr.ReadUInt32();
}
public X25Record(RR rr, RecordReader recordReader)
: base(rr)
{
if (recordReader == null)
{
throw new ArgumentNullException("recordReader");
}
m_psdnAddress = recordReader.ReadString();
}
public void should_correctly_handle_a_record()
{
var ip = IPAddress.Parse("192.168.1.1");
var bytes = ip.GetAddressBytes();
var reader = new RecordReader(bytes);
var recordA = new RecordA(reader);
Assert.AreEqual("192.168.1.1", recordA.ToString());
}
public ARecord(RR rr, RecordReader recordReader)
: base(rr)
{
if (recordReader == null)
{
throw new ArgumentNullException("recordReader");
}
m_address = new IPAddress(recordReader.ReadBytes(4));
}
public NSAPPTRRecord(RR rr, RecordReader recordReader)
: base(rr)
{
if (recordReader == null)
{
throw new ArgumentNullException("recordReader");
}
m_owner = recordReader.ReadString();
}
public RecordSoa(RecordReader rr)
{
Mname = rr.ReadDomainName();
Rname = rr.ReadDomainName();
Serial = rr.ReadUInt32();
Refresh = rr.ReadUInt32();
Retry = rr.ReadUInt32();
Expire = rr.ReadUInt32();
Minimum = rr.ReadUInt32();
}
public RecordWks(RecordReader rr)
{
ushort length = rr.ReadUInt16(-2);
Address = $"{rr.ReadByte()}.{rr.ReadByte()}.{rr.ReadByte()}.{rr.ReadByte()}";
Protocol = rr.ReadByte();
length -= 5;
Bitmap = new byte[length];
Bitmap = rr.ReadBytes(length);
}
public void CreateWriterFromReaderTest()
{
const string fullPath = @"outputBin.cfg";
var reader = new RecordReader(fullPath);
var writer = new RecordWriter(reader);
writer.SaveToFile(fullPathAsciiTwo, DataFileType.ASCII);
//TODO add test - open the configured one and check the equality to the original binary
}
public MDRecord(RR rr, RecordReader recordReader)
: base(rr)
{
if (recordReader == null)
{
throw new ArgumentNullException("recordReader");
}
m_madName = recordReader.ReadDomainName();
}
public ARecord(RR rr, RecordReader recordReader)
: base(rr)
{
if (recordReader == null)
{
throw new ArgumentNullException("recordReader");
}
m_address = new IPAddress(recordReader.ReadBytes(4));
}
public RecordSOA(RecordReader rr)
{
MNAME = rr.ReadDomainName();
RNAME = rr.ReadDomainName();
SERIAL = rr.ReadUInt32();
REFRESH = rr.ReadUInt32();
RETRY = rr.ReadUInt32();
EXPIRE = rr.ReadUInt32();
MINIMUM = rr.ReadUInt32();
}
public MGRecord(RR rr, RecordReader recordReader)
: base(rr)
{
if (recordReader == null)
{
throw new ArgumentNullException("recordReader");
}
m_mgmName = recordReader.ReadDomainName();
}
protected override void AfterRead(RecordReader reader)
{
// Pull localized string if needed and replace data
if (Type == 's' && reader.PluginFlags.HasFlag(PluginFlags.Localized))
{
uint index = BitConverter.ToUInt32(Data.Bytes, 0);
string localized = reader.GetLocalizedString(LocalizedStringGroups.Strings, index);
Data.Bytes = GetStringZeroTerminatedBytes(localized);
}
}
public RecordDS(RecordReader rr)
{
ushort length = rr.ReadUInt16(-2);
KEYTAG = rr.ReadUInt16();
ALGORITHM = rr.ReadByte();
DIGESTTYPE = rr.ReadByte();
length -= 4;
DIGEST = new byte[length];
DIGEST = rr.ReadBytes(length);
}
public RecordLoc(RecordReader rr)
{
Version = rr.ReadByte(); // must be 0!
Size = rr.ReadByte();
Horizpre = rr.ReadByte();
Vertpre = rr.ReadByte();
Latitude = rr.ReadUInt32();
Longitude = rr.ReadUInt32();
Altitude = rr.ReadUInt32();
}
/// <exception cref="System.Exception"/>
public virtual void TestFormat()
{
JobConf job = new JobConf(conf);
Reporter reporter = Reporter.Null;
Random random = new Random();
long seed = random.NextLong();
Log.Info("seed = " + seed);
random.SetSeed(seed);
localFs.Delete(workDir, true);
FileInputFormat.SetInputPaths(job, workDir);
int length = 10000;
int numFiles = 10;
// create a file with various lengths
CreateFiles(length, numFiles, random);
// create a combine split for the files
InputFormat <IntWritable, BytesWritable> format = new CombineSequenceFileInputFormat
<IntWritable, BytesWritable>();
IntWritable key = new IntWritable();
BytesWritable value = new BytesWritable();
for (int i = 0; i < 3; i++)
{
int numSplits = random.Next(length / (SequenceFile.SyncInterval / 20)) + 1;
Log.Info("splitting: requesting = " + numSplits);
InputSplit[] splits = format.GetSplits(job, numSplits);
Log.Info("splitting: got = " + splits.Length);
// we should have a single split as the length is comfortably smaller than
// the block size
NUnit.Framework.Assert.AreEqual("We got more than one splits!", 1, splits.Length);
InputSplit split = splits[0];
NUnit.Framework.Assert.AreEqual("It should be CombineFileSplit", typeof(CombineFileSplit
), split.GetType());
// check each split
BitSet bits = new BitSet(length);
RecordReader <IntWritable, BytesWritable> reader = format.GetRecordReader(split, job
, reporter);
try
{
while (reader.Next(key, value))
{
NUnit.Framework.Assert.IsFalse("Key in multiple partitions.", bits.Get(key.Get())
);
bits.Set(key.Get());
}
}
finally
{
reader.Close();
}
NUnit.Framework.Assert.AreEqual("Some keys in no partition.", length, bits.Cardinality
());
}
}
/// <summary>Run the map task.</summary>
/// <param name="input">the set of inputs</param>
/// <param name="output">the object to collect the outputs of the map</param>
/// <param name="reporter">the object to update with status</param>
/// <exception cref="System.IO.IOException"/>
public override void Run(RecordReader <K1, V1> input, OutputCollector <K2, V2> output
, Reporter reporter)
{
Application <K1, V1, K2, V2> application = null;
try
{
RecordReader <FloatWritable, NullWritable> fakeInput = (!Submitter.GetIsJavaRecordReader
(job) && !Submitter.GetIsJavaMapper(job)) ? (RecordReader <FloatWritable, NullWritable
>)input : null;
application = new Application <K1, V1, K2, V2>(job, fakeInput, output, reporter, (
Type)job.GetOutputKeyClass(), (Type)job.GetOutputValueClass());
}
catch (Exception ie)
{
throw new RuntimeException("interrupted", ie);
}
DownwardProtocol <K1, V1> downlink = application.GetDownlink();
bool isJavaInput = Submitter.GetIsJavaRecordReader(job);
downlink.RunMap(reporter.GetInputSplit(), job.GetNumReduceTasks(), isJavaInput);
bool skipping = job.GetBoolean(MRJobConfig.SkipRecords, false);
try
{
if (isJavaInput)
{
// allocate key & value instances that are re-used for all entries
K1 key = input.CreateKey();
V1 value = input.CreateValue();
downlink.SetInputTypes(key.GetType().FullName, value.GetType().FullName);
while (input.Next(key, value))
{
// map pair to output
downlink.MapItem(key, value);
if (skipping)
{
//flush the streams on every record input if running in skip mode
//so that we don't buffer other records surrounding a bad record.
downlink.Flush();
}
}
downlink.EndOfInput();
}
application.WaitForFinish();
}
catch (Exception t)
{
application.Abort(t);
}
finally
{
application.Cleanup();
}
}
internal override void ReadField(RecordReader reader)
{
// Read flags and skip 3 bytes
Flags = (ConditionFlags)reader.ReadByte();
reader.Seek(3);
// Read either global variable reference or float
if (Flags.HasFlag(ConditionFlags.UseGlobal))
{
Operand.GlobalVariable = reader.ReadReference(FormKindSet.GlobOnly);
}
else
{
Operand.FloatValue = reader.ReadSingle();
}
// Read function code and skip 2 bytes
Function = (Function)reader.ReadUInt16();
reader.Seek(2);
// Warn if unknown function - no enum value is defined for it
if (!Enum.IsDefined(typeof(Function), Function))
{
Log.Warning("Function '{0}' was not recorgnised and any of parameter references may have may get scrambled.", Function);
}
// Find function signature
var signature = SignatureProvider.Default.GetSignature(Function);
// Read function params
// References must be read with ReadReference function
if (signature[0].IsReference)
{
Params.UInt32_0 = reader.ReadReference(signature[0].Reference);
}
else
{
Params.Int32_0 = reader.ReadInt32();
}
if (signature[1].IsReference)
{
Params.UInt32_1 = reader.ReadReference(signature[1].Reference);
}
else
{
Params.Int32_1 = reader.ReadInt32();
}
Target = (FunctionTarget)reader.ReadUInt32();
TargetReference = reader.ReadReference(FormKindSet.Any);
// Third parameter
IntParam3 = reader.ReadInt32();
}
public AFSDBRecord(RR rr, RecordReader recordReader)
: base(rr)
{
if (recordReader == null)
{
throw new ArgumentNullException("recordReader");
}
m_subtype = recordReader.ReadUInt16();
m_hostName = recordReader.ReadDomainName();
}
public AFSDBRecord(RR rr, RecordReader recordReader)
: base(rr)
{
if (recordReader == null)
{
throw new ArgumentNullException("recordReader");
}
m_subtype = recordReader.ReadUInt16();
m_hostName = recordReader.ReadDomainName();
}
/// <summary>Constructs the DelegatingRecordReader.</summary>
/// <param name="split">TaggegInputSplit object</param>
/// <param name="context">TaskAttemptContext object</param>
/// <exception cref="System.IO.IOException"/>
/// <exception cref="System.Exception"/>
public DelegatingRecordReader(InputSplit split, TaskAttemptContext context)
{
// Find the InputFormat and then the RecordReader from the
// TaggedInputSplit.
TaggedInputSplit taggedInputSplit = (TaggedInputSplit)split;
InputFormat <K, V> inputFormat = (InputFormat <K, V>)ReflectionUtils.NewInstance(taggedInputSplit
.GetInputFormatClass(), context.GetConfiguration());
originalRR = inputFormat.CreateRecordReader(taggedInputSplit.GetInputSplit(), context
);
}
public MINFORecord(RR rr, RecordReader recordReader)
: base(rr)
{
if (recordReader == null)
{
throw new ArgumentNullException("recordReader");
}
m_rMailBx = recordReader.ReadDomainName();
m_eMailBx = recordReader.ReadDomainName();
}
internal override void ReadField(RecordReader reader)
{
Strength = reader.ReadSingle();
Distance = reader.ReadSingle();
Range = reader.ReadSingle();
if (!reader.IsEndOfSegment)
{
Radius = reader.ReadSingle();
}
}
public NULLRecord(RR rr, RecordReader recordReader)
: base(rr)
{
if (recordReader == null)
{
throw new ArgumentNullException("recordReader");
}
var count = recordReader.ReadUInt16(-1);
m_anything = recordReader.ReadBytes(count);
}
public MXRecord(RR rr, RecordReader recordReader)
: base(rr)
{
if (recordReader == null)
{
throw new ArgumentNullException("recordReader");
}
m_preference = recordReader.ReadUInt16();
m_exchange = recordReader.ReadDomainName();
}
internal override void ReadField(RecordReader reader)
{
DayNear = reader.ReadSingle();
DayFar = reader.ReadSingle();
NightNear = reader.ReadSingle();
NightFar = reader.ReadSingle();
DayPow = reader.ReadSingle();
NightPow = reader.ReadSingle();
DayMax = reader.ReadSingle();
NightMax = reader.ReadSingle();
}
public RecordDS(RecordReader rr)
{
ushort length = rr.ReadUInt16(-2);
KEYTAG = rr.ReadUInt16();
ALGORITHM = rr.ReadByte();
DIGESTTYPE = rr.ReadByte();
length -= 4;
DIGEST = new byte[length];
DIGEST = rr.ReadBytes(length);
}
public NSAPRecord(RR rr, RecordReader recordReader)
: base(rr)
{
if (recordReader == null)
{
throw new ArgumentNullException("recordReader");
}
m_length = recordReader.ReadUInt16();
m_nsapAddress = recordReader.ReadBytes(m_length);
}
public HINFORecord(RR rr, RecordReader recordReader)
: base(rr)
{
if (recordReader == null)
{
throw new ArgumentNullException("recordReader");
}
m_cpu = recordReader.ReadString();
m_os = recordReader.ReadString();
}
public RTRecord(RR rr, RecordReader recordReader)
: base(rr)
{
if (recordReader == null)
{
throw new ArgumentNullException("recordReader");
}
m_preference = recordReader.ReadUInt16();
m_intermediateHost = recordReader.ReadDomainName();
}
public NSAPRecord(RR rr, RecordReader recordReader)
: base(rr)
{
if (recordReader == null)
{
throw new ArgumentNullException("recordReader");
}
m_length = recordReader.ReadUInt16();
m_nsapAddress = recordReader.ReadBytes(m_length);
}
public HINFORecord(RR rr, RecordReader recordReader)
: base(rr)
{
if (recordReader == null)
{
throw new ArgumentNullException("recordReader");
}
m_cpu = recordReader.ReadString();
m_os = recordReader.ReadString();
}
/// <summary>
/// Create a map context that is based on ChainMapContext and the given record
/// reader and record writer
/// </summary>
private Mapper.Context CreateMapContext <Keyin, Valuein, Keyout, Valueout>(RecordReader
<KEYIN, VALUEIN> rr, RecordWriter <KEYOUT, VALUEOUT> rw, TaskInputOutputContext <KEYIN
, VALUEIN, KEYOUT, VALUEOUT> context, Configuration conf)
{
MapContext <KEYIN, VALUEIN, KEYOUT, VALUEOUT> mapContext = new ChainMapContextImpl
<KEYIN, VALUEIN, KEYOUT, VALUEOUT>(context, rr, rw, conf);
Mapper.Context mapperContext = new WrappedMapper <KEYIN, VALUEIN, KEYOUT, VALUEOUT
>().GetMapContext(mapContext);
return(mapperContext);
}
public MINFORecord(RR rr, RecordReader recordReader)
: base(rr)
{
if (recordReader == null)
{
throw new ArgumentNullException("recordReader");
}
m_rMailBx = recordReader.ReadDomainName();
m_eMailBx = recordReader.ReadDomainName();
}
public APLRecord(RR rr, RecordReader recordReader)
: base(rr)
{
if (recordReader == null)
{
throw new ArgumentNullException("recordReader");
}
var count = recordReader.ReadUInt16(-2);
m_rdata = recordReader.ReadBytes(count);
}
internal override void ReadField(RecordReader reader)
{
Damage = reader.ReadUInt16();
Unknown = reader.ReadUInt16();
Multiplier = reader.ReadSingle();
Flags = (CriticalFlags)reader.ReadUInt32();
SpellEffect = reader.ReadReference(FormKindSet.SpelOnly);
Unknown1 = reader.ReadUInt32();
Unknown2 = reader.ReadUInt32();
}
public RTRecord(RR rr, RecordReader recordReader)
: base(rr)
{
if (recordReader == null)
{
throw new ArgumentNullException("recordReader");
}
m_preference = recordReader.ReadUInt16();
m_intermediateHost = recordReader.ReadDomainName();
}
public MXRecord(RR rr, RecordReader recordReader)
: base(rr)
{
if (recordReader == null)
{
throw new ArgumentNullException("recordReader");
}
m_preference = recordReader.ReadUInt16();
m_exchange = recordReader.ReadDomainName();
}
///<summary>
///</summary>
///<param name="rr"></param>
public RecordTSIG(RecordReader rr)
{
AlgorithmName = rr.ReadDomainName();
TimeSigned = rr.ReadUInt32() << 32 | rr.ReadUInt32();
Fudge = rr.ReadUInt16();
MacSize = rr.ReadUInt16();
Mac = rr.ReadBytes(MacSize);
OriginalId = rr.ReadUInt16();
Error = rr.ReadUInt16();
OtherLen = rr.ReadUInt16();
OtherData = rr.ReadBytes(OtherLen);
}
public GPOSRecord(RR rr, RecordReader recordReader)
: base(rr)
{
if (recordReader == null)
{
throw new ArgumentNullException("recordReader");
}
m_longitude = recordReader.ReadString();
m_latitude = recordReader.ReadString();
m_altitude = recordReader.ReadString();
}
///<summary>
///</summary>
///<param name="rr"></param>
public RecordTKEY(RecordReader rr)
{
Algorithm = rr.ReadDomainName();
Inception = rr.ReadUInt32();
Expiration = rr.ReadUInt32();
Mode = rr.ReadUInt16();
Error = rr.ReadUInt16();
Keysize = rr.ReadUInt16();
Keydata = rr.ReadBytes(Keysize);
Othersize = rr.ReadUInt16();
Otherdata = rr.ReadBytes(Othersize);
}
internal void ReadRecord(RecordReader reader, bool lazyLoading)
{
var compinfo = InfoProvider.GetCompoundInfo(GetType());
var recinfo = InfoProvider.GetRecordInfo(GetType());
BeforeRead(reader);
reader.BeginReadFields(0);
HashSet<string> remainingPropertiesToLoad = lazyLoading ? new HashSet<string>(compinfo.Members.Values.Where(m => m.IsLazy).SelectMany(m => m.FieldNames)) : null;
foreach (string propertyName in reader.FindFields())
{
MemberInfo meminf = compinfo.FindMember(propertyName);
if (meminf != null)
{
reader.ReadField(this, propertyName, meminf, 0);
if (remainingPropertiesToLoad != null)
{
if (!meminf.IsListType && !meminf.IsDynamic)
remainingPropertiesToLoad.Remove(propertyName);
if (!remainingPropertiesToLoad.Any())
{
// Loaded all properties that were supposed to
reader.CancelFindFields();
break;
}
}
}
else if (lazyLoading || recinfo.IsDummyRecord)
{
// Prevent segment errors when not all properties were expected to be consumed
reader.SeekEndOfSegment();
}
else
{
Log.Warning("Unexpected record property: {0}", propertyName);
}
}
reader.EndReadFields(0);
//// Make sure list properties that were supposed to be loaded are not null
//foreach (MemberInfo meminfo in members.Where(m => m.Value.IsListType && (fieldsToLoad == null || fieldsToLoad.Contains(m.Key))).Select(m => m.Value))
//{
// meminfo.EnsureListCreated(this);
//}
AfterRead(reader);
}
public RecordWKS(RecordReader rr)
{
ushort length = rr.ReadUInt16(-2);
ADDRESS = string.Format("{0}.{1}.{2}.{3}",
rr.ReadByte(),
rr.ReadByte(),
rr.ReadByte(),
rr.ReadByte());
PROTOCOL = (int)rr.ReadByte();
length -= 5;
BITMAP = new byte[length];
BITMAP = rr.ReadBytes(length);
}
public KEYRecord(RR rr, RecordReader recordReader)
: base(rr)
{
if (recordReader == null)
{
throw new ArgumentNullException("recordReader");
}
m_flags = recordReader.ReadUInt16();
m_protocol = recordReader.ReadByte();
m_algorithm = recordReader.ReadByte();
m_publicKey = recordReader.ReadString();
}
internal void OnComplete(RecordReader reader, int depth)
{
reader.EndReadFields(depth);
// Make sure list fields that were supposed to be loaded are not null
var members = InfoProvider.GetCompoundInfo(GetType()).Members;
foreach (MemberInfo meminfo in members.Where(m => m.Value.IsListType).Select(m => m.Value))
{
meminfo.EnsureListCreated(this);
}
AfterRead(reader);
}
