C# IByteReader.GetNumberOfBytes方法代码示例

		//public int getMaxOffset() { return MaxOffset; }



		/**
		 * checks whether the binary file specified by targetFile is compliant
		 * with this byte sequence
		 *
		 * @param targetFile   The binary file to be identified
		 */
		public bool isFileCompliant(IByteReader targetFile)
		{
			//System.out.println("Looking at new byte sequence with reference "+Reference);
			//initialise variables and start with the file marker at the beginning of the file
			bool isCompliant = true;
			bool reverseOrder = (string.Compare(getReference(), "EOFoffset", true) == 0) ? true : false; //(getReference().equalsIgnoreCase("EOFoffset")) ? true : false;
			int ssLoopStart = reverseOrder ? getNumSubSequences() - 1 : 0;
			int ssLoopEnd = reverseOrder ? -1 : getNumSubSequences();
			int searchDirection = reverseOrder ? -1 : 1;
			if (reverseOrder)
			{
				targetFile.SetFileMarker(targetFile.GetNumberOfBytes() - 1L);
			}
			else
			{
				targetFile.SetFileMarker(0L);
			}

			//check whether each subsequence in turn is compliant
			for (int iSS = ssLoopStart; (searchDirection * iSS < searchDirection * ssLoopEnd) & isCompliant; iSS += searchDirection)
			{
				bool isFixedStart = ((string.Compare(getReference(), "EOFoffset", true) == 0) || (string.Compare(getReference(), "BOFoffset", true) == 0)) ? true : false; //getReference().equalsIgnoreCase("EOFoffset") || getReference().equalsIgnoreCase("BOFoffset");
				if ((iSS == ssLoopStart) && (isFixedStart))
				{
					isCompliant = getSubSequence(iSS).isFoundAtStartOfFile(targetFile, reverseOrder, bigEndian); //, MaxOffset);
				}
				else
				{
					isCompliant = getSubSequence(iSS).isFoundAfterFileMarker(targetFile, reverseOrder, bigEndian);
				}
			}
			return isCompliant;
		}

		/**
		 * Searches for this subsequence at the start of the current file.
		 * Moves the file marker to the end of this subsequence.
		 *
		 * @param targetFile   the binary file to be identified
		 * @param reverseOrder  true if file is being searched from right to left
		 * @param bigEndian    True iff our parent signature is big-endian
		 */
		public bool isFoundAtStartOfFile(IByteReader targetFile, bool reverseOrder, bool bigEndian)
		{
			int searchDirection = reverseOrder ? -1 : 1;
			int minSeqOffset = this.getMinSeqOffset();
			int maxSeqOffset = this.getMaxSeqOffset();
			long[] startPosInFile = new long[1];
			startPosInFile[0] = reverseOrder ? targetFile.GetNumberOfBytes() - minSeqOffset - 1 : minSeqOffset;
			bool subseqFound = true;
			bool leftFrag = true;

			if (reverseOrder) { leftFrag = false; }

			//match intial fragment
			if (reverseOrder)
			{
				startPosInFile = bytePosForRightFragments(targetFile, 0, startPosInFile[0], -1, (maxSeqOffset - minSeqOffset), bigEndian);
			}
			else
			{
				startPosInFile = bytePosForLeftFragments(targetFile, startPosInFile[0], targetFile.GetNumberOfBytes() - 1, 1, (maxSeqOffset - minSeqOffset), bigEndian);
			}
			int numOptions = startPosInFile.Length;
			if (numOptions == 0)
			{
				subseqFound = false;
			}
			else
			{
				for (int i = 0; i < numOptions; i++)
				{
					startPosInFile[i] += (long)searchDirection;
				}
			}

			//match main sequence
			if (subseqFound)
			{
				//move startPosInFile according to min offset of last fragment looked at
				int minOffset = 0;
				int maxOffset = 0;
				if (this.getNumFragmentPositions(leftFrag) > 0)
				{
					minOffset = this.getFragment(leftFrag, 1, 0).getMinOffset();
					maxOffset = this.getFragment(leftFrag, 1, 0).getMaxOffset();
					for (int i = 0; i < numOptions; i++)
					{
						startPosInFile[i] += (long)(minOffset * searchDirection);
					}
				}

				//add new possible values for startPosInFile to allow for difference between maxOffset and minOffset
				int offsetRange = maxOffset - minOffset;
				if (offsetRange > 0)
				{
					long[] newStartPosInFile = new long[numOptions * (offsetRange + 1)];
					for (int i = 0; i <= offsetRange; i++)
					{
						for (int j = 0; j < numOptions; j++)
						{
							newStartPosInFile[j + i * numOptions] = startPosInFile[j] + (long)(i * searchDirection);
						}
					}
					//Arrays.sort(newStartPosInFile);
					System.Array.Sort(newStartPosInFile);
					
					int newNumOptions = 1;
					for (int i = 1; i < numOptions * (offsetRange + 1); i++)
					{
						if (newStartPosInFile[i] > newStartPosInFile[newNumOptions - 1])
						{
							newStartPosInFile[newNumOptions] = newStartPosInFile[i];
							newNumOptions++;
						}
					}
					//now copy these back to the startPosInFile array (sorted in searchDirection)
					numOptions = newNumOptions;
					if (searchDirection > 1)
					{
						System.Array.Copy(newStartPosInFile, 0, startPosInFile, 0, numOptions);						
					}
					else
					{
						//reverse order copy
						for (int i = 0; i < numOptions; i++)
						{
							startPosInFile[i] = newStartPosInFile[numOptions - 1 - i];
						}
					}

				}

				//check that the end of the file is not going to be reached
//.........这里部分代码省略.........

		/**
		 * Searches for this subsequence after the current file marker position in the file.
		 * Moves the file marker to the end of this subsequence.
		 *
		 * @param targetFile   the binary file to be identified
		 * @param reverseOrder  true if file is being searched from right to left
		 * @param bigEndian    True iff our parent signature is big-endian
		 */
		public bool isFoundAfterFileMarker(IByteReader targetFile, bool reverseOrder, bool bigEndian) {
        
        int searchDirection = reverseOrder?-1:1;
        //get the current file marker
        long startPosInFile = targetFile.GetFileMarker();
        //Add the minimum offset before start of sequence and update the file marker accordingly
        startPosInFile = startPosInFile + (long)(searchDirection * this.getMinSeqOffset());
        if (targetFile.GetNumberOfBytes() < startPosInFile)
        {
            // We're looking for a sequence of bytes at an offset which is longer than the file itself
            return false;
        }
        targetFile.SetFileMarker(startPosInFile);
        //start searching for main sequence after the minimum length of the relevant fragments
        startPosInFile = startPosInFile + (long)(searchDirection * this.getMinFragLength());
        long numFileBytes = reverseOrder?(startPosInFile+1):(targetFile.GetNumberOfBytes() - startPosInFile);
        int numSeqBytes = this.getNumBytes();
        bool subSeqFound = false;
        bool endOfFileReached = false;
        while((!subSeqFound) & (!endOfFileReached)) {
            if((long)numSeqBytes> numFileBytes) {
                endOfFileReached = true;
            } else {
                //compare sequence with file contents directly at fileMarker position
                bool missMatchFound = false;
                int byteLoopStart = reverseOrder?numSeqBytes-1:0;
                int byteLoopEnd   = reverseOrder?0:numSeqBytes-1;
                long tempFileMarker = startPosInFile;
                for(int iByte=byteLoopStart; (!missMatchFound) && (iByte<=numSeqBytes-1) && (iByte>=0); iByte+=searchDirection) {
                    missMatchFound = (byteSequence[iByte] != targetFile.GetByte(tempFileMarker));
                    if(!missMatchFound && showProgress) { System.Console.WriteLine("FLOATING SEQ: A match was found for " + this.getByte(iByte).ToString()); }
                    tempFileMarker+=searchDirection;
                }
                if(!missMatchFound) { //subsequence was found at position fileMarker in the file
                    //Now search for fragments between original fileMarker and startPosInFile
                    if(reverseOrder) {
                        long rightFragEnd;
                        long[] rightFragEndArray = bytePosForRightFragments(targetFile, startPosInFile+1, targetFile.GetFileMarker(), 1, 0, bigEndian);
                        if(rightFragEndArray.Length == 0) {
                            missMatchFound = true;
                        } else {
                            rightFragEnd = rightFragEndArray[0];
                            long leftFragEnd;
                            long[] leftFragEndArray = bytePosForLeftFragments(targetFile, 0, startPosInFile - numSeqBytes, -1, 0, bigEndian);
                            if(leftFragEndArray.Length == 0) {
                                missMatchFound = true;
                            } else {
                                leftFragEnd = leftFragEndArray[0];
                                targetFile.SetFileMarker(leftFragEnd-1L);
                                subSeqFound = true;
                            }
                        }
                        
                    } else {  //search is in forward direction
                        long leftFragEnd;
                        long[] leftFragEndArray = bytePosForLeftFragments(targetFile, targetFile.GetFileMarker(), startPosInFile-1L, -1, 0, bigEndian);
                        if(leftFragEndArray.Length == 0) {
                            missMatchFound = true;
                        } else {
                            leftFragEnd = leftFragEndArray[0];
                            long rightFragEnd;
                            long[] rightFragEndArray = bytePosForRightFragments(targetFile, startPosInFile + numSeqBytes, targetFile.GetNumberOfBytes()-1L, 1, 0, bigEndian);
                            if(rightFragEndArray.Length == 0) {
                                missMatchFound = true;
                            } else {
                                rightFragEnd = rightFragEndArray[0];
                                targetFile.SetFileMarker(rightFragEnd+1L);
                                subSeqFound = true;
                            }
                        }
                    }
                    
                }
                if(missMatchFound) {
                    if (startPosInFile+(long)(searchDirection*numSeqBytes)>=targetFile.GetNumberOfBytes()) {
                        endOfFileReached = true;
                    } else {
                        long numShiftBytes = this.getShift(targetFile.GetByte(startPosInFile+(long)(searchDirection*numSeqBytes))); //reverseOrder?-1:1;   // add shift function for the byte at [fileMarker+(searchDirection*numSeqBytes)] in file
                        numFileBytes -= (numShiftBytes>0)?numShiftBytes:-numShiftBytes;
                        startPosInFile += numShiftBytes;
                        
                        if((startPosInFile<0L) || (startPosInFile>=targetFile.GetNumberOfBytes())) {
                            endOfFileReached = true;
                        }
                    }
                }
            }
        }
        return subSeqFound;
    }