Пример #1
0
 public void ConstructionOfInvalidTypeThrows()
 {
     Assert.Throws <InvalidOperationException>(() => TypeConstruction.Construct <IConstructInterface>());
     Assert.Throws <InvalidOperationException>(() => TypeConstruction.Construct <AbstractConstructibleBaseType>());
     Assert.Throws <InvalidOperationException>(() => TypeConstruction.Construct <NonConstructibleDerivedType>());
     Assert.Throws <InvalidOperationException>(() => TypeConstruction.Construct <ParameterConstructorType>());
 }
        internal static void ValidateBuildArtifactTypeAndThrow(Type buildArtifactType)
        {
            if (buildArtifactType == null)
            {
                throw new ArgumentNullException(nameof(buildArtifactType));
            }

            if (buildArtifactType == typeof(object))
            {
                throw new InvalidOperationException("Build artifact type cannot be object.");
            }

            if (!buildArtifactType.IsClass)
            {
                throw new InvalidOperationException($"Build artifact type {buildArtifactType.FullName} is not a class.");
            }

            if (!typeof(IBuildArtifact).IsAssignableFrom(buildArtifactType))
            {
                throw new InvalidOperationException($"Build artifact type {buildArtifactType.FullName} does not derive from {typeof(IBuildArtifact).FullName}.");
            }

            if (!TypeConstruction.CanBeConstructed(buildArtifactType))
            {
                throw new InvalidOperationException($"Build artifact type {buildArtifactType.FullName} cannot be constructed because it does not have a default, implicit or registered constructor.");
            }
        }
Пример #3
0
        internal static IBuildStep Deserialize(string json)
        {
            if (string.IsNullOrEmpty(json))
            {
                return(null);
            }

            if (GlobalObjectId.TryParse(json, out var id))
            {
                if (GlobalObjectId.GlobalObjectIdentifierToObjectSlow(id) is BuildPipeline pipeline)
                {
                    return(pipeline);
                }
            }
            else
            {
                var type = Type.GetType(json);
                if (TypeConstruction.TryConstruct <IBuildStep>(type, out var step))
                {
                    return(step);
                }
            }

            return(null);
        }
Пример #4
0
 public void CanBeConstructedFromGenericMethod_WithNonConstructableType_ReturnsFalse()
 {
     Assert.That(TypeConstruction.CanBeConstructed <IConstructInterface>(), Is.False);
     Assert.That(TypeConstruction.CanBeConstructed <AbstractConstructibleBaseType>(), Is.False);
     Assert.That(TypeConstruction.CanBeConstructed <NonConstructibleDerivedType>(), Is.False);
     Assert.That(TypeConstruction.CanBeConstructed <ParameterConstructorType>(), Is.False);
 }
        public CerasMessageSerializer()
        {
            CerasBufferPool.Pool = new CerasBuffer();

            _serializer = new ThreadLocal <CerasSerializer>(() =>
            {
                config = new SerializerConfig();

                config.Warnings.ExceptionOnStructWithAutoProperties = false;

                config.OnConfigNewType = (t) =>
                {
                    t.TargetMembers = TargetMember.AllPublic;

                    t.TypeConstruction = TypeConstruction.ByUninitialized();

                    if (typeof(Exception).IsAssignableFrom(t.Type))
                    {
                        t.TargetMembers = TargetMember.All;
                    }
                };

                return(new CerasSerializer(config));
            });
        }
Пример #6
0
        /// <summary>
        /// Get all optional components from <see cref="BuildConfiguration"/>, that matches <see cref="Type"/>.
        /// Optional component types not found in <see cref="BuildConfiguration"/> will be set to a new instance of that type.
        /// </summary>
        /// <param name="context">The <see cref="BuildContext"/> used by the execution of this <see cref="BuildStep"/>.</param>
        /// <param name="type">Type of the components.</param>
        /// <returns>List of optional components.</returns>
        public IEnumerable <IBuildComponent> GetOptionalComponents(BuildContext context, Type type)
        {
            CheckTypeAndThrowIfInvalid <IBuildComponent>(type);
            if (OptionalComponents == null || !OptionalComponents.Contains(type))
            {
                throw new InvalidOperationException($"Component type '{type.FullName}' is not in the {nameof(OptionalComponents)} list.");
            }

            var lookup = new Dictionary <Type, IBuildComponent>();

            foreach (var optionalComponentType in OptionalComponents)
            {
                if (!type.IsAssignableFrom(optionalComponentType))
                {
                    continue;
                }

                if (!context.BuildConfiguration.TryGetComponent(optionalComponentType, out var component))
                {
                    component = TypeConstruction.Construct <IBuildComponent>(optionalComponentType);
                }
                lookup[optionalComponentType] = component;
            }
            return(lookup.Values);
        }
Пример #7
0
        public void ReturnsAnActualInstanceTests()
        {
            {
                var instance = TypeConstruction.Construct <ConstructibleBaseType>();
                Assert.That(instance, Is.Not.Null);
                Assert.That(instance.Value, Is.EqualTo(25.0f));
            }

            {
                var instance = TypeConstruction.Construct <ConstructibleDerivedType>();
                Assert.That(instance, Is.Not.Null);
                Assert.That(instance.Value, Is.EqualTo(25.0f));
                Assert.That(instance.SubValue, Is.EqualTo(50.0f));
            }

            {
                var instance = TypeConstruction.Construct <ConstructibleDerivedType>();
                Assert.That(instance, Is.Not.Null);
                Assert.That(instance.Value, Is.EqualTo(25.0f));
                Assert.That(instance.SubValue, Is.EqualTo(50.0f));
            }

            {
                var instance = TypeConstruction.Construct <ScriptableObjectType>();
                Assert.That(instance, Is.Not.Null);
                Assert.That(instance, Is.Not.False);
            }
        }
Пример #8
0
        public Ceras(bool forNetworking = true)
        {
            if (CerasBufferPool.Pool == null)
            {
                CerasBufferPool.Pool = new CerasDefaultBufferPool();
            }

            mSerializerConfig = new SerializerConfig
            {
                PreserveReferences = false
            };

            mSerializerConfig.Advanced.SealTypesWhenUsingKnownTypes = forNetworking;

            if (forNetworking)
            {
                mSerializerConfig.VersionTolerance.Mode = VersionToleranceMode.Disabled;
                mSerializerConfig.KnownTypes.AddRange(KnownTypes);
                mSerializerConfig.KnownTypes.ForEach(
                    knownType =>
                    mSerializerConfig.ConfigType(knownType).TypeConstruction = TypeConstruction.ByUninitialized()
                    );
            }
            else
            {
                mSerializerConfig.VersionTolerance.Mode = VersionToleranceMode.Standard;
            }

            mSerializer = new CerasSerializer(mSerializerConfig);
        }
        static void AssertPropertyIsOfType <TContainer, TValue>(IPropertyBag <TContainer> propertyBag, string propertyName)
        {
            var container     = TypeConstruction.Construct <TContainer>(typeof(TContainer));
            var changeTracker = default(ChangeTracker);
            var action        = new AssertThatPropertyIsOfType <TContainer, TValue>();

            Assert.That(propertyBag.FindProperty(propertyName, ref container, ref changeTracker, ref action), Is.True);
        }
Пример #10
0
        static T CopyComponent <T>(T value)
        {
            var result = TypeConstruction.Construct <T>(value.GetType());

            PropertyContainer.Construct(ref result, ref value).Dispose();
            PropertyContainer.Transfer(ref result, ref value).Dispose();
            return(result);
        }
        public static void RegisterTypes()
        {
            TypeConversion.Register <SerializedStringView, DirectoryInfo>(view => new DirectoryInfo(view.ToString()));
            TypeConstruction.SetExplicitConstructionMethod(() => { return(new DirectoryInfo(".")); });

            TypeConversion.Register <SerializedStringView, FileInfo>(view => new FileInfo(view.ToString()));
            TypeConstruction.SetExplicitConstructionMethod(() => { return(new FileInfo(".")); });
        }
Пример #12
0
 public void CanBeConstructedFromGenericMethod_WithConstructableType_ReturnsTrue()
 {
     Assert.That(TypeConstruction.CanBeConstructed <ConstructibleBaseType>(), Is.True);
     Assert.That(TypeConstruction.CanBeConstructed <ConstructibleDerivedType>(), Is.True);
     Assert.That(TypeConstruction.CanBeConstructed <NoConstructorType>(), Is.True);
     Assert.That(TypeConstruction.CanBeConstructed <ParameterLessConstructorType>(), Is.True);
     Assert.That(TypeConstruction.CanBeConstructed <ScriptableObjectType>(), Is.True);
 }
Пример #13
0
        public VisitStatus Visit <TContainer, TValue>(Property <TContainer, TValue> property, ref TContainer container,
                                                      ref TValue value)
        {
            if (!RuntimeTypeInfoCache <TValue> .CanBeNull || null != value)
            {
                return(VisitStatus.Unhandled);
            }

            if (typeof(UnityEngine.Object).IsAssignableFrom(typeof(TValue)))
            {
                return(VisitStatus.Unhandled);
            }

            if (!property.IsReadOnly && property.HasAttribute <CreateInstanceOnInspectionAttribute>() && !(property is ICollectionElementProperty))
            {
                var attribute = property.GetAttribute <CreateInstanceOnInspectionAttribute>();
                if (null == attribute.Type)
                {
                    if (TypeConstruction.CanBeConstructed <TValue>())
                    {
                        value = TypeConstruction.Construct <TValue>();
                        property.SetValue(ref container, value);
                        return(VisitStatus.Unhandled);
                    }

                    Debug.LogWarning(PropertyChecks.GetNotConstructableWarningMessage(typeof(TValue)));
                }
                else
                {
                    var isAssignable    = typeof(TValue).IsAssignableFrom(attribute.Type);
                    var isConstructable = TypeConstruction.GetAllConstructableTypes(typeof(TValue))
                                          .Contains(attribute.Type);
                    if (isAssignable && isConstructable)
                    {
                        value = TypeConstruction.Construct <TValue>(attribute.Type);
                        property.SetValue(ref container, value);
                        return(VisitStatus.Unhandled);
                    }

                    Debug.LogWarning(isAssignable
                        ? PropertyChecks.GetNotConstructableWarningMessage(attribute.Type)
                        : PropertyChecks.GetNotAssignableWarningMessage(attribute.Type, typeof(TValue)));
                }
            }

            Visitor.AddToPath(property);
            try
            {
                var path    = Visitor.GetCurrentPath();
                var element = new NullElement <TValue>(VisitorContext.Root, property, path);
                VisitorContext.Parent.contentContainer.Add(element);
            }
            finally
            {
                Visitor.RemoveFromPath(property);
            }
            return(VisitStatus.Stop);
        }
Пример #14
0
        internal static SearcherDatabase Populate <T>(Func <Type, bool> filter = null, Func <Type, string> nameResolver = null, Func <Type, string> categoryResolver = null)
        {
            var list = new List <SearcherItem>();
            var dict = new Dictionary <string, SearcherItem>();

            var types = TypeCache.GetTypesDerivedFrom <T>();

            foreach (var type in types)
            {
                if (type.IsGenericType || type.IsAbstract || type.ContainsGenericParameters || type.IsInterface)
                {
                    continue;
                }

                if (!TypeConstruction.CanBeConstructed(type))
                {
                    continue;
                }

                if (filter != null && !filter(type))
                {
                    continue;
                }

                try
                {
                    var typeItem = new TypeSearcherItem(type, nameResolver != null ? nameResolver(type) : string.Empty);
                    var category = categoryResolver != null?categoryResolver(type) : type.Namespace ?? "Global";

                    if (!string.IsNullOrEmpty(category))
                    {
                        if (!dict.TryGetValue(category, out var item))
                        {
                            dict[category] = item = new SearcherItem(category);
                            list.Add(item);
                        }
                        item.AddChild(typeItem);
                    }
                    else
                    {
                        list.Add(typeItem);
                    }
                }
                catch (Exception)
                {
                    // ignored
                }
            }

            foreach (var kvp in dict)
            {
                kvp.Value.Children.Sort(CompareByName);
            }

            list.Sort(CompareByName);

            return(new SearcherDatabase(list));
        }
Пример #15
0
 bool OnTypeSelected(SearcherItem item)
 {
     if (item is TypeSearcherItem typeItem && TypeConstruction.TryConstruct <T>(typeItem.Type, out var instance))
     {
         Target = instance;
         return(true);
     }
     return(false);
 }
Пример #16
0
 public void CanBeConstructedFromDerivedType_FromNonConstructableDerivedType_ReturnsFalse()
 {
     Assert.That(TypeConstruction.CanBeConstructedFromDerivedType <ConstructibleDerivedType>(), Is.False);
     Assert.That(TypeConstruction.CanBeConstructedFromDerivedType <NonConstructibleDerivedType>(), Is.False);
     Assert.That(TypeConstruction.CanBeConstructedFromDerivedType <NoConstructorType>(), Is.False);
     Assert.That(TypeConstruction.CanBeConstructedFromDerivedType <ParameterLessConstructorType>(), Is.False);
     Assert.That(TypeConstruction.CanBeConstructedFromDerivedType <ParameterConstructorType>(), Is.False);
     Assert.That(TypeConstruction.CanBeConstructedFromDerivedType <ScriptableObjectType>(), Is.False);
 }
 /// <summary>
 /// Get the value of a <see cref="Type"/> component if found.
 /// Otherwise an instance created using <see cref="TypeConstruction"/> utility.
 /// The container is not modified.
 /// </summary>
 /// <param name="type"><see cref="Type"/> of the component.</param>
 /// <returns>The component value.</returns>
 public TComponent GetComponentOrDefault(Type type)
 {
     CheckComponentTypeAndThrowIfInvalid(type);
     if (!TryGetComponent(type, out var value))
     {
         return(TypeConstruction.Construct <TComponent>(type));
     }
     return(value);
 }
Пример #18
0
        internal static TComponent Construct(Type componentType)
        {
            if (!TypeConstruction.CanBeConstructed(componentType))
            {
                throw new InvalidOperationException($"Component type {componentType.FullName} cannot be constructed because it does not have a default, implicit or registered constructor.");
            }

            return(TypeConstruction.Construct <TComponent>(componentType));
        }
        public NullElement(PropertyElement root, IProperty property, PropertyPath path)
        {
            m_PotentialTypes = new List <Type> {
                typeof(Null)
            };
            binding = this;
            m_Root  = root;
            m_Path  = path;
            name    = m_Path.ToString();

            TypeConstruction.GetAllConstructableTypes <T>(m_PotentialTypes);

            if (typeof(T).IsArray)
            {
                Resources.Templates.NullStringField.Clone(this);
                this.Q <Label>().text = GuiFactory.GetDisplayName(property);
                var button = this.Q <Button>();
                button.text = $"Null ({GetTypeName(typeof(T))})";
                button.clickable.clicked += ReloadWithArrayType;
                if (property.IsReadOnly)
                {
                    button.SetEnabledSmart(false);
                }
                return;
            }

            if (m_PotentialTypes.Count == 2)
            {
                Resources.Templates.NullStringField.Clone(this);
                this.Q <Label>().text = GuiFactory.GetDisplayName(property);
                var button = this.Q <Button>();
                button.text = $"Null ({GetTypeName(typeof(T))})";
                button.clickable.clicked += ReloadWithFirstType;
                if (property.IsReadOnly)
                {
                    button.SetEnabledSmart(false);
                }
                return;
            }

            var typeSelector = new PopupField <Type>(
                GuiFactory.GetDisplayName(property),
                m_PotentialTypes,
                typeof(Null),
                GetTypeName,
                GetTypeName);

            typeSelector.RegisterValueChangedCallback(OnCreateItem);
            if (property.IsReadOnly)
            {
                typeSelector.pickingMode = PickingMode.Ignore;
                typeSelector.Q(className: UssClasses.Unity.BasePopupFieldInput).SetEnabledSmart(false);
            }

            Add(typeSelector);
        }
        static void AssertPropertyValueAndTypeIsEqualTo <TContainer>(IPropertyBag <TContainer> propertyBag, string propertyName, object expectedValue)
        {
            var container     = TypeConstruction.Construct <TContainer>(typeof(TContainer));
            var changeTracker = default(ChangeTracker);
            var action        = new AssertThatPropertyValueAndTypeIsEqualTo <TContainer> {
                ExpectedValue = expectedValue
            };

            Assert.That(propertyBag.FindProperty(propertyName, ref container, ref changeTracker, ref action), Is.True);
        }
Пример #21
0
        public static IEnumerable <T> ConstructTypesDerivedFrom <T>(bool fromUnityAssembliesOnly = true)
        {
            var types = TypeCache.GetTypesDerivedFrom <T>().Where(type => !type.IsAbstract && !type.IsGenericType);

            if (fromUnityAssembliesOnly)
            {
                types = types.Where(type => type.Assembly.GetName().Name.StartsWith("Unity."));
            }
            return(types.Select(type => TypeConstruction.Construct <T>(type)));
        }
Пример #22
0
        public void Initialization()
        {
            var constructor = NormalizingMemberInfoFromExpressionUtility.GetConstructor(() => new DomainAspect());

            var result = new TypeConstruction(typeof(DomainAspect));

            Assert.That(result.ConstructorInfo, Is.EqualTo(constructor));
            Assert.That(result.ConstructorArguments, Is.Empty);
            Assert.That(result.NamedArguments, Is.Empty);
        }
        /// <summary>
        /// Set the value of a <see cref="Type"/> component on this container using an instance created using <see cref="TypeConstruction"/> utility.
        /// </summary>
        /// <param name="type">Type of the component.</param>
        public void SetComponent(Type type)
        {
            CheckComponentTypeAndThrowIfInvalid(type);
            if (type.IsInterface || type.IsAbstract)
            {
                throw new InvalidOperationException($"{nameof(type)} cannot be interface or abstract.");
            }

            SetComponent(type, TypeConstruction.Construct <TComponent>(type));
        }
Пример #24
0
        private void AddKnownTypes(SerializerConfig config, string nameSpce)
        {
            var packetTypes = Assembly.GetExecutingAssembly().GetTypes().Where(t => t.Namespace == nameSpce).ToList();

            foreach (var typ in packetTypes)
            {
                config.KnownTypes.Add(typ);
                mSerializerConfig.ConfigType(typ).TypeConstruction = TypeConstruction.ByUninitialized();
            }
        }
        public static T ConstructFromAssemblyQualifiedTypeName <T>(string assemblyQualifiedTypeName)
        {
            var type = Type.GetType(assemblyQualifiedTypeName);

            if (null == type && FormerNameAttribute.TryGetCurrentTypeName(assemblyQualifiedTypeName, out var currentTypeName))
            {
                type = Type.GetType(currentTypeName);
            }
            return(TypeConstruction.Construct <T>(type));
        }
Пример #26
0
 public void TryToConstructAnInstance_WithAConstructableType_ReturnsTrue()
 {
     Assert.That(TypeConstruction.TryConstruct <Types.NoConstructorClass>(out _), Is.True);
     Assert.That(TypeConstruction.TryConstruct <Types.NoConstructorStruct>(out _), Is.True);
     Assert.That(TypeConstruction.TryConstruct <Types.DefaultConstructorClass>(out _), Is.True);
     Assert.That(TypeConstruction.TryConstruct <Types.DefaultAndCustomConstructorClass>(out _), Is.True);
     Assert.That(TypeConstruction.TryConstruct <Types.CustomConstructorStruct>(out _), Is.True);
     Assert.That(TypeConstruction.TryConstruct <Types.ChildOfAbstractClassWithNoConstructor>(out _), Is.True);
     Assert.That(TypeConstruction.TryConstruct <Types.ChildOfAbstractClassWithDefaultConstructor>(out _), Is.True);
     Assert.That(TypeConstruction.TryConstruct <Types.ChildOfAbstractClassWithPrivateDefaultConstructor>(out _), Is.True);
 }
        /// <summary>
        /// Get the first build artifact value that is assignable to specified type, or create and set it if not found.
        /// Multiple build artifact value can be stored per build configuration.
        /// </summary>
        /// <typeparam name="T">The build artifact type.</typeparam>
        /// <returns>The build artifact value.</returns>
        public T GetOrCreateBuildArtifact <T>() where T : class, IBuildArtifact, new()
        {
            var artifact = GetBuildArtifact <T>();

            if (artifact == null)
            {
                artifact = TypeConstruction.Construct <T>();
                SetBuildArtifact(artifact);
            }
            return(artifact);
        }
Пример #28
0
        /// <summary>
        /// Get value of type <typeparamref name="T"/> if found, otherwise a new instance of type <typeparamref name="T"/> constructed with <see cref="TypeConstruction"/>.
        /// </summary>
        /// <typeparam name="T">The value type.</typeparam>
        /// <returns>The value or new instance of type <typeparamref name="T"/>.</returns>
        public T GetOrCreateValue <T>() where T : class
        {
            var value = GetValue <T>();

            if (value == null)
            {
                value = TypeConstruction.Construct <T>();
                SetValue(value);
            }
            return(value);
        }
Пример #29
0
        public Aspect Build(Type type)
        {
            var aspectAttribute = type.GetCustomAttributes <AspectAttribute> (true).SingleOrDefault();

            Assertion.IsNotNull(aspectAttribute);

            var construction = new TypeConstruction(type);
            var pointcut     = _pointcutBuilder.Build(type);

            return(Build(type, aspectAttribute, construction, pointcut));
        }
Пример #30
0
 public void ConstructingAnInstance_WithAConstructableType_ReturnsAnActualInstance()
 {
     Assert.That(TypeConstruction.Construct <Types.NoConstructorClass>(), Is.Not.Null);
     Assert.That(TypeConstruction.Construct <Types.NoConstructorStruct>(), Is.Not.Null);
     Assert.That(TypeConstruction.Construct <Types.DefaultConstructorClass>(), Is.Not.Null);
     Assert.That(TypeConstruction.Construct <Types.DefaultAndCustomConstructorClass>(), Is.Not.Null);
     Assert.That(TypeConstruction.Construct <Types.CustomConstructorStruct>(), Is.Not.Null);
     Assert.That(TypeConstruction.Construct <Types.ChildOfAbstractClassWithNoConstructor>(), Is.Not.Null);
     Assert.That(TypeConstruction.Construct <Types.ChildOfAbstractClassWithDefaultConstructor>(), Is.Not.Null);
     Assert.That(TypeConstruction.Construct <Types.ChildOfAbstractClassWithPrivateDefaultConstructor>(), Is.Not.Null);
 }