/// <summary>
        /// Initializes a new instance of the <see cref="VistaDBErrorLog"/> class
        /// using a dictionary of configured settings.
        /// </summary>

        public VistaDBErrorLog(IDictionary config)
        {
            if (config == null)
                throw new ArgumentNullException("config");

            _connectionString = ConnectionStringHelper.GetConnectionString(config);

            //
            // If there is no connection string to use then throw an 
            // exception to abort construction.
            //

            if (_connectionString.Length == 0)
                throw new ApplicationException("Connection string is missing for the VistaDB error log.");

            _databasePath = ConnectionStringHelper.GetDataSourceFilePath(_connectionString);
            InitializeDatabase();

            string appName = Mask.NullString((string)config["applicationName"]);

            if (appName.Length > _maxAppNameLength)
            {
                throw new ApplicationException(string.Format(
                    "Application name is too long. Maximum length allowed is {0} characters.",
                    _maxAppNameLength.ToString("N0")));
            }

            ApplicationName = appName;
        }

 /// <summary> Ctor.</summary>
 /// <param name="selector">Selector.
 /// </param>
 /// <param name="root">Root expression of the parsed selector.
 /// </param>
 /// <param name="identifiers">Identifiers used by the selector. The key
 /// into the <tt>Map</tt> is name of the identifier and the value is an
 /// instance of <tt>Identifier</tt>.
 /// </param>
 private Selector(System.String selector, IExpression root, System.Collections.IDictionary identifiers)
 {
     selector_ = selector;
     root_ = root;
     //UPGRADE_ISSUE: Method 'java.util.Collections.unmodifiableMap' was not converted. 'ms-help://MS.VSCC.2003/commoner/redir/redirect.htm?keyword="jlca1000_javautilCollectionsunmodifiableMap_javautilMap"'
     identifiers_ = identifiers;
 }

        /// <summary>
        /// Returns a string representation of this IDictionary.
        /// </summary>
        /// <remarks>
        /// The string representation is a list of the collection's elements in the order 
        /// they are returned by its IEnumerator, enclosed in curly brackets ("{}").
        /// The separator is a comma followed by a space i.e. ", ".
        /// </remarks>
        /// <param name="dict">Dictionary whose string representation will be returned</param>
        /// <returns>A string representation of the specified dictionary or "null"</returns>
        public static string DictionaryToString(IDictionary dict)
        {
            StringBuilder sb = new StringBuilder();

            if (dict != null)
            {
                sb.Append("{");
                int i = 0;
                foreach (DictionaryEntry e in dict)
                {
                    if (i > 0)
                    {
                        sb.Append(", ");
                    }

                    if (e.Value is IDictionary)
                        sb.AppendFormat("{0}={1}", e.Key.ToString(), DictionaryToString((IDictionary)e.Value));
                    else if (e.Value is IList)
                        sb.AppendFormat("{0}={1}", e.Key.ToString(), ListToString((IList)e.Value));
                    else
                        sb.AppendFormat("{0}={1}", e.Key.ToString(), e.Value.ToString());
                    i++;
                }
                sb.Append("}");
            }
            else
                sb.Insert(0, "null");

            return sb.ToString();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="SqlErrorLog"/> class
        /// using a dictionary of configured settings.
        /// </summary>

        public SqlErrorLog(IDictionary config)
        {
            if (config == null)
                throw new ArgumentNullException("config");

            var connectionString = ConnectionStringHelper.GetConnectionString(config);

            //
            // If there is no connection string to use then throw an 
            // exception to abort construction.
            //

            if (connectionString.Length == 0)
                throw new ApplicationException("Connection string is missing for the SQL error log.");

            _connectionString = connectionString;

            //
            // Set the application name as this implementation provides
            // per-application isolation over a single store.
            //

            var appName = config.Find("applicationName", string.Empty);

            if (appName.Length > _maxAppNameLength)
            {
                throw new ApplicationException(string.Format(
                    "Application name is too long. Maximum length allowed is {0} characters.",
                    _maxAppNameLength.ToString("N0")));
            }

            ApplicationName = appName;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="AccessErrorLog"/> class
        /// using a dictionary of configured settings.
        /// </summary>
        public AccessErrorLog(IDictionary config)
        {
            if (config == null)
                throw new ArgumentNullException("config");

            string connectionString = ConnectionStringHelper.GetConnectionString(config);

            //
            // If there is no connection string to use then throw an
            // exception to abort construction.
            //

            if (connectionString.Length == 0)
                throw new ApplicationException("Connection string is missing for the Access error log.");

            _connectionString = connectionString;

            InitializeDatabase();

            //
            // Set the application name as this implementation provides
            // per-application isolation over a single store.
            //

            string appName = Mask.NullString((string)config["applicationName"]);

            if (appName.Length > _maxAppNameLength)
            {
                throw new ApplicationException(string.Format(
                    "Application name is too long. Maximum length allowed is {0} characters.",
                    _maxAppNameLength.ToString("N0")));
            }

            ApplicationName = appName;
        }

        /// <summary>
        /// Creates an object given its text-based type specification 
        /// (see <see cref="System.Type.GetType"/> for notes on the
        /// specification) and optionally sends it settings for
        /// initialization.
        /// </summary>
        public static object Create(string typeSpec, IDictionary settings)
        {
            if (typeSpec.Length == 0)
                return null;

            Type type = Type.GetType(typeSpec, true);

            return (settings == null) ?
                Activator.CreateInstance(type) :
                Activator.CreateInstance(type, new object[] { settings });
        }

        private static string GetString(IDictionary options, string name)
        {
            Debug.Assert(name != null);

            if (options == null)
                return string.Empty;

            object value = options[name];

            if (value == null)
                return string.Empty;

            return value.ToString() ?? string.Empty;
        }

        /// <summary>
        /// Gets the connection string from the given configuration 
        /// dictionary.
        /// </summary>
        public static string GetConnectionString(IDictionary config)
        {
            Debug.Assert(config != null);

            #if !NET_1_1 && !NET_1_0
            //
            // First look for a connection string name that can be
            // subsequently indexed into the <connectionStrings> section of
            // the configuration to get the actual connection string.
            //

            string connectionStringName = (string)config["connectionStringName"] ?? string.Empty;

            if (connectionStringName.Length > 0)
            {
                ConnectionStringSettings settings = ConfigurationManager.ConnectionStrings[connectionStringName];

                if (settings == null)
                    return string.Empty;

                return settings.ConnectionString ?? string.Empty;
            }
            #endif

            //
            // Connection string name not found so see if a connection
            // string was given directly.
            //

            string connectionString = Mask.NullString((string)config["connectionString"]);

            if (connectionString.Length > 0)
                return connectionString;

            //
            // As a last resort, check for another setting called
            // connectionStringAppKey. The specifies the key in
            // <appSettings> that contains the actual connection string to
            // be used.
            //

            string connectionStringAppKey = Mask.NullString((string)config["connectionStringAppKey"]);

            if (connectionStringAppKey.Length == 0)
                return string.Empty;

            return Configuration.AppSettings[connectionStringAppKey];
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="MemoryErrorLog"/> class
        /// using a dictionary of configured settings.
        /// </summary>        
        public MemoryErrorLog(IDictionary config)
        {
            if (config == null)
            {
                _size = DefaultSize;
                return;
            }

            string sizeString = (string)config["size"] ?? "";
            if (sizeString.Length == 0)
            {
                _size = DefaultSize;
                return;
            }

            _size = Convert.ToInt32(sizeString, CultureInfo.InvariantCulture);
            _size = Math.Max(0, Math.Min(MaximumSize, _size));
        }

        /// <summary>
        /// Gets the connection string from the given configuration 
        /// dictionary.
        /// </summary>
        public static string GetConnectionString(IDictionary config)
        {
            Debug.Assert(config != null);

            //
            // First look for a connection string name that can be
            // subsequently indexed into the <connectionStrings> section of
            // the configuration to get the actual connection string.
            //

            string connectionStringName = config.Find("connectionStringName", string.Empty);

            if (connectionStringName.Length > 0)
            {
                ConnectionStringSettings settings = ConfigurationManager.ConnectionStrings[connectionStringName];

                if (settings == null)
                    return string.Empty;

                return settings.ConnectionString ?? string.Empty;
            }

            //
            // Connection string name not found so see if a connection
            // string was given directly.
            //

            var connectionString = config.Find("connectionString", string.Empty);
            if (connectionString.Length > 0)
                return connectionString;

            //
            // As a last resort, check for another setting called
            // connectionStringAppKey. The specifies the key in
            // <appSettings> that contains the actual connection string to
            // be used.
            //

            var connectionStringAppKey = config.Find("connectionStringAppKey", string.Empty);
            return connectionStringAppKey.Length > 0
                 ? ConfigurationManager.AppSettings[connectionStringAppKey]
                 : string.Empty;
        }

		public MockRAMDirectory(System.IO.FileInfo dir) : base(dir)
		{
			if (openFiles == null)
			{
				openFiles = new System.Collections.Hashtable();
			}
		}

        static LiteralBool()
        {
            idMap_ = new System.Collections.Hashtable();
            {
                LiteralBool literal = new LiteralBool("true");
                object tempObject;
                tempObject = literal;
                idMap_["true"] = tempObject;
                System.Object generatedAux = tempObject;
                object tempObject2;
                tempObject2 = literal;
                idMap_["TRUE"] = tempObject2;
                System.Object generatedAux2 = tempObject2;
                object tempObject3;
                tempObject3 = literal;
                idMap_["True"] = tempObject3;
                System.Object generatedAux3 = tempObject3;

                literal = new LiteralBool("false");
                object tempObject4;
                tempObject4 = literal;
                idMap_["false"] = tempObject4;
                System.Object generatedAux4 = tempObject4;
                object tempObject5;
                tempObject5 = literal;
                idMap_["FALSE"] = tempObject5;
                System.Object generatedAux5 = tempObject5;
                object tempObject6;
                tempObject6 = literal;
                idMap_["False"] = tempObject6;
                System.Object generatedAux6 = tempObject6;
            }
        }

 public Group(QName name, Field[] fields, bool optional)
     : base(name, optional)
 {
     var expandedFields = new List<Field>();
     var references = new List<StaticTemplateReference>();
     for (int i = 0; i < fields.Length; i++)
     {
         if (fields[i] is StaticTemplateReference)
         {
             var currentTemplate = (StaticTemplateReference)fields[i];
             Field[] referenceFields = currentTemplate.Template.Fields;
             for (int j = 1; j < referenceFields.Length; j++)
                 expandedFields.Add(referenceFields[j]);
             references.Add(currentTemplate);
         }
         else
         {
             expandedFields.Add(fields[i]);
         }
     }
     this.fields = expandedFields.ToArray();
     fieldDefinitions = fields;
     fieldIndexMap = ConstructFieldIndexMap(this.fields);
     fieldNameMap = ConstructFieldNameMap(this.fields);
     fieldIdMap = ConstructFieldIdMap(this.fields);
     introspectiveFieldMap = ConstructInstrospectiveFields(this.fields);
     usesPresenceMap_Renamed_Field = DeterminePresenceMapUsage(this.fields);
     staticTemplateReferences = references.ToArray();
 }

		public override System.Collections.BitArray Bits(IndexReader reader)
		{
			if (cache == null)
			{
                cache = new SupportClass.WeakHashTable();
			}
			
			System.Object cached = null;
			lock (cache.SyncRoot)
			{
				// check cache
				cached = cache[reader];
			}
			
			if (cached != null)
			{
				if (cached is System.Collections.BitArray)
				{
					return (System.Collections.BitArray) cached;
				}
				else if (cached is DocIdBitSet)
					return ((DocIdBitSet) cached).GetBitSet();
				// It would be nice to handle the DocIdSet case, but that's not really possible
			}
			
			System.Collections.BitArray bits = filter.Bits(reader);
			
			lock (cache.SyncRoot)
			{
				// update cache
				cache[reader] = bits;
			}
			
			return bits;
		}

		public override System.Collections.BitArray Bits(IndexReader reader)
		{
			if (cache == null)
			{
				cache = new System.Collections.Hashtable();
			}
			
			lock (cache.SyncRoot)
			{
				// check cache
				System.Collections.BitArray cached = (System.Collections.BitArray) cache[reader];
				if (cached != null)
				{
					return cached;
				}
			}
			
			System.Collections.BitArray bits = filter.Bits(reader);
			
			lock (cache.SyncRoot)
			{
				// update cache
				cache[reader] = bits;
			}
			
			return bits;
		}

		public virtual void AddEntry(object key, object value)
		{
			if (map == null)
			{
				map = new NeoDatis.Tool.Wrappers.Map.OdbHashMap();
			}
			map.Add(key, value);
		}

 public virtual void Close()
 {
     // Clear the hard refs; then, the only remaining refs to
     // all values we were storing are weak (unless somewhere
     // else is still using them) and so GC may reclaim them:
     hardRefs = null;
     t = null;
 }

 public ValidationException(Result result)
     : base("There was a problem validating the submission. See data property for messages.")
 {
     this.data = new Dictionary<string, string>();
     foreach (var message in result.FailureMessages)
     {
         this.data.Add(message.PropertyName, message.Message);
     }
 }

		public MultiFieldComparator(string[] names, NeoDatis.Odb.Core.OrderByConstants orderByType
			)
		{
			this.fieldNames = names;
			map = new System.Collections.Hashtable();
			this.way = orderByType.IsOrderByAsc() ? 1 : -1;
			this.classIntrospector = NeoDatis.Odb.OdbConfiguration.GetCoreProvider().GetClassIntrospector
				();
		}

 /// <summary> An AttributeSource that uses the same attributes as the supplied one.</summary>
 public AttributeSource(AttributeSource input)
 {
     if (input == null)
     {
         throw new System.ArgumentException("input AttributeSource must not be null");
     }
     this.attributes = input.attributes;
     this.attributeImpls = input.attributeImpls;
     this.factory = input.factory;
 }