public Windowed <Bytes> PeekNextKey()
{
if (bytesEnumerator.Current.HasValue)
{
var key = bytesEnumerator.Current?.Key.Get;
return(WindowKeyHelper.FromStoreBytesKey(key, windowSize));
}
else
{
return(null);
}
}
/// <summary>
/// Serialize an <see cref="Windowed{K}"/> instance to byte array
/// </summary>
/// <param name="data">Instance to serialize</param>
/// <param name="context">serialization context</param>
/// <returns>Return an array of byte</returns>
public override byte[] Serialize(Windowed <T> data, SerializationContext context)
{
if (data == null)
{
return(null);
}
var bytesKey = innerSerdes.Serialize(data.Key, context);
var bytes = WindowKeyHelper.ToStoreKeyBinary(bytesKey, data.Window.StartMs, 0);
return(bytes.Get);
}
public void ExtractStoreKeyBytesTest()
{
var bytes = new byte[14] {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13
};
var expected = new byte[2] {
0, 1
};
var r = WindowKeyHelper.ExtractStoreKeyBytes(bytes);
Assert.AreEqual(expected, r);
}
/// <summary>
/// Deserialize data array to <see cref="Windowed{K}"/>
/// </summary>
/// <param name="data">Data array</param>
/// <param name="context">serialization context</param>
/// <returns>Return <see cref="Windowed{K}"/> instance</returns>
public override Windowed <T> Deserialize(byte[] data, SerializationContext context)
{
if (data == null || data.Length == 0)
{
return(null);
}
long start = WindowKeyHelper.ExtractStoreTimestamp(data);
return(new Windowed <T>(
innerSerdes.Deserialize(WindowKeyHelper.ExtractStoreKeyBytes(data), context),
new TimeWindow(start, start + windowSize)));
}
public void ExtractStoreSeqnum()
{
string key = "test";
long ts = DateTime.Now.GetMilliseconds();
int seq = 14;
List <byte> bytes = new List <byte>();
bytes.AddRange(Encoding.UTF8.GetBytes(key));
bytes.AddRange(BitConverter.GetBytes(ts));
bytes.AddRange(BitConverter.GetBytes(seq));
long r = WindowKeyHelper.ExtractStoreSequence(bytes.ToArray());
Assert.AreEqual(seq, r);
}
public Func <IKeyValueEnumerator <Bytes, byte[]>, bool> HasNextCondition(Bytes binaryKeyFrom, Bytes binaryKeyTo, long from, long to)
{
return((enumerator) =>
{
while (enumerator.MoveNext())
{
var bytes = enumerator.PeekNextKey();
Bytes keyBytes = Bytes.Wrap(WindowKeyHelper.ExtractStoreKeyBytes(bytes.Get));
long time = WindowKeyHelper.ExtractStoreTimestamp(bytes.Get);
if ((binaryKeyFrom == null || bytesComparer.Compare(keyBytes, binaryKeyFrom) >= 0) &&
(binaryKeyTo == null || bytesComparer.Compare(keyBytes, binaryKeyTo) <= 0) &&
time >= from &&
time <= to)
{
return true;
}
}
return false;
});
}
public Bytes UpperRangeFixedSize(Bytes key, long to) => WindowKeyHelper.ToStoreKeyBinary(key, to, Int32.MaxValue);
public long SegmentTimestamp(Bytes key) => WindowKeyHelper.ExtractStoreTimestamp(key.Get);
public Bytes LowerRangeFixedSize(Bytes key, long from) => WindowKeyHelper.ToStoreKeyBinary(key, Math.Max(0, from), 0);
public void Put(Bytes key, byte[] value, long windowStartTimestamp) => wrapped.Put(WindowKeyHelper.ToStoreKeyBinary(key, windowStartTimestamp, seqnum), value);
public byte[] Fetch(Bytes key, long time) => wrapped.Get(WindowKeyHelper.ToStoreKeyBinary(key, time, seqnum));
public long PeekNextKey() => WindowKeyHelper.ExtractStoreTimestamp(bytesEnumerator.PeekNextKey().Get);
public void Put(Bytes key, byte[] value, long windowStartTimestamp)
{
wrapped.Put(key, value, windowStartTimestamp);
Publish(WindowKeyHelper.ToStoreKeyBinary(key, windowStartTimestamp, 0), value);
}
