[#26] All: Remove V2 from naming

Rename project, namespaces and class names

Signed-off-by: Pavel Gross <p.gross@yadro.com>

src/FrostFS.SDK.Client/Models/Object/FrostFsAddress.cs

@@ -0,0 +1,48 @@
+using FrostFS.Refs;
+using FrostFS.SDK.Client.Mappers.GRPC;
+
+namespace FrostFS.SDK;
+
+public class FrostFsAddress
+{
+    private FrostFsObjectId? frostFsObjectId;
+    private FrostFsContainerId? frostFsContainerId;
+    private ObjectID? objectId;
+    private ContainerID? containerId;
+
+    public FrostFsAddress(FrostFsContainerId frostFsContainerId, FrostFsObjectId frostFsObjectId)
+    {
+        FrostFsObjectId = frostFsObjectId ?? throw new System.ArgumentNullException(nameof(frostFsObjectId));
+        FrostFsContainerId = frostFsContainerId ?? throw new System.ArgumentNullException(nameof(frostFsContainerId));
+    }
+
+    internal FrostFsAddress(ObjectID objectId, ContainerID containerId)
+    {
+        ObjectId = objectId ?? throw new System.ArgumentNullException(nameof(objectId));
+        ContainerId = containerId ?? throw new System.ArgumentNullException(nameof(containerId));
+    }
+
+    public FrostFsObjectId FrostFsObjectId
+    {
+        get => frostFsObjectId ??= objectId!.ToModel();
+        set => frostFsObjectId = value;
+    }
+
+    public FrostFsContainerId FrostFsContainerId
+    {
+        get => frostFsContainerId ??= containerId!.ToModel();
+        set => frostFsContainerId = value;
+    }
+
+    public ObjectID ObjectId
+    {
+        get => objectId ??= frostFsObjectId!.ToMessage();
+        set => objectId = value;
+    }
+
+    public ContainerID ContainerId
+    {
+        get => containerId ??= frostFsContainerId!.ToMessage();
+        set => containerId = value;
+    }
+}

src/FrostFS.SDK.Client/Models/Object/FrostFsAttributePair.cs

@@ -0,0 +1,8 @@
+namespace FrostFS.SDK;
+
+public class FrostFsAttributePair(string key, string value)
+{
+    public string Key { get; set; } = key;
+
+    public string Value { get; set; } = value;
+}

src/FrostFS.SDK.Client/Models/Object/FrostFsLargeObject.cs

@@ -0,0 +1,9 @@
+namespace FrostFS.SDK;
+
+public class FrostFsLargeObject(FrostFsContainerId container) : FrostFsObject(container)
+{
+    public ulong PayloadLength
+    {
+        get { return Header!.PayloadLength; }
+    }
+}

src/FrostFS.SDK.Client/Models/Object/FrostFsLinkObject.cs

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+namespace FrostFS.SDK;
+
+public class FrostFsLinkObject : FrostFsObject
+{
+    public FrostFsLinkObject(FrostFsContainerId containerId,
+        SplitId splitId,
+        FrostFsObjectHeader largeObjectHeader,
+        IList<FrostFsObjectId> children)
+        : base(containerId)
+    {
+        Header!.Split = new FrostFsSplit(splitId,
+            null,
+            null,
+            largeObjectHeader,
+            null,
+            new ReadOnlyCollection<FrostFsObjectId>(children));
+    }
+}

src/FrostFS.SDK.Client/Models/Object/FrostFsObject.cs

@@ -0,0 +1,74 @@
+using System;
+
+namespace FrostFS.SDK;
+
+public class FrostFsObject
+{
+    private byte[]? bytes;
+
+    /// <summary>
+    /// Creates new instance from <c>ObjectHeader</c>
+    /// </summary>
+    /// <param name="header"></param> <summary>
+    public FrostFsObject(FrostFsObjectHeader header)
+    {
+        Header = header;
+    }
+
+    /// <summary>
+    /// Creates new instance with specified parameters
+    /// </summary>
+    /// <param name="container"></param>
+    /// <param name="objectType"></param>
+    public FrostFsObject(FrostFsContainerId container, FrostFsObjectType objectType = FrostFsObjectType.Regular)
+    {
+        Header = new FrostFsObjectHeader(containerId: container, type: objectType);
+    }
+
+    /// <summary>
+    /// Header contains metadata for the object
+    /// </summary>
+    /// <value></value>
+    public FrostFsObjectHeader 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 FrostFsObjectId? ObjectId
+    {
+        get; set;
+    }
+
+    /// <summary>
+    /// A payload is obtained via stream reader
+    /// </summary>
+    /// <value>Reader for received data</value>
+    public IObjectReader? ObjectReader { get; set; }
+
+    internal byte[] SingleObjectPayload
+    {
+        get { return bytes ?? []; }
+    }
+
+    /// <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 void SetSingleObjectPayload(byte[] bytes)
+    {
+        this.bytes = bytes;
+    }
+
+    /// <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(FrostFsObjectHeader largeObjectHeader)
+    {
+        if (Header?.Split == null)
+            throw new ArgumentNullException(nameof(largeObjectHeader), "Split value must not be null");
+
+        Header.Split.ParentHeader = largeObjectHeader;
+    }
+}

src/FrostFS.SDK.Client/Models/Object/FrostFsObjectFilter.cs

@@ -0,0 +1,111 @@
+namespace FrostFS.SDK;
+
+public interface IObjectFilter
+{
+    public FrostFsMatchType MatchType { get; set; }
+    public string Key { get; set; }
+
+    string? GetSerializedValue();
+}
+
+public abstract class FrostFsObjectFilter<T>(FrostFsMatchType matchType, string key, T value) : IObjectFilter
+{
+    public FrostFsMatchType MatchType { get; set; } = matchType;
+    public string Key { get; set; } = key;
+
+    public T Value { get; set; } = value;
+
+    public string? GetSerializedValue()
+    {
+        return Value?.ToString();
+    }
+}
+
+/// <summary>
+/// Creates filter to search by Attribute
+/// </summary>
+/// <param name="matchType">Match type</param>
+/// <param name="key">Attribute key</param>
+/// <param name="value">Attribute value</param>
+public class FilterByAttributePair(FrostFsMatchType matchType, string key, string value) : FrostFsObjectFilter<string>(matchType, key, value) { }
+
+/// <summary>
+/// Creates filter to search by ObjectId
+/// </summary>
+/// <param name="matchType">Match type</param>
+/// <param name="objectId">ObjectId</param>
+public class FilterByObjectId(FrostFsMatchType matchType, FrostFsObjectId objectId) : FrostFsObjectFilter<FrostFsObjectId>(matchType, Constants.FilterHeaderObjectID, objectId) { }
+
+/// <summary>
+/// Creates filter to search by OwnerId
+/// </summary>
+/// <param name="matchType">Match type</param>
+/// <param name="ownerId">ObjectId</param>
+public class FilterByOwnerId(FrostFsMatchType matchType, FrostFsOwner ownerId) : FrostFsObjectFilter<FrostFsOwner>(matchType, Constants.FilterHeaderOwnerID, ownerId) { }
+
+/// <summary>
+/// Creates filter to search by Version
+/// </summary>
+/// <param name="matchType">Match type</param>
+/// <param name="version">Version</param>
+public class FilterByVersion(FrostFsMatchType matchType, FrostFsVersion version) : FrostFsObjectFilter<FrostFsVersion>(matchType, Constants.FilterHeaderVersion, version) { }
+
+/// <summary>
+/// Creates filter to search by ContainerId
+/// </summary>
+/// <param name="matchType">Match type</param>
+/// <param name="containerId">ContainerId</param>
+public class FilterByContainerId(FrostFsMatchType matchType, FrostFsContainerId containerId) : FrostFsObjectFilter<FrostFsContainerId>(matchType, Constants.FilterHeaderContainerID, containerId) { }
+
+/// <summary>
+/// Creates filter to search by creation Epoch
+/// </summary>
+/// <param name="matchType">Match type</param>
+/// <param name="epoch">Creation Epoch</param>
+public class FilterByEpoch(FrostFsMatchType matchType, ulong epoch) : FrostFsObjectFilter<ulong>(matchType, Constants.FilterHeaderCreationEpoch, epoch) { }
+
+/// <summary>
+/// Creates filter to search by Payload Length
+/// </summary>
+/// <param name="matchType">Match type</param>
+/// <param name="payloadLength">Payload Length</param>
+public class FilterByPayloadLength(FrostFsMatchType matchType, ulong payloadLength) : FrostFsObjectFilter<ulong>(matchType, Constants.FilterHeaderPayloadLength, payloadLength) { }
+
+/// <summary>
+/// Creates filter to search by Payload Hash
+/// </summary>
+/// <param name="matchType">Match type</param>
+/// <param name="payloadHash">Payload Hash</param>
+public class FilterByPayloadHash(FrostFsMatchType matchType, CheckSum payloadHash) : FrostFsObjectFilter<CheckSum>(matchType, Constants.FilterHeaderPayloadHash, payloadHash) { }
+
+/// <summary>
+/// Creates filter to search by Parent
+/// </summary>
+/// <param name="matchType">Match type</param>
+/// <param name="parentId">Parent</param>
+public class FilterByParent(FrostFsMatchType matchType, FrostFsObjectId parentId) : FrostFsObjectFilter<FrostFsObjectId>(matchType, Constants.FilterHeaderParent, parentId) { }
+
+/// <summary>
+/// Creates filter to search by SplitId
+/// </summary>
+/// <param name="matchType">Match type</param>
+/// <param name="splitId">SplitId</param>
+public class FilterBySplitId(FrostFsMatchType matchType, SplitId splitId) : FrostFsObjectFilter<SplitId>(matchType, Constants.FilterHeaderSplitID, splitId) { }
+
+/// <summary>
+/// Creates filter to search by Payload Hash
+/// </summary>
+/// <param name="matchType">Match type</param>
+/// <param name="ecParentId">Payload Hash</param>
+public class FilterByECParent(FrostFsMatchType matchType, FrostFsObjectId ecParentId) : FrostFsObjectFilter<FrostFsObjectId>(matchType, Constants.FilterHeaderECParent, ecParentId) { }
+
+/// <summary>
+/// Creates filter to search Root objects
+/// </summary>
+public class FilterByRootObject() : FrostFsObjectFilter<string>(FrostFsMatchType.Unspecified, Constants.FilterHeaderRoot, string.Empty) { }
+
+/// <summary>
+/// Creates filter to search objects that are physically stored on the server 
+/// </summary
+public class FilterByPhysicallyStored() : FrostFsObjectFilter<string>(FrostFsMatchType.Unspecified, Constants.FilterHeaderPhy, string.Empty) { }
+

src/FrostFS.SDK.Client/Models/Object/FrostFsObjectHeader.cs

@@ -0,0 +1,90 @@
+using System;
+using System.Collections.ObjectModel;
+using System.Linq;
+
+using FrostFS.Object;
+
+using FrostFS.SDK.Client.Mappers.GRPC;
+
+namespace FrostFS.SDK;
+
+public class FrostFsObjectHeader(
+    FrostFsContainerId containerId,
+    FrostFsObjectType type = FrostFsObjectType.Regular,
+    FrostFsAttributePair[]? attributes = null,
+    FrostFsSplit? split = null,
+    FrostFsOwner? owner = null,
+    FrostFsVersion? version = null)
+{
+    private Header? header;
+    private Container.Container.Types.Attribute[]? grpsAttributes;
+
+    public ReadOnlyCollection<FrostFsAttributePair>? Attributes { get; internal set; } =
+        attributes == null ? null :
+        new ReadOnlyCollection<FrostFsAttributePair>(attributes);
+
+    public FrostFsContainerId ContainerId { get; } = containerId;
+
+    public ulong PayloadLength { get; set; }
+
+    public byte[]? PayloadCheckSum { get; set; }
+
+    public FrostFsObjectType ObjectType { get; } = type;
+
+    public FrostFsOwner? OwnerId { get; internal set; } = owner;
+
+    public FrostFsVersion? Version { get; internal set; } = version;
+
+    public FrostFsSplit? Split { get; internal set; } = split;
+
+    internal Container.Container.Types.Attribute[]? GetGrpsAttributes()
+    {
+        grpsAttributes ??= Attributes?
+            .Select(a => new Container.Container.Types.Attribute { Key = a.Key, Value = a.Value })
+            .ToArray();
+
+        return grpsAttributes;
+    }
+
+    public Header GetHeader()
+    {
+        if (header == null)
+        {
+            var objTypeName = ObjectType switch
+            {
+                FrostFsObjectType.Regular => Object.ObjectType.Regular,
+                FrostFsObjectType.Lock => Object.ObjectType.Lock,
+                FrostFsObjectType.Tombstone => Object.ObjectType.Tombstone,
+                _ => throw new ArgumentException($"Unknown ObjectType. Value: '{ObjectType}'.")
+            };
+
+            this.header = new Header
+            {
+                OwnerId = OwnerId?.ToMessage(),
+                Version = Version?.ToMessage(),
+                ContainerId = ContainerId.ToMessage(),
+                ObjectType = objTypeName,
+                PayloadLength = PayloadLength
+            };
+
+            if (Attributes != null)
+            {
+                foreach (var attribute in Attributes)
+                {
+                    this.header.Attributes.Add(attribute.ToMessage());
+                }
+            }
+
+            var split = Split;
+            if (split != null)
+            {
+                this.header.Split = new Header.Types.Split
+                {
+                    SplitId = split!.SplitId != null ? split.SplitId.GetSplitId() : null
+                };
+            }
+        }
+
+        return this.header;
+    }
+}

src/FrostFS.SDK.Client/Models/Object/FrostFsObjectId.cs

@@ -0,0 +1,33 @@
+using System;
+
+using FrostFS.SDK.Cryptography;
+
+namespace FrostFS.SDK;
+
+public class FrostFsObjectId(string id)
+{
+    public string Value { get; } = id;
+
+    public static FrostFsObjectId FromHash(byte[] hash)
+    {
+        if (hash is null)
+        {
+            throw new ArgumentNullException(nameof(hash));
+        }
+
+        if (hash.Length != Constants.Sha256HashLength)
+            throw new FormatException("ObjectID must be a sha256 hash.");
+
+        return new FrostFsObjectId(Base58.Encode(hash));
+    }
+
+    public byte[] ToHash()
+    {
+        return Base58.Decode(Value);
+    }
+
+    public override string ToString()
+    {
+        return Value;
+    }
+}

src/FrostFS.SDK.Client/Models/Object/FrostFsOwner.cs

@@ -0,0 +1,38 @@
+using System.Security.Cryptography;
+
+using FrostFS.Refs;
+using FrostFS.SDK.Client.Mappers.GRPC;
+using FrostFS.SDK.Cryptography;
+
+namespace FrostFS.SDK;
+
+public class FrostFsOwner(string id)
+{
+    private OwnerID? ownerID;
+
+    public string Value { get; } = id;
+
+    public static FrostFsOwner FromKey(ECDsa key)
+    {
+        return new FrostFsOwner(key.PublicKey().PublicKeyToAddress());
+    }
+
+    internal OwnerID OwnerID
+    {
+        get
+        {
+            ownerID ??= this.ToMessage();
+            return ownerID;
+        }
+    }
+
+    public byte[] ToHash()
+    {
+        return Base58.Decode(Value);
+    }
+
+    public override string ToString()
+    {
+        return Value;
+    }
+}

src/FrostFS.SDK.Client/Models/Object/FrostFsRange.cs

@@ -0,0 +1,27 @@
+namespace FrostFS.SDK;
+
+public readonly struct FrostFsRange(ulong offset, ulong length) : System.IEquatable<FrostFsRange>
+{
+    public ulong Offset { get; } = offset;
+
+    public ulong Length { get; } = length;
+
+    public override readonly bool Equals(object obj) => this == (FrostFsRange)obj;
+
+    public override readonly int GetHashCode() => $"{Offset}{Length}".GetHashCode();
+
+    public static bool operator ==(FrostFsRange left, FrostFsRange right)
+    {
+        return left.Equals(right);
+    }
+
+    public static bool operator !=(FrostFsRange left, FrostFsRange right)
+    {
+        return !(left == right);
+    }
+
+    public readonly bool Equals(FrostFsRange other)
+    {
+        return this == other;
+    }
+}

src/FrostFS.SDK.Client/Models/Object/FrostFsSplit.cs

@@ -0,0 +1,28 @@
+using System.Collections.ObjectModel;
+
+namespace FrostFS.SDK;
+
+public class FrostFsSplit(SplitId splitId,
+    FrostFsObjectId? previous = null,
+    FrostFsObjectId? parent = null,
+    FrostFsObjectHeader? parentHeader = null,
+    FrostFsSignature? parentSignature = null,
+    ReadOnlyCollection<FrostFsObjectId>? children = null)
+{
+    public FrostFsSplit() : this(new SplitId())
+    {
+    }
+
+    public SplitId SplitId { get; private set; } = splitId;
+
+    public FrostFsObjectId? Previous { get; } = previous;
+
+    public FrostFsObjectId? Parent { get; } = parent;
+
+    public FrostFsSignature? ParentSignature { get; } = parentSignature;
+
+    public FrostFsObjectHeader? ParentHeader { get; set; } = parentHeader;
+
+    public ReadOnlyCollection<FrostFsObjectId>? Children { get; } = children;
+
+}

src/FrostFS.SDK.Client/Models/Object/IObjectReader.cs

@@ -0,0 +1,10 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace FrostFS.SDK;
+
+public interface IObjectReader : IDisposable
+{
+    ValueTask<ReadOnlyMemory<byte>?> ReadChunk(CancellationToken cancellationToken = default);
+}

src/FrostFS.SDK.Client/Models/Object/SplitId.cs

@@ -0,0 +1,62 @@
+using System;
+
+using FrostFS.SDK.Cryptography;
+
+using Google.Protobuf;
+
+namespace FrostFS.SDK;
+
+public class SplitId
+{
+    private readonly Guid id;
+
+    private ByteString? message;
+
+    public SplitId()
+    {
+        this.id = Guid.NewGuid();
+    }
+
+    public SplitId(Guid id)
+    {
+        this.id = id;
+    }
+
+    private SplitId(byte[] binary)
+    {
+        this.id = new Guid(binary);
+    }
+
+    private SplitId(string str)
+    {
+        this.id = new Guid(str);
+    }
+
+    public static SplitId CreateFromBinary(byte[] binaryData)
+    {
+        return new SplitId(binaryData);
+    }
+
+    public static SplitId CreateFromString(string stringData)
+    {
+        return new SplitId(stringData);
+    }
+
+    public override string ToString()
+    {
+        return this.id.ToString();
+    }
+
+    public byte[]? ToBinary()
+    {
+        if (this.id == Guid.Empty)
+            return null;
+
+        return this.id.ToBytes();
+    }
+
+    public ByteString? GetSplitId()
+    {
+        return this.message ??= ByteString.CopyFrom(ToBinary());
+    }
+}