private void CreateAccessor() { var nodeConfiguration = new NodeConfiguration(); var configuration = DomainConfigurationFactory.Create(); var descriptor = ProviderDescriptor.Get(configuration.ConnectionInfo.Provider); var driverFactory = (SqlDriverFactory)Activator.CreateInstance(descriptor.DriverFactory); var storageDriver = StorageDriver.Create(driverFactory, configuration); var nameBuilder = new NameBuilder(configuration, storageDriver.ProviderInfo); var handlerFactory = (HandlerFactory)Activator.CreateInstance(descriptor.HandlerFactory); var accessor = new UpgradeServiceAccessor { Configuration = configuration, StorageDriver = storageDriver, NameBuilder = nameBuilder, HandlerFactory = handlerFactory }; configuration.Lock(); var connection = storageDriver.CreateConnection(null); connection.Open(); accessor.MappingResolver = MappingResolver.Create(configuration, nodeConfiguration, storageDriver.GetDefaultSchema(connection)); if (storageDriver.ProviderInfo.Supports(ProviderFeatures.SingleConnection)) { accessor.RegisterTemporaryResource(connection); } else { accessor.RegisterResource(connection); } accessor.Connection = connection; accessor.Connection.Extensions.AddOne(new TypeDelegator(typeof(IProviderExecutor))); this.accessor = accessor; }
string GetSetting(string key) { string theKey = NameBuilder.GetSettingName(HostName, Environment, Machine.NotSpecified, key.ToLower()).ToLower(); if (!configuration.ContainsKey(theKey)) { throw new KeyNotFoundException($"The corresponding key is missing - {theKey}"); } string theValue = (string)configuration[theKey]; string parameterPattern = @"\${(.*?)}"; var regex = new Regex(parameterPattern, RegexOptions.IgnoreCase); Match match = regex.Match(theValue); if (match.Success) { string wrappedKey = match.Value; string internalKey = match.Groups[1].Value; string internalValue = GetSetting(internalKey); string evaluated = theValue.Replace(wrappedKey, internalValue); return(evaluated); } return(theValue); }
// Use this for initialization void Start() { for (int i = 0; i < 20; i++) { Debug.Log(NameBuilder.GetName("PlanetName")); } }
// Constructors public UpgradeHintsProcessor( HandlerAccessor handlers, MappingResolver resolver, StoredDomainModel currentDomainModel, StoredDomainModel extractedDomainModel, StorageModel extractedStorageModel, bool autoDetectTypesMovements) { ArgumentValidator.EnsureArgumentNotNull(handlers, "handlers"); ArgumentValidator.EnsureArgumentNotNull(resolver, "resolver"); ArgumentValidator.EnsureArgumentNotNull(currentDomainModel, "currentDomainModel"); ArgumentValidator.EnsureArgumentNotNull(extractedDomainModel, "extractedDomainModel"); ArgumentValidator.EnsureArgumentNotNull(extractedStorageModel, "extractedStorageModel"); typeMapping = new Dictionary <StoredTypeInfo, StoredTypeInfo>(); reverseTypeMapping = new Dictionary <StoredTypeInfo, StoredTypeInfo>(); fieldMapping = new Dictionary <StoredFieldInfo, StoredFieldInfo>(); reverseFieldMapping = new Dictionary <StoredFieldInfo, StoredFieldInfo>(); this.resolver = resolver; nameBuilder = handlers.NameBuilder; domainModel = handlers.Domain.Model; this.extractedStorageModel = extractedStorageModel; currentModel = currentDomainModel; currentTypes = currentModel.Types.ToDictionary(t => t.UnderlyingType); extractedModel = extractedDomainModel; extractedTypes = extractedModel.Types.ToDictionary(t => t.UnderlyingType); this.autoDetectTypesMovements = autoDetectTypesMovements; hints = new NativeTypeClassifier <UpgradeHint>(true); suspiciousTypes = new List <StoredTypeInfo>(); }
internal static string GetNameOf(LambdaExpression expression) { var nb = new NameBuilder(expression); AddNames(expression.Body, nb); return(nb.ToString()); }
// Constructors public DomainModelConverter( HandlerAccessor handlers, ITypeIdProvider typeIdProvider, PartialIndexFilterCompiler compiler, MappingResolver resolver, IFullTextCatalogNameBuilder fulltextCatalogNameBuilder, bool isUpgradingStage) { ArgumentValidator.EnsureArgumentNotNull(handlers, "handlers"); ArgumentValidator.EnsureArgumentNotNull(typeIdProvider, "typeIdProvider"); ArgumentValidator.EnsureArgumentNotNull(compiler, "compiler"); ArgumentValidator.EnsureArgumentNotNull(resolver, "resolver"); this.handlers = handlers; this.compiler = compiler; this.typeIdProvider = typeIdProvider; this.resolver = resolver; this.isUpgradingStage = isUpgradingStage; this.fulltextCatalogNameBuilder = fulltextCatalogNameBuilder; sourceModel = handlers.Domain.Model; configuration = handlers.Domain.Configuration; providerInfo = handlers.ProviderInfo; driver = handlers.StorageDriver; nameBuilder = handlers.NameBuilder; FieldMapping = new Dictionary <StoredFieldInfo, StoredFieldInfo>(); StorageModel = null; CurrentModelTypes = new Dictionary <string, StoredTypeInfo>(); }
public override void EvaluateNode(OTreeNode node) { MethodInfo m = (MethodInfo)node.Definition; if (m.GetMethodBody() != null) { foreach (LocalVariableInfo i in m.GetMethodBody().LocalVariables) { if (!i.LocalType.IsGenericParameter && !i.LocalType.IsGenericType) { if (i.LocalType.IsArray) { if (i.LocalType.GetElementType().IsGenericParameter || i.LocalType.GetElementType().IsGenericType) { continue; } } if (i.LocalType.IsInterface) { #if DebugWarnings Log.WriteLine("Warning: " + NameBuilder.BuildMethodName(m) + " Uses an interface"); #endif if (node.SelectedImageIndex != Constants.ErrorIcon) { node.SelectedImageIndex = Constants.WarningIcon; node.ImageIndex = Constants.WarningIcon; } node.Warnings.Add(this); return; } } } } }
void VisitUsingDirective(UsingDirectiveSyntax n) { WriteLine(n.Kind() + " " + n.GetType() + " #" + GetUid(n)); NameBuilder sub = TraverseChildren(n, new NameBuilder(this)); csharpBuilder.usingDirective(GetUid(n), sub.numNameComponents()); }
public void GetName_ReturnsTypeName_WithWrappedSuffix() { var typeSymbol = Substitute.For <ITypeSymbol>(); typeSymbol.Name.Returns("TestName"); var result = NameBuilder.GetName(typeSymbol); Assert.Equal("TestNameWrapped", result); }
public void Execute(GeneratorExecutionContext context) { var currentAssemblyName = context.Compilation.Assembly.Name; var namespaceName = NameBuilder.GetNamespace(currentAssemblyName); var modelBuilderGenerator = new ModelBuilderExtensionGenerator(); var mvcExtension = modelBuilderGenerator.CreateModelBuilder($"{namespaceName}.TypeRepository.Instance"); context.AddSource("LaDeakJsonMergePatchModelBuilderExtension", SourceText.From(mvcExtension, Encoding.UTF8)); }
public void GetNamespaceExtension_Returns_SafeExtension() { var typeSymbol = Substitute.For <ITypeSymbol>(); typeSymbol.ContainingNamespace.ToDisplayString().Returns("Test.Namespace"); var result = NameBuilder.GetNamespaceExtension(typeSymbol); Assert.Equal("SafeTest.Namespace", result); }
public void GetNamespace_Returns_Namespace_SafeExtension() { var typeSymbol = Substitute.For <ITypeSymbol>(); typeSymbol.ContainingNamespace.ToDisplayString().Returns("Test.Namespace"); var result = NameBuilder.GetNamespace(typeSymbol); Assert.Equal("LaDeak.JsonMergePatch.Generated.SafeTest.Namespace", result); }
private void ApplyBonus(ItemConfiguration item, NameBuilder name, IBonusConfiguration bonusConfig) { if (!BonusAppliers.ContainsKey(bonusConfig.Type)) { throw new ApplicationException($"Bonus applier not found for bonus type: {bonusConfig.Type}"); } var applier = BonusAppliers[bonusConfig.Type]; applier.Apply(bonusConfig, item, name); }
private void GenerateBonuses( ItemConfiguration item, NameBuilder name, IBonusConfiguration[] config, int bonusesCount) { for (var counter = 0; counter < bonusesCount; counter++) { var bonusConfig = RandomHelper.GetRandomElement(config); ApplyBonus(item, name, bonusConfig); } }
//Constructors #region SearchHitViewModel public SearchHitViewModel(Vehicle vehicle) { this.Guid = vehicle.Guid; this.Title = NameBuilder.BuildNames(vehicle).FirstOrDefault()?.Name; var teaserImage = vehicle.VehiclePictures .OrderBy(runner => runner.SortOrder) .Select(runner => runner.Picture) .FirstOrDefault(); this.TeaserImageUrl = teaserImage == null ? $"./style/images/noimage.png" : $"./pictures/render/{teaserImage.Guid}"; this.TargetUrl = $"./vehicles/details/{vehicle.Guid.ToShortString()}"; }
protected virtual bool EquivalentUniqueConstraints( [NotNull] IKey sourceKey, [NotNull] IKey targetKey, [NotNull] IDictionary <IProperty, IProperty> columnMap) { Check.NotNull(sourceKey, "sourceKey"); Check.NotNull(targetKey, "targetKey"); Check.NotNull(columnMap, "columnMap"); return (NameBuilder.KeyName(sourceKey) == NameBuilder.KeyName(targetKey) && EquivalentColumnReferences(sourceKey.Properties, targetKey.Properties, columnMap)); }
public Name Generate() { var builder = new NameBuilder(); builder.AddSubname(this.RandomName()); builder.AddTitle(string.Concat("son of ", this.RandomName())); var hasTitle = titleBearing.Sample(); if (hasTitle) builder.AddTitle(titles.Sample()); return builder.Build(); }
protected virtual bool EquivalentForeignKeys( [NotNull] IForeignKey sourceForeignKey, [NotNull] IForeignKey targetForeignKey, [NotNull] IDictionary <IProperty, IProperty> columnMap) { Check.NotNull(sourceForeignKey, "sourceForeignKey"); Check.NotNull(targetForeignKey, "targetForeignKey"); Check.NotNull(columnMap, "columnMap"); return (NameBuilder.ForeignKeyName(sourceForeignKey) == NameBuilder.ForeignKeyName(targetForeignKey) && EquivalentColumnReferences(sourceForeignKey.Properties, targetForeignKey.Properties, columnMap) && EquivalentColumnReferences(sourceForeignKey.ReferencedProperties, targetForeignKey.ReferencedProperties, columnMap)); }
public override void EvaluateNode(OTreeNode node) { MethodInfo m = (MethodInfo)node.Definition; if ((m.Attributes & MethodAttributes.PinvokeImpl) != 0) { #if DebugErrors Log.WriteLine(NameBuilder.BuildMethodName(m) + " ~ PInvoke Impl"); #endif node.SelectedImageIndex = Constants.ErrorIcon; node.ImageIndex = Constants.ErrorIcon; node.Errors.Add(this); } }
public override void EvaluateNode(OTreeNode node) { MethodInfo m = (MethodInfo)node.Definition; MethodImplAttributes xImplFlags = m.GetMethodImplementationFlags(); if ((xImplFlags & MethodImplAttributes.Unmanaged) != 0) { #if DebugErrors Log.WriteLine(NameBuilder.BuildMethodName(m) + " ~ Method Implementation: Unmanaged"); #endif node.SelectedImageIndex = Constants.ErrorIcon; node.ImageIndex = Constants.ErrorIcon; node.Errors.Add(this); } }
protected virtual void Process(DropColumnOperation dropColumnOperation, Context context) { Check.NotNull(dropColumnOperation, "dropColumnOperation"); Check.NotNull(context, "context"); var entityType = context.SourceModel.EntityTypes.Single( t => NameBuilder.SchemaQualifiedTableName(t) == dropColumnOperation.TableName); var property = entityType.Properties.Single( p => NameBuilder.ColumnName(p) == dropColumnOperation.ColumnName); var extensions = property.SqlServer(); if (extensions.DefaultValue != null || extensions.DefaultExpression != null) { context.Operations.Add(OperationFactory.DropDefaultConstraintOperation(property)); } }
protected virtual void Process(DropTableOperation dropTableOperation, Context context) { Check.NotNull(dropTableOperation, "dropTableOperation"); Check.NotNull(context, "context"); var entityType = context.SourceModel.EntityTypes.Single( t => NameBuilder.SchemaQualifiedTableName(t) == dropTableOperation.TableName); foreach (var foreignKey in context.SourceModel.EntityTypes .SelectMany(t => t.ForeignKeys) .Where(fk => ReferenceEquals(fk.ReferencedEntityType, entityType))) { context.Operations.Add(OperationFactory.DropForeignKeyOperation(foreignKey), (x, y) => x.TableName == y.TableName && x.ForeignKeyName == y.ForeignKeyName); } }
private void FillName() { if (NameBuilder == null) { return; } var documentName = string.Format("Счет № {0} от {1}", Account.Number, Account.Date.ToShortDateString()); NameBuilder.DocumentName = documentName; NameBuilder.Build(); var nameParagraph = NameBuilder.GetResult(); _mainDocumentPart.Document.Body.AppendChild(nameParagraph); }
/// <summary> /// 双差网解定位构造函数 /// </summary> /// <param name="epochInfo">历元信息</param> /// <param name="Adjustment">平差信息</param> /// <param name="ClockEstimationer">钟差估计器</param> /// <param name="previousResult">上一历元结果</param> public MultiSiteGnssExtentResult( MultiSiteEpochInfo epochInfo, AdjustResultMatrix Adjustment, GnssParamNameBuilder ClockEstimationer, MultiSiteGnssExtentResult previousResult = null) : base(epochInfo, Adjustment, ClockEstimationer) { Vector vector = Adjustment.Corrected.CorrectedValue; //update foreach (var epoch in epochInfo) { var key = NameBuilder.GetSiteWetTropZpdName(epoch); epoch.NumeralCorrections[Gnsser.ParamNames.WetTropZpd] = vector[Adjustment.GetIndexOf(key)]; } }
protected List <string> GetLocalAccounts(int countAccounts) { var result = new List <string>(); var alphabet = "abcdefghijklmnopqrstuvwxyz"; for (int i = 0; i < countAccounts; i++) { NameBuilder.Clear(); for (var j = 0; j < 6; j++) { NameBuilder.Append(alphabet[Random.Next(26)]); } result.Add($"{NameBuilder}@ageron.info"); } return(result); }
internal static void AddNames(Expression expression, NameBuilder nb) { if (expression == null) { return; } switch (expression.NodeType) { case ExpressionType.MemberAccess: var memberExpression = (MemberExpression)expression; AddNames(memberExpression.Expression, nb); if (nb.DotNeeded) { nb.Append("."); } nb.Append(memberExpression.Member.Name); break; //case ExpressionType.Convert: // var unaryExpression = (UnaryExpression)expression; // AddNames(unaryExpression.Operand, nb); // break; case ExpressionType.Call: var callExpression = (MethodCallExpression)expression; MethodInfo method = callExpression.Method; bool isIndexer = (method.Name == "get_Item" && method.IsSpecialName); if (!isIndexer) { goto default; } AddNames(callExpression.Object, nb); nb.Append("[" + GetArguments(callExpression.Arguments).Aggregate((a, b) => a + b) + "]"); break; case ExpressionType.Parameter: break; default: throw new InvalidOperationException( string.Format("Unsupported expression type \"{0}\" in named expression", Enum.GetName(typeof(ExpressionType), expression.NodeType))); } }
// Constructors public UpgradeHintsProcessor( HandlerAccessor handlers, MappingResolver resolver, StoredDomainModel currentDomainModel, StoredDomainModel extractedDomainModel, StorageModel extractedStorageModel, bool autoDetectTypesMovements) { ArgumentValidator.EnsureArgumentNotNull(handlers, nameof(handlers)); ArgumentValidator.EnsureArgumentNotNull(resolver, nameof(resolver)); ArgumentValidator.EnsureArgumentNotNull(currentDomainModel, nameof(currentDomainModel)); ArgumentValidator.EnsureArgumentNotNull(extractedDomainModel, nameof(extractedDomainModel)); ArgumentValidator.EnsureArgumentNotNull(extractedStorageModel, nameof(extractedStorageModel)); // since type mapping is intersection of current types and extracted types // it will be equal or less than min size of these two sets var typesCapacity = currentDomainModel.Types.Length > extractedDomainModel.Types.Length ? extractedDomainModel.Types.Length : currentDomainModel.Types.Length; // By setting capacity we eliminate resize work and memory fluctuations. // In the worst case, when almost all types don't intersect, we will have some waste of memory // but in real life this is very rare case. typeMapping = new Dictionary <StoredTypeInfo, StoredTypeInfo>(typesCapacity); reverseTypeMapping = new Dictionary <StoredTypeInfo, StoredTypeInfo>(typesCapacity); fieldMapping = new Dictionary <StoredFieldInfo, StoredFieldInfo>(); reverseFieldMapping = new Dictionary <StoredFieldInfo, StoredFieldInfo>(); this.resolver = resolver; nameBuilder = handlers.NameBuilder; domainModel = handlers.Domain.Model; this.extractedStorageModel = extractedStorageModel; currentModel = currentDomainModel; currentTypes = currentModel.Types.ToDictionary(t => t.UnderlyingType, StringComparer.Ordinal, currentModel.Types.Length); extractedModel = extractedDomainModel; extractedTypes = extractedModel.Types.ToDictionary(t => t.UnderlyingType, StringComparer.Ordinal, extractedModel.Types.Length); this.autoDetectTypesMovements = autoDetectTypesMovements; hints = new NativeTypeClassifier <UpgradeHint>(true); suspiciousTypes = new HashSet <StoredTypeInfo>(); }
// Constructors public MetadataMapping(StorageDriver driver, NameBuilder nameBuilder) { this.nameBuilder = nameBuilder; Assembly = TableOf(typeof (Assembly)); AssemblyName = ColumnOf((Assembly x) => x.Name); AssemblyVersion = ColumnOf((Assembly x) => x.Version); Type = TableOf(typeof (Metadata.Type)); TypeId = ColumnOf((Metadata.Type x) => x.Id); TypeName = ColumnOf((Metadata.Type x) => x.Name); Extension = TableOf(typeof (Extension)); ExtensionName = ColumnOf((Extension x) => x.Name); ExtensionText = ColumnOf((Extension x) => x.Text); StringMapping = driver.GetTypeMapping(WellKnownTypes.String); IntMapping = driver.GetTypeMapping(WellKnownTypes.Int32); }
public virtual void GenerateColumnType( SchemaQualifiedName tableName, [NotNull] Column column, [NotNull] SqlBatchBuilder batchBuilder) { Check.NotNull(column, "column"); Check.NotNull(batchBuilder, "batchBuilder"); if (!string.IsNullOrEmpty(column.DataType)) { batchBuilder.Append(column.DataType); return; } var entityType = TargetModel.EntityTypes.Single(t => NameBuilder.SchemaQualifiedTableName(t) == tableName); var property = entityType.Properties.Single(p => NameBuilder.ColumnName(p) == column.Name); var isKey = property.IsKey() || property.IsForeignKey(); batchBuilder.Append(_typeMapper.GetTypeMapping(column.DataType, column.Name, column.ClrType, isKey, column.IsTimestamp).StoreTypeName); }
public void ProcessToken() { Content.Append(";"); bool parsingString = false; bool parseName = false; bool parseAttribute = false; for (int i = 0; i < Content.Length - 1; i++) { char c = Content[i]; char c1 = Content[i + 1]; if (c == '"') { parsingString = !parsingString; } if (!parsingString && (c == '<' || c == '/') && char.IsLetter(c1)) { parseName = true; } if (parseName) { if (c == ' ') { parseAttribute = true; } if (parseAttribute) { AttributeBuilder.Append(c); } else { if (!parsingString && c == '/' || c == '<' || c == '>') { continue; } NameBuilder.Append(c); } } } }
public void GenerateBonuses(ItemConfiguration item, int bonusesCount) { if (bonusesCount == 0) { return; } var configurationGroup = GetConfigurationGroup(item); var config = GetConfiguration(item.Rareness, configurationGroup); var nameBuilder = new NameBuilder(item.Name, (item as EquipableItemConfiguration)?.Description); GenerateBonuses(item, nameBuilder, config, bonusesCount); item.Name = nameBuilder.ToString(); if (item is EquipableItemConfiguration equipable) { equipable.Description = nameBuilder.GetDescription(); } }
private static void _ReadName(_Property nameProp, Contact contact) { Assert.IsNotNull(nameProp); Assert.IsNotNull(contact); var nb = new NameBuilder(contact.Names.Default); string[] names = _TokenizeEscapedMultipropString(nameProp.ValueString); switch (names.Length) { default: // too many. Ignore extras case 5: nb.Suffix = names[4]; goto case 4; case 4: nb.Prefix = names[3]; goto case 3; case 3: nb.MiddleName = names[2]; goto case 2; case 2: nb.GivenName = names[1]; goto case 1; case 1: nb.FamilyName = names[0]; break; case 0: Assert.Fail("Tokenize shouldn't have yielded an empty array."); break; } contact.Names.Default = nb; }