public bool IsTokenExists(int token)
		{
			int type = MetadataToken.GetType(token);
			int tableType = MetadataToken.GetTableTypeByTokenType(type);
			if (tableType < 0 || tableType >= MetadataConstants.TableCount)
				return false;

			int rowCount = _tables[tableType].RowCount;

			int rid = MetadataToken.GetRID(token);
			if (rid < 1 || rid > rowCount)
				return false;

			return true;
		}
        public bool IsTokenExists(int token)
        {
            int type      = MetadataToken.GetType(token);
            int tableType = MetadataToken.GetTableTypeByTokenType(type);

            if (tableType < 0 || tableType >= MetadataConstants.TableCount)
            {
                return(false);
            }

            var table = Tables[tableType];

            int rid = MetadataToken.GetRID(token);

            if (!table.Exists(rid))
            {
                return(false);
            }

            return(true);
        }
        public int[][] Sort()
        {
            int[] classLayoutMap     = SortClassLayoutTable();
            int[] constantMap        = SortConstantTable();
            int[] fieldLayoutMap     = SortFieldLayoutTable();
            int[] fieldMarshalMap    = SortFieldMarshalTable();
            int[] fieldRVAMap        = SortFieldRVATable();
            int[] propertyMap        = SortPropertyMapTable();
            int[] eventMap           = SortEventMapTable();
            int[] implMapMap         = SortImplMapTable();
            int[] interfaceImplMap   = SortInterfaceImplTable();
            int[] methodImplMap      = SortMethodImplTable();
            int[] methodSemanticsMap = SortMethodSemanticsTable();
            int[] nestedClassMap     = SortNestedClassTable();
            int[] declSecurityMap    = SortDeclSecurityTable();
            int[] genericParamMap    = SortGenericParamTable();

            // Update GenericParamConstraint table
            if (genericParamMap != null)
            {
                int   count  = _genericParamConstraintTable.Count;
                int[] owners = new int[count];
                _genericParamConstraintTable.Get(1, 0, count, owners);

                for (int i = 0; i < count; i++)
                {
                    owners[i] = genericParamMap[owners[i] - 1];
                }

                _genericParamConstraintTable.Update(1, 0, count, owners);
            }

            int[] genericParamConstraintMap = SortGenericParamConstraintTable();

            // Update CustomAttribute table
            {
                int   count   = _customAttributeTable.Count;
                int[] parents = new int[count];
                _customAttributeTable.Get(1, 0, count, parents);

                for (int i = 0; i < count; i++)
                {
                    int  parentToken = MetadataToken.DecompressHasCustomAttribute(parents[i]);
                    int  parentRID   = MetadataToken.GetRID(parentToken);
                    int  parentType  = MetadataToken.GetType(parentToken);
                    bool changed     = false;
                    switch (parentType)
                    {
                    case MetadataTokenType.GenericParam:
                    {
                        if (genericParamMap != null)
                        {
                            parentRID = genericParamMap[parentRID - 1];
                            changed   = true;
                        }
                    }
                    break;

                    case MetadataTokenType.GenericParamConstraint:
                    {
                        if (genericParamConstraintMap != null)
                        {
                            parentRID = genericParamConstraintMap[parentRID - 1];
                            changed   = true;
                        }
                    }
                    break;

                    case MetadataTokenType.InterfaceImpl:
                    {
                        if (interfaceImplMap != null)
                        {
                            parentRID = interfaceImplMap[parentRID - 1];
                            changed   = true;
                        }
                    }
                    break;

                    case MetadataTokenType.DeclSecurity:
                    {
                        if (declSecurityMap != null)
                        {
                            parentRID = declSecurityMap[parentRID - 1];
                            changed   = true;
                        }
                    }
                    break;
                    }

                    if (changed)
                    {
                        parents[i] = MetadataToken.CompressHasCustomAttribute(MetadataToken.Get(parentType, parentRID));
                    }
                }

                _customAttributeTable.Update(1, 0, count, parents);
            }

            int[] customAttributeMap = SortCustomAttributeTable();

            return(new int[][]
            {
                classLayoutMap,
                constantMap,
                fieldLayoutMap,
                fieldMarshalMap,
                fieldRVAMap,
                propertyMap,
                eventMap,
                genericParamMap,
                genericParamConstraintMap,
                implMapMap,
                interfaceImplMap,
                methodImplMap,
                methodSemanticsMap,
                nestedClassMap,
                declSecurityMap,
                customAttributeMap,
            });
        }