/// <summary>
/// Initializes a new instance of the <see cref="Selector" /> struct.
/// </summary>
public static Selector Deserialize(BuildXLReader reader)
{
Contract.Requires(reader != null);
var contentHash = new ContentHash(reader);
var output = ContentHashList.ReadNullableArray(reader);
return(new Selector(contentHash, output));
}
/// <summary>
/// Initializes a new instance of the <see cref="ContentHashListWithDeterminism"/> struct from its binary
/// representation.
/// </summary>
public static ContentHashListWithDeterminism Deserialize(BuildXLReader reader)
{
Contract.Requires(reader != null);
var writeContentHashList = reader.ReadBoolean();
var contentHashList = writeContentHashList ? ContentHashList.Deserialize(reader) : null;
var length = reader.ReadInt32();
var determinismBytes = reader.ReadBytes(length);
var determinism = CacheDeterminism.Deserialize(determinismBytes);
return(new ContentHashListWithDeterminism(contentHashList, determinism));
}
/// <inheritdoc />
public bool Equals(ContentHashListWithDeterminism other)
{
if (!ReferenceEquals(ContentHashList, other.ContentHashList))
{
if (ContentHashList == null || other.ContentHashList == null)
{
return(false);
}
if (!ContentHashList.Equals(other.ContentHashList))
{
return(false);
}
}
return(Determinism.Equals(other.Determinism));
}
/// <summary>
/// Serializes an instance into a binary stream.
/// </summary>
public void Serialize(BuildXLWriter writer)
{
Contract.Requires(writer != null);
var writeContentHashList = ContentHashList != null;
writer.Write(writeContentHashList);
if (writeContentHashList)
{
ContentHashList.Serialize(writer);
}
var determinism = Determinism.Serialize();
writer.Write(determinism.Length);
writer.Write(determinism);
}
/// <summary>
/// Ensure the existence of all related content by pinning it.
/// </summary>
public static async Task <bool> EnsureContentIsAvailableAsync(this IContentSession contentSession, Context context, string componentName, ContentHashList contentHashList, CancellationToken cts)
{
// If there is no contentSession in which to find content, then trivially no content is available.
if (contentSession == null)
{
return(false);
}
// If the contentHashList does not exist, then trivially all content is pinned.
if (contentHashList == null)
{
return(true);
}
IEnumerable <Task <Indexed <PinResult> > > pinResultEnumerable = await contentSession.PinAsync(context, contentHashList.Hashes, cts).ConfigureAwait(false);
var pinSucceeded = true;
foreach (var pinResultTask in pinResultEnumerable)
{
var pinResult = await pinResultTask.ConfigureAwait(false);
if (!pinResult.Item.Succeeded)
{
if (pinResult.Item.Code != PinResult.ResultCode.ContentNotFound)
{
context.Warning($"Pinning hash {contentHashList.Hashes[pinResult.Index]} failed with error {pinResult}", component: componentName);
}
pinSucceeded = false;
}
}
return(pinSucceeded);
}
/// <summary>
/// Serialize whole value to a binary writer.
/// </summary>
public void Serialize(BuildXLWriter writer)
{
ContentHash.Serialize(writer);
ContentHashList.WriteNullableArray(Output, writer);
}
/// <summary>
/// Initializes a new instance of the <see cref="ContentHashListWithDeterminism"/> struct
/// </summary>
public ContentHashListWithDeterminism(ContentHashList contentHashList, CacheDeterminism determinism)
{
ContentHashList = contentHashList;
Determinism = determinism;
}
/// <inheritdoc />
public override int GetHashCode()
{
return((ContentHashList?.GetHashCode() ?? 0) ^ Determinism.GetHashCode());
}
