ProxyGenerator/tests/ProxyInterfaceSourceGeneratorTests/ProxyInterfaceSourceGeneratorTest.GenerateFiles_ForClassWithIgnores.verified.txt

[
  {
    HintName: ProxyInterfaceSourceGeneratorTests.Source.IFoo2.g.cs,
    Source:
//----------------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by https://github.com/specklesystems/ProxyGenerator.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//----------------------------------------------------------------------------------------

#nullable enable
using System;

namespace ProxyInterfaceSourceGeneratorTests.Source
{
    public partial interface IFoo2
    {
        global::ProxyInterfaceSourceGeneratorTests.Source.Foo2 _Instance { get; }

        global::ProxyInterfaceSourceGeneratorTests.Source.IFoo2[] Foos { get; set; }

        global::ProxyInterfaceSourceGeneratorTests.Source.IFoo2[] DoSomethingAndGetAnArrayOfFoos();

        int Weird2();
    }
}
#nullable restore
  },
  {
    HintName: ProxyInterfaceSourceGeneratorTests.Source.Foo2Proxy.g.cs,
    Source:
//----------------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by https://github.com/specklesystems/ProxyGenerator.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//----------------------------------------------------------------------------------------

#nullable enable
using System;

namespace ProxyInterfaceSourceGeneratorTests.Source
{
    public partial class Foo2Proxy : global::ProxyInterfaceSourceGeneratorTests.Source.IFoo2
    {
        public global::ProxyInterfaceSourceGeneratorTests.Source.Foo2 _Instance { get; }
        
        public global::ProxyInterfaceSourceGeneratorTests.Source.IFoo2[] Foos { get => Mapster.TypeAdapter.Adapt<global::ProxyInterfaceSourceGeneratorTests.Source.IFoo2[]>(_Instance.Foos); set => _Instance.Foos = Mapster.TypeAdapter.Adapt<ProxyInterfaceSourceGeneratorTests.Source.Foo2[]>(value); }

        public global::ProxyInterfaceSourceGeneratorTests.Source.IFoo2[] DoSomethingAndGetAnArrayOfFoos()
        {
            var result_1603865878 = _Instance.DoSomethingAndGetAnArrayOfFoos();
            return Mapster.TypeAdapter.Adapt<global::ProxyInterfaceSourceGeneratorTests.Source.IFoo2[]>(result_1603865878);
        }

        public int Weird2()
        {
            var result__1602200929 = _Instance.Weird2();
            return result__1602200929;
        }


        public Foo2Proxy(global::ProxyInterfaceSourceGeneratorTests.Source.Foo2 instance)
        {
            _Instance = instance;
            
        }

        static Foo2Proxy()
        {
            Mapster.TypeAdapterConfig<global::ProxyInterfaceSourceGeneratorTests.Source.Foo2, global::ProxyInterfaceSourceGeneratorTests.Source.IFoo2>.NewConfig().ConstructUsing(instance1325374861 => new global::ProxyInterfaceSourceGeneratorTests.Source.Foo2Proxy(instance1325374861));
            Mapster.TypeAdapterConfig<global::ProxyInterfaceSourceGeneratorTests.Source.IFoo2, global::ProxyInterfaceSourceGeneratorTests.Source.Foo2>.NewConfig().MapWith(proxy1047178445 => ((global::ProxyInterfaceSourceGeneratorTests.Source.Foo2Proxy) proxy1047178445)._Instance);
        }
            
    }
}
#nullable restore
  },
  {
    HintName: Speckle.ProxyGenerator.Extra.g.cs,
    Source:
//----------------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by https://github.com/specklesystems/ProxyGenerator
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//----------------------------------------------------------------------------------------

#nullable enable
using System;

namespace Speckle.ProxyGenerator
{
    [AttributeUsage(AttributeTargets.Interface)]
    internal sealed class ProxyAttribute : Attribute
    {
        public Type Type { get; }
        public ImplementationOptions Options { get; }
        public ProxyClassAccessibility Accessibility { get; }
        public string[]? MembersToIgnore { get; }

        public ProxyAttribute(Type type) : this(type, ImplementationOptions.None, ProxyClassAccessibility.Public)
        {
        }

        public ProxyAttribute(Type type, ImplementationOptions options) : this(type, options, ProxyClassAccessibility.Public)
        {
        }

       	public ProxyAttribute(Type type, ProxyClassAccessibility accessibility) : this(type, ImplementationOptions.None, accessibility)
        {
        }

        public ProxyAttribute(Type type, ImplementationOptions options, ProxyClassAccessibility accessibility) : this(type, options, accessibility, null)
        {
        }

        public ProxyAttribute(Type type, string[]? membersToIgnore) : this(type, ImplementationOptions.None, ProxyClassAccessibility.Public, null)
        {
        }

        public ProxyAttribute(Type type, ImplementationOptions options, string[]? membersToIgnore) : this(type, options, ProxyClassAccessibility.Public, null)
        {
        }

        public ProxyAttribute(Type type, ImplementationOptions options, ProxyClassAccessibility accessibility, string[]? membersToIgnore)
        {
            Type = type;
            Options = options;
            Accessibility = accessibility;
            MembersToIgnore = membersToIgnore;
        }
    }

    [Flags]
    internal enum ProxyClassAccessibility
    {
        Public = 0,

        Internal = 1
    }
    [Flags]
    internal enum ImplementationOptions
    {
        None = 0,

        ProxyBaseClasses = 1,

        ProxyInterfaces = 2,

        UseExtendedInterfaces = 4,

        ProxyForBaseInterface = 8
    }

    public static class ProxyMap
    {
      private static readonly global::System.Collections.Concurrent.ConcurrentDictionary<Type, Type> s_revitToInterfaceMap = new();
      private static readonly global::System.Collections.Concurrent.ConcurrentDictionary<Type, Type> s_proxyToInterfaceMap = new();
      private static readonly global::System.Collections.Concurrent.ConcurrentDictionary<Type, Type> s_interfaceToRevit = new();
      private static readonly global::System.Collections.Concurrent.ConcurrentDictionary<Type, Func<object, object>> s_proxyFactory = new();

      static ProxyMap()
      {
        Add<ProxyInterfaceSourceGeneratorTests.Source.Foo2, global::ProxyInterfaceSourceGeneratorTests.Source.IFoo2, ProxyInterfaceSourceGeneratorTests.Source.Foo2Proxy>(x => new ProxyInterfaceSourceGeneratorTests.Source.Foo2Proxy(x));

      }

      private static void Add<T, TInterface, TProxy>(Func<T, TProxy> f)
        where T : class
        where TInterface : notnull
        where TProxy : TInterface
      {
        s_revitToInterfaceMap.TryAdd(typeof(T), typeof(TInterface));
        s_proxyToInterfaceMap.TryAdd(typeof(TProxy), typeof(TInterface));
        s_proxyFactory.TryAdd(typeof(TInterface), w => f((T)w));
        s_interfaceToRevit.TryAdd(typeof(TInterface), typeof(T));
      }

      public static Type? GetMappedTypeFromHostType(Type type)
      {
        if (s_revitToInterfaceMap.TryGetValue(type, out var t))
        {
          return t;
        }
        return null;
      }

      public static Type? GetMappedTypeFromProxyType(Type type)
      {
        if (s_proxyToInterfaceMap.TryGetValue(type, out var t))
        {
          return t;
        }

        return null;
      }

      public static Type? GetHostTypeFromMappedType(Type type)
      {
        if (s_interfaceToRevit.TryGetValue(type, out var t))
        {
          return t;
        }

        return null;
      }

      public static object CreateProxy(Type type, object toWrap) => s_proxyFactory[type](toWrap);
      public static T CreateProxy<T>(object toWrap) => (T)CreateProxy(typeof(T), toWrap);
    }
#nullable restore
}
  }
]