internal FdbEncoderSubspace(Slice rawPrefix, bool copy, [NotNull] ICompositeKeyEncoder <T1, T2, T3> encoder)
: base(rawPrefix, copy)
{
Contract.NotNull(encoder, nameof(encoder));
m_encoder = encoder;
m_keys = new FdbEncoderSubspaceKeys <T1, T2, T3>(this, encoder);
}
internal TypedKeySubspace(Slice prefix, [NotNull] ICompositeKeyEncoder <T1, T2, T3> encoder)
: base(prefix)
{
Contract.Requires(encoder != null);
this.KeyEncoder = encoder;
this.Keys = new TypedKeys <T1, T2, T3>(this, this.KeyEncoder);
}
/// <summary>Returns a partial encoder that will only encode the first element</summary>
public static HeadEncoder <T1, T2> Head <T1, T2>(this ICompositeKeyEncoder <T1, T2> encoder)
{
if (encoder == null)
{
throw new ArgumentNullException("encoder");
}
return(new HeadEncoder <T1, T2>(encoder));
}
public static Slice EncodePartialKey <T1, T2>(this ICompositeKeyEncoder <T1, T2> encoder, T1 item1)
{
var writer = default(SliceWriter);
var tuple = (item1, default(T2));
encoder.WriteKeyPartsTo(ref writer, 1, ref tuple);
return(writer.ToSlice());
}
public static Slice EncodeKey <T1, T2>(this ICompositeKeyEncoder <T1, T2> encoder, Slice prefix, T1 item1, T2 item2)
{
var writer = new SliceWriter(prefix.Count + 24);
writer.WriteBytes(in prefix);
encoder.WriteKeyTo(ref writer, item1, item2);
return(writer.ToSlice());
}
internal TypedKeys(
[NotNull] TypedKeySubspace <T1, T2, T3, T4> parent,
[NotNull] ICompositeKeyEncoder <T1, T2, T3, T4> encoder)
{
Contract.Requires(parent != null && encoder != null);
this.Parent = parent;
this.Encoder = encoder;
}
/// <summary>Returns a partial encoder that will only encode the first and second elements</summary>
public static PairEncoder <T1, T2, T3> Pair <T1, T2, T3>(this ICompositeKeyEncoder <T1, T2, T3> encoder)
{
if (encoder == null)
{
throw new ArgumentNullException("encoder");
}
return(new PairEncoder <T1, T2, T3>(encoder));
}
public static Slice EncodePartialKey <T1, T2>(this ICompositeKeyEncoder <T1, T2> encoder, Slice prefix, T1 item1)
{
var writer = new SliceWriter(prefix.Count + 16);
writer.WriteBytes(in prefix);
var tuple = (item1, default(T2));
encoder.WriteKeyPartsTo(ref writer, 1, ref tuple);
return(writer.ToSlice());
}
internal FdbEncoderSubspace(Slice rawPrefix, bool copy, [NotNull] ICompositeKeyEncoder <T1, T2, T3, T4> encoder)
: base(rawPrefix, copy)
{
if (encoder == null)
{
throw new ArgumentNullException("encoder");
}
m_encoder = encoder;
m_keys = new FdbEncoderSubspaceKeys <T1, T2, T3, T4>(this, encoder);
}
public FdbEncoderSubspace([NotNull] FdbSubspace subspace, [NotNull] ICompositeKeyEncoder <T1, T2> 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 multimap, using a specific key and value encoder</summary>
/// <param name="subspace">Location where the map will be stored in the database</param>
/// <param name="allowNegativeValues">If true, allow negative or zero values to stay in the map.</param>
/// <param name="encoder">Encoder for the key/value pairs</param>
public FdbMultiMap(IFdbSubspace subspace, bool allowNegativeValues, ICompositeKeyEncoder <TKey, TValue> encoder)
{
if (subspace == null)
{
throw new ArgumentNullException("subspace");
}
if (encoder == null)
{
throw new ArgumentNullException("encoder");
}
this.Subspace = subspace;
this.AllowNegativeValues = allowNegativeValues;
this.Location = subspace.UsingEncoder(encoder);
}
/// <summary>Return a version of this subspace, which uses a different type system to produces the keys and values</summary>
/// <param name="subspace">Instance of a generic subspace</param>
/// <param name="encoder">Custom key encoder</param>
/// <returns>Subspace equivalent to <paramref name="subspace"/>, but augmented with a specific TypeSystem</returns>
public static IFdbEncoderSubspace <T1, T2, T3, T4> UsingEncoder <T1, T2, T3, T4>([NotNull] this IFdbSubspace subspace, [NotNull] ICompositeKeyEncoder <T1, T2, T3, T4> encoder)
{
if (subspace == null)
{
throw new ArgumentNullException("subspace");
}
if (encoder == null)
{
throw new ArgumentNullException("encoder");
}
return(FdbSubspace.CopyEncoder <T1, T2, T3, T4>(subspace, encoder));
}
public FdbDocumentCollection(FdbSubspace subspace, Func <TDocument, TId> selector, ICompositeKeyEncoder <TId, int> keyEncoder, IValueEncoder <TDocument> valueEncoder)
{
if (subspace == null)
{
throw new ArgumentNullException("subspace");
}
if (selector == null)
{
throw new ArgumentNullException("selector");
}
if (keyEncoder == null)
{
throw new ArgumentNullException("keyEncoder");
}
if (valueEncoder == null)
{
throw new ArgumentNullException("valueEncoder");
}
this.Subspace = subspace;
this.IdSelector = selector;
this.ValueEncoder = valueEncoder;
this.Location = new FdbEncoderSubspace <TId, int>(subspace, keyEncoder);
}
public FdbEncoderSubspacePartition([NotNull] IFdbSubspace subspace, [NotNull] ICompositeKeyEncoder <T1, T2, T3, T4> encoder)
{
Contract.Requires(subspace != null && encoder != null);
this.Subspace = subspace;
this.Encoder = encoder;
}
public static ITypedKeySubspace <T1, T2, T3, T4> UsingEncoder <T1, T2, T3, T4>(this IKeySubspace subspace, ICompositeKeyEncoder <T1, T2, T3, T4> encoder, ISubspaceContext?context = null)
{
Contract.NotNull(subspace);
Contract.NotNull(encoder);
return(new TypedKeySubspace <T1, T2, T3, T4>(subspace.GetPrefix(), encoder, context ?? subspace.Context));
}
public FdbEncoderSubspaceKeys([NotNull] IFdbSubspace subspace, [NotNull] ICompositeKeyEncoder <T1, T2, T3> encoder)
{
this.Subspace = subspace;
this.Encoder = encoder;
}
public PairEncoder([NotNull] ICompositeKeyEncoder <T1, T2, T3> encoder)
{
Contract.Requires(encoder != null);
this.Encoder = encoder;
}
internal TypedKeySubspace(Slice prefix, [NotNull] ICompositeKeyEncoder <T1, T2, T3, T4> encoder)
: base(prefix)
{
this.KeyEncoder = encoder;
this.Keys = new TypedKeys <T1, T2, T3, T4>(this, this.KeyEncoder);
}
public static IFdbEncoderSubspace <T1, T2, T3, T4> CreateEncoder <T1, T2, T3, T4>(Slice slice, ICompositeKeyEncoder <T1, T2, T3, T4> encoder)
{
if (encoder == null)
{
throw new ArgumentNullException("encoder");
}
return(new FdbEncoderSubspace <T1, T2, T3, T4>(slice, encoder));
}
public FdbDocumentCollection(FdbSubspace subspace, Func <TDocument, TId> selector, ICompositeKeyEncoder <TId, int> keyEncoder, IValueEncoder <TDocument> valueEncoder)
{
if (subspace == null)
{
throw new ArgumentNullException(nameof(subspace));
}
if (selector == null)
{
throw new ArgumentNullException(nameof(selector));
}
if (keyEncoder == null)
{
throw new ArgumentNullException(nameof(keyEncoder));
}
if (valueEncoder == null)
{
throw new ArgumentNullException(nameof(valueEncoder));
}
this.Subspace = subspace;
this.IdSelector = selector;
this.ValueEncoder = valueEncoder;
this.Location = subspace.UsingEncoder(keyEncoder);
}
public HeadEncoder(ICompositeKeyEncoder <T1, T2> encoder)
{
this.Encoder = encoder;
}
public FdbEncoderSubspacePartition([NotNull] IFdbSubspace subspace, [NotNull] ICompositeKeyEncoder <T1, T2> encoder)
{
this.Subspace = subspace;
this.Encoder = encoder;
}
public static ITypedKeySubspace <T1, T2, T3, T4> UsingEncoder <T1, T2, T3, T4>([NotNull] this IKeySubspace subspace, [NotNull] ICompositeKeyEncoder <T1, T2, T3, T4> encoder)
{
Contract.NotNull(subspace, nameof(subspace));
Contract.NotNull(encoder, nameof(encoder));
return(new TypedKeySubspace <T1, T2, T3, T4>(subspace.GetPrefix(), encoder));
}
public static IFdbEncoderSubspace <T1, T2, T3, T4> CopyEncoder <T1, T2, T3, T4>([NotNull] IFdbSubspace subspace, [NotNull] ICompositeKeyEncoder <T1, T2, T3, T4> encoder)
{
if (encoder == null)
{
throw new ArgumentNullException("encoder");
}
return(new FdbEncoderSubspace <T1, T2, T3, T4>(subspace.Key, true, encoder));
}
public FdbEncoderSubspace(Slice rawPrefix, [NotNull] ICompositeKeyEncoder <T1, T2, T3, T4> encoder)
: this(rawPrefix, true, encoder)
{
}
/// <summary>Initializes a new subspace with the given binary <paramref name="prefix"/>, that uses a typed key <paramref name="encoder"/>.</summary>
/// <returns>A subspace that can handle composite keys of type (<typeparamref name="T1"/>, <typeparamref name="T2"/>, <typeparamref name="T3"/>).</returns>
public static ITypedKeySubspace <T1, T2, T3, T4> CreateTyped <T1, T2, T3, T4>(Slice prefix, ICompositeKeyEncoder <T1, T2, T3, T4> encoder, ISubspaceContext?context = null)
{
Contract.NotNull(encoder);
return(new TypedKeySubspace <T1, T2, T3, T4>(prefix, encoder, context ?? SubspaceContext.Default));
}
public PairEncoder(ICompositeKeyEncoder <T1, T2, T3> encoder)
{
this.Encoder = encoder;
}
/// <summary>Initializes a new subspace with the given binary <paramref name="prefix"/>, that uses a typed key <paramref name="encoder"/>.</summary>
/// <returns>A subspace that can handle composite keys of type (<typeparamref name="T1"/>, <typeparamref name="T2"/>, <typeparamref name="T3"/>).</returns>
public static TypedKeySubspace <T1, T2, T3, T4> CreateTyped <T1, T2, T3, T4>(Slice prefix, [NotNull] ICompositeKeyEncoder <T1, T2, T3, T4> encoder)
{
Contract.NotNull(encoder, nameof(encoder));
return(new TypedKeySubspace <T1, T2, T3, T4>(prefix, encoder));
}
internal TypedKeySubspace(Slice prefix, ICompositeKeyEncoder <T1, T2> encoder, ISubspaceContext context)
: base(prefix, context)
{
Contract.Debug.Requires(encoder != null);
this.KeyEncoder = encoder;
}
public FdbIndex([NotNull] string name, [NotNull] IFdbSubspace subspace, IEqualityComparer <TValue> valueComparer, bool indexNullValues, [NotNull] ICompositeKeyEncoder <TValue, TId> encoder)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (subspace == null)
{
throw new ArgumentNullException("subspace");
}
if (encoder == null)
{
throw new ArgumentNullException("encoder");
}
this.Name = name;
this.Subspace = subspace;
this.ValueComparer = valueComparer ?? EqualityComparer <TValue> .Default;
this.IndexNullValues = indexNullValues;
this.Location = subspace.UsingEncoder(encoder);
}
