static BasicMimeTypesX() { MTIDict_ByEnums = AllTypes.ToDictionary(v => v.MimeType, v => v); MTIDict_ByMimeNames = AllTypes.ToDictionary(v => v.MimeTypeString, v => v); MTIDict_ByExtensions = AllTypes.Where(v => v.Extension.NotNulle()).ToDictionary(v => v.Extension, v => v); for (int i = 0; i < AllTypes.Length; i++) { MTI mti = AllTypes[i]; if (mti.ExtraMimeStrings.NotNulle()) { foreach (string extMimeStr in mti.ExtraMimeStrings) { if (!MTIDict_ByMimeNames.ContainsKey(extMimeStr)) { MTIDict_ByMimeNames.Add(extMimeStr, mti); } } } if (mti.ExtraExtensions.NotNulle()) { foreach (string ext in mti.ExtraExtensions) { if (!MTIDict_ByExtensions.ContainsKey(ext)) { MTIDict_ByExtensions.Add(ext, mti); } } } } }
//static EndpointConfiguration DistributionConfig(string endpointName) //{ // #region DistributionEndpointName // var distributionEndpointName = $"{endpointName}.{Utils.GetUniqueDataDistributionId()}"; // var distributionConfig = new EndpointConfiguration(distributionEndpointName); // #endregion // #region DistributionEndpointTypes // var typesToExclude = AllTypes // .Where(t => t.Namespace != "DataDistribution") // .ToArray(); // var scanner = distributionConfig.AssemblyScanner(); // scanner.ExcludeTypes(typesToExclude); // #endregion // var transport = distributionConfig.UseTransport<MsmqTransport>(); // var routing = transport.Routing(); // routing.RegisterPublisher( // publisherEndpoint: "Samples.DataDistribution.Server-2", // eventType: typeof(OrderAccepted)); // ApplyDefaults(distributionConfig); // return distributionConfig; //} static EndpointConfiguration MainConfig(string endpointName) { #region MainConfig var mainConfig = new EndpointConfiguration(endpointName); var typesToExclude = AllTypes .Where(t => t.Namespace == "DataDistribution") .ToArray(); var scanner = mainConfig.AssemblyScanner(); scanner.ExcludeTypes(typesToExclude); var transport = mainConfig.UseTransport <MsmqTransport>(); var mainRouting = transport.Routing(); mainRouting.RouteToEndpoint( messageType: typeof(PlaceOrder), destination: "Samples.DataDistribution.Server-2"); //mainRouting.RegisterPublisher( // publisherEndpoint: "Samples.DataDistribution.Server-2", // eventType: typeof(OrderAccepted)); #endregion ApplyDefaults(mainConfig); return(mainConfig); }
static EndpointConfiguration DistributionConfig(string endpointName) { #region DistributionEndpointName var distributionEndpointName = $"{endpointName}.{Utils.GetUniqueDataDistributionId()}"; var distributionConfig = new EndpointConfiguration(distributionEndpointName); #endregion #region DistributionEndpointTypes var typesToExclude = AllTypes .Where(t => t.Namespace != "DataDistribution") .ToArray(); var assemblyScanner = distributionConfig.AssemblyScanner(); assemblyScanner.ExcludeTypes(typesToExclude); #endregion var transport = distributionConfig.UseTransport <MsmqTransport>(); var routing = transport.Routing(); routing.RegisterPublisher( publisherEndpoint: "Samples.DataDistribution.Server", eventType: typeof(OrderAccepted)); ApplyDefaults(distributionConfig); return(distributionConfig); }
public override string ToString() { string result = null; foreach (var rt in AllTypes.Where(rt => this[rt] > 0)) { result = result ?? ""; result += $"{rt}:{this[rt]} "; } return(result ?? "<none>"); }
private void RefreshInheritanceMap(IEnumerable <TypeDefinition> types) { var mapDelta = AllTypes.Where(x => x.BaseType != null).ToLookup(x => x.BaseType, comparer); foreach (var item in mapDelta) { var derivedTypes = InheritanceMap.GetValue(item.Key) ?? new HashSet <TypeDefinition>(comparer); derivedTypes.UnionWith(item); InheritanceMap[item.Key] = derivedTypes; } }
public void Aggregate() { if (!File.Exists(assemblyPath)) { throw new FileNotFoundException("Imported assembly does not exist.", assemblyPath); } assemblyDirectory = Path.GetDirectoryName(assemblyPath); AllTypes = LoadTypes(); PublicClasses = ApplyIncludeExcludeRules(AllTypes.Where(t => IsObjCClassCandidate(t))); PublicStructs = ApplyIncludeExcludeRules(AllTypes.Where(t => IsStructCandidate(t))); PublicProtocols = ApplyIncludeExcludeRules(AllTypes.Where(t => IsObjCProtocolCandidate(t))); PublicEnums = ApplyIncludeExcludeRules(AllTypes.Where(t => t.IsPublic && t.IsEnum)); }
private void RefreshInterfaceMap(IEnumerable <TypeDefinition> types) { var mapDelta = AllTypes.Where(x => x.Interfaces.Any()) .SelectMany(x => x.Interfaces.Select(y => new { i = y, t = x })) .ToLookup(x => x.i, x => x.t, comparer); foreach (var item in mapDelta) { var implementations = InterfaceMap.GetValue(item.Key) ?? new HashSet <TypeDefinition>(comparer); implementations.UnionWith(item); InterfaceMap[item.Key] = implementations; } }
/// <summary> /// Discovers the types. /// </summary> protected void DiscoverTypes() { FailedAssemblies.Clear(); var assemblies = GetComposablePartAssemblies().ToList(); foreach (var assembly in assemblies) { Logger.Info("Loading {0}", assembly.FullName); } AllTypes = assemblies.SelectMany(GetTypes).ToArray(); AllConcreteTypes = AllTypes.Where(t => t.IsClass && !t.IsAbstract && !t.IsInterface && !t.IsGenericType).ToArray(); }
static EndpointConfiguration FilterNamespace1(string endpointName) { var mainConfig = new EndpointConfiguration(endpointName); var typesToExclude = AllTypes.Where(t => t.Namespace == "DataDistribution").ToArray(); mainConfig.ExcludeTypes(typesToExclude); #region FilterNamespace1 var transport = mainConfig.UseTransport <MsmqTransport>(); var mainRouting = transport.Routing(); #endregion mainRouting.RouteToEndpoint(typeof(PlaceOrder), "Samples.DataDistribution.Server"); mainRouting.RegisterPublisher(typeof(OrderAccepted), "Samples.DataDistribution.Server"); ApplyDefaults(mainConfig); return(mainConfig); }
static EndpointConfiguration FilterNamespace2(string endpointName) { var distributionConfig = new EndpointConfiguration($"{endpointName}.{GetUniqueDataDistributionId()}"); #region FilterNamespace2 var typesToExclude = AllTypes .Where(t => t.Namespace != "DataDistribution") .ToArray(); distributionConfig.ExcludeTypes(typesToExclude); #endregion var transport = distributionConfig.UseTransport <MsmqTransport>(); var routing = transport.Routing(); routing.RegisterPublisher( publisherEndpoint: "Samples.DataDistribution.Server", eventType: typeof(OrderAccepted)); ApplyDefaults(distributionConfig); return(distributionConfig); }
protected virtual void WriteNestedTypes() { if (NestedTypes != null && NestedTypes.Any()) { if (!Emitter.IsNewLine) { WriteNewLine(); } var typeDef = Emitter.GetTypeDefinition(); string name = Emitter.Validator.GetCustomTypeName(typeDef, Emitter, true); if (name.IsEmpty()) { name = H5Types.ToJsName(TypeInfo.Type, Emitter, true, true, nomodule: true); } Write("module "); Write(name); WriteSpace(); BeginBlock(); var last = NestedTypes.LastOrDefault(); foreach (var nestedType in NestedTypes) { Emitter.Translator.EmitNode = nestedType.TypeDeclaration; if (nestedType.IsObjectLiteral) { continue; } ITypeInfo typeInfo; if (Emitter.TypeInfoDefinitions.ContainsKey(nestedType.Key)) { typeInfo = Emitter.TypeInfoDefinitions[nestedType.Key]; nestedType.Module = typeInfo.Module; nestedType.FileName = typeInfo.FileName; nestedType.Dependencies = typeInfo.Dependencies; typeInfo = nestedType; } else { typeInfo = nestedType; } Emitter.TypeInfo = nestedType; var nestedTypes = AllTypes.Where(t => t.ParentType == nestedType); new ClassBlock(Emitter, Emitter.TypeInfo, nestedTypes, AllTypes, Namespace).Emit(); WriteNewLine(); if (nestedType != last) { WriteNewLine(); } } EndBlock(); } }
public string GetCode(MetadataTypes metadata, IRequest request, INativeTypesMetadata nativeTypes) { var typeNamespaces = new HashSet <string>(); var includeList = metadata.RemoveIgnoredTypes(Config); metadata.Types.Each(x => typeNamespaces.Add(x.Namespace)); metadata.Operations.Each(x => typeNamespaces.Add(x.Request.Namespace)); var defaultImports = !Config.DefaultImports.IsEmpty() ? Config.DefaultImports : DefaultImports; var globalNamespace = Config.GlobalNamespace; string defaultValue(string k) => request.QueryString[k].IsNullOrEmpty() ? "//" : ""; var sbInner = StringBuilderCache.Allocate(); var sb = new StringBuilderWrapper(sbInner); sb.AppendLine("/* Options:"); sb.AppendLine("Date: {0}".Fmt(DateTime.Now.ToString("s").Replace("T", " "))); sb.AppendLine("Version: {0}".Fmt(Env.VersionString)); sb.AppendLine("Tip: {0}".Fmt(HelpMessages.NativeTypesDtoOptionsTip.Fmt("//"))); sb.AppendLine("BaseUrl: {0}".Fmt(Config.BaseUrl)); if (Config.UsePath != null) { sb.AppendLine("UsePath: {0}".Fmt(Config.UsePath)); } sb.AppendLine(); sb.AppendLine("{0}GlobalNamespace: {1}".Fmt(defaultValue("GlobalNamespace"), Config.GlobalNamespace)); sb.AppendLine("{0}MakePropertiesOptional: {1}".Fmt(defaultValue("MakePropertiesOptional"), Config.MakePropertiesOptional)); sb.AppendLine("{0}AddServiceStackTypes: {1}".Fmt(defaultValue("AddServiceStackTypes"), Config.AddServiceStackTypes)); sb.AppendLine("{0}AddResponseStatus: {1}".Fmt(defaultValue("AddResponseStatus"), Config.AddResponseStatus)); sb.AppendLine("{0}AddImplicitVersion: {1}".Fmt(defaultValue("AddImplicitVersion"), Config.AddImplicitVersion)); sb.AppendLine("{0}AddDescriptionAsComments: {1}".Fmt(defaultValue("AddDescriptionAsComments"), Config.AddDescriptionAsComments)); sb.AppendLine("{0}IncludeTypes: {1}".Fmt(defaultValue("IncludeTypes"), Config.IncludeTypes.Safe().ToArray().Join(","))); sb.AppendLine("{0}ExcludeTypes: {1}".Fmt(defaultValue("ExcludeTypes"), Config.ExcludeTypes.Safe().ToArray().Join(","))); sb.AppendLine("{0}DefaultImports: {1}".Fmt(defaultValue("DefaultImports"), defaultImports.Join(","))); sb.AppendLine("*/"); sb.AppendLine(); string lastNS = null; var existingTypes = new HashSet <string>(); var requestTypes = metadata.Operations.Select(x => x.Request).ToHashSet(); var requestTypesMap = metadata.Operations.ToSafeDictionary(x => x.Request); var responseTypes = metadata.Operations .Where(x => x.Response != null) .Select(x => x.Response).ToHashSet(); var types = metadata.Types.CreateSortedTypeList(); AllTypes = metadata.GetAllTypesOrdered(); AllTypes.RemoveAll(x => x.IgnoreType(Config, includeList)); AllTypes = FilterTypes(AllTypes); //TypeScript doesn't support reusing same type name with different generic airity var conflictPartialNames = AllTypes.Map(x => x.Name).Distinct() .GroupBy(g => g.LeftPart('`')) .Where(g => g.Count() > 1) .Select(g => g.Key) .ToList(); this.conflictTypeNames = AllTypes .Where(x => conflictPartialNames.Any(name => x.Name.StartsWith(name))) .Map(x => x.Name); foreach (var import in defaultImports) { var pos = import.IndexOf(':'); sb.AppendLine(pos == -1 ? $"import {import};" : $"import {{ {import.Substring(0, pos)} }} from \"{import.Substring(pos + 1).StripQuotes()}\";"); } if (!string.IsNullOrEmpty(globalNamespace)) { var moduleDef = Config.ExportAsTypes ? "export " : "declare "; sb.AppendLine(); sb.AppendLine("{0}module {1}".Fmt(moduleDef, globalNamespace.SafeToken())); sb.AppendLine("{"); sb = sb.Indent(); } var insertCode = InsertCodeFilter?.Invoke(AllTypes, Config); if (insertCode != null) { sb.AppendLine(insertCode); } //ServiceStack core interfaces foreach (var type in AllTypes) { var fullTypeName = type.GetFullName(); if (requestTypes.Contains(type)) { if (!existingTypes.Contains(fullTypeName)) { MetadataType response = null; if (requestTypesMap.TryGetValue(type, out var operation)) { response = operation.Response; } lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { Routes = metadata.Operations.GetRoutes(type), ImplementsFn = () => { if (!Config.AddReturnMarker && operation?.ReturnsVoid != true && operation?.ReturnType == null) { return(null); } if (operation?.ReturnsVoid == true) { return(nameof(IReturnVoid)); } if (operation?.ReturnType != null) { return(Type("IReturn`1", new[] { Type(operation.ReturnType) })); } return(response != null ? Type("IReturn`1", new[] { Type(response.Name, response.GenericArgs) }) : null); }, IsRequest = true, }); existingTypes.Add(fullTypeName); } } else if (responseTypes.Contains(type)) { if (!existingTypes.Contains(fullTypeName) && !Config.IgnoreTypesInNamespaces.Contains(type.Namespace)) { lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { IsResponse = true, }); existingTypes.Add(fullTypeName); } } else if (types.Contains(type) && !existingTypes.Contains(fullTypeName)) { lastNS = AppendType(ref sb, type, lastNS, new CreateTypeOptions { IsType = true }); existingTypes.Add(fullTypeName); } } var addCode = AddCodeFilter?.Invoke(AllTypes, Config); if (addCode != null) { sb.AppendLine(addCode); } if (!string.IsNullOrEmpty(globalNamespace)) { sb = sb.UnIndent(); sb.AppendLine(); sb.AppendLine("}"); } sb.AppendLine(); //tslint return(StringBuilderCache.ReturnAndFree(sbInner)); }