public IndexDefinition(IndexType indexType,
                               IList<IndexColumnName> columns,
                               IList<IndexOption> options)
        {
            IndexType = indexType;
            if (columns == null || columns.IsEmpty())
            {
                throw new ArgumentException("columns is null or empty");
            }

            Columns = columns;
            Options = options == null || options.IsEmpty() ? new List<IndexOption>(0) : options;
        }

	    /// <summary>
	    ///		Constructor.
	    /// </summary>
	    ///<param name="manager"></param>
	    ///<param name="type">Type of index (16 or 32 bit).</param>
	    /// <param name="numIndices">Number of indices to create in this buffer.</param>
	    /// <param name="usage">Buffer usage.</param>
	    /// <param name="useSystemMemory">Create in system memory?</param>
	    /// <param name="useShadowBuffer">Use a shadow buffer for reading/writing?</param>
	    public HardwareIndexBuffer( HardwareBufferManagerBase manager, IndexType type, int numIndices, BufferUsage usage, bool useSystemMemory, bool useShadowBuffer )
			: base( usage, useSystemMemory, useShadowBuffer )
		{
			this.type = type;
			this.numIndices = numIndices;
			this.Manager =  manager;
			// calc the index buffer size
			sizeInBytes = numIndices;

			if ( type == IndexType.Size32 )
			{
				indexSize = Marshal.SizeOf( typeof( int ) );
			}
			else
			{
				indexSize = Marshal.SizeOf( typeof( short ) );
			}

			sizeInBytes *= indexSize;

			// create a shadow buffer if required
			if ( useShadowBuffer )
			{
				shadowBuffer = new DefaultHardwareIndexBuffer( Manager, type, numIndices, BufferUsage.Dynamic );
			}
		}

        public void ShouldCreateIndex(
            IndexFor indexFor,
            IndexProvider indexProvider,
            IndexType indexType,
            string createEndpoint,
            string createJson)
        {
            //Arrange
            using (var testHarness = new RestTestHarness
            {
                {
                    MockRequest.PostJson(createEndpoint, createJson),
                    MockResponse.Http(201)
                }
            })
            {
                var graphClient = testHarness.CreateAndConnectGraphClient();

                var indexConfiguration = new IndexConfiguration
                {
                    Provider = indexProvider,
                    Type = indexType
                };
                graphClient.CreateIndex("foo", indexConfiguration, indexFor);
            }
        }

 public IndexOption(IndexType indexType)
 {
     KeyBlockSize = null;
     IndexType = indexType;
     ParserName = null;
     Comment = null;
 }

		public GLESHardwareIndexBuffer( HardwareBufferManagerBase manager, IndexType type, int numIndices, BufferUsage usage, bool useShadowBuffer )
			: base( manager, type, numIndices, usage, false, useShadowBuffer )
		{
			if ( type == IndexType.Size32 )
			{
				throw new AxiomException( "32 bit hardware buffers are not allowed in OpenGL ES." );
			}
			
			if ( !useShadowBuffer )
			{
				throw new AxiomException( "Only support with shadowBuffer" );
			}
			
			OpenGL.GenBuffers( 1, ref this._bufferId );
			GLESConfig.GlCheckError( this );
			if ( this._bufferId == 0 )
			{
				throw new AxiomException( "Cannot create GL index buffer" );
			}
			
			OpenGL.BindBuffer( All.ElementArrayBuffer, this._bufferId );
			GLESConfig.GlCheckError( this );
			OpenGL.BufferData( All.ElementArrayBuffer, new IntPtr( sizeInBytes ), IntPtr.Zero, GLESHardwareBufferManager.GetGLUsage( usage ) );
			GLESConfig.GlCheckError( this );
		}

 /// <summary>
 /// Initializes a new instance of the <see cref="SearcherEventArgs"/> class.
 /// </summary>
 /// <param name="indexName">Name of the index that is being searched.</param>
 /// <param name="structure">The structure of the index that is being searched.</param>
 /// <param name="methodType">The search method type that is being used.</param>
 /// <param name="location">The location within the method body where this event was fired from.</param>
 /// <param name="result">The search result was found.</param>
 public SearcherEventArgs(string indexName, IndexType structure, SearchMethodType methodType, SearchMethodLocation location, SearchResult result)
 {
     this.indexName = indexName;
     this.structure = structure;
     this.SearchMethodType = methodType;
     this.SearchMethodLocation = location;
     this.SearchResult = result;
 }

		public override HardwareIndexBuffer CreateIndexBuffer( IndexType type, int numIndices, BufferUsage usage,
															   bool useShadowBuffer )
		{
			var buffer = new GLHardwareIndexBuffer( this, type, numIndices, usage, useShadowBuffer );
			lock ( IndexBuffersMutex )
				indexBuffers.Add( buffer );
			return buffer;
		}

 public ValidityIndex(IndexType indexType)
 {
     IndexType = indexType;
     m_PreviousValue = 0;
     CurrentValue = 0;
     m_IsRising = true;
     m_LocalMaximums = new List<double>();
 }

        public DeleteIndexRequest(string designDoc, string name, IndexType type = IndexType.Json)
        {
            Ensure.That(designDoc, "designDoc").IsNotNullOrWhiteSpace();
            Ensure.That(name, "name").IsNotNullOrWhiteSpace();

            DesignDoc = designDoc;
            Name = name;
            Type = type;
        }

		public override HardwareIndexBuffer CreateIndexBuffer( IndexType type, int numIndices, BufferUsage usage, bool useShadowBuffer )
		{
			var indexBuffer = new GLESHardwareIndexBuffer( this, type, numIndices, usage, true );
			lock ( IndexBuffersMutex )
			{
				indexBuffers.Add( indexBuffer );
			}
			return indexBuffer;
		}

 public Index(DirectoryInfo indexDirectory)
 {
     if (indexDirectory == null)
         throw new ArgumentNullException("indexDirectory", "indexDirectory cannot be null");
     if (!indexDirectory.Exists)
         indexDirectory.Create();
     this.directory = indexDirectory;
     this.structure = IndexLibrary.IndexType.SingleIndex;
 }

        private static IndexType Validate(IndexType type)
        {
#if SILVERLIGHT
            if (type != IndexType.Size16)
                LogManager.Instance.Write("WARNING!!! Requested 32 bit indexes but Reach profile on only allows 16 bit indexes");
            return IndexType.Size16;
#else
            return type;
#endif
        }

        public void createIndex(String indexName, String binName, IndexType indexType)
        {
            // drop index
            client.DropIndex(null, TestQueryEngine.NAMESPACE, SET, indexName);

                Thread.Sleep(150);

            // create index
            IndexTask task = client.CreateIndex(null, TestQueryEngine.NAMESPACE, SET, indexName, binName, indexType, IndexCollectionType.LIST);
            task.Wait();
        }

		/// <summary>
		/// </summary>
		/// <param name="idxType"> </param>
		/// <param name="numIndexes"> </param>
		/// <param name="usage"> </param>
		public GLES2DefaultHardwareIndexBuffer( IndexType idxType, int numIndexes, BufferUsage usage )
			: base( null, idxType, numIndexes, usage, true, false ) // always software, never shadowed
		{
			if ( idxType == IndexType.Size32 )
			{
				throw new AxiomException( "32 bit hardware buffers are not allowed in OpenGL ES." );
			}

			this._data = new byte[ sizeInBytes ];
			this._dataPtr = BufferBase.Wrap( this._data );
		}

 public SqlCreateIndexExpression(string indexName, SqlTableExpression table, bool unique, bool lowercaseIndex, IndexType indexType, bool ifNotExist, IReadOnlyList<SqlIndexedColumnExpression> columns)
     : base(typeof(void))
 {
     this.IndexName = indexName;
     this.Table = table;
     this.Unique = unique;
     this.LowercaseIndex = lowercaseIndex;
     this.IndexType = indexType;
     this.IfNotExist = ifNotExist;
     this.Columns = columns;
 }

 public IList<Record> GetInRange(IndexType type, DateTimeIntervals intervalType, IndexBarInfo barInfo, int startIndex, int count)
 {
     switch (type)
     {
         case IndexType.None:
             break;
         case IndexType.OEE:
             switch (barInfo.Level)
             {
                 case 0:
                     return GetOEEByDateTime(intervalType, startIndex, count);
                 case 1:
                     return GetOEEByMachines(barInfo, startIndex, count);
             }
             break;
         case IndexType.Performance:
             if (barInfo.Level == 0)
             {
                 return GetPerformanceByDateTime(intervalType, startIndex, count);
             }
             switch (barInfo.Filter)
             {
                 case IndexFilter.ByProduct:
                     return GetPerformanceByProducts(barInfo, startIndex, count);
                 case IndexFilter.ByStation:
                     return GetPerformanceByStations(barInfo, startIndex, count);
                 case IndexFilter.ByActivity:
                     return GetPerformanceByActivities(barInfo, startIndex, count);
                 case IndexFilter.ByOperator:
                     return GetPerformanceByOperators(barInfo, startIndex, count);
                 default:
                     return new List<Record>();
             }
         case IndexType.InternalPPM:
             switch (barInfo.Level)
             {
                 case 0:
                     return GetPPMByDateTime(intervalType, startIndex, count);
             }
             break;
         case IndexType.RemainingCapacity:
             switch (barInfo.Level)
             {
                 case 0:
                     return GetCapacityByDateTime(intervalType, startIndex, count);
             }
             break;
         default:
             throw new ArgumentOutOfRangeException("type");
     }
     return new List<Record>();
 }

        public IndexTool(UserSettings settings, string filename, IndexType indexType)
            : base()
        {
            try
            {
                this.settings = settings;
                this.filename = filename;
                this.indexType = indexType;

                if (indexType == IndexType.ffmsindex)
                {
                    if (settings.deleteIndex || isOlder(filename + ".ffindex", filename))
                    {
                        if (File.Exists(filename + ".ffindex"))
                        {
                            try
                            {
                                File.Delete(filename + ".ffindex");
                            }
                            catch (Exception)
                            {
                            }
                        }
                    }
                    Path = settings.ffmsindexPath;
                    Parameter = "\"" + filename + "\"";
                }
                else if (indexType == IndexType.dgindex)
                {
                    string output = System.IO.Path.ChangeExtension(filename, "dgi");
                    if (settings.deleteIndex || isOlder(output, filename))
                    {
                        if (File.Exists(output))
                        {
                            try
                            {
                                File.Delete(output);
                            }
                            catch (Exception)
                            {
                            }
                        }
                    }                    
                    Path = settings.dgindexnvPath;
                    Parameter = "-i \"" + filename + "\" -o \"" + output + "\" -e";
                }
            }
            catch (Exception)
            {
            }
        }

 public RunWorkPlan(
     DataSet dataSet,
     Cardinality cardinality,
     IndexType indexType,
     ReservationBufferSize reservationBufferSize,
     CacheSize cacheSize,
     Drive drive,
     CacheType cacheType,
     WorkPlan workPlan)
     : base(dataSet, cardinality, indexType, reservationBufferSize, cacheType, cacheSize)
 {
     Drive = drive;
     WorkPlan = workPlan;
 }

 public Experiment(
     DataSet dataSet,
     Cardinality cardinality,
     IndexType indexType,
     ReservationBufferSize reservationBufferSize,
     CacheType cacheType,
     CacheSize cacheSize)
 {
     DataSet = dataSet;
     Cardinality = cardinality;
     IndexType = indexType;
     ReservationBufferSize = reservationBufferSize;
     CacheType = cacheType;
     CacheSize = cacheSize;
 }

		unsafe public XnaHardwareIndexBuffer( HardwareBufferManagerBase manager, IndexType type, int numIndices, BufferUsage usage, XFG.GraphicsDevice device, bool useSystemMemory, bool useShadowBuffer )
			: base( manager, type, numIndices, usage, useSystemMemory, useShadowBuffer )
		{
			_bufferType = ( type == IndexType.Size16 ) ? XFG.IndexElementSize.SixteenBits : XFG.IndexElementSize.ThirtyTwoBits;

			// create the buffer
            if (usage == BufferUsage.Dynamic || usage == BufferUsage.DynamicWriteOnly)
            {
                _xnaBuffer = new XFG.IndexBuffer(device, _bufferType, numIndices, XnaHelper.Convert(usage));
            }
            else 
                _xnaBuffer = new XFG.IndexBuffer(device, _bufferType, numIndices, XFG.BufferUsage.None);

			_bufferBytes = new byte[ sizeInBytes ];
			_bufferBytes.Initialize();
		}