frostfs-sdk-csharp/src/FrostFS.SDK.ModelsV2/Object/FrostFsObject.cs

using System;
using System.Security.Cryptography;
using FrostFS.SDK.ModelsV2.Enums;

namespace FrostFS.SDK.ModelsV2;

public class FrostFsObject
{
    /// <summary>
    /// Creates new instance from <c>ObjectHeader</c>
    /// </summary>
    /// <param name="header"></param> <summary>
    public FrostFsObject(ObjectHeader header)
    {
        Header = header;        
    }

    /// <summary>
    /// Creates new instance with specified parameters
    /// </summary>
    /// <param name="container"></param>
    /// <param name="objectType"></param>
    public FrostFsObject(ContainerId container, ObjectType objectType = ObjectType.Regular)
    {
        Header = new ObjectHeader(containerId: container, type: objectType);        
    }
    
    /// <summary>
    /// Header contains metadata for the object
    /// </summary>
    /// <value></value>
    public ObjectHeader Header { get; set; }
    
    /// <summary>
    /// The value is calculated internally as a hash of ObjectHeader. Do not use pre-calculated value is the object has been changed.
    /// </summary>
    public ObjectId? ObjectId
    {
        get; internal set;
    }

    /// <summary>
    /// The size of payload cannot exceed <c>MaxObjectSize</c> value from <c>NetworkSettings</c>
    /// Used only for PutSingleObject method
    /// </summary>
    /// <value>Buffer for output data</value>
    public byte[] Payload { get; set; } = [];

    /// <summary>
    /// A payload is obtained via stream reader
    /// </summary>
    /// <value>Reader for received data</value>
    public IObjectReader? ObjectReader { get; set; }
    
    /// <summary>
    /// Applied only for the last Object in chain in case of manual multipart uploading
    /// </summary>
    /// <param name="largeObject">Parent for multipart object</param>
    public void SetParent(LargeObject largeObject)
    {
        if (Header?.Split == null)
            throw new Exception("The object is not initialized properly");

        Header.Split.ParentHeader = largeObject.Header;
    }
}

public class LargeObject(ContainerId container) : FrostFsObject(container)
{
    private readonly SHA256 payloadHash = SHA256.Create();

    public void AppendBlock(byte[] bytes, int count)
    {
        Header!.PayloadLength += (ulong)count;
        this.payloadHash.TransformBlock(bytes, 0, count, bytes, 0);
    }

    public LargeObject CalculateHash()
    {
        this.payloadHash.TransformFinalBlock([], 0, 0);
        Header!.PayloadCheckSum = this.payloadHash.Hash;
        return this;
    }

    public ulong PayloadLength
    {
        get { return Header!.PayloadLength; }
    }
}

public class LinkObject : FrostFsObject
{
    public LinkObject(ContainerId containerId, SplitId splitId, LargeObject largeObject) : base (containerId)
    {
        Header!.Split = new Split(splitId)
        {
            ParentHeader = largeObject.Header            
        };
    }
}