C# IndexType类代码示例

        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;
 }