public MouseKeyboardEvents(CompendiumMapDepthMap _caller, MapDepthViewManager viewManager, TypeManager typeManager, MapDepthNavigator navigator, DatabaseMappingService nodeService, ScaleTransform _scaleTransform, TranslateTransform _translateTransform) { caller = _caller; ViewManager = viewManager; _typeManager = typeManager; _navigator = navigator; _nodeService = nodeService; scaleTransform = _scaleTransform; translateTransform = _translateTransform; }
/// <summary> /// Get all types that can be assigned to type rootType. /// </summary> /// <param name="rootType">The class type to use as the base class or interface for all found types.</param> /// <returns>A list of types that are assignable to type T. The results are not cached.</returns> public static List <Type> GetTypes(Type rootType) { return(TypeManager.GetManagerTypes(rootType)); }
private PackageFragmentValidationResult DoInstall() { using (var transactionScope = TransactionsFacade.Create(true, TimeSpan.FromMinutes(30.0))) { string uninstallFilename = Path.Combine(this.PackageInstallDirectory, PackageSystemSettings.UninstallFilename); Exception installException = null; XElement uninstallElements = new XElement(XmlUtils.GetXName(PackageSystemSettings.XmlNamespace, PackageSystemSettings.PackageFragmentUninstallersElementName)); try { foreach (var kvp in _packageFramentInstallers) { List <XElement> uninstallInformation = kvp.Key.Install().ToList(); if (this.CanBeUninstalled) { XElement uninstallElement = new XElement(XmlUtils.GetXName(PackageSystemSettings.XmlNamespace, PackageSystemSettings. PackageFragmentUninstallersAddElementName)); uninstallElement.Add(new XAttribute(PackageSystemSettings.UninstallerTypeAttributeName, TypeManager.SerializeType(kvp.Value))); uninstallElement.Add(uninstallInformation); uninstallElements.Add(uninstallElement); } } } catch (Exception ex) { installException = ex; LoggingService.LogError("Package installation failed", ex); } finally { if (this.CanBeUninstalled) { XDocument doc = new XDocument( new XElement( XmlUtils.GetXName(PackageSystemSettings.XmlNamespace, PackageSystemSettings.PackageInstallerElementName), uninstallElements)); doc.SaveToFile(uninstallFilename); } } if (installException != null) { if (this.CanBeUninstalled) { IPackageUninstaller packageUninstaller = this.PackageInstallerUninstallerFactory.CreateUninstaller( this.ZipFilename, uninstallFilename, this.PackageInstallDirectory, TempDirectoryFacade. CreateTempDirectory(), this.FlushOnCompletion, this.ReloadConsoleOnCompletion, false, this.PackageInformation); List <PackageFragmentValidationResult> validationResult = null; try { validationResult = packageUninstaller.Validate().ToList(); } catch (Exception ex) { return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, ex)); } if (validationResult.Count == 0) { try { packageUninstaller.Uninstall(SystemLockingType.None); } catch (Exception ex) { return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, ex)); } } else { LoggingService.LogError(LogTitle, "Failed to perform installation rollback."); foreach (var valResult in validationResult) { if (valResult.Exception != null) { LoggingService.LogError(LogTitle, new InvalidOperationException(valResult.Message ?? string.Empty, valResult.Exception)); } else { LoggingService.LogWarning(LogTitle, valResult.Message); } } return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, "Could not perform installation rollback. The details are in the log.") { InnerResult = validationResult }); } } return(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, installException)); } transactionScope.Complete(); } return(null); }
public IValue ReadXML(XmlReaderImpl xmlReader, IValue valueType = null) { TypeTypeValue typeValue = null; if (valueType is TypeTypeValue typeTypeValue) { typeValue = typeTypeValue; } else if (xmlReader.NodeType == xmlNodeEnum.FromNativeValue(XmlNodeType.Element)) { IValue xsiType = xmlReader.GetAttribute(ValueFactory.Create("type"), XmlSchema.InstanceNamespace); IValue xsiNil = xmlReader.GetAttribute(ValueFactory.Create("nil"), XmlSchema.InstanceNamespace); if (xsiType.DataType == DataType.String) { switch (xsiType.AsString()) { case "string": typeValue = new TypeTypeValue("String"); break; case "decimal": typeValue = new TypeTypeValue("Number"); break; case "boolean": typeValue = new TypeTypeValue("Boolean"); break; case "dateTime": typeValue = new TypeTypeValue("Date"); break; default: break; } } else if (xsiNil.DataType == DataType.String) { typeValue = new TypeTypeValue("Undefined"); } } ; if (typeValue == null) { throw RuntimeException.InvalidArgumentValue(); } Type implType = TypeManager.GetImplementingClass(typeValue.Value.ID); IValue result = ValueFactory.Create(); if (typeValue.Equals(new TypeTypeValue("Undefined"))) { result = ValueFactory.Create(); xmlReader.Skip(); } else if (implType == typeof(DataType)) { xmlReader.Read(); if (xmlReader.NodeType == xmlNodeEnum.FromNativeValue(XmlNodeType.Text)) { result = XMLValue(typeValue, xmlReader.Value); xmlReader.Read(); } else { throw RuntimeException.InvalidArgumentValue(); } } else if (typeof(IXDTOSerializableXML).IsAssignableFrom(implType)) { result = Activator.CreateInstance(implType, new object[] { xmlReader, this }) as IValue; } xmlReader.Read(); return(result); }
// caller already: // - setup the header and namespace // - call/emit PrintPlatformAttributes on the type void GenerateEnum(Type type) { if (AttributeManager.HasAttribute <FlagsAttribute> (type)) { print("[Flags]"); } var native = AttributeManager.GetCustomAttribute <NativeAttribute> (type); if (native != null) { var sb = new StringBuilder(); sb.Append("[Native"); var hasNativeName = !string.IsNullOrEmpty(native.NativeName); var hasConvertToManaged = !string.IsNullOrEmpty(native.ConvertToManaged); var hasConvertToNative = !string.IsNullOrEmpty(native.ConvertToNative); if (hasNativeName || hasConvertToManaged || hasConvertToNative) { sb.Append(" ("); if (hasNativeName) { sb.Append('"').Append(native.NativeName).Append('"'); } if (hasConvertToManaged) { if (hasNativeName) { sb.Append(", "); } sb.Append("ConvertToManaged = \""); sb.Append(native.ConvertToManaged); sb.Append('"'); } if (hasConvertToNative) { if (hasNativeName || hasConvertToManaged) { sb.Append(", "); } sb.Append("ConvertToNative = \""); sb.Append(native.ConvertToNative); sb.Append('"'); } sb.Append(")"); } sb.Append("]"); print(sb.ToString()); } CopyObsolete(type); var unique_constants = new HashSet <string> (); var fields = new Dictionary <FieldInfo, FieldAttribute> (); Tuple <FieldInfo, FieldAttribute> null_field = null; Tuple <FieldInfo, FieldAttribute> default_symbol = null; var underlying_type = GetCSharpTypeName(TypeManager.GetUnderlyingEnumType(type)); print("{0} enum {1} : {2} {{", AttributeManager.HasAttribute <InternalAttribute> (type) ? "internal" : "public", type.Name, underlying_type); indent++; foreach (var f in type.GetFields()) { // skip value__ field if (f.IsSpecialName) { continue; } PrintPlatformAttributes(f); CopyObsolete(f); print("{0} = {1},", f.Name, f.GetRawConstantValue()); var fa = AttributeManager.GetCustomAttribute <FieldAttribute> (f); if (fa == null) { continue; } if (f.IsUnavailable(this)) { continue; } if (fa.SymbolName == null) { null_field = new Tuple <FieldInfo, FieldAttribute> (f, fa); } else if (unique_constants.Contains(fa.SymbolName)) { throw new BindingException(1046, true, fa.SymbolName, type.Name); } else { fields.Add(f, fa); unique_constants.Add(fa.SymbolName); } if (AttributeManager.GetCustomAttribute <DefaultEnumValueAttribute> (f) != null) { if (default_symbol != null) { throw new BindingException(1045, true, type.Name); } default_symbol = new Tuple <FieldInfo, FieldAttribute> (f, fa); } } indent--; print("}"); unique_constants.Clear(); var library_name = type.Namespace; var error = AttributeManager.GetCustomAttribute <ErrorDomainAttribute> (type); if ((fields.Count > 0) || (error != null) || (null_field != null)) { print(""); // the *Extensions has the same version requirement as the enum itself PrintPlatformAttributes(type); print_generated_code(); print("static public partial class {0}Extensions {{", type.Name); indent++; var field = fields.FirstOrDefault(); var fieldAttr = field.Value; ComputeLibraryName(fieldAttr, type, field.Key?.Name, out library_name, out string library_path); } if (error != null) { // this attribute is important for our tests print("[Field (\"{0}\", \"{1}\")]", error.ErrorDomain, library_name); print("static NSString? _domain;"); print(""); print("public static NSString? GetDomain (this {0} self)", type.Name); print("{"); indent++; print("if (_domain is null)"); indent++; print("_domain = Dlfcn.GetStringConstant (Libraries.{0}.Handle, \"{1}\");", library_name, error.ErrorDomain); indent--; print("return _domain;"); indent--; print("}"); } if ((fields.Count > 0) || (null_field != null)) { print("static IntPtr[] values = new IntPtr [{0}];", fields.Count); print(""); int n = 0; foreach (var kvp in fields) { var f = kvp.Key; var fa = kvp.Value; // the attributes (availability and field) are important for our tests PrintPlatformAttributes(f); libraries.TryGetValue(library_name, out var libPath); var libname = fa.LibraryName?.Replace("+", string.Empty); // We need to check for special cases inside FieldAttributes // fa.LibraryName could contain a different framework i.e UITrackingRunLoopMode (UIKit) inside NSRunLoopMode enum (Foundation). // libPath could have a custom path i.e. CoreImage which in macOS is inside Quartz // library_name contains the Framework constant name the Field is inside of, used as fallback. bool useFieldAttrLibName = libname != null && !string.Equals(libname, library_name, StringComparison.OrdinalIgnoreCase); print("[Field (\"{0}\", \"{1}\")]", fa.SymbolName, useFieldAttrLibName ? libname : libPath ?? library_name); print("internal unsafe static IntPtr {0} {{", fa.SymbolName); indent++; print("get {"); indent++; print("fixed (IntPtr *storage = &values [{0}])", n++); indent++; print("return Dlfcn.CachePointer (Libraries.{0}.Handle, \"{1}\", storage);", useFieldAttrLibName ? libname : library_name, fa.SymbolName); indent--; indent--; print("}"); indent--; print("}"); print(""); } print("public static NSString? GetConstant (this {0} self)", type.Name); print("{"); indent++; print("IntPtr ptr = IntPtr.Zero;"); // can be empty - and the C# compiler emit `warning CS1522: Empty switch block` if (fields.Count > 0) { print("switch (({0}) self) {{", underlying_type); var default_symbol_name = default_symbol?.Item2.SymbolName; // more than one enum member can share the same numeric value - ref: #46285 foreach (var kvp in fields) { print("case {0}: // {1}.{2}", Convert.ToInt64(kvp.Key.GetRawConstantValue()), type.Name, kvp.Key.Name); var sn = kvp.Value.SymbolName; if (sn == default_symbol_name) { print("default:"); } indent++; print("ptr = {0};", sn); print("break;"); indent--; } print("}"); } print("return (NSString?) Runtime.GetNSObject (ptr);"); indent--; print("}"); print(""); var nullable = null_field != null; print("public static {0} GetValue (NSString{1} constant)", type.Name, nullable ? "?" : ""); print("{"); indent++; print("if (constant is null)"); indent++; // if we do not have a enum value that maps to a null field then we throw if (!nullable) { print("throw new ArgumentNullException (nameof (constant));"); } else { print("return {0}.{1};", type.Name, null_field.Item1.Name); } indent--; foreach (var kvp in fields) { print("if (constant.IsEqualTo ({0}))", kvp.Value.SymbolName); indent++; print("return {0}.{1};", type.Name, kvp.Key.Name); indent--; } // if there's no default then we throw on unknown constants if (default_symbol == null) { print("throw new NotSupportedException ($\"{constant} has no associated enum value on this platform.\");"); } else { print("return {0}.{1};", type.Name, default_symbol.Item1.Name); } indent--; print("}"); } if ((fields.Count > 0) || (error != null) || (null_field != null)) { indent--; print("}"); } // namespace closing (it's optional to use namespaces even if it's a bad practice, ref #35283) if (indent > 0) { indent--; print("}"); } }
public COMWrapperContext() : base(TypeManager.GetTypeByFrameworkType(typeof(COMWrapperContext))) { }
public MessageReceiverHandler(INodeNavigator navigator, MapDepthViewManager viewManager, TypeManager typeManager) { Navigator = navigator; ViewManager = viewManager; TypeManager = typeManager; }
public CharacterDB(DatabaseConnection db, ItemDB itemDB, TypeManager typeManager) : base(db) { this.TypeManager = typeManager; this.ItemDB = itemDB; }
private void ValidateDynamicAddedType(DataType dataType) { DataTypeDescriptor dataTypeDescriptor = this.InstallerContext.GetPendingDataTypeDescriptor(dataType.InterfaceTypeName); if (dataTypeDescriptor == null) { _validationResult.AddFatal(GetText("DataPackageFragmentInstaller.MissingTypeDescriptor").FormatWith(dataType.InterfaceTypeName)); return; } bool dataTypeLocalized = dataTypeDescriptor.SuperInterfaces.Contains(typeof(ILocalizedControlled)); if (!ValidateTargetLocaleInfo(dataType, dataTypeLocalized)) { return; } foreach (XElement addElement in dataType.Dataset) { var dataKeyPropertyCollection = new DataKeyPropertyCollection(); bool propertyValidationPassed = true; var fieldValues = new Dictionary <string, object>(); foreach (XAttribute attribute in addElement.Attributes()) { string fieldName = attribute.Name.LocalName; // A compatibility fix if (IsObsoleteField(dataTypeDescriptor, fieldName)) { continue; } DataFieldDescriptor dataFieldDescriptor = dataTypeDescriptor.Fields[fieldName]; if (dataFieldDescriptor == null) { _validationResult.AddFatal(Texts.DataPackageFragmentInstaller_MissingProperty(dataTypeDescriptor, fieldName)); propertyValidationPassed = false; continue; } object fieldValue; try { fieldValue = ValueTypeConverter.Convert(attribute.Value, dataFieldDescriptor.InstanceType); } catch (Exception) { _validationResult.AddFatal(Texts.DataPackageFragmentInstaller_ConversionFailed(attribute.Value, dataFieldDescriptor.InstanceType)); propertyValidationPassed = false; continue; } if (dataTypeDescriptor.KeyPropertyNames.Contains(fieldName)) { dataKeyPropertyCollection.AddKeyProperty(fieldName, fieldValue); } fieldValues.Add(fieldName, fieldValue); } if (!propertyValidationPassed) { continue; } if (!dataType.AllowOverwrite && !dataType.OnlyUpdate) { // TODO: implement check if the same key has already been added } RegisterKeyToBeAdded(dataType, dataTypeDescriptor, dataKeyPropertyCollection); // Checking foreign key references foreach (var referenceField in dataTypeDescriptor.Fields.Where(f => f.ForeignKeyReferenceTypeName != null)) { if (!fieldValues.TryGetValue(referenceField.Name, out object propertyValue) || propertyValue == null || (propertyValue is Guid guid && guid == Guid.Empty) || (propertyValue is string str && str == "")) { continue; } string referredTypeName = referenceField.ForeignKeyReferenceTypeName; var referredType = TypeManager.TryGetType(referredTypeName); if (referredType == null) { // TODO: implement reference check for dynamic types as well continue; } string targetKeyPropertyName = referredType.GetKeyPropertyNames().SingleOrDefault(); CheckForBrokenReference(dataType, referredType, targetKeyPropertyName, propertyValue); } } }
private void ValidateAndLoadConfiguration() { XElement typesElement = this.Configuration.SingleOrDefault(f => f.Name == "Types"); if (typesElement == null) { _validationResult.AddFatal(GetText("DataPackageFragmentInstaller.MissingElement")); } if (typesElement == null) { return; } foreach (XElement typeElement in typesElement.Elements("Type")) { var typeAttribute = typeElement.Attribute("type"); if (typeAttribute == null) { _validationResult.AddFatal(Texts.DataPackageFragmentInstaller_MissingAttribute("type"), typeElement); continue; } XAttribute allowOverwriteAttribute = typeElement.Attribute("allowOverwrite"); XAttribute onlyUpdateAttribute = typeElement.Attribute("onlyUpdate"); bool allowOverwrite = allowOverwriteAttribute != null && (bool)allowOverwriteAttribute; bool onlyUpdate = onlyUpdateAttribute != null && (bool)onlyUpdateAttribute; string interfaceTypeName = typeAttribute.Value; interfaceTypeName = TypeManager.FixLegasyTypeName(interfaceTypeName); foreach (XElement dataElement in typeElement.Elements("Data")) { XAttribute dataScopeIdentifierAttribute = dataElement.Attribute("dataScopeIdentifier"); if (dataScopeIdentifierAttribute == null) { _validationResult.AddFatal(Texts.DataPackageFragmentInstaller_MissingAttribute("dataScopeIdentifier"), typeElement); continue; } DataScopeIdentifier dataScopeIdentifier; try { dataScopeIdentifier = DataScopeIdentifier.Deserialize(dataScopeIdentifierAttribute.Value); } catch (Exception) { _validationResult.AddFatal(GetText("DataPackageFragmentInstaller.WrongDataScopeIdentifier").FormatWith(dataScopeIdentifierAttribute.Value), dataScopeIdentifierAttribute); continue; } CultureInfo locale = null; // null => do not use localization bool allLocales = false; bool currentLocale = false; XAttribute localeAttribute = dataElement.Attribute("locale"); if (localeAttribute != null) { if (localeAttribute.Value == "*") { allLocales = true; } else if (localeAttribute.Value == "?") { currentLocale = true; } else { try { locale = CultureInfo.CreateSpecificCulture(localeAttribute.Value); } catch (Exception) { _validationResult.AddFatal(GetText("DataPackageFragmentInstaller.WrongLocale").FormatWith(localeAttribute.Value), localeAttribute); continue; } } } XAttribute dataFilenameAttribute = dataElement.Attribute("dataFilename"); if (dataFilenameAttribute == null) { _validationResult.AddFatal(Texts.DataPackageFragmentInstaller_MissingAttribute("dataFilename"), typeElement); continue; } if (!this.InstallerContext.ZipFileSystem.ContainsFile(dataFilenameAttribute.Value)) { _validationResult.AddFatal(GetText("DataPackageFragmentInstaller.MissingFile").FormatWith(dataFilenameAttribute.Value), dataFilenameAttribute); continue; } XDocument doc; try { using (var stream = this.InstallerContext.ZipFileSystem.GetFileStream(dataFilenameAttribute.Value)) using (var reader = new C1StreamReader(stream)) { doc = XDocument.Load(reader); } } catch (Exception ex) { _validationResult.Add(new PackageFragmentValidationResult(PackageFragmentValidationResultType.Fatal, ex)); continue; } XAttribute isDynamicAddedAttribute = typeElement.Attribute("isDynamicAdded"); bool isDynamicAdded = isDynamicAddedAttribute != null && (bool)isDynamicAddedAttribute; var dataType = new DataType { InterfaceTypeName = interfaceTypeName, DataScopeIdentifier = dataScopeIdentifier, Locale = locale, AddToAllLocales = allLocales, AddToCurrentLocale = currentLocale, IsDynamicAdded = isDynamicAdded, AllowOverwrite = allowOverwrite, OnlyUpdate = onlyUpdate, Dataset = doc.Root.Elements("Add") }; _dataTypes.Add(dataType); } } }
private ConstantExpression TryReduce(Type targetType) { if (Type == targetType) { var thisType = GetType(); if (!thisType.IsGenericType && !TypeManager.IsEnumType(targetType)) { switch (Type.GetTypeCode(targetType)) { case TypeCode.Boolean: return(new ConstantExpression <bool>((bool)_value) { Span = Span }); case TypeCode.Char: return(new ConstantExpression <char>((char)_value) { Span = Span }); case TypeCode.SByte: return(new ConstantExpression <sbyte>((sbyte)_value) { Span = Span }); case TypeCode.Byte: return(new ConstantExpression <byte>((byte)_value) { Span = Span }); case TypeCode.Int16: return(new ConstantExpression <short>((short)_value) { Span = Span }); case TypeCode.UInt16: return(new ConstantExpression <ushort>((ushort)_value) { Span = Span }); case TypeCode.Int32: return(new ConstantExpression <int>((int)_value) { Span = Span }); case TypeCode.UInt32: return(new ConstantExpression <uint>((uint)_value) { Span = Span }); case TypeCode.Int64: return(new ConstantExpression <long>((long)_value) { Span = Span }); case TypeCode.UInt64: return(new ConstantExpression <ulong>((ulong)_value) { Span = Span }); case TypeCode.Single: return(new ConstantExpression <float>((float)_value) { Span = Span }); case TypeCode.Double: return(new ConstantExpression <double>((double)_value) { Span = Span }); case TypeCode.Decimal: return(new ConstantExpression <decimal>((decimal)_value) { Span = Span }); case TypeCode.String: return(new ConstantExpression <string>((string)_value) { Span = Span }); } } return(this); } if (TypeManager.IsEnumType(targetType)) { var c = TryReduce(Enum.GetUnderlyingType(targetType)); if (c == null) { return(null); } return(new EnumConstantExpression(c, targetType)); } return(ConvertExplicitly(false, targetType)); }
private TypeConverter HandleGetTypeConverter(IElement container, NamedObjectSave instance, TypedMemberBase typedMember) { Type memberType = typedMember.MemberType; string memberName = typedMember.MemberName; TypeConverter typeConverter = null; // If the NOS references a FRB type, we need to adjust the type appropriately bool wasTypeModified = false; Type oldType = memberType; bool handled = false; if (instance.SourceType == SourceType.FlatRedBallType) { Type type = TypeManager.GetTypeFromString(instance.SourceClassType); if (type == typeof(Sprite) && memberName == "CurrentChainName") { // special case handling for CurrentChainName typeConverter = new AvailableAnimationChainsStringConverter(container, instance); handled = true; } else if (typedMember.MemberType?.Name == "Sprite") { var nosTypeConverter = new AvailableNamedObjectsAndFiles(container); nosTypeConverter.NamedObjectTypeRestriction = "FlatRedBall.Sprite"; typeConverter = nosTypeConverter; handled = true; } } else if (instance.SourceType == SourceType.File) { if (instance.ClassType == "Sprite" && memberName == "CurrentChainName") { // special case handling for CurrentChainName typeConverter = new AvailableAnimationChainsStringConverter(container, instance); handled = true; } } if (!handled) { if (instance.DoesMemberNeedToBeSetByContainer(memberName)) { var availableNamedObjectsAndFiles = new AvailableNamedObjectsAndFiles(container); availableNamedObjectsAndFiles.NamedObjectTypeRestriction = typedMember.MemberType.FullName; typeConverter = availableNamedObjectsAndFiles; } else if (memberType.IsEnum) { typeConverter = new EnumConverter(memberType); } else if (memberType == typeof(Microsoft.Xna.Framework.Color)) { typeConverter = new AvailableColorTypeConverter(); memberType = typeof(string); } else if (IsTypeFile(typedMember)) { AvailableFileStringConverter availableFileStringConverter = new AvailableFileStringConverter(container); availableFileStringConverter.QualifiedRuntimeTypeName = memberType.FullName; if (!string.IsNullOrEmpty(typedMember.CustomTypeName)) { availableFileStringConverter.QualifiedRuntimeTypeName = typedMember.CustomTypeName; } availableFileStringConverter.RemovePathAndExtension = true; typeConverter = availableFileStringConverter; memberType = typeof(string); } else if (instance.SourceType == SourceType.Entity && !string.IsNullOrEmpty(instance.SourceClassType)) { EntitySave entity = ObjectFinder.Self.GetEntitySave(instance.SourceClassType); if (entity != null) { CustomVariable customVariable = entity.GetCustomVariable(memberName); if (customVariable != null) { typeConverter = customVariable.GetTypeConverter(entity); } } } } //else if (this.SourceType == SaveClasses.SourceType.FlatRedBallType && // typedMember != null && typedMember.MemberType != null) //{ //} if (wasTypeModified) { memberType = oldType; } return(typeConverter); }
/// <summary> /// This method finds the callers tree node own entity token by searching up/down using filters. /// In some cases this can be expensive. /// </summary> /// <param name="treeNode"></param> /// <param name="entityToken"></param> /// <param name="dynamicContext"></param> /// <returns></returns> private EntityToken FindOwnEntityToken(TreeNode treeNode, EntityToken entityToken, TreeNodeDynamicContext dynamicContext) { DataElementsTreeNode dataElementsTreeNode = treeNode as DataElementsTreeNode; if (dataElementsTreeNode != null) { if (dataElementsTreeNode.InterfaceType == this.OwnerNode.InterfaceType) // We found it :) { return(entityToken); } } TreeDataFieldGroupingElementEntityToken dataFieldGroupingElementEntityToken = entityToken as TreeDataFieldGroupingElementEntityToken; if (dataFieldGroupingElementEntityToken != null) // Search 'downwards' { ParameterExpression parameterExpression = Expression.Parameter(this.OwnerNode.InterfaceType, "data"); DataKeyPropertyCollection dataKeyPropertyCollection = new DataKeyPropertyCollection(); dataKeyPropertyCollection.AddKeyProperty("Id", dataFieldGroupingElementEntityToken.ChildGeneratingDataElementsReferenceValue); Type dataType = dataFieldGroupingElementEntityToken.ChildGeneratingDataElementsReferenceType; IData parentData = DataFacade.GetDataByUniqueKey(dataType, dataKeyPropertyCollection); TreeNodeDynamicContext dummyContext = new TreeNodeDynamicContext(TreeNodeDynamicContextDirection.Down); dummyContext.CustomData.Add("ParentData", parentData); IData resultData; if (this.OwnerNode.InterfaceType == TypeManager.GetType(dataFieldGroupingElementEntityToken.Type)) { Expression filterExpression = this.CreateDownwardsFilterExpression(parameterExpression, dummyContext); Expression whereExpression = ExpressionHelper.CreateWhereExpression(DataFacade.GetData(this.OwnerNode.InterfaceType).Expression, parameterExpression, filterExpression); resultData = (IData)DataFacade.GetData(this.OwnerNode.InterfaceType).Provider.CreateQuery(whereExpression).ToEnumerableOfObjects().First(); } else { resultData = parentData; } return(resultData.GetDataEntityToken()); } AncestorResult ancestorResult = treeNode.GetParentEntityToken(entityToken, this.ParentFilterType, dynamicContext); if ((this.OwnerNode.Id == ancestorResult.TreeNode.Id) || (this.OwnerNode.IsDescendant(ancestorResult.TreeNode))) // Search upwards { return(FindOwnEntityToken(ancestorResult.TreeNode, ancestorResult.EntityToken, dynamicContext)); } // Search 'downwards' by using the parent datas key value to get DataElementsTreeNode parentDataElementsTreeNode = (DataElementsTreeNode)ancestorResult.TreeNode; if (this.ParentFilterType == parentDataElementsTreeNode.InterfaceType) { DataEntityToken dataEntityToken = (DataEntityToken)ancestorResult.EntityToken; ParameterExpression parameterExpression = Expression.Parameter(this.OwnerNode.InterfaceType, "data"); TreeNodeDynamicContext dummyContext = new TreeNodeDynamicContext(TreeNodeDynamicContextDirection.Down); dummyContext.CustomData.Add("ParentData", dataEntityToken.Data); Expression filterExpression = this.CreateDownwardsFilterExpression(parameterExpression, dummyContext); Expression whereExpression = ExpressionHelper.CreateWhereExpression(DataFacade.GetData(this.OwnerNode.InterfaceType).Expression, parameterExpression, filterExpression); IData resultData = (IData)DataFacade.GetData(this.OwnerNode.InterfaceType).Provider.CreateQuery(whereExpression).ToEnumerableOfObjects().First(); return(resultData.GetDataEntityToken()); } throw new InvalidOperationException("Missing parent id filtering or try to simplify the parent id filterings (Unable to find own entity token)"); }
public string GenerateAdditionalLinkXmlFile(BuildReport report, UnityLinkerBuildPipelineData data) { // Let's build a dictionary of Assemblies as key and all their ComponentSystem as value (in a list) var typesByAssemblies = new Dictionary <Assembly, List <Type> >(); var csb = typeof(ComponentSystemBase); foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies()) { if (!TypeManager.IsAssemblyReferencingEntities(assembly)) { continue; } try { var allTypes = assembly.GetTypes(); var types = allTypes.Where(type => type.IsSubclassOf(csb)).ToList(); if (types.Count > 0) { typesByAssemblies.Add(assembly, types); } } catch (ReflectionTypeLoadException) { Debug.LogWarning($"Couldn't load types from assembly: {assembly.FullName}"); } } // Create the XML file var sb = new StringBuilder(); // Header sb.AppendLine("<linker>"); // For each assembly, add an <assembly> element that will contains <type> elements nested for all the type to include foreach (var assembly in typesByAssemblies.Keys) { // Add the assembly element sb.AppendLine($" <assembly fullname=\"{assembly.GetName().Name}\">"); // Add the type element var types = typesByAssemblies[assembly]; foreach (var type in types) { sb.AppendLine($" <type fullname=\"{FormatForXml(ToCecilName(type.FullName))}\" preserve=\"all\"/>"); } // Close assembly element sb.AppendLine(" </assembly>"); } // Close linker element sb.AppendLine("</linker>"); // Create a file with the content var filePathName = Path.Combine(data.inputDirectory, "DotsStripping.xml"); File.WriteAllText(filePathName, sb.ToString()); // Return the file path & name return(filePathName); }
protected override void OnUpdate() { var mgr = EntityManager; // cleanup native and internal components in case the thing component was removed (this also covers entity deletion) // remove Native and Loading if Thing is gone EntityCommandBuffer ecb = new EntityCommandBuffer(Allocator.Temp); using (var entities = m_CleanupQuery.ToEntityArray(Allocator.TempJob)) { foreach (var e in entities) { var n = TypeManager.IsZeroSized(m_TN_TypeIndex) ? default : EntityManager.GetComponentData <TN>(e); c.FreeNative(mgr, e, ref n); ecb.RemoveComponent <TN>(e); if (mgr.HasComponent <L>(e)) { ecb.RemoveComponent <L>(e); } } } ecb.Playback(mgr); ecb.Dispose(); // add the Native component for Things that want to load and do not have one yet ecb = new EntityCommandBuffer(Allocator.Temp); using (var entities = m_PrepareLoadQuery.ToEntityArray(Allocator.TempJob)) { foreach (var e in entities) { ecb.AddComponent(e, default(TN)); // +TN } } ecb.Playback(mgr); ecb.Dispose(); // start loading! ecb = new EntityCommandBuffer(Allocator.Temp); using (var entities = m_StartLoadQuery.ToEntityArray(Allocator.TempJob)) { foreach (var e in entities) { var t = TypeManager.IsZeroSized(m_T_TypeIndex) ? default : EntityManager.GetComponentData <T>(e); var n = TypeManager.IsZeroSized(m_TN_TypeIndex) ? default : EntityManager.GetComponentData <TN>(e); var s = TypeManager.IsZeroSized(m_TS_TypeIndex) ? default : EntityManager.GetComponentData <TS>(e); L l = default; c.StartLoad(mgr, e, ref t, ref n, ref s, ref l); ecb.AddComponent(e, l); ecb.SetComponent(e, t); ecb.SetComponent(e, n); ecb.SetComponent(e, s); } } ecb.Playback(mgr); ecb.Dispose(); // check on all things that are in flight, and finish when done ecb = new EntityCommandBuffer(Allocator.Temp); using (var entities = m_InProgressLoadQuery.ToEntityArray(Allocator.TempJob)) { foreach (var e in entities) { var t = TypeManager.IsZeroSized(m_T_TypeIndex) ? default : EntityManager.GetComponentData <T>(e); var n = TypeManager.IsZeroSized(m_TN_TypeIndex) ? default : EntityManager.GetComponentData <TN>(e); var s = TypeManager.IsZeroSized(m_TS_TypeIndex) ? default : EntityManager.GetComponentData <TS>(e); var l = TypeManager.IsZeroSized(m_L_TypeIndex) ? default : EntityManager.GetComponentData <L>(e); LoadResult lr = c.CheckLoading(wrapper, mgr, e, ref t, ref n, ref s, ref l); if (lr == LoadResult.stillWorking) { ecb.SetComponent(e, t); ecb.SetComponent(e, n); ecb.SetComponent(e, s); ecb.SetComponent(e, l); continue; } // remove load state ecb.RemoveComponent <L>(e); ecb.RemoveComponent <TS>(e); if (lr == LoadResult.failed) { c.FreeNative(mgr, e, ref n); // should we remove native here? ecb.SetComponent(e, t); ecb.SetComponent(e, n); continue; } // success! c.FinishLoading(mgr, e, ref t, ref n, ref l); ecb.SetComponent(e, t); ecb.SetComponent(e, n); } } ecb.Playback(mgr); ecb.Dispose(); }
public override string GetSignatureForError() { return(TypeManager.GetCSharpName(Type)); }
/// <exclude /> public override IEnumerable <XElement> Install() { Verify.IsNotNull(_dataTypes, "DataPackageFragmentInstaller has not been validated"); List <XElement> typeElements = new List <XElement>(); foreach (DataType dataType in _dataTypes) { Log.LogVerbose(LogTitle, $"Installing data for the type '{dataType.InterfaceType}'"); if (dataType.IsDynamicAdded || dataType.InterfaceType == null) { dataType.InterfaceType = this.InstallerContext.IsDataTypePending(dataType.InterfaceTypeName) ? this.InstallerContext.GetPendingDataType(dataType.InterfaceTypeName) : TypeManager.GetType(dataType.InterfaceTypeName); Verify.IsNotNull(dataType.InterfaceType, "Failed to get interface type by name: '{0}'", dataType.InterfaceTypeName); } XElement typeElement = new XElement("Type", new XAttribute("type", TypeManager.SerializeType(dataType.InterfaceType)), new XAttribute("dataScopeIdentifier", dataType.DataScopeIdentifier)); using (new DataScope(dataType.DataScopeIdentifier)) { if (dataType.AddToAllLocales) { foreach (CultureInfo locale in DataLocalizationFacade.ActiveLocalizationCultures) { using (new DataScope(locale)) { XElement element = AddData(dataType, locale); typeElement.Add(element); } } } else if (dataType.AddToCurrentLocale) { var currentLocale = DataLocalizationFacade.DefaultLocalizationCulture; if (UserValidationFacade.IsLoggedIn()) { currentLocale = UserSettings.ActiveLocaleCultureInfo; } using (new DataScope(currentLocale)) { XElement element = AddData(dataType, currentLocale); typeElement.Add(element); } } else if (dataType.Locale != null) { if (DataLocalizationFacade.ActiveLocalizationCultures.Contains(dataType.Locale)) { using (new DataScope(dataType.Locale)) { XElement element = AddData(dataType, dataType.Locale); typeElement.Add(element); } } } else { var locale = UserValidationFacade.IsLoggedIn() ? UserSettings.ActiveLocaleCultureInfo : DataLocalizationFacade.DefaultLocalizationCulture; using (new DataScope(locale)) { XElement element = AddData(dataType, null); typeElement.Add(element); } } } typeElements.Add(typeElement); } yield return(new XElement("Types", typeElements)); }
private static DynamicBufferUnsafe <T> ToDynamicBufferUnsafe <T>(this IntPtr ptr) where T : struct, IBufferElementData { var internalCapacity = TypeManager.GetTypeInfo <T>().BufferCapacity; return(new DynamicBufferUnsafe <T>(ptr, internalCapacity)); }
private static bool Get( ref EntityContainer container, int index, HashSet <Type> primitiveTypes, out StructProxy p) { var typeIndex = container.m_Manager.GetComponentTypeIndex(container.m_Entity, index); var propertyType = TypeManager.GetType(typeIndex); p = new StructProxy(); if (typeof(ISharedComponentData).IsAssignableFrom(propertyType)) { try { var o = container.m_Manager.GetSharedComponentData(container.m_Entity, typeIndex); // TODO: skip the StructObjectProxyProperty adapter and have the Accept() // TODO: handle Struct & Object proxies p = new StructProxy { bag = new StructPropertyBag <StructProxy>( new StructObjectProxyProperty(propertyType, o, primitiveTypes) ), data = default(byte *), type = propertyType }; return(true); } catch (Exception) { return(false); } } if (typeof(IBufferElementData).IsAssignableFrom(propertyType)) { IPropertyBag bag = TypeInformation.GetOrCreate(propertyType, primitiveTypes); p = new StructProxy { bag = new StructPropertyBag <StructProxy>( new BufferListProxyProperty( bag, propertyType, container.m_Manager.GetBufferLength(container.m_Entity, typeIndex) ) ), data = (byte *)container.m_Manager.GetBufferRawRW(container.m_Entity, typeIndex), type = propertyType }; return(true); } { IPropertyBag bag = TypeInformation.GetOrCreate(propertyType, primitiveTypes); // We skip the property bag & proxy creation for zero sized types (e.g. MonoBehaviors, etc). // They wont get displayed at all in the inspector since we dont know byte *data = null; if (!TypeManager.GetTypeInfo(typeIndex).IsZeroSized) { data = (byte *)container.m_Manager.GetComponentDataRawRW(container.m_Entity, typeIndex); } p = new StructProxy { bag = bag, data = data, type = propertyType }; return(true); } }
void EmitFieldSize(int buffer_size) { int type_size = BuiltinTypeSpec.GetSize(MemberType); if (buffer_size > int.MaxValue / type_size) { Report.Error(1664, Location, "Fixed size buffer `{0}' of length `{1}' and type `{2}' exceeded 2^31 limit", GetSignatureForError(), buffer_size.ToString(), TypeManager.CSharpName(MemberType)); return; } AttributeEncoder encoder; var ctor = Module.PredefinedMembers.StructLayoutAttributeCtor.Resolve(Location); if (ctor == null) { return; } var field_size = Module.PredefinedMembers.StructLayoutSize.Resolve(Location); var field_charset = Module.PredefinedMembers.StructLayoutCharSet.Resolve(Location); if (field_size == null || field_charset == null) { return; } var char_set = CharSet ?? Module.DefaultCharSet ?? 0; encoder = new AttributeEncoder(); encoder.Encode((short)LayoutKind.Sequential); encoder.EncodeNamedArguments( new [] { field_size, field_charset }, new Constant [] { new IntConstant(Compiler.BuiltinTypes, buffer_size * type_size, Location), new IntConstant(Compiler.BuiltinTypes, (int)char_set, Location) } ); fixed_buffer_type.SetCustomAttribute((ConstructorInfo)ctor.GetMetaInfo(), encoder.ToArray()); // // Don't emit FixedBufferAttribute attribute for private types // if ((ModFlags & Modifiers.PRIVATE) != 0) { return; } ctor = Module.PredefinedMembers.FixedBufferAttributeCtor.Resolve(Location); if (ctor == null) { return; } encoder = new AttributeEncoder(); encoder.EncodeTypeName(MemberType); encoder.Encode(buffer_size); encoder.EncodeEmptyNamedArguments(); FieldBuilder.SetCustomAttribute((ConstructorInfo)ctor.GetMetaInfo(), encoder.ToArray()); }
public static int SyncIndex() { _index = TypeManager <IEvent> .IndexOf(typeof(T)); return(_index); }
public void SIZ_TagComponentZeroSize() { var entity0 = m_Manager.CreateEntity(typeof(EcsTestTag)); unsafe { // a system ran, the version should match the global var chunk0 = m_Manager.Entities->GetComponentChunk(entity0); var archetype0 = chunk0->Archetype; var indexInTypeArray = ChunkDataUtility.GetIndexInTypeArray(chunk0->Archetype, TypeManager.GetTypeIndex <EcsTestTag>()); Assert.AreEqual(0, archetype0->SizeOfs[indexInTypeArray]); } }
/// <summary> /// Executes the task. /// </summary> protected override void ExecuteTask() { String baseFolder = this.CreateBaseDir(); DocSet docSet = this.CreateDocSet(); IEnumerable <Framework> frameworks = this.CreateFrameworks(docSet); this.typeManager = new TypeManager(); this.typeManager.SetMappings(this.MappingFile.ToString()); Func <FrameworkEntity, bool> selector = delegate(FrameworkEntity e) { return(e.type == FrameworkEntityType.C || e.type == FrameworkEntityType.P); }; var names = frameworks.SelectMany(f => f.GetEntities().Where(selector).Select(e => e.name)); this.typeManager.SetClasses(names); // Prepare the settings this.settings = this.CreateSettings(); TextWriter writer = null; if (this.Report != null) { writer = new StreamWriter(this.Report.ToString()); } foreach (var f in frameworks) { if (writer != null) { writer.WriteLine("Framework " + f.name); } foreach (var e in f.GetEntities()) { if (writer != null) { writer.WriteLine("Entity " + e.name); } this.Log(Level.Verbose, String.Format("Processing '{0}'...", e.name)); String sourcePath = e.GetPath(baseFolder, DocumentType.Xhtml); String destinationPath = e.GetPath(baseFolder, DocumentType.Model); if (sourcePath == null || !File.Exists(sourcePath)) { continue; } if (sourcePath.IsYoungerThan(destinationPath)) { this.Log(Level.Info, String.Format("Converting '{0}'...", e.name)); Convert(f, e, sourcePath, destinationPath, writer); } else { this.Log(Level.Debug, String.Format("Skipping '{0}'...", e.name)); } } } if (this.Report != null) { writer.Close(); writer.Dispose(); } if (this.MappingReport != null) { using (writer = new StreamWriter(this.MappingReport.ToString())) { IDictionary <String, String> samples = this.typeManager.Samples; List <String> keys = new List <String>(samples.Keys); keys.Sort(); foreach (var key in keys) { writer.WriteLine("{0}={1}", key, samples[key]); } writer.Close(); } } }
public static unsafe void SerializeWorld(EntityManager entityManager, BinaryWriter writer, out int[] sharedComponentsToSerialize, NativeArray <EntityRemapUtility.EntityRemapInfo> entityRemapInfos) { writer.Write(CurrentFileFormatVersion); var entityComponentStore = entityManager.EntityComponentStore; NativeHashMap <EntityArchetype, int> archetypeToIndex; EntityArchetype[] archetypeArray; GetAllArchetypes(entityComponentStore, out archetypeToIndex, out archetypeArray); var typeHashes = new NativeHashMap <ulong, int>(1024, Allocator.Temp); foreach (var archetype in archetypeArray) { for (int iType = 0; iType < archetype.Archetype->TypesCount; ++iType) { var typeIndex = archetype.Archetype->Types[iType].TypeIndex; var typeInfo = TypeManager.GetTypeInfo(typeIndex); var hash = typeInfo.StableTypeHash; ValidateTypeForSerialization(typeInfo); typeHashes.TryAdd(hash, 0); } } var typeHashSet = typeHashes.GetKeyArray(Allocator.Temp); writer.Write(typeHashSet.Length); foreach (ulong hash in typeHashSet) { writer.Write(hash); } var typeHashToIndexMap = new NativeHashMap <ulong, int>(typeHashSet.Length, Allocator.Temp); for (int i = 0; i < typeHashes.Length; ++i) { typeHashToIndexMap.TryAdd(typeHashSet[i], i); } WriteArchetypes(writer, archetypeArray, typeHashToIndexMap); var sharedComponentMapping = GatherSharedComponents(archetypeArray, out var sharedComponentArraysTotalCount); var sharedComponentArrays = new NativeArray <int>(sharedComponentArraysTotalCount, Allocator.Temp); FillSharedComponentArrays(sharedComponentArrays, archetypeArray, sharedComponentMapping); writer.Write(sharedComponentArrays.Length); writer.WriteArray(sharedComponentArrays); sharedComponentArrays.Dispose(); //TODO: ensure chunks are defragged? var bufferPatches = new NativeList <BufferPatchRecord>(128, Allocator.Temp); var totalChunkCount = GenerateRemapInfo(entityManager, archetypeArray, entityRemapInfos); writer.Write(totalChunkCount); GatherAllUsedBlobAssets(archetypeArray, out var blobAssetRefs, out var blobAssets); var blobAssetOffsets = new NativeArray <int>(blobAssets.Length, Allocator.Temp); int totalBlobAssetSize = sizeof(BlobAssetBatch); for (int i = 0; i < blobAssets.Length; ++i) { totalBlobAssetSize += sizeof(BlobAssetHeader); blobAssetOffsets[i] = totalBlobAssetSize; totalBlobAssetSize += Align16(blobAssets[i].header->Length); } writer.Write(totalBlobAssetSize); var blobAssetBatch = BlobAssetBatch.CreateForSerialize(blobAssets.Length, totalBlobAssetSize); writer.WriteBytes(&blobAssetBatch, sizeof(BlobAssetBatch)); var zeroBytes = int4.zero; for (int i = 0; i < blobAssets.Length; ++i) { var blobAssetLength = blobAssets[i].header->Length; var header = BlobAssetHeader.CreateForSerialize(Align16(blobAssetLength)); writer.WriteBytes(&header, sizeof(BlobAssetHeader)); writer.WriteBytes(blobAssets[i].header + 1, blobAssetLength); writer.WriteBytes(&zeroBytes, header.Length - blobAssetLength); } var tempChunk = (Chunk *)UnsafeUtility.Malloc(Chunk.kChunkSize, 16, Allocator.Temp); for (int archetypeIndex = 0; archetypeIndex < archetypeArray.Length; ++archetypeIndex) { var archetype = archetypeArray[archetypeIndex].Archetype; for (var ci = 0; ci < archetype->Chunks.Count; ++ci) { var chunk = archetype->Chunks.p[ci]; bufferPatches.Clear(); UnsafeUtility.MemCpy(tempChunk, chunk, Chunk.kChunkSize); tempChunk->metaChunkEntity = EntityRemapUtility.RemapEntity(ref entityRemapInfos, tempChunk->metaChunkEntity); // Prevent patching from touching buffers allocated memory BufferHeader.PatchAfterCloningChunk(tempChunk); byte *tempChunkBuffer = tempChunk->Buffer; EntityRemapUtility.PatchEntities(archetype->ScalarEntityPatches, archetype->ScalarEntityPatchCount, archetype->BufferEntityPatches, archetype->BufferEntityPatchCount, tempChunkBuffer, tempChunk->Count, ref entityRemapInfos); if (archetype->ContainsBlobAssetRefs) { PatchBlobAssetsInChunkBeforeSave(tempChunk, chunk, blobAssetOffsets, blobAssetRefs); } FillPatchRecordsForChunk(chunk, bufferPatches); ClearChunkHeaderComponents(tempChunk); ChunkDataUtility.MemsetUnusedChunkData(tempChunk, 0); tempChunk->Archetype = (Archetype *)archetypeIndex; if (archetype->NumManagedArrays != 0) { throw new ArgumentException("Serialization of GameObject components is not supported for pure entity scenes"); } writer.WriteBytes(tempChunk, Chunk.kChunkSize); writer.Write(bufferPatches.Length); if (bufferPatches.Length > 0) { writer.WriteList(bufferPatches); // Write heap backed data for each required patch. // TODO: PERF: Investigate static-only deserialization could manage one block and mark in pointers somehow that they are not indiviual for (int i = 0; i < bufferPatches.Length; ++i) { var patch = bufferPatches[i]; var header = (BufferHeader *)OffsetFromPointer(tempChunk->Buffer, patch.ChunkOffset); writer.WriteBytes(header->Pointer, patch.AllocSizeBytes); BufferHeader.Destroy(header); } } } } blobAssetRefs.Dispose(); blobAssets.Dispose(); bufferPatches.Dispose(); UnsafeUtility.Free(tempChunk, Allocator.Temp); sharedComponentsToSerialize = new int[sharedComponentMapping.Length - 1]; using (var keyArray = sharedComponentMapping.GetKeyArray(Allocator.Temp)) foreach (var key in keyArray) { if (key == 0) { continue; } if (sharedComponentMapping.TryGetValue(key, out var val)) { sharedComponentsToSerialize[val - 1] = key; } } archetypeToIndex.Dispose(); typeHashes.Dispose(); typeHashSet.Dispose(); typeHashToIndexMap.Dispose(); }
public BindAsAttribute (Type type) { Type = type; #if BGENERATOR var nullable = type.IsArray ? TypeManager.GetUnderlyingNullableType (type.GetElementType ()) : TypeManager.GetUnderlyingNullableType (type); IsNullable = nullable != null; IsValueType = IsNullable ? nullable.IsValueType : type.IsValueType; #endif }
public static FilterNode CreateFilterNode(XElement filterElement, Tree tree) { if (filterElement.Name == TreeMarkupConstants.Namespace + "ParentIdFilter") { XAttribute parentTypeAttribute = filterElement.Attribute("ParentType"); XAttribute referenceFieldNameAttribute = filterElement.Attribute("ReferenceFieldName"); if (parentTypeAttribute == null) { tree.AddValidationError(filterElement.GetXPath(), "TreeValidationError.Common.MissingAttribute", "ParentType"); return(null); } if (referenceFieldNameAttribute == null) { tree.AddValidationError(filterElement.GetXPath(), "TreeValidationError.Common.MissingAttribute", "ReferenceFieldName"); return(null); } Type parentInterfaceType = TypeManager.TryGetType(parentTypeAttribute.Value); if (parentInterfaceType == null) { tree.AddValidationError(filterElement.GetXPath(), "TreeValidationError.Common.UnknownInterfaceType", parentTypeAttribute.Value); return(null); } return(new ParentIdFilterNode { XPath = filterElement.GetXPath(), Id = tree.BuildProcessContext.FilterIdCounter++, ParentFilterType = parentInterfaceType, ReferenceFieldName = referenceFieldNameAttribute.Value }); } if (filterElement.Name == TreeMarkupConstants.Namespace + "FieldFilter") { XAttribute fieldNameAttribute = filterElement.Attribute("FieldName"); XAttribute fieldValueAttribute = filterElement.Attribute("FieldValue"); XAttribute operatorValueAttribute = filterElement.Attribute("Operator"); if (fieldNameAttribute == null) { tree.AddValidationError(filterElement.GetXPath(), "TreeValidationError.Common.MissingAttribute", "FieldName"); return(null); } if (fieldValueAttribute == null) { tree.AddValidationError(filterElement.GetXPath(), "TreeValidationError.Common.MissingAttribute", "FieldValue"); return(null); } FieldFilterNodeOperator filterOperator; string operatorValue = operatorValueAttribute.GetValueOrDefault("equal"); switch (operatorValue) { case "equal": filterOperator = FieldFilterNodeOperator.Equal; break; case "inequal": filterOperator = FieldFilterNodeOperator.Inequal; break; case "lesser": filterOperator = FieldFilterNodeOperator.Lesser; break; case "greater": filterOperator = FieldFilterNodeOperator.Greater; break; case "lesserequal": filterOperator = FieldFilterNodeOperator.LesserEqual; break; case "greaterequal": filterOperator = FieldFilterNodeOperator.GreaterEqual; break; default: tree.AddValidationError(filterElement.GetXPath(), "TreeValidationError.FieldFilter.UnknownOperatorName", operatorValue); return(null); } return(new FieldFilterNode { XPath = filterElement.GetXPath(), Id = tree.BuildProcessContext.FilterIdCounter++, FieldName = fieldNameAttribute.Value, FieldValue = fieldValueAttribute.Value, Operator = filterOperator }); } if (filterElement.Name == TreeMarkupConstants.Namespace + "FunctionFilter") { XElement functionMarkupElement = filterElement.Element((XNamespace)FunctionTreeConfigurationNames.NamespaceName + FunctionTreeConfigurationNames.FunctionTagName); if (functionMarkupElement == null) { tree.AddValidationError(filterElement.GetXPath(), "TreeValidationError.FunctionFilter.MissingFunctionMarkup"); return(null); } return(new FunctionFilterNode() { XPath = filterElement.GetXPath(), Id = tree.BuildProcessContext.FilterIdCounter++, FunctionMarkup = functionMarkupElement }); } throw new NotImplementedException("ValidationError"); }
public void ReactToNamedObjectChangedValue(string changedMember, string parent, object oldValue) { string combinedMember; if (string.IsNullOrEmpty(parent)) { combinedMember = changedMember; } else { combinedMember = parent + "." + changedMember; } NamedObjectSave namedObjectSave = EditorLogic.CurrentNamedObject; IElement element = EditorLogic.CurrentElement; if (PropertiesToMethods.ContainsKey(changedMember)) { PropertiesToMethods[changedMember](namedObjectSave, oldValue); } #region SourceType changed else if (changedMember == "SourceType") { bool didErrorOccur = false; if (didErrorOccur) { namedObjectSave.SourceType = (SourceType)oldValue; } else { if (namedObjectSave.SourceType == SourceType.Entity) { namedObjectSave.AddToManagers = true; } else if (namedObjectSave.SourceType == SourceType.File && namedObjectSave.GetContainerType() == ContainerType.Screen) { namedObjectSave.AddToManagers = false; } } } #endregion #region SourceClassType changed else if (changedMember == "SourceClassType") { ReactToChangedSourceClassType(namedObjectSave, oldValue); } #endregion #region SourceFile changed else if (changedMember == "SourceFile") { if (namedObjectSave.SourceFile != (string)oldValue) { // See if the current SourceName is valid or not List <string> availableSourceNames = AvailableNameablesStringConverter.GetAvailableNamedObjectSourceNames(namedObjectSave); bool isSourceNameValid = availableSourceNames.Contains(namedObjectSave.SourceName); if (!isSourceNameValid) { namedObjectSave.SourceName = "<NONE>"; } } } #endregion #region SourceName else if (changedMember == "SourceName") { // This needs to happen before we update custom properties ReactToChangedNosSourceName(namedObjectSave, oldValue as string); namedObjectSave.UpdateCustomProperties(); } #endregion #region InstanceName changed else if (changedMember == "InstanceName") { ReactToNamedObjectChangedInstanceName(namedObjectSave, oldValue); } #endregion #region SetByDerived Changed else if (changedMember == "SetByDerived") { if (namedObjectSave.SourceType == SourceType.Entity && !string.IsNullOrEmpty(namedObjectSave.SourceClassType)) { if (ProjectManager.VerifyReferenceGraph(ObjectFinder.Self.GetEntitySave(namedObjectSave.SourceClassType)) == ProjectManager.CheckResult.Failed) { namedObjectSave.SetByDerived = !namedObjectSave.SetByDerived; } } if (namedObjectSave.SetByDerived && namedObjectSave.ExposedInDerived) { // The user has just set SetByDerived to true, but ExposedInDerived means that // the derived expects that the base instantiates. We need to tell the user that // both values can't be true at the same time, and that ExposedInDerived will be set // to false. MessageBox.Show("You have set SetByDerived to true, but ExposedInDerived is also true. Both cannot be true at the same time " + "so Glue will set ExposedInDerived to false."); namedObjectSave.ExposedInDerived = false; } if (namedObjectSave.SourceType == SourceType.FlatRedBallType && namedObjectSave.IsList && namedObjectSave.SetByDerived == true && namedObjectSave.ContainedObjects.Count != 0) { MessageBox.Show("This list is not empty, so it can't be set to \"Set By Derived\". You must first empty the list", "Invalid Setting"); namedObjectSave.SetByDerived = false; } else { ProjectManager.UpdateAllDerivedElementFromBaseValues(false, true); } } #endregion #region ExposedInDerived Changed else if (changedMember == "ExposedInDerived") { if (namedObjectSave.SetByDerived && namedObjectSave.ExposedInDerived) { // See comment in ExposedByDerived block on why this occurs MessageBox.Show("You have set ExposedInDerived to true, but SetByDerived is also true. Both cannot be true at the same time " + "so Glue will set SetByDerived to false."); namedObjectSave.SetByDerived = false; } SetExposedByDerivedRecursively(namedObjectSave, oldValue); ProjectManager.UpdateAllDerivedElementFromBaseValues(false, true); } #endregion #region SourceClassGenericType else if (changedMember == "SourceClassGenericType") { ReactToSourceClassGenericType(namedObjectSave, oldValue); } #endregion #region IsDisabled else if (changedMember == "IsDisabled") { GlueState.Self.Find.ElementTreeNode(EditorLogic.CurrentElement).UpdateReferencedTreeNodes(); } #endregion #region SetByContainer Changed else if (changedMember == "SetByContainer") { if (namedObjectSave.SourceType == SourceType.Entity && !string.IsNullOrEmpty(namedObjectSave.SourceClassType)) { if (ProjectManager.VerifyReferenceGraph(ObjectFinder.Self.GetEntitySave(namedObjectSave.SourceClassType)) == ProjectManager.CheckResult.Failed) { namedObjectSave.SetByContainer = !namedObjectSave.SetByContainer; } } List <IElement> derivedElements = ObjectFinder.Self.GetAllElementsThatInheritFrom( EditorLogic.CurrentElement.Name); foreach (IElement derived in derivedElements) { foreach (NamedObjectSave nos in derived.NamedObjects) { if (nos.InstanceName == namedObjectSave.InstanceName) { nos.SetByContainer = namedObjectSave.SetByContainer; } } } if (EditorLogic.CurrentEntitySave != null) { List <NamedObjectSave> entityNamedObjects = ObjectFinder.Self.GetAllNamedObjectsThatUseEntity(EditorLogic.CurrentEntitySave.Name); foreach (NamedObjectSave nos in entityNamedObjects) { nos.UpdateCustomProperties(); } } } #endregion #region AddToManagers Changed else if (changedMember == "AddToManagers") { if (namedObjectSave.AddToManagers && namedObjectSave.GetContainerType() == ContainerType.Screen && namedObjectSave.SourceType == SourceType.File) { ScreenSave screenSave = namedObjectSave.GetContainer() as ScreenSave; ReferencedFileSave rfs = screenSave.GetReferencedFileSave(namedObjectSave.SourceFile); if (rfs != null && !rfs.IsSharedStatic) { System.Windows.Forms.MessageBox.Show("This object comes from a file. Files which are part of Screens " + "are automatically added to the engine managers. " + "Adding this object would result in double-membership in the engine which may cause unexpected results. " + "\n\nGlue will now set this value back to false."); namedObjectSave.AddToManagers = false; } } } #endregion #region LayerOn else if (changedMember == "LayerOn") { if (namedObjectSave.IsList) { DialogResult result = DialogResult.No; if (string.IsNullOrEmpty(namedObjectSave.LayerOn)) { result = MessageBox.Show("Do you want to remove every object in the List " + namedObjectSave.InstanceName + " from its Layer?", "Remove all from Layer?", MessageBoxButtons.YesNo); } else { result = MessageBox.Show("Do you want to add every object contained in the List " + namedObjectSave.InstanceName + " to the Layer " + namedObjectSave.LayerOn + "?", "Add all to Layer?", MessageBoxButtons.YesNo); } if (result == DialogResult.Yes) { namedObjectSave.SetLayerRecursively(namedObjectSave.LayerOn); } } } #endregion #region IsContainer else if (changedMember == "IsContainer") { HandleChangedIsContainer(namedObjectSave, element); } #endregion #region AttachToCamera else if (changedMember == "AttachToCamera") { if (namedObjectSave.IsList) { DialogResult result = DialogResult.No; if (namedObjectSave.AttachToCamera) { result = MessageBox.Show("Do you want to attach every object contained in the list " + namedObjectSave.InstanceName + " to the Camera?", "Attach all to Camera?", MessageBoxButtons.YesNo); } else { result = MessageBox.Show("Do you want to detach every object contained in the list " + namedObjectSave.InstanceName + " from the Camera?", "Detach all from the Camera?", MessageBoxButtons.YesNo); } if (result == DialogResult.Yes) { namedObjectSave.SetAttachToCameraRecursively(namedObjectSave.AttachToCamera); } } } #endregion #region DestinationRectangle.Y (for Layers) else if (parent == "DestinationRectangle" && changedMember == "Y") { // If the Y is odd, we should warn the user that it should be even // or else text will draw incorrectly if (namedObjectSave.DestinationRectangle.HasValue && namedObjectSave.DestinationRectangle.Value.Y % 2 == 1) { MessageBox.Show("Setting an odd value to the DestinationRectangle's Y may cause text to render improperly. An " + "even value is recommended"); } } #endregion #region RemoveFromManagersWhenInvisible else if (changedMember == "RemoveFromManagersWhenInvisible") { // is this an Entity instance? if (namedObjectSave.SourceType == SourceType.Entity && namedObjectSave.RemoveFromManagersWhenInvisible) { var entitySave = ObjectFinder.Self.GetEntitySave(namedObjectSave.SourceClassType); if (entitySave != null) { // Is this CreatedByOtherEntities? if (!entitySave.CreatedByOtherEntities) { MessageBox.Show("The Entity " + entitySave + " should have its CreatedByOtherEntities set to true to enable " + "visibility-based removal to work properly"); } } } } #endregion else if (namedObjectSave?.GetCustomVariable(changedMember) != null) { // See if this variable is tunneled into in this element. // If so, set that value too. CustomVariableInNamedObject cvino = namedObjectSave.GetCustomVariable(changedMember); object value = cvino.Value; foreach (CustomVariable customVariable in EditorLogic.CurrentElement.CustomVariables) { if (customVariable.SourceObject == namedObjectSave.InstanceName && customVariable.SourceObjectProperty == changedMember) { // The custom variable may have a different type: if (!string.IsNullOrEmpty(customVariable.OverridingPropertyType)) { // it does, so convert Type overridingType = TypeManager.GetTypeFromString(customVariable.OverridingPropertyType); customVariable.DefaultValue = System.Convert.ChangeType(value, overridingType); } else { customVariable.DefaultValue = value; } break; } } } // If we changed BitmapFont and if the NOS is marked as PixelPerfect // and if it's a Text object, then we should set the Scale, Spacing, and // NewLineDistance according to the set BitmapFont // We don't do an else because there could be a CustomVariable by the name // of BitmapFont as well, and we dont' want to eliminate that. if (changedMember == "Font" && namedObjectSave.SourceType == SourceType.FlatRedBallType && namedObjectSave.SourceClassType == "Text" && namedObjectSave.IsPixelPerfect) { ReactToFontSet(namedObjectSave, oldValue); } PropertyGridHelper.UpdateNamedObjectDisplay(); PluginManager.ReactToNamedObjectChangedValue(changedMember, oldValue); }
private IList <PackageFragmentValidationResult> LoadPackageFragmentInstallers(XElement packageFragmentInstallersElement) { var result = new List <PackageFragmentValidationResult>(); XName packageInstallerXName = XmlUtils.GetXName(PackageSystemSettings.XmlNamespace, PackageSystemSettings.PackageFragmentInstallersAddElementName); foreach (XElement element in packageFragmentInstallersElement.Elements(packageInstallerXName)) { XAttribute installerTypeAttribute = element.Attribute(PackageSystemSettings.InstallerTypeAttributeName); if (installerTypeAttribute == null) { result.AddFatal($"Missing attribute '{PackageSystemSettings.InstallerTypeAttributeName}'", element); continue; } Type installerType = TypeManager.TryGetType(installerTypeAttribute.Value); if (installerType == null) { result.AddFatal($"Could not find install fragment type '{installerTypeAttribute.Value}'", installerTypeAttribute); continue; } IPackageFragmentInstaller packageFragmentInstaller; try { packageFragmentInstaller = Activator.CreateInstance(installerType) as IPackageFragmentInstaller; } catch (Exception ex) { result.AddFatal(ex); continue; } if (packageFragmentInstaller == null) { result.AddFatal($"The type '{installerTypeAttribute.Value}' does not implement {typeof (IPackageFragmentInstaller)}", installerTypeAttribute); continue; } Type uninstallerType = null; if (this.CanBeUninstalled) { XAttribute uninstallerTypeAttribute = element.Attribute(PackageSystemSettings.UninstallerTypeAttributeName); if (uninstallerTypeAttribute == null) { result.AddFatal($"Missing attribute '{PackageSystemSettings.UninstallerTypeAttributeName}'", element); continue; } uninstallerType = TypeManager.TryGetType(uninstallerTypeAttribute.Value); if (uninstallerType == null) { result.AddFatal($"Could not find uninstall fragment type '{uninstallerTypeAttribute.Value}'", uninstallerTypeAttribute); continue; } IPackageFragmentUninstaller packageFragmentUninstaller; try { packageFragmentUninstaller = Activator.CreateInstance(uninstallerType) as IPackageFragmentUninstaller; } catch (Exception ex) { result.AddFatal(ex); continue; } if (packageFragmentUninstaller == null) { result.AddFatal($"The type '{uninstallerTypeAttribute.Value}' does not implement {typeof (IPackageFragmentUninstaller)}", uninstallerTypeAttribute); continue; } } try { packageFragmentInstaller.Initialize(_packageInstallerContex, element.Descendants(), element); } catch (Exception ex) { result.AddFatal(ex); continue; } _packageFramentInstallers.Add(packageFragmentInstaller, uninstallerType); } return(result); }
public PageTeaserInstanceEntityToken(IPage page, IPageTeaser teaser) { _source = page.Id.ToString(); _type = TypeManager.SerializeType(teaser.DataSourceId.InterfaceType); _id = teaser.Id.ToString(); }
/// <summary> /// Initializes a new instance of the <see cref = "XhtmlBaseParser" /> class. /// </summary> /// <param name = "settings">The settings.</param> /// <param name = "typeManager">The type manager.</param> protected XhtmlBaseParser(NameValueCollection settings, TypeManager typeManager, TextWriter logger) : base(settings, typeManager, logger) { }
public void RegisterUnityEngineComponentType_WithWrongType_ThrowsArgumentException(Type type) { Assert.Throws <ArgumentException>(() => TypeManager.RegisterUnityEngineComponentType(type)); }
private void initializeCodeActivity_Copy_ExecuteCode(object sender, EventArgs e) { var castedEntityToken = (DataEntityToken)this.EntityToken; IPage newPage; using (var transactionScope = TransactionsFacade.CreateNewScope()) { CultureInfo sourceCultureInfo = UserSettings.ForeignLocaleCultureInfo; IPage sourcePage; List <IPagePlaceholderContent> sourcePagePlaceholders; List <IData> sourceMetaDataSet; using (new DataScope(sourceCultureInfo)) { var pageFromEntityToken = (IPage)castedEntityToken.Data; Guid sourcePageId = pageFromEntityToken.Id; Guid sourcePageVersionId = pageFromEntityToken.VersionId; using (new DataScope(DataScopeIdentifier.Administrated)) { sourcePage = DataFacade.GetData <IPage>(f => f.Id == sourcePageId && f.VersionId == sourcePageVersionId).Single(); sourcePage = sourcePage.GetTranslationSource(); using (new DataScope(sourcePage.DataSourceId.DataScopeIdentifier)) { sourcePagePlaceholders = DataFacade .GetData <IPagePlaceholderContent>(f => f.PageId == sourcePageId && f.VersionId == sourcePageVersionId) .ToList(); sourceMetaDataSet = sourcePage.GetMetaData().ToList(); } } } CultureInfo targetCultureInfo = UserSettings.ActiveLocaleCultureInfo; using (new DataScope(targetCultureInfo)) { newPage = DataFacade.BuildNew <IPage>(); sourcePage.ProjectedCopyTo(newPage); newPage.SourceCultureName = targetCultureInfo.Name; newPage.PublicationStatus = GenericPublishProcessController.Draft; newPage = DataFacade.AddNew <IPage>(newPage); foreach (IPagePlaceholderContent sourcePagePlaceholderContent in sourcePagePlaceholders) { IPagePlaceholderContent newPagePlaceholderContent = DataFacade.BuildNew <IPagePlaceholderContent>(); sourcePagePlaceholderContent.ProjectedCopyTo(newPagePlaceholderContent); newPagePlaceholderContent.SourceCultureName = targetCultureInfo.Name; newPagePlaceholderContent.PublicationStatus = GenericPublishProcessController.Draft; DataFacade.AddNew <IPagePlaceholderContent>(newPagePlaceholderContent); } foreach (IData metaData in sourceMetaDataSet) { ILocalizedControlled localizedData = metaData as ILocalizedControlled; if (localizedData == null) { continue; } IEnumerable <ReferenceFailingPropertyInfo> referenceFailingPropertyInfos = DataLocalizationFacade.GetReferencingLocalizeFailingProperties(localizedData).Evaluate(); if (!referenceFailingPropertyInfos.Any()) { IData newMetaData = DataFacade.BuildNew(metaData.DataSourceId.InterfaceType); metaData.ProjectedCopyTo(newMetaData); ILocalizedControlled localizedControlled = newMetaData as ILocalizedControlled; localizedControlled.SourceCultureName = targetCultureInfo.Name; IPublishControlled publishControlled = newMetaData as IPublishControlled; publishControlled.PublicationStatus = GenericPublishProcessController.Draft; DataFacade.AddNew(newMetaData); } else { foreach (ReferenceFailingPropertyInfo referenceFailingPropertyInfo in referenceFailingPropertyInfos) { Log.LogVerbose("LocalizePageWorkflow", "Meta data of type '{0}' is not localized because the field '{1}' is referring some not yet localzed data" .FormatWith(metaData.DataSourceId.InterfaceType, referenceFailingPropertyInfo.DataFieldDescriptor.Name)); } } } } EntityTokenCacheFacade.ClearCache(sourcePage.GetDataEntityToken()); EntityTokenCacheFacade.ClearCache(newPage.GetDataEntityToken()); foreach (var folderType in PageFolderFacade.GetDefinedFolderTypes(newPage)) { EntityTokenCacheFacade.ClearCache(new AssociatedDataElementProviderHelperEntityToken( TypeManager.SerializeType(typeof(IPage)), PageElementProvider.DefaultConfigurationName, newPage.Id.ToString(), TypeManager.SerializeType(folderType))); } transactionScope.Complete(); } ParentTreeRefresher parentTreeRefresher = this.CreateParentTreeRefresher(); parentTreeRefresher.PostRefreshMesseges(newPage.GetDataEntityToken(), 2); this.ExecuteWorklow(newPage.GetDataEntityToken(), typeof(EditPageWorkflow)); }
public CompendiumFirstDepthMap() { InitializeComponent(); if (!IsInDesignMode) { _nodeService = new DatabaseMappingService(); _typeManager = new TypeManager(_nodeService); IoC.IoCContainer.GetInjectionInstance().RegisterComponent<TypeManager>(_typeManager); _typeManager.InitialiseNodeTypeManagerCompleted += new EventHandler(InitialiseNodeTypeManagerCompleted); _typeManager.InitialiseNodeTypeManager(); } }