Implement capability API rename

bindings/c/include/opendal.h

@@ -2013,6 +2013,11 @@ char *opendal_operator_info_get_root(const struct opendal_operator_info *self);
  */
 char *opendal_operator_info_get_name(const struct opendal_operator_info *self);
 
+/**
+ * \brief Return the operator's capability
+ */
+struct opendal_capability opendal_operator_info_get_capability(const struct opendal_operator_info *self);
+
 /**
  * \brief Return the operator's full capability
  */

bindings/c/src/operator_info.rs

@@ -238,12 +238,19 @@ impl opendal_operator_info {
             .into_raw()
     }
 
+    /// \brief Return the operator's capability
+    #[no_mangle]
+    pub unsafe extern "C" fn opendal_operator_info_get_capability(&self) -> opendal_capability {
+        let cap = self.deref().capability();
+        cap.into()
+    }
+
     /// \brief Return the operator's full capability
     #[no_mangle]
     pub unsafe extern "C" fn opendal_operator_info_get_full_capability(
         &self,
     ) -> opendal_capability {
-        let cap = self.deref().full_capability();
+        let cap = self.deref().capability();
         cap.into()
     }
 
@@ -252,6 +259,7 @@ impl opendal_operator_info {
     pub unsafe extern "C" fn opendal_operator_info_get_native_capability(
         &self,
     ) -> opendal_capability {
+        #[allow(deprecated)]
         let cap = self.deref().native_capability();
         cap.into()
     }

bindings/c/tests/example_test.cpp

@@ -56,7 +56,7 @@ void simple_test()
     // Test basic write/read if supported
     opendal_operator_info* info = opendal_operator_info_new(config->operator_instance);
     if (info) {
-        opendal_capability cap = opendal_operator_info_get_full_capability(info);
+        opendal_capability cap = opendal_operator_info_get_capability(info);
 
         if (cap.write && cap.read) {
             printf("Testing write/read operations...\n");

bindings/c/tests/opinfo.cpp

@@ -60,7 +60,7 @@ class OpendalOperatorInfoTest : public ::testing::Test {
 // We test the capability set by **memory** service.
 TEST_F(OpendalOperatorInfoTest, CapabilityTest)
 {
-    opendal_capability full_cap = opendal_operator_info_get_full_capability(this->info);
+    opendal_capability full_cap = opendal_operator_info_get_capability(this->info);
     opendal_capability native_cap = opendal_operator_info_get_native_capability(this->info);
 
     EXPECT_TRUE(full_cap.read);

bindings/c/tests/test_framework.cpp

@@ -164,7 +164,7 @@ bool opendal_check_capability(const opendal_operator* op,
     if (!info)
         return false;
 
-    opendal_capability cap = opendal_operator_info_get_full_capability(info);
+    opendal_capability cap = opendal_operator_info_get_capability(info);
 
     bool result = true;
     if (required.stat && !cap.stat)

bindings/c/tests/test_runner.cpp

@@ -169,7 +169,7 @@ int main(int argc, char* argv[])
         return 1;
     }
 
-    opendal_capability cap = opendal_operator_info_get_full_capability(info);
+    opendal_capability cap = opendal_operator_info_get_capability(info);
 
     // Check operator availability - only perform list-based check if list is supported
     if (cap.list) {

bindings/c/tests/test_suites_basic.cpp

@@ -26,7 +26,7 @@ void test_check(opendal_test_context* ctx)
     opendal_operator_info* info = opendal_operator_info_new(ctx->config->operator_instance);
     OPENDAL_ASSERT_NOT_NULL(info, "Should be able to get operator info");
 
-    opendal_capability cap = opendal_operator_info_get_full_capability(info);
+    opendal_capability cap = opendal_operator_info_get_capability(info);
 
     if (cap.list) {
         // Only perform the standard check if list operations are supported

bindings/c/tests/test_suites_presign.cpp

@@ -661,7 +661,7 @@ void test_presign_delete(opendal_test_context* ctx)
 {
     opendal_operator_info* info = opendal_operator_info_new(ctx->config->operator_instance);
     OPENDAL_ASSERT_NOT_NULL(info, "Operator info should not be null");
-    opendal_capability cap = opendal_operator_info_get_full_capability(info);
+    opendal_capability cap = opendal_operator_info_get_capability(info);
     opendal_operator_info_free(info);
     if (!cap.presign_delete) {
         return;

bindings/cpp/src/lib.rs

@@ -259,7 +259,7 @@ impl Operator {
 
     fn info(&self) -> Result<ffi::Capability> {
         let info = self.0.info();
-        let cap = info.full_capability();
+        let cap = info.capability();
 
         Ok(ffi::Capability {
             stat: cap.stat,

bindings/dotnet/OpenDAL.Tests/Behavior/BehaviorOperatorFixture.cs

@@ -57,7 +57,7 @@ public BehaviorOperatorFixture()
             op = op.WithLayer(new CapabilityOverrideLayer(capabilityOverrides));
         }
 
-        capability = op.Info.FullCapability;
+        capability = op.Info.Capability;
     }
 
     public bool IsEnabled => op is not null;

bindings/dotnet/OpenDAL.Tests/OperatorInfoTest.cs

@@ -35,8 +35,8 @@ public void OperatorInfo_MemoryConfig_ReturnsExpectedSchemeAndCapabilities()
         var info = op.Info;
 
         Assert.Equal("memory", info.Scheme);
-        Assert.True(info.FullCapability.Read);
-        Assert.True(info.FullCapability.Write);
+        Assert.True(info.Capability.Read);
+        Assert.True(info.Capability.Write);
     }
 
     [Fact]
@@ -56,8 +56,8 @@ public void OperatorInfo_FsConfig_ReturnsExpectedSchemeAndCapabilities()
             var info = op.Info;
 
             Assert.Equal("fs", info.Scheme);
-            Assert.True(info.FullCapability.Read);
-            Assert.True(info.FullCapability.Write);
+            Assert.True(info.Capability.Read);
+            Assert.True(info.Capability.Write);
         }
         finally
         {

bindings/dotnet/OpenDAL/Interop/Marshalling/OperatorInfoMarshaller.cs

@@ -55,8 +55,8 @@ internal static OperatorInfo ToOperatorInfo(OpenDALOperatorInfo payload)
             Utilities.ReadUtf8(payload.Scheme),
             Utilities.ReadUtf8(payload.Root),
             Utilities.ReadUtf8(payload.Name),
-            new Capability(payload.FullCapability),
+            new Capability(payload.Capability),
             new Capability(payload.NativeCapability)
         );
     }
-}
+}

bindings/dotnet/OpenDAL/Interop/NativeObject/OpenDALOperatorInfo.cs

@@ -33,7 +33,7 @@ internal struct OpenDALOperatorInfo
 
     public IntPtr Name;
 
-    public OpenDALCapability FullCapability;
+    public OpenDALCapability Capability;
 
     public OpenDALCapability NativeCapability;
 }

bindings/dotnet/OpenDAL/Layer/CapabilityOverrideLayer.cs

@@ -22,7 +22,7 @@
 namespace OpenDAL.Layer;
 
 /// <summary>
-/// Layer that overrides the full capability exposed by an operator.
+/// Layer that overrides the effective capability exposed by an operator.
 /// </summary>
 public sealed class CapabilityOverrideLayer : ILayer
 {

bindings/dotnet/OpenDAL/OperatorInfo.cs

@@ -39,22 +39,29 @@
     /// </summary>
     public string Name { get; }
 
+    /// <summary>
+    /// Gets the capability of this operator.
+    /// </summary>
+    public Capability Capability { get; }
+
     /// <summary>
     /// Gets the full capability of this operator.
     /// </summary>
-    public Capability FullCapability { get; }
+    [Obsolete("Use Capability.")]
+    public Capability FullCapability => Capability;
 
     /// <summary>
     /// Gets the native capability of this operator.
     /// </summary>
+    [Obsolete("NativeCapability is not intended for availability checks. Use Capability.")]
     public Capability NativeCapability { get; }
 
-    internal OperatorInfo(string scheme, string root, string name, Capability fullCapability, Capability nativeCapability)
+    internal OperatorInfo(string scheme, string root, string name, Capability capability, Capability nativeCapability)
     {
         Scheme = scheme;
         Root = root;
         Name = name;
-        FullCapability = fullCapability;
+        Capability = capability;
         NativeCapability = nativeCapability;
     }
-}
+}

bindings/dotnet/README.md

@@ -235,10 +235,10 @@ catch (OpenDALException ex) when (ex.Code == ErrorCode.NotFound)
 }
 ```
 
-Some features depend on backend capability. Check `op.Info.FullCapability` before using optional options/features:
+Some features depend on backend capability. Check `op.Info.Capability` before using optional options/features:
 
 ```csharp
-var cap = op.Info.FullCapability;
+var cap = op.Info.Capability;
 if (cap.PresignRead)
 {
 	var req = await op.PresignReadAsync("a.txt", TimeSpan.FromMinutes(5));

bindings/dotnet/src/operator_info.rs

@@ -25,16 +25,19 @@ pub struct OpendalOperatorInfo {
     pub scheme: *mut c_char,
     pub root: *mut c_char,
     pub name: *mut c_char,
-    pub full_capability: Capability,
+    pub capability: Capability,
     pub native_capability: Capability,
 }
 
 pub fn into_operator_info(info: opendal::OperatorInfo) -> OpendalOperatorInfo {
+    #[allow(deprecated)]
+    let native_capability = info.native_capability();
+
     OpendalOperatorInfo {
         scheme: into_string_ptr(info.scheme().to_string()),
         root: into_string_ptr(info.root()),
         name: into_string_ptr(info.name()),
-        full_capability: Capability::new(info.full_capability()),
-        native_capability: Capability::new(info.native_capability()),
+        capability: Capability::new(info.capability()),
+        native_capability: Capability::new(native_capability),
     }
 }

bindings/go/operator_info.go

@@ -41,7 +41,7 @@ func (op *Operator) Info() *OperatorInfo {
 		scheme:    ffiOperatorInfoGetScheme.symbol(op.ctx)(inner),
 		root:      ffiOperatorInfoGetRoot.symbol(op.ctx)(inner),
 		name:      ffiOperatorInfoGetName.symbol(op.ctx)(inner),
-		fullCap:   &Capability{inner: ffiOperatorInfoGetFullCapability.symbol(op.ctx)(inner)},
+		cap:       &Capability{inner: ffiOperatorInfoGetCapability.symbol(op.ctx)(inner)},
 		nativeCap: &Capability{inner: ffiOperatorInfoGetNativeCapability.symbol(op.ctx)(inner)},
 	}
 }
@@ -55,12 +55,16 @@ type OperatorInfo struct {
 	scheme    string
 	root      string
 	name      string
-	fullCap   *Capability
+	cap       *Capability
 	nativeCap *Capability
 }
 
+func (i *OperatorInfo) GetCapability() *Capability {
+	return i.cap
+}
+
 func (i *OperatorInfo) GetFullCapability() *Capability {
-	return i.fullCap
+	return i.cap
 }
 
 func (i *OperatorInfo) GetNativeCapability() *Capability {
@@ -335,8 +339,8 @@ var ffiOperatorInfoFree = newFFI(ffiOpts{
 	}
 })
 
-var ffiOperatorInfoGetFullCapability = newFFI(ffiOpts{
-	sym:    "opendal_operator_info_get_full_capability",
+var ffiOperatorInfoGetCapability = newFFI(ffiOpts{
+	sym:    "opendal_operator_info_get_capability",
 	rType:  &typeCapability,
 	aTypes: []*ffi.Type{&ffi.TypePointer},
 }, func(ctx context.Context, ffiCall ffiCall) func(info *opendalOperatorInfo) *opendalCapability {

bindings/go/string_ownership_test.go

@@ -89,7 +89,7 @@ func TestOperatorInfoCopiesAndFreesOwnedStrings(t *testing.T) {
 		assertOperatorInfoPointer(t, infoInner, aValues...)
 		*(**byte)(rValue) = namePtr
 	}))
-	ctx = context.WithValue(ctx, ffiOperatorInfoGetFullCapability.opts.sym, func(info *opendalOperatorInfo) *opendalCapability {
+	ctx = context.WithValue(ctx, ffiOperatorInfoGetCapability.opts.sym, func(info *opendalOperatorInfo) *opendalCapability {
 		if info != infoInner {
 			t.Fatalf("Info() requested full capability for unexpected operator info: %p", info)
 		}
@@ -117,8 +117,8 @@ func TestOperatorInfoCopiesAndFreesOwnedStrings(t *testing.T) {
 	if info.GetName() != "namespace" {
 		t.Fatalf("Info().GetName() = %q, want namespace", info.GetName())
 	}
-	if !info.GetFullCapability().Stat() {
-		t.Fatal("Info().GetFullCapability().Stat() = false, want true")
+	if !info.GetCapability().Stat() {
+		t.Fatal("Info().GetCapability().Stat() = false, want true")
 	}
 	if !info.GetNativeCapability().List() {
 		t.Fatal("Info().GetNativeCapability().List() = false, want true")

bindings/java/src/lib.rs

@@ -73,8 +73,10 @@ fn make_operator_info<'a>(env: &mut JNIEnv<'a>, info: OperatorInfo) -> Result<JO
     let scheme = env.new_string(info.scheme().to_string())?;
     let root = env.new_string(info.root().to_string())?;
     let name = env.new_string(info.name().to_string())?;
-    let full_capability_obj = make_capability(env, info.full_capability())?;
-    let native_capability_obj = make_capability(env, info.native_capability())?;
+    let capability_obj = make_capability(env, info.capability())?;
+    #[allow(deprecated)]
+    let native_capability = info.native_capability();
+    let native_capability_obj = make_capability(env, native_capability)?;
 
     let result = env
         .new_object(
@@ -84,7 +86,7 @@ fn make_operator_info<'a>(env: &mut JNIEnv<'a>, info: OperatorInfo) -> Result<JO
                 JValue::Object(&scheme),
                 JValue::Object(&root),
                 JValue::Object(&name),
-                JValue::Object(&full_capability_obj),
+                JValue::Object(&capability_obj),
                 JValue::Object(&native_capability_obj),
             ],
         )?;

bindings/java/src/main/java/org/apache/opendal/OperatorInfo.java

@@ -27,19 +27,25 @@ public class OperatorInfo {
     public final String scheme;
     public final String root;
     public final String name;
+    public final Capability capability;
+
+    @Deprecated
     public final Capability fullCapability;
+
+    @Deprecated
     public final Capability nativeCapability;
 
     public OperatorInfo(
             @NonNull String scheme,
             @NonNull String root,
             @NonNull String name,
-            @NonNull Capability fullCapability,
+            @NonNull Capability capability,
             @NonNull Capability nativeCapability) {
         this.scheme = scheme;
         this.root = root;
         this.name = name;
-        this.fullCapability = fullCapability;
+        this.capability = capability;
+        this.fullCapability = capability;
         this.nativeCapability = nativeCapability;
     }
 }

bindings/java/src/test/java/org/apache/opendal/test/OperatorInfoTest.java

@@ -43,13 +43,13 @@ public void testBlockingOperatorInfo() {
             assertThat(info).isNotNull();
             assertThat(info.scheme).isEqualTo("fs");
 
-            assertThat(info.fullCapability).isNotNull();
-            assertThat(info.fullCapability.read).isTrue();
-            assertThat(info.fullCapability.write).isTrue();
-            assertThat(info.fullCapability.delete).isTrue();
-            assertThat(info.fullCapability.writeCanAppend).isTrue();
-            assertThat(info.fullCapability.writeMultiMaxSize).isEqualTo(-1);
-            assertThat(info.fullCapability.writeMultiMinSize).isEqualTo(-1);
+            assertThat(info.capability).isNotNull();
+            assertThat(info.capability.read).isTrue();
+            assertThat(info.capability.write).isTrue();
+            assertThat(info.capability.delete).isTrue();
+            assertThat(info.capability.writeCanAppend).isTrue();
+            assertThat(info.capability.writeMultiMaxSize).isEqualTo(-1);
+            assertThat(info.capability.writeMultiMinSize).isEqualTo(-1);
 
             assertThat(info.nativeCapability).isNotNull();
         }
@@ -64,13 +64,13 @@ public void testOperatorInfo() {
             assertThat(info).isNotNull();
             assertThat(info.scheme).isEqualTo("memory");
 
-            assertThat(info.fullCapability).isNotNull();
-            assertThat(info.fullCapability.read).isTrue();
-            assertThat(info.fullCapability.write).isTrue();
-            assertThat(info.fullCapability.delete).isTrue();
-            assertThat(info.fullCapability.writeCanAppend).isFalse();
-            assertThat(info.fullCapability.writeMultiMaxSize).isEqualTo(-1);
-            assertThat(info.fullCapability.writeMultiMinSize).isEqualTo(-1);
+            assertThat(info.capability).isNotNull();
+            assertThat(info.capability.read).isTrue();
+            assertThat(info.capability.write).isTrue();
+            assertThat(info.capability.delete).isTrue();
+            assertThat(info.capability.writeCanAppend).isFalse();
+            assertThat(info.capability.writeMultiMaxSize).isEqualTo(-1);
+            assertThat(info.capability.writeMultiMinSize).isEqualTo(-1);
 
             assertThat(info.nativeCapability).isNotNull();
         }

bindings/nodejs/src/lib.rs

@@ -99,7 +99,7 @@ impl Operator {
     #[napi]
     pub fn capability(&self) -> Result<capability::Capability> {
         Ok(capability::Capability::new(
-            self.async_op.info().full_capability(),
+            self.async_op.info().capability(),
         ))
     }