/// <summary>
        /// This method is used to seek row for a table
        /// </summary>
        /// <param name="origin">Identify the origin position</param>
        /// <param name="forwardSeek">Identify whether to seek row forward</param>
        /// <param name="wantRowMovedCountout">Identify whether to return the actual moved row number</param>
        /// <param name="enoughRow">Identify whether there is enough row to seek</param>
        /// <returns>Table ROP return value</returns>
        public TableRopReturnValues RopSeekRow(BookmarkType origin, bool forwardSeek, bool wantRowMovedCountout, bool enoughRow)
        {
            uint tempRowCount = this.GetRowsCount(forwardSeek); // Gets the number of rows from current location to begin row or last row.

            RopSeekRowRequest seekRowRequest = new RopSeekRowRequest();
            RopSeekRowResponse seekRowResponse;

            seekRowRequest.RopId = 0x18;
            seekRowRequest.LogonId = 0x00;
            seekRowRequest.InputHandleIndex = 0x00;
            seekRowRequest.Origin = (byte)origin;

            if (origin == BookmarkType.BOOKMARK_BEGINNING)
            {
                if (forwardSeek)
                {
                    if (enoughRow)
                    {
                        seekRowRequest.RowCount = (int)this.rowCount;
                    }
                    else
                    {
                        // Identify there is not enough row to forward seek.
                        seekRowRequest.RowCount = (int)(this.rowCount + 1);
                    }
                }
                else
                {
                    if (enoughRow)
                    {
                        seekRowRequest.RowCount = 0;
                    }
                    else
                    {
                        seekRowRequest.RowCount = -1; // Identify there is not enough row to backward seek when the location is beginning.
                    }
                }
            }
            else if (origin == BookmarkType.BOOKMARK_END)
            {
                if (forwardSeek)
                {
                    if (enoughRow)
                    {
                        seekRowRequest.RowCount = 0;
                    }
                    else
                    {
                        seekRowRequest.RowCount = 1;
                    }
                }
                else
                {
                    if (enoughRow)
                    {
                        seekRowRequest.RowCount = -(int)this.rowCount;
                    }
                    else
                    {
                        seekRowRequest.RowCount = -(int)(this.rowCount + 1);
                    }
                }
            }
            else
            {
                if (forwardSeek)
                {
                    if (enoughRow)
                    {
                        seekRowRequest.RowCount = (int)tempRowCount;
                    }
                    else
                    {
                        seekRowRequest.RowCount = (int)(tempRowCount + 1);
                    }
                }
                else
                {
                    if (enoughRow)
                    {
                        seekRowRequest.RowCount = -(int)tempRowCount;
                    }
                    else
                    {
                        seekRowRequest.RowCount = -(int)(tempRowCount + 1);
                    }
                }
            }

            seekRowRequest.WantRowMovedCount = Convert.ToByte(wantRowMovedCountout);

            this.rowCountInSeekRowRequest = seekRowRequest.RowCount;

            this.DoSingleCallROP(seekRowRequest, this.tableHandle, ref this.response, ref this.rawData);
            seekRowResponse = (RopSeekRowResponse)this.response;

            this.ropType = TableRopType.MOVECURSOR;
            bool hasSoughtLess = false;
            bool isActualRowsCount = false;
            if (wantRowMovedCountout)
            {
                hasSoughtLess = Convert.ToBoolean(seekRowResponse.HasSoughtLess);
                if (origin == BookmarkType.BOOKMARK_BEGINNING)
                {
                    if (forwardSeek)
                    {
                        isActualRowsCount = seekRowResponse.RowsSought == this.rowCount;
                    }
                    else
                    {
                        isActualRowsCount = seekRowResponse.RowsSought == 0;
                    }
                }

                if (origin == BookmarkType.BOOKMARK_END)
                {
                    if (forwardSeek)
                    {
                        isActualRowsCount = seekRowResponse.RowsSought == 0;
                    }
                    else
                    {
                        isActualRowsCount = seekRowResponse.RowsSought == -this.rowCount;
                    }
                }

                if (origin == BookmarkType.BOOKMARK_CURRENT)
                {
                    isActualRowsCount = System.Math.Abs(seekRowResponse.RowsSought) == tempRowCount;
                }
            }
            else
            {
                hasSoughtLess = true;
                isActualRowsCount = true;
            }

            if (this.RopSeekRowResponse != null)
            {
                this.RopSeekRowResponse(wantRowMovedCountout, enoughRow, hasSoughtLess, isActualRowsCount);
            }

            return (TableRopReturnValues)seekRowResponse.ReturnValue;
        }