示例#1
0
        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;
        }
示例#2
0
文件: C3poConfig.cs 项目: Elders/c3po
        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);
        }
示例#3
0
 // 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>();
        }
示例#5
0
        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>();
        }
示例#7
0
        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;
                        }
                    }
                }
            }
        }
示例#8
0
    void VisitUsingDirective(UsingDirectiveSyntax n)
    {
        WriteLine(n.Kind() + " " + n.GetType() + "  #" + GetUid(n));

        NameBuilder sub = TraverseChildren(n, new NameBuilder(this));

        csharpBuilder.usingDirective(GetUid(n), sub.numNameComponents());
    }
示例#9
0
        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));
    }
示例#11
0
        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);
        }
示例#12
0
        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);
        }
示例#13
0
        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);
        }
示例#14
0
 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);
     }
 }
示例#15
0
            //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()}";
            }
示例#16
0
        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));
        }
示例#17
0
        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();
        }
示例#18
0
        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));
        }
示例#19
0
        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);
            }
        }
示例#21
0
        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));
            }
        }
示例#22
0
        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);
            }
        }
示例#23
0
        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);
        }
示例#24
0
        /// <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)];
            }
        }
示例#25
0
        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);
        }
示例#26
0
        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)));
            }
        }
示例#27
0
        // 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);
        }
示例#30
0
        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);
                    }
                }
            }
        }
示例#31
0
        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();
            }
        }
示例#32
0
        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;
        }