public static bool TryDecodeKey <T1>(this IKeyEncoder <T1> decoder, Slice encoded, out T1 item)
{
var reader = new SliceReader(encoded);
//TODO: should we fail if extra bytes?
return(decoder.TryReadKeyFrom(ref reader, out item));
}
public static Slice EncodeKey <T1>([NotNull] this IKeyEncoder <T1> encoder, T1 value)
{
var writer = default(SliceWriter);
encoder.WriteKeyTo(ref writer, value);
return(writer.ToSlice());
}
public static IEnumerable <Slice> EncodeRange <T>(this IKeyEncoder <T> encoder, [NotNull] IEnumerable <T> values)
{
if (encoder == null)
{
throw new ArgumentNullException("encoder");
}
if (values == null)
{
throw new ArgumentNullException("values");
}
// note: T=>Slice usually is used for writing batches as fast as possible, which means that keys will be consumed immediately and don't need to be streamed
var array = values as T[];
if (array != null)
{ // optimized path for arrays
return(EncodeRange <T>(encoder, array));
}
var coll = values as ICollection <T>;
if (coll != null)
{ // optimized path when we know the count
var slices = new List <Slice>(coll.Count);
foreach (var value in coll)
{
slices.Add(encoder.EncodeKey(value));
}
return(slices);
}
// "slow" path
return(values.Select(value => encoder.EncodeKey(value)));
}
internal TypedKeySubspace(Slice prefix, [NotNull] IKeyEncoder <T1> encoder)
: base(prefix)
{
Contract.Requires(encoder != null);
this.KeyEncoder = encoder;
this.Keys = new TypedKeys <T1>(this, this.KeyEncoder);
}
public static IFdbEncoderSubspace <T> CreateEncoder <T>(Slice slice, IKeyEncoder <T> encoder)
{
if (encoder == null)
{
throw new ArgumentNullException("encoder");
}
return(new FdbEncoderSubspace <T>(slice, encoder));
}
public static T1 DecodeKey <T1>([NotNull] this IKeyEncoder <T1> decoder, Slice encoded)
{
var reader = new SliceReader(encoded);
decoder.ReadKeyFrom(ref reader, out T1 item);
//TODO: should we fail if extra bytes?
return(item);
}
public static Slice EncodeKey <T1>([NotNull] this IKeyEncoder <T1> encoder, Slice prefix, T1 value)
{
var writer = new SliceWriter(prefix.Count + 16); // ~16 bytes si T1 = Guid
writer.WriteBytes(in prefix);
encoder.WriteKeyTo(ref writer, value);
return(writer.ToSlice());
}
internal TypedKeys(
[NotNull] TypedKeySubspace <T1> parent,
[NotNull] IKeyEncoder <T1> encoder)
{
Contract.Requires(parent != null && encoder != null);
this.Parent = parent;
this.Encoder = encoder;
}
/// <summary>
/// Create an instance of this service.
/// </summary>
/// <param name="mapper">Object mapper.</param>
/// <param name="objectService">Service class for managing object operations.</param>
/// <param name="keyEncoder">Service for encoding/decoding an object's unique identifier.</param>
public DtoService(
IMapper mapper,
IObjectService <TEntity, TEntityKey> objectService,
IKeyEncoder <TDtoKey, TDtoKey> keyEncoder = null)
{
Mapper = mapper;
ObjectService = objectService;
KeyEncoder = keyEncoder;
}
internal FdbEncoderSubspace(Slice rawPrefix, bool copy, [NotNull] IKeyEncoder <T> encoder)
: base(rawPrefix, copy)
{
if (encoder == null)
{
throw new ArgumentNullException("encoder");
}
m_encoder = encoder;
m_keys = new FdbEncoderSubspaceKeys <T>(this, encoder);
}
public FdbEncoderSubspace([NotNull] FdbSubspace subspace, [NotNull] IKeyEncoder <T> encoder)
: base(subspace)
{
if (subspace == null)
{
throw new ArgumentNullException("subspace");
}
if (encoder == null)
{
throw new ArgumentNullException("encoder");
}
m_parent = subspace;
m_encoder = encoder;
}
/// <summary>Create a new counter map, using a specific key encoder.</summary>
public FdbCounterMap(FdbSubspace subspace, IKeyEncoder <TKey> keyEncoder)
{
if (subspace == null)
{
throw new ArgumentNullException("subspace");
}
if (keyEncoder == null)
{
throw new ArgumentNullException("keyEncoder");
}
this.Subspace = subspace;
this.KeyEncoder = keyEncoder;
this.Location = new FdbEncoderSubspace <TKey>(subspace, keyEncoder);
}
public static IEnumerable <T> DecodeRange <T>(this IKeyEncoder <T> encoder, [NotNull] IEnumerable <Slice> slices)
{
if (encoder == null)
{
throw new ArgumentNullException("encoder");
}
if (slices == null)
{
throw new ArgumentNullException("slices");
}
// Slice=>T may be filtered in LINQ queries, so we should probably stream the values (so no optimization needed)
return(slices.Select(slice => encoder.DecodeKey(slice)));
}
public T[] DecodeKeys <T>([NotNull] IKeyEncoder <T> keyEncoder)
{
if (keyEncoder == null)
{
throw new ArgumentNullException("keyEncoder");
}
var results = new T[this.Count];
for (int i = 0; i < results.Length; i++)
{
results[i] = keyEncoder.DecodeKey(this.Chunk[i].Key);
}
return(results);
}
/// <summary>Create a new counter map, using a specific key encoder.</summary>
public FdbCounterMap([NotNull] IFdbSubspace subspace, [NotNull] IKeyEncoder <TKey> keyEncoder)
{
if (subspace == null)
{
throw new ArgumentNullException("subspace");
}
if (keyEncoder == null)
{
throw new ArgumentNullException("keyEncoder");
}
this.Subspace = subspace;
this.KeyEncoder = keyEncoder;
this.Location = subspace.UsingEncoder(keyEncoder);
}
public T[] DecodeKeys <T>([NotNull] FdbSubspace subspace, [NotNull] IKeyEncoder <T> keyEncoder)
{
if (subspace == null)
{
throw new ArgumentNullException("subspace");
}
if (keyEncoder == null)
{
throw new ArgumentNullException("keyEncoder");
}
var results = new T[this.Count];
for (int i = 0; i < results.Length; i++)
{
results[i] = keyEncoder.DecodeKey(subspace.ExtractKey(this.Chunk[i].Key, boundCheck: true));
}
return(results);
}
public static Slice[] EncodeRange <T>(this IKeyEncoder <T> encoder, [NotNull] T[] values)
{
if (encoder == null)
{
throw new ArgumentNullException("encoder");
}
if (values == null)
{
throw new ArgumentNullException("values");
}
var slices = new Slice[values.Length];
for (int i = 0; i < values.Length; i++)
{
slices[i] = encoder.EncodeKey(values[i]);
}
return(slices);
}
public static T[] DecodeRange <T>(this IKeyEncoder <T> encoder, [NotNull] Slice[] slices)
{
if (encoder == null)
{
throw new ArgumentNullException("encoder");
}
if (slices == null)
{
throw new ArgumentNullException("slices");
}
var values = new T[slices.Length];
for (int i = 0; i < slices.Length; i++)
{
values[i] = encoder.DecodeKey(slices[i]);
}
return(values);
}
public static T[] DecodeRange <T>(this IKeyEncoder <T> encoder, [NotNull] KeyValuePair <Slice, Slice>[] items)
{
if (encoder == null)
{
throw new ArgumentNullException("encoder");
}
if (items == null)
{
throw new ArgumentNullException("items");
}
var values = new T[items.Length];
for (int i = 0; i < items.Length; i++)
{
values[i] = encoder.DecodeKey(items[i].Key);
}
return(values);
}
public static Slice[] EncodeKeys <TKey, TElement>([NotNull] this IKeyEncoder <TKey> encoder, [NotNull] IEnumerable <TElement> elements, Func <TElement, TKey> selector)
{
if (encoder == null)
{
throw new ArgumentNullException("encoder");
}
if (elements == null)
{
throw new ArgumentNullException("elements");
}
if (selector == null)
{
throw new ArgumentNullException("selector");
}
TElement[] arr;
ICollection <TElement> coll;
if ((arr = elements as TElement[]) != null)
{ // fast path for arrays
return(EncodeKeys <TKey, TElement>(encoder, arr, selector));
}
else if ((coll = elements as ICollection <TElement>) != null)
{ // we can pre-allocate the result array
var slices = new Slice[coll.Count];
int p = 0;
foreach (var item in coll)
{
slices[p++] = encoder.EncodeKey(selector(item));
}
return(slices);
}
else
{ // slow path
return(elements
.Select((item) => encoder.EncodeKey(selector(item)))
.ToArray());
}
}
public static Slice[] EncodeRange <TKey, TElement>(this IKeyEncoder <TKey> encoder, [NotNull] TElement[] elements, Func <TElement, TKey> selector)
{
if (encoder == null)
{
throw new ArgumentNullException("encoder");
}
if (elements == null)
{
throw new ArgumentNullException("elements");
}
if (selector == null)
{
throw new ArgumentNullException("selector");
}
var slices = new Slice[elements.Length];
for (int i = 0; i < elements.Length; i++)
{
slices[i] = encoder.EncodeKey(selector(elements[i]));
}
return(slices);
}
public FdbMap([NotNull] string name, [NotNull] IFdbSubspace subspace, [NotNull] IKeyEncoder <TKey> keyEncoder, [NotNull] IValueEncoder <TValue> valueEncoder)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (subspace == null)
{
throw new ArgumentNullException("subspace");
}
if (keyEncoder == null)
{
throw new ArgumentNullException("keyEncoder");
}
if (valueEncoder == null)
{
throw new ArgumentNullException("valueEncoder");
}
this.Name = name;
this.Subspace = subspace;
this.Location = subspace.UsingEncoder(keyEncoder);
this.ValueEncoder = valueEncoder;
}
public KeyValuePair <TKey, TValue>[] Decode <TKey, TValue>([NotNull] IKeyEncoder <TKey> keyEncoder, [NotNull] IValueEncoder <TValue> valueEncoder)
{
if (keyEncoder == null)
{
throw new ArgumentNullException("keyEncoder");
}
if (valueEncoder == null)
{
throw new ArgumentNullException("valueEncoder");
}
var chunk = this.Chunk;
var results = new KeyValuePair <TKey, TValue> [chunk.Length];
for (int i = 0; i < chunk.Length; i++)
{
results[i] = new KeyValuePair <TKey, TValue>(
keyEncoder.DecodeKey(chunk[i].Key),
valueEncoder.DecodeValue(chunk[i].Value)
);
}
return(results);
}
public IFdbEncoderSubspace <TNext> ByKey <TNext>(T1 value1, T2 value2, T3 value3, T4 value4, [NotNull] IKeyEncoder <TNext> encoder)
{
return(FdbSubspace.CreateEncoder <TNext>(this.Subspace.ConcatKey(this.Encoder.EncodeKey(value1, value2, value3, value4)), encoder));
}
public FdbCompressedBitmapIndex([NotNull] string name, [NotNull] FdbSubspace subspace, IEqualityComparer <TValue> valueComparer, bool indexNullValues, [NotNull] IKeyEncoder <TValue> encoder)
{
Contract.NotNull(name, nameof(name));
Contract.NotNull(subspace, nameof(subspace));
Contract.NotNull(encoder, nameof(encoder));
this.Name = name;
this.Subspace = subspace;
this.ValueComparer = valueComparer ?? EqualityComparer <TValue> .Default;
this.IndexNullValues = indexNullValues;
this.Location = subspace.UsingEncoder(encoder);
}
internal TypedKeySubspace(Slice prefix, IKeyEncoder <T1> encoder, ISubspaceContext context)
: base(prefix, context)
{
Contract.Requires(encoder != null);
this.KeyEncoder = encoder;
}
public static ITypedKeySubspace <T> UsingEncoder <T>(this IKeySubspace subspace, IKeyEncoder <T> encoder, ISubspaceContext?context = null)
{
Contract.NotNull(subspace);
Contract.NotNull(encoder);
return(new TypedKeySubspace <T>(subspace.GetPrefix(), encoder, context ?? subspace.Context));
}
public FdbEncoderSubspaceKeys([NotNull] IFdbSubspace subspace, [NotNull] IKeyEncoder <T> encoder)
{
Contract.Requires(subspace != null && encoder != null);
this.Subspace = subspace;
this.Encoder = encoder;
}
public IFdbEncoderSubspace <TNext> ByKey <TNext>(T value, [NotNull] IKeyEncoder <TNext> encoder)
{
return(FdbSubspace.CreateEncoder <TNext>(this.Subspace.ConcatKey(this.Encoder.EncodeKey(value)), encoder));
}
public FdbEncoderSubspacePartition([NotNull] IFdbSubspace subspace, [NotNull] IKeyEncoder <T> encoder)
{
this.Subspace = subspace;
this.Encoder = encoder;
}