[
	uuid(12345778-1234-abcd-ef00-0123456789ab),
	version(0.0)
]
interface lsarpc
{
	import "../rpc.idl";

	typedef struct {
		uint32_t length;
		uint16_t impersonation_level;
		uint8_t context_mode;
		uint8_t effective_only;
	} LsarQosInfo;

	typedef struct {
		uint32_t length;
		uint8_t *root_directory;
		unicode_string *object_name;
		uint32_t attributes;
		uint32_t security_descriptor;

            return 0;
        }

        writeInt2( NET_SHARE_ENUM, dst, dstIndex );
        dstIndex += 2;
        System.arraycopy( descr, 0, dst, dstIndex, descr.length );
        dstIndex += descr.length;
        writeInt2( 0x0001, dst, dstIndex );
        dstIndex += 2;
        writeInt2( maxDataCount, dst, dstIndex );
        dstIndex += 2;

        return dstIndex - start;
    }

import java.util.Random;

/**
 * Benchmarks for comparing the various {@link HashFunction functions} that we provide.
 *
 * <p>Parameters for the benchmark are:
 *
 * <ul>
 *   <li>size: The length of the byte array to hash.
 *   <li>hashFunctionEnum: The {@link HashFunction} to use for hashing.
 * </ul>
 *
 * @author Kurt Alfred Kluever
 */
public class HashFunctionBenchmark {

  }

  private static void lockAndUnlockNested(Lock[] locks, int reps) {
    for (int i = 0; i < reps; i++) {
      for (int j = 0; j < locks.length; j++) {
        locks[j].lock();
      }
      for (int j = locks.length - 1; j >= 0; j--) {
        locks[j].unlock();
      }
    }
  }

  force-attribute-nesting: 0
  force-element-nesting: 0
  force-pseudo-nesting: 0
  function-name-format: 2
  hex-length: 0
  hex-notation: 2
  id-name-format: 2
  indentation:
    - 2
    -
      size: 4
  leading-zero:
    - 2
    -
      include: false
  max-file-line-count: 0
  max-file-length: 0
  mixins-before-declarations: 2
  no-attribute-selectors: 0
  no-color-hex: 0
  no-color-keywords: 0

[
	uuid(12345778-1234-abcd-ef00-0123456789ab),
	version(0.0)
]
interface lsarpc
{
	import "../rpc.idl";

	typedef struct {
		uint32_t length;
		uint16_t impersonation_level;
		uint8_t context_mode;
		uint8_t effective_only;
	} LsarQosInfo;

	typedef struct {
		uint32_t length;
		uint8_t *root_directory;
		unicode_string *object_name;
		uint32_t attributes;
		uint32_t security_descriptor;

    return asList(contents).iterator();
  }

  @Override
  public @Nullable Object[] toArray() {
    @Nullable Object[] result = new @Nullable Object[contents.length];
    arraycopy(contents, 0, result, 0, contents.length);
    return result;
  }

  /*
   * a "type A" unmodifiable collection freaks out proactively, even if there
   * wasn't going to be any actual work to do anyway
   */

        sb.append(dm).append(term);
        sb.append(dm).append(updatedBy);
        sb.append(dm).append(updatedTime);
        sb.append(dm).append(virtualHost);
        if (sb.length() > dm.length()) {
            sb.delete(0, dm.length());
        }
        sb.insert(0, "{").append("}");
        return sb.toString();
    }

    // ===================================================================================

        StringBuilder buffer = new StringBuilder(256);

        if (!getSource().isEmpty()) {
            if (buffer.length() > 0) {
                buffer.append(", ");
            }
            buffer.append(getSource());
        }

        if (getLineNumber() > 0) {
            if (buffer.length() > 0) {
                buffer.append(", ");
            }
            buffer.append("line ").append(getLineNumber());

            final String[] encodingPairs = value.split(",");
            for (final String pair : encodingPairs) {
                final String[] encInfos = pair.trim().split(":");
                if (encInfos.length == 2) {
                    encodingMap.put("/" + encInfos[0] + "/", encInfos[1]);
                }
            }
        }
    }

    @Override