Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 116 insertions, 0 deletions

diff --git a/udkapi/com/sun/star/uno/XInterface.idl b/udkapi/com/sun/star/uno/XInterface.idl
new file mode 100644
index 000000000..f8632a8e4
--- /dev/null
+++ b/udkapi/com/sun/star/uno/XInterface.idl
@@ -0,0 +1,116 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifndef __com_sun_star_uno_XInterface_idl__
+#define __com_sun_star_uno_XInterface_idl__
+
+
+ module com {  module sun {  module star {  module uno {
+
+/** base interface of all UNO interfaces
+
+    <p> It provides lifetime control by reference counting and the
+    possibility of querying for other
+    interfaces of the same logical object.
+
+
+    <p>
+    "Logical Object" in this case means that the
+    interfaces actually can be supported by internal (e.g. aggregated) physical objects.</p>
+
+    <p> Deriving from this interface is mandatory for all UNO interfaces.
+    <p> Each language binding (Java, C++, StarBasic, Python, ... ) may
+    provide a different mapping of this interface, please look into the language
+    dependent documentation.
+
+    <p> The UNO object does not export the state of the reference count (acquire() and
+        release() do not have return values). In general, also the UNO object itself
+        should not make any assumption on the concrete value of the reference count
+        (except on the transition from one to zero ).
+
+ */
+published interface XInterface
+{
+    /** queries for a new interface to an existing UNO object.
+        <p>
+        The queryInterface() method is the entry point to obtain other interfaces which
+        are exported by the object. The caller asks the implementation of the object,
+        if it supports the interface specified by the type argument. The call may either
+        return with an interface reference of the requested type or with a void any.
+
+        <p>
+        There are certain specifications, a queryInterface() implementation must not violate.
+        <p>
+        1) If queryInterface on a specific object has once returned a valid interface reference
+          for a given type, it must return a valid reference for any successive queryInterface
+          calls on this object for the same type.
+        <p>
+        2) If queryInterface on a specific object has once returned a null reference
+        for a given type, it must always return a null reference for the same type.
+        <p>
+        3) If queryInterface on a reference A returns reference B, queryInterface on
+        B for Type A must return interface reference A or calls made on the returned
+        reference must be equivalent to calls made on reference A.
+        <p>
+        4) If queryInterface on a reference A returns reference B, queryInterface on
+        A and B for XInterface must return the same interface reference (object identity).
+
+        <p> The reason for the strong specification is, that a Uno Runtime Environment (URE)
+        may choose to cache queryInterface() calls.
+        <p> As mentioned above, certain language bindings may map this function differently also
+        with different specifications, please visit the language dependent specification for it.
+        The current C++ binding sticks to the specification state
+        <p>
+        The rules mentioned above are basically identical to the rules of QueryInterface in MS COM.
+
+        @param aType a UNO interface type, for which an object reference shall be obtained.
+        @return an interface reference in case the requested interface is supported by the object,
+                a void any otherwise.
+     */
+    any queryInterface( [in] type aType );
+
+    /** increases the reference counter by one.
+
+        <p>When you have called acquire() on the
+        UNO object, it is often said, that you have a reference or a hard reference
+        to the object.
+
+        <p>
+        It is only allowed to invoke a method on a UNO object, when you keep
+        a hard reference to it.
+
+        <p> Every call to acquire must be followed by a corresponding call to release
+        some time later, which may eventually lead to the destruction of the object.
+     */
+    void acquire();
+
+    /** decreases the reference counter by one.
+        <p>When the reference counter reaches 0, the object gets deleted.</p>
+        <p>Calling release() on the object is often called releasing
+        or clearing the reference to an object.
+     */
+    void release();
+
+};
+
+
+}; }; }; };
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */