예제 #1
0
        /// <summary>
        /// Mappings to the specified Argument.
        /// </summary>
        /// <param name="name">The name.</param>
        /// <returns></returns>
        public ArgumentExpression MappingArgument(string name)
        {
            Contract.Require.That(name, Is.Not.Null & Is.Not.Empty).When("retrieving name argument in MappingArgument method");

            //if (parentConfiguration == null)
            //{
            //    argumentExpression = new ArgumentExpression(builder);
            //    parentConfiguration = builder.RegisterConfiguration();
            //    argumentExpression.parentConfiguration = parentConfiguration;
            //}
            //if (argumentExpression == null)
            //{
            //    argumentExpression = new ArgumentExpression(builder);
            //    argumentExpression.parentConfiguration = parentConfiguration;
            //}
            //currentArgument = new MutableConfiguration(ConfigConstants.ELEMENT_ARGUMENT, name);
            //currentArgument.CreateAttribute(ConfigConstants.ATTRIBUTE_ARGUMENTNAME, name);

            //parentConfiguration.Children.Add(currentSubMap);

            MutableConfiguration configArgument = new MutableConfiguration(ConfigConstants.ELEMENT_ARGUMENT, name);
            configArgument.CreateAttribute(ConfigConstants.ATTRIBUTE_ARGUMENTNAME, name);
            builder.CurrentConfiguration.Children.Add(configArgument);

            ArgumentExpression argumentExpression = new ArgumentExpression(builder, parentConfiguration, configArgument);

            return argumentExpression;
        }
        /// <summary>
        /// Processes a parameter map element.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="configurationStore">The configuration store.</param>
        private void ProcessParameterMapElement(Tag element, IConfigurationStore configurationStore)
        {
            MutableConfiguration config = null;

            if (element.Attributes.ContainsKey(ConfigConstants.ATTRIBUTE_CLASS))
            {
                config = new MutableConfiguration(
                        element.Name,
                        ApplyNamespace(element.Attributes[ConfigConstants.ATTRIBUTE_ID]),
                        element.Attributes[ConfigConstants.ATTRIBUTE_CLASS]);
            }
            else
            {
                config = new MutableConfiguration(
                        element.Name,
                        ApplyNamespace(element.Attributes[ConfigConstants.ATTRIBUTE_ID]));
            }
            config.CreateAttributes(element.Attributes);
            config.CreateAttribute(ConfigConstants.ATTRIBUTE_NAMESPACE, nameSpace);

            AddAttribute(config, ConfigConstants.ATTRIBUTE_EXTENDS, true);

            configurationStore.AddParameterMapConfiguration(config);
            element.Configuration = config;
        }
        /// <summary>
        /// Creates the child on the <see cref="MutableConfiguration"/>.
        /// </summary>
        /// <param name="name">The name.</param>
        /// <param name="value">The value.</param>
        /// <returns>The <see cref="MutableConfiguration"/></returns>
        public MutableConfiguration CreateChild(string name, string value)
        {
            MutableConfiguration child = new MutableConfiguration(name, value);

            Children.Add(child);
            return(child);
        }
예제 #4
0
 /// <summary>
 /// Serializes the specified <see cref="IDbProvider"/> into an <see cred="IConfiguration" /> node.
 /// </summary>
 public static IConfiguration Serialize(IDbProvider dbProvider)
 {
     IConfiguration providerConfig = new MutableConfiguration("provider", dbProvider.Id, dbProvider.Id);
     providerConfig.Attributes[DataConstants.ATTRIBUTE_NAME] = dbProvider.Id;
     providerConfig.Attributes[DataConstants.ATTRIBUTE_ASSEMBLYNAME] = dbProvider.AssemblyName;
     providerConfig.Attributes[DataConstants.ATTRIBUTE_COMMANDBUILDERCLASS] = dbProvider.CommandBuilderClass;
     providerConfig.Attributes[DataConstants.ATTRIBUTE_COMMANDCLASS] = dbProvider.DbCommandClass;
     providerConfig.Attributes[DataConstants.ATTRIBUTE_CONNECTIONCLASS] = dbProvider.DbConnectionClass;
     providerConfig.Attributes[DataConstants.ATTRIBUTE_DESCRIPTION] = dbProvider.Description;
     providerConfig.Attributes[DataConstants.ATTRIBUTE_DEFAULT] = dbProvider.IsDefault.ToString().ToLower();
     providerConfig.Attributes[DataConstants.ATTRIBUTE_ENABLED] = dbProvider.IsEnabled.ToString().ToLower();
     providerConfig.Attributes[DataConstants.ATTRIBUTE_PARAMETERDBTYPECLASS] = dbProvider.ParameterDbTypeClass;
     providerConfig.Attributes[DataConstants.ATTRIBUTE_PARAMETERDBTYPEPROPERTY] = dbProvider.ParameterDbTypeProperty;
     providerConfig.Attributes[DataConstants.ATTRIBUTE_PARAMETERPREFIX] = dbProvider.ParameterPrefix;
     providerConfig.Attributes[DataConstants.ATTRIBUTE_PARAMETERPREFIX] = dbProvider.ParameterPrefix;
     providerConfig.Attributes[DataConstants.ATTRIBUTE_SETDBPARAMETERPRECISION] = dbProvider.SetDbParameterPrecision.ToString().ToLower();
     providerConfig.Attributes[DataConstants.ATTRIBUTE_SETDBPARAMETERSCALE] = dbProvider.SetDbParameterScale.ToString().ToLower();
     providerConfig.Attributes[DataConstants.ATTRIBUTE_SETDBPARAMETERSIZE] = dbProvider.SetDbParameterSize.ToString().ToLower();
     providerConfig.Attributes[DataConstants.ATTRIBUTE_USEDERIVEPARAMETERS] = dbProvider.UseDeriveParameters.ToString().ToLower();
     providerConfig.Attributes[DataConstants.ATTRIBUTE_USEPARAMETERPREFIXINPARAMETER] = dbProvider.UseParameterPrefixInParameter.ToString().ToLower();
     providerConfig.Attributes[DataConstants.ATTRIBUTE_USEPARAMETERPREFIXINSQL] = dbProvider.UseParameterPrefixInSql.ToString().ToLower();
     providerConfig.Attributes[DataConstants.ATTRIBUTE_USEPOSITIONALPARAMETERS] = dbProvider.UsePositionalParameters.ToString().ToLower();
     providerConfig.Attributes[DataConstants.ATTRIBUTE_ALLOWMARS] = dbProvider.AllowMARS.ToString().ToLower();
     return providerConfig;
 }
        /// <summary>
        /// Processes the database element in the SqlMap.config file.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="configurationStore">The configuration store.</param>
        private void ProcessDatabaseElement(Tag element, IConfigurationStore configurationStore)
        {
            MutableConfiguration config = new MutableConfiguration(element.Name);
            config.CreateAttributes(element.Attributes);

            configurationStore.AddDatabaseConfiguration(config);
            element.Configuration = config;
        }
        /// <summary>
        /// Adds a Type alias to the store.
        /// </summary>
        /// <remarks>
        /// Uses ConfigConstants.ELEMENT_TYPEALIAS as the value for IConfiguration.Type.
        /// </remarks>
        /// <example>
        /// <code>
        /// &lt;alias&gt;
        ///	 &lt;typeAlias alias="Account" type="MyBatis.DataMapper.Sqlite.Test.Domain.Account, MyBatis.DataMapper.Sqlite.Test"/&gt;
	    /// &lt;/alias&gt;
        /// </code>
        /// </example>
        public void AddAlias(Type type, string name)
        {
            IConfiguration typeAlias = new MutableConfiguration(
                ConfigConstants.ELEMENT_TYPEALIAS,
                name,
                type.FullName + ", " + type.Assembly.GetName().Name);

            configurationStore.AddAliasConfiguration(typeAlias);
        }
        /// <summary>
        /// Processes the type alias element.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="configurationStore">The configuration store.</param>
        private void ProcessTypeAliasElement(Tag element, IConfigurationStore configurationStore)
        {
            IConfiguration config = new MutableConfiguration(
                element.Name,
                element.Attributes[ConfigConstants.ATTRIBUTE_ALIAS],
                element.Attributes[ConfigConstants.ATTRIBUTE_TYPE]);

            configurationStore.AddAliasConfiguration(config);
        }
예제 #8
0
        /// <summary>
        /// Processes the add element in external properties file
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="configurationStore">The configuration store.</param>
        private void ProcessAddElement(Tag element, IConfigurationStore configurationStore)
        {
            IConfiguration config = new MutableConfiguration(
                element.Name,
                element.Attributes[ConfigConstants.ATTRIBUTE_KEY],
                element.Attributes[ConfigConstants.ATTRIBUTE_VALUE]);

            configurationStore.AddPropertyConfiguration(config);
        }
        /// <summary>
        /// Processes the flush intervall element.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="configurationStore">The configuration store.</param>
        private void ProcessFlushIntervallElement(Tag element, IConfigurationStore configurationStore)
        {
            if (element.Parent != null && element.Parent.Name == ConfigConstants.ELEMENT_CACHEMODEL)
            {
                MutableConfiguration config = new MutableConfiguration(element.Name);
                config.CreateAttributes(element.Attributes);

                element.Parent.Configuration.Children.Add(config);
            }
        }
        /// <summary>
        /// Processes the constructor element.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="configurationStore">The configuration store.</param>
        private void ProcessConstructorElement(Tag element, IConfigurationStore configurationStore)
        {
            if (element.Parent != null && element.Parent.Name == ConfigConstants.ELEMENT_RESULTMAP)
            {
                IConfiguration config = new MutableConfiguration(element.Name);
                element.Configuration = config;

                element.Parent.Configuration.Children.Add(config);
            }
        }
예제 #11
0
        /// <summary>
        /// Processes the Sql element.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="configurationStore">The configuration store.</param>
        private void ProcessSqlElement(Tag element, IConfigurationStore configurationStore)
        {
            MutableConfiguration config = new MutableConfiguration(
                    element.Name,
                    element.Attributes[ConfigConstants.ATTRIBUTE_ID]);
            config.CreateAttribute(ConfigConstants.ATTRIBUTE_NAMESPACE, nameSpace);

            configurationStore.AddStatementConfiguration(config);
            element.Configuration = config;
        }
        /// <summary>
        /// Processes the type handler element.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="configurationStore">The configuration store.</param>
        private void ProcessTypeHandlerElement(Tag element, IConfigurationStore configurationStore)
        {
            MutableConfiguration config = new MutableConfiguration(
                element.Name,
                element.Attributes[ConfigConstants.ATTRIBUTE_TYPE]
                );
            config.CreateAttributes(element.Attributes);

            configurationStore.AddTypeHandlerConfiguration(config);
        }
        /// <summary>
        /// Processes a cache model element.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="configurationStore">The configuration store.</param>
        private void ProcessCacheModelElement(Tag element, IConfigurationStore configurationStore)
        {
            MutableConfiguration config = new MutableConfiguration(
                element.Name,
                ApplyNamespace(element.Attributes[ConfigConstants.ATTRIBUTE_ID]),
                element.Attributes[ConfigConstants.ATTRIBUTE_TYPE]);
            config.CreateAttributes(element.Attributes);
            config.CreateAttribute(ConfigConstants.ATTRIBUTE_NAMESPACE, nameSpace);

            configurationStore.AddCacheConfiguration(config);
            element.Configuration = config;
        }
예제 #14
0
        /// <summary>
        /// Processes the Include element.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="configurationStore">The configuration store.</param>
        private void ProcessIncludeElement(Tag element, IConfigurationStore configurationStore)
        {
            MutableConfiguration config = new MutableConfiguration(
                element.Name,
                element.Attributes[ConfigConstants.ATTRIBUTE_REFID]);
            config.CreateAttribute(ConfigConstants.ATTRIBUTE_NAMESPACE, nameSpace);
            config.CreateAttributes(element.Attributes);
            config.Parent = element.Parent.Configuration;

            element.Parent.Configuration.Children.Add(config);
            element.Configuration = config;
        }
        /// <summary>
        /// Processes the parameter element.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="configurationStore">The configuration store.</param>
        private void ProcessParameterElement(Tag element, IConfigurationStore configurationStore)
        {
            if (element.Parent != null && element.Parent.Name == ConfigConstants.ELEMENT_PARAMETERMAP)
            {
                MutableConfiguration config = new MutableConfiguration(
                    element.Name,
                    element.Attributes[ConfigConstants.ATTRIBUTE_PROPERTY]);
                config.CreateAttributes(element.Attributes);

                element.Parent.Configuration.Children.Add(config);
            }
        }
        /// <summary>
        /// Processes the flush on execute element.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="configurationStore">The configuration store.</param>
        private void ProcessFlushOnExecuteElement(Tag element, IConfigurationStore configurationStore)
        {
            if (element.Parent != null && element.Parent.Name == ConfigConstants.ELEMENT_CACHEMODEL)
            {
                MutableConfiguration config = new MutableConfiguration(
                    element.Name,
                    element.Attributes[ConfigConstants.ATTRIBUTE_STATEMENT]);
                config.CreateAttributes(element.Attributes);

                element.Parent.Configuration.Children.Add(config);
            }
        }
예제 #17
0
        /// <summary>
        /// Processes the argument element.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="configurationStore">The configuration store.</param>
        private void ProcessArgumentElement(Tag element, IConfigurationStore configurationStore)
        {
            if (element.Parent != null && element.Parent.Name == ConfigConstants.ELEMENT_CONSTRUCTOR)
            {
                MutableConfiguration config = new MutableConfiguration(
                    element.Name,
                    element.Attributes[ConfigConstants.ATTRIBUTE_ARGUMENTNAME]);
                config.CreateAttributes(element.Attributes);

                element.Parent.Configuration.Children.Add(config);
            }
        }
예제 #18
0
        /// <summary>
        /// Processes the dynamic elements.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="configurationStore">The configuration store.</param>
        private void ProcessDynamicElement(Tag element, IConfigurationStore configurationStore)
        {
            if (element.Parent != null)
            {
                MutableConfiguration config = new MutableConfiguration(element.Name);
                config.CreateAttributes(element.Attributes);
                config.Parent = element.Parent.Configuration;

                element.Parent.Configuration.Children.Add(config);
                element.Configuration = config;
            }
        }
        /// <summary>
        /// Processes the DataSource element in the SqlMap.config file. 
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="configurationStore">The configuration store.</param>
        private void ProcessDataSourceElement(Tag element, IConfigurationStore configurationStore)
        {
            if (element.Parent != null && element.Parent.Name == ConfigConstants.ELEMENT_DATABASE)
            {
                MutableConfiguration config = new MutableConfiguration(
                    element.Name,
                    element.Attributes[DataConstants.ATTRIBUTE_NAME],
                    element.Attributes[DataConstants.ATTRIBUTE_CONNECTIONSTRING]);
                config.CreateAttributes(element.Attributes);

                element.Parent.Configuration.Children.Add(config);
            }
        }
        /// <summary>
        /// Processes the discriminator element.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="configurationStore">The configuration store.</param>
        private void ProcessDiscriminatorElement(Tag element, IConfigurationStore configurationStore)
        {
            if (element.Parent != null && element.Parent.Name == ConfigConstants.ELEMENT_RESULTMAP)
            {
                MutableConfiguration config = new MutableConfiguration(
                    element.Name,
                    element.Attributes[ConfigConstants.ATTRIBUTE_COLUMN]);
                config.CreateAttributes(element.Attributes);
                element.Configuration = config;

                element.Parent.Configuration.Children.Add(config);
            }
        }
예제 #21
0
        /// <summary>
        /// Processes the setting element in the SqlMap.config file.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="configurationStore">The configuration store.</param>
        private void ProcessSettingElement(Tag element, IConfigurationStore configurationStore)
        {
            // <setting hello="world" />

            string settingKey = element.GetAttributeName(0);
            string settingValue = element.GetAttributeValue(0);

            IConfiguration config = new MutableConfiguration(
                element.Name,
                settingKey,
                settingValue);
            configurationStore.AddSettingConfiguration(config);
        }
예제 #22
0
        /// <summary>
        /// Processes the discriminator/case element.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="configurationStore">The configuration store.</param>
        private void ProcessCaseElement(Tag element, IConfigurationStore configurationStore)
        {
            if (element.Parent != null && element.Parent.Name == ConfigConstants.ELEMENT_DISCRIMINATOR)
            {
                MutableConfiguration config = new MutableConfiguration(
                    element.Name,
                    element.Attributes[ConfigConstants.ATTRIBUTE_VALUE]);
                config.CreateAttributes(element.Attributes);

                AddAttribute(config, ConfigConstants.ATTRIBUTE_RESULTMAP, true);

                element.Parent.Configuration.Children.Add(config);
            }
        }
        /// <summary>
        /// Processes the result map element.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="configurationStore">The configuration store.</param>
        private void ProcessResultMapElement(Tag element, IConfigurationStore configurationStore)
        {
            MutableConfiguration config = new MutableConfiguration(
                    element.Name,
                    ApplyNamespace(element.Attributes[ConfigConstants.ATTRIBUTE_ID]),
                    element.Attributes[ConfigConstants.ATTRIBUTE_CLASS]);
            config.CreateAttributes(element.Attributes);
            config.CreateAttribute(ConfigConstants.ATTRIBUTE_NAMESPACE, nameSpace);

            AddAttribute(config, ConfigConstants.ATTRIBUTE_EXTENDS, true);

            configurationStore.AddResultMapConfiguration(config);
            element.Configuration = config;
        }
예제 #24
0
        /// <summary>
        /// Processes the discriminator/default element.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="configurationStore">The configuration store.</param>
        private void ProcessDefaultElement(Tag element, IConfigurationStore configurationStore)
        {
            if (element.Parent != null && element.Parent.Name == ConfigConstants.ELEMENT_DISCRIMINATOR)
            {
                MutableConfiguration config = new MutableConfiguration(
                    ConfigConstants.ELEMENT_CASE,
                    Discriminator.DEFAULT_KEY);
                config.CreateAttributes(element.Attributes);
                config.CreateAttribute(ConfigConstants.ATTRIBUTE_VALUE, Discriminator.DEFAULT_KEY);

                AddAttribute(config, ConfigConstants.ATTRIBUTE_RESULTMAP, true);

                element.Parent.Configuration.Children.Add(config);
            }
        }
예제 #25
0
        /// <summary>
        /// Processes the text element.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="configurationStore">The configuration store.</param>
        protected override void ProcessTextElement(Tag element, IConfigurationStore configurationStore)
        {
            if (element.Parent != null)
            {
                string text = element.Value.Replace('\n', ' ').Replace('\r', ' ').Replace('\t', ' ').Trim(); 

                MutableConfiguration config = new MutableConfiguration(
                                    element.Name,
                                    string.Empty,
                                    element.Value); // text);

                element.Parent.Configuration.Children.Add(config);
                element.Configuration = config;
            }
        }
        /// <summary>
        /// Processes the statement element.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="configurationStore">The configuration store.</param>
        private void ProcessStatementElement(Tag element, IConfigurationStore configurationStore)
        {
            MutableConfiguration config = new MutableConfiguration(
                    element.Name,
                    element.Attributes[ConfigConstants.ATTRIBUTE_ID]);
            config.CreateAttributes(element.Attributes);
            config.CreateAttribute(ConfigConstants.ATTRIBUTE_NAMESPACE, nameSpace);

            AddAttribute(config, ConfigConstants.ATTRIBUTE_CACHEMODEL, true);
            AddAttribute(config, ConfigConstants.ELEMENT_PARAMETERMAP, true);
            AddAttribute(config, ConfigConstants.ELEMENT_RESULTMAP, true);
            AddAttribute(config, ConfigConstants.ELEMENT_PRESERVEWHITESPACE, false);

            configurationStore.AddStatementConfiguration(config);
            element.Configuration = config;
        }
예제 #27
0
        /// <summary>
        /// Extendses the specified parameter map.
        /// </summary>
        /// <param name="extend">The extend id.</param>
        /// <returns></returns>
        public ParameterExpression Extends(string extend)
        {
            Contract.Require.That(extend, Is.Not.Null & Is.Not.Empty).When("retrieving extend argument in Extends method");

            if (parentConfiguration == null)
            {
                parameterExpression = new ParameterExpression(builder);
                parentConfiguration = builder.RegisterConfiguration();
                parameterExpression.parentConfiguration = parentConfiguration;
            }
            if (parameterExpression == null)
            {
                parameterExpression = new ParameterExpression(builder);
                parameterExpression.parentConfiguration = parentConfiguration;
            }
            parentConfiguration.CreateAttribute(ConfigConstants.ATTRIBUTE_EXTENDS, builder.ApplyNamespace(extend));

            return parameterExpression;
        }
예제 #28
0
        /// <summary>
        /// Processes the provider element in the providers.config file.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="configurationStore">The configuration store.</param>
        private void ProcessProviderElement(Tag element, IConfigurationStore configurationStore)
        {
            // provider child tag of Database tag
            if (element.Parent != null && element.Parent.Name == "database")
            {
                MutableConfiguration config = new MutableConfiguration(
                    element.Name,
                    element.Attributes[DataConstants.ATTRIBUTE_NAME],
                    element.Attributes[DataConstants.ATTRIBUTE_NAME]);
                config.CreateAttributes(element.Attributes);
                element.Parent.Configuration.Children.Add(config);
            }
            else
            {
                MutableConfiguration config = new MutableConfiguration(
                    element.Name,
                    element.Attributes[DataConstants.ATTRIBUTE_NAME]);
                config.CreateAttributes(element.Attributes);

                configurationStore.AddProviderConfiguration(config);
            }
        }
예제 #29
0
        /// <summary>
        /// Processes the property element in the SqlMap.config file.
        /// </summary>
        /// <param name="element">The element.</param>
        /// <param name="configurationStore">The configuration store.</param>
        private void ProcessPropertyElement(Tag element, IConfigurationStore configurationStore)
        {
            if (element.Parent.Name != ConfigConstants.ELEMENT_CACHEMODEL)
            {
                if (element.Attributes.ContainsKey(ConfigConstants.ATTRIBUTE_URI))
                {
                    string uri = element.Attributes[ConfigConstants.ATTRIBUTE_URI];

                    using (XmlTextReader reader = Resources.GetUriAsXmlReader(uri))
                    {
                        this.Process(reader, configurationStore);
                    }
                }
                else
                {
                    IConfiguration config = new MutableConfiguration(
                        element.Name,
                        element.Attributes[ConfigConstants.ATTRIBUTE_KEY],
                        element.Attributes[ConfigConstants.ATTRIBUTE_VALUE]);
                    configurationStore.AddPropertyConfiguration(config);
                }
            }
        }
예제 #30
0
        /// <summary>
        /// Registers the current configuration.
        /// </summary>
        /// <returns></returns>
        public MutableConfiguration RegisterConfiguration()
        {
            MutableConfiguration configuration = currentConfiguration;

            if (currentConfiguration!=null)
            {
                switch(currentConfiguration.Type)
                {
                    case ConfigConstants.ELEMENT_TYPEALIAS:
                        store.AddAliasConfiguration(currentConfiguration);
                        break;
                    case ConfigConstants.ELEMENT_TYPEHANDLER:
                        store.AddTypeHandlerConfiguration(currentConfiguration);
                        break;
                    case ConfigConstants.ELEMENT_RESULTMAP:
                        store.AddResultMapConfiguration(currentConfiguration);
                        break;
                    case ConfigConstants.ELEMENT_PARAMETERMAP:
                        store.AddParameterMapConfiguration(currentConfiguration);
                        break;
                    case ConfigConstants.ELEMENT_RESULT:
                    case ConfigConstants.ELEMENT_DISCRIMINATOR:
                    case ConfigConstants.ELEMENT_CONSTRUCTOR:
                    case ConfigConstants.ELEMENT_PARAMETER:
                        break;
                    default:
                        throw new DataMapperException("Invalid configuration registration for configuration type:" + currentConfiguration.Type);
                }
                currentConfiguration = null;
            }

            return configuration;
        }
예제 #31
0
 /// <summary>
 /// Creates the child on the <see cref="MutableConfiguration"/>.
 /// </summary>
 /// <param name="name">The name.</param>
 /// <param name="value">The value.</param>
 /// <returns>The <see cref="MutableConfiguration"/></returns>
 public MutableConfiguration CreateChild(string name, string value)
 {
     MutableConfiguration child = new MutableConfiguration(name, value);
     Children.Add(child);
     return child;
 }