public TypeMemberSource(IMetadataSpecification specification, IProperties properties, IFields fields, IMembers members)
{
_specification = specification;
_properties = properties;
_fields = fields;
_members = members;
}
public abstract void TranslateMembers <TItem, TParent, TDom>(TParent parent, IMembers <TItem, TParent, TDom> members)
where TItem :
IMember <TParent, TDom>
where TParent :
IDeclarationTarget
where TDom :
CodeObject;
public static Event Event(this IMembers members, Type handlerType, string eventName)
{
var typed = new EventTypeFilter(members.Events(), handlerType);
var named = new MemberNameFilter <Event, EventInfo>(typed, eventName);
return(named.Single());
}
public static Property Property(this IMembers members, Type propertyType, string propertyName)
{
var typed = new PropertyTypeFilter(members.Properties(), propertyType);
var named = new MemberNameFilter <Property, PropertyInfo>(typed, propertyName);
return(named.Single());
}
public static Field Field(this IMembers members, Type fieldType, string fieldName)
{
var typed = new FieldTypeFilter(members.Fields(), fieldType);
var named = new MemberNameFilter <Field, FieldInfo>(typed, fieldName);
return(named.Single());
}
static void VerifyDeclaredMembers <TDeclaringType>(object instance, IMembers actual)
{
var declaredMembers = (DeclaredMembers)actual;
Assert.Equal(typeof(TDeclaringType), declaredMembers.DeclaringType);
VerifyInstanceMembers(instance, declaredMembers.Source);
}
static void VerifyInheritedMembers <TAncestorType>(object instance, IMembers actual)
{
var inheritedMembers = (InheritedMembers)actual;
Assert.Equal(typeof(TAncestorType), inheritedMembers.AncestorType);
VerifyInstanceMembers(instance, inheritedMembers.Source);
}
static void VerifyInheritedMembers <TAncestorType>(IMembers source, IMembers actual)
{
var inheritedMembers = (InheritedMembers)actual;
Assert.Equal(typeof(TAncestorType), inheritedMembers.AncestorType);
Assert.Same(source, inheritedMembers.Source);
}
public void ReturnsInstanceMembersDeclaredByInstanceType()
{
var instance = new TestType();
IMembers actual = instance.Declared();
VerifyDeclaredMembers <TestType>(instance, actual);
}
static void VerifyDeclaredMembers <TDeclaringType>(IMembers source, IMembers actual)
{
var declaredMembers = (DeclaredMembers)actual;
Assert.Equal(typeof(TDeclaringType), declaredMembers.DeclaringType);
Assert.Same(source, declaredMembers.Source);
}
public static Method Method(this IMembers members, Type methodType, string methodName)
{
var typed = new MethodTypeFilter(members.Methods(), methodType, methodFactory);
var named = new MemberNameFilter <Method, MethodInfo>(typed, methodName);
return(named.Single());
}
public TypeMembers(IIdentities identities, ITypeMembers typeMembers, IMembers members,
ImmutableArray <IProperty> properties)
{
_identities = identities;
_typeMembers = typeMembers;
_members = members;
_properties = properties;
}
public void PublicReturnsPublicMembers()
{
IMembers actual = members.Public();
var accessibleMembers = (AccessibleMembers)actual;
Assert.Equal(Accessibility.Public, accessibleMembers.Accessibility);
}
public void ProtectedReturnsProtectedMembers()
{
IMembers actual = members.Protected();
var accessibleMembers = (AccessibleMembers)actual;
Assert.Equal(Accessibility.Protected, accessibleMembers.Accessibility);
}
public void PrivateReturnsPrivateMembers()
{
IMembers actual = members.Private();
var accessibleMembers = (AccessibleMembers)actual;
Assert.Equal(Accessibility.Private, accessibleMembers.Accessibility);
}
public void InternalReturnsInternalMembers()
{
IMembers actual = members.Internal();
var accessibleMembers = (AccessibleMembers)actual;
Assert.Equal(Accessibility.Internal, accessibleMembers.Accessibility);
}
static void VerifyInheritedMembers <TAncestorType>(Type staticType, IMembers actual)
{
var inheritedMembers = (InheritedMembers)actual;
Assert.Equal(typeof(TAncestorType), inheritedMembers.AncestorType);
var staticMembers = (StaticMembers)inheritedMembers.Source;
Assert.Equal(staticType, staticMembers.Type);
}
static void VerifyDeclaredMembers <TDeclaringType>(Type staticType, IMembers actual)
{
var declaredMembers = (DeclaredMembers)actual;
Assert.Equal(typeof(TDeclaringType), declaredMembers.DeclaringType);
var staticMembers = (StaticMembers)declaredMembers.Source;
Assert.Equal(staticType, staticMembers.Type);
}
internal void ReturnsEventsOfGivenTypeOrInstance(IMembers sut, Type type, object?instance, Lifetime lifetime)
{
var members = (Members <EventInfo, Event>)sut.Events();
Assert.Same(type, members.Type);
Assert.Same(instance, members.Instance);
Assert.Equal(type.GetTypeInfo().GetEvents, members.GetMemberInfo(type.GetTypeInfo()));
Assert.Equal(Event.Create, members.CreateMember);
Assert.Equal(lifetime, members.Lifetime);
}
static void VerifyMembers(IMembers actual, Type type, Accessibility accessibility)
{
var accessibleMembers = (AccessibleMembers)actual;
Assert.Equal(accessibility, accessibleMembers.Accessibility);
var staticMembers = (StaticMembers)accessibleMembers.Source;
Assert.Same(type, staticMembers.Type);
}
internal void ReturnsConstructorsOfGivenTypeOrInstance(IMembers sut, Type type, object?instance)
{
var members = (Members <ConstructorInfo, Constructor>)sut.Constructors();
Assert.Same(type, members.Type);
Assert.Same(instance, members.Instance);
Assert.Equal(type.GetTypeInfo().GetConstructors, members.GetMemberInfo(type.GetTypeInfo()));
Assert.Equal(Constructor.Create, members.CreateMember);
Assert.Equal(Lifetime.Instance, members.Lifetime);
}
internal void ReturnsPropertiesOfGivenTypeOrInstance(IMembers sut, Type type, object?instance, Lifetime lifetime)
{
var members = (Members <PropertyInfo, Property>)sut.Properties();
Assert.Same(type, members.Type);
Assert.Same(instance, members.Instance);
Assert.Equal(type.GetTypeInfo().GetProperties, members.GetMemberInfo(type.GetTypeInfo()));
Assert.Equal(Property.Create, members.CreateMember);
Assert.Equal(lifetime, members.Lifetime);
}
internal void ReturnsMethodsOfGivenTypeOrInstance(IMembers sut, Type type, object?instance, Lifetime lifetime)
{
var members = (Members <MethodInfo, Method>)sut.Methods();
Assert.Same(type, members.Type);
Assert.Same(instance, members.Instance);
Assert.Equal(type.GetTypeInfo().GetMethods, members.GetMemberInfo(type.GetTypeInfo()));
Assert.Equal(Method.Create, members.CreateMember);
Assert.Equal(lifetime, members.Lifetime);
}
public DictionaryEntries(Func <IEnumerable <IMemberSerializer>, IMemberSerialization> builder,
IInnerContentServices contents, IMemberSerializers serializers, IMembers members,
IWriter element, IDictionaryPairTypesLocator locator)
{
_builder = builder;
_contents = contents;
_members = members;
_serializers = serializers;
_element = element;
_locator = locator;
}
public void Init(IMembers view, bool IsPostBack)
{
_view = view;
//do we show the buttons?
if (_webContext.CurrentUser == null)
_view.SetButtonsVisibility(false);
else if (_groupService.IsOwnerOrAdministrator(_webContext.CurrentUser.AccountID, _webContext.GroupID))
_view.SetButtonsVisibility(true);
else
_view.SetButtonsVisibility(false);
if (!IsPostBack)
LoadData();
}
public override void TranslateMembers <TItem, TParent, TDom>(TParent parent, IMembers <TItem, TParent, TDom> members)
{
bool firstMember = true;
foreach (TItem ti in members.Values)
{
if ((((IDeclarationTarget)(ti.ParentTarget)) == ((IDeclarationTarget)(parent))) || ((!(options.AllowPartials)) && (parent is ISegmentableDeclarationTarget) && (ti.ParentTarget is ISegmentableDeclarationTarget) && ((ISegmentableDeclarationTarget)(ti.ParentTarget)).GetRootDeclaration() == ((ISegmentableDeclarationTarget)(parent)).GetRootDeclaration()))
{
if (firstMember)
{
firstMember = false;
}
else
{
this.WriteLine();
}
this.TranslateMember((IMember)ti);
}
}
}
public void Init(IMembers view, bool IsPostBack)
{
_view = view;
//do we show the buttons?
if (_webContext.CurrentUser == null)
{
_view.SetButtonsVisibility(false);
}
else if (_groupService.IsOwnerOrAdministrator(_webContext.CurrentUser.AccountID, _webContext.GroupID))
{
_view.SetButtonsVisibility(true);
}
else
{
_view.SetButtonsVisibility(false);
}
if (!IsPostBack)
{
LoadData();
}
}
public static Method Method(this IMembers members, Type methodType) => new MethodTypeFilter(members.Methods(), methodType, methodFactory).Single();
public static Method Method(this IMembers members, string methodName) => new MemberNameFilter <Method, MethodInfo>(members.Methods(), methodName).Single();
public static Method Method(this IMembers members) => members.Methods().Single();
public static IMembers Internal(this IMembers members) => new AccessibleMembers(members, Accessibility.Internal);
