/*
    * Copyright (C) 2007, Robin Rosenberg <robin.rosenberg@dewire.com>
    * Copyright (C) 2006-2008, Shawn O. Pearce <spearce@spearce.org> and others
    *
    * This program and the accompanying materials are made available under the
    * terms of the Eclipse Distribution License v. 1.0 which is available at
    * https://www.eclipse.org/org/documents/edl-v10.php.
    *
    * SPDX-License-Identifier: BSD-3-Clause
   */
  
  package org.eclipse.jgit.lib;
  
  import java.io.IOException;
  import java.io.OutputStream;
  
  /**
   * Constants describing various file modes recognized by GIT.
   * <p>
   * GIT uses a subset of the available UNIX file permission bits. The
   * <code>FileMode</code> class provides access to constants defining the modes
   * actually used by GIT.
   * </p>
   */
  public abstract class FileMode {
  	/**
  	 * Mask to apply to a file mode to obtain its type bits.
  	 *
  	 * @see #TYPE_TREE
  	 * @see #TYPE_SYMLINK
  	 * @see #TYPE_FILE
  	 * @see #TYPE_GITLINK
  	 * @see #TYPE_MISSING
  	 */
  	public static final int TYPE_MASK = 0170000;
  
  	/** Bit pattern for {@link #TYPE_MASK} matching {@link #TREE}. */
  	public static final int TYPE_TREE = 0040000;
  
  	/** Bit pattern for {@link #TYPE_MASK} matching {@link #SYMLINK}. */
  	public static final int TYPE_SYMLINK = 0120000;
  
  	/** Bit pattern for {@link #TYPE_MASK} matching {@link #REGULAR_FILE}. */
  	public static final int TYPE_FILE = 0100000;
  
  	/** Bit pattern for {@link #TYPE_MASK} matching {@link #GITLINK}. */
  	public static final int TYPE_GITLINK = 0160000;
  
  	/** Bit pattern for {@link #TYPE_MASK} matching {@link #MISSING}. */
  	public static final int TYPE_MISSING = 0000000;
  
  	/**
  	 * Mode indicating an entry is a tree (aka directory).
  	 */
  	public static final FileModee.html#FileMode">FileMode TREE = new FileMode(TYPE_TREE,
  			Constants.OBJ_TREE) {
  		@Override
  		@SuppressWarnings("NonOverridingEquals")
  		public boolean equals(int modeBits) {
  			return (modeBits & TYPE_MASK) == TYPE_TREE;
  		}
  	};
  
  	/** Mode indicating an entry is a symbolic link. */
  	public static final FileModetml#FileMode">FileMode SYMLINK = new FileMode(TYPE_SYMLINK,
  			Constants.OBJ_BLOB) {
  		@Override
  		@SuppressWarnings("NonOverridingEquals")
  		public boolean equals(int modeBits) {
  			return (modeBits & TYPE_MASK) == TYPE_SYMLINK;
  		}
  	};
  
  	/** Mode indicating an entry is a non-executable file. */
  	public static final FileModeileMode">FileMode REGULAR_FILE = new FileMode(0100644,
  			Constants.OBJ_BLOB) {
  		@Override
  		@SuppressWarnings("NonOverridingEquals")
  		public boolean equals(int modeBits) {
  			return (modeBits & TYPE_MASK) == TYPE_FILE && (modeBits & 0111) == 0;
  		}
  	};
  
  	/** Mode indicating an entry is an executable file. */
  	public static final FileModeMode">FileMode EXECUTABLE_FILE = new FileMode(0100755,
  			Constants.OBJ_BLOB) {
  		@Override
  		@SuppressWarnings("NonOverridingEquals")
  		public boolean equals(int modeBits) {
  			return (modeBits & TYPE_MASK) == TYPE_FILE && (modeBits & 0111) != 0;
  		}
  	};
  
  	/** Mode indicating an entry is a submodule commit in another repository. */
  	public static final FileModetml#FileMode">FileMode GITLINK = new FileMode(TYPE_GITLINK,
  			Constants.OBJ_COMMIT) {
  		@Override
  		@SuppressWarnings("NonOverridingEquals")
  		public boolean equals(int modeBits) {
 			return (modeBits & TYPE_MASK) == TYPE_GITLINK;
 		}
 	};
 
 	/** Mode indicating an entry is missing during parallel walks. */
 	public static final FileModetml#FileMode">FileMode MISSING = new FileMode(TYPE_MISSING,
 			Constants.OBJ_BAD) {
 		@Override
 		@SuppressWarnings("NonOverridingEquals")
 		public boolean equals(int modeBits) {
 			return modeBits == 0;
 		}
 	};
 
 	/**
 	 * Convert a set of mode bits into a FileMode enumerated value.
 	 *
 	 * @param bits
 	 *            the mode bits the caller has somehow obtained.
 	 * @return the FileMode instance that represents the given bits.
 	 */
 	public static final FileMode fromBits(int bits) {
 		switch (bits & TYPE_MASK) {
 		case TYPE_MISSING:
 			if (bits == 0)
 				return MISSING;
 			break;
 		case TYPE_TREE:
 			return TREE;
 		case TYPE_FILE:
 			if ((bits & 0111) != 0)
 				return EXECUTABLE_FILE;
 			return REGULAR_FILE;
 		case TYPE_SYMLINK:
 			return SYMLINK;
 		case TYPE_GITLINK:
 			return GITLINK;
 		}
 
 		return new FileMode(bits, Constants.OBJ_BAD) {
 			@Override
 			@SuppressWarnings("NonOverridingEquals")
 			public boolean equals(int a) {
 				return bits == a;
 			}
 		};
 	}
 
 	private final byte[] octalBytes;
 
 	private final int modeBits;
 
 	private final int objectType;
 
 	private FileMode(int mode, int expType) {
 		modeBits = mode;
 		objectType = expType;
 		if (mode != 0) {
 			final byte[] tmp = new byte[10];
 			int p = tmp.length;
 
 			while (mode != 0) {
 				tmp[--p] = (byte) ('0' + (mode & 07));
 				mode >>= 3;
 			}
 
 			octalBytes = new byte[tmp.length - p];
 			for (int k = 0; k < octalBytes.length; k++) {
 				octalBytes[k] = tmp[p + k];
 			}
 		} else {
 			octalBytes = new byte[] { '0' };
 		}
 	}
 
 	/**
 	 * Test a file mode for equality with this
 	 * {@link org.eclipse.jgit.lib.FileMode} object.
 	 *
 	 * @param modebits
 	 *            a int.
 	 * @return true if the mode bits represent the same mode as this object
 	 */
 	@SuppressWarnings("NonOverridingEquals")
 	public abstract boolean equals(int modebits);
 
 	/**
 	 * Copy this mode as a sequence of octal US-ASCII bytes.
 	 * <p>
 	 * The mode is copied as a sequence of octal digits using the US-ASCII
 	 * character encoding. The sequence does not use a leading '0' prefix to
 	 * indicate octal notation. This method is suitable for generation of a mode
 	 * string within a GIT tree object.
 	 * </p>
 	 *
 	 * @param os
 	 *            stream to copy the mode to.
 	 * @throws java.io.IOException
 	 *             the stream encountered an error during the copy.
 	 */
 	public void copyTo(OutputStream os) throws IOException {
 		os.write(octalBytes);
 	}
 
 	/**
 	 * Copy this mode as a sequence of octal US-ASCII bytes.
 	 *
 	 * The mode is copied as a sequence of octal digits using the US-ASCII
 	 * character encoding. The sequence does not use a leading '0' prefix to
 	 * indicate octal notation. This method is suitable for generation of a mode
 	 * string within a GIT tree object.
 	 *
 	 * @param buf
 	 *            buffer to copy the mode to.
 	 * @param ptr
 	 *            position within {@code buf} for first digit.
 	 */
 	public void copyTo(byte[] buf, int ptr) {
 		System.arraycopy(octalBytes, 0, buf, ptr, octalBytes.length);
 	}
 
 	/**
 	 * Copy the number of bytes written by {@link #copyTo(OutputStream)}.
 	 *
 	 * @return the number of bytes written by {@link #copyTo(OutputStream)}.
 	 */
 	public int copyToLength() {
 		return octalBytes.length;
 	}
 
 	/**
 	 * Get the object type that should appear for this type of mode.
 	 * <p>
 	 * See the object type constants in {@link org.eclipse.jgit.lib.Constants}.
 	 *
 	 * @return one of the well known object type constants.
 	 */
 	public int getObjectType() {
 		return objectType;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 * <p>
 	 * Format this mode as an octal string (for debugging only).
 	 */
 	@Override
 	public String toString() {
 		return Integer.toOctalString(modeBits);
 	}
 
 	/**
 	 * Get the mode bits as an integer.
 	 *
 	 * @return The mode bits as an integer.
 	 */
 	public int getBits() {
 		return modeBits;
 	}
 }