test_component.idl

#include "Types.idl"
#include "AsyncMethods.idl"
#include "BufferTests.idl"
#include "CollectionTester.idl"
#include "EventTester.idl"
#include "Keywords.idl"
#include "NullValues.idl"
#include "WeakReferencer.idl"
#include "ArrayTester.idl"
import "Windows.Foundation.idl";
// import "Windows.Foundation.Numerics.idl";

namespace Windows.Foundation.Metadata
{
    [attributeusage(target_method, target_property)]
    [attributename("noexcept2")]
    attribute NoExceptionAttribute
    {
    }
}

namespace test_component
{
        // Just defined to validate we properly generate this name
        enum SwiftifiableNames
        {
            camelCase, // Should be preserved
            PascalCase, // Should become pascalCase
            ESingleLetterPrefixed, // Should become esingleLetterPrefixed
            LEADINGCaps, // Should become leadingCaps
            R8G8B8A8Typeless, // Should become r8g8b8a8Typeless (from D3D)
            UUID, // Should become uuid
        };

        struct StructWithEnum
        {
            SwiftifiableNames Names;
        };

        struct StructWithIReference
        {
            Windows.Foundation.IReference<Int32> Value1;
            Windows.Foundation.IReference<Int32> Value2;
        };
        namespace Delegates
        {
            delegate void SignalDelegate();
            delegate void InDelegate(String value);
            delegate String ReturnStringDelegate();
            delegate Int32 ReturnInt32Delegate();
            delegate void OutStringDelegate(out String value);
            delegate void OutInt32Delegate(out Int32 value);
            delegate void InObjectDelegate(Object value);
            //  delegate String[] ReturnStringArrayDelegate();
            //  delegate void OutStringArrayDelegate(out String[] value);
            //  delegate void RefStringArrayDelegate(ref String[] value);
            //  delegate test_component.Struct[] StructDelegate();
        }

        struct SimpleEventArgs
        {
            Int32 Value;
        };

        // Just ensure that IObservableVector compiles
        interface IInterfaceWithObservableVector
        {
            void TakeObservable(Windows.Foundation.Collections.IObservableVector<IBasic> basics);
        }

        runtimeclass Simple
        {
            Simple();
            void Method();

            //Windows.Foundation.IReference<Int32> Reference(Windows.Foundation.DateTime value);
            Windows.Foundation.IAsyncOperation<Int32> Operation(Windows.Foundation.DateTime value);

            Windows.Foundation.IAsyncAction Action(Windows.Foundation.DateTime value);
            Object Object(Windows.Foundation.DateTime value);
            static event Windows.Foundation.EventHandler<Object> StaticEvent;
            static void FireStaticEvent();
            //Windows.Foundation.Numerics.Vector2 ReturnVector2();
            BlittableStruct ReturnBlittableStruct();
            void TakeBlittableStruct(BlittableStruct value);
            BlittableStruct BlittableStructProperty;

            StructWithIReference ReturnStructWithReference();
            void TakeStructWithReference(StructWithIReference value);
            StructWithIReference StructWithReferenceProperty;

            NonBlittableStruct ReturnNonBlittableStruct();
            void TakeNonBlittableStruct(NonBlittableStruct value);
            NonBlittableStruct NonBlittableStructProperty;

            String StringProperty;

            event test_component.Delegates.SignalDelegate SignalEvent;
            event test_component.Delegates.InDelegate InEvent;
            event Windows.Foundation.TypedEventHandler<Simple, SimpleEventArgs> SimpleEvent;
            void FireEvent();

            overridable void CantActuallyOverrideBecauseNotComposable();
        }

        runtimeclass DeferrableEventArgs
        {
             Windows.Foundation.Deferral GetDeferral();
             void IncrementCounter();
        }

        //runtimeclass Optional
        //{
            // Optional();
            // Windows.Foundation.IReference<Int32> Property;
        //}

        interface IIAmImplementable
        {
            String InInt32(Int32 value);
            String InString(String value);
            String InObject(Object value);
            //  String InStringable(Windows.Foundation.IStringable value);
            //  String InStruct(Struct value);
            //  String InStructRef(ref const Struct value);
            String InEnum(Signed value);

            void OutInt32(out Int32 value);
            void OutString(out String value);
            void OutObject(out Object value);
            //  void OutStringable(out Windows.Foundation.IStringable value);
            void OutBlittableStruct(out BlittableStruct value);
            void OutNonBlittableStruct(out NonBlittableStruct value);
            void OutEnum(out Signed value);

            // Int32 ReturnInt32();
            // String ReturnString();
            Object ReturnObject();
            // Windows.Foundation.IStringable ReturnStringable();
            // Struct ReturnStruct();
            Signed ReturnEnum();

            Fruit EnumProperty;

            Windows.Foundation.IReference<Guid> Id;
            event test_component.Delegates.InDelegate ImplementableEvent;
            void FireEvent(String data);
        }

        interface ISimpleDelegate
        {
            void DoThis();
            void DoThat(Int32 val);
        }

        interface IBasic
        {
            [noexcept2]
            void Method();
        }

        runtimeclass Class : IBasic
        {
            Class();
            Class(String name);
            Class(String name, Fruit fruit);
            static void StaticTest();
            static Int32 StaticTestReturn();
            static Int32 StaticProperty{ get; };

            IBasic Implementation;
            // This is used to mimic API contract behavior, such that this will enforce separate types be generated
            [
              constructor_name("test_component.IClassFactory2"),
              static_name("test_component.IClassStatics2")
            ]
            {
               Class(String name, Fruit fruit, IIAmImplementable implementation);
               static Single StaticTestReturnFloat();
               static Single StaticPropertyFloat;
            }

            void SetDelegate(ISimpleDelegate value);
            ISimpleDelegate GetDelegate();

            // Class(Windows.Foundation.Collections.IIterable<String> arg, Int32 dummy1);
            // Class(Windows.Foundation.Collections.IIterable<Windows.Foundation.Collections.IKeyValuePair<String, String> > arg, Int32 dummy1, Int32 dummy2);
            Class(Windows.Foundation.Collections.IMap<String, String> arg, Int32 dummy1, Int32 dummy2, Int32 dummy3);
            Class(Windows.Foundation.Collections.IMapView<String, String> arg, Int32 dummy1, Int32 dummy2, Int32 dummy3, Int32 dummy4);
            Class(Windows.Foundation.Collections.IVector<String> arg, Int32 dummy1, Int32 dummy2, Int32 dummy3, Int32 dummy4, Int32 dummy5);
            Class(Windows.Foundation.Collections.IVectorView<String> arg, Int32 dummy1, Int32 dummy2, Int32 dummy3, Int32 dummy4, Int32 dummy5, Int32 dummy6);

            void Fail(String message);

            String InInt32(Int32 value);
            String InString(String value);
            String InObject(Object value);
            //  String InStringable(Windows.Foundation.IStringable value);
            //  String InStruct(Struct value);
            //  String InStructRef(ref const Struct value);
            String InEnum(Signed value);

            void OutInt32(out Int32 value);
            void OutString(out String value);
            void OutObject(out Object value);
            void OutStringable(out Windows.Foundation.IStringable value);
            void OutBlittableStruct(out BlittableStruct value);
            void OutNonBlittableStruct(out NonBlittableStruct value);
            void OutEnum(out Signed value);

            // Int32 ReturnInt32();
            // String ReturnString();
            Object ReturnObject();
            // Windows.Foundation.IStringable ReturnStringable();
            // Struct ReturnStruct();
            Signed ReturnEnum();
            Windows.Foundation.IReference<Signed> ReturnReferenceEnum();
            Fruit EnumProperty;

            // void OutInt32Array(out Int32[] value);
            // void OutStringArray(out String[] value);
            // void OutObjectArray(out Object[] value);
            // void OutStringableArray(out Windows.Foundation.IStringable[] value);
            // void OutStructArray(out Struct[] value);
            // void OutEnumArray(out Signed[] value);

            // void RefInt32Array(ref Int32[] value);
            // void RefStringArray(ref String[] value);
            // void RefObjectArray(ref Object[] value);
            // void RefStringableArray(ref Windows.Foundation.IStringable[] value);
            // void RefStructArray(ref Struct[] value);
            // void RefEnumArray(ref Signed[] value);

            // Int32[] ReturnInt32Array();
            // String[] ReturnStringArray();
            // Object[] ReturnObjectArray();
            // Windows.Foundation.IStringable[] ReturnStringableArray();
            // Struct[] ReturnStructArray();
            // Signed[] ReturnEnumArray();

            [noexcept2] void NoexceptVoid();
            [noexcept2] Int32 NoexceptInt32();
            [noexcept2] String NoexceptString();

             event Windows.Foundation.TypedEventHandler<Class, DeferrableEventArgs> DeferrableEvent;
             Windows.Foundation.IAsyncOperation<Int32> RaiseDeferrableEventAsync();

            // static Boolean TestNoMakeDetection();
            // static Int32 StaticPropertyWithAsyncSetter;
            // static void StaticMethodWithAsyncReturn();

            Char ReturnChar();
            String InChar(Char value);
            void OutChar(out Char value);

            Windows.Foundation.IReference<Int32> StartValue;
            Windows.Foundation.IReference<Guid> Id;

            Base BaseProperty;
            BaseNoOverrides BaseNoOverridesProperty;
            static void TakeBaseAndGiveToCallbackAsObject(Base base, test_component.Delegates.InObjectDelegate callback);
        }

        static runtimeclass StaticClass
        {
            static Fruit EnumProperty;
            static String InEnum(Signed value);
            static String InNonBlittableStruct(NonBlittableStruct value);

            static void TakeBase(Base base);
        }
        //namespace Structs
        //
            // struct All
            // {
            //     Windows.Foundation.Numerics.Matrix3x2 A;
            //     Windows.Foundation.Numerics.Matrix4x4 B;
            //     Windows.Foundation.Numerics.Plane C;
            //     Windows.Foundation.Numerics.Quaternion D;
            //     Windows.Foundation.Numerics.Vector2 E;
            //     Windows.Foundation.Numerics.Vector3 F;
            //     Windows.Foundation.Numerics.Vector4 G;
            //     Guid H;

            //     // TODO: uncomment when build server has newer version of midlrt.
            //     //HRESULT I;
            //     //EventRegistrationToken J;
            // };

            // struct Inner
            // {
            //     Int32 InnerValue;
            // };

            // namespace Nested
            // {
            //     struct Outer
            //     {
            //         test_component.Structs.Inner Depends;
            //         Int32 OuterValue;
            //     };
            // }

            //     // structs can contain nullable types (IReference<>) as well as strings. These are the only non-POD types
            //     // Alphabetical sorting of names below is important to validate sort order in generated code. Metadata will
            //     // sort to alphabetical order. cppwinrt needs to re-establish dependencies in the IReference types to produce
            //     // correct output.
            //     struct NullableC
            //     {
            //         Single a1;
            //         Windows.Foundation.IReference<Single> a2;
            //     };

            //     struct NullableB
            //     {
            //         Windows.Foundation.IReference<NullableC> a1;
            //     };

            //     struct NullableA
            //     {
            //         Windows.Foundation.IReference<NullableB> a1;
            //     };
            // }

            // namespace Parent
            // {
            //     // This validates namespace inclusion rules. The "...Three.h" header must include the
            //     // "...Parent.h" header but skip over the intermediate namespaces as they are empty
            //     // and won't be generated and those won't exist.

            //     struct ParentStruct
            //     {
            //         Int32 Value;
            //     };

            //     namespace One.Two.Three
            //     {
            //         struct ThreeStruct
            //         {
            //             Int32 Value;
            //         };
            //     }
            // }
        //}

        unsealed runtimeclass Base {
            protected Base();

            overridable void OnDoTheThing();

            void DoTheThing();

            static Base CreateFromString(String value);
        };

        unsealed runtimeclass BaseNoOverrides {
            protected BaseNoOverrides();

            static BaseNoOverrides CreateFromString(String value);
        }


        unsealed runtimeclass UnsealedDerivedNoOverrides : BaseNoOverrides {
            protected UnsealedDerivedNoOverrides();
        }

        runtimeclass Derived : Base {
            Derived();

            Int32 Prop;

            static Derived CreateFromString(String value);
        };

        unsealed runtimeclass UnsealedDerivedNoConstructor: Base {

        }

        runtimeclass DerivedFromNoConstructor: UnsealedDerivedNoConstructor {
            void Method();
        }

        unsealed runtimeclass UnsealedDerivedFromNoConstructor: UnsealedDerivedNoConstructor {
            UnsealedDerivedFromNoConstructor();
        }

        unsealed runtimeclass UnsealedDerived : Base {
            UnsealedDerived();
            UnsealedDerived(Int32 prop);
            UnsealedDerived(String prop1, Base prop2);

            Int32 Prop;

            overridable void OnBeforeDoTheThing();
            [
            overridable_name("test_component.IUnsealedDerivedOverloads2")
            ]
            {
                overridable void OnAfterDoTheThing();
            }
        };

        unsealed runtimeclass UnsealedDerived2 : UnsealedDerived {
            protected UnsealedDerived2();
            UnsealedDerived2(Int32 prop);

            void Method();
        }


        // unsealed to verify composable type names for generic default interfaces
        unsealed runtimeclass BaseCollection : [default] IVector<Base>
        {
            protected BaseCollection();
        }

        runtimeclass BaseMapCollection : [default] IMap<String, Base>
        {
        }

        runtimeclass BaseObservableCollection: [default] IObservableVector<Base>
        {
        }
    }