FilesExpand file tree

 master

/

RecordField.cs

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

83 lines (68 loc) · 2.39 KB

 master

/

RecordField.cs

Copy path

Top

File metadata and controls

• Code
• Blame

83 lines (68 loc) · 2.39 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

using DBClientFiles.NET.Collections;

using System;

using System.Collections.Generic;

using System.Runtime.CompilerServices;

namespace DBClientFiles.NET.Types

{

/// <summary>

/// This is a representation of a field where size and type are unknown.

/// </summary>

public unsafe class RecordField

{

private int _recordOffset;

private int _bitCount;

internal RecordField(int offset, int bitCount, Record record)

{

_recordOffset = offset;

_bitCount = bitCount;

Record = record;

}

internal RecordField(int offset, int bitCount, int cardinality, Record record) : this(offset, bitCount, record)

{

// _cardinality = cardinality;

}

[MethodImpl(MethodImplOptions.AggressiveInlining)]

private T Read<T>() where T : unmanaged

{

var byteOffset = _recordOffset / 8;

var bitOffset = _recordOffset & 7;

var dataPtr = (byte*) Unsafe.AsPointer(ref Record.Data[byteOffset]);

return *(T*)dataPtr;

}

public string Name { get; }

public Record Record { get; }

public ulong UInt64 => Read<ulong>();

public uint UInt32 => Read<uint>();

public ushort UInt16 => Read<ushort>();

public byte UInt8 => Read<byte>();

public long Int64 => Read<long>();

public int Int32 => Read<int>();

public short Int16 => Read<short>();

public sbyte Int8 => Read<sbyte>();

public float Single => Read<float>();

public double Double => Read<double>();

public string String => throw new NotImplementedException();

}

/// <summary>

/// This is a representation of a record made of a varying amount of members, unknown at compile time.

/// </summary>

public sealed class Record

{

/// <summary>

/// The backing container.

/// </summary>

internal StorageList List { get; }

/// <summary>

/// The record's underlying data.

/// </summary>

internal byte[] Data { get; }

/// <summary>

/// A collection of members of the record, keyed by their name

/// </summary>

internal IDictionary<String, RecordField> Members { get; }

public RecordField this[string memberName]

{

get { return Members[memberName]; }

}

}

}