internal StaticPartialClassNestedClassCollectionWithCodeAnalysis(
StaticClassNestedClassCollectionWithCodeAnalysis classCollection)
{
classes = new WrappedCollection <StaticClassNestedClassWithCodeAnalysis, StaticPartialClassNestedClassWithCodeAnalysis>(
classCollection.Classes,
parent => new StaticPartialClassNestedClassWithCodeAnalysis(parent),
child => child.Class,
value => classCollection.Classes = value);
abstractClasses = new WrappedCollection <StaticClassNestedAbstractClassWithCodeAnalysis, StaticPartialClassNestedAbstractClassWithCodeAnalysis>(
classCollection.AbstractClasses,
parent => new StaticPartialClassNestedAbstractClassWithCodeAnalysis(parent),
child => child.Class,
value => classCollection.AbstractClasses = value);
sealedClasses = new WrappedCollection <StaticClassNestedSealedClassWithCodeAnalysis, StaticPartialClassNestedSealedClassWithCodeAnalysis>(
classCollection.SealedClasses,
parent => new StaticPartialClassNestedSealedClassWithCodeAnalysis(parent),
child => child.Class,
value => classCollection.SealedClasses = value);
staticClasses = new WrappedCollection <StaticClassNestedStaticClassWithCodeAnalysis, StaticPartialClassNestedStaticClassWithCodeAnalysis>(
classCollection.StaticClasses,
parent => new StaticPartialClassNestedStaticClassWithCodeAnalysis(parent),
child => child.Class,
value => classCollection.StaticClasses = value);
partialClasses = StaticPartialClassNestedPartialClassCollectionWithCodeAnalysis.Create(classCollection.PartialClasses);
}
public InternalStaticTypeWithCodeAnalysis(TClass @class)
{
node = new Node <TClass, ClassDeclarationSyntax>(@class);
attributes = new AttributeListWrapper <TClass, ClassDeclarationSyntax>(
node,
syntax => syntax.AttributeLists,
(parentSyntax, childSyntax) => parentSyntax.WithAttributeLists(childSyntax));
classes = new InternalStaticClassNestedClassCollectionWithCodeAnalysis <TClass>(this);
delegates = new ClassMemberListWrapper <TClass, StaticClassNestedDelegateWithCodeAnalysis, DelegateDeclarationSyntax>(
node,
() => new StaticClassNestedDelegateWithCodeAnalysis());
enums = new ClassMemberListWrapper <TClass, StaticClassNestedEnumWithCodeAnalysis, EnumDeclarationSyntax>(
node,
() => new StaticClassNestedEnumWithCodeAnalysis());
events = new InternalStaticClassEventCollectionWithCodeAnalysis <TClass>(this);
fields = new InternalStaticClassFieldCollectionWithCodeAnalysis <TClass>(this);
genericParameters = new GenericParameterDeclarationNodeList <TClass, ClassDeclarationSyntax>(
node,
syntax => syntax.TypeParameterList,
(parentSyntax, childSyntax) => parentSyntax.WithTypeParameterList(childSyntax),
syntax => syntax.ConstraintClauses,
(parentSyntax, childSyntax) => parentSyntax.WithConstraintClauses(childSyntax));
interfaces = new ClassMemberListWrapper <TClass, StaticClassNestedInterfaceWithCodeAnalysis, InterfaceDeclarationSyntax>(
node,
() => new StaticClassNestedInterfaceWithCodeAnalysis());
methods = new InternalStaticClassMethodCollectionWithCodeAnalysis <TClass>(this);
properties = new InternalStaticClassPropertyCollectionWithCodeAnalysis <TClass>(this);
staticConstructor = new ClassMemberListWrapper <TClass, StaticConstructorWithCodeAnalysis, ConstructorDeclarationSyntax>(
node,
() => new StaticConstructorWithCodeAnalysis());
structs = new InternalStaticClassNestedStructCollectionWithCodeAnalysis <TClass>(this);
members = new MemberList <TClass, ClassDeclarationSyntax>(
node,
(parentSyntax, childSyntax) => parentSyntax.WithMembers(childSyntax))
{
{ nameof(fields.Constants), () => fields.Constants.Select(item => item.Syntax) },
{ nameof(fields.Fields), () => fields.Fields.Select(item => item.Syntax) },
{ nameof(Enums), () => enums.Select(item => item.Syntax) },
{ nameof(Delegates), () => delegates.Select(item => item.Syntax) },
{ nameof(events.Events), () => events.Events.Select(item => item.Syntax) },
{ nameof(events.EventProperties), () => events.EventProperties.Select(item => item.Syntax) },
{ nameof(Interfaces), () => interfaces.Select(item => item.Syntax) },
{ nameof(Properties), () => Properties.Select(item => item.Syntax) },
{ nameof(methods.ExtensionMethods), () => methods.ExtensionMethods.Select(item => item.Syntax) },
{ nameof(methods.Methods), () => methods.Methods.Select(item => item.Syntax) }
};
}
