Cilador.Clone.MultiplexedConstructor.Get C# (CSharp) Method

        public static MultiplexedConstructor Get(ICloningContext cloningContext, MethodDefinition constructor)
        {
            var multiplexer = new MultiplexedConstructor(cloningContext, constructor);
            multiplexer.Multiplex();
            return multiplexer;
        }

        private IReadOnlyCollection <ICloner <object, object> > InvokeForRootTypeConstructorBody(MethodBody item, MethodDefinition parent)
        {
            Contract.Requires(item != null);
            Contract.Requires(parent != null);
            Contract.Ensures(Contract.Result <IReadOnlyCollection <ICloner <object, object> > >() != null);

            var parentCloners = this.ClonersBySource[parent];

            Contract.Assume(parentCloners != null);

            var constructorLogicSignatureCloner =
                parentCloners.SingleOrDefault(parentCloner => parentCloner is ConstructorLogicSignatureCloner) as ConstructorLogicSignatureCloner;
            var sourceMultiplexedConstructor = MultiplexedConstructor.Get(this.CloningContext, parent);

            var cloners = new List <ICloner <object, object> >();

            if (constructorLogicSignatureCloner != null)
            {
                cloners.Add(new ConstructorLogicBodyCloner(constructorLogicSignatureCloner, sourceMultiplexedConstructor));
            }

            foreach (var parentCloner in parentCloners
                     .Where(parentCloner => parentCloner is NoOpCloner <MethodDefinition, MethodDefinition>)
                     .Cast <NoOpCloner <MethodDefinition, MethodDefinition> >())
            {
                // the initialization cloning includes calling redirected construction methods
                // so we want to do this if we have initialization items or if we have to create a logic cloner
                if (!sourceMultiplexedConstructor.HasInitializationItems && constructorLogicSignatureCloner == null)
                {
                    continue;
                }

                var targetMultiplexedConstructor = MultiplexedConstructor.Get(this.CloningContext, parentCloner.Target);

                if (!targetMultiplexedConstructor.IsInitializingConstructor)
                {
                    // skip non-initializing constructors because they will eventually call into an initializing constructor
                    continue;
                }

                Contract.Assert(parentCloner.Target.HasBody);
                var constructorCloner = new ConstructorInitializationCloner(
                    parentCloner,
                    constructorLogicSignatureCloner,
                    sourceMultiplexedConstructor,
                    parentCloner.Target.Body);

                cloners.Add(constructorCloner);
            }

            return(cloners);
        }