text,length,is_long_context,metric_val,label_metric
"/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2018, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */

#include ""math-precomp.h""  // Precompiled headers

#include <mrpt/math/fourier.h>
#include <algorithm>
#include <mrpt/core/bits_math.h>
#include <cmath>

using namespace mrpt;
using namespace std;
using namespace mrpt::math;

// Next we declare some auxiliary functions:
namespace mrpt::math
{
// Replaces data[1..2*nn] by its discrete Fourier transform, if isign is input
// as 1; or replaces
// data[1..2*nn] by nn times its inverse discrete Fourier transform, if isign is
// input as -1.
// data is a complex array of length nn or, equivalently, a real array of length
// 2*nn. nn MUST
// be an integer power of 2 (this is not checked for!).
static void four1(float data[], unsigned long nn, int isign)
{
	unsigned long n, mmax, m, j, i;
	double wtemp, wr, wpr, wpi, wi,
		theta;  // Double precision for the trigonometric recurrences.
	float tempr, tempi;

	n = nn << 1;
	j = 1;

	for (i = 1; i < n;
		 i += 2)  // This is the bit-reversal section of the routine.
	{
		if (j > i)
		{
			std::swap(data[j], data[i]);  // Exchange the two complex numbers.
			std::swap(data[j + 1], data[i + 1]);
		}
		m = nn;
		while (m >= 2 && j > m)
		{
			j -= m;
			m >>= 1;
		}
		j += m;
	}
	// Here begins the Danielson-Lanczos section of the routine.
	mmax = 2;
	while (n > mmax)  // Outer loop executed log2 nn times.
	{
		unsigned long istep = mmax << 1;
		theta = isign * (6.28318530717959 /
						 mmax);  // Initialize the trigonometric recurrence.
		wtemp = sin(0.5 * theta);
		wpr = -2.0 * wtemp * wtemp;
		wpi = sin(theta);
		wr = 1.0;
		wi = 0.0;
		for (m = 1; m < mmax; m += 2)  // Here are the two nested inner loops.
		{
			for (i = m; i <= n; i += istep)
			{
				j = i + mmax;  // This is the Danielson-Lanczos formula:
				tempr = (float)(wr * data[j] - wi * data[j + 1]);
				tempi = (float)(wr * data[j + 1] + wi * data[j]);
				data[j] = data[i] - tempr;
				data[j + 1] = data[i + 1] - tempi;
				data[i] += tempr;
				data[i + 1] += tempi;
			}
			wr = (wtemp = wr) * wpr - wi * wpi +
				 wr;  // Trigonometric recurrence.
			wi = wi * wpr + wtemp * wpi + wi;
		}
		mmax = istep;
	}
}

// Calculates the Fourier transform of a set of n real-valued data points.
// Replaces this data (which
// is stored in array data[1..n]) by the positive frequency half of its complex
// Fourier transform.
// The real-valued first and last components of the complex transform are
// returned as elements
// data[1] and data[2], respectively. n must be a power of 2. This routine also
// calculates the
// inverse transform of a complex data array if it is the transform of real
// data. (Result in this case
// must be multiplied by 2/n.)
static void realft(float data[], unsigned long n)
{
	unsigned long i, i1, i2, i3, i4, np3;
	float c1 = 0.5, c2, h1r, h1i, h2r, h2i;
	double wr, wi, wpr, wpi, wtemp,
		theta;  // Double precision for the trigonometric recurrences.
	theta = 3.141592653589793 / (double)(n >> 1);  // Initialize the recurrence.

	c2 = -0.5;
	four1(data, n >> 1, 1);  // The forward transform is here.

	wtemp = sin(0.5 * theta);
	wpr = -2.0 * wtemp * wtemp;
	wpi = sin(theta);
	wr = 1.0 + wpr;
	wi = wpi;
	np3 = n + 3;
	for (i = 2; i <= (n >> 2); i++)  // Case i=1 done separately below.
	{
		i4 = 1 + (i3 = np3 - (i2 = 1 + (i1 = i + i - 1)));
		h1r = c1 * (data[i1] + data[i3]);  // The two separate transforms are
		// separated out of data.
		h1i = c1 * (data[i2] - data[i4]);
		h2r = -c2 * (data[i2] + data[i4]);
		h2i = c2 * (data[i1] - data[i3]);
		data[i1] =
			(float)(h1r + wr * h2r - wi * h2i);  // Here they are recombined to
		// form the true transform of
		// the original real data.
		data[i2] = (float)(h1i + wr * h2i + wi * h2r);
		data[i3] = (float)(h1r - wr * h2r + wi * h2i);
		data[i4] = (float)(-h1i + wr * h2i + wi * h2r);
		wr = (wtemp = wr) * wpr - wi * wpi + wr;  // The recurrence.
		wi = wi * wpr + wtemp * wpi + wi;
	}

	data[1] = (h1r = data[1]) + data[2];
	// Squeeze the first and last data together to get them all within the
	// original array.
	data[2] = h1r - data[2];
}

/**
	Copyright(C) 1997 Takuya OOURA (email: ooura@mmm.t.u-tokyo.ac.jp).
	You may use, copy, modify this code for any purpose and
	without fee. You may distribute this ORIGINAL package.
  */
using FFT_TYPE = float;

static void makewt(int nw, int* ip, FFT_TYPE* w);
static void bitrv2(int n, int* ip, FFT_TYPE* a);
static void cftbsub(int n, FFT_TYPE* a, FFT_TYPE* w);
static void cftfsub(int n, FFT_TYPE* a, FFT_TYPE* w);
static void rftfsub(int n, FFT_TYPE* a, int nc, FFT_TYPE* c);
static void rftbsub(int n, FFT_TYPE* a, int nc, FFT_TYPE* c);

static void cftbsub(int n, FFT_TYPE* a, FFT_TYPE* w)
{
	int j, j1, j2, j3, k, k1, ks, l, m;
	FFT_TYPE wk1r, wk1i, wk2r, wk2i, wk3r, wk3i;
	FFT_TYPE x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;

	l = 2;
	while ((l << 1) < n)
	{
		m = l << 2;
		for (j = 0; j <= l - 2; j += 2)
		{
			j1 = j + l;
			j2 = j1 + l;
			j3 = j2 + l;
			x0r = a[j] + a[j1];
			x0i = a[j + 1] + a[j1 + 1];
			x1r = a[j] - a[j1];
			x1i = a[j + 1] - a[j1 + 1];
			x2r = a[j2] + a[j3];
			x2i = a[j2 + 1] + a[j3 + 1];
			x3r = a[j2] - a[j3];
			x3i = a[j2 + 1] - a[j3 + 1];
			a[j] = x0r + x2r;
			a[j + 1] = x0i + x2i;
			a[j2] = x0r - x2r;
			a[j2 + 1] = x0i - x2i;
			a[j1] = x1r - x3i;
			a[j1 + 1] = x1i + x3r;
			a[j3] = x1r + x3i;
			a[j3 + 1] = x1i - x3r;
		}
		if (m < n)
		{
			wk1r = w[2];
			for (j = m; j <= l + m - 2; j += 2)
			{
				j1 = j + l;
				j2 = j1 + l;
				j3 = j2 + l;
				x0r = a[j] + a[j1];
				x0i = a[j + 1] + a[j1 + 1];
				x1r = a[j] - a[j1];
				x1i = a[j + 1] - a[j1 + 1];
				x2r = a[j2] + a[j3];
				x2i = a[j2 + 1] + a[j3 + 1];
				x3r = a[j2] - a[j3];
				x3i = a[j2 + 1] - a[j3 + 1];
				a[j] = x0r + x2r;
				a[j + 1] = x0i + x2i;
				a[j2] = x2i - x0i;
				a[j2 + 1] = x0r - x2r;
				x0r = x1r - x3i;
				x0i = x1i + x3r;
				a[j1] = wk1r * (x0r - x0i);
				a[j1 + 1] = wk1r * (x0r + x0i);
				x0r = x3i + x1r;
				x0i = x3r - x1i;
				a[j3] = wk1r * (x0i - x0r);
				a[j3 + 1] = wk1r * (x0i + x0r);
			}
			k1 = 1;
			ks = -1;
			for (k = (m << 1); k <= n - m; k += m)
			{
				k1++;
				ks = -ks;
				wk1r = w[k1 << 1];
				wk1i = w[(k1 << 1) + 1];
				wk2r = ks * w[k1];
				wk2i = w[k1 + ks];
				wk3r = wk1r - 2 * wk2i * wk1i;
				wk3i = 2 * wk2i * wk1r - wk1i;
				for (j = k; j <= l + k - 2; j += 2)
				{
					j1 = j + l;
					j2 = j1 + l;
					j3 = j2 + l;
					x0r = a[j] + a[j1];
					x0i = a[j + 1] + a[j1 + 1];
					x1r = a[j] - a[j1];
					x1i = a[j + 1] - a[j1 + 1];
					x2r = a[j2] + a[j3];
					x2i = a[j2 + 1] + a[j3 + 1];
					x3r = a[j2] - a[j3];
					x3i = a[j2 + 1] - a[j3 + 1];
					a[j] = x0r + x2r;
					a[j + 1] = x0i + x2i;
					x0r -= x2r;
					x0i -= x2i;
					a[j2] = wk2r * x0r - wk2i * x0i;
					a[j2 + 1] = wk2r * x0i + wk2i * x0r;
					x0r = x1r - x3i;
					x0i = x1i + x3r;
					a[j1] = wk1r * x0r - wk1i * x0i;
					a[j1 + 1] = wk1r * x0i + wk1i * x0r;
					x0r = x1r + x3i;
					x0i = x1i - x3r;
					a[j3] = wk3r * x0r - wk3i * x0i;
					a[j3 + 1] = wk3r * x0i + wk3i * x0r;
				}
			}
		}
		l = m;
	}
	if (l < n)
	{
		for (j = 0; j <= l - 2; j += 2)
		{
			j1 = j + l;
			x0r = a[j] - a[j1];
			x0i = a[j + 1] - a[j1 + 1];
			a[j] += a[j1];
			a[j + 1] += a[j1 + 1];
			a[j1] = x0r;
			a[j1 + 1] = x0i;
		}
	}
}

static void cftfsub(int n, FFT_TYPE* a, FFT_TYPE* w)
{
	int j, j1, j2, j3, k, k1, ks, l, m;
	FFT_TYPE wk1r, wk1i, wk2r, wk2i, wk3r, wk3i;
	FFT_TYPE x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i;

	l = 2;
	while ((l << 1) < n)
	{
		m = l << 2;
		for (j = 0; j <= l - 2; j += 2)
		{
			j1 = j + l;
			j2 = j1 + l;
			j3 = j2 + l;
			x0r = a[j] + a[j1];
			x0i = a[j + 1] + a[j1 + 1];
			x1r = a[j] - a[j1];
			x1i = a[j + 1] - a[j1 + 1];
			x2r = a[j2] + a[j3];
			x2i = a[j2 + 1] + a[j3 + 1];
			x3r = a[j2] - a[j3];
			x3i = a[j2 + 1] - a[j3 + 1];
			a[j] = x0r + x2r;
			a[j + 1] = x0i + x2i;
			a[j2] = x0r - x2r;
			a[j2 + 1] = x0i - x2i;
			a[j1] = x1r + x3i;
			a[j1 + 1] = x1i - x3r;
			a[j3] = x1r - x3i;
			a[j3 + 1] = x1i + x3r;
		}
		if (m < n)
		{
			wk1r = w[2];
			for (j = m; j <= l + m - 2; j += 2)
			{
				j1 = j + l;
				j2 = j1 + l;
				j3 = j2 + l;
				x0r = a[j] + a[j1];
				x0i = a[j + 1] + a[j1 + 1];
				x1r = a[j] - a[j1];
				x1i = a[j + 1] - a[j1 + 1];
				x2r = a[j2] + a[j3];
				x2i = a[j2 + 1] + a[j3 + 1];
				x3r = a[j2] - a[j3];
				x3i = a[j2 + 1] - a[j3 + 1];
				a[j] = x0r + x2r;
				a[j + 1] = x0i + x2i;
				a[j2] = x0i - x2i;
				a[j2 + 1] = x2r - x0r;
				x0r = x1r + x3i;
				x0i = x1i - x3r;
				a[j1] = wk1r * (x0i + x0r);
				a[j1 + 1] = wk1r * (x0i - x0r);
				x0r = x3i - x1r;
				x0i = x3r + x1i;
				a[j3] = wk1r * (x0r + x0i);
				a[j3 + 1] = wk1r * (x0r - x0i);
			}
			k1 = 1;
			ks = -1;
			for (k = (m << 1); k <= n - m; k += m)
			{
				k1++;
				ks = -ks;
				wk1r = w[k1 << 1];
				wk1i = w[(k1 << 1) + 1];
				wk2r = ks * w[k1];
				wk2i = w[k1 + ks];
				wk3r = wk1r - 2 * wk2i * wk1i;
				wk3i = 2 * wk2i * wk1r - wk1i;
				for (j = k; j <= l + k - 2; j += 2)
				{
					j1 = j + l;
					j2 = j1 + l;
					j3 = j2 + l;
					x0r = a[j] + a[j1];
					x0i = a[j + 1] + a[j1 + 1];
					x1r = a[j] - a[j1];
					x1i = a[j + 1] - a[j1 + 1];
					x2r = a[j2] + a[j3];
					x2i = a[j2 + 1] + a[j3 + 1];
					x3r = a[j2] - a[j3];
					x3i = a[j2 + 1] - a[j3 + 1];
					a[j] = x0r + x2r;
					a[j + 1] = x0i + x2i;
					x0r -= x2r;
					x0i -= x2i;
					a[j2] = wk2r * x0r + wk2i * x0i;
					a[j2 + 1] = wk2r * x0i - wk2i * x0r;
					x0r = x1r + x3i;
					x0i = x1i - x3r;
					a[j1] = wk1r * x0r + wk1i * x0i;
					a[j1 + 1] = wk1r * x0i - wk1i * x0r;
					x0r = x1r - x3i;
					x0i = x1i + x3r;
					a[j3] = wk3r * x0r + wk3i * x0i;
					a[j3 + 1] = wk3r * x0i - wk3i * x0r;
				}
			}
		}
		l = m;
	}
	if (l < n)
	{
		for (j = 0; j <= l - 2; j += 2)
		{
			j1 = j + l;
			x0r = a[j] - a[j1];
			x0i = a[j + 1] - a[j1 + 1];
			a[j] += a[j1];
			a[j + 1] += a[j1 + 1];
			a[j1] = x0r;
			a[j1 + 1] = x0i;
		}
	}
}

static void makewt(int nw, int* ip, FFT_TYPE* w)
{
	void bitrv2(int n, int* ip, FFT_TYPE* a);
	int nwh, j;
	FFT_TYPE delta, x, y;

	ip[0] = nw;
	ip[1] = 1;
	if (nw > 2)
	{
		nwh = nw >> 1;
		delta = atan(1.0f) / nwh;
		w[0] = 1;
		w[1] = 0;
		w[nwh] = cos(delta * nwh);
		w[nwh + 1] = w[nwh];
		for (j = 2; j <= nwh - 2; j += 2)
		{
			x = cos(delta * j);
			y = sin(delta * j);
			w[j] = x;
			w[j + 1] = y;
			w[nw - j] = y;
			w[nw - j + 1] = x;
		}
		bitrv2(nw, ip + 2, w);
	}
}

/**
	Copyright(C) 1997 Takuya OOURA (email: ooura@mmm.t.u-tokyo.ac.jp).
	You may use, copy, modify this code for any purpose and
	without fee. You may distribute this ORIGINAL package.
  */
static void makect(int nc, int* ip, FFT_TYPE* c)
{
	int nch, j;
	FFT_TYPE delta;

	ip[1] = nc;
	if (nc > 1)
	{
		nch = nc >> 1;
		delta = atan(1.0f) / nch;
		c[0] = 0.5f;
		c[nch] = 0.5f * cos(delta * nch);
		for (j = 1; j <= nch - 1; j++)
		{
			c[j] = 0.5f * cos(delta * j);
			c[nc - j] = 0.5f * sin(delta * j);
		}
	}
}

/**
	Copyright(C) 1997 Takuya OOURA (email: ooura@mmm.t.u-tokyo.ac.jp).
	You may use, copy, modify this code for any purpose and
	without fee. You may distribute this ORIGINAL package.
  */
static void bitrv2(int n, int* ip, FFT_TYPE* a)
{
	int j, j1, k, k1, l, m, m2;
	FFT_TYPE xr, xi;

	ip[0] = 0;
	l = n;
	m = 1;
	while ((m << 2) < l)
	{
		l >>= 1;
		for (j = 0; j <= m - 1; j++)
		{
			ip[m + j] = ip[j] + l;
		}
		m <<= 1;
	}
	if ((m << 2) > l)
	{
		for (k = 1; k <= m - 1; k++)
		{
			for (j = 0; j <= k - 1; j++)
			{
				j1 = (j << 1) + ip[k];
				k1 = (k << 1) + ip[j];
				xr = a[j1];
				xi = a[j1 + 1];
				a[j1] = a[k1];
				a[j1 + 1] = a[k1 + 1];
				a[k1] = xr;
				a[k1 + 1] = xi;
			}
		}
	}
	else
	{
		m2 = m << 1;
		for (k = 1; k <= m - 1; k++)
		{
			for (j = 0; j <= k - 1; j++)
			{
				j1 = (j << 1) + ip[k];
				k1 = (k << 1) + ip[j];
				xr = a[j1];
				xi = a[j1 + 1];
				a[j1] = a[k1];
				a[j1 + 1] = a[k1 + 1];
				a[k1] = xr;
				a[k1 + 1] = xi;
				j1 += m2;
				k1 += m2;
				xr = a[j1];
				xi = a[j1 + 1];
				a[j1] = a[k1];
				a[j1 + 1] = a[k1 + 1];
				a[k1] = xr;
				a[k1 + 1] = xi;
			}
		}
	}
}

/**
	Copyright(C) 1997 Takuya OOURA (email: ooura@mmm.t.u-tokyo.ac.jp).
	You may use, copy, modify this code for any purpose and
	without fee. You may distribute this ORIGINAL package.
  */
static void cdft(int n, int isgn, FFT_TYPE* a, int* ip, FFT_TYPE* w)
{
	if (n > (ip[0] << 2))
	{
		makewt(n >> 2, ip, w);
	}
	if (n > 4)
	{
		bitrv2(n, ip + 2, a);
	}
	if (isgn < 0)
	{
		cftfsub(n, a, w);
	}
	else
	{
		cftbsub(n, a, w);
	}
}

static void rftfsub(int n, FFT_TYPE* a, int nc, FFT_TYPE* c)
{
	int j, k, kk, ks;
	FFT_TYPE wkr, wki, xr, xi, yr, yi;

	ks = (nc << 2) / n;
	kk = 0;
	for (k = (n >> 1) - 2; k >= 2; k -= 2)
	{
		j = n - k;
		kk += ks;
		wkr = 0.5f - c[kk];
		wki = c[nc - kk];
		xr = a[k] - a[j];
		xi = a[k + 1] + a[j + 1];
		yr = wkr * xr + wki * xi;
		yi = wkr * xi - wki * xr;
		a[k] -= yr;
		a[k + 1] -= yi;
		a[j] += yr;
		a[j + 1] -= yi;
	}
}

static void rdft(int n, int isgn, FFT_TYPE* a, int* ip, FFT_TYPE* w)
{
	int nw, nc;
	FFT_TYPE xi;

	nw = ip[0];
	if (n > (nw << 2))
	{
		nw = n >> 2;
		makewt(nw, ip, w);
	}
	nc = ip[1];
	if (n > (nc << 2))
	{
		nc = n >> 2;
		makect(nc, ip, w + nw);
	}
	if (isgn < 0)
	{
		a[1] = 0.5f * (a[0] - a[1]);
		a[0] -= a[1];
		if (n > 4)
		{
			rftfsub(n, a, nc, w + nw);
			bitrv2(n, ip + 2, a);
		}
		cftfsub(n, a, w);
	}
	else
	{
		if (n > 4)
		{
			bitrv2(n, ip + 2, a);
		}
		cftbsub(n, a, w);
		if (n > 4)
		{
			rftbsub(n, a, nc, w + nw);
		}
		xi = a[0] - a[1];
		a[0] += a[1];
		a[1] = xi;
	}
}

static void rftbsub(int n, FFT_TYPE* a, int nc, FFT_TYPE* c)
{
	int j, k, kk, ks;
	FFT_TYPE wkr, wki, xr, xi, yr, yi;

	ks = (nc << 2) / n;
	kk = 0;
	for (k = (n >> 1) - 2; k >= 2; k -= 2)
	{
		j = n - k;
		kk += ks;
		wkr = 0.5f - c[kk];
		wki = c[nc - kk];
		xr = a[k] - a[j];
		xi = a[k + 1] + a[j + 1];
		yr = wkr * xr - wki * xi;
		yi = wkr * xi + wki * xr;
		a[k] -= yr;
		a[k + 1] -= yi;
		a[j] += yr;
		a[j + 1] -= yi;
	}
}

/**
	Copyright(C) 1997 Takuya OOURA (email: ooura@mmm.t.u-tokyo.ac.jp).
	You may use, copy, modify this code for any purpose and
	without fee. You may distribute this ORIGINAL package.

-------- Real DFT / Inverse of Real DFT --------
	[definition]
		<case1> RDFT
			R[k1][k2] = sum_j1=0^n1-1 sum_j2=0^n2-1 a[j1][j2] *
							cos(2*pi*j1*k1/n1 + 2*pi*j2*k2/n2),
							0<=k1<n1, 0<=k2<n2
			I[k1][k2] = sum_j1=0^n1-1 sum_j2=0^n2-1 a[j1][j2] *
							sin(2*pi*j1*k1/n1 + 2*pi*j2*k2/n2),
							0<=k1<n1, 0<=k2<n2
		<case2> IRDFT (excluding scale)
			a[k1][k2] = (1/2) * sum_j1=0^n1-1 sum_j2=0^n2-1
							(R[j1][j2] *
							cos(2*pi*j1*k1/n1 + 2*pi*j2*k2/n2) +
							I[j1][j2] *
							sin(2*pi*j1*k1/n1 + 2*pi*j2*k2/n2)),
							0<=k1<n1, 0<=k2<n2
		(notes: R[n1-k1][n2-k2] = R[k1][k2],
				I[n1-k1][n2-k2] = -I[k1][k2],
				R[n1-k1][0] = R[k1][0],
				I[n1-k1][0] = -I[k1][0],
				R[0][n2-k2] = R[0][k2],
				I[0][n2-k2] = -I[0][k2],
				0<k1<n1, 0<k2<n2)
	[usage]
		<case1>
			ip[0] = 0; // first time only
			rdft2d(n1, n2, 1, a, t, ip, w);
		<case2>
			ip[0] = 0; // first time only
			rdft2d(n1, n2, -1, a, t, ip, w);
	[parameters]
		n1     :data length (int)
				n1 >= 2, n1 = power of 2
		n2     :data length (int)
				n2 >= 2, n2 = power of 2
		a[0...n1-1][0...n2-1]
			   :input/output data (FFT_TYPE **)
				<case1>
					output data
						a[k1][2*k2] = R[k1][k2] = R[n1-k1][n2-k2],
						a[k1][2*k2+1] = I[k1][k2] = -I[n1-k1][n2-k2],
							0<k1<n1, 0<k2<n2/2,
						a[0][2*k2] = R[0][k2] = R[0][n2-k2],
						a[0][2*k2+1] = I[0][k2] = -I[0][n2-k2],
							0<k2<n2/2,
						a[k1][0] = R[k1][0] = R[n1-k1][0],
						a[k1][1] = I[k1][0] = -I[n1-k1][0],
						a[n1-k1][1] = R[k1][n2/2] = R[n1-k1][n2/2],
						a[n1-k1][0] = -I[k1][n2/2] = I[n1-k1][n2/2],
							0<k1<n1/2,
						a[0][0] = R[0][0],
						a[0][1] = R[0][n2/2],
						a[n1/2][0] = R[n1/2][0],
						a[n1/2][1] = R[n1/2][n2/2]
				<case2>
					input data
						a[j1][2*j2] = R[j1][j2] = R[n1-j1][n2-j2],
						a[j1][2*j2+1] = I[j1][j2] = -I[n1-j1][n2-j2],
							0<j1<n1, 0<j2<n2/2,
						a[0][2*j2] = R[0][j2] = R[0][n2-j2],
						a[0][2*j2+1] = I[0][j2] = -I[0][n2-j2],
							0<j2<n2/2,
						a[j1][0] = R[j1][0] = R[n1-j1][0],
						a[j1][1] = I[j1][0] = -I[n1-j1][0],
						a[n1-j1][1] = R[j1][n2/2] = R[n1-j1][n2/2],
						a[n1-j1][0] = -I[j1][n2/2] = I[n1-j1][n2/2],
							0<j1<n1/2,
						a[0][0] = R[0][0],
						a[0][1] = R[0][n2/2],
						a[n1/2][0] = R[n1/2][0],
						a[n1/2][1] = R[n1/2][n2/2]
		t[0...2*n1-1]
			   :work area (FFT_TYPE *)
		ip[0...*]
			   :work area for bit reversal (int *)
				length of ip >= 2+sqrt(n)  ; if n % 4 == 0
								2+sqrt(n/2); otherwise
				(n = max(n1, n2/2))
				ip[0],ip[1] are pointers of the cos/sin table.
		w[0...*]
			   :cos/sin table (FFT_TYPE *)
				length of w >= max(n1/2, n2/4) + n2/4
				w[],ip[] are initialized if ip[0] == 0.
	[remark]
		Inverse of
			rdft2d(n1, n2, 1, a, t, ip, w);
		is
			rdft2d(n1, n2, -1, a, t, ip, w);
			for (j1 = 0; j1 <= n1 - 1; j1++) {
				for (j2 = 0; j2 <= n2 - 1; j2++) {
					a[j1][j2] *= 2.0 / (n1 * n2);
				}
			}
  */
static void rdft2d(
	int n1, int n2, int isgn, FFT_TYPE** a, FFT_TYPE* t, int* ip, FFT_TYPE* w)
{
	int n, nw, nc, n1h, i, j, i2;
	FFT_TYPE xi;

	n = n1 << 1;
	if (n < n2)
	{
		n = n2;
	}
	nw = ip[0];
	if (n > (nw << 2))
	{
		nw = n >> 2;
		makewt(nw, ip, w);
	}
	nc = ip[1];
	if (n2 > (nc << 2))
	{
		nc = n2 >> 2;
		makect(nc, ip, w + nw);
	}
	n1h = n1 >> 1;
	if (isgn < 0)
	{
		for (i = 1; i <= n1h - 1; i++)
		{
			j = n1 - i;
			xi = a[i][0] - a[j][0];
			a[i][0] += a[j][0];
			a[j][0] = xi;
			xi = a[j][1] - a[i][1];
			a[i][1] += a[j][1];
			a[j][1] = xi;
		}
		for (j = 0; j <= n2 - 2; j += 2)
		{
			for (i = 0; i <= n1 - 1; i++)
			{
				i2 = i << 1;
				t[i2] = a[i][j];
				t[i2 + 1] = a[i][j + 1];
			}
			cdft(n1 << 1, isgn, t, ip, w);
			for (i = 0; i <= n1 - 1; i++)
			{
				i2 = i << 1;
				a[i][j] = t[i2];
				a[i][j + 1] = t[i2 + 1];
			}
		}
		for (i = 0; i <= n1 - 1; i++)
		{
			rdft(n2, isgn, a[i], ip, w);
		}
	}
	else
	{
		for (i = 0; i <= n1 - 1; i++)
		{
			rdft(n2, isgn, a[i], ip, w);
		}
		for (j = 0; j <= n2 - 2; j += 2)
		{
			for (i = 0; i <= n1 - 1; i++)
			{
				i2 = i << 1;
				t[i2] = a[i][j];
				t[i2 + 1] = a[i][j + 1];
			}
			cdft(n1 << 1, isgn, t, ip, w);
			for (i = 0; i <= n1 - 1; i++)
			{
				i2 = i << 1;
				a[i][j] = t[i2];
				a[i][j + 1] = t[i2 + 1];
			}
		}
		for (i = 1; i <= n1h - 1; i++)
		{
			j = n1 - i;
			a[j][0] = 0.5f * (a[i][0] - a[j][0]);
			a[i][0] -= a[j][0];
			a[j][1] = 0.5f * (a[i][1] + a[j][1]);
			a[i][1] -= a[j][1];
		}
	}
}

/**
	Copyright(C) 1997 Takuya OOURA (email: ooura@mmm.t.u-tokyo.ac.jp).
	You may use, copy, modify this code for any purpose and
	without fee. You may distribute this ORIGINAL package.

-------- Complex DFT (Discrete Fourier Transform) --------
	[definition]
		<case1>
			X[k1][k2] = sum_j1=0^n1-1 sum_j2=0^n2-1 x[j1][j2] *
							exp(2*pi*i*j1*k1/n1) *
							exp(2*pi*i*j2*k2/n2), 0<=k1<n1, 0<=k2<n2
		<case2>
			X[k1][k2] = sum_j1=0^n1-1 sum_j2=0^n2-1 x[j1][j2] *
							exp(-2*pi*i*j1*k1/n1) *
							exp(-2*pi*i*j2*k2/n2), 0<=k1<n1, 0<=k2<n2
		(notes: sum_j=0^n-1 is a summation from j=0 to n-1)
	[usage]
		<case1>
			ip[0] = 0; // first time only
			cdft2d(n1, 2*n2, 1, a, t, ip, w);
		<case2>
			ip[0] = 0; // first time only
			cdft2d(n1, 2*n2, -1, a, t, ip, w);
	[parameters]
		n1     :data length (int)
				n1 >= 1, n1 = power of 2
		2*n2   :data length (int)
				n2 >= 1, n2 = power of 2
		a[0...n1-1][0...2*n2-1]
			   :input/output data (double **)
				input data
					a[j1][2*j2] = Re(x[j1][j2]),
					a[j1][2*j2+1] = Im(x[j1][j2]),
					0<=j1<n1, 0<=j2<n2
				output data
					a[k1][2*k2] = Re(X[k1][k2]),
					a[k1][2*k2+1] = Im(X[k1][k2]),
					0<=k1<n1, 0<=k2<n2
		t[0...2*n1-1]
			   :work area (double *)
		ip[0...*]
			   :work area for bit reversal (int *)
				length of ip >= 2+sqrt(n)  ; if n % 4 == 0
								2+sqrt(n/2); otherwise
				(n = max(n1, n2))
				ip[0],ip[1] are pointers of the cos/sin table.
		w[0...*]
			   :cos/sin table (double *)
				length of w >= max(n1/2, n2/2)
				w[],ip[] are initialized if ip[0] == 0.
	[remark]
		Inverse of
			cdft2d(n1, 2*n2, -1, a, t, ip, w);
		is
			cdft2d(n1, 2*n2, 1, a, t, ip, w);
			for (j1 = 0; j1 <= n1 - 1; j1++) {
				for (j2 = 0; j2 <= 2 * n2 - 1; j2++) {
					a[j1][j2] *= 1.0 / (n1 * n2);
				}
			}

*/
static void cdft2d(
	int n1, int n2, int isgn, FFT_TYPE** a, FFT_TYPE* t, int* ip, FFT_TYPE* w)
{
	void makewt(int nw, int* ip, FFT_TYPE* w);
	void cdft(int n, int isgn, FFT_TYPE* a, int* ip, FFT_TYPE* w);
	int n, i, j, i2;

	n = n1 << 1;
	if (n < n2)
	{
		n = n2;
	}
	if (n > (ip[0] << 2))
	{
		makewt(n >> 2, ip, w);
	}
	for (i = 0; i <= n1 - 1; i++)
	{
		cdft(n2, isgn, a[i], ip, w);
	}
	for (j = 0; j <= n2 - 2; j += 2)
	{
		for (i = 0; i <= n1 - 1; i++)
		{
			i2 = i << 1;
			t[i2] = a[i][j];
			t[i2 + 1] = a[i][j + 1];
		}
		cdft(n1 << 1, isgn, t, ip, w);
		for (i = 0; i <= n1 - 1; i++)
		{
			i2 = i << 1;
			a[i][j] = t[i2];
			a[i][j + 1] = t[i2 + 1];
		}
	}
}

} // namespace mrpt::math

void mrpt::math::fft_real(
	CVectorFloat& in_realData, CVectorFloat& out_FFT_Re,
	CVectorFloat& out_FFT_Im, CVectorFloat& out_FFT_Mag)
{
	MRPT_START

	unsigned long n = (unsigned long)in_realData.size();

	// TODO: Test data lenght is 2^N...

	CVectorFloat auxVect(n + 1);

	memcpy(&auxVect[1], &in_realData[0], n * sizeof(auxVect[0]));

	realft(&auxVect[0], n);

	unsigned int n_2 = 1 + (n / 2);

	out_FFT_Re.resize(n_2);
	out_FFT_Im.resize(n_2);
	out_FFT_Mag.resize(n_2);

	for (unsigned int i = 0; i < n_2; i++)
	{
		if (i == (n_2 - 1))
			out_FFT_Re[i] = auxVect[2];
		else
			out_FFT_Re[i] = auxVect[1 + i * 2];

		if (i == 0 || i == (n_2 - 1))
			out_FFT_Im[i] = 0;
		else
			out_FFT_Im[i] = auxVect[1 + i * 2 + 1];

		out_FFT_Mag[i] =
			std::sqrt(square(out_FFT_Re[i]) + square(out_FFT_Im[i]));
	}

	MRPT_END
}

void math::dft2_real(
	const CMatrixFloat& in_data, CMatrixFloat& out_real, CMatrixFloat& out_imag)
{
	MRPT_START

	size_t i, j;
	using float_ptr = FFT_TYPE*;

	// The dimensions:
	size_t dim1 = in_data.rows();
	size_t dim2 = in_data.cols();

	// Transform to format compatible with C routines:
	// ------------------------------------------------------------
	FFT_TYPE** a;
	FFT_TYPE* t;
	int* ip;
	FFT_TYPE* w;

	// Reserve memory and copy data:
	// --------------------------------------
	a = new float_ptr[dim1];
	for (i = 0; i < dim1; i++)
	{
		a[i] = new FFT_TYPE[dim2];
		for (j = 0; j < dim2; j++) a[i][j] = in_data.get_unsafe(i, j);
	}

	t = new FFT_TYPE[2 * dim1 + 20];
	ip = new int[(int)ceil(20 + 2 + sqrt((FFT_TYPE)max(dim1, dim2 / 2)))];
	ip[0] = 0;
	w = new FFT_TYPE[max(dim1 / 2, dim2 / 4) + dim2 / 4 + 20];

	// Do the job!
	// --------------------------------------
	rdft2d((int)dim1, (int)dim2, 1, a, t, ip, w);

	// Transform back to MRPT matrix format:
	// --------------------------------------
	out_real.setSize(dim1, dim2);
	out_imag.setSize(dim1, dim2);

	// a[k1][2*k2] = R[k1][k2] = R[n1-k1][n2-k2],
	// a[k1][2*k2+1] = I[k1][k2] = -I[n1-k1][n2-k2],
	//       0<k1<n1, 0<k2<n2/2,
	for (i = 1; i < dim1; i++)
		for (j = 1; j < dim2 / 2; j++)
		{
			out_real.set_unsafe(i, j, (float)a[i][j * 2]);
			out_real.set_unsafe(dim1 - i, dim2 - j, (float)a[i][j * 2]);
			out_imag.set_unsafe(i, j, (float)-a[i][j * 2 + 1]);
			out_imag.set_unsafe(dim1 - i, dim2 - j, (float)a[i][j * 2 + 1]);
		}
	// a[0][2*k2] = R[0][k2] = R[0][n2-k2],
	// a[0][2*k2+1] = I[0][k2] = -I[0][n2-k2],
	//     0<k2<n2/2,
	for (j = 1; j < dim2 / 2; j++)
	{
		out_real.set_unsafe(0, j, (float)a[0][j * 2]);
		out_real.set_unsafe(0, dim2 - j, (float)a[0][j * 2]);
		out_imag.set_unsafe(0, j, (float)-a[0][j * 2 + 1]);
		out_imag.set_unsafe(0, dim2 - j, (float)a[0][j * 2 + 1]);
	}

	// a[k1][0] = R[k1][0] = R[n1-k1][0],
	// a[k1][1] = I[k1][0] = -I[n1-k1][0],
	// a[n1-k1][1] = R[k1][n2/2] = R[n1-k1][n2/2],
	// a[n1-k1][0] = -I[k1][n2/2] = I[n1-k1][n2/2],
	//    0<k1<n1/2,
	for (i = 1; i < dim1 / 2; i++)
	{
		out_real.set_unsafe(i, 0, (float)a[i][0]);
		out_real.set_unsafe(dim1 - i, 0, (float)a[i][0]);
		out_imag.set_unsafe(i, 0, (float)-a[i][1]);
		out_imag.set_unsafe(dim1 - i, 0, (float)a[i][1]);
		out_real.set_unsafe(i, dim2 / 2, (float)a[dim1 - i][1]);
		out_real.set_unsafe(dim1 - i, dim2 / 2, (float)a[dim1 - i][1]);
		out_imag.set_unsafe(i, dim2 / 2, (float)a[dim1 - i][0]);
		out_imag.set_unsafe(dim1 - i, dim2 / 2, (float)-a[dim1 - i][0]);
	}

	// a[0][0] = R[0][0],
	// a[0][1] = R[0][n2/2],
	// a[n1/2][0] = R[n1/2][0],
	// a[n1/2][1] = R[n1/2][n2/2]
	out_real.set_unsafe(0, 0, (float)a[0][0]);
	out_real.set_unsafe(0, dim2 / 2, (float)a[0][1]);
	out_real.set_unsafe(dim1 / 2, 0, (float)a[dim1 / 2][0]);
	out_real.set_unsafe(dim1 / 2, dim2 / 2, (float)a[dim1 / 2][1]);

	// Free temporary memory:
	for (i = 0; i < dim1; i++) delete[] a[i];
	delete[] a;
	delete[] t;
	delete[] ip;
	delete[] w;

	MRPT_END
}

void math::idft2_real(
	const CMatrixFloat& in_real, const CMatrixFloat& in_imag,
	CMatrixFloat& out_data)
{
	MRPT_START

	size_t i, j;
	using float_ptr = FFT_TYPE*;

	ASSERT_(in_real.rows() == in_imag.rows());
	ASSERT_(in_real.cols() == in_imag.cols());

	// The dimensions:
	size_t dim1 = in_real.rows();
	size_t dim2 = in_real.cols();

	if (mrpt::round2up(dim1) != dim1 || mrpt::round2up(dim2) != dim2)
		THROW_EXCEPTION(""Matrix sizes are not a power of two!"");

	// Transform to format compatible with C routines:
	// ------------------------------------------------------------
	FFT_TYPE** a;
	FFT_TYPE* t;
	int* ip;
	FFT_TYPE* w;

	// Reserve memory and copy data:
	// --------------------------------------
	a = new float_ptr[dim1];
	for (i = 0; i < dim1; i++) a[i] = new FFT_TYPE[dim2];

	// a[j1][2*j2] = R[j1][j2] = R[n1-j1][n2-j2],
	// a[j1][2*j2+1] = I[j1][j2] = -I[n1-j1][n2-j2],
	//    0<j1<n1, 0<j2<n2/2,
	for (i = 1; i < dim1; i++)
		for (j = 1; j < dim2 / 2; j++)
		{
			a[i][2 * j] = in_real.get_unsafe(i, j);
			a[i][2 * j + 1] = -in_imag.get_unsafe(i, j);
		}

	// a[0][2*j2] = R[0][j2] = R[0][n2-j2],
	// a[0][2*j2+1] = I[0][j2] = -I[0][n2-j2],
	//    0<j2<n2/2,
	for (j = 1; j < dim2 / 2; j++)
	{
		a[0][2 * j] = in_real.get_unsafe(0, j);
		a[0][2 * j + 1] = -in_imag.get_unsafe(0, j);
	}

	// a[j1][0] = R[j1][0] = R[n1-j1][0],
	// a[j1][1] = I[j1][0] = -I[n1-j1][0],
	// a[n1-j1][1] = R[j1][n2/2] = R[n1-j1][n2/2],
	// a[n1-j1][0] = -I[j1][n2/2] = I[n1-j1][n2/2],
	//    0<j1<n1/2,
	for (i = 1; i < dim1 / 2; i++)
	{
		a[i][0] = in_real.get_unsafe(i, 0);
		a[i][1] = -in_imag.get_unsafe(i, 0);
		a[dim1 - i][1] = in_real.get_unsafe(i, dim2 / 2);
		a[dim1 - i][0] = in_imag.get_unsafe(i, dim2 / 2);
	}

	// a[0][0] = R[0][0],
	// a[0][1] = R[0][n2/2],
	// a[n1/2][0] = R[n1/2][0],
	// a[n1/2][1] = R[n1/2][n2/2]
	a[0][0] = in_real.get_unsafe(0, 0);
	a[0][1] = in_real.get_unsafe(0, dim2 / 2);
	a[dim1 / 2][0] = in_real.get_unsafe(dim1 / 2, 0);
	a[dim1 / 2][1] = in_real.get_unsafe(dim1 / 2, dim2 / 2);

	t = new FFT_TYPE[2 * dim1 + 20];
	ip = new int[(int)ceil(20 + 2 + sqrt((FFT_TYPE)max(dim1, dim2 / 2)))];
	ip[0] = 0;
	w = new FFT_TYPE[max(dim1 / 2, dim2 / 4) + dim2 / 4 + 20];

	// Do the job!
	// --------------------------------------
	rdft2d((int)dim1, (int)dim2, -1, a, t, ip, w);

	// Transform back to MRPT matrix format:
	// --------------------------------------
	out_data.setSize(dim1, dim2);

	FFT_TYPE scale = 2.0f / (dim1 * dim2);

	for (i = 0; i < dim1; i++)
		for (j = 0; j < dim2; j++)
			out_data.set_unsafe(i, j, (float)(a[i][j] * scale));

	// Free temporary memory:
	for (i = 0; i < dim1; i++) delete[] a[i];
	delete[] a;
	delete[] t;
	delete[] ip;
	delete[] w;

	MRPT_END
}

/*---------------------------------------------------------------
						myGeneralDFT

	sign ->  -1: DFT, 1:IDFT
 ---------------------------------------------------------------*/
static void myGeneralDFT(
	int sign, const CMatrixFloat& in_real, const CMatrixFloat& in_imag,
	CMatrixFloat& out_real, CMatrixFloat& out_imag)
{
	ASSERT_(in_real.rows() == in_imag.rows());
	ASSERT_(in_real.cols() == in_imag.cols());

	// The dimensions:
	size_t dim1 = in_real.rows();
	size_t dim2 = in_real.cols();

	size_t k1, k2, n1, n2;
	float w_r, w_i;
	float ang1 = (float)(sign * M_2PI / dim1);
	float ang2 = (float)(sign * M_2PI / dim2);
	float phase;
	float R, I;
	float scale = sign == 1 ? (1.0f / (dim1 * dim2)) : 1;

	out_real.setSize(dim1, dim2);
	out_imag.setSize(dim1, dim2);

	for (k1 = 0; k1 < dim1; k1++)
	{
		for (k2 = 0; k2 < dim2; k2++)
		{
			R = I = 0;  // Accum:

			for (n1 = 0; n1 < dim1; n1++)
			{
				phase = ang1 * n1 * k1;
				for (n2 = 0; n2 < dim2; n2++)
				{
					w_r = cos(phase);
					w_i = sin(phase);

					R += w_r * in_real.get_unsafe(n1, n2) -
						 w_i * in_imag.get_unsafe(n1, n2);
					I += w_i * in_real.get_unsafe(n1, n2) +
						 w_r * in_imag.get_unsafe(n1, n2);

					phase += ang2 * k2;
				}  // end for k2
			}  // end for k1

			// Save result:
			out_real.set_unsafe(k1, k2, R * scale);
			out_imag.set_unsafe(k1, k2, I * scale);

		}  // end for k2
	}  // end for k1
}

/*---------------------------------------------------------------
						dft2_complex
 ---------------------------------------------------------------*/
void math::dft2_complex(
	const CMatrixFloat& in_real, const CMatrixFloat& in_imag,
	CMatrixFloat& out_real, CMatrixFloat& out_imag)
{
	MRPT_START

	ASSERT_(in_real.rows() == in_imag.rows());
	ASSERT_(in_real.cols() == in_imag.cols());

	// The dimensions:
	size_t dim1 = in_real.rows();
	size_t dim2 = in_real.cols();
	size_t i, j;

	bool dim1IsPower2 = (mrpt::round2up(dim1) == dim1);
	bool dim2IsPower2 = (mrpt::round2up(dim2) == dim2);

	// FFT or DFT??
	if (dim1IsPower2 && dim2IsPower2)
	{
		// ----------------------------------------
		//			Optimized FFT:
		// ----------------------------------------
		using float_ptr = FFT_TYPE*;

		// Transform to format compatible with C routines:
		// ------------------------------------------------------------
		static FFT_TYPE** a = nullptr;
		static FFT_TYPE* t = nullptr;
		static int* ip = nullptr;
		static FFT_TYPE* w = nullptr;

		// Reserve memory
		// --------------------------------------
		static int alreadyInitSize1 = -1, alreadyInitSize2 = -1;

		if (alreadyInitSize1 != (int)dim1 || alreadyInitSize2 != (int)dim2)
		{
			// Create/realloc buffers:
			if (a)
			{
				for (i = 0; i < dim1; i++) delete[] a[i];
				delete[] a;
			}
			if (ip) delete[] ip;
			if (t) delete[] t;
			if (w) delete[] w;

			alreadyInitSize1 = (int)dim1;
			alreadyInitSize2 = (int)dim2;

			a = new float_ptr[dim1];
			for (i = 0; i < dim1; i++) a[i] = new FFT_TYPE[2 * dim2];

			t = new FFT_TYPE[2 * dim1 + 20];
			ip = new int[(int)ceil(
				20 + 2 + sqrt((FFT_TYPE)max(dim1, dim2 / 2)))];
			ip[0] = 0;
			w = new FFT_TYPE[max(dim1 / 2, dim2 / 4) + dim2 / 4 + 20];
		}

		// and copy data:
		// --------------------------------------
		for (i = 0; i < dim1; i++)
			for (j = 0; j < dim2; j++)
			{
				a[i][2 * j + 0] = in_real.get_unsafe(i, j);
				a[i][2 * j + 1] = in_imag.get_unsafe(i, j);
			}

		// Do the job!
		// --------------------------------------
		cdft2d((int)dim1, (int)(2 * dim2), 1, a, t, ip, w);

		// Transform back to MRPT matrix format:
		// --------------------------------------
		out_real.setSize(dim1, dim2);
		out_imag.setSize(dim1, dim2);

		// a[k1][2*k2] = Re(X[k1][k2]),
		// a[k1][2*k2+1] = Im(X[k1][k2]),
		// 0<=k1<n1, 0<=k2<n2
		for (i = 0; i < dim1; i++)
			for (j = 0; j < dim2; j++)
			{
				out_real.set_unsafe(i, j, (float)a[i][j * 2 + 0]);
				out_imag.set_unsafe(i, j, (float)a[i][j * 2 + 1]);
			}

	}  // end FFT
	else
	{
		// ----------------------------------------
		//			General DFT:
		// ----------------------------------------
		printf(""Using general DFT...\\n"");
		myGeneralDFT(-1, in_real, in_imag, out_real, out_imag);
	}

	MRPT_END
}

/*---------------------------------------------------------------
						idft2_complex
 ---------------------------------------------------------------*/
void math::idft2_complex(
	const CMatrixFloat& in_real, const CMatrixFloat& in_imag,
	CMatrixFloat& out_real, CMatrixFloat& out_imag)
{
	MRPT_START

	ASSERT_(in_real.rows() == in_imag.rows());
	ASSERT_(in_real.cols() == in_imag.cols());

	// The dimensions:
	size_t dim1 = in_real.rows();
	size_t dim2 = in_real.cols();
	size_t i, j;

	bool dim1IsPower2 = (mrpt::round2up(dim1) == dim1);
	bool dim2IsPower2 = (mrpt::round2up(dim2) == dim2);

	// FFT or DFT??
	if (dim1IsPower2 && dim2IsPower2)
	{
		using float_ptr = FFT_TYPE*;
		// ----------------------------------------
		//			Optimized FFT:
		// ----------------------------------------

		// Transform to format compatible with C routines:
		// ------------------------------------------------------------
		static FFT_TYPE** a = nullptr;
		static FFT_TYPE* t = nullptr;
		static int* ip = nullptr;
		static FFT_TYPE* w = nullptr;

		// Reserve memory
		// --------------------------------------

		// and copy data:
		// --------------------------------------
		static int alreadyInitSize1 = -1, alreadyInitSize2 = -1;

		if (alreadyInitSize1 != (int)dim1 || alreadyInitSize2 != (int)dim2)
		{
			// Create/realloc buffers:
			if (a)
			{
				for (i = 0; i < dim1; i++) delete[] a[i];
				delete[] a;
			}
			if (ip) delete[] ip;
			if (t) delete[] t;
			if (w) delete[] w;

			alreadyInitSize1 = (int)dim1;
			alreadyInitSize2 = (int)dim2;

			a = new float_ptr[dim1];
			for (i = 0; i < dim1; i++) a[i] = new FFT_TYPE[2 * dim2];
			t = new FFT_TYPE[2 * dim1 + 20];
			ip = new int[(int)ceil(
				20 + 2 + sqrt((FFT_TYPE)max(dim1, dim2 / 2)))];
			ip[0] = 0;
			w = new FFT_TYPE[max(dim1 / 2, dim2 / 4) + dim2 / 4 + 20];
		}

		// and copy data:
		// --------------------------------------
		for (i = 0; i < dim1; i++)
			for (j = 0; j < dim2; j++)
			{
				a[i][2 * j + 0] = in_real.get_unsafe(i, j);
				a[i][2 * j + 1] = in_imag.get_unsafe(i, j);
			}

		// Do the job!
		// --------------------------------------
		cdft2d((int)dim1, (int)(2 * dim2), -1, a, t, ip, w);

		// Transform back to MRPT matrix format:
		// --------------------------------------
		out_real.setSize(dim1, dim2);
		out_imag.setSize(dim1, dim2);

		FFT_TYPE scale = 1.0f / (dim1 * dim2);

		// a[k1][2*k2] = Re(X[k1][k2]),
		// a[k1][2*k2+1] = Im(X[k1][k2]),
		// 0<=k1<n1, 0<=k2<n2
		for (i = 0; i < dim1; i++)
			for (j = 0; j < dim2; j++)
			{
				//				out_real.set_unsafe(i,j,(float)(a[i][j*2+0]*scale));
				//				out_imag.set_unsafe(i,j,(float)(a[i][j*2+1]*scale));
				out_real.set_unsafe(i, j, (float)(a[i][j * 2 + 0]));
				out_imag.set_unsafe(i, j, (float)(a[i][j * 2 + 1]));
			}

		out_real *= scale;
		out_imag *= scale;

		// The element (0,0) is purely real!
		out_imag.set_unsafe(0, 0, 0);

	}  // end FFT
	else
	{
		// ----------------------------------------
		//			General DFT:
		// ----------------------------------------
		printf(""Using general DFT...\\n"");
		myGeneralDFT(1, in_real, in_imag, out_real, out_imag);
	}

	MRPT_END
}

void mrpt::math::cross_correlation_FFT(
	const CMatrixFloat& A, const CMatrixFloat& B, CMatrixFloat& out_corr)
{
	MRPT_START

	ASSERT_(A.cols() == B.cols() && A.rows() == B.rows());
	if (mrpt::round2up(A.rows()) != A.rows() ||
		mrpt::round2up(A.cols()) != A.cols())
		THROW_EXCEPTION(""Size of input matrices must be powers of two."");

	// Find smallest valid size:
	size_t x, y;
	const size_t lx = A.cols();
	const size_t ly = A.rows();

	const CMatrixFloat& i1 = A;
	const CMatrixFloat& i2 = B;

	// FFT:
	CMatrixFloat I1_R, I1_I, I2_R, I2_I, ZEROS(ly, lx);
	math::dft2_complex(i1, ZEROS, I1_R, I1_I);
	math::dft2_complex(i2, ZEROS, I2_R, I2_I);

	// Compute the COMPLEX division of I2 by I1:
	for (y = 0; y < ly; y++)
		for (x = 0; x < lx; x++)
		{
			float r1 = I1_R.get_unsafe(y, x);
			float r2 = I2_R.get_unsafe(y, x);

			float ii1 = I1_I.get_unsafe(y, x);
			float ii2 = I2_I.get_unsafe(y, x);

			float den = square(r1) + square(ii1);
			I2_R.set_unsafe(y, x, (r1 * r2 + ii1 * ii2) / den);
			I2_I.set_unsafe(y, x, (ii2 * r1 - r2 * ii1) / den);
		}

	// IFFT:
	CMatrixFloat res_R, res_I;
	math::idft2_complex(I2_R, I2_I, res_R, res_I);

	out_corr.setSize(ly, lx);
	for (y = 0; y < ly; y++)
		for (x = 0; x < lx; x++)
			out_corr(y, x) = sqrt(square(res_R(y, x)) + square(res_I(y, x)));

	MRPT_END
}
",16179,True,2617.1457199223573,median
"/* The copyright in this software is being made available under the BSD
 * License, included below. This software may be subject to other third party
 * and contributor rights, including patent rights, and no such rights are
 * granted under this license.
 *
 * Copyright (c) 2010-2018, ITU/ISO/IEC
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *  * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
 *    be used to endorse or promote products derived from this software without
 *    specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ""AS IS""
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

/** \\file     QuantRDOQ.cpp
    \\brief    transform and quantization class
*/

#include ""QuantRDOQ.h""
#if JEM_TOOLS
#include ""TrQuant_EMT.h""
#endif

#include ""UnitTools.h""
#include ""ContextModelling.h""
#include ""CodingStructure.h""
#include ""CrossCompPrediction.h""

#include ""dtrace_next.h""
#include ""dtrace_buffer.h""

#include <stdlib.h>
#include <limits>
#include <memory.h>


struct coeffGroupRDStats
{
  int    iNNZbeforePos0;
  double d64CodedLevelandDist; // distortion and level cost only
  double d64UncodedDist;    // all zero coded block distortion
  double d64SigCost;
  double d64SigCost_0;
};


//! \\ingroup CommonLib
//! \\{

// ====================================================================================================================
// Constants
// ====================================================================================================================


// ====================================================================================================================
// Static functions
// ====================================================================================================================

// ====================================================================================================================
// QuantRDOQ class member functions
// ====================================================================================================================


QuantRDOQ::QuantRDOQ( const Quant* other ) : Quant( other )
{

  const QuantRDOQ *rdoq = dynamic_cast<const QuantRDOQ*>( other );
  CHECK( other && !rdoq, ""The RDOQ cast must be successfull!"" );
#if HEVC_USE_SCALING_LISTS
  xInitScalingList( rdoq );
#endif
}

QuantRDOQ::~QuantRDOQ()
{
#if HEVC_USE_SCALING_LISTS
  xDestroyScalingList();
#endif
}




/** Get the best level in RD sense
 *
 * \\returns best quantized transform level for given scan position
 *
 * This method calculates the best quantized transform level for a given scan position.
 */
#if JVET_K0072
inline uint32_t QuantRDOQ::xGetCodedLevel( double&            rd64CodedCost,
                                       double&            rd64CodedCost0,
                                       double&            rd64CodedCostSig,
                                       Intermediate_Int   lLevelDouble,
                                       uint32_t               uiMaxAbsLevel,
                                       const BinFracBits* fracBitsSig,
                                       const BinFracBits& fracBitsPar,
                                       const BinFracBits& fracBitsGt1,
                                       const BinFracBits& fracBitsGt2,
                                       uint16_t             ui16AbsGoRice,
                                       int                iQBits,
                                       double             errorScale,
                                       bool               bLast,
                                       bool               useLimitedPrefixLength,
                                       const int          maxLog2TrDynamicRange
                                     ) const
{
  double dCurrCostSig   = 0;
  uint32_t   uiBestAbsLevel = 0;

  if( !bLast && uiMaxAbsLevel < 3 )
  {
    rd64CodedCostSig    = xGetRateSigCoef( *fracBitsSig, 0 );
    rd64CodedCost       = rd64CodedCost0 + rd64CodedCostSig;
    if( uiMaxAbsLevel == 0 )
    {
      return uiBestAbsLevel;
    }
  }
  else
  {
    rd64CodedCost       = MAX_DOUBLE;
  }

  if( !bLast )
  {
    dCurrCostSig        = xGetRateSigCoef( *fracBitsSig, 1 );
  }

  uint32_t uiMinAbsLevel    = ( uiMaxAbsLevel > 1 ? uiMaxAbsLevel - 1 : 1 );
  for( int uiAbsLevel  = uiMaxAbsLevel; uiAbsLevel >= uiMinAbsLevel ; uiAbsLevel-- )
  {
    double dErr         = double( lLevelDouble  - ( Intermediate_Int(uiAbsLevel) << iQBits ) );
    double dCurrCost    = dErr * dErr * errorScale + xGetICost( xGetICRate( uiAbsLevel, fracBitsPar, fracBitsGt1, fracBitsGt2, ui16AbsGoRice, useLimitedPrefixLength, maxLog2TrDynamicRange ) );
    dCurrCost          += dCurrCostSig;

    if( dCurrCost < rd64CodedCost )
    {
      uiBestAbsLevel    = uiAbsLevel;
      rd64CodedCost     = dCurrCost;
      rd64CodedCostSig  = dCurrCostSig;
    }
  }

  return uiBestAbsLevel;
}
#else
inline uint32_t QuantRDOQ::xGetCodedLevel  ( double&            rd64CodedCost,
                                       double&            rd64CodedCost0,
                                       double&            rd64CodedCostSig,
                                       Intermediate_Int   lLevelDouble,
                                       uint32_t               uiMaxAbsLevel,
                                       const BinFracBits* fracBitsSig,
                                       const BinFracBits& fracBitsOne,
                                       const BinFracBits& fracBitsAbs,
#if JEM_TOOLS
                                       const bool         useAltRC,
#endif
                                       uint16_t             ui16AbsGoRice,
                                       uint32_t               c1Idx,
                                       uint32_t               c2Idx,
                                       int                iQBits,
                                       double             errorScale,
                                       bool               bLast,
                                       bool               useLimitedPrefixLength,
                                       const int          maxLog2TrDynamicRange
                                     ) const
{
  double dCurrCostSig   = 0;
  uint32_t   uiBestAbsLevel = 0;

  if( !bLast && uiMaxAbsLevel < 3 )
  {
    rd64CodedCostSig    = xGetRateSigCoef( *fracBitsSig, 0 );
    rd64CodedCost       = rd64CodedCost0 + rd64CodedCostSig;
    if( uiMaxAbsLevel == 0 )
    {
      return uiBestAbsLevel;
    }
  }
  else
  {
    rd64CodedCost       = MAX_DOUBLE;
  }

  if( !bLast )
  {
    dCurrCostSig        = xGetRateSigCoef( *fracBitsSig, 1 );
  }

  uint32_t uiMinAbsLevel    = ( uiMaxAbsLevel > 1 ? uiMaxAbsLevel - 1 : 1 );
  for( int uiAbsLevel  = uiMaxAbsLevel; uiAbsLevel >= uiMinAbsLevel ; uiAbsLevel-- )
  {
    double dErr         = double( lLevelDouble  - ( Intermediate_Int(uiAbsLevel) << iQBits ) );
#if JEM_TOOLS
    double dCurrCost    = dErr * dErr * errorScale + xGetICost( xGetICRate( uiAbsLevel, fracBitsOne, fracBitsAbs, useAltRC, ui16AbsGoRice, c1Idx, c2Idx, useLimitedPrefixLength, maxLog2TrDynamicRange ) );
#else
    double dCurrCost    = dErr * dErr * errorScale + xGetICost( xGetICRate( uiAbsLevel, fracBitsOne, fracBitsAbs, ui16AbsGoRice, c1Idx, c2Idx, useLimitedPrefixLength, maxLog2TrDynamicRange ) );
#endif
    dCurrCost          += dCurrCostSig;

    if( dCurrCost < rd64CodedCost )
    {
      uiBestAbsLevel    = uiAbsLevel;
      rd64CodedCost     = dCurrCost;
      rd64CodedCostSig  = dCurrCostSig;
    }
  }

  return uiBestAbsLevel;
}
#endif

/** Calculates the cost for specific absolute transform level
 * \\param uiAbsLevel scaled quantized level
 * \\param ui16CtxNumOne current ctxInc for coeff_abs_level_greater1 (1st bin of coeff_abs_level_minus1 in AVC)
 * \\param ui16CtxNumAbs current ctxInc for coeff_abs_level_greater2 (remaining bins of coeff_abs_level_minus1 in AVC)
 * \\param ui16AbsGoRice Rice parameter for coeff_abs_level_minus3
 * \\param c1Idx
 * \\param c2Idx
 * \\param useLimitedPrefixLength
 * \\param maxLog2TrDynamicRange
 * \\returns cost of given absolute transform level
 */
#if JVET_K0072
inline int QuantRDOQ::xGetICRate( const uint32_t         uiAbsLevel,
                                  const BinFracBits& fracBitsPar,
                                  const BinFracBits& fracBitsGt1,
                                  const BinFracBits& fracBitsGt2,
                                  const uint16_t       ui16AbsGoRice,
                                  const bool         useLimitedPrefixLength,
                                  const int          maxLog2TrDynamicRange  ) const
{
  int iRate = int( xGetIEPRate() ); // cost of sign bit

  if( uiAbsLevel >= 5 )
  {
    uint32_t symbol = ( uiAbsLevel - 5 ) >> 1;
    uint32_t length;
    const int threshold = g_auiGoRiceRange[ui16AbsGoRice];
    if( symbol < ( threshold << ui16AbsGoRice ) )
    {
      length = symbol >> ui16AbsGoRice;
      iRate += ( length + 1 + ui16AbsGoRice ) << SCALE_BITS;
    }
    else if( useLimitedPrefixLength )
    {
      const uint32_t maximumPrefixLength = ( 32 - ( COEF_REMAIN_BIN_REDUCTION + maxLog2TrDynamicRange ) );

      uint32_t prefixLength = 0;
      uint32_t suffix = ( symbol >> ui16AbsGoRice ) - COEF_REMAIN_BIN_REDUCTION;

      while( ( prefixLength < maximumPrefixLength ) && ( suffix > ( ( 2 << prefixLength ) - 2 ) ) )
      {
        prefixLength++;
      }

      const uint32_t suffixLength = ( prefixLength == maximumPrefixLength ) ? ( maxLog2TrDynamicRange - ui16AbsGoRice ) : ( prefixLength + 1/*separator*/ );

      iRate += ( COEF_REMAIN_BIN_REDUCTION + prefixLength + suffixLength + ui16AbsGoRice ) << SCALE_BITS;
    }
    else
    {
      length = ui16AbsGoRice;
      symbol = symbol - ( threshold << ui16AbsGoRice );
      while( symbol >= ( 1 << length ) )
      {
        symbol -= ( 1 << ( length++ ) );
      }
      iRate += ( threshold + length + 1 - ui16AbsGoRice + length ) << SCALE_BITS;
    }

    iRate += fracBitsPar.intBits[( uiAbsLevel - 1 ) & 1];
    iRate += fracBitsGt1.intBits[1];
    iRate += fracBitsGt2.intBits[1];
  }
  else if( uiAbsLevel == 1 )
  {
    iRate += fracBitsPar.intBits[0];
    iRate += fracBitsGt1.intBits[0];
  }
  else if( uiAbsLevel == 2 )
  {
    iRate += fracBitsPar.intBits[1];
    iRate += fracBitsGt1.intBits[0];
  }
  else if( uiAbsLevel == 3 )
  {
    iRate += fracBitsPar.intBits[0];
    iRate += fracBitsGt1.intBits[1];
    iRate += fracBitsGt2.intBits[0];
  }
  else if( uiAbsLevel == 4 )
  {
    iRate += fracBitsPar.intBits[1];
    iRate += fracBitsGt1.intBits[1];
    iRate += fracBitsGt2.intBits[0];
  }
  else
  {
    iRate = 0;
  }
  return  iRate;
}
#else
inline int QuantRDOQ::xGetICRate  ( const uint32_t   uiAbsLevel,
                                  const BinFracBits& fracBitsOne,
                                  const BinFracBits& fracBitsAbs,
#if JEM_TOOLS
                                  const bool   useAltRC,
#endif
                                  const uint16_t ui16AbsGoRice,
                                  const uint32_t   c1Idx,
                                  const uint32_t   c2Idx,
                                  const bool   useLimitedPrefixLength,
                                  const int maxLog2TrDynamicRange
                                ) const
{
  int  iRate      = int(xGetIEPRate()); // cost of sign bit
  uint32_t baseLevel  = (c1Idx < C1FLAG_NUMBER) ? (2 + (c2Idx < C2FLAG_NUMBER)) : 1;

  if ( uiAbsLevel >= baseLevel )
  {
    uint32_t symbol     = uiAbsLevel - baseLevel;
    uint32_t length;
#if JEM_TOOLS
    const int threshold = useAltRC ? g_auiGoRiceRange[ ui16AbsGoRice ] : COEF_REMAIN_BIN_REDUCTION;
#else
    const int threshold = COEF_REMAIN_BIN_REDUCTION;
#endif
    if( symbol < ( threshold << ui16AbsGoRice ) )
    {
      length = symbol>>ui16AbsGoRice;
      iRate += (length+1+ui16AbsGoRice)<< SCALE_BITS;
    }
    else if (useLimitedPrefixLength)
    {
      const uint32_t maximumPrefixLength = (32 - (COEF_REMAIN_BIN_REDUCTION + maxLog2TrDynamicRange));

      uint32_t prefixLength = 0;
      uint32_t suffix       = (symbol >> ui16AbsGoRice) - COEF_REMAIN_BIN_REDUCTION;

      while ((prefixLength < maximumPrefixLength) && (suffix > ((2 << prefixLength) - 2)))
      {
        prefixLength++;
      }

      const uint32_t suffixLength = (prefixLength == maximumPrefixLength) ? (maxLog2TrDynamicRange - ui16AbsGoRice) : (prefixLength + 1/*separator*/);

      iRate += (COEF_REMAIN_BIN_REDUCTION + prefixLength + suffixLength + ui16AbsGoRice) << SCALE_BITS;
    }
    else
    {
      length = ui16AbsGoRice;
      symbol  = symbol - ( threshold << ui16AbsGoRice);
      while (symbol >= (1<<length))
      {
        symbol -=  (1<<(length++));
      }
      iRate += (threshold+length+1-ui16AbsGoRice+length)<< SCALE_BITS;
    }

    if (c1Idx < C1FLAG_NUMBER)
    {
      iRate += fracBitsOne.intBits[1];

      if (c2Idx < C2FLAG_NUMBER)
      {
        iRate += fracBitsAbs.intBits[1];
      }
    }
  }
  else if( uiAbsLevel == 1 )
  {
    iRate += fracBitsOne.intBits[0];
  }
  else if( uiAbsLevel == 2 )
  {
    iRate += fracBitsOne.intBits[1];
    iRate += fracBitsAbs.intBits[0];
  }
  else
  {
    iRate = 0;
  }

  return  iRate;
}
#endif

inline double QuantRDOQ::xGetRateSigCoeffGroup( const BinFracBits& fracBitsSigCG, unsigned uiSignificanceCoeffGroup ) const
{
  return xGetICost( fracBitsSigCG.intBits[uiSignificanceCoeffGroup] );
}

/** Calculates the cost of signaling the last significant coefficient in the block
 * \\param uiPosX X coordinate of the last significant coefficient
 * \\param uiPosY Y coordinate of the last significant coefficient
 * \\param component colour component ID
 * \\returns cost of last significant coefficient
 */
/*
 * \\param uiWidth width of the transform unit (TU)
*/
inline double QuantRDOQ::xGetRateLast( const int* lastBitsX, const int* lastBitsY, unsigned PosX, unsigned PosY ) const
{
  uint32_t    CtxX  = g_uiGroupIdx[PosX];
  uint32_t    CtxY  = g_uiGroupIdx[PosY];
  double  Cost  = lastBitsX[ CtxX ] + lastBitsY[ CtxY ];
  if( CtxX > 3 )
  {
    Cost += xGetIEPRate() * ((CtxX-2)>>1);
  }
  if( CtxY > 3 )
  {
    Cost += xGetIEPRate() * ((CtxY-2)>>1);
  }
  return xGetICost( Cost );
}


inline double QuantRDOQ::xGetRateSigCoef( const BinFracBits& fracBitsSig, unsigned uiSignificance ) const
{
  return xGetICost( fracBitsSig.intBits[uiSignificance] );
}

/** Get the cost for a specific rate
 * \\param dRate rate of a bit
 * \\returns cost at the specific rate
 */
inline double QuantRDOQ::xGetICost        ( double                          dRate         ) const
{
  return m_dLambda * dRate;
}

/** Get the cost of an equal probable bit
 * \\returns cost of equal probable bit
 */
inline double QuantRDOQ::xGetIEPRate      (                                               ) const
{
  return 32768;
}



#if HEVC_USE_SCALING_LISTS
/** set quantized matrix coefficient for encode
 * \\param scalingList            quantized matrix address
 * \\param format                 chroma format
 * \\param maxLog2TrDynamicRange
 * \\param bitDepths              reference to bit depth array for all channels
 */
void QuantRDOQ::setScalingList(ScalingList *scalingList, const int maxLog2TrDynamicRange[MAX_NUM_CHANNEL_TYPE], const BitDepths &bitDepths)
{
  Quant::setScalingList( scalingList, maxLog2TrDynamicRange, bitDepths );

  const int minimumQp = 0;
  const int maximumQp = SCALING_LIST_REM_NUM;

  for(uint32_t size = 0; size < SCALING_LIST_SIZE_NUM; size++)
  {
    for(uint32_t list = 0; list < SCALING_LIST_NUM; list++)
    {
      for(int qp = minimumQp; qp < maximumQp; qp++)
      {
//         xSetScalingListEnc(scalingList,list,size,qp);
//         xSetScalingListDec(*scalingList,list,size,qp);
        xSetErrScaleCoeff(list,size, size,qp,maxLog2TrDynamicRange, bitDepths);
      }
    }
  }
}



#if HM_QTBT_AS_IN_JEM_QUANT
#endif
#else

double QuantRDOQ::xGetErrScaleCoeff( SizeType width, SizeType height, int qp, const int maxLog2TrDynamicRange, const int channelBitDepth )
{
  const int iTransformShift = getTransformShift(channelBitDepth, Size(width, height), maxLog2TrDynamicRange);
#if HM_QTBT_AS_IN_JEM_QUANT
  double    dErrScale       = (double)( 1 << SCALE_BITS );                                // Compensate for scaling of bitcount in Lagrange cost function
  bool      needsSrqt2      = TU::needsBlockSizeTrafoScale( Size(width, height) );// ( ( (sizeX+sizeY) & 1 ) !=0 );
  double    dTransShift     = (double)iTransformShift + ( needsSrqt2 ? -0.5 : 0.0 );
  dErrScale                 = dErrScale*pow( 2.0, ( -2.0*dTransShift ) );                     // Compensate for scaling through forward transform
  int       QStep           = ( needsSrqt2 ? ( ( g_quantScales[qp] * 181 ) >> 7 ) : g_quantScales[qp] );
#if DISTORTION_LAMBDA_BUGFIX
  double    finalErrScale = dErrScale / QStep / QStep / (1 << (DISTORTION_PRECISION_ADJUSTMENT(channelBitDepth) << 1));
#else
  double finalErrScale = dErrScale / QStep / QStep / (1 << DISTORTION_PRECISION_ADJUSTMENT(2 * (channelBitDepth - 8)));
#endif
#else
#if DISTORTION_LAMBDA_BUGFIX
  int errShift = SCALE_BITS - ((iTransformShift + DISTORTION_PRECISION_ADJUSTMENT(channelBitDepth)) << 1);
#else
  int       errShift        = SCALE_BITS - ( ( iTransformShift + DISTORTION_PRECISION_ADJUSTMENT( channelBitDepth - 8 ) ) << 1 );
#endif
  double    dErrScale       = exp2( double( errShift ) );
  double    finalErrScale   = dErrScale / double( g_quantScales[qp] * g_quantScales[qp] );
#endif
  return    finalErrScale;
}
#endif



#if HEVC_USE_SCALING_LISTS
/** set error scale coefficients
 * \\param list                   list ID
 * \\param size
 * \\param qp                     quantization parameter
 * \\param maxLog2TrDynamicRange
 * \\param bitDepths              reference to bit depth array for all channels
 */
void QuantRDOQ::xSetErrScaleCoeff( uint32_t list, uint32_t sizeX, uint32_t sizeY, int qp, const int maxLog2TrDynamicRange[MAX_NUM_CHANNEL_TYPE], const BitDepths &bitDepths )
{
  const int width = g_scalingListSizeX[sizeX];
  const int height = g_scalingListSizeX[sizeY];
  const ChannelType channelType = ( ( list == 0 ) || ( list == MAX_NUM_COMPONENT ) ) ? CHANNEL_TYPE_LUMA : CHANNEL_TYPE_CHROMA;
  const int channelBitDepth = bitDepths.recon[channelType];
  const int iTransformShift = getTransformShift( channelBitDepth, Size( g_scalingListSizeX[sizeX], g_scalingListSizeX[sizeY] ), maxLog2TrDynamicRange[channelType] );  // Represents scaling through forward transform

  uint32_t i, uiMaxNumCoeff = width * height;
  int *piQuantcoeff;
  double *pdErrScale;
  piQuantcoeff = getQuantCoeff( list, qp, sizeX, sizeY );
  pdErrScale   = xGetErrScaleCoeff( list, sizeX, sizeY, qp );

#if HM_QTBT_AS_IN_JEM_QUANT
  double dErrScale = (double)( 1 << SCALE_BITS );                                // Compensate for scaling of bitcount in Lagrange cost function

  bool   needsSrqt2 = TU::needsBlockSizeTrafoScale( Size( g_scalingListSizeX[sizeX], g_scalingListSizeX[sizeY] ) );// ( ( (sizeX+sizeY) & 1 ) !=0 );
  double dTransShift = (double)iTransformShift + ( needsSrqt2 ? -0.5 : 0.0 );
  dErrScale = dErrScale*pow( 2.0, ( -2.0*dTransShift ) );                     // Compensate for scaling through forward transform

  for( i = 0; i < uiMaxNumCoeff; i++ )
  {
#if DISTORTION_LAMBDA_BUGFIX
    pdErrScale[i] = dErrScale / piQuantcoeff[i] / piQuantcoeff[i]
                    / (1 << (DISTORTION_PRECISION_ADJUSTMENT(bitDepths.recon[channelType]) << 1));
#else
    pdErrScale[i] = dErrScale / piQuantcoeff[i] / piQuantcoeff[i] / ( 1 << DISTORTION_PRECISION_ADJUSTMENT( 2 * ( bitDepths.recon[channelType] - 8 ) ) );
#endif
  }

  int QStep = ( needsSrqt2 ? ( ( g_quantScales[qp] * 181 ) >> 7 ) : g_quantScales[qp] );

#if DISTORTION_LAMBDA_BUGFIX
  xGetErrScaleCoeffNoScalingList(list, sizeX, sizeY, qp) =
    dErrScale / QStep / QStep / (1 << (DISTORTION_PRECISION_ADJUSTMENT(bitDepths.recon[channelType]) << 1));
#else
  xGetErrScaleCoeffNoScalingList( list, sizeX, sizeY, qp ) = dErrScale / QStep / QStep / ( 1 << DISTORTION_PRECISION_ADJUSTMENT( 2 * ( bitDepths.recon[channelType] - 8 ) ) );
#endif
#else
#if DISTORTION_LAMBDA_BUGFIX
  int errShift = SCALE_BITS - ((iTransformShift + DISTORTION_PRECISION_ADJUSTMENT(bitDepths.recon[channelType])) << 1);
#else
  int    errShift = SCALE_BITS - ( ( iTransformShift + DISTORTION_PRECISION_ADJUSTMENT( bitDepths.recon[channelType] - 8 ) ) << 1 );
#endif
  double dErrScale = exp2( double( errShift ) );
  for( i = 0; i < uiMaxNumCoeff; i++ )
  {
    pdErrScale[i] = dErrScale / double( piQuantcoeff[i] * piQuantcoeff[i] );
  }
  xGetErrScaleCoeffNoScalingList( list, sizeX, sizeY, qp ) = dErrScale / double( g_quantScales[qp] * g_quantScales[qp] );
#endif
}

/** set flat matrix value to quantized coefficient
 */
void QuantRDOQ::setFlatScalingList(const int maxLog2TrDynamicRange[MAX_NUM_CHANNEL_TYPE], const BitDepths &bitDepths)
{
  Quant::setFlatScalingList( maxLog2TrDynamicRange, bitDepths );

  const int minimumQp = 0;
  const int maximumQp = SCALING_LIST_REM_NUM;

  for(uint32_t sizeX = 0; sizeX < SCALING_LIST_SIZE_NUM; sizeX++)
  {
    for(uint32_t sizeY = 0; sizeY < SCALING_LIST_SIZE_NUM; sizeY++)
    {
      for(uint32_t list = 0; list < SCALING_LIST_NUM; list++)
      {
        for(int qp = minimumQp; qp < maximumQp; qp++)
        {
          xSetErrScaleCoeff( list, sizeX, sizeY, qp, maxLog2TrDynamicRange, bitDepths );
        }
      }
    }
  }
}

/** initialization process of scaling list array
 */
void QuantRDOQ::xInitScalingList( const QuantRDOQ* other )
{
  m_isErrScaleListOwner = other == nullptr;

  for(uint32_t sizeIdX = 0; sizeIdX < SCALING_LIST_SIZE_NUM; sizeIdX++)
  {
    for(uint32_t sizeIdY = 0; sizeIdY < SCALING_LIST_SIZE_NUM; sizeIdY++)
    {
      for(uint32_t qp = 0; qp < SCALING_LIST_REM_NUM; qp++)
      {
        for(uint32_t listId = 0; listId < SCALING_LIST_NUM; listId++)
        {
          if( m_isErrScaleListOwner )
          {
            m_errScale[sizeIdX][sizeIdY][listId][qp] = new double[g_scalingListSizeX[sizeIdX] * g_scalingListSizeX[sizeIdY]];
          }
          else
          {
            m_errScale[sizeIdX][sizeIdY][listId][qp] = other->m_errScale[sizeIdX][sizeIdY][listId][qp];
          }
        } // listID loop
      }
    }
  }
}

/** destroy quantization matrix array
 */
void QuantRDOQ::xDestroyScalingList()
{
  if( !m_isErrScaleListOwner ) return;

  for(uint32_t sizeIdX = 0; sizeIdX < SCALING_LIST_SIZE_NUM; sizeIdX++)
  {
    for(uint32_t sizeIdY = 0; sizeIdY < SCALING_LIST_SIZE_NUM; sizeIdY++)
    {
      for(uint32_t listId = 0; listId < SCALING_LIST_NUM; listId++)
      {
        for(uint32_t qp = 0; qp < SCALING_LIST_REM_NUM; qp++)
        {
          if(m_errScale[sizeIdX][sizeIdY][listId][qp])
          {
            delete [] m_errScale[sizeIdX][sizeIdY][listId][qp];
          }
        }
      }
    }
  }
//   Quant::destroyScalingList();
}
#endif


void QuantRDOQ::quant(TransformUnit &tu, const ComponentID &compID, const CCoeffBuf &pSrc, TCoeff &uiAbsSum, const QpParam &cQP, const Ctx& ctx)
{
  const CompArea &rect      = tu.blocks[compID];
  const uint32_t uiWidth        = rect.width;
  const uint32_t uiHeight       = rect.height;

  const CCoeffBuf &piCoef   = pSrc;
        CoeffBuf   piQCoef  = tu.getCoeffs(compID);

  const bool useTransformSkip      = tu.transformSkip[compID];

  bool useRDOQ = useTransformSkip ? m_useRDOQTS : m_useRDOQ;

  {
    useRDOQ &= uiWidth > 2;
    useRDOQ &= uiHeight > 2;
  }

  if (useRDOQ && (isLuma(compID) || RDOQ_CHROMA))
  {
#if T0196_SELECTIVE_RDOQ
    if (!m_useSelectiveRDOQ || xNeedRDOQ(tu, compID, piCoef, cQP))
    {
#endif
      xRateDistOptQuant( tu, compID, pSrc, uiAbsSum, cQP, ctx );
#if T0196_SELECTIVE_RDOQ
    }
    else
    {
      piQCoef.fill(0);
      uiAbsSum = 0;
    }
#endif
  }
  else
  {
    Quant::quant( tu, compID, pSrc, uiAbsSum, cQP, ctx );
  }
}



void QuantRDOQ::xRateDistOptQuant(TransformUnit &tu, const ComponentID &compID, const CCoeffBuf &pSrc, TCoeff &uiAbsSum, const QpParam &cQP, const Ctx &ctx)
{
  const FracBitsAccess& fracBits = ctx.getFracBitsAcess();

  const SPS &sps            = *tu.cs->sps;
#if JVET_K0072
#else
#if HEVC_USE_SIGN_HIDING
  const PPS &pps            = *tu.cs->pps;
#endif
#endif
  const CompArea &rect      = tu.blocks[compID];
  const uint32_t uiWidth        = rect.width;
  const uint32_t uiHeight       = rect.height;
  const ChannelType chType  = toChannelType(compID);
  const int channelBitDepth = sps.getBitDepth( chType );

  const bool extendedPrecision     = sps.getSpsRangeExtension().getExtendedPrecisionProcessingFlag();
  const int  maxLog2TrDynamicRange = sps.getMaxLog2TrDynamicRange(chType);

  /* for 422 chroma blocks, the effective scaling applied during transformation is not a power of 2, hence it cannot be
  * implemented as a bit-shift (the quantised result will be sqrt(2) * larger than required). Alternatively, adjust the
  * uiLog2TrSize applied in iTransformShift, such that the result is 1/sqrt(2) the required result (i.e. smaller)
  * Then a QP+3 (sqrt(2)) or QP-3 (1/sqrt(2)) method could be used to get the required result
  */

  // Represents scaling through forward transform
  int iTransformShift = getTransformShift(channelBitDepth, rect.size(), maxLog2TrDynamicRange);

  if (tu.transformSkip[compID] && extendedPrecision)
  {
    iTransformShift = std::max<int>(0, iTransformShift);
  }

#if JVET_K0072
#else
  const bool bUseGolombRiceParameterAdaptation = sps.getSpsRangeExtension().getPersistentRiceAdaptationEnabledFlag();
  const uint32_t initialGolombRiceParameter        = ctx.getGRAdaptStats(TU::getGolombRiceStatisticsIndex(tu, compID)) >> 2;
  uint32_t uiGoRiceParam                           = initialGolombRiceParameter;
#endif
  double     d64BlockUncodedCost               = 0;
  const uint32_t uiLog2BlockWidth                  = g_aucLog2[uiWidth];
#if HEVC_USE_SCALING_LISTS
  const uint32_t uiLog2BlockHeight                 = g_aucLog2[uiHeight];
#endif
  const uint32_t uiMaxNumCoeff                     = rect.area();

  CHECK(compID >= MAX_NUM_TBLOCKS, ""Invalid component ID"");

#if HEVC_USE_SCALING_LISTS
  int scalingListType = getScalingListType(tu.cu->predMode, compID);

  CHECK(scalingListType >= SCALING_LIST_NUM, ""Invalid scaling list"");
#endif

  const TCoeff *plSrcCoeff = pSrc.buf;
        TCoeff *piDstCoeff = tu.getCoeffs(compID).buf;

  double *pdCostCoeff  = m_pdCostCoeff;
  double *pdCostSig    = m_pdCostSig;
  double *pdCostCoeff0 = m_pdCostCoeff0;
#if HEVC_USE_SIGN_HIDING
  int    *rateIncUp    = m_rateIncUp;
  int    *rateIncDown  = m_rateIncDown;
  int    *sigRateDelta = m_sigRateDelta;
  TCoeff *deltaU       = m_deltaU;
#endif

  memset( m_pdCostCoeff,  0, sizeof( double ) *  uiMaxNumCoeff );
  memset( m_pdCostSig,    0, sizeof( double ) *  uiMaxNumCoeff );
#if HEVC_USE_SIGN_HIDING
  memset( m_rateIncUp,    0, sizeof( int    ) *  uiMaxNumCoeff );
  memset( m_rateIncDown,  0, sizeof( int    ) *  uiMaxNumCoeff );
  memset( m_sigRateDelta, 0, sizeof( int    ) *  uiMaxNumCoeff );
  memset( m_deltaU,       0, sizeof( TCoeff ) *  uiMaxNumCoeff );
#endif

#if JVET_K0072
#else
#if JEM_TOOLS
  const unsigned altResiCompId = tu.cs->sps->getSpsNext().getAltResiCompId();
#endif
#endif

  const int iQBits = QUANT_SHIFT + cQP.per + iTransformShift;                   // Right shift of non-RDOQ quantizer;  level = (coeff*uiQ + offset)>>q_bits

#if HEVC_USE_SCALING_LISTS
  const double *const pdErrScale = xGetErrScaleCoeff(scalingListType, (uiLog2BlockWidth-1), (uiLog2BlockHeight-1), cQP.rem);
  const int    *const piQCoef    = getQuantCoeff(scalingListType, cQP.rem, (uiLog2BlockWidth-1), (uiLog2BlockHeight-1));

  const bool   enableScalingLists             = getUseScalingList(uiWidth, uiHeight, tu.transformSkip[compID]);
#if HM_QTBT_AS_IN_JEM_QUANT
  const int    defaultQuantisationCoefficient = ( TU::needsSqrt2Scale( rect ) ? ( g_quantScales[cQP.rem] * 181 ) >> 7 : g_quantScales[cQP.rem] );
  const double defaultErrorScale              = xGetErrScaleCoeffNoScalingList(scalingListType, (uiLog2BlockWidth-1), (uiLog2BlockHeight-1), cQP.rem);
#else
  const double blkErrScale                    = ( TU::needsQP3Offset( tu, compID ) ? 2.0 : 1.0 );
  const int    defaultQuantisationCoefficient = g_quantScales[cQP.rem];
  const double defaultErrorScale              = blkErrScale * xGetErrScaleCoeffNoScalingList( scalingListType, ( uiLog2BlockWidth - 1 ), ( uiLog2BlockHeight - 1 ), cQP.rem );
#endif
#else //HEVC_USE_SCALING_LISTS
#if HM_QTBT_AS_IN_JEM_QUANT
  const int    quantisationCoefficient = ( TU::needsSqrt2Scale( rect ) ? ( g_quantScales[cQP.rem] * 181 ) >> 7 : g_quantScales[cQP.rem] );
  const double errorScale              = xGetErrScaleCoeff( uiWidth, uiHeight, cQP.rem, maxLog2TrDynamicRange, channelBitDepth );
#else
  const double blkErrScale             = ( TU::needsQP3Offset( tu, compID ) ? 2.0 : 1.0 );
  const int    quantisationCoefficient = g_quantScales[cQP.rem];
  const double errorScale              = blkErrScale * xGetErrScaleCoeff( uiWidth, uiHeight, cQP.rem, maxLog2TrDynamicRange, channelBitDepth );
#endif
#endif//HEVC_USE_SCALING_LISTS


#if HEVC_USE_SIGN_HIDING
  const TCoeff entropyCodingMinimum = -(1 << maxLog2TrDynamicRange);
#endif
  const TCoeff entropyCodingMaximum =  (1 << maxLog2TrDynamicRange) - 1;

#if HEVC_USE_SIGN_HIDING
#if JVET_K0072
  CoeffCodingContext cctx(tu, compID, tu.cs->slice->getSignDataHidingEnabledFlag());
#else
  CoeffCodingContext cctx(tu, compID, pps.getSignDataHidingEnabledFlag());
#endif
#else
  CoeffCodingContext cctx(tu, compID);
#endif
  const int    iCGSizeM1      = (1 << cctx.log2CGSize()) - 1;

  int     iCGLastScanPos      = -1;
#if JVET_K0072
#else
  int     c1                  = 1;
  int     c2                  = 0;
#endif
  double  d64BaseCost         = 0;
  int     iLastScanPos        = -1;

#if JVET_K0072
#else
  uint32_t    c1Idx     = 0;
  uint32_t    c2Idx     = 0;
  int     baseLevel;
#endif

  double *pdCostCoeffGroupSig = m_pdCostCoeffGroupSig;
  memset( pdCostCoeffGroupSig, 0, ( uiMaxNumCoeff >> cctx.log2CGSize() ) * sizeof( double ) );

  const int iCGNum  = uiWidth * uiHeight >> cctx.log2CGSize();
  int iScanPos;
  coeffGroupRDStats rdStats;

#if ENABLE_TRACING
  DTRACE( g_trace_ctx, D_RDOQ, ""%d: %3d, %3d, %dx%d, comp=%d\\n"", DTRACE_GET_COUNTER( g_trace_ctx, D_RDOQ ), rect.x, rect.y, rect.width, rect.height, compID );
#endif



  for (int subSetId = iCGNum - 1; subSetId >= 0; subSetId--)
  {
    cctx.initSubblock( subSetId );

    memset( &rdStats, 0, sizeof (coeffGroupRDStats));

    for (int iScanPosinCG = iCGSizeM1; iScanPosinCG >= 0; iScanPosinCG--)
    {
      iScanPos = cctx.minSubPos() + iScanPosinCG;
      //===== quantization =====
      uint32_t    uiBlkPos          = cctx.blockPos(iScanPos);

      // set coeff
#if HEVC_USE_SCALING_LISTS
      const int    quantisationCoefficient = (enableScalingLists) ? piQCoef   [uiBlkPos]               : defaultQuantisationCoefficient;
#if HM_QTBT_AS_IN_JEM_QUANT
      const double errorScale              = (enableScalingLists) ? pdErrScale[uiBlkPos]               : defaultErrorScale;
#else
      const double errorScale              = (enableScalingLists) ? pdErrScale[uiBlkPos] * blkErrScale : defaultErrorScale;
#endif
#endif
      const int64_t  tmpLevel                = int64_t(abs(plSrcCoeff[ uiBlkPos ])) * quantisationCoefficient;

      const Intermediate_Int lLevelDouble  = (Intermediate_Int)std::min<int64_t>(tmpLevel, std::numeric_limits<Intermediate_Int>::max() - (Intermediate_Int(1) << (iQBits - 1)));

      uint32_t uiMaxAbsLevel        = std::min<uint32_t>(uint32_t(entropyCodingMaximum), uint32_t((lLevelDouble + (Intermediate_Int(1) << (iQBits - 1))) >> iQBits));

      const double dErr         = double( lLevelDouble );
      pdCostCoeff0[ iScanPos ]  = dErr * dErr * errorScale;
      d64BlockUncodedCost      += pdCostCoeff0[ iScanPos ];
      piDstCoeff[ uiBlkPos ]    = uiMaxAbsLevel;

      if ( uiMaxAbsLevel > 0 && iLastScanPos < 0 )
      {
        iLastScanPos            = iScanPos;
        iCGLastScanPos          = cctx.subSetId();
      }

      if ( iLastScanPos >= 0 )
      {

#if ENABLE_TRACING
        uint32_t uiCGPosY = cctx.cgPosX();
        uint32_t uiCGPosX = cctx.cgPosY();
        uint32_t uiPosY = cctx.posY( iScanPos );
        uint32_t uiPosX = cctx.posX( iScanPos );
        DTRACE( g_trace_ctx, D_RDOQ, ""%d [%d][%d][%2d:%2d][%2d:%2d]"", DTRACE_GET_COUNTER( g_trace_ctx, D_RDOQ ), iScanPos, uiBlkPos, uiCGPosX, uiCGPosY, uiPosX, uiPosY );
#if JVET_K0072
#else
        DTRACE( g_trace_ctx, D_RDOQ, "" c1: %d, c2: %d, c1Idx: %d, c2Idx: %d\\n"", c1, c2, c1Idx, c2Idx );
#endif
#endif
        //===== coefficient level estimation =====
        unsigned ctxIdSig = 0;
        if( iScanPos != iLastScanPos )
        {
#if JVET_K0072
          ctxIdSig = cctx.sigCtxIdAbs( iScanPos, piDstCoeff, 0 );
#else
#if JEM_TOOLS
          ctxIdSig = altResiCompId ? cctx.sigCtxId( iScanPos, piDstCoeff ) : cctx.sigCtxId( iScanPos );
#else
          ctxIdSig = cctx.sigCtxId( iScanPos );
#endif
#endif
        }
        uint32_t    uiLevel;
#if JVET_K0072
        uint8_t ctxOffset     = cctx.ctxOffsetAbs     ();
        uint32_t    uiParCtx      = cctx.parityCtxIdAbs   ( ctxOffset );
        uint32_t    uiGt1Ctx      = cctx.greater1CtxIdAbs ( ctxOffset );
        uint32_t    uiGt2Ctx      = cctx.greater2CtxIdAbs ( ctxOffset );
        uint32_t    uiGoRiceParam = cctx.GoRiceParAbs     ( iScanPos, piDstCoeff );

        const BinFracBits fracBitsPar = fracBits.getFracBitsArray( uiParCtx );
        const BinFracBits fracBitsGt1 = fracBits.getFracBitsArray( uiGt1Ctx );
        const BinFracBits fracBitsGt2 = fracBits.getFracBitsArray( uiGt2Ctx );
#else
#if JEM_TOOLS
#if ENABLE_TRACING
        uint32_t uiOneCtx = altResiCompId ? ( iScanPos == iLastScanPos ? cctx.greater1CtxIdOfs() : cctx.greater1CtxId( iScanPos, piDstCoeff ) ) : cctx.greater1CtxId( c1 );
        uint32_t uiAbsCtx = altResiCompId ? ( iScanPos == iLastScanPos ? cctx.greater1CtxIdOfs() : cctx.greater2CtxId( iScanPos, piDstCoeff ) ) : cctx.greater2CtxId();
#endif
        const BinFracBits fracBitsOne = fracBits.getFracBitsArray( altResiCompId ? ( iScanPos == iLastScanPos ? cctx.greater1CtxIdOfs() : cctx.greater1CtxId( iScanPos, piDstCoeff ) ) : cctx.greater1CtxId( c1 ) );
        const BinFracBits fracBitsAbs = fracBits.getFracBitsArray( altResiCompId ? ( iScanPos == iLastScanPos ? cctx.greater1CtxIdOfs() : cctx.greater2CtxId( iScanPos, piDstCoeff ) ) : cctx.greater2CtxId()     );
                        uiGoRiceParam = altResiCompId ? cctx.GoRicePar( iScanPos, piDstCoeff ) : uiGoRiceParam;
#else
#if ENABLE_TRACING
        uint32_t uiOneCtx = cctx.greater1CtxId( c1 );
        uint32_t uiAbsCtx = cctx.greater2CtxId();
#endif
        const BinFracBits fracBitsOne = fracBits.getFracBitsArray( cctx.greater1CtxId( c1 ) );
        const BinFracBits fracBitsAbs = fracBits.getFracBitsArray( cctx.greater2CtxId()     );
#endif

        DTRACE_COND( ( uiMaxAbsLevel != 0 ), g_trace_ctx, D_RDOQ_MORE, "" One=%d Abs=%d"", uiOneCtx, uiAbsCtx );
#endif

        if( iScanPos == iLastScanPos )
        {
#if JVET_K0072
          uiLevel = xGetCodedLevel( pdCostCoeff[ iScanPos ], pdCostCoeff0[ iScanPos ], pdCostSig[ iScanPos ],
                                    lLevelDouble, uiMaxAbsLevel, nullptr, fracBitsPar, fracBitsGt1, fracBitsGt2, uiGoRiceParam, iQBits, errorScale, 1, extendedPrecision, maxLog2TrDynamicRange );
#else
          uiLevel              = xGetCodedLevel( pdCostCoeff[ iScanPos ], pdCostCoeff0[ iScanPos ], pdCostSig[ iScanPos ],
                                                 lLevelDouble, uiMaxAbsLevel, nullptr, fracBitsOne, fracBitsAbs, 
#if JEM_TOOLS
                                                 altResiCompId, 
#endif
                                                 uiGoRiceParam, c1Idx, c2Idx, iQBits, errorScale, 1, extendedPrecision, maxLog2TrDynamicRange );
#endif
        }
        else
        {
          DTRACE_COND( ( uiMaxAbsLevel != 0 ), g_trace_ctx, D_RDOQ_MORE, "" uiCtxSig=%d"", ctxIdSig );

          const BinFracBits fracBitsSig = fracBits.getFracBitsArray( ctxIdSig );
#if JVET_K0072
          uiLevel = xGetCodedLevel( pdCostCoeff[ iScanPos ], pdCostCoeff0[ iScanPos ], pdCostSig[ iScanPos ],
                                    lLevelDouble, uiMaxAbsLevel, &fracBitsSig, fracBitsPar, fracBitsGt1, fracBitsGt2, uiGoRiceParam, iQBits, errorScale, 0, extendedPrecision, maxLog2TrDynamicRange );
#else
          uiLevel              = xGetCodedLevel( pdCostCoeff[ iScanPos ], pdCostCoeff0[ iScanPos ], pdCostSig[ iScanPos ],
                                                lLevelDouble, uiMaxAbsLevel, &fracBitsSig, fracBitsOne, fracBitsAbs, 
#if JEM_TOOLS
                                                altResiCompId, 
#endif
                                                uiGoRiceParam, c1Idx, c2Idx, iQBits, errorScale, 0, extendedPrecision, maxLog2TrDynamicRange );
#endif
#if HEVC_USE_SIGN_HIDING
          sigRateDelta[ uiBlkPos ] = fracBitsSig.intBits[1] - fracBitsSig.intBits[0];
#endif
        }

        DTRACE( g_trace_ctx, D_RDOQ, "" Lev=%d \\n"", uiLevel );
        DTRACE_COND( ( uiMaxAbsLevel != 0 ), g_trace_ctx, D_RDOQ, "" CostC0=%d\\n"", (int64_t)( pdCostCoeff0[iScanPos] ) );
        DTRACE_COND( ( uiMaxAbsLevel != 0 ), g_trace_ctx, D_RDOQ, "" CostC =%d\\n"", (int64_t)( pdCostCoeff[iScanPos] ) );

#if HEVC_USE_SIGN_HIDING
        deltaU[ uiBlkPos ]        = TCoeff((lLevelDouble - (Intermediate_Int(uiLevel) << iQBits)) >> (iQBits-8));

        if( uiLevel > 0 )
        {
#if JVET_K0072
          int rateNow              = xGetICRate( uiLevel,   fracBitsPar, fracBitsGt1, fracBitsGt2, uiGoRiceParam, extendedPrecision, maxLog2TrDynamicRange );
          rateIncUp   [ uiBlkPos ] = xGetICRate( uiLevel+1, fracBitsPar, fracBitsGt1, fracBitsGt2, uiGoRiceParam, extendedPrecision, maxLog2TrDynamicRange ) - rateNow;
          rateIncDown [ uiBlkPos ] = xGetICRate( uiLevel-1, fracBitsPar, fracBitsGt1, fracBitsGt2, uiGoRiceParam, extendedPrecision, maxLog2TrDynamicRange ) - rateNow;
#elif JEM_TOOLS
          int rateNow              = xGetICRate( uiLevel,   fracBitsOne, fracBitsAbs, altResiCompId, uiGoRiceParam, c1Idx, c2Idx, extendedPrecision, maxLog2TrDynamicRange );
          rateIncUp   [ uiBlkPos ] = xGetICRate( uiLevel+1, fracBitsOne, fracBitsAbs, altResiCompId, uiGoRiceParam, c1Idx, c2Idx, extendedPrecision, maxLog2TrDynamicRange ) - rateNow;
          rateIncDown [ uiBlkPos ] = xGetICRate( uiLevel-1, fracBitsOne, fracBitsAbs, altResiCompId, uiGoRiceParam, c1Idx, c2Idx, extendedPrecision, maxLog2TrDynamicRange ) - rateNow;
#else
          int rateNow              = xGetICRate( uiLevel,   fracBitsOne, fracBitsAbs, uiGoRiceParam, c1Idx, c2Idx, extendedPrecision, maxLog2TrDynamicRange );
          rateIncUp   [ uiBlkPos ] = xGetICRate( uiLevel+1, fracBitsOne, fracBitsAbs, uiGoRiceParam, c1Idx, c2Idx, extendedPrecision, maxLog2TrDynamicRange ) - rateNow;
          rateIncDown [ uiBlkPos ] = xGetICRate( uiLevel-1, fracBitsOne, fracBitsAbs, uiGoRiceParam, c1Idx, c2Idx, extendedPrecision, maxLog2TrDynamicRange ) - rateNow;
#endif
        }
        else // uiLevel == 0
        {
#if JVET_K0072
          rateIncUp   [ uiBlkPos ] = fracBitsPar.intBits[ 0 ] + fracBitsGt1.intBits[ 0 ];
#else
          rateIncUp   [ uiBlkPos ] = fracBitsOne.intBits[ 0 ];
#endif
        }
#endif
        piDstCoeff[ uiBlkPos ] = uiLevel;
        d64BaseCost           += pdCostCoeff [ iScanPos ];

#if JVET_K0072
#else
        baseLevel = (c1Idx < C1FLAG_NUMBER) ? (2 + (c2Idx < C2FLAG_NUMBER)) : 1;
        if( uiLevel >= baseLevel )
        {
          if (uiLevel > 3*(1<<uiGoRiceParam))
          {
            uiGoRiceParam = bUseGolombRiceParameterAdaptation ? (uiGoRiceParam + 1) : (std::min<uint32_t>((uiGoRiceParam + 1), 4));
          }
        }
        if ( uiLevel >= 1)
        {
          c1Idx ++;
        }

        //===== update bin model =====
        if( uiLevel > 1 )
        {
          c1 = 0;
          c2 += (c2 < 2);
          c2Idx ++;
        }
        else if( (c1 < 3) && (c1 > 0) && uiLevel)
        {
          c1++;
        }

        //===== context set update =====
        if( ( (iScanPos & iCGSizeM1) == 0 ) && ( iScanPos > 0 ) )
        {
          cctx.setGt2Flag( c1 == 0 );
          c1                = 1;
          c2                = 0;
          c1Idx             = 0;
          c2Idx             = 0;
          uiGoRiceParam     = initialGolombRiceParameter;
        }
#endif
      }
      else
      {
        d64BaseCost    += pdCostCoeff0[ iScanPos ];
      }
      rdStats.d64SigCost += pdCostSig[ iScanPos ];
      if (iScanPosinCG == 0 )
      {
        rdStats.d64SigCost_0 = pdCostSig[ iScanPos ];
      }
      if (piDstCoeff[ uiBlkPos ] )
      {
        cctx.setSigGroup();
        rdStats.d64CodedLevelandDist += pdCostCoeff[ iScanPos ] - pdCostSig[ iScanPos ];
        rdStats.d64UncodedDist += pdCostCoeff0[ iScanPos ];
        if ( iScanPosinCG != 0 )
        {
          rdStats.iNNZbeforePos0++;
        }
      }
    } //end for (iScanPosinCG)

    if (iCGLastScanPos >= 0)
    {
      if( cctx.subSetId() )
      {
        if( !cctx.isSigGroup() )
        {
          const BinFracBits fracBitsSigGroup = fracBits.getFracBitsArray( cctx.sigGroupCtxId() );
          d64BaseCost += xGetRateSigCoeffGroup(fracBitsSigGroup, 0) - rdStats.d64SigCost;
          pdCostCoeffGroupSig[ cctx.subSetId() ] = xGetRateSigCoeffGroup(fracBitsSigGroup, 0);
        }
        else
        {
          if (cctx.subSetId() < iCGLastScanPos) //skip the last coefficient group, which will be handled together with last position below.
          {
            if ( rdStats.iNNZbeforePos0 == 0 )
            {
              d64BaseCost -= rdStats.d64SigCost_0;
              rdStats.d64SigCost -= rdStats.d64SigCost_0;
            }
            // rd-cost if SigCoeffGroupFlag = 0, initialization
            double d64CostZeroCG = d64BaseCost;

            const BinFracBits fracBitsSigGroup = fracBits.getFracBitsArray( cctx.sigGroupCtxId() );

            if (cctx.subSetId() < iCGLastScanPos)
            {
              d64BaseCost  += xGetRateSigCoeffGroup(fracBitsSigGroup,1);
              d64CostZeroCG += xGetRateSigCoeffGroup(fracBitsSigGroup,0);
              pdCostCoeffGroupSig[ cctx.subSetId() ] = xGetRateSigCoeffGroup(fracBitsSigGroup,1);
            }

            // try to convert the current coeff group from non-zero to all-zero
            d64CostZeroCG += rdStats.d64UncodedDist;  // distortion for resetting non-zero levels to zero levels
            d64CostZeroCG -= rdStats.d64CodedLevelandDist;   // distortion and level cost for keeping all non-zero levels
            d64CostZeroCG -= rdStats.d64SigCost;     // sig cost for all coeffs, including zero levels and non-zerl levels

                                                     // if we can save cost, change this block to all-zero block
            if ( d64CostZeroCG < d64BaseCost )
            {
              cctx.resetSigGroup();
              d64BaseCost = d64CostZeroCG;
              if (cctx.subSetId() < iCGLastScanPos)
              {
                pdCostCoeffGroupSig[ cctx.subSetId() ] = xGetRateSigCoeffGroup(fracBitsSigGroup,0);
              }
              // reset coeffs to 0 in this block
              for (int iScanPosinCG = iCGSizeM1; iScanPosinCG >= 0; iScanPosinCG--)
              {
                iScanPos      = cctx.minSubPos() + iScanPosinCG;
                uint32_t uiBlkPos = cctx.blockPos( iScanPos );

                if (piDstCoeff[ uiBlkPos ])
                {
                  piDstCoeff [ uiBlkPos ] = 0;
                  pdCostCoeff[ iScanPos ] = pdCostCoeff0[ iScanPos ];
                  pdCostSig  [ iScanPos ] = 0;
                }
              }
            } // end if ( d64CostAllZeros < d64BaseCost )
          }
        } // end if if (uiSigCoeffGroupFlag[ uiCGBlkPos ] == 0)
      }
      else
      {
        cctx.setSigGroup();
      }
    }
  } //end for (cctx.subSetId)


  //===== estimate last position =====
  if ( iLastScanPos < 0 )
  {
    return;
  }

  double  d64BestCost         = 0;
  int     iBestLastIdxP1      = 0;


#if ENABLE_BMS
  if( !CU::isIntra( *tu.cu ) && isLuma( compID ) && tu.depth == 0 )
#else
  if( !CU::isIntra( *tu.cu ) && isLuma( compID ) )
#endif
  {
    const BinFracBits fracBitsQtRootCbf = fracBits.getFracBitsArray( Ctx::QtRootCbf() );
    d64BestCost  = d64BlockUncodedCost + xGetICost( fracBitsQtRootCbf.intBits[ 0 ] );
    d64BaseCost += xGetICost( fracBitsQtRootCbf.intBits[ 1 ] );
  }
  else
  {
#if ENABLE_BMS
#if JVET_K0072
    BinFracBits fracBitsQtCbf = fracBits.getFracBitsArray( Ctx::QtCbf[compID]( DeriveCtx::CtxQtCbf( rect.compID, tu.depth, tu.cbf[COMPONENT_Cb] ) ) );
#else
    BinFracBits fracBitsQtCbf = fracBits.getFracBitsArray( Ctx::QtCbf[chType]( DeriveCtx::CtxQtCbf( rect.compID, tu.depth ) ) );
#endif
#else
#if JVET_K0072
    BinFracBits fracBitsQtCbf = fracBits.getFracBitsArray( Ctx::QtCbf[compID]( DeriveCtx::CtxQtCbf( rect.compID, tu.cbf[COMPONENT_Cb] ) ) );
#else
    BinFracBits fracBitsQtCbf = fracBits.getFracBitsArray( Ctx::QtCbf[chType]( DeriveCtx::CtxQtCbf( rect.compID ) ) );
#endif
#endif

    d64BestCost  = d64BlockUncodedCost + xGetICost( fracBitsQtCbf.intBits[0] );
    d64BaseCost += xGetICost( fracBitsQtCbf.intBits[1] );
  }

  int lastBitsX[LAST_SIGNIFICANT_GROUPS] = { 0 };
  int lastBitsY[LAST_SIGNIFICANT_GROUPS] = { 0 };
  {
#if HEVC_USE_MDCS
    int dim1  = ( cctx.scanType() == SCAN_VER ? uiHeight : uiWidth  );
    int dim2  = ( cctx.scanType() == SCAN_VER ? uiWidth  : uiHeight );
#else
    int dim1  = uiWidth;
    int dim2  = uiHeight;
#endif
    int bitsX = 0;
    int bitsY = 0;
    int ctxId;
    //X-coordinate
    for ( ctxId = 0; ctxId < g_uiGroupIdx[dim1-1]; ctxId++)
    {
      const BinFracBits fB = fracBits.getFracBitsArray( cctx.lastXCtxId(ctxId) );
      lastBitsX[ ctxId ]   = bitsX + fB.intBits[ 0 ];
      bitsX               +=         fB.intBits[ 1 ];
    }
    lastBitsX[ctxId] = bitsX;
    //Y-coordinate
    for ( ctxId = 0; ctxId < g_uiGroupIdx[dim2-1]; ctxId++)
    {
      const BinFracBits fB = fracBits.getFracBitsArray( cctx.lastYCtxId(ctxId) );
      lastBitsY[ ctxId ]   = bitsY + fB.intBits[ 0 ];
      bitsY               +=         fB.intBits[ 1 ];
    }
    lastBitsY[ctxId] = bitsY;
  }


  bool bFoundLast = false;
  for (int iCGScanPos = iCGLastScanPos; iCGScanPos >= 0; iCGScanPos--)
  {
    d64BaseCost -= pdCostCoeffGroupSig [ iCGScanPos ];
    if (cctx.isSigGroup( iCGScanPos ) )
    {
      for (int iScanPosinCG = iCGSizeM1; iScanPosinCG >= 0; iScanPosinCG--)
      {
        iScanPos = iCGScanPos * (iCGSizeM1 + 1) + iScanPosinCG;

        if (iScanPos > iLastScanPos)
        {
          continue;
        }
        uint32_t   uiBlkPos     = cctx.blockPos( iScanPos );

        if( piDstCoeff[ uiBlkPos ] )
        {
          uint32_t   uiPosY = uiBlkPos >> uiLog2BlockWidth;
          uint32_t   uiPosX = uiBlkPos - ( uiPosY << uiLog2BlockWidth );
#if HEVC_USE_MDCS
          double d64CostLast  = ( cctx.scanType() == SCAN_VER ? xGetRateLast( lastBitsX, lastBitsY, uiPosY, uiPosX ) : xGetRateLast( lastBitsX, lastBitsY, uiPosX, uiPosY ) );
#else
          double d64CostLast  = xGetRateLast( lastBitsX, lastBitsY, uiPosX, uiPosY );
#endif

          double totalCost = d64BaseCost + d64CostLast - pdCostSig[ iScanPos ];

          if( totalCost < d64BestCost )
          {
            iBestLastIdxP1  = iScanPos + 1;
            d64BestCost     = totalCost;
          }
          if( piDstCoeff[ uiBlkPos ] > 1 )
          {
            bFoundLast = true;
            break;
          }
          d64BaseCost      -= pdCostCoeff[ iScanPos ];
          d64BaseCost      += pdCostCoeff0[ iScanPos ];
        }
        else
        {
          d64BaseCost      -= pdCostSig[ iScanPos ];
        }
      } //end for
      if (bFoundLast)
      {
        break;
      }
    } // end if (uiSigCoeffGroupFlag[ uiCGBlkPos ])
    DTRACE( g_trace_ctx, D_RDOQ_COST, ""%d: %3d, %3d, %dx%d, comp=%d\\n"", DTRACE_GET_COUNTER( g_trace_ctx, D_RDOQ_COST ), rect.x, rect.y, rect.width, rect.height, compID );
    DTRACE( g_trace_ctx, D_RDOQ_COST, ""Uncoded=%d\\n"", (int64_t)( d64BlockUncodedCost ) );
    DTRACE( g_trace_ctx, D_RDOQ_COST, ""Coded  =%d\\n"", (int64_t)( d64BaseCost ) );

  } // end for


  for ( int scanPos = 0; scanPos < iBestLastIdxP1; scanPos++ )
  {
    int blkPos = cctx.blockPos( scanPos );
    TCoeff level = piDstCoeff[ blkPos ];
    uiAbsSum += level;
    piDstCoeff[ blkPos ] = ( plSrcCoeff[ blkPos ] < 0 ) ? -level : level;
  }

  //===== clean uncoded coefficients =====
  for ( int scanPos = iBestLastIdxP1; scanPos <= iLastScanPos; scanPos++ )
  {
    piDstCoeff[ cctx.blockPos( scanPos ) ] = 0;
  }

#if HEVC_USE_SIGN_HIDING
  if( cctx.signHiding() && uiAbsSum>=2)
  {
    const double inverseQuantScale = double(g_invQuantScales[cQP.rem]);
#if DISTORTION_LAMBDA_BUGFIX
    int64_t rdFactor = (int64_t)(inverseQuantScale * inverseQuantScale * (1 << (2 * cQP.per)) / m_dLambda / 16
                               / (1 << (2 * DISTORTION_PRECISION_ADJUSTMENT(channelBitDepth)))
#else
    int64_t rdFactor = (int64_t)(inverseQuantScale * inverseQuantScale * (1 << (2 * cQP.per))
                             / m_dLambda / 16 / (1 << (2 * DISTORTION_PRECISION_ADJUSTMENT(channelBitDepth - 8)))
#endif
#if HM_QTBT_AS_IN_JEM_QUANT
#else
                              * blkErrScale
#endif
                             + 0.5);

    int lastCG = -1;
    int absSum = 0 ;
    int n ;

    for( int subSet = (uiWidth*uiHeight-1) >> cctx.log2CGSize(); subSet >= 0; subSet-- )
    {
      int  subPos         = subSet << cctx.log2CGSize();
      int  firstNZPosInCG = iCGSizeM1 + 1, lastNZPosInCG = -1;
      absSum = 0 ;

      for( n = iCGSizeM1; n >= 0; --n )
      {
        if( piDstCoeff[ cctx.blockPos( n + subPos )] )
        {
          lastNZPosInCG = n;
          break;
        }
      }

      for( n = 0; n <= iCGSizeM1; n++ )
      {
        if( piDstCoeff[ cctx.blockPos( n + subPos )] )
        {
          firstNZPosInCG = n;
          break;
        }
      }

      for( n = firstNZPosInCG; n <= lastNZPosInCG; n++ )
      {
        absSum += int(piDstCoeff[ cctx.blockPos( n + subPos )]);
      }

      if(lastNZPosInCG>=0 && lastCG==-1)
      {
        lastCG = 1;
      }

      if( lastNZPosInCG-firstNZPosInCG>=SBH_THRESHOLD )
      {
        uint32_t signbit = (piDstCoeff[cctx.blockPos(subPos+firstNZPosInCG)]>0?0:1);
        if( signbit!=(absSum&0x1) )  // hide but need tune
        {
          // calculate the cost
          int64_t minCostInc = std::numeric_limits<int64_t>::max(), curCost = std::numeric_limits<int64_t>::max();
          int minPos = -1, finalChange = 0, curChange = 0;

          for( n = (lastCG == 1 ? lastNZPosInCG : iCGSizeM1); n >= 0; --n )
          {
            uint32_t uiBlkPos   = cctx.blockPos( n + subPos );
            if(piDstCoeff[ uiBlkPos ] != 0 )
            {
              int64_t costUp   = rdFactor * ( - deltaU[uiBlkPos] ) + rateIncUp[uiBlkPos];
              int64_t costDown = rdFactor * (   deltaU[uiBlkPos] ) + rateIncDown[uiBlkPos]
                -   ((abs(piDstCoeff[uiBlkPos]) == 1) ? sigRateDelta[uiBlkPos] : 0);

              if(lastCG==1 && lastNZPosInCG==n && abs(piDstCoeff[uiBlkPos])==1)
              {
                costDown -= (4<<SCALE_BITS);
              }

              if(costUp<costDown)
              {
                curCost = costUp;
                curChange =  1;
              }
              else
              {
                curChange = -1;
                if(n==firstNZPosInCG && abs(piDstCoeff[uiBlkPos])==1)
                {
                  curCost = std::numeric_limits<int64_t>::max();
                }
                else
                {
                  curCost = costDown;
                }
              }
            }
            else
            {
              curCost = rdFactor * ( - (abs(deltaU[uiBlkPos])) ) + (1<<SCALE_BITS) + rateIncUp[uiBlkPos] + sigRateDelta[uiBlkPos] ;
              curChange = 1 ;

              if(n<firstNZPosInCG)
              {
                uint32_t thissignbit = (plSrcCoeff[uiBlkPos]>=0?0:1);
                if(thissignbit != signbit )
                {
                  curCost = std::numeric_limits<int64_t>::max();
                }
              }
            }

            if( curCost<minCostInc)
            {
              minCostInc = curCost;
              finalChange = curChange;
              minPos = uiBlkPos;
            }
          }

          if(piDstCoeff[minPos] == entropyCodingMaximum || piDstCoeff[minPos] == entropyCodingMinimum)
          {
            finalChange = -1;
          }

          if(plSrcCoeff[minPos]>=0)
          {
            piDstCoeff[minPos] += finalChange ;
          }
          else
          {
            piDstCoeff[minPos] -= finalChange ;
          }
        }
      }

      if(lastCG==1)
      {
        lastCG=0 ;
      }
    }
  }
#endif
}

//! \\}
",16130,True,3035.173468882632,median
"// This file is part of AsmJit project <https://asmjit.com>
//
// See asmjit.h or LICENSE.md for license and copyright information
// SPDX-License-Identifier: Zlib

#include ""../core/api-build_p.h""
#ifndef ASMJIT_NO_COMPILER

#include ""../core/formatter.h""
#include ""../core/ralocal_p.h""
#include ""../core/rapass_p.h""
#include ""../core/support.h""
#include ""../core/type.h""
#include ""../core/zonestack.h""

ASMJIT_BEGIN_NAMESPACE

// RABlock - Control Flow
// ======================

Error RABlock::appendSuccessor(RABlock* successor) noexcept {
  RABlock* predecessor = this;

  if (predecessor->hasSuccessor(successor))
    return kErrorOk;

  ASMJIT_PROPAGATE(successor->_predecessors.willGrow(allocator()));
  ASMJIT_PROPAGATE(predecessor->_successors.willGrow(allocator()));

  predecessor->_successors.appendUnsafe(successor);
  successor->_predecessors.appendUnsafe(predecessor);

  return kErrorOk;
}

Error RABlock::prependSuccessor(RABlock* successor) noexcept {
  RABlock* predecessor = this;

  if (predecessor->hasSuccessor(successor))
    return kErrorOk;

  ASMJIT_PROPAGATE(successor->_predecessors.willGrow(allocator()));
  ASMJIT_PROPAGATE(predecessor->_successors.willGrow(allocator()));

  predecessor->_successors.prependUnsafe(successor);
  successor->_predecessors.prependUnsafe(predecessor);

  return kErrorOk;
}

// BaseRAPass - Construction & Destruction
// =======================================

BaseRAPass::BaseRAPass() noexcept : FuncPass(""BaseRAPass"") {}
BaseRAPass::~BaseRAPass() noexcept {}

// BaseRAPass - RunOnFunction
// ==========================

static void BaseRAPass_reset(BaseRAPass* self, FuncDetail* funcDetail) noexcept {
  ZoneAllocator* allocator = self->allocator();

  self->_blocks.reset();
  self->_exits.reset();
  self->_pov.reset();
  self->_workRegs.reset();
  self->_instructionCount = 0;
  self->_createdBlockCount = 0;

  self->_sharedAssignments.reset();
  self->_lastTimestamp = 0;

  self->_archTraits = nullptr;
  self->_physRegIndex.reset();
  self->_physRegCount.reset();
  self->_physRegTotal = 0;
  self->_scratchRegIndexes.fill(BaseReg::kIdBad);

  self->_availableRegs.reset();
  self->_availableRegCount.reset();
  self->_clobberedRegs.reset();

  self->_workRegs.reset();
  self->_workRegsOfGroup.forEach([](RAWorkRegs& regs) { regs.reset(); });
  self->_strategy.forEach([](RAStrategy& strategy) { strategy.reset(); });
  self->_globalLiveSpans.fill(nullptr);
  self->_globalMaxLiveCount.reset();
  self->_temporaryMem.reset();

  self->_stackAllocator.reset(allocator);
  self->_argsAssignment.reset(funcDetail);
  self->_numStackArgsToStackSlots = 0;
  self->_maxWorkRegNameSize = 0;
}

static void BaseRAPass_resetVirtRegData(BaseRAPass* self) noexcept {
  for (RAWorkReg* wReg : self->_workRegs) {
    VirtReg* vReg = wReg->virtReg();

    // Update the information regarding the stack of the virtual register.
    if (wReg->hasStackSlot()) {
      RAStackSlot* slot = wReg->stackSlot();
      vReg->assignStackSlot(slot->offset());
    }

    // Reset work reg association so it cannot be used by accident (RAWorkReg data will be destroyed).
    vReg->_workReg = nullptr;
  }
}

Error BaseRAPass::runOnFunction(Zone* zone, Logger* logger, FuncNode* func) {
  _allocator.reset(zone);

#ifndef ASMJIT_NO_LOGGING
  _logger = logger;
  _formatOptions.reset();
  _diagnosticOptions = DiagnosticOptions::kNone;

  if (logger) {
    _formatOptions = logger->options();
    _diagnosticOptions = _cb->diagnosticOptions();
  }
#else
  DebugUtils::unused(logger);
#endif

  // Initialize all core structures to use `zone` and `func`.
  BaseNode* end = func->endNode();
  _func = func;
  _stop = end->next();
  _extraBlock = end;

  BaseRAPass_reset(this, &_func->_funcDetail);

  // Initialize architecture-specific members.
  onInit();

  // Perform all allocation steps required.
  Error err = onPerformAllSteps();

  // Must be called regardless of the allocation status.
  onDone();

  // Reset possible connections introduced by the register allocator.
  BaseRAPass_resetVirtRegData(this);

  // Reset all core structures and everything that depends on the passed `Zone`.
  BaseRAPass_reset(this, nullptr);
  _allocator.reset(nullptr);

#ifndef ASMJIT_NO_LOGGING
  _logger = nullptr;
  _formatOptions.reset();
  _diagnosticOptions = DiagnosticOptions::kNone;
#endif

  _func = nullptr;
  _stop = nullptr;
  _extraBlock = nullptr;

  // Reset `Zone` as nothing should persist between `runOnFunction()` calls.
  zone->reset();

  // We alter the compiler cursor, because it doesn't make sense to reference it after the compilation - some
  // nodes may disappear and the old cursor can go out anyway.
  cc()->_setCursor(cc()->lastNode());

  return err;
}

Error BaseRAPass::onPerformAllSteps() noexcept {
  ASMJIT_PROPAGATE(buildCFG());
  ASMJIT_PROPAGATE(buildCFGViews());
  ASMJIT_PROPAGATE(removeUnreachableCode());

  ASMJIT_PROPAGATE(buildCFGDominators());
  ASMJIT_PROPAGATE(buildLiveness());
  ASMJIT_PROPAGATE(assignArgIndexToWorkRegs());

#ifndef ASMJIT_NO_LOGGING
  if (hasDiagnosticOption(DiagnosticOptions::kRAAnnotate))
    ASMJIT_PROPAGATE(annotateCode());
#endif

  ASMJIT_PROPAGATE(runGlobalAllocator());
  ASMJIT_PROPAGATE(runLocalAllocator());

  ASMJIT_PROPAGATE(updateStackFrame());
  ASMJIT_PROPAGATE(insertPrologEpilog());

  ASMJIT_PROPAGATE(rewrite());

  return kErrorOk;
}

// BaseRAPass - CFG - Basic Block Management
// =========================================

RABlock* BaseRAPass::newBlock(BaseNode* initialNode) noexcept {
  RABlock* block = zone()->newT<RABlock>(this);
  if (ASMJIT_UNLIKELY(!block))
    return nullptr;

  block->setFirst(initialNode);
  block->setLast(initialNode);

  _createdBlockCount++;
  return block;
}

RABlock* BaseRAPass::newBlockOrExistingAt(LabelNode* cbLabel, BaseNode** stoppedAt) noexcept {
  if (cbLabel->hasPassData())
    return cbLabel->passData<RABlock>();

  FuncNode* func = this->func();
  BaseNode* node = cbLabel->prev();
  RABlock* block = nullptr;

  // Try to find some label, but terminate the loop on any code. We try hard to coalesce code that contains two
  // consecutive labels or a combination of non-code nodes between 2 or more labels.
  //
  // Possible cases that would share the same basic block:
  //
  //   1. Two or more consecutive labels:
  //     Label1:
  //     Label2:
  //
  //   2. Two or more labels separated by non-code nodes:
  //     Label1:
  //     ; Some comment...
  //     .align 16
  //     Label2:
  size_t nPendingLabels = 0;

  while (node) {
    if (node->type() == NodeType::kLabel) {
      // Function has a different NodeType, just make sure this was not messed up as we must never associate
      // BasicBlock with a `func` itself.
      ASMJIT_ASSERT(node != func);

      block = node->passData<RABlock>();
      if (block) {
        // Exit node has always a block associated with it. If we went here it means that `cbLabel` passed here
        // is after the end of the function and cannot be merged with the function exit block.
        if (node == func->exitNode())
          block = nullptr;
        break;
      }

      nPendingLabels++;
    }
    else if (node->type() == NodeType::kAlign) {
      // Align node is fine.
    }
    else {
      break;
    }

    node = node->prev();
  }

  if (stoppedAt)
    *stoppedAt = node;

  if (!block) {
    block = newBlock();
    if (ASMJIT_UNLIKELY(!block))
      return nullptr;
  }

  cbLabel->setPassData<RABlock>(block);
  node = cbLabel;

  while (nPendingLabels) {
    node = node->prev();
    for (;;) {
      if (node->type() == NodeType::kLabel) {
        node->setPassData<RABlock>(block);
        nPendingLabels--;
        break;
      }

      node = node->prev();
      ASMJIT_ASSERT(node != nullptr);
    }
  }

  if (!block->first()) {
    block->setFirst(node);
    block->setLast(cbLabel);
  }

  return block;
}

Error BaseRAPass::addBlock(RABlock* block) noexcept {
  ASMJIT_PROPAGATE(_blocks.willGrow(allocator()));

  block->_blockId = blockCount();
  _blocks.appendUnsafe(block);
  return kErrorOk;
}

// BaseRAPass - CFG - Build
// ========================

Error BaseRAPass::initSharedAssignments(const ZoneVector<uint32_t>& sharedAssignmentsMap) noexcept {
  if (sharedAssignmentsMap.empty())
    return kErrorOk;

  uint32_t count = 0;
  for (RABlock* block : _blocks) {
    if (block->hasSharedAssignmentId()) {
      uint32_t sharedAssignmentId = sharedAssignmentsMap[block->sharedAssignmentId()];
      block->setSharedAssignmentId(sharedAssignmentId);
      count = Support::max(count, sharedAssignmentId + 1);
    }
  }

  ASMJIT_PROPAGATE(_sharedAssignments.resize(allocator(), count));

  // Aggregate all entry scratch GP regs from blocks of the same assignment to the assignment itself. It will then be
  // used instead of RABlock's own scratch regs mask, as shared assignments have precedence.
  for (RABlock* block : _blocks) {
    if (block->hasJumpTable()) {
      const RABlocks& successors = block->successors();
      if (!successors.empty()) {
        RABlock* firstSuccessor = successors[0];
        // NOTE: Shared assignments connect all possible successors so we only need the first to propagate exit scratch
        // GP registers.
        ASMJIT_ASSERT(firstSuccessor->hasSharedAssignmentId());
        RASharedAssignment& sa = _sharedAssignments[firstSuccessor->sharedAssignmentId()];
        sa.addEntryScratchGpRegs(block->exitScratchGpRegs());
      }
    }
    if (block->hasSharedAssignmentId()) {
      RASharedAssignment& sa = _sharedAssignments[block->sharedAssignmentId()];
      sa.addEntryScratchGpRegs(block->_entryScratchGpRegs);
    }
  }

  return kErrorOk;
}

// BaseRAPass - CFG - Views Order
// ==============================

class RABlockVisitItem {
public:
  inline RABlockVisitItem(RABlock* block, uint32_t index) noexcept
    : _block(block),
      _index(index) {}

  inline RABlockVisitItem(const RABlockVisitItem& other) noexcept
    : _block(other._block),
      _index(other._index) {}

  inline RABlockVisitItem& operator=(const RABlockVisitItem& other) noexcept = default;

  inline RABlock* block() const noexcept { return _block; }
  inline uint32_t index() const noexcept { return _index; }

  RABlock* _block;
  uint32_t _index;
};

Error BaseRAPass::buildCFGViews() noexcept {
#ifndef ASMJIT_NO_LOGGING
  Logger* logger = getLoggerIf(DiagnosticOptions::kRADebugCFG);
  ASMJIT_RA_LOG_FORMAT(""[BuildCFGViews]\\n"");
#endif

  uint32_t count = blockCount();
  if (ASMJIT_UNLIKELY(!count)) return kErrorOk;

  ASMJIT_PROPAGATE(_pov.reserve(allocator(), count));

  ZoneStack<RABlockVisitItem> stack;
  ASMJIT_PROPAGATE(stack.init(allocator()));

  ZoneBitVector visited;
  ASMJIT_PROPAGATE(visited.resize(allocator(), count));

  RABlock* current = _blocks[0];
  uint32_t i = 0;

  for (;;) {
    for (;;) {
      if (i >= current->successors().size())
        break;

      // Skip if already visited.
      RABlock* child = current->successors()[i++];
      if (visited.bitAt(child->blockId()))
        continue;

      // Mark as visited to prevent visiting the same block multiple times.
      visited.setBit(child->blockId(), true);

      // Add the current block on the stack, we will get back to it later.
      ASMJIT_PROPAGATE(stack.append(RABlockVisitItem(current, i)));
      current = child;
      i = 0;
    }

    current->makeReachable();
    current->_povOrder = _pov.size();
    _pov.appendUnsafe(current);

    if (stack.empty())
      break;

    RABlockVisitItem top = stack.pop();
    current = top.block();
    i = top.index();
  }

  ASMJIT_RA_LOG_COMPLEX({
    StringTmp<1024> sb;
    for (RABlock* block : blocks()) {
      sb.clear();
      if (block->hasSuccessors()) {
        sb.appendFormat(""  #%u -> {"", block->blockId());
        _dumpBlockIds(sb, block->successors());
        sb.append(""}\\n"");
      }
      else {
        sb.appendFormat(""  #%u -> {Exit}\\n"", block->blockId());
      }
      logger->log(sb);
    }
  });

  visited.release(allocator());
  return kErrorOk;
}

// BaseRAPass - CFG - Dominators
// =============================

static ASMJIT_FORCE_INLINE RABlock* intersectBlocks(RABlock* b1, RABlock* b2) noexcept {
  while (b1 != b2) {
    while (b2->povOrder() > b1->povOrder()) b1 = b1->iDom();
    while (b1->povOrder() > b2->povOrder()) b2 = b2->iDom();
  }
  return b1;
}

// Based on ""A Simple, Fast Dominance Algorithm"".
Error BaseRAPass::buildCFGDominators() noexcept {
#ifndef ASMJIT_NO_LOGGING
  Logger* logger = getLoggerIf(DiagnosticOptions::kRADebugCFG);
  ASMJIT_RA_LOG_FORMAT(""[BuildCFGDominators]\\n"");
#endif

  if (_blocks.empty())
    return kErrorOk;

  RABlock* entryBlock = this->entryBlock();
  entryBlock->setIDom(entryBlock);

  bool changed = true;
  uint32_t nIters = 0;

  while (changed) {
    nIters++;
    changed = false;

    uint32_t i = _pov.size();
    while (i) {
      RABlock* block = _pov[--i];
      if (block == entryBlock)
        continue;

      RABlock* iDom = nullptr;
      const RABlocks& preds = block->predecessors();

      uint32_t j = preds.size();
      while (j) {
        RABlock* p = preds[--j];
        if (!p->iDom())
          continue;
        iDom = !iDom ? p : intersectBlocks(iDom, p);
      }

      if (block->iDom() != iDom) {
        ASMJIT_ASSUME(iDom != nullptr);
        ASMJIT_RA_LOG_FORMAT(""  IDom of #%u -> #%u\\n"", block->blockId(), iDom->blockId());
        block->setIDom(iDom);
        changed = true;
      }
    }
  }

  ASMJIT_RA_LOG_FORMAT(""  Done (%u iterations)\\n"", nIters);
  return kErrorOk;
}

bool BaseRAPass::_strictlyDominates(const RABlock* a, const RABlock* b) const noexcept {
  ASMJIT_ASSERT(a != nullptr); // There must be at least one block if this function is
  ASMJIT_ASSERT(b != nullptr); // called, as both `a` and `b` must be valid blocks.
  ASMJIT_ASSERT(a != b);       // Checked by `dominates()` and `strictlyDominates()`.

  // Nothing strictly dominates the entry block.
  const RABlock* entryBlock = this->entryBlock();
  if (a == entryBlock)
    return false;

  const RABlock* iDom = b->iDom();
  while (iDom != a && iDom != entryBlock)
    iDom = iDom->iDom();

  return iDom != entryBlock;
}

const RABlock* BaseRAPass::_nearestCommonDominator(const RABlock* a, const RABlock* b) const noexcept {
  ASMJIT_ASSERT(a != nullptr); // There must be at least one block if this function is
  ASMJIT_ASSERT(b != nullptr); // called, as both `a` and `b` must be valid blocks.
  ASMJIT_ASSERT(a != b);       // Checked by `dominates()` and `properlyDominates()`.

  if (a == b)
    return a;

  // If `a` strictly dominates `b` then `a` is the nearest common dominator.
  if (_strictlyDominates(a, b))
    return a;

  // If `b` strictly dominates `a` then `b` is the nearest common dominator.
  if (_strictlyDominates(b, a))
    return b;

  const RABlock* entryBlock = this->entryBlock();
  uint64_t timestamp = nextTimestamp();

  // Mark all A's dominators.
  const RABlock* block = a->iDom();
  while (block != entryBlock) {
    block->setTimestamp(timestamp);
    block = block->iDom();
  }

  // Check all B's dominators against marked dominators of A.
  block = b->iDom();
  while (block != entryBlock) {
    if (block->hasTimestamp(timestamp))
      return block;
    block = block->iDom();
  }

  return entryBlock;
}

// BaseRAPass - CFG - Utilities
// ============================

Error BaseRAPass::removeUnreachableCode() noexcept {
  uint32_t numAllBlocks = blockCount();
  uint32_t numReachableBlocks = reachableBlockCount();

  // All reachable -> nothing to do.
  if (numAllBlocks == numReachableBlocks)
    return kErrorOk;

#ifndef ASMJIT_NO_LOGGING
  StringTmp<256> sb;
  Logger* logger = getLoggerIf(DiagnosticOptions::kRADebugUnreachable);
  ASMJIT_RA_LOG_FORMAT(""[RemoveUnreachableCode - detected %u of %u unreachable blocks]\\n"", numAllBlocks - numReachableBlocks, numAllBlocks);
#endif

  for (uint32_t i = 0; i < numAllBlocks; i++) {
    RABlock* block = _blocks[i];
    if (block->isReachable())
      continue;

    ASMJIT_RA_LOG_FORMAT(""  Removing code from unreachable block {%u}\\n"", i);
    BaseNode* first = block->first();
    BaseNode* last = block->last();

    BaseNode* beforeFirst = first->prev();
    BaseNode* afterLast = last->next();

    BaseNode* node = first;
    while (node != afterLast) {
      BaseNode* next = node->next();

      if (node->isCode() || node->isRemovable()) {
#ifndef ASMJIT_NO_LOGGING
        if (logger) {
          sb.clear();
          Formatter::formatNode(sb, _formatOptions, cc(), node);
          logger->logf(""    %s\\n"", sb.data());
        }
#endif
        cc()->removeNode(node);
      }
      node = next;
    }

    if (beforeFirst->next() == afterLast) {
      block->setFirst(nullptr);
      block->setLast(nullptr);
    }
    else {
      block->setFirst(beforeFirst->next());
      block->setLast(afterLast->prev());
    }
  }

  return kErrorOk;
}

BaseNode* BaseRAPass::findSuccessorStartingAt(BaseNode* node) noexcept {
  while (node && (node->isInformative() || node->hasNoEffect()))
    node = node->next();
  return node;
}

bool BaseRAPass::isNextTo(BaseNode* node, BaseNode* target) noexcept {
  for (;;) {
    node = node->next();
    if (node == target)
      return true;

    if (!node)
      return false;

    if (node->isCode() || node->isData())
      return false;
  }
}

// BaseRAPass - Registers - VirtReg / WorkReg Mapping
// ==================================================

Error BaseRAPass::_asWorkReg(VirtReg* vReg, RAWorkReg** out) noexcept {
  // Checked by `asWorkReg()` - must be true.
  ASMJIT_ASSERT(vReg->_workReg == nullptr);

  RegGroup group = vReg->group();
  ASMJIT_ASSERT(group <= RegGroup::kMaxVirt);

  RAWorkRegs& wRegs = workRegs();
  RAWorkRegs& wRegsByGroup = workRegs(group);

  ASMJIT_PROPAGATE(wRegs.willGrow(allocator()));
  ASMJIT_PROPAGATE(wRegsByGroup.willGrow(allocator()));

  RAWorkReg* wReg = zone()->newT<RAWorkReg>(vReg, wRegs.size());
  if (ASMJIT_UNLIKELY(!wReg))
    return DebugUtils::errored(kErrorOutOfMemory);

  vReg->setWorkReg(wReg);
  if (!vReg->isStack())
    wReg->setRegByteMask(Support::lsbMask<uint64_t>(vReg->virtSize()));
  wRegs.appendUnsafe(wReg);
  wRegsByGroup.appendUnsafe(wReg);

  // Only used by RA logging.
  _maxWorkRegNameSize = Support::max(_maxWorkRegNameSize, vReg->nameSize());

  *out = wReg;
  return kErrorOk;
}

RAAssignment::WorkToPhysMap* BaseRAPass::newWorkToPhysMap() noexcept {
  uint32_t count = workRegCount();
  size_t size = WorkToPhysMap::sizeOf(count);

  // If no registers are used it could be zero, in that case return a dummy
  // map instead of NULL.
  if (ASMJIT_UNLIKELY(!size)) {
    static const RAAssignment::WorkToPhysMap nullMap = {{ 0 }};
    return const_cast<RAAssignment::WorkToPhysMap*>(&nullMap);
  }

  WorkToPhysMap* map = zone()->allocT<WorkToPhysMap>(size);
  if (ASMJIT_UNLIKELY(!map))
    return nullptr;

  map->reset(count);
  return map;
}

RAAssignment::PhysToWorkMap* BaseRAPass::newPhysToWorkMap() noexcept {
  uint32_t count = physRegTotal();
  size_t size = PhysToWorkMap::sizeOf(count);

  PhysToWorkMap* map = zone()->allocT<PhysToWorkMap>(size);
  if (ASMJIT_UNLIKELY(!map))
    return nullptr;

  map->reset(count);
  return map;
}

// BaseRAPass - Registers - Liveness Analysis and Statistics
// =========================================================

namespace LiveOps {
  typedef ZoneBitVector::BitWord BitWord;

  struct In {
    static ASMJIT_FORCE_INLINE BitWord op(BitWord dst, BitWord out, BitWord gen, BitWord kill) noexcept {
      DebugUtils::unused(dst);
      return (out | gen) & ~kill;
    }
  };

  template<typename Operator>
  static ASMJIT_FORCE_INLINE bool op(BitWord* dst, const BitWord* a, uint32_t n) noexcept {
    BitWord changed = 0;

    for (uint32_t i = 0; i < n; i++) {
      BitWord before = dst[i];
      BitWord after = Operator::op(before, a[i]);

      dst[i] = after;
      changed |= (before ^ after);
    }

    return changed != 0;
  }

  template<typename Operator>
  static ASMJIT_FORCE_INLINE bool op(BitWord* dst, const BitWord* a, const BitWord* b, uint32_t n) noexcept {
    BitWord changed = 0;

    for (uint32_t i = 0; i < n; i++) {
      BitWord before = dst[i];
      BitWord after = Operator::op(before, a[i], b[i]);

      dst[i] = after;
      changed |= (before ^ after);
    }

    return changed != 0;
  }

  template<typename Operator>
  static ASMJIT_FORCE_INLINE bool op(BitWord* dst, const BitWord* a, const BitWord* b, const BitWord* c, uint32_t n) noexcept {
    BitWord changed = 0;

    for (uint32_t i = 0; i < n; i++) {
      BitWord before = dst[i];
      BitWord after = Operator::op(before, a[i], b[i], c[i]);

      dst[i] = after;
      changed |= (before ^ after);
    }

    return changed != 0;
  }

  static ASMJIT_FORCE_INLINE bool recalcInOut(RABlock* block, uint32_t numBitWords, bool initial = false) noexcept {
    bool changed = initial;

    const RABlocks& successors = block->successors();
    uint32_t numSuccessors = successors.size();

    // Calculate `OUT` based on `IN` of all successors.
    for (uint32_t i = 0; i < numSuccessors; i++)
      changed |= op<Support::Or>(block->liveOut().data(), successors[i]->liveIn().data(), numBitWords);

    // Calculate `IN` based on `OUT`, `GEN`, and `KILL` bits.
    if (changed)
      changed = op<In>(block->liveIn().data(), block->liveOut().data(), block->gen().data(), block->kill().data(), numBitWords);

    return changed;
  }
}

ASMJIT_FAVOR_SPEED Error BaseRAPass::buildLiveness() noexcept {
#ifndef ASMJIT_NO_LOGGING
  Logger* logger = getLoggerIf(DiagnosticOptions::kRADebugLiveness);
  StringTmp<512> sb;
#endif

  ASMJIT_RA_LOG_FORMAT(""[BuildLiveness]\\n"");

  uint32_t i;

  uint32_t numAllBlocks = blockCount();
  uint32_t numReachableBlocks = reachableBlockCount();

  uint32_t numVisits = numReachableBlocks;
  uint32_t numWorkRegs = workRegCount();
  uint32_t numBitWords = ZoneBitVector::_wordsPerBits(numWorkRegs);

  if (!numWorkRegs) {
    ASMJIT_RA_LOG_FORMAT(""  Done (no virtual registers)\\n"");
    return kErrorOk;
  }

  ZoneVector<uint32_t> nUsesPerWorkReg; // Number of USEs of each RAWorkReg.
  ZoneVector<uint32_t> nOutsPerWorkReg; // Number of OUTs of each RAWorkReg.
  ZoneVector<uint32_t> nInstsPerBlock;  // Number of instructions of each RABlock.

  ASMJIT_PROPAGATE(nUsesPerWorkReg.resize(allocator(), numWorkRegs));
  ASMJIT_PROPAGATE(nOutsPerWorkReg.resize(allocator(), numWorkRegs));
  ASMJIT_PROPAGATE(nInstsPerBlock.resize(allocator(), numAllBlocks));

  // Calculate GEN/KILL of Each Block
  // --------------------------------

  for (i = 0; i < numReachableBlocks; i++) {
    RABlock* block = _pov[i];
    ASMJIT_PROPAGATE(block->resizeLiveBits(numWorkRegs));

    BaseNode* node = block->last();
    BaseNode* stop = block->first();

    uint32_t nInsts = 0;
    for (;;) {
      if (node->isInst()) {
        InstNode* inst = node->as<InstNode>();
        RAInst* raInst = inst->passData<RAInst>();
        ASMJIT_ASSERT(raInst != nullptr);

        RATiedReg* tiedRegs = raInst->tiedRegs();
        uint32_t count = raInst->tiedCount();

        for (uint32_t j = 0; j < count; j++) {
          RATiedReg* tiedReg = &tiedRegs[j];
          uint32_t workId = tiedReg->workId();

          // Update `nUses` and `nOuts`.
          nUsesPerWorkReg[workId] += 1u;
          nOutsPerWorkReg[workId] += uint32_t(tiedReg->isWrite());

          // Mark as:
          //   KILL - if this VirtReg is killed afterwards.
          //   LAST - if this VirtReg is last in this basic block.
          if (block->kill().bitAt(workId))
            tiedReg->addFlags(RATiedFlags::kKill);
          else if (!block->gen().bitAt(workId))
            tiedReg->addFlags(RATiedFlags::kLast);

          if (tiedReg->isWriteOnly()) {
            // KILL.
            block->kill().setBit(workId, true);
          }
          else {
            // GEN.
            block->kill().setBit(workId, false);
            block->gen().setBit(workId, true);
          }

          if (tiedReg->isLeadConsecutive()) {
            RAWorkReg* workReg = workRegById(workId);
            workReg->markLeadConsecutive();
          }

          if (tiedReg->hasConsecutiveParent()) {
            RAWorkReg* consecutiveParentReg = workRegById(tiedReg->consecutiveParent());
            consecutiveParentReg->addImmediateConsecutive(allocator(), workId);
          }
        }

        nInsts++;
      }

      if (node == stop)
        break;

      node = node->prev();
      ASMJIT_ASSERT(node != nullptr);
    }

    nInstsPerBlock[block->blockId()] = nInsts;
  }

  // Calculate IN/OUT of Each Block
  // ------------------------------

  {
    ZoneStack<RABlock*> workList;
    ZoneBitVector workBits;

    ASMJIT_PROPAGATE(workList.init(allocator()));
    ASMJIT_PROPAGATE(workBits.resize(allocator(), blockCount(), true));

    for (i = 0; i < numReachableBlocks; i++) {
      RABlock* block = _pov[i];
      LiveOps::recalcInOut(block, numBitWords, true);
      ASMJIT_PROPAGATE(workList.append(block));
    }

    while (!workList.empty()) {
      RABlock* block = workList.popFirst();
      uint32_t blockId = block->blockId();

      workBits.setBit(blockId, false);
      if (LiveOps::recalcInOut(block, numBitWords)) {
        const RABlocks& predecessors = block->predecessors();
        uint32_t numPredecessors = predecessors.size();

        for (uint32_t j = 0; j < numPredecessors; j++) {
          RABlock* pred = predecessors[j];
          if (!workBits.bitAt(pred->blockId())) {
            workBits.setBit(pred->blockId(), true);
            ASMJIT_PROPAGATE(workList.append(pred));
          }
        }
      }
      numVisits++;
    }

    workList.reset();
    workBits.release(allocator());
  }

  ASMJIT_RA_LOG_COMPLEX({
    logger->logf(""  LiveIn/Out Done (%u visits)\\n"", numVisits);
    for (i = 0; i < numAllBlocks; i++) {
      RABlock* block = _blocks[i];

      ASMJIT_PROPAGATE(sb.assignFormat(""  {#%u}\\n"", block->blockId()));
      ASMJIT_PROPAGATE(_dumpBlockLiveness(sb, block));

      logger->log(sb);
    }
  });

  // Reserve the space in each `RAWorkReg` for references
  // ----------------------------------------------------

  for (i = 0; i < numWorkRegs; i++) {
    RAWorkReg* workReg = workRegById(i);
    ASMJIT_PROPAGATE(workReg->_refs.reserve(allocator(), nUsesPerWorkReg[i]));
    ASMJIT_PROPAGATE(workReg->_writes.reserve(allocator(), nOutsPerWorkReg[i]));
  }

  // Assign block and instruction positions, build LiveCount and LiveSpans
  // ---------------------------------------------------------------------

  uint32_t position = 2;
  for (i = 0; i < numAllBlocks; i++) {
    RABlock* block = _blocks[i];
    if (!block->isReachable())
      continue;

    BaseNode* node = block->first();
    BaseNode* stop = block->last();

    uint32_t endPosition = position + nInstsPerBlock[i] * 2;
    block->setFirstPosition(position);
    block->setEndPosition(endPosition);

    RALiveCount curLiveCount;
    RALiveCount maxLiveCount;

    // Process LIVE-IN.
    ZoneBitVector::ForEachBitSet it(block->liveIn());
    while (it.hasNext()) {
      RAWorkReg* workReg = _workRegs[uint32_t(it.next())];
      curLiveCount[workReg->group()]++;
      ASMJIT_PROPAGATE(workReg->liveSpans().openAt(allocator(), position, endPosition));
    }

    for (;;) {
      if (node->isInst()) {
        InstNode* inst = node->as<InstNode>();
        RAInst* raInst = inst->passData<RAInst>();
        ASMJIT_ASSERT(raInst != nullptr);

        RATiedReg* tiedRegs = raInst->tiedRegs();
        uint32_t count = raInst->tiedCount();

        inst->setPosition(position);
        raInst->_liveCount = curLiveCount;

        for (uint32_t j = 0; j < count; j++) {
          RATiedReg* tiedReg = &tiedRegs[j];
          uint32_t workId = tiedReg->workId();

          // Create refs and writes.
          RAWorkReg* workReg = workRegById(workId);
          workReg->_refs.appendUnsafe(node);
          if (tiedReg->isWrite())
            workReg->_writes.appendUnsafe(node);

          // We couldn't calculate this in previous steps, but since we know all LIVE-OUT at this point it becomes
          // trivial. If this is the last instruction that uses this `workReg` and it's not LIVE-OUT then it is
          // KILLed here.
          if (tiedReg->isLast() && !block->liveOut().bitAt(workId))
            tiedReg->addFlags(RATiedFlags::kKill);

          LiveRegSpans& liveSpans = workReg->liveSpans();
          bool wasOpen;
          ASMJIT_PROPAGATE(liveSpans.openAt(allocator(), position + !tiedReg->isRead(), endPosition, wasOpen));

          RegGroup group = workReg->group();
          if (!wasOpen) {
            curLiveCount[group]++;
            raInst->_liveCount[group]++;
          }

          if (tiedReg->isKill()) {
            liveSpans.closeAt(position + !tiedReg->isRead() + 1);
            curLiveCount[group]--;
          }

          // Update `RAWorkReg::useIdMask` and `RAWorkReg::hintRegId`.
          if (tiedReg->hasUseId()) {
            uint32_t useId = tiedReg->useId();
            workReg->addUseIdMask(Support::bitMask(useId));
            if (!workReg->hasHintRegId() && !Support::bitTest(raInst->_clobberedRegs[group], useId))
              workReg->setHintRegId(useId);
          }

          if (tiedReg->useRegMask()) {
            workReg->restrictPreferredMask(tiedReg->useRegMask());
            if (workReg->isLeadConsecutive())
              workReg->restrictConsecutiveMask(tiedReg->useRegMask());
          }

          if (tiedReg->outRegMask()) {
            workReg->restrictPreferredMask(tiedReg->outRegMask());
            if (workReg->isLeadConsecutive())
              workReg->restrictConsecutiveMask(tiedReg->outRegMask());
          }

          // Update `RAWorkReg::clobberedSurvivalMask`.
          if (raInst->_clobberedRegs[group] && !tiedReg->isOutOrKill()) {
            workReg->addClobberSurvivalMask(raInst->_clobberedRegs[group]);
          }
        }

        position += 2;
        maxLiveCount.op<Support::Max>(raInst->_liveCount);
      }

      if (node == stop)
        break;

      node = node->next();
      ASMJIT_ASSERT(node != nullptr);
    }

    block->_maxLiveCount = maxLiveCount;
    _globalMaxLiveCount.op<Support::Max>(maxLiveCount);
    ASMJIT_ASSERT(position == block->endPosition());
  }

  // Calculate WorkReg statistics
  // ----------------------------

  for (i = 0; i < numWorkRegs; i++) {
    RAWorkReg* workReg = _workRegs[i];

    LiveRegSpans& spans = workReg->liveSpans();
    uint32_t width = spans.width();
    float freq = width ? float(double(workReg->_refs.size()) / double(width)) : float(0);

    RALiveStats& stats = workReg->liveStats();
    stats._width = width;
    stats._freq = freq;
    stats._priority = freq + float(int(workReg->virtReg()->weight())) * 0.01f;
  }

  ASMJIT_RA_LOG_COMPLEX({
    sb.clear();
    _dumpLiveSpans(sb);
    logger->log(sb);
  });

  nUsesPerWorkReg.release(allocator());
  nOutsPerWorkReg.release(allocator());
  nInstsPerBlock.release(allocator());

  return kErrorOk;
}

Error BaseRAPass::assignArgIndexToWorkRegs() noexcept {
  ZoneBitVector& liveIn = entryBlock()->liveIn();
  uint32_t argCount = func()->argCount();

  for (uint32_t argIndex = 0; argIndex < argCount; argIndex++) {
    for (uint32_t valueIndex = 0; valueIndex < Globals::kMaxValuePack; valueIndex++) {
      // Unassigned argument.
      const RegOnly& regArg = func()->argPack(argIndex)[valueIndex];
      if (!regArg.isReg() || !cc()->isVirtIdValid(regArg.id()))
        continue;

      VirtReg* virtReg = cc()->virtRegById(regArg.id());
      if (!virtReg)
        continue;

      // Unreferenced argument.
      RAWorkReg* workReg = virtReg->workReg();
      if (!workReg)
        continue;

      // Overwritten argument.
      uint32_t workId = workReg->workId();
      if (!liveIn.bitAt(workId))
        continue;

      workReg->setArgIndex(argIndex, valueIndex);
      const FuncValue& arg = func()->detail().arg(argIndex, valueIndex);

      if (arg.isReg() && _archTraits->regTypeToGroup(arg.regType()) == workReg->group()) {
        workReg->setHintRegId(arg.regId());
      }
    }
  }

  return kErrorOk;
}

// BaseRAPass - Allocation - Global
// ================================

#ifndef ASMJIT_NO_LOGGING
static void RAPass_dumpSpans(String& sb, uint32_t index, const LiveRegSpans& liveSpans) noexcept {
  sb.appendFormat(""  %02u: "", index);

  for (uint32_t i = 0; i < liveSpans.size(); i++) {
    const LiveRegSpan& liveSpan = liveSpans[i];
    if (i) sb.append("", "");
    sb.appendFormat(""[%u:%u@%u]"", liveSpan.a, liveSpan.b, liveSpan.id);
  }

  sb.append('\\n');
}
#endif

Error BaseRAPass::runGlobalAllocator() noexcept {
  ASMJIT_PROPAGATE(initGlobalLiveSpans());

  for (RegGroup group : RegGroupVirtValues{}) {
    ASMJIT_PROPAGATE(binPack(group));
  }

  return kErrorOk;
}

ASMJIT_FAVOR_SPEED Error BaseRAPass::initGlobalLiveSpans() noexcept {
  for (RegGroup group : RegGroupVirtValues{}) {
    size_t physCount = _physRegCount[group];
    LiveRegSpans* liveSpans = nullptr;

    if (physCount) {
      liveSpans = allocator()->allocT<LiveRegSpans>(physCount * sizeof(LiveRegSpans));
      if (ASMJIT_UNLIKELY(!liveSpans))
        return DebugUtils::errored(kErrorOutOfMemory);

      for (size_t physId = 0; physId < physCount; physId++)
        new(&liveSpans[physId]) LiveRegSpans();
    }

    _globalLiveSpans[group] = liveSpans;
  }

  return kErrorOk;
}

struct RAConsecutiveReg {
  RAWorkReg* workReg;
  RAWorkReg* parentReg;
};

ASMJIT_FAVOR_SPEED Error BaseRAPass::binPack(RegGroup group) noexcept {
  if (workRegCount(group) == 0)
    return kErrorOk;

#ifndef ASMJIT_NO_LOGGING
  Logger* logger = getLoggerIf(DiagnosticOptions::kRADebugAssignment);
  StringTmp<512> sb;

  ASMJIT_RA_LOG_FORMAT(""[BinPack] Available=%u (0x%08X) Count=%u RegGroup=%u\\n"",
    Support::popcnt(_availableRegs[group]),
    _availableRegs[group],
    workRegCount(group),
    uint32_t(group));
#endif

  uint32_t i;
  uint32_t physCount = _physRegCount[group];

  RAWorkRegs workRegs;
  ZoneVector<RAConsecutiveReg> consecutiveRegs;
  LiveRegSpans tmpSpans;

  ASMJIT_PROPAGATE(workRegs.concat(allocator(), this->workRegs(group)));
  workRegs.sort([](const RAWorkReg* a, const RAWorkReg* b) noexcept {
    return b->liveStats().priority() - a->liveStats().priority();
  });

  uint32_t numWorkRegs = workRegs.size();
  RegMask availableRegs = _availableRegs[group];

  // First try to pack everything that provides register-id hint as these are most likely function arguments and fixed
  // (precolored) virtual registers.
  if (!workRegs.empty()) {
    uint32_t dstIndex = 0;

    for (i = 0; i < numWorkRegs; i++) {
      RAWorkReg* workReg = workRegs[i];

      if (workReg->isLeadConsecutive()) {
        ASMJIT_PROPAGATE(consecutiveRegs.append(allocator(), RAConsecutiveReg{workReg, nullptr}));
        workReg->markProcessedConsecutive();
      }

      if (workReg->hasHintRegId()) {
        uint32_t physId = workReg->hintRegId();
        if (Support::bitTest(availableRegs, physId)) {
          LiveRegSpans& live = _globalLiveSpans[group][physId];
          Error err = tmpSpans.nonOverlappingUnionOf(allocator(), live, workReg->liveSpans(), LiveRegData(workReg->virtId()));

          if (err == kErrorOk) {
            live.swap(tmpSpans);
            workReg->setHomeRegId(physId);
            workReg->markAllocated();
            continue;
          }

          if (err != 0xFFFFFFFFu)
            return err;
        }
      }

      workRegs[dstIndex++] = workReg;
    }

    workRegs._setSize(dstIndex);
    numWorkRegs = dstIndex;
  }

  // Allocate consecutive registers - both leads and all consecutives. This is important and prioritized over the rest,
  // because once a lead is allocated we really need to allocate its consecutives, otherwise we may bin pack other
  // registers into their places, which would result in wrong hints to the local allocator, and then into many moves
  // or spills.
  if (!consecutiveRegs.empty()) {
    // This loop appends all other consecutive registers into `consecutiveRegs` array. Leads are at the beginning,
    // non-leads follow.
    i = 0;
    for (;;) {
      uint32_t stop = consecutiveRegs.size();
      if (i == stop)
        break;

      while (i < stop) {
        RAWorkReg* workReg = consecutiveRegs[i].workReg;
        if (workReg->hasImmediateConsecutives()) {
          ZoneBitVector::ForEachBitSet it(workReg->immediateConsecutives());
          while (it.hasNext()) {
            uint32_t consecutiveWorkId = uint32_t(it.next());
            RAWorkReg* consecutiveReg = workRegById(consecutiveWorkId);
            if (!consecutiveReg->isProcessedConsecutive()) {
              ASMJIT_PROPAGATE(consecutiveRegs.append(allocator(), RAConsecutiveReg{consecutiveReg, workReg}));
              consecutiveReg->markProcessedConsecutive();
            }
          }
        }
        i++;
      }
    }

    uint32_t numConsecutiveRegs = consecutiveRegs.size();
    for (i = 0; i < numConsecutiveRegs; i++) {
      RAWorkReg* workReg = consecutiveRegs[i].workReg;
      if (workReg->isAllocated())
        continue;

      RAWorkReg* parentReg = consecutiveRegs[i].parentReg;
      RegMask physRegs = 0;

      if (!parentReg) {
        physRegs = availableRegs & workReg->preferredMask();
        if (!physRegs) {
          physRegs = availableRegs & workReg->consecutiveMask();

          // NOTE: This should never be true as it would mean we would never allocate this virtual register
          // (not here, and not later when local register allocator processes RATiedReg sets).
          if (ASMJIT_UNLIKELY(!physRegs))
            return DebugUtils::errored(kErrorConsecutiveRegsAllocation);
        }
      }
      else if (parentReg->hasHomeRegId()) {
        uint32_t consecutiveId = parentReg->homeRegId() + 1;

        // NOTE: We don't support wrapping. If this goes beyond all allocable registers there is something wrong.
        if (consecutiveId > 31 || !Support::bitTest(availableRegs, consecutiveId))
          return DebugUtils::errored(kErrorConsecutiveRegsAllocation);

        workReg->setHintRegId(consecutiveId);
        physRegs = Support::bitMask(consecutiveId);
      }

      while (physRegs) {
        uint32_t physId = Support::bitSizeOf<RegMask>() - 1 - Support::clz(physRegs);

        LiveRegSpans& live = _globalLiveSpans[group][physId];
        Error err = tmpSpans.nonOverlappingUnionOf(allocator(), live, workReg->liveSpans(), LiveRegData(workReg->virtId()));

        if (err == kErrorOk) {
          workReg->setHomeRegId(physId);
          workReg->markAllocated();
          live.swap(tmpSpans);
          break;
        }

        if (ASMJIT_UNLIKELY(err != 0xFFFFFFFFu))
          return err;

        physRegs ^= Support::bitMask(physId);
      }
    }
  }

  // Try to pack the rest.
  if (!workRegs.empty()) {
    uint32_t dstIndex = 0;

    for (i = 0; i < numWorkRegs; i++) {
      RAWorkReg* workReg = workRegs[i];

      if (workReg->isAllocated())
        continue;

      RegMask physRegs = availableRegs;
      if (physRegs & workReg->preferredMask())
        physRegs &= workReg->preferredMask();

      while (physRegs) {
        RegMask preferredMask = physRegs;
        uint32_t physId = Support::ctz(preferredMask);

        if (workReg->clobberSurvivalMask()) {
          preferredMask &= workReg->clobberSurvivalMask();
          if (preferredMask)
            physId = Support::ctz(preferredMask);
        }

        LiveRegSpans& live = _globalLiveSpans[group][physId];
        Error err = tmpSpans.nonOverlappingUnionOf(allocator(), live, workReg->liveSpans(), LiveRegData(workReg->virtId()));

        if (err == kErrorOk) {
          workReg->setHomeRegId(physId);
          workReg->markAllocated();
          live.swap(tmpSpans);
          break;
        }

        if (ASMJIT_UNLIKELY(err != 0xFFFFFFFFu))
          return err;

        physRegs ^= Support::bitMask(physId);
      }

      // Keep it in `workRegs` if it was not allocated.
      if (!physRegs)
        workRegs[dstIndex++] = workReg;
    }

    workRegs._setSize(dstIndex);
    numWorkRegs = dstIndex;
  }

  ASMJIT_RA_LOG_COMPLEX({
    for (uint32_t physId = 0; physId < physCount; physId++) {
      LiveRegSpans& live = _globalLiveSpans[group][physId];
      if (live.empty())
        continue;

      sb.clear();
      RAPass_dumpSpans(sb, physId, live);
      logger->log(sb);
    }
  });

  // Maybe unused if logging is disabled.
  DebugUtils::unused(physCount);

  if (workRegs.empty()) {
    ASMJIT_RA_LOG_FORMAT(""  Completed.\\n"");
  }
  else {
    _strategy[group].setType(RAStrategyType::kComplex);
    for (RAWorkReg* workReg : workRegs)
      workReg->markStackPreferred();

    ASMJIT_RA_LOG_COMPLEX({
      uint32_t count = workRegs.size();
      sb.clear();
      sb.appendFormat(""  Unassigned (%u): "", count);
      for (i = 0; i < numWorkRegs; i++) {
        RAWorkReg* workReg = workRegs[i];
        if (i) sb.append("", "");
        sb.append(workReg->name());
      }
      sb.append('\\n');
      logger->log(sb);
    });
  }

  return kErrorOk;
}

// BaseRAPass - Allocation - Local
// ===============================

Error BaseRAPass::runLocalAllocator() noexcept {
  RALocalAllocator lra(this);
  ASMJIT_PROPAGATE(lra.init());

  if (!blockCount())
    return kErrorOk;

  // The allocation is done when this reaches zero.
  uint32_t blocksRemaining = reachableBlockCount();

  // Current block.
  uint32_t blockId = 0;
  RABlock* block = _blocks[blockId];

  // The first block (entry) must always be reachable.
  ASMJIT_ASSERT(block->isReachable());

  // Assign function arguments for the initial block. The `lra` is valid now.
  lra.makeInitialAssignment();
  ASMJIT_PROPAGATE(setBlockEntryAssignment(block, block, lra._curAssignment));

  // The loop starts from the first block and iterates blocks in order, however, the algorithm also allows to jump to
  // any other block when finished if it's a jump target. In-order iteration just makes sure that all blocks are visited.
  for (;;) {
    BaseNode* first = block->first();
    BaseNode* last = block->last();
    BaseNode* terminator = block->hasTerminator() ? last : nullptr;

    BaseNode* beforeFirst = first->prev();
    BaseNode* afterLast = last->next();

    bool unconditionalJump = false;
    RABlock* consecutive = nullptr;

    if (block->hasSuccessors())
      consecutive = block->successors()[0];

    lra.setBlock(block);
    block->makeAllocated();

    BaseNode* node = first;
    while (node != afterLast) {
      BaseNode* next = node->next();
      if (node->isInst()) {
        InstNode* inst = node->as<InstNode>();

        if (ASMJIT_UNLIKELY(inst == terminator)) {
          const RABlocks& successors = block->successors();
          if (block->hasConsecutive()) {
            ASMJIT_PROPAGATE(lra.allocBranch(inst, successors.last(), successors.first()));

            node = next;
            continue;
          }
          else if (successors.size() > 1) {
            RABlock* cont = block->hasConsecutive() ? successors.first() : nullptr;
            ASMJIT_PROPAGATE(lra.allocJumpTable(inst, successors, cont));

            node = next;
            continue;
          }
          else {
            // Otherwise this is an unconditional jump, special handling isn't required.
            unconditionalJump = true;
          }
        }

        ASMJIT_PROPAGATE(lra.allocInst(inst));
        if (inst->type() == NodeType::kInvoke)
          ASMJIT_PROPAGATE(emitPreCall(inst->as<InvokeNode>()));
        else
          ASMJIT_PROPAGATE(lra.spillAfterAllocation(inst));
      }
      node = next;
    }

    if (consecutive) {
      BaseNode* prev = afterLast ? afterLast->prev() : cc()->lastNode();
      cc()->_setCursor(unconditionalJump ? prev->prev() : prev);

      if (consecutive->hasEntryAssignment()) {
        ASMJIT_PROPAGATE(
          lra.switchToAssignment(
            consecutive->entryPhysToWorkMap(),
            consecutive->entryWorkToPhysMap(),
            consecutive->liveIn(),
            consecutive->isAllocated(),
            false));
      }
      else {
        ASMJIT_PROPAGATE(lra.spillRegsBeforeEntry(consecutive));
        ASMJIT_PROPAGATE(setBlockEntryAssignment(consecutive, block, lra._curAssignment));
        lra._curAssignment.copyFrom(consecutive->entryPhysToWorkMap(), consecutive->entryWorkToPhysMap());
      }
    }

    // Important as the local allocator can insert instructions before
    // and after any instruction within the basic block.
    block->setFirst(beforeFirst->next());
    block->setLast(afterLast ? afterLast->prev() : cc()->lastNode());

    if (--blocksRemaining == 0)
      break;

    // Switch to the next consecutive block, if any.
    if (consecutive) {
      block = consecutive;
      if (!block->isAllocated())
        continue;
    }

    // Get the next block.
    for (;;) {
      if (++blockId >= blockCount())
        blockId = 0;

      block = _blocks[blockId];
      if (!block->isReachable() || block->isAllocated() || !block->hasEntryAssignment())
        continue;

      break;
    }

    // If we switched to some block we have to update the local allocator.
    lra.replaceAssignment(block->entryPhysToWorkMap(), block->entryWorkToPhysMap());
  }

  _clobberedRegs.op<Support::Or>(lra._clobberedRegs);
  return kErrorOk;
}

Error BaseRAPass::setBlockEntryAssignment(RABlock* block, const RABlock* fromBlock, const RAAssignment& fromAssignment) noexcept {
  if (block->hasSharedAssignmentId()) {
    uint32_t sharedAssignmentId = block->sharedAssignmentId();

    // Shouldn't happen. Entry assignment of a block that has a shared-state will assign to all blocks
    // with the same sharedAssignmentId. It's a bug if the shared state has been already assigned.
    if (!_sharedAssignments[sharedAssignmentId].empty())
      return DebugUtils::errored(kErrorInvalidState);

    return setSharedAssignment(sharedAssignmentId, fromAssignment);
  }

  PhysToWorkMap* physToWorkMap = clonePhysToWorkMap(fromAssignment.physToWorkMap());
  WorkToPhysMap* workToPhysMap = cloneWorkToPhysMap(fromAssignment.workToPhysMap());

  if (ASMJIT_UNLIKELY(!physToWorkMap || !workToPhysMap))
    return DebugUtils::errored(kErrorOutOfMemory);

  block->setEntryAssignment(physToWorkMap, workToPhysMap);

  // True if this is the first (entry) block, nothing to do in this case.
  if (block == fromBlock) {
    // Entry block should never have a shared state.
    if (block->hasSharedAssignmentId())
      return DebugUtils::errored(kErrorInvalidState);

    return kErrorOk;
  }

  RAAssignment as;
  as.initLayout(_physRegCount, workRegs());
  as.initMaps(physToWorkMap, workToPhysMap);

  const ZoneBitVector& liveOut = fromBlock->liveOut();
  const ZoneBitVector& liveIn = block->liveIn();

  // It's possible that `fromBlock` has LIVE-OUT regs that `block` doesn't
  // have in LIVE-IN, these have to be unassigned.
  {
    ZoneBitVector::ForEachBitOp<Support::AndNot> it(liveOut, liveIn);
    while (it.hasNext()) {
      uint32_t workId = uint32_t(it.next());
      RAWorkReg* workReg = workRegById(workId);

      RegGroup group = workReg->group();
      uint32_t physId = as.workToPhysId(group, workId);

      if (physId != RAAssignment::kPhysNone)
        as.unassign(group, workId, physId);
    }
  }

  return blockEntryAssigned(as);
}

Error BaseRAPass::setSharedAssignment(uint32_t sharedAssignmentId, const RAAssignment& fromAssignment) noexcept {
  ASMJIT_ASSERT(_sharedAssignments[sharedAssignmentId].empty());

  PhysToWorkMap* physToWorkMap = clonePhysToWorkMap(fromAssignment.physToWorkMap());
  WorkToPhysMap* workToPhysMap = cloneWorkToPhysMap(fromAssignment.workToPhysMap());

  if (ASMJIT_UNLIKELY(!physToWorkMap || !workToPhysMap))
    return DebugUtils::errored(kErrorOutOfMemory);

  _sharedAssignments[sharedAssignmentId].assignMaps(physToWorkMap, workToPhysMap);
  ZoneBitVector& sharedLiveIn = _sharedAssignments[sharedAssignmentId]._liveIn;
  ASMJIT_PROPAGATE(sharedLiveIn.resize(allocator(), workRegCount()));

  RAAssignment as;
  as.initLayout(_physRegCount, workRegs());

  Support::Array<uint32_t, Globals::kNumVirtGroups> sharedAssigned {};

  for (RABlock* block : blocks()) {
    if (block->sharedAssignmentId() == sharedAssignmentId) {
      ASMJIT_ASSERT(!block->hasEntryAssignment());

      PhysToWorkMap* entryPhysToWorkMap = clonePhysToWorkMap(fromAssignment.physToWorkMap());
      WorkToPhysMap* entryWorkToPhysMap = cloneWorkToPhysMap(fromAssignment.workToPhysMap());

      if (ASMJIT_UNLIKELY(!entryPhysToWorkMap || !entryWorkToPhysMap))
        return DebugUtils::errored(kErrorOutOfMemory);

      block->setEntryAssignment(entryPhysToWorkMap, entryWorkToPhysMap);
      as.initMaps(entryPhysToWorkMap, entryWorkToPhysMap);

      const ZoneBitVector& liveIn = block->liveIn();
      sharedLiveIn.or_(liveIn);

      for (RegGroup group : RegGroupVirtValues{}) {
        sharedAssigned[group] |= entryPhysToWorkMap->assigned[group];
        Support::BitWordIterator<RegMask> it(entryPhysToWorkMap->assigned[group]);

        while (it.hasNext()) {
          uint32_t physId = it.next();
          uint32_t workId = as.physToWorkId(group, physId);

          if (!liveIn.bitAt(workId))
            as.unassign(group, workId, physId);
        }
      }
    }
  }

  {
    as.initMaps(physToWorkMap, workToPhysMap);

    for (RegGroup group : RegGroupVirtValues{}) {
      Support::BitWordIterator<RegMask> it(_availableRegs[group] & ~sharedAssigned[group]);

      while (it.hasNext()) {
        uint32_t physId = it.next();
        if (as.isPhysAssigned(group, physId)) {
          uint32_t workId = as.physToWorkId(group, physId);
          as.unassign(group, workId, physId);
        }
      }
    }
  }

  return blockEntryAssigned(as);
}

Error BaseRAPass::blockEntryAssigned(const RAAssignment& as) noexcept {
  // Complex allocation strategy requires to record register assignments upon block entry (or per shared state).
  for (RegGroup group : RegGroupVirtValues{}) {
    if (!_strategy[group].isComplex())
      continue;

    Support::BitWordIterator<RegMask> it(as.assigned(group));
    while (it.hasNext()) {
      uint32_t physId = it.next();
      uint32_t workId = as.physToWorkId(group, physId);

      RAWorkReg* workReg = workRegById(workId);
      workReg->addAllocatedMask(Support::bitMask(physId));
    }
  }

  return kErrorOk;
}

// BaseRAPass - Allocation - Utilities
// ===================================

Error BaseRAPass::useTemporaryMem(BaseMem& out, uint32_t size, uint32_t alignment) noexcept {
  ASMJIT_ASSERT(alignment <= 64);

  if (_temporaryMem.isNone()) {
    ASMJIT_PROPAGATE(cc()->_newStack(&_temporaryMem.as<BaseMem>(), size, alignment));
  }
  else {
    ASMJIT_ASSERT(_temporaryMem.as<BaseMem>().isRegHome());

    uint32_t virtId = _temporaryMem.as<BaseMem>().baseId();
    VirtReg* virtReg = cc()->virtRegById(virtId);

    cc()->setStackSize(virtId, Support::max(virtReg->virtSize(), size),
                               Support::max(virtReg->alignment(), alignment));
  }

  out = _temporaryMem.as<BaseMem>();
  return kErrorOk;
}

// BaseRAPass - Allocation - Prolog & Epilog
// =========================================

Error BaseRAPass::updateStackFrame() noexcept {
  // Update some StackFrame information that we updated during allocation. The only information we don't have at the
  // moment is final local stack size, which is calculated last.
  FuncFrame& frame = func()->frame();
  for (RegGroup group : RegGroupVirtValues{})
    frame.addDirtyRegs(group, _clobberedRegs[group]);
  frame.setLocalStackAlignment(_stackAllocator.alignment());

  // If there are stack arguments that are not assigned to registers upon entry and the function doesn't require
  // dynamic stack alignment we keep these arguments where they are. This will also mark all stack slots that match
  // these arguments as allocated.
  if (_numStackArgsToStackSlots)
    ASMJIT_PROPAGATE(_markStackArgsToKeep());

  // Calculate offsets of all stack slots and update StackSize to reflect the calculated local stack size.
  ASMJIT_PROPAGATE(_stackAllocator.calculateStackFrame());
  frame.setLocalStackSize(_stackAllocator.stackSize());

  // Update the stack frame based on `_argsAssignment` and finalize it. Finalization means to apply final calculation
  // to the stack layout.
  ASMJIT_PROPAGATE(_argsAssignment.updateFuncFrame(frame));
  ASMJIT_PROPAGATE(frame.finalize());

  // StackAllocator allocates all stots starting from [0], adjust them when necessary.
  if (frame.localStackOffset() != 0)
    ASMJIT_PROPAGATE(_stackAllocator.adjustSlotOffsets(int32_t(frame.localStackOffset())));

  // Again, if there are stack arguments allocated in function's stack we have to handle them. This handles all cases
  // (either regular or dynamic stack alignment).
  if (_numStackArgsToStackSlots)
    ASMJIT_PROPAGATE(_updateStackArgs());

  return kErrorOk;
}

Error BaseRAPass::_markStackArgsToKeep() noexcept {
  FuncFrame& frame = func()->frame();
  bool hasSAReg = frame.hasPreservedFP() || !frame.hasDynamicAlignment();

  RAWorkRegs& workRegs = _workRegs;
  uint32_t numWorkRegs = workRegCount();

  for (uint32_t workId = 0; workId < numWorkRegs; workId++) {
    RAWorkReg* workReg = workRegs[workId];
    if (workReg->hasFlag(RAWorkRegFlags::kStackArgToStack)) {
      ASMJIT_ASSERT(workReg->hasArgIndex());
      const FuncValue& srcArg = _func->detail().arg(workReg->argIndex());

      // If the register doesn't have stack slot then we failed. It doesn't make much sense as it was marked as
      // `kFlagStackArgToStack`, which requires the WorkReg was live-in upon function entry.
      RAStackSlot* slot = workReg->stackSlot();
      if (ASMJIT_UNLIKELY(!slot))
        return DebugUtils::errored(kErrorInvalidState);

      if (hasSAReg && srcArg.isStack() && !srcArg.isIndirect()) {
        uint32_t typeSize = TypeUtils::sizeOf(srcArg.typeId());
        if (typeSize == slot->size()) {
          slot->addFlags(RAStackSlot::kFlagStackArg);
          continue;
        }
      }

      // NOTE: Update StackOffset here so when `_argsAssignment.updateFuncFrame()` is called it will take into
      // consideration moving to stack slots. Without this we may miss some scratch registers later.
      FuncValue& dstArg = _argsAssignment.arg(workReg->argIndex(), workReg->argValueIndex());
      dstArg.assignStackOffset(0);
    }
  }

  return kErrorOk;
}

Error BaseRAPass::_updateStackArgs() noexcept {
  FuncFrame& frame = func()->frame();
  RAWorkRegs& workRegs = _workRegs;
  uint32_t numWorkRegs = workRegCount();

  for (uint32_t workId = 0; workId < numWorkRegs; workId++) {
    RAWorkReg* workReg = workRegs[workId];
    if (workReg->hasFlag(RAWorkRegFlags::kStackArgToStack)) {
      ASMJIT_ASSERT(workReg->hasArgIndex());
      RAStackSlot* slot = workReg->stackSlot();

      if (ASMJIT_UNLIKELY(!slot))
        return DebugUtils::errored(kErrorInvalidState);

      if (slot->isStackArg()) {
        const FuncValue& srcArg = _func->detail().arg(workReg->argIndex());
        if (frame.hasPreservedFP()) {
          slot->setBaseRegId(_fp.id());
          slot->setOffset(int32_t(frame.saOffsetFromSA()) + srcArg.stackOffset());
        }
        else {
          slot->setOffset(int32_t(frame.saOffsetFromSP()) + srcArg.stackOffset());
        }
      }
      else {
        FuncValue& dstArg = _argsAssignment.arg(workReg->argIndex(), workReg->argValueIndex());
        dstArg.setStackOffset(slot->offset());
      }
    }
  }

  return kErrorOk;
}

Error BaseRAPass::insertPrologEpilog() noexcept {
  FuncFrame& frame = _func->frame();

  cc()->_setCursor(func());
  ASMJIT_PROPAGATE(cc()->emitProlog(frame));
  ASMJIT_PROPAGATE(_iEmitHelper->emitArgsAssignment(frame, _argsAssignment));

  cc()->_setCursor(func()->exitNode());
  ASMJIT_PROPAGATE(cc()->emitEpilog(frame));

  return kErrorOk;
}

// BaseRAPass - Rewriter
// =====================

Error BaseRAPass::rewrite() noexcept {
  return _rewrite(_func, _stop);
}

// BaseRAPass - Logging
// ====================

#ifndef ASMJIT_NO_LOGGING
static void RAPass_formatLiveness(BaseRAPass* pass, String& sb, const RAInst* raInst) noexcept {
  const RATiedReg* tiedRegs = raInst->tiedRegs();
  uint32_t tiedCount = raInst->tiedCount();

  for (uint32_t i = 0; i < tiedCount; i++) {
    const RATiedReg& tiedReg = tiedRegs[i];

    if (i != 0)
      sb.append(' ');

    sb.appendFormat(""%s{"", pass->workRegById(tiedReg.workId())->name());
    sb.append(tiedReg.isReadWrite() ? 'X' :
              tiedReg.isRead()      ? 'R' :
              tiedReg.isWrite()     ? 'W' : '?');

    if (tiedReg.isLeadConsecutive())
      sb.appendFormat(""|Lead[%u]"", tiedReg.consecutiveData() + 1u);

    if (tiedReg.hasUseId())
      sb.appendFormat(""|Use=%u"", tiedReg.useId());
    else if (tiedReg.isUse())
      sb.append(""|Use"");

    if (tiedReg.isUseConsecutive() && !tiedReg.isLeadConsecutive())
      sb.appendFormat(""+%u"", tiedReg.consecutiveData());

    if (tiedReg.hasOutId())
      sb.appendFormat(""|Out=%u"", tiedReg.outId());
    else if (tiedReg.isOut())
      sb.append(""|Out"");

    if (tiedReg.isOutConsecutive() && !tiedReg.isLeadConsecutive())
      sb.appendFormat(""+%u"", tiedReg.consecutiveData());

    if (tiedReg.isLast())
      sb.append(""|Last"");

    if (tiedReg.isKill())
      sb.append(""|Kill"");

    sb.append(""}"");
  }
}

ASMJIT_FAVOR_SIZE Error BaseRAPass::annotateCode() noexcept {
  StringTmp<1024> sb;

  for (const RABlock* block : _blocks) {
    BaseNode* node = block->first();
    if (!node) continue;

    BaseNode* last = block->last();
    for (;;) {
      sb.clear();
      Formatter::formatNode(sb, _formatOptions, cc(), node);

      if (hasDiagnosticOption(DiagnosticOptions::kRADebugLiveness) && node->isInst() && node->hasPassData()) {
        const RAInst* raInst = node->passData<RAInst>();
        if (raInst->tiedCount() > 0) {
          sb.padEnd(40);
          sb.append("" | "");
          RAPass_formatLiveness(this, sb, raInst);
        }
      }

      node->setInlineComment(static_cast<char*>(cc()->_dataZone.dup(sb.data(), sb.size(), true)));
      if (node == last)
        break;
      node = node->next();
    }
  }

  return kErrorOk;
}

ASMJIT_FAVOR_SIZE Error BaseRAPass::_dumpBlockIds(String& sb, const RABlocks& blocks) noexcept {
  for (uint32_t i = 0, size = blocks.size(); i < size; i++) {
    const RABlock* block = blocks[i];
    if (i != 0)
      ASMJIT_PROPAGATE(sb.appendFormat("", #%u"", block->blockId()));
    else
      ASMJIT_PROPAGATE(sb.appendFormat(""#%u"", block->blockId()));
  }
  return kErrorOk;
}

ASMJIT_FAVOR_SIZE Error BaseRAPass::_dumpBlockLiveness(String& sb, const RABlock* block) noexcept {
  for (uint32_t liveType = 0; liveType < RABlock::kLiveCount; liveType++) {
    const char* bitsName = liveType == RABlock::kLiveIn  ? ""IN  "" :
                           liveType == RABlock::kLiveOut ? ""OUT "" :
                           liveType == RABlock::kLiveGen ? ""GEN "" : ""KILL"";

    const ZoneBitVector& bits = block->_liveBits[liveType];
    uint32_t size = bits.size();
    ASMJIT_ASSERT(size <= workRegCount());

    uint32_t n = 0;
    for (uint32_t workId = 0; workId < size; workId++) {
      if (bits.bitAt(workId)) {
        RAWorkReg* wReg = workRegById(workId);

        if (!n)
          sb.appendFormat(""    %s ["", bitsName);
        else
          sb.append("", "");

        sb.append(wReg->name());
        n++;
      }
    }

    if (n)
      sb.append(""]\\n"");
  }

  return kErrorOk;
}

ASMJIT_FAVOR_SIZE Error BaseRAPass::_dumpLiveSpans(String& sb) noexcept {
  uint32_t numWorkRegs = _workRegs.size();
  uint32_t maxSize = _maxWorkRegNameSize;

  for (uint32_t workId = 0; workId < numWorkRegs; workId++) {
    RAWorkReg* workReg = _workRegs[workId];

    sb.append(""  "");

    size_t oldSize = sb.size();
    sb.append(workReg->name());
    sb.padEnd(oldSize + maxSize);

    RALiveStats& stats = workReg->liveStats();
    sb.appendFormat("" {id:%04u width: %-4u freq: %0.4f priority=%0.4f}"",
      workReg->virtId(),
      stats.width(),
      stats.freq(),
      stats.priority());
    sb.append("": "");

    LiveRegSpans& liveSpans = workReg->liveSpans();
    for (uint32_t x = 0; x < liveSpans.size(); x++) {
      const LiveRegSpan& liveSpan = liveSpans[x];
      if (x)
        sb.append("", "");
      sb.appendFormat(""[%u:%u]"", liveSpan.a, liveSpan.b);
    }

    sb.append('\\n');
  }

  return kErrorOk;
}
#endif

ASMJIT_END_NAMESPACE

#endif // !ASMJIT_NO_COMPILER
",16322,True,3171.5162022330856,median
"/*
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the ""License"").
 * You may not use this file except in compliance with the License.
 * A copy of the License is located at
 *
 *     http://aws.amazon.com/apache2.0/
 *
 * or in the ""license"" file accompanying this file. This file is distributed
 * on an ""AS IS"" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 */

#include <climits>

#include ""APLClient/AplCoreTextMeasurement.h""
#include ""APLClient/AplCoreLocaleMethods.h""
#include ""APLClient/AplCoreConnectionManager.h""
#include ""APLClient/AplCoreViewhostMessage.h""

#include <apl/datasource/dynamicindexlistdatasourceprovider.h>
#include <apl/datasource/dynamictokenlistdatasourceprovider.h>

namespace APLClient {

/// The keys used in ProvideState.
static const char TOKEN_KEY[] = ""token"";
static const char VERSION_KEY[] = ""version"";
static const char VISUAL_CONTEXT_KEY[] = ""componentsVisibleOnScreen"";
static const char DATASOURCE_CONTEXT_KEY[] = ""dataSources"";
/// The value used in ProvideState.
static const char CLIENT_VERSION_PREFIX[] = ""AplClientLibrary-"";

// Key used in messaging
static const char SEQNO_KEY[] = ""seqno"";

/// APL Scaling bias constant
static const float SCALING_BIAS_CONSTANT = 10.0f;
/// APL Scaling cost override
static const bool SCALING_SHAPE_OVERRIDES_COST = true;

/// The keys used in APL context creation.
static const char HEIGHT_KEY[] = ""height"";
static const char WIDTH_KEY[] = ""width"";
static const char DPI_KEY[] = ""dpi"";
static const char MODE_KEY[] = ""mode"";
static const char SHAPE_KEY[] = ""shape"";
static const char SCALING_KEY[] = ""scaling"";
static const char SCALE_FACTOR_KEY[] = ""scaleFactor"";
static const char VIEWPORT_WIDTH_KEY[] = ""viewportWidth"";
static const char VIEWPORT_HEIGHT_KEY[] = ""viewportHeight"";
static const char HIERARCHY_KEY[] = ""hierarchy"";
static const char REHIERARCHY_KEY[] = ""reHierarchy"";
static const char X_KEY[] = ""x"";
static const char Y_KEY[] = ""y"";
static const char DOCTHEME_KEY[] = ""docTheme"";
static const char BACKGROUND_KEY[] = ""background"";
static const char SCREENLOCK_KEY[] = ""screenLock"";
static const char COLOR_KEY[] = ""color"";
static const char GRADIENT_KEY[] = ""gradient"";
static const char ENSURELAYOUT_KEY[] = ""ensureLayout"";
static const char AGENTNAME_KEY[] = ""agentName"";
static const char AGENTVERSION_KEY[] = ""agentVersion"";
static const char ALLOWOPENURL_KEY[] = ""allowOpenUrl"";
static const char DISALLOWVIDEO_KEY[] = ""disallowVideo"";
static const char ANIMATIONQUALITY_KEY[] = ""animationQuality"";
static const char SUPPORTED_EXTENSIONS[] = ""supportedExtensions"";
static const char EXTENSION_MESSAGE_KEY[] = ""extension"";

/// The keys used in OS accessibility settings.
static const char FONTSCALE_KEY[] = ""fontScale"";
static const char SCREENMODE_KEY[] = ""screenMode"";
static const char SCREENREADER_KEY[] = ""screenReader"";

/// Document settings keys.
static const char SUPPORTS_RESIZING_KEY[] = ""supportsResizing"";

/// The keys used in APL event execution.
static const char ERROR_KEY[] = ""error"";
static const char EVENT_KEY[] = ""event"";
static const char ARGUMENT_KEY[] = ""argument"";
static const char EVENT_TERMINATE_KEY[] = ""eventTerminate"";
static const char DIRTY_KEY[] = ""dirty"";

/// SendEvent keys
static const char PRESENTATION_TOKEN_KEY[] = ""presentationToken"";
static const char SOURCE_KEY[] = ""source"";
static const char ARGUMENTS_KEY[] = ""arguments"";
static const char COMPONENTS_KEY[] = ""components"";

/// RuntimeError keys
static const char ERRORS_KEY[] = ""errors"";

/// Media update keys
static const char MEDIA_STATE_KEY[] = ""mediaState"";
static const char FROM_EVENT_KEY[] = ""fromEvent"";
static const char TRACK_INDEX_KEY[] = ""trackIndex"";
static const char TRACK_COUNT_KEY[] = ""trackCount"";
static const char TRACK_STATE_KEY[] = ""trackState"";
static const char CURRENT_TIME_KEY[] = ""currentTime"";
static const char DURATION_KEY[] = ""duration"";
static const char PAUSED_KEY[] = ""paused"";
static const char ENDED_KEY[] = ""ended"";

/// Activity tracking sources
static const std::string APL_COMMAND_EXECUTION{""APLCommandExecution""};
static const std::string APL_SCREEN_LOCK{""APLScreenLock""};
static const char RENDERING_OPTIONS_KEY[] = ""renderingOptions"";

static const char LEGACY_KARAOKE_KEY[] = ""legacyKaraoke"";

/// HandlePointerEvent keys
static const char POINTEREVENTTYPE_KEY[] = ""pointerEventType"";
static const char POINTERTYPE_KEY[] = ""pointerType"";
static const char POINTERID_KEY[] = ""pointerId"";

/// Data sources
static const std::vector<std::string> KNOWN_DATA_SOURCES = {
        apl::DynamicIndexListConstants::DEFAULT_TYPE_NAME,
        apl::DynamicTokenListConstants::DEFAULT_TYPE_NAME,
};

static apl::Bimap<std::string, apl::ViewportMode> AVS_VIEWPORT_MODE_MAP = {
        {""HUB"",    apl::ViewportMode::kViewportModeHub},
        {""TV"",     apl::ViewportMode::kViewportModeTV},
        {""MOBILE"", apl::ViewportMode::kViewportModeMobile},
        {""AUTO"",   apl::ViewportMode::kViewportModeAuto},
        {""PC"",     apl::ViewportMode::kViewportModePC},
};

static apl::Bimap<std::string, apl::ScreenShape> AVS_VIEWPORT_SHAPE_MAP = {
        {""ROUND"",     apl::ScreenShape::ROUND},
        {""RECTANGLE"", apl::ScreenShape::RECTANGLE},
};

static apl::Bimap<std::string, apl::RootConfig::ScreenMode> AVS_SCREEN_MODE_MAP = {
        {""normal"",        apl::RootConfig::kScreenModeNormal},
        {""high-contrast"", apl::RootConfig::kScreenModeHighContrast},
};

AplCoreConnectionManager::AplCoreConnectionManager(AplConfigurationPtr config) :
        m_aplConfiguration{config},
        m_ScreenLock{false},
        m_SequenceNumber{0},
        m_replyExpectedSequenceNumber{0},
        m_blockingSendReplyExpected{false} {
    m_StartTime = getCurrentTime();

    m_extensionManager = std::make_shared<AplCoreExtensionManager>();
    m_messageHandlers.emplace(""build"", [this](const rapidjson::Value& payload) { handleBuild(payload); });
    m_messageHandlers.emplace(""configurationChange"",[this](const rapidjson::Value& payload) { handleConfigurationChange(payload); });
    m_messageHandlers.emplace(""updateDisplayState"", [this](const rapidjson::Value& payload) { handleUpdateDisplayState(payload); });
    m_messageHandlers.emplace(""update"", [this](const rapidjson::Value& payload) { handleUpdate(payload); });
    m_messageHandlers.emplace(""updateMedia"", [this](const rapidjson::Value& payload) { handleMediaUpdate(payload); });
    m_messageHandlers.emplace(""updateGraphic"", [this](const rapidjson::Value& payload) { handleGraphicUpdate(payload); });
    m_messageHandlers.emplace(""response"", [this](const rapidjson::Value& payload) { handleEventResponse(payload); });
    m_messageHandlers.emplace(""ensureLayout"", [this](const rapidjson::Value& payload) { handleEnsureLayout(payload); });
    m_messageHandlers.emplace(""scrollToRectInComponent"",[this](const rapidjson::Value& payload) { handleScrollToRectInComponent(payload); });
    m_messageHandlers.emplace(""handleKeyboard"", [this](const rapidjson::Value& payload) { handleHandleKeyboard(payload); });
    m_messageHandlers.emplace(""getFocusableAreas"", [this](const rapidjson::Value& payload) { getFocusableAreas(payload); });
    m_messageHandlers.emplace(""getFocused"", [this](const rapidjson::Value& payload) { getFocused(payload); });
    m_messageHandlers.emplace(""setFocus"", [this](const rapidjson::Value& payload) { setFocus(payload); });
    m_messageHandlers.emplace(""updateCursorPosition"", [this](const rapidjson::Value& payload) { handleUpdateCursorPosition(payload); });
    m_messageHandlers.emplace(""handlePointerEvent"", [this](const rapidjson::Value& payload) { handleHandlePointerEvent(payload); });
    m_messageHandlers.emplace(""isCharacterValid"", [this](const rapidjson::Value& payload) { handleIsCharacterValid(payload); });
    m_messageHandlers.emplace(""reInflate"", [this](const rapidjson::Value& payload) { handleReInflate(payload); });
    m_messageHandlers.emplace(""reHierarchy"", [this](const rapidjson::Value& payload) { handleReHierarchy(payload); });
    m_messageHandlers.emplace(""extension"", [this](const rapidjson::Value& payload) { handleExtensionMessage(payload); });
    m_messageHandlers.emplace(""mediaLoaded"", [this](const rapidjson::Value& payload) { mediaLoaded(payload); });
    m_messageHandlers.emplace(""mediaLoadFailed"", [this](const rapidjson::Value& payload) { mediaLoadFailed(payload); });
}

void AplCoreConnectionManager::setContent(const apl::ContentPtr content, const std::string& token) {
    m_Content = content;
    m_aplToken = token;
    m_ConfigurationChange.clear();
    m_aplConfiguration->getAplOptions()->resetViewhost(token);
}

void AplCoreConnectionManager::setSupportedViewports(const std::string& jsonPayload) {
    rapidjson::Document doc;
    auto aplOptions = m_aplConfiguration->getAplOptions();
    if (doc.Parse(jsonPayload.c_str()).HasParseError()) {
        aplOptions->logMessage(LogLevel::ERROR, ""setSupportedViewportsFailed"", ""Failed to parse json payload"");
        return;
    }

    if (doc.GetType() != rapidjson::Type::kArrayType) {
        aplOptions->logMessage(LogLevel::ERROR, ""setSupportedViewportsFailed"", ""Unexpected json document type"");
        return;
    }

    m_ViewportSizeSpecifications.clear();
    for (auto& spec : doc.GetArray()) {
        double minWidth = getOptionalValue(spec, ""minWidth"", 1);
        double maxWidth = getOptionalValue(spec, ""maxWidth"", INT_MAX);
        double minHeight = getOptionalValue(spec, ""minHeight"", 1);
        double maxHeight = getOptionalValue(spec, ""maxHeight"", INT_MAX);
        std::string mode = getOptionalValue(spec, ""mode"", ""HUB"");
        std::string shape = spec.FindMember(""shape"")->value.GetString();

        m_ViewportSizeSpecifications.emplace_back(
                minWidth,
                maxWidth,
                minHeight,
                maxHeight,
                AVS_VIEWPORT_MODE_MAP.at(mode),
                AVS_VIEWPORT_SHAPE_MAP.at(shape) == apl::ScreenShape::ROUND);
    }
}

double AplCoreConnectionManager::getOptionalValue(
        const rapidjson::Value& jsonNode,
        const std::string& key,
        double defaultValue) {
    double value = defaultValue;
    const auto& valueIt = jsonNode.FindMember(key);
    if (valueIt != jsonNode.MemberEnd()) {
        value = valueIt->value.GetDouble();
    }

    return value;
}

std::string AplCoreConnectionManager::getOptionalValue(
        const rapidjson::Value& jsonNode,
        const std::string& key,
        const std::string& defaultValue) {
    std::string value = defaultValue;
    const auto& valueIt = jsonNode.FindMember(key);
    if (valueIt != jsonNode.MemberEnd()) {
        value = valueIt->value.GetString();
    }

    return value;
}

bool AplCoreConnectionManager::getOptionalBool(
        const rapidjson::Value& jsonNode,
        const std::string& key,
        bool defaultValue) {
    bool value = defaultValue;
    const auto& valueIt = jsonNode.FindMember(key);
    if (valueIt != jsonNode.MemberEnd()) {
        value = valueIt->value.GetBool();
    }

    return value;
}

int AplCoreConnectionManager::getOptionalInt(
        const rapidjson::Value& jsonNode,
        const std::string& key,
        int defaultValue) {
    if (jsonNode.HasMember(key) && jsonNode[key].IsInt()) {
        return jsonNode[key].GetInt();
    }

    return defaultValue;
}

bool AplCoreConnectionManager::shouldHandleMessage(const std::string& message) {
    if (m_blockingSendReplyExpected) {
        rapidjson::Document doc;
        if (doc.Parse(message.c_str()).HasParseError()) {
            auto aplOptions = m_aplConfiguration->getAplOptions();
            aplOptions->logMessage(LogLevel::ERROR, ""shouldHandleMessageFailed"", ""Error whilst parsing message"");
            return false;
        }

        if (doc.HasMember(SEQNO_KEY) && doc[SEQNO_KEY].IsNumber()) {
            unsigned int seqno = doc[SEQNO_KEY].GetUint();
            if (seqno == m_replyExpectedSequenceNumber) {
                m_blockingSendReplyExpected = false;
                m_replyPromise.set_value(message);
                return false;
            }
        }
    }

    return true;
}

void AplCoreConnectionManager::handleMessage(const std::string& message) {
    auto aplOptions = m_aplConfiguration->getAplOptions();
    rapidjson::Document doc;
    if (doc.Parse(message.c_str()).HasParseError()) {
        aplOptions->logMessage(LogLevel::ERROR, ""handleMessageFailed"", ""Error whilst parsing message"");
        return;
    }

    if (!doc.HasMember(""type"")) {
        aplOptions->logMessage(LogLevel::ERROR, ""handleMessageFailed"", ""Unable to find type in message"");
        return;
    }
    std::string type = doc[""type""].GetString();

    auto payload = doc.FindMember(""payload"");
    if (payload == doc.MemberEnd()) {
        aplOptions->logMessage(LogLevel::ERROR, ""handleMessageFailed"", ""Unable to find payload in message"");
        return;
    }

    auto fit = m_messageHandlers.find(type);
    if (fit != m_messageHandlers.end()) {
        fit->second(payload->value);
    } else {
        aplOptions->logMessage(LogLevel::ERROR, ""handleMessageFailed"", ""Unrecognized message type: "" + type);
    }
}

void AplCoreConnectionManager::handleConfigurationChange(const rapidjson::Value& configurationChange) {
    auto aplOptions = m_aplConfiguration->getAplOptions();

    if (!m_Root || !m_AplCoreMetrics) {
        aplOptions->logMessage(LogLevel::ERROR, ""handleConfigurationChangeFailed"", ""Root context is missing"");
        return;
    }

    apl::ConfigurationChange configChange = apl::ConfigurationChange();
    // config change for width and height
    if (configurationChange.HasMember(WIDTH_KEY) && configurationChange[WIDTH_KEY].IsInt() && configurationChange.HasMember(HEIGHT_KEY) && configurationChange[HEIGHT_KEY].IsInt()) {

        m_Metrics.size((int) configurationChange[WIDTH_KEY].GetInt(), (int) configurationChange[HEIGHT_KEY].GetInt());
        m_AplCoreMetrics.reset();
        apl::ScalingOptions scalingOptions = {
                m_ViewportSizeSpecifications, SCALING_BIAS_CONSTANT, SCALING_SHAPE_OVERRIDES_COST};
        if (!scalingOptions.getSpecifications().empty()) {
            m_AplCoreMetrics = std::make_shared<AplCoreMetrics>(m_Metrics, scalingOptions);
        } else {
            m_AplCoreMetrics = std::make_shared<AplCoreMetrics>(m_Metrics);
        }

        const int pixelWidth = (int) m_AplCoreMetrics->toCorePixel(m_AplCoreMetrics->getViewhostWidth());
        const int pixelHeight = (int) m_AplCoreMetrics->toCorePixel(m_AplCoreMetrics->getViewhostHeight());
        configChange = configChange.size(pixelWidth, pixelHeight);
        sendViewhostScalingMessage();
    }
    // config change for theme
    if (configurationChange.HasMember(DOCTHEME_KEY) && configurationChange[DOCTHEME_KEY].IsString()) {
        configChange = configChange.theme(configurationChange[DOCTHEME_KEY].GetString());
        sendDocumentThemeMessage();
    }
    // config change for mode
    if (configurationChange.HasMember(MODE_KEY) &&
            configurationChange[MODE_KEY].IsString() &&
        AVS_VIEWPORT_MODE_MAP.find(configurationChange[MODE_KEY].GetString()) != AVS_VIEWPORT_MODE_MAP.end()) {
        configChange = configChange.mode(AVS_VIEWPORT_MODE_MAP.at(configurationChange[MODE_KEY].GetString()));
    }
    // config change for fontScale
    if (configurationChange.HasMember(FONTSCALE_KEY) && configurationChange[FONTSCALE_KEY].IsFloat()) {
        configChange = configChange.fontScale(configurationChange[FONTSCALE_KEY].GetFloat());
    }
    // config change for screenMode
    if (configurationChange.HasMember(SCREENMODE_KEY) &&
            configurationChange[SCREENMODE_KEY].IsString() &&
        AVS_SCREEN_MODE_MAP.find(configurationChange[SCREENMODE_KEY].GetString()) != AVS_SCREEN_MODE_MAP.end()) {
        configChange = configChange.screenMode(AVS_SCREEN_MODE_MAP.at(configurationChange[SCREENMODE_KEY].GetString()));
    }
    // config change for screenReader
    if (configurationChange.HasMember(SCREENREADER_KEY) && configurationChange[SCREENREADER_KEY].IsBool()) {
        configChange = configChange.screenReader(configurationChange[SCREENREADER_KEY].GetBool());
    }
    updateConfigurationChange(configChange);
    m_Root->configurationChange(configChange);
}

void AplCoreConnectionManager::handleUpdateDisplayState(const rapidjson::Value& displayState) {
    auto aplOptions = m_aplConfiguration->getAplOptions();
    if (!m_Root) {
        aplOptions->logMessage(LogLevel::ERROR, ""handleUpdateDisplayStateFailed"", ""Root context is missing"");
        return;
    }

    /// Display State Mapping
    std::map<int, apl::DisplayState> displayStateMapping = {
        {0, apl::DisplayState::kDisplayStateHidden},
        {1, apl::DisplayState::kDisplayStateBackground},
        {2, apl::DisplayState::kDisplayStateForeground}
    };

    int state = displayState.GetInt();

    if (displayStateMapping.find(state) == displayStateMapping.end()) {
        aplOptions->logMessage(LogLevel::ERROR, ""handleUpdateDisplayStateFailed"", ""Valid state not found"");
        return;
    } else {
        m_Root->updateDisplayState(displayStateMapping[state]);
    }
}

void AplCoreConnectionManager::executeCommands(const std::string& command, const std::string& token) {
    auto aplOptions = m_aplConfiguration->getAplOptions();
    if (!m_Root) {
        aplOptions->logMessage(LogLevel::ERROR, ""executeCommandsFailed"", ""Root context is missing"");
        return;
    }

    std::shared_ptr<rapidjson::Document> document(new rapidjson::Document);
    if (document->Parse(command).HasParseError()) {
        aplOptions->logMessage(LogLevel::ERROR, ""executeCommandsFailed"", ""Parse commands failed"");
        return;
    }

    auto it = document->FindMember(""commands"");
    if (it == document->MemberEnd() || it->value.GetType() != rapidjson::Type::kArrayType) {
        aplOptions->logMessage(LogLevel::ERROR, ""executeCommandsFailed"", ""Missing commands, or is not array"");
        return;
    }

    apl::Object object{it->value};
    auto action = m_Root->executeCommands(object, false);
    if (!action) {
        aplOptions->logMessage(LogLevel::ERROR, ""executeCommandsFailed"", ""Execute commands failed"");
        return;
    }

    aplOptions->onActivityStarted(token, APL_COMMAND_EXECUTION);

    action->then([this, document, token](const apl::ActionPtr& action) {
        auto aplOptions = m_aplConfiguration->getAplOptions();
        aplOptions->logMessage(LogLevel::DBG, ""executeCommands"", ""Command sequence complete"");
        aplOptions->onCommandExecutionComplete(token, true);
        aplOptions->onActivityEnded(token, APL_COMMAND_EXECUTION);
    });

    action->addTerminateCallback([this, document, token](const apl::TimersPtr&) {
        auto aplOptions = m_aplConfiguration->getAplOptions();
        aplOptions->logMessage(LogLevel::DBG, ""executeCommandsFailed"", ""Command sequence failed"");
        aplOptions->onCommandExecutionComplete(token, false);
        aplOptions->onActivityEnded(token, APL_COMMAND_EXECUTION);
    });
}

void AplCoreConnectionManager::onExtensionEvent(
        const std::string& uri,
        const std::string& name,
        const std::string& source,
        const std::string& params,
        unsigned int event,
        std::shared_ptr<AplCoreExtensionEventCallbackResultInterface> resultCallback) {
    rapidjson::Document sourceDoc;
    rapidjson::Document paramsDoc;

    auto aplOptions = m_aplConfiguration->getAplOptions();
    if (sourceDoc.Parse(source).HasParseError()) {
        aplOptions->logMessage(LogLevel::ERROR, ""onExtensionEventFailed"", ""Parse source failed"");
        return;
    }

    if (paramsDoc.Parse(params).HasParseError()) {
        aplOptions->logMessage(LogLevel::ERROR, ""onExtensionEventFailed"", ""Parse params failed"");
        return;
    }

    m_extensionManager->onExtensionEvent(
            uri, name, apl::Object(sourceDoc), apl::Object(paramsDoc), event, resultCallback);
}

void AplCoreConnectionManager::onExtensionEventResult(unsigned int event, bool succeeded) {
    rapidjson::Document response(rapidjson::kObjectType);
    rapidjson::Document::AllocatorType& allocator = response.GetAllocator();
    rapidjson::Value payload(rapidjson::kObjectType);
    payload.AddMember(EVENT_KEY, event, allocator);
    payload.AddMember(ARGUMENT_KEY, succeeded ? 0 : 1, allocator);
    handleEventResponse(payload);
}

AplDocumentStatePtr AplCoreConnectionManager::getActiveDocumentState() {
    // If we have active content, report it as an AplDocumentState
    if (m_Content && m_Root && m_AplCoreMetrics) {
        auto documentState = std::make_shared<AplDocumentState>(m_aplToken, m_Root, m_AplCoreMetrics);
        return documentState;
    }
    return nullptr;
}

void AplCoreConnectionManager::restoreDocumentState(AplDocumentStatePtr documentState) {
    m_documentStateToRestore = std::move(documentState);
    m_documentStateToRestore->configurationChange = m_ConfigurationChange;
    reset();
    m_aplConfiguration->getAplOptions()->resetViewhost(m_documentStateToRestore->token);
}

void AplCoreConnectionManager::invokeExtensionEventHandler(
        const std::string& uri,
        const std::string& name,
        const apl::ObjectMap& data,
        bool fastMode) {
    auto aplOptions = m_aplConfiguration->getAplOptions();
    if (!m_Root) {
        aplOptions->logMessage(LogLevel::ERROR, ""invokeExtensionEventHandlerFailed"", ""Root context is missing"");
        return;
    }
    aplOptions->logMessage(LogLevel::DBG, ""invokeExtensionEventHandler"", +""< "" + uri + "":"" + name + "" >"");
    auto actnPtr = m_Root->invokeExtensionEventHandler(uri, name, data, fastMode);
    if (actnPtr == nullptr) {
        aplOptions->logMessage(LogLevel::ERROR, ""invokeExtensionEventHandlerFailed"", ""No handler found"");
    }
}

void AplCoreConnectionManager::sendExtensionEvent(
        const std::string &uri,
        const std::string &name,
        const apl::Object &source,
        const apl::Object &params,
        unsigned int event,
        std::shared_ptr<AplCoreExtensionEventCallbackResultInterface> resultCallback) {
    auto message = AplCoreViewhostMessage(EXTENSION_MESSAGE_KEY);

    auto &mAlloc = message.alloc();
    rapidjson::Value payload(rapidjson::kObjectType);
    payload.AddMember(""URI"", uri, mAlloc);
    payload.AddMember(""type"", ""event"", mAlloc);
    payload.AddMember(""name"", name, mAlloc);

    rapidjson::Value jsonParams = params.serialize(mAlloc);
    payload.AddMember(""params"", jsonParams, mAlloc);

    message.setPayload(std::move(payload));
    send(message);
}

void AplCoreConnectionManager::dataSourceUpdate(
        const std::string& sourceType,
        const std::string& jsonPayload,
        const std::string& token) {

    auto aplOptions = m_aplConfiguration->getAplOptions();
    if (!m_Root) {
        aplOptions->logMessage(LogLevel::ERROR, ""dataSourceUpdateFailed"", ""Root context is missing"");
        return;
    }

    auto provider = m_Root->getRootConfig().getDataSourceProvider(sourceType);
    if (!provider) {
        aplOptions->logMessage(LogLevel::ERROR, ""dataSourceUpdateFailed"", ""Unknown provider requested."");
        return;
    }

    bool result = provider->processUpdate(jsonPayload);
    if (!result) {
        aplOptions->logMessage(LogLevel::ERROR, ""dataSourceUpdateFailed"", ""Update is not processed."");
        checkAndSendDataSourceErrors();
    }
}

void AplCoreConnectionManager::provideState(unsigned int stateRequestToken) {
    auto aplOptions = m_aplConfiguration->getAplOptions();
    auto timer = m_aplConfiguration->getMetricsRecorder()->createTimer(
            Telemetry::AplMetricsRecorderInterface::CURRENT_DOCUMENT,
            ""APL-Web.RootContext.notifyVisualContext"");
    timer->start();
    rapidjson::Document state(rapidjson::kObjectType);
    rapidjson::Document::AllocatorType& allocator = state.GetAllocator();
    rapidjson::StringBuffer buffer;
    rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);

    // Add presentation token info
    state.AddMember(TOKEN_KEY, m_aplToken, allocator);

    // Add version info
    state.AddMember(VERSION_KEY, CLIENT_VERSION_PREFIX + apl::APLVersion::getDefaultReportedVersionString(), allocator);

    // Add visual context info
    state.AddMember(VISUAL_CONTEXT_KEY, getVisualContext(allocator), allocator);

    // Add datasource context info
    state.AddMember(DATASOURCE_CONTEXT_KEY, getDatasourceContext(allocator), allocator);

    state.Accept(writer);
    aplOptions->onVisualContextAvailable(m_aplToken, stateRequestToken, buffer.GetString());
    timer->stop();
}

rapidjson::Value AplCoreConnectionManager::getVisualContext(rapidjson::Document::AllocatorType& allocator) {
    auto aplOptions = m_aplConfiguration->getAplOptions();
    auto timer = m_aplConfiguration->getMetricsRecorder()->createTimer(
            Telemetry::AplMetricsRecorderInterface::CURRENT_DOCUMENT,
            ""APL-Web.RootContext.serializeVisualContext"");
    timer->start();
    rapidjson::Value arr(rapidjson::kArrayType);
    if (m_Root) {
        auto context = m_Root->serializeVisualContext(allocator);
        arr.PushBack(context, allocator);
    } else {
        aplOptions->logMessage(LogLevel::ERROR, ""getVisualContextFailed"", ""Unable to get visual context"");
        rapidjson::Value emptyObj(rapidjson::kObjectType);
        // add an empty visual context
        arr.PushBack(emptyObj, allocator);
    }
    timer->stop();
    return arr;
}

rapidjson::Value AplCoreConnectionManager::getDatasourceContext(rapidjson::Document::AllocatorType& allocator) {
    auto aplOptions = m_aplConfiguration->getAplOptions();
    auto timer = m_aplConfiguration->getMetricsRecorder()->createTimer(
            Telemetry::AplMetricsRecorderInterface::CURRENT_DOCUMENT,
            ""APL-Web.RootContext.serializeDataSourceContext"");
    timer->start();
    rapidjson::Value context;

    if (m_Root) {
        context = m_Root->serializeDataSourceContext(allocator);
    } else {
        aplOptions->logMessage(LogLevel::ERROR, ""getDatasourceContextFailed"", ""Unable to get datasource context"");
        rapidjson::Value emptyDataSource(rapidjson::kArrayType);
        // return empty datasource context
        context = emptyDataSource;
    }
    timer->stop();
    return context;
}

void AplCoreConnectionManager::interruptCommandSequence() {
    if (m_Root) {
        m_Root->cancelExecution();
    }
}

void AplCoreConnectionManager::handleBuild(const rapidjson::Value& message) {
    auto aplOptions = m_aplConfiguration->getAplOptions();

    auto inflationTimer = m_aplConfiguration->getMetricsRecorder()->createTimer(
            Telemetry::AplMetricsRecorderInterface::LATEST_DOCUMENT,
            Telemetry::AplRenderingSegment::kRootContextInflation);
    inflationTimer->start();

    /* APL Document Inflation started */
    aplOptions->onRenderingEvent(m_aplToken, AplRenderingEvent::INFLATE_BEGIN);


    apl::RootConfig config;

    if (m_documentStateToRestore) {
        // Restore from document state
        m_aplToken = m_documentStateToRestore->token;
        m_Root = m_documentStateToRestore->rootContext;
        m_Content = m_Root->content();
        config = m_documentStateToRestore->rootContext->getRootConfig();
        m_Root->configurationChange(m_documentStateToRestore->configurationChange);
        coreFrameUpdate();
    }

    if (!m_Content) {
        aplOptions->logMessage(LogLevel::WARN, ""handleBuildFailed"", ""No content to build"");
        sendError(""No content to build"");
        inflationTimer->fail();
        return;
    }

    // Get APL Version for content
    std::string aplVersion = m_Content->getAPLVersion();

    // If we're not restoring a document state, create a new RootConfig.
    if (!m_documentStateToRestore) {
        std::string agentName = getOptionalValue(message, AGENTNAME_KEY, ""wssHost"");
        std::string agentVersion = getOptionalValue(message, AGENTVERSION_KEY, ""1.0"");
        bool allowOpenUrl = getOptionalBool(message, ALLOWOPENURL_KEY, false);
        bool disallowVideo = getOptionalBool(message, DISALLOWVIDEO_KEY, false);
        int animationQuality =
            getOptionalInt(message, ANIMATIONQUALITY_KEY, apl::RootConfig::AnimationQuality::kAnimationQualityNormal);

        config = apl::RootConfig()
                     .agent(agentName, agentVersion)
                     .allowOpenUrl(allowOpenUrl)
                     .disallowVideo(disallowVideo)
                     .animationQuality(static_cast<apl::RootConfig::AnimationQuality>(animationQuality))
                     .measure(std::make_shared<AplCoreTextMeasurement>(shared_from_this(), m_aplConfiguration))
                     .localeMethods(std::make_shared<AplCoreLocaleMethods>(shared_from_this(), m_aplConfiguration))
                     .utcTime(getCurrentTime().count())
                     .localTimeAdjustment(aplOptions->getTimezoneOffset().count())
                     .enforceAPLVersion(apl::APLVersion::kAPLVersionIgnore)
                     .sequenceChildCache(5)
                     .enableExperimentalFeature(apl::RootConfig::ExperimentalFeature::kExperimentalFeatureManageMediaRequests)
                     .set(apl::RootProperty::kDefaultIdleTimeout, -1);

        // Data Sources
        config.dataSourceProvider(
            apl::DynamicIndexListConstants::DEFAULT_TYPE_NAME,
            std::make_shared<apl::DynamicIndexListDataSourceProvider>());

        config.dataSourceProvider(
                apl::DynamicTokenListConstants::DEFAULT_TYPE_NAME,
                std::make_shared<apl::DynamicTokenListDataSourceProvider>());
    }

    // Add Extensions which are supported, requested, and available to the config
    if (message.HasMember(SUPPORTED_EXTENSIONS) && message[SUPPORTED_EXTENSIONS].IsArray()) {
        // Extensions supported by the client renderer instance
        auto supportedExtensions = message[SUPPORTED_EXTENSIONS].GetArray();
        // Extensions requested by the content
        auto requestedExtensions = m_Content->getExtensionRequests();
        for (auto& ext : supportedExtensions) {
            auto uri = ext.GetString();
            // If the supported extension is both requested and available, register it with the config
            if (requestedExtensions.find(uri) != requestedExtensions.end()) {
                if (auto extension = m_extensionManager->getExtension(uri)) {
                    // Apply content defined settings to extension
                    extension->applySettings(m_Content->getExtensionSettings(uri));
                    m_extensionManager->registerRequestedExtension(extension->getUri(), config);
                }
            }
        }
    }

    auto renderingOptionsMsg = AplCoreViewhostMessage(RENDERING_OPTIONS_KEY);
    rapidjson::Value renderingOptions(rapidjson::kObjectType);
    renderingOptions.AddMember(LEGACY_KARAOKE_KEY, aplVersion == ""1.0"", renderingOptionsMsg.alloc());
    send(renderingOptionsMsg.setPayload(std::move(renderingOptions)));

    m_PendingEvents.clear();

    // Release the activity tracker
    aplOptions->onActivityEnded(m_aplToken, APL_COMMAND_EXECUTION);

    if (m_ScreenLock) {
        aplOptions->onActivityEnded(m_aplToken, APL_SCREEN_LOCK);
        m_ScreenLock = false;
    }

    m_StartTime = getCurrentTime();

    // If we're not restoring a document state, then create metrics and RootContext
    if (!m_documentStateToRestore) {
        // Handle metrics data
        m_Metrics.size(message[WIDTH_KEY].GetInt(), message[HEIGHT_KEY].GetInt())
            .dpi(message[DPI_KEY].GetInt())
            .shape(AVS_VIEWPORT_SHAPE_MAP.at(message[SHAPE_KEY].GetString()))
            .mode(AVS_VIEWPORT_MODE_MAP.at(message[MODE_KEY].GetString()));

        do {
            apl::ScalingOptions scalingOptions = {
                m_ViewportSizeSpecifications, SCALING_BIAS_CONSTANT, SCALING_SHAPE_OVERRIDES_COST};
            if (!scalingOptions.getSpecifications().empty()) {
                m_AplCoreMetrics = std::make_shared<AplCoreMetrics>(m_Metrics, scalingOptions);
            } else {
                m_AplCoreMetrics = std::make_shared<AplCoreMetrics>(m_Metrics);
            }

            sendViewhostScalingMessage();

            m_StartTime = getCurrentTime();
            m_Root = apl::RootContext::create(m_AplCoreMetrics->getMetrics(), m_Content, config);
            if (m_Root) {
                break;
            } else if (!m_ViewportSizeSpecifications.empty()) {
                aplOptions->logMessage(
                    LogLevel::WARN, __func__, ""Unable to inflate document with current chosen scaling."");
            }

            auto it = m_ViewportSizeSpecifications.begin();
            for (; it != m_ViewportSizeSpecifications.end(); it++) {
                if (*it == m_AplCoreMetrics->getChosenSpec()) {
                    m_ViewportSizeSpecifications.erase(it);
                    break;
                }
            }
            if (it == m_ViewportSizeSpecifications.end()) {
                // Core returned specification that is not in list. Something went wrong. Prevent infinite loop.
                break;
            }
        } while (!m_ViewportSizeSpecifications.empty());
    }

    // Make sure we only restore a documentState once.
    if (m_documentStateToRestore) {
        m_documentStateToRestore.reset();
    }

    // Get background
    apl::Object background = m_Content->getBackground(m_AplCoreMetrics->getMetrics(), config);

    bool supportsResizing = false;

    // Get Document Settings
    if (auto documentSettings = m_Content->getDocumentSettings()) {
        // Get resizing setting
        supportsResizing = documentSettings->getValue(SUPPORTS_RESIZING_KEY).asBoolean();
    }

    sendSupportsResizingMessage(supportsResizing);

    /* APL Core Inflation ended */
    aplOptions->onRenderingEvent(m_aplToken, AplRenderingEvent::INFLATE_END);

    if (m_Root) {
        inflationTimer->stop();
        // Init viewhost globals
        sendViewhostScalingMessage();
        sendDocumentThemeMessage();
        sendDocumentBackgroundMessage(background);

        // Start rendering component hierarchy
        // and displaying Children
        sendHierarchy(HIERARCHY_KEY);

        auto idleTimeout = std::chrono::milliseconds(m_Root->settings().idleTimeout(config));
        aplOptions->onSetDocumentIdleTimeout(m_aplToken, idleTimeout);
        aplOptions->onRenderDocumentComplete(m_aplToken, true, """");
    } else {
        inflationTimer->fail();
        aplOptions->logMessage(LogLevel::ERROR, ""handleBuildFailed"", ""Unable to inflate document"");
        sendError(""Unable to inflate document"");
        aplOptions->onRenderDocumentComplete(m_aplToken, false, ""Unable to inflate document"");
        // Send DataSource errors if any
        checkAndSendDataSourceErrors();
    }
}

void AplCoreConnectionManager::onDocumentRendered(
        const std::chrono::steady_clock::time_point &renderTime,
        uint64_t complexityScore) {
    auto metricsRecorder = m_aplConfiguration->getMetricsRecorder();
    metricsRecorder->flush();
}

void AplCoreConnectionManager::sendViewhostScalingMessage() {
    if (m_AplCoreMetrics) {
        // Send scaling metrics out to viewhost
        auto reply = AplCoreViewhostMessage(SCALING_KEY);
        rapidjson::Value scaling(rapidjson::kObjectType);
        scaling.AddMember(SCALE_FACTOR_KEY, m_AplCoreMetrics->toViewhost(1.0f), reply.alloc());
        scaling.AddMember(VIEWPORT_WIDTH_KEY, m_AplCoreMetrics->getViewhostWidth(), reply.alloc());
        scaling.AddMember(VIEWPORT_HEIGHT_KEY, m_AplCoreMetrics->getViewhostHeight(), reply.alloc());
        send(reply.setPayload(std::move(scaling)));
    }
}

void AplCoreConnectionManager::sendDocumentThemeMessage() {
    if (m_Root) {
        auto themeMsg = AplCoreViewhostMessage(DOCTHEME_KEY);
        auto& alloc = themeMsg.alloc();
        rapidjson::Value payload(rapidjson::kObjectType);
        std::string docTheme = ""dark"";
        docTheme = m_Root->getTheme();
        payload.AddMember(DOCTHEME_KEY, rapidjson::Value(docTheme.c_str(), alloc).Move(), alloc);
        themeMsg.setPayload(std::move(payload));
        send(themeMsg);
    }
}

void AplCoreConnectionManager::sendDocumentBackgroundMessage(const apl::Object& background) {
    auto backgroundMsg = AplCoreViewhostMessage(BACKGROUND_KEY);
    auto& alloc = backgroundMsg.alloc();
    rapidjson::Value payload(rapidjson::kObjectType);
    rapidjson::Value backgroundValue(rapidjson::kObjectType);
    if (background.isColor()) {
        backgroundValue.AddMember(COLOR_KEY, background.asString(), alloc);
    } else if (background.isGradient()) {
        backgroundValue.AddMember(GRADIENT_KEY, background.getGradient().serialize(alloc), alloc);
    } else {
        backgroundValue.AddMember(COLOR_KEY, apl::Color().asString(), alloc);
    }
    payload.AddMember(BACKGROUND_KEY, backgroundValue, alloc);
    backgroundMsg.setPayload(std::move(payload));
    send(backgroundMsg);
}

void AplCoreConnectionManager::sendScreenLockMessage(bool screenLock) {
    auto screenLockMsg = AplCoreViewhostMessage(SCREENLOCK_KEY);
    auto& alloc = screenLockMsg.alloc();
    rapidjson::Value payload(rapidjson::kObjectType);
    payload.AddMember(SCREENLOCK_KEY, screenLock, alloc);
    screenLockMsg.setPayload(std::move(payload));
    send(screenLockMsg);
}

void AplCoreConnectionManager::sendSupportsResizingMessage(bool supportsResizing) {
    auto supportsResizingMsg = AplCoreViewhostMessage(SUPPORTS_RESIZING_KEY);
    auto& alloc = supportsResizingMsg.alloc();
    rapidjson::Value payload(rapidjson::kObjectType);
    payload.AddMember(SUPPORTS_RESIZING_KEY, supportsResizing, alloc);
    supportsResizingMsg.setPayload(std::move(payload));
    send(supportsResizingMsg);
}

void AplCoreConnectionManager::handleUpdate(const rapidjson::Value& update) {
    auto aplOptions = m_aplConfiguration->getAplOptions();

    if (!m_Root) {
        aplOptions->logMessage(LogLevel::ERROR, ""handleUpdateFailed"", ""Root context is null"");
        return;
    }

    auto id = update[""id""].GetString();
    auto component = m_Root->findComponentById(id);
    if (!component) {
        aplOptions->logMessage(
            LogLevel::ERROR, ""handleUpdateFailed"", std::string(""Unable to find component with id: "") + id);
        sendError(""Unable to find component"");
        return;
    }

    auto type = static_cast<apl::UpdateType>(update[""type""].GetInt());

    if (update[""value""].IsString()) {
        std::string value = update[""value""].GetString();
        component->update(type, value);
    } else {
        auto value = update[""value""].GetFloat();

        if (type == apl::UpdateType::kUpdateScrollPosition) {
            value = m_AplCoreMetrics->toCore(value);
        }

        component->update(type, value);
    }
}

void AplCoreConnectionManager::handleMediaUpdate(const rapidjson::Value& update) {
    auto aplOptions = m_aplConfiguration->getAplOptions();

    if (!m_Root) {
        aplOptions->logMessage(LogLevel::ERROR, ""handleMediaUpdateFailed"", ""Root context is null"");
        return;
    }

    auto id = update[""id""].GetString();
    auto component = m_Root->findComponentById(id);
    if (!component) {
        aplOptions->logMessage(
            LogLevel::ERROR, ""handleMediaUpdateFailed"", std::string(""Unable to find component with id: "") + id);
        sendError(""Unable to find component"");
        return;
    }

    if (!update.HasMember(MEDIA_STATE_KEY) || !update.HasMember(FROM_EVENT_KEY)) {
        aplOptions->logMessage(
            LogLevel::ERROR, ""handleMediaUpdateFailed"", ""State update object is missing parameters"");
        sendError(""Can't update media state."");
        return;
    }
    auto& state = update[MEDIA_STATE_KEY];
    auto fromEvent = update[FROM_EVENT_KEY].GetBool();

    if (!state.HasMember(TRACK_INDEX_KEY) || !state.HasMember(TRACK_COUNT_KEY) || !state.HasMember(CURRENT_TIME_KEY) ||
        !state.HasMember(DURATION_KEY) || !state.HasMember(PAUSED_KEY) || !state.HasMember(ENDED_KEY) ||
        !state.HasMember(TRACK_STATE_KEY)) {
        aplOptions->logMessage(
            LogLevel::ERROR, ""handleMediaUpdateFailed"", ""Can't update media state. MediaStatus structure is wrong"");
        sendError(""Can't update media state."");
        return;
    }

    // numeric parameters are sometimes converted to null during stringification, set these to 0
    const int trackIndex = getOptionalInt(state, TRACK_INDEX_KEY, 0);
    const int trackCount = getOptionalInt(state, TRACK_COUNT_KEY, 0);
    const int currentTime = getOptionalInt(state, CURRENT_TIME_KEY, 0);
    const int duration = getOptionalInt(state, DURATION_KEY, 0);
    const auto trackState = static_cast<apl::TrackState>(state[TRACK_STATE_KEY].GetInt());

    apl::MediaState mediaState(
        trackIndex, trackCount, currentTime, duration, state[PAUSED_KEY].GetBool(), state[ENDED_KEY].GetBool());

    mediaState.withTrackState(trackState);
    component->updateMediaState(mediaState, fromEvent);
}

void AplCoreConnectionManager::handleGraphicUpdate(const rapidjson::Value& update) {
    auto aplOptions = m_aplConfiguration->getAplOptions();
    if (!m_Root) {
        aplOptions->logMessage(LogLevel::ERROR, ""handleGraphicUpdateFailed"", ""Root context is null"");
        return;
    }

    auto id = update[""id""].GetString();
    auto component = m_Root->findComponentById(id);
    if (!component) {
        aplOptions->logMessage(
            LogLevel::ERROR, ""handleGraphicUpdateFailed"", std::string(""Unable to find component with id:"") + id);
        sendError(""Unable to find component"");
        return;
    }

    auto json = apl::GraphicContent::create(update[""avg""].GetString());
    component->updateGraphic(json);
}

void AplCoreConnectionManager::handleEnsureLayout(const rapidjson::Value& payload) {
    auto aplOptions = m_aplConfiguration->getAplOptions();
    if (!m_Root) {
        aplOptions->logMessage(LogLevel::ERROR, ""handleEnsureLayoutFailed"", ""Root context is null"");
        return;
    }

    auto id = payload[""id""].GetString();
    auto component = m_Root->findComponentById(id);
    if (!component) {
        aplOptions->logMessage(
            LogLevel::ERROR, ""handleEnsureLayoutFailed"", std::string(""Unable to find component with id:"") + id);
        sendError(""Unable to find component"");
        return;
    }

    component->ensureLayout(true);
    auto msg = AplCoreViewhostMessage(ENSURELAYOUT_KEY);
    send(msg.setPayload(id));
}

void AplCoreConnectionManager::handleScrollToRectInComponent(const rapidjson::Value& payload) {
    auto aplOptions = m_aplConfiguration->getAplOptions();
    if (!m_Root) {
        aplOptions->logMessage(LogLevel::ERROR, ""handleScrollToRectInComponentFailed"", ""Root context is null"");
        return;
    }

    auto id = payload[""id""].GetString();
    auto component = m_Root->findComponentById(id);
    if (!component) {
        aplOptions->logMessage(
            LogLevel::ERROR,
            ""handleScrollToRectInComponentFailed"",
            std::string(""Unable to find component with id:"") + id);
        sendError(""Unable to find component"");
        return;
    }

    apl::Rect rect = convertJsonToScaledRect(payload);
    m_Root->scrollToRectInComponent(component, rect, static_cast<apl::CommandScrollAlign>(payload[""align""].GetInt()));
}

void AplCoreConnectionManager::handleHandleKeyboard(const rapidjson::Value& payload) {
    auto aplOptions = m_aplConfiguration->getAplOptions();
    if (!m_Root) {
        aplOptions->logMessage(LogLevel::ERROR, ""handleHandleKeyboardFailed"", ""Root context is null"");
        return;
    }

    auto messageId = payload[""messageId""].GetString();
    auto keyType = payload[""keyType""].GetInt();
    auto code = payload[""code""].GetString();
    auto key = payload[""key""].GetString();
    auto repeat = payload[""repeat""].GetBool();
    auto altKey = payload[""altKey""].GetBool();
    auto ctrlKey = payload[""ctrlKey""].GetBool();
    auto metaKey = payload[""metaKey""].GetBool();
    auto shiftKey = payload[""shiftKey""].GetBool();
    apl::Keyboard keyboard(code, key);
    keyboard.repeat(repeat);
    keyboard.alt(altKey);
    keyboard.ctrl(ctrlKey);
    keyboard.meta(metaKey);
    keyboard.shift(shiftKey);
    bool result = m_Root->handleKeyboard(static_cast<apl::KeyHandlerType>(keyType), keyboard);

    auto handleKeyboardResultMessage = AplCoreViewhostMessage(""handleKeyboard"");
    auto& alloc = handleKeyboardResultMessage.alloc();
    rapidjson::Value handleKeyboardResultValue(rapidjson::kObjectType);

    rapidjson::Value value;
    value.SetString(messageId, alloc);
    handleKeyboardResultValue.AddMember(""messageId"", value, alloc);
    handleKeyboardResultValue.AddMember(""result"", result, alloc);

    handleKeyboardResultMessage.setPayload(std::move(handleKeyboardResultValue));
    send(handleKeyboardResultMessage);
}

void AplCoreConnectionManager::getFocusableAreas(const rapidjson::Value& payload) {
    auto aplOptions = m_aplConfiguration->getAplOptions();
    if (!m_Root) {
        aplOptions->logMessage(LogLevel::ERROR, ""getFocusableAreasFailed"", ""Root context is null"");
        return;
    }

    auto messageId = payload[""messageId""].GetString();
    auto message = AplCoreViewhostMessage(""getFocusableAreas"");
    auto result = m_Root->getFocusableAreas();
    auto& alloc = message.alloc();

    rapidjson::Value outPayload(rapidjson::kObjectType);
    rapidjson::Value value;
    value.SetString(messageId, alloc);
    outPayload.AddMember(""messageId"", value, alloc);

    rapidjson::Value areas(rapidjson::kObjectType);

    for (auto iterator = result.begin(); iterator != result.end(); iterator++) {
        auto top = iterator->second.getTop();
        auto left = iterator->second.getLeft();
        auto width = iterator->second.getWidth();
        auto height = iterator->second.getHeight();

        rapidjson::Value rectangle(rapidjson::kObjectType);
        rectangle.AddMember(""top"", top, alloc);
        rectangle.AddMember(""left"", left, alloc);
        rectangle.AddMember(""width"", width, alloc);
        rectangle.AddMember(""height"", height, alloc);
        rapidjson::Value key(rapidjson::kStringType);
        key.SetString(iterator->first.c_str(), alloc);
        areas.AddMember(key, rectangle, alloc);
    }

    outPayload.AddMember(""areas"", areas, alloc);
    message.setPayload(std::move(outPayload));
    send(message);
}

void AplCoreConnectionManager::getFocused(const rapidjson::Value& payload) {
    auto messageId = payload[""messageId""].GetString();
    auto message = AplCoreViewhostMessage(""getFocused"");

    auto aplOptions = m_aplConfiguration->getAplOptions();
    if (!m_Root) {
        aplOptions->logMessage(LogLevel::ERROR, ""getFocusedFailed"", ""Root context is null"");
        return;
    }

    auto result = m_Root->getFocused();
    auto& alloc = message.alloc();
    rapidjson::Value outPayload(rapidjson::kObjectType);
    rapidjson::Value value;
    value.SetString(messageId, alloc);
    outPayload.AddMember(""messageId"", value, alloc);
    outPayload.AddMember(""result"", result, alloc);
    message.setPayload(std::move(outPayload));
    send(message);
}

void AplCoreConnectionManager::setFocus(const rapidjson::Value& payload) {
    auto direction = payload[""direction""].GetInt();
    auto top = payload[""origin""].FindMember(""top"")->value.Get<float>();
    auto left = payload[""origin""].FindMember(""left"")->value.Get<float>();
    auto width = payload[""origin""].FindMember(""width"")->value.Get<float>();
    auto height = payload[""origin""].FindMember(""height"")->value.Get<float>();

    auto origin = apl::Rect(top, left, width, height);
    auto targetId = payload[""targetId""].GetString();
    m_Root->setFocus(static_cast<apl::FocusDirection>(direction), origin, targetId);
}

void AplCoreConnectionManager::mediaLoaded(const rapidjson::Value& payload) {
    auto aplOptions = m_aplConfiguration->getAplOptions();

    if (!m_Root) {
        aplOptions->logMessage(LogLevel::ERROR, ""AplCoreConnectionManager:mediaLoaded"", ""Root context is null"");
        return;
    }
    auto source = payload[""source""].GetString();
    m_Root->mediaLoaded(source);
}

void AplCoreConnectionManager::mediaLoadFailed(const rapidjson::Value& payload) {
    auto aplOptions = m_aplConfiguration->getAplOptions();

    if (!m_Root) {
        aplOptions->logMessage(LogLevel::ERROR, ""AplCoreConnectionManager::mediaLoadFailed"", ""Root context is null"");
        return;
    }
    auto source = payload[""source""].GetString();
    auto errorCode = payload[""errorCode""].GetInt();
    auto error = payload[""error""].GetString();
    m_Root->mediaLoadFailed(source, errorCode, error);
}

void AplCoreConnectionManager::handleUpdateCursorPosition(const rapidjson::Value& payload) {
    auto aplOptions = m_aplConfiguration->getAplOptions();

    if (!m_Root) {
        aplOptions->logMessage(LogLevel::ERROR, ""handleUpdateCursorPositionFailed"", ""Root context is null"");
        return;
    }

    const float x = payload[X_KEY].GetFloat();
    const float y = payload[Y_KEY].GetFloat();
    apl::Point cursorPosition(m_AplCoreMetrics->toCore(x), m_AplCoreMetrics->toCore(y));
    m_Root->updateCursorPosition(cursorPosition);
}

void AplCoreConnectionManager::handleHandlePointerEvent(const rapidjson::Value& payload) {
    auto aplOptions = m_aplConfiguration->getAplOptions();

    if (!m_Root) {
        aplOptions->logMessage(LogLevel::ERROR, ""handleHandlePointerEventFailed"", ""Root context is null"");
        return;
    }

    const float x = payload[X_KEY].GetFloat();
    const float y = payload[Y_KEY].GetFloat();

    apl::Point point = apl::Point(m_AplCoreMetrics->toCore(x), m_AplCoreMetrics->toCore(y));
    apl::PointerEventType pointerEventType = static_cast<apl::PointerEventType>(payload[POINTEREVENTTYPE_KEY].GetInt());
    apl::PointerType pointerType = static_cast<apl::PointerType>(payload[POINTERTYPE_KEY].GetInt());
    auto pointerId = static_cast<apl::id_type>(payload[POINTERID_KEY].GetInt());
    apl::PointerEvent pointerEvent = apl::PointerEvent(pointerEventType, point, pointerId, pointerType);

    m_Root->handlePointerEvent(pointerEvent);
}

void AplCoreConnectionManager::handleEventResponse(const rapidjson::Value& response) {
    auto aplOptions = m_aplConfiguration->getAplOptions();

    if (!m_Root) {
        aplOptions->logMessage(LogLevel::ERROR, ""handleEventResponseFailed"", ""Root context is null"");
        return;
    }

    if (!response[EVENT_KEY].IsInt()) {
        aplOptions->logMessage(LogLevel::ERROR, ""handleEventResponseFailed"", ""Invalid event response"");
        sendError(""Invalid event response"");
        return;
    }
    auto event = response[EVENT_KEY].GetInt();
    auto it = m_PendingEvents.find(event);
    if (it != m_PendingEvents.end()) {
        auto rectJson = response.FindMember(""rectArgument"");
        if (rectJson != response.MemberEnd()) {
            apl::Rect rect = convertJsonToScaledRect(rectJson->value);
            it->second.resolve(rect);
        } else {
            auto arg = response.FindMember(ARGUMENT_KEY);
            if (arg != response.MemberEnd()) {
                it->second.resolve(arg->value.GetInt());
            } else {
                it->second.resolve();
            }
        }
        m_PendingEvents.erase(it);
    }
}

unsigned int AplCoreConnectionManager::send(AplCoreViewhostMessage& message) {
    unsigned int seqno = ++m_SequenceNumber;
    m_aplConfiguration->getAplOptions()->sendMessage(m_aplToken, message.setSequenceNumber(seqno).get());
    return seqno;
}

rapidjson::Document AplCoreConnectionManager::blockingSend(
        AplCoreViewhostMessage& message,
        const std::chrono::milliseconds& timeout) {
    std::lock_guard<std::mutex> lock{m_blockingSendMutex};
    m_replyPromise = std::promise<std::string>();
    m_blockingSendReplyExpected = true;
    m_replyExpectedSequenceNumber = send(message);

    auto aplOptions = m_aplConfiguration->getAplOptions();
    auto future = m_replyPromise.get_future();
    auto status = future.wait_for(timeout);
    if (status != std::future_status::ready) {
        m_blockingSendReplyExpected = false;
        // Under the situation that finish command destroys the renderer, there is no response.
        aplOptions->logMessage(LogLevel::WARN, ""blockingSendFailed"", ""Did not receive response"");
        return rapidjson::Document(rapidjson::kNullType);
    }

    rapidjson::Document doc;
    if (doc.Parse(future.get()).HasParseError()) {
        aplOptions->logMessage(LogLevel::ERROR, ""blockingSendFailed"", ""parsingFailed"");
        return rapidjson::Document(rapidjson::kNullType);
    }

    return doc;
}

void AplCoreConnectionManager::sendError(const std::string& message) {
    auto reply = AplCoreViewhostMessage(ERROR_KEY);
    send(reply.setPayload(message));
}

void AplCoreConnectionManager::handleScreenLock() {
    auto aplOptions = m_aplConfiguration->getAplOptions();

    if (m_Root->screenLock() && !m_ScreenLock) {
        aplOptions->onActivityStarted(m_aplToken, APL_SCREEN_LOCK);
        m_ScreenLock = true;
    } else if (!m_Root->screenLock() && m_ScreenLock) {
        aplOptions->onActivityEnded(m_aplToken, APL_SCREEN_LOCK);
        m_ScreenLock = false;
    } else {
        return;
    }
    sendScreenLockMessage(m_ScreenLock);
}

void AplCoreConnectionManager::processEvent(const apl::Event& event) {
    auto aplOptions = m_aplConfiguration->getAplOptions();

    if (apl::EventType::kEventTypeFinish == event.getType()) {
        aplOptions->onFinish(m_aplToken);
        return;
    }

    if (apl::EventType::kEventTypeSendEvent == event.getType()) {
        rapidjson::Document userEventPayloadJson(rapidjson::kObjectType);
        auto& allocator = userEventPayloadJson.GetAllocator();
        auto source = event.getValue(apl::EventProperty::kEventPropertySource);
        auto components = event.getValue(apl::EventProperty::kEventPropertyComponents);
        auto arguments = event.getValue(apl::EventProperty::kEventPropertyArguments);

        userEventPayloadJson.AddMember(
            PRESENTATION_TOKEN_KEY, rapidjson::Value(m_aplToken.c_str(), allocator).Move(), allocator);
        userEventPayloadJson.AddMember(SOURCE_KEY, source.serialize(allocator).Move(), allocator);
        userEventPayloadJson.AddMember(ARGUMENTS_KEY, arguments.serialize(allocator).Move(), allocator);
        userEventPayloadJson.AddMember(COMPONENTS_KEY, components.serialize(allocator).Move(), allocator);

        rapidjson::StringBuffer sb;
        rapidjson::Writer<rapidjson::StringBuffer> writer(sb);
        userEventPayloadJson.Accept(writer);

        aplOptions->onSendEvent(m_aplToken, sb.GetString());
        return;
    }

    if (apl::EventType::kEventTypeDataSourceFetchRequest == event.getType()) {
        rapidjson::Document fetchRequestPayloadJson(rapidjson::kObjectType);
        auto& allocator = fetchRequestPayloadJson.GetAllocator();
        auto type = event.getValue(apl::EventProperty::kEventPropertyName);
        auto payload = event.getValue(apl::EventProperty::kEventPropertyValue);

        apl::ObjectMap fetchRequest(payload.getMap());
        fetchRequest.emplace(PRESENTATION_TOKEN_KEY, m_aplToken);

        auto fetch = apl::Object(std::make_shared<apl::ObjectMap>(fetchRequest)).serialize(allocator);
        rapidjson::StringBuffer sb;
        rapidjson::Writer<rapidjson::StringBuffer> writer(sb);
        fetch.Accept(writer);

        aplOptions->onDataSourceFetchRequestEvent(m_aplToken, type.asString(), sb.GetString());
        return;
    }

    if (apl::EventType::kEventTypeExtension == event.getType()) {
        /**
         * Extension Events are received when registered ExtensionCommands are fired
         * https://github.com/alexa/apl-core-library/blob/master/aplcore/include/apl/content/extensioncommanddefinition.h
         */
        rapidjson::Document extensionEventPayloadJson(rapidjson::kObjectType);
        auto& allocator = extensionEventPayloadJson.GetAllocator();

        auto uri = event.getValue(apl::EventProperty::kEventPropertyExtensionURI);
        auto name = event.getValue(apl::EventProperty::kEventPropertyName);
        auto source = event.getValue(apl::EventProperty::kEventPropertySource);
        auto params = event.getValue(apl::EventProperty::kEventPropertyExtension);

        std::string sourceStr;
        std::string paramsStr;

        serializeJSONValueToString(source.serialize(allocator).Move(), &sourceStr);
        serializeJSONValueToString(params.serialize(allocator).Move(), &paramsStr);

        /**
         * If the registered ExtensionCommand requires resolution, the resultCallback should be registered with the
         * extension
         * https://github.com/alexa/apl-core-library/blob/master/aplcore/include/apl/content/extensioncommanddefinition.h#L87
         */
        auto token = ++m_SequenceNumber;
        auto resultCallback = addPendingEvent(token, event, false) ? shared_from_this() : nullptr;
        aplOptions->onExtensionEvent(m_aplToken, uri.getString(), name.getString(), sourceStr, paramsStr, token, resultCallback);
        return;
    }

    auto msg = AplCoreViewhostMessage(EVENT_KEY);
    auto token = send(msg.setPayload(event.serialize(msg.alloc())));
    addPendingEvent(token, event);
}

bool AplCoreConnectionManager::addPendingEvent(unsigned int token, const apl::Event& event, bool isViewhostEvent) {
    // If the event had an action ref, stash the reference for future use
    auto ref = event.getActionRef();
    if (!ref.isEmpty()) {
        m_PendingEvents.emplace(token, ref);
        ref.addTerminateCallback([this, token, isViewhostEvent](const apl::TimersPtr&) {
            auto it = m_PendingEvents.find(token);
            if (it != m_PendingEvents.end()) {
                if (isViewhostEvent) {
                    auto msg = AplCoreViewhostMessage(EVENT_TERMINATE_KEY);
                    rapidjson::Value payload(rapidjson::kObjectType);
                    payload.AddMember(""token"", token, msg.alloc());
                    send(msg.setPayload(std::move(payload)));
                }

                m_PendingEvents.erase(it);  // Remove the pending event
            } else {
                m_aplConfiguration->getAplOptions()->logMessage(LogLevel::WARN, __func__, ""Event was not pending"");
            }
        });
        return true;
    }
    return false;
}

void AplCoreConnectionManager::sendHierarchy(const std::string& messageKey, bool blocking) {
    if (m_Root) {
        auto reply = AplCoreViewhostMessage(messageKey);
        rapidjson::Value hierarchy(rapidjson::kObjectType);
        hierarchy.AddMember(""hierarchy"", m_Root->topComponent()->serialize(reply.alloc()), reply.alloc());

        rapidjson::Value displayedChildrenHierarchy = buildDisplayedChildrenHierarchy(m_Root->topComponent(), reply);
        hierarchy.AddMember(""displayedChildrenHierarchy"", displayedChildrenHierarchy, reply.alloc());

        if (blocking) {
            blockingSend(reply.setPayload(std::move(hierarchy)));
        } else {
            send(reply.setPayload(std::move(hierarchy)));
        }
    }
}

rapidjson::Value
AplCoreConnectionManager::buildDisplayedChildrenHierarchy(const apl::ComponentPtr& component, AplCoreViewhostMessage& message) {
    rapidjson::Value displayedChildrenHierarchy(rapidjson::kObjectType);
    std::vector<apl::ComponentPtr> stack;
    stack.push_back(component);

    while(!stack.empty()) {
        rapidjson::Value displayedChildrenUniqueIds(rapidjson::kArrayType);
        apl::ComponentPtr node = stack.back();
        stack.pop_back();
        auto count = node->getDisplayedChildCount();
        for (size_t i = 0; i < count; i++) {
            auto childComponent = node->getDisplayedChildAt(i);
            auto str = childComponent->getUniqueId();
            displayedChildrenUniqueIds.PushBack(rapidjson::Value{}.SetString(str.c_str(), str.length(), message.alloc()), message.alloc());
            stack.push_back(childComponent);
        }
        displayedChildrenHierarchy.AddMember(
                rapidjson::Value{}.SetString(node->getUniqueId().c_str(), node->getUniqueId().length(),message.alloc()),
                displayedChildrenUniqueIds,
                message.alloc());
    }
    return displayedChildrenHierarchy;
}

void AplCoreConnectionManager::processDirty(const std::set<apl::ComponentPtr>& dirty) {
    std::map<std::string, rapidjson::Value> tempDirty;
    auto msg = AplCoreViewhostMessage(DIRTY_KEY);

    for (auto& component : dirty) {
        if (component->getDirty().count(apl::kPropertyNotifyChildrenChanged)) {
            auto notify = component->getCalculated(apl::kPropertyNotifyChildrenChanged);
            const auto& changed = notify.getArray();
            // Whenever we get NotifyChildrenChanged we get 2 types of action
            // Either insert or delete. The delete will happen on the viewhost level
            // However, insert needs the full serialized component from core & will be initalized
            // on apl-client side
            for (size_t i = 0; i < changed.size(); i++) {
                auto newChildId = changed.at(i).get(""uid"").asString();
                auto newChildIndex = changed.at(i).get(""index"").asInt();
                auto action = changed.at(i).get(""action"").asString();
                if (action == ""insert"") {
                    auto newComponent = component->getChildAt(newChildIndex);
                    rapidjson::Value newComponentHierarchy = newComponent->serialize(msg.alloc());
                    rapidjson::Value displayedChildrenHierarchy = buildDisplayedChildrenHierarchy(newComponent, msg);
                    newComponentHierarchy.AddMember(""displayedChildrenHierarchy"", displayedChildrenHierarchy, msg.alloc());
                    tempDirty[newChildId] = newComponentHierarchy;
                }
            }
            if (tempDirty.find(component->getUniqueId()) == tempDirty.end()) {
                // notify children change needs to update displayed children ids
                rapidjson::Value dirtyWithChildChange = component->serializeDirty(msg.alloc());
                rapidjson::Value displayedChildrenHierarchy = buildDisplayedChildrenHierarchy(component, msg);
                dirtyWithChildChange.AddMember(""displayedChildrenHierarchy"", displayedChildrenHierarchy, msg.alloc());
                tempDirty[component->getUniqueId()] = dirtyWithChildChange;
            }
        }
        if (component->getDirty().count(apl::kPropertyGraphic)) {
            // for graphic component, apl-client need walk into graphicPtr to get dirty and dirtyPropertyKeys.
            rapidjson::Value vectorGraphicComponent = component->serializeDirty(msg.alloc());
            rapidjson::Value dirtyGraphicElement(rapidjson::kArrayType);
            const apl::GraphicPtr graphic = component->getCalculated(apl::kPropertyGraphic).getGraphic();
            for (auto& graphicDirty : graphic->getDirty()) {
                rapidjson::Value serializedGraphicElement = graphicDirty->serialize(msg.alloc());
                rapidjson::Value dirtyPropertyKeys(rapidjson::kArrayType);
                for (auto& dirtyPropertyKey : graphicDirty->getDirtyProperties()) {
                    dirtyPropertyKeys.PushBack(dirtyPropertyKey, msg.alloc());
                }
                serializedGraphicElement.AddMember(""dirtyProperties"", dirtyPropertyKeys, msg.alloc());
                dirtyGraphicElement.PushBack(serializedGraphicElement, msg.alloc());
            }
            if (vectorGraphicComponent.HasMember(""graphic"") && vectorGraphicComponent[""graphic""].IsObject()) {
                vectorGraphicComponent[""graphic""].AddMember(""dirty"", dirtyGraphicElement, msg.alloc());
            }
            tempDirty[component->getUniqueId()] = vectorGraphicComponent;
        }
        if (tempDirty.find(component->getUniqueId()) == tempDirty.end()) {
            tempDirty.emplace(component->getUniqueId(), component->serializeDirty(msg.alloc()));
        }
    }

    rapidjson::Value array(rapidjson::kArrayType);
    for (auto rit = tempDirty.rbegin(); rit != tempDirty.rend(); rit++) {
        auto uid = rit->first;
        auto& update = rit->second;

        array.PushBack(update.Move(), msg.alloc());
    }
    send(msg.setPayload(std::move(array)));
}

void AplCoreConnectionManager::coreFrameUpdate() {
    auto aplOptions = m_aplConfiguration->getAplOptions();
    auto now = getCurrentTime() - m_StartTime;
    m_Root->updateTime(now.count(), getCurrentTime().count());
    m_Root->setLocalTimeAdjustment(aplOptions->getTimezoneOffset().count());

    m_Root->clearPending();

    while (m_Root->hasEvent()) {
        processEvent(m_Root->popEvent());
    }

    if (m_Root->isDirty()) {
        processDirty(m_Root->getDirty());
        m_Root->clearDirty();
    }

    handleScreenLock();
}

void AplCoreConnectionManager::onUpdateTick() {
    if (m_Root) {
        coreFrameUpdate();
        // Check regularly as something like timed-out fetch requests could come up.
        checkAndSendDataSourceErrors();
    }
}

apl::Rect AplCoreConnectionManager::convertJsonToScaledRect(const rapidjson::Value& jsonNode) {
    const float scale = m_AplCoreMetrics->toCore(1.0f);
    const float x = jsonNode[X_KEY].IsNumber() ? jsonNode[X_KEY].GetFloat() : 0.0f;
    const float y = jsonNode[Y_KEY].IsNumber() ? jsonNode[Y_KEY].GetFloat() : 0.0f;
    const float width = jsonNode[WIDTH_KEY].IsNumber() ? jsonNode[WIDTH_KEY].GetFloat() : 0.0f;
    const float height = jsonNode[HEIGHT_KEY].IsNumber() ? jsonNode[HEIGHT_KEY].GetFloat() : 0.0f;

    return apl::Rect(x * scale, y * scale, width * scale, height * scale);
}

void AplCoreConnectionManager::checkAndSendDataSourceErrors() {
    if (!m_Root) return;

    std::vector<apl::Object> errorArray;

    for (auto& type : KNOWN_DATA_SOURCES) {
        auto provider = m_Root->getRootConfig().getDataSourceProvider(type);

        if (provider) {
            auto pendingErrors = provider->getPendingErrors();
            if (!pendingErrors.empty() && pendingErrors.isArray()) {
                errorArray.insert(errorArray.end(), pendingErrors.getArray().begin(), pendingErrors.getArray().end());
            }
        }
    }

    auto errors = apl::Object(std::make_shared<apl::ObjectArray>(errorArray));

    if (!errors.empty()) {
        auto errorEvent = std::make_shared<apl::ObjectMap>();
        errorEvent->emplace(PRESENTATION_TOKEN_KEY, m_aplToken);
        errorEvent->emplace(ERRORS_KEY, errors);

        rapidjson::Document runtimeErrorPayloadJson(rapidjson::kObjectType);
        auto& allocator = runtimeErrorPayloadJson.GetAllocator();
        auto runtimeError = apl::Object(errorEvent).serialize(allocator);

        rapidjson::StringBuffer sb;
        rapidjson::Writer<rapidjson::StringBuffer> writer(sb);
        runtimeError.Accept(writer);

        m_aplConfiguration->getAplOptions()->onRuntimeErrorEvent(m_aplToken, sb.GetString());
    }
}

const std::string AplCoreConnectionManager::getAPLToken() {
    return m_aplToken;
}

void AplCoreConnectionManager::serializeJSONValueToString(const rapidjson::Value& documentNode, std::string* value) {
    rapidjson::StringBuffer stringBuffer;
    rapidjson::Writer<rapidjson::StringBuffer> writer(stringBuffer);

    if (!documentNode.Accept(writer)) {
        auto aplOptions = m_aplConfiguration->getAplOptions();
        aplOptions->logMessage(LogLevel::ERROR, ""serializeJSONValueToStringFailed"", ""acceptFailed"");
        return;
    }

    *value = stringBuffer.GetString();
}

void AplCoreConnectionManager::addExtensions(
        std::unordered_set<std::shared_ptr<AplCoreExtensionInterface>> extensions) {
    for (auto& extension : extensions) {
        extension->setEventHandler(shared_from_this());
        m_extensionManager->addExtension(extension);
    }
}

std::shared_ptr<AplCoreExtensionInterface> AplCoreConnectionManager::getExtension(const std::string& uri) {
    return m_extensionManager->getExtension(uri);
}

void AplCoreConnectionManager::reset() {
    m_aplToken = """";
    m_Root.reset();
    m_Content.reset();
}

void AplCoreConnectionManager::handleIsCharacterValid(const rapidjson::Value& payload) {
    auto aplOptions = m_aplConfiguration->getAplOptions();
    if (!m_Root) {
        aplOptions->logMessage(LogLevel::ERROR, ""handleIsCharacterValidFailed"", ""Root context is null"");
        return;
    }

    auto messageId = payload[""messageId""].GetString();
    if (!messageId) {
        aplOptions->logMessage(
            LogLevel::ERROR, ""handleIsCharacterValidFailed"", std::string(""Payload does not contain messageId""));
        sendError(""Payload does not contain messageId"");
        return;
    }

    auto character = payload[""character""].GetString();
    if (!character) {
        aplOptions->logMessage(
            LogLevel::ERROR, ""handleIsCharacterValidFailed"", std::string(""Payload does not contain character""));
        sendError(""Payload does not contain character"");
        return;
    }

    auto componentId = payload[""componentId""].GetString();
    if (!componentId) {
        aplOptions->logMessage(
            LogLevel::ERROR, ""handleIsCharacterValidFailed"", std::string(""Payload does not contain componentId""));
        sendError(""Payload does not contain componentId"");
        return;
    }
    auto component = m_Root->findComponentById(componentId);
    if (!component) {
        aplOptions->logMessage(
            LogLevel::ERROR,
            ""handleIsCharacterValidFailed"",
            std::string(""Unable to find component with id: "") + componentId);
        sendError(""Unable to find component"");
        return;
    }

    auto result = component->isCharacterValid(character[0]);

    auto resultMessage = AplCoreViewhostMessage(""isCharacterValid"");
    auto& alloc = resultMessage.alloc();
    rapidjson::Value resultMessageValue(rapidjson::kObjectType);

    rapidjson::Value messageIdValue;
    messageIdValue.SetString(messageId, alloc);
    resultMessageValue.AddMember(""messageId"", messageIdValue, alloc);

    resultMessageValue.AddMember(""valid"", result, alloc);

    rapidjson::Value componentIdValue;
    componentIdValue.SetString(componentId, alloc);
    resultMessageValue.AddMember(""componentId"", componentIdValue, alloc);

    resultMessage.setPayload(std::move(resultMessageValue));
    send(resultMessage);
}

void AplCoreConnectionManager::handleReInflate(const rapidjson::Value& payload) {
    auto aplOptions = m_aplConfiguration->getAplOptions();
    if (!m_Root) {
        aplOptions->logMessage(LogLevel::ERROR, ""handleIsCharacterValidFailed"", ""Root context is null"");
        return;
    }
    m_Root->reinflate();

    // update component hierarchy
    sendHierarchy(HIERARCHY_KEY);
}

void AplCoreConnectionManager::handleReHierarchy(const rapidjson::Value& payload) {
    // send component hierarchy
    sendHierarchy(REHIERARCHY_KEY, true);
}

void AplCoreConnectionManager::updateConfigurationChange(const apl::ConfigurationChange& configurationChange) {
    m_ConfigurationChange.mergeConfigurationChange(configurationChange);
}

void AplCoreConnectionManager::handleExtensionMessage(const rapidjson::Value& payload) {
    auto const& uriMember = payload.FindMember(""uri"")->value;
    auto const& nameMember = payload.FindMember(""name"")->value;
    auto const& fastModeMember = payload.FindMember(""fastMode"")->value;
    auto const aplOptions = m_aplConfiguration->getAplOptions();
    if (!uriMember.IsString()
        || !nameMember.IsString()
        || !fastModeMember.IsBool()) {
        aplOptions->logMessage(LogLevel::ERROR, ""handleExtensionMessageFailed"", ""Could not parse extensionMessage"");
        return;
    }
    auto const uri = uriMember.GetString();
    auto const name = nameMember.GetString();
    auto const fastMode = fastModeMember.GetBool();

    auto const& dataMember = payload.FindMember(""data"")->value;
    apl::ObjectMap data;
    for (auto itr = dataMember.MemberBegin(); itr != dataMember.MemberEnd(); ++itr) {
        if (!itr->value.IsString()) {
            aplOptions->logMessage(LogLevel::ERROR, ""handleExtensionMessageFailed"",
                                   ""Could not parse extensionMessage data"");
            continue;
        }
        data.emplace(itr->name.GetString(), itr->value.GetString());
    }
    invokeExtensionEventHandler(uri, name, data, fastMode);
}

}  // namespace APLClient
",16373,True,3137.7175278270734,median
"[[install-config-syncing-groups-with-ldap]]
= Syncing groups With LDAP
{product-author}
{product-version}
:data-uri:
:icons:
:experimental:
:toc: macro
:toc-title:

toc::[]

== Overview
As an {product-title} administrator, you can use groups to manage users, change
their permissions, and enhance collaboration. Your organization may have already
created user groups and stored them in an LDAP server. {product-title} can sync
those LDAP records with internal {product-title} records, enabling you to manage
your groups in one place. {product-title} currently supports group sync with
LDAP servers using three common schemas for defining group membership: RFC 2307,
Active Directory, and augmented Active Directory.

[NOTE]
====
You must have
xref:../architecture/additional_concepts/authorization.adoc#roles[`cluster-admin`
privileges] to sync groups.
====

[[configuring-ldap-sync]]
== Configuring LDAP sync

Before you can xref:running-ldap-sync[run LDAP sync], you need a sync
configuration file. This file contains LDAP client configuration details:

* Configuration for connecting to your LDAP server.
* Sync configuration options that are dependent on the schema used in your LDAP
server.

A sync configuration file can also contain an administrator-defined list of name
mappings that maps {product-title} group names to groups in your LDAP server.

[[ldap-client-configuration]]
=== LDAP client configuration

.LDAP client configuration
[source,yaml]
----
url: ldap://10.0.0.0:389 <1>
bindDN: cn=admin,dc=example,dc=com <2>
bindPassword: password <3>
insecure: false <4>
ca: my-ldap-ca-bundle.crt <5>
----
<1> The connection protocol, IP address of the LDAP server hosting your
database, and the port to connect to, formatted as `scheme://host:port`.
<2> Optional distinguished name (DN) to use as the Bind DN.
{product-title} uses this if elevated privilege is required to retrieve entries for
the sync operation.
<3> Optional password to use to bind. {product-title} uses this if elevated privilege is
necessary to retrieve entries for the sync operation. This value may also be
provided in an
xref:../install_config/master_node_configuration.adoc#master-node-configuration-passwords-and-other-data[environment
variable, external file, or encrypted file].
<4> When `true`, no TLS connection is made to the server. When `false`, secure
LDAP (`ldaps://`) URLs connect using TLS, and insecure LDAP (`ldap://`) URLs are
upgraded to TLS.
<5> The certificate bundle to use for validating server certificates for the
configured URL. If empty, {product-title} uses system-trusted roots. This only applies
if `insecure` is set to `false`.

[[ldap-query-definition]]
=== LDAP query definition

Sync configurations consist of LDAP query definitions for the entries that are
required for synchronization. The specific definition of an LDAP query depends
on the schema used to store membership information in the LDAP server.

.LDAP query definition
[source,yaml]
----
baseDN: ou=users,dc=example,dc=com <1>
scope: sub <2>
derefAliases: never <3>
timeout: 0 <4>
filter: (objectClass=inetOrgPerson) <5>
pageSize: 0 <6>
----
<1> The distinguished name (DN) of the branch of the directory where all
searches will start from. It is required that you specify the top of your
directory tree, but you can also specify a subtree in the directory.
<2> The scope of the search. Valid values are `base`, `one`, or `sub`. If this
is left undefined, then a scope of `sub` is assumed. Descriptions of the scope
options can be found in the xref:ldap-search[table below].
<3> The behavior of the search with respect to aliases in the LDAP tree. Valid
values are `never`, `search`, `base`, or `always`. If this is left undefined,
then the default is to `always` dereference aliases. Descriptions of the
dereferencing behaviors can be found in the xref:deref-aliases[table below].
<4> The time limit allowed for the search by the client, in seconds. A value of
0 imposes no client-side limit.
<5> A valid LDAP search filter. If this is left undefined, then the default is
`(objectClass=*)`.
<6> The optional maximum size of response pages from the server, measured in LDAP
entries. If set to 0, no size restrictions will be made on pages of responses.
Setting paging sizes is necessary when queries return more entries than the
client or server allow by default.

[[ldap-search]]
.LDAP search scope options
[cols=""2a,8a"",options=""header""]
|===
|LDAP Search Scope | Description
.^|`base`          | Only consider the object specified by the base DN given for the query.
.^|`one`           | Consider all of the objects on the same level in the tree as the base DN for
the query.
.^|`sub`           | Consider the entire subtree rooted at the base DN given for the query.
|===

[[deref-aliases]]
.LDAP dereferencing behaviors
[cols=""2a,8a"",options=""header""]
|===
|Dereferencing Behavior | Description
.^|`never`              | Never dereference any aliases found in the LDAP tree.
.^|`search`             | Only dereference aliases found while searching.
.^|`base`               | Only dereference aliases while finding the base object.
.^|`always`             | Always dereference all aliases found in the LDAP tree.
|===

[[user-defined-name-mapping]]
=== User-defined name mapping

A user-defined name mapping explicitly maps the names of {product-title} groups to
unique identifiers that find groups on your LDAP server. The mapping uses normal
YAML syntax. A user-defined mapping can contain an entry for every group in your
LDAP server or only a subset of those groups. If there are groups on the LDAP
server that do not have a user-defined name mapping, the default behavior during
sync is to use the attribute specified as the {product-title} group's name.

.User-defined name mapping
[source,yaml]
----
groupUIDNameMapping:
  ""cn=group1,ou=groups,dc=example,dc=com"": firstgroup
  ""cn=group2,ou=groups,dc=example,dc=com"": secondgroup
  ""cn=group3,ou=groups,dc=example,dc=com"": thirdgroup
----

[[running-ldap-sync]]
== Running LDAP sync

Once you have created a xref:configuring-ldap-sync[sync configuration file],
then sync can begin. {product-title} allows administrators to perform a number of
different sync types with the same server.

[NOTE]
====
By default, all group synchronization or pruning operations are dry-run, so you
must set the `--confirm` flag on the `oc adm groups sync` command in order to make
changes to {product-title} group records.
====

To sync all groups from the LDAP server with {product-title}:

----
$ oc adm groups sync --sync-config=config.yaml --confirm
----

To sync all groups already in {product-title} that correspond to groups in the
LDAP server specified in the configuration file:

----
$ oc adm groups sync --type=openshift --sync-config=config.yaml --confirm
----

To sync a subset of LDAP groups with {product-title}, you can use whitelist files,
blacklist files, or both:

[NOTE]
====
You can use any combination of blacklist files, whitelist files, or whitelist
literals. Whitelist and blacklist files must contain one unique group identifier
per line, and you can include whitelist literals directly in the command itself.
These guidelines apply to groups found on LDAP servers as well as groups already
present in {product-title}. 
====

----
$ oc adm groups sync --whitelist=<whitelist_file> \\
                   --sync-config=config.yaml    \\
                   --confirm
$ oc adm groups sync --blacklist=<blacklist_file> \\
                   --sync-config=config.yaml    \\
                   --confirm
$ oc adm groups sync <group_unique_identifier>    \\
                   --sync-config=config.yaml    \\
                   --confirm
$ oc adm groups sync <group_unique_identifier>    \\
                   --whitelist=<whitelist_file> \\
                   --blacklist=<blacklist_file> \\
                   --sync-config=config.yaml    \\
                   --confirm
$ oc adm groups sync --type=openshift             \\
                   --whitelist=<whitelist_file> \\
                   --sync-config=config.yaml    \\
                   --confirm
----

[[running-a-group-pruning-job]]
== Running a group pruning job

An administrator can also choose to remove groups from {product-title} records
if the records on the LDAP server that created them are no longer present. The
prune job will accept the same sync configuration file and white- or black-lists
as used for the sync job. More information is available in
xref:../admin_guide/pruning_resources.adoc#pruning-groups[Pruning groups] section.

[[sync-examples]]
== Sync examples

This section contains examples for the xref:sync-ldap-rfc-2307[RFC 2307],
xref:sync-ldap-active-directory[Active Directory], and
xref:sync-ldap-augmented-active-directory[augmented Active Directory] schemas.
All of the following examples synchronize a group named `admins` that has two
members: `Jane` and `Jim`. Each example explains:

* How the group and users are added to the LDAP server.
* What the LDAP sync configuration file looks like.
* What the resulting group record in {product-title} will be after synchronization.

[NOTE]
====
These examples assume that all users are direct members of their respective
groups. Specifically, no groups have other groups as members. See
xref:sync-ldap-nested-example[Nested Membership Sync Example] for information on
how to sync nested groups.
====

[[sync-ldap-rfc-2307]]
=== Syncing groups by using RFC 2307 schema

In the RFC 2307 schema, both users (Jane and Jim) and groups exist on the LDAP
server as first-class entries, and group membership is stored in attributes on
the group. The following snippet of `ldif` defines the users and group for this
schema:

.LDAP entries that use RFC 2307 schema: *_rfc2307.ldif_*
[source,ldif]
----
  dn: ou=users,dc=example,dc=com
  objectClass: organizationalUnit
  ou: users

  dn: cn=Jane,ou=users,dc=example,dc=com
  objectClass: person
  objectClass: organizationalPerson
  objectClass: inetOrgPerson
  cn: Jane
  sn: Smith
  displayName: Jane Smith
  mail: jane.smith@example.com

  dn: cn=Jim,ou=users,dc=example,dc=com
  objectClass: person
  objectClass: organizationalPerson
  objectClass: inetOrgPerson
  cn: Jim
  sn: Adams
  displayName: Jim Adams
  mail: jim.adams@example.com

  dn: ou=groups,dc=example,dc=com
  objectClass: organizationalUnit
  ou: groups

  dn: cn=admins,ou=groups,dc=example,dc=com <1>
  objectClass: groupOfNames
  cn: admins
  owner: cn=admin,dc=example,dc=com
  description: System Administrators
  member: cn=Jane,ou=users,dc=example,dc=com <2>
  member: cn=Jim,ou=users,dc=example,dc=com
----
<1> The group is a first-class entry in the LDAP server.
<2> Members of a group are listed with an identifying reference as attributes on
the group.

To sync this group, you must first create the configuration file. The
RFC 2307 schema requires you to provide an LDAP query definition for both user
and group entries, as well as the attributes with which to represent them in the
internal {product-title} records.

For clarity, the group you create in {product-title} should use attributes other
than the distinguished name whenever possible for user- or administrator-facing
fields. For example, identify the users of an {product-title} group by their e-mail, and use the
name of the group as the common name. The following configuration file creates
these relationships:

[NOTE]
====
If using user-defined name mappings, your
xref:rfc2307-with-user-defined-name-mappings[configuration file] will differ.
====

.LDAP sync configuration that uses RFC 2307 schema: *_rfc2307_config.yaml_*
[source,yaml]
----
kind: LDAPSyncConfig
apiVersion: v1
url: ldap://LDAP_SERVICE_IP:389 <1>
insecure: false <2>
rfc2307:
    groupsQuery:
        baseDN: ""ou=groups,dc=example,dc=com""
        scope: sub
        derefAliases: never
        pageSize: 0
    groupUIDAttribute: dn <3>
    groupNameAttributes: [ cn ] <4>
    groupMembershipAttributes: [ member ] <5>
    usersQuery:
        baseDN: ""ou=users,dc=example,dc=com""
        scope: sub
        derefAliases: never
        pageSize: 0
    userUIDAttribute: dn <6>
    userNameAttributes: [ mail ] <7>
    tolerateMemberNotFoundErrors: false
    tolerateMemberOutOfScopeErrors: false
----
<1> The IP address and host of the LDAP server where this group's record is
stored.
<2> When `true`, no TLS connection is made to the server. When `false`, secure
LDAP (`ldaps://`) URLs connect using TLS, and insecure LDAP (`ldap://`) URLs are
upgraded to TLS.
<3> The attribute that uniquely identifies a group on the LDAP server.
You cannot specify `groupsQuery` filters when using DN for groupUIDAttribute.
For fine-grained filtering, use the
xref:../install_config/syncing_groups_with_ldap.adoc#running-ldap-sync[whitelist / blacklist method].
<4> The attribute to use as the name of the group.
<5> The attribute on the group that stores the membership information.
<6> The attribute that uniquely identifies a user on the LDAP server. You
cannot specify `usersQuery` filters when using DN for userUIDAttribute. For
fine-grained  filtering, use the
xref:../install_config/syncing_groups_with_ldap.adoc#running-ldap-sync[whitelist / blacklist method].
<7> The attribute to use as the name of the user in the {product-title} group record.

To run sync with the *_rfc2307_config.yaml_* file:

----
$ oc adm groups sync --sync-config=rfc2307_config.yaml --confirm
----

{product-title} creates the following group record as a result of the above sync
operation:

.{product-title} group created by using the *_rfc2307_config.yaml_* file
[source,yaml]
----
apiVersion: user.openshift.io/v1
kind: Group
metadata:
  annotations:
    openshift.io/ldap.sync-time: 2015-10-13T10:08:38-0400 <1>
    openshift.io/ldap.uid: cn=admins,ou=groups,dc=example,dc=com <2>
    openshift.io/ldap.url: LDAP_SERVER_IP:389 <3>
  creationTimestamp:
  name: admins <4>
users: <5>
- jane.smith@example.com
- jim.adams@example.com
----
<1> The last time this {product-title} group was synchronized with the LDAP server, in ISO 6801
format.
<2> The unique identifier for the group on the LDAP server.
<3> The IP address and host of the LDAP server where this group's record is
stored.
<4> The name of the group as specified by the sync file.
<5> The users that are members of the group, named as specified by the sync file.

[[rfc2307-with-user-defined-name-mappings]]
==== RFC2307 with user-defined name mappings

When syncing groups with user-defined name mappings, the configuration file
changes to contain these mappings as shown below.

.LDAP sync configuration that uses RFC 2307 schema with user-defined name mappings: *_rfc2307_config_user_defined.yaml_*
[source,yaml]
----
kind: LDAPSyncConfig
apiVersion: v1
groupUIDNameMapping:
  ""cn=admins,ou=groups,dc=example,dc=com"": Administrators <1>
rfc2307:
    groupsQuery:
        baseDN: ""ou=groups,dc=example,dc=com""
        scope: sub
        derefAliases: never
        pageSize: 0
    groupUIDAttribute: dn <2>
    groupNameAttributes: [ cn ] <3>
    groupMembershipAttributes: [ member ]
    usersQuery:
        baseDN: ""ou=users,dc=example,dc=com""
        scope: sub
        derefAliases: never
        pageSize: 0
    userUIDAttribute: dn <4>
    userNameAttributes: [ mail ]
    tolerateMemberNotFoundErrors: false
    tolerateMemberOutOfScopeErrors: false
----
<1> The user-defined name mapping.
<2> The unique identifier attribute that is used for the keys in the
user-defined name mapping. You cannot specify `groupsQuery` filters when using
DN for groupUIDAttribute. For fine-grained filtering, use the
xref:../install_config/syncing_groups_with_ldap.adoc#running-ldap-sync[whitelist / blacklist method].
<3> The attribute to name {product-title} groups with if their unique identifier is
not in the user-defined name mapping.
<4> The attribute that uniquely identifies a user on the LDAP server. You
cannot specify `usersQuery` filters when using DN for userUIDAttribute. For
fine-grained  filtering, use the
xref:../install_config/syncing_groups_with_ldap.adoc#running-ldap-sync[whitelist / blacklist method].

To run sync with the *_rfc2307_config_user_defined.yaml_* file:

----
$ oc adm groups sync --sync-config=rfc2307_config_user_defined.yaml --confirm
----

{product-title} creates the following group record as a result of the above sync
operation:

.{product-title} group created by using the *_rfc2307_config_user_defined.yaml_* file
[source,yaml]
----
apiVersion: user.openshift.io/v1
kind: Group
metadata:
  annotations:
    openshift.io/ldap.sync-time: 2015-10-13T10:08:38-0400
    openshift.io/ldap.uid: cn=admins,ou=groups,dc=example,dc=com
    openshift.io/ldap.url: LDAP_SERVER_IP:389
  creationTimestamp:
  name: Administrators <1>
users:
- jane.smith@example.com
- jim.adams@example.com
----
<1> The name of the group as specified by the user-defined name mapping.

[[rfc2307-with-error-tolerances]]
=== Syncing groups by using RFC 2307 with user-defined error tolerances

By default, if the groups being synced contain members whose entries are outside
of the scope defined in the member query, the group sync fails with an error:

----
Error determining LDAP group membership for ""<group>"": membership lookup for user ""<user>"" in group ""<group>"" failed because of ""search for entry with dn=""<user-dn>"" would search outside of the base dn specified (dn=""<base-dn>"")"".
----

This often indicates a mis-configured `baseDN` in the `usersQuery` field.
However, in cases where the `baseDN` intentionally does not contain some of the
members of the group, setting `tolerateMemberOutOfScopeErrors: true` allows
the group sync to continue. Out of scope members will be ignored.

Similarly, when the group sync process fails to locate a member for a group, it
fails outright with errors:

----
Error determining LDAP group membership for ""<group>"": membership lookup for user ""<user>"" in group ""<group>"" failed because of ""search for entry with base dn=""<user-dn>"" refers to a non-existent entry"".

Error determining LDAP group membership for ""<group>"": membership lookup for user ""<user>"" in group ""<group>"" failed because of ""search for entry with base dn=""<user-dn>"" and filter ""<filter>"" did not return any results"".
----

This often indicates a mis-configured `usersQuery` field. However, in cases
where the group contains member entries that are known to be missing, setting
`tolerateMemberNotFoundErrors: true` allows the group sync to continue.
Problematic members will be ignored.

[WARNING]
====
Enabling error tolerances for the LDAP group sync causes the sync process to
ignore problematic member entries. If the LDAP group sync is not configured
correctly, this could result in synced {product-title} groups missing members.
====

.LDAP entries that use RFC 2307 schema with problematic group membership: *_rfc2307_problematic_users.ldif_*
[source,ldif]
----
  dn: ou=users,dc=example,dc=com
  objectClass: organizationalUnit
  ou: users

  dn: cn=Jane,ou=users,dc=example,dc=com
  objectClass: person
  objectClass: organizationalPerson
  objectClass: inetOrgPerson
  cn: Jane
  sn: Smith
  displayName: Jane Smith
  mail: jane.smith@example.com

  dn: cn=Jim,ou=users,dc=example,dc=com
  objectClass: person
  objectClass: organizationalPerson
  objectClass: inetOrgPerson
  cn: Jim
  sn: Adams
  displayName: Jim Adams
  mail: jim.adams@example.com

  dn: ou=groups,dc=example,dc=com
  objectClass: organizationalUnit
  ou: groups

  dn: cn=admins,ou=groups,dc=example,dc=com
  objectClass: groupOfNames
  cn: admins
  owner: cn=admin,dc=example,dc=com
  description: System Administrators
  member: cn=Jane,ou=users,dc=example,dc=com
  member: cn=Jim,ou=users,dc=example,dc=com
  member: cn=INVALID,ou=users,dc=example,dc=com <1>
  member: cn=Jim,ou=OUTOFSCOPE,dc=example,dc=com <2>
----
<1> A member that does not exist on the LDAP server.
<2> A member that may exist, but is not under the `baseDN` in the
user query for the sync job.

In order to tolerate the errors in the above example, the following additions to
your sync configuration file must be made:

.LDAP sync configuration that uses RFC 2307 schema tolerating errors: *_rfc2307_config_tolerating.yaml_*
[source,yaml]
----
kind: LDAPSyncConfig
apiVersion: v1
url: ldap://LDAP_SERVICE_IP:389
rfc2307:
    groupsQuery:
        baseDN: ""ou=groups,dc=example,dc=com""
        scope: sub
        derefAliases: never
    groupUIDAttribute: dn
    groupNameAttributes: [ cn ]
    groupMembershipAttributes: [ member ]
    usersQuery:
        baseDN: ""ou=users,dc=example,dc=com""
        scope: sub
        derefAliases: never
    userUIDAttribute: dn <3>
    userNameAttributes: [ mail ]
    tolerateMemberNotFoundErrors: true <1>
    tolerateMemberOutOfScopeErrors: true <2>
----
<1> When `true`, the sync job tolerates groups for which some members were not
found, and members whose LDAP entries are not found are ignored. The
default behavior for the sync job is to fail if a member of a group is not
found.
<2> When `true`, the sync job tolerates groups for which some members are outside
the user scope given in the `usersQuery` base DN, and members outside the member
query scope are ignored. The default behavior for the sync job is to fail if a
member of a group is out of scope.
<3> The attribute that uniquely identifies a user on the LDAP server. You
cannot specify `usersQuery` filters when using DN for userUIDAttribute. For
fine-grained  filtering, use the
xref:../install_config/syncing_groups_with_ldap.adoc#running-ldap-sync[whitelist / blacklist method].

To run sync with the *_rfc2307_config_tolerating.yaml_* file:

----
$ oc adm groups sync --sync-config=rfc2307_config_tolerating.yaml --confirm
----

{product-title} creates the following group record as a result of the above sync
operation:

.{product-title} group created by using the *_rfc2307_config.yaml_* file
[source,yaml]
----
apiVersion: user.openshift.io/v1
kind: Group
metadata:
  annotations:
    openshift.io/ldap.sync-time: 2015-10-13T10:08:38-0400
    openshift.io/ldap.uid: cn=admins,ou=groups,dc=example,dc=com
    openshift.io/ldap.url: LDAP_SERVER_IP:389
  creationTimestamp:
  name: admins
users: <1>
- jane.smith@example.com
- jim.adams@example.com
----
<1> The users that are members of the group, as specified by the sync file.
Members for which lookup encountered tolerated errors are absent.

[[sync-ldap-active-directory]]
=== Syncing groups by using Active Directory

In the Active Directory schema, both users (Jane and Jim) exist in the LDAP
server as first-class entries, and group membership is stored in attributes on
the user. The following snippet of `ldif` defines the users and group for this
schema:

.LDAP entries that use Active Directory schema: *_active_directory.ldif_*
[source,ldif]
----
dn: ou=users,dc=example,dc=com
objectClass: organizationalUnit
ou: users

dn: cn=Jane,ou=users,dc=example,dc=com
objectClass: person
objectClass: organizationalPerson
objectClass: inetOrgPerson
objectClass: testPerson
cn: Jane
sn: Smith
displayName: Jane Smith
mail: jane.smith@example.com
memberOf: admins <1>

dn: cn=Jim,ou=users,dc=example,dc=com
objectClass: person
objectClass: organizationalPerson
objectClass: inetOrgPerson
objectClass: testPerson
cn: Jim
sn: Adams
displayName: Jim Adams
mail: jim.adams@example.com
memberOf: admins
----
<1> The user's group memberships are listed as attributes on the user, and the
group does not exist as an entry on the server. The `memberOf` attribute does
not have to be a literal attribute on the user; in some LDAP servers, it is created
during search and returned to the client, but not committed to the database.

To sync this group, you must first create the configuration file. The
Active Directory schema requires you to provide an LDAP query definition for
user entries, as well as the attributes to represent them with in the internal
{product-title} group records.

For clarity, the group you create in {product-title} should use attributes other
than the distinguished name whenever possible for user- or administrator-facing
fields. For example, identify the users of an {product-title} group by their e-mail, but define
the name of the group by the name of the group on the LDAP server.
The following configuration file creates these relationships:

.LDAP sync configuration that uses Active Directory schema: *_active_directory_config.yaml_*
[source,yaml]
----
kind: LDAPSyncConfig
apiVersion: v1
url: ldap://LDAP_SERVICE_IP:389
activeDirectory:
    usersQuery:
        baseDN: ""ou=users,dc=example,dc=com""
        scope: sub
        derefAliases: never
        filter: (objectclass=inetOrgPerson)
        pageSize: 0
    userNameAttributes: [ mail ] <1>
    groupMembershipAttributes: [ memberOf ] <2>
----
<1> The attribute to use as the name of the user in the {product-title} group record.
<2> The attribute on the user that stores the membership information.

To run sync with the *_active_directory_config.yaml_* file:

----
$ oc adm groups sync --sync-config=active_directory_config.yaml --confirm
----

{product-title} creates the following group record as a result of the above sync
operation:

.{product-title} group created by using the  *_active_directory_config.yaml_* file
[source,yaml]
----
apiVersion: user.openshift.io/v1
kind: Group
metadata:
  annotations:
    openshift.io/ldap.sync-time: 2015-10-13T10:08:38-0400 <1>
    openshift.io/ldap.uid: admins <2>
    openshift.io/ldap.url: LDAP_SERVER_IP:389 <3>
  creationTimestamp:
  name: admins <4>
users: <5>
- jane.smith@example.com
- jim.adams@example.com
----
<1> The last time this {product-title} group was synchronized with the LDAP server, in ISO 6801
format.
<2> The unique identifier for the group on the LDAP server.
<3> The IP address and host of the LDAP server where this group's record is
stored.
<4> The name of the group as listed in the LDAP server.
<5> The users that are members of the group, named as specified by the sync
file.

[[sync-ldap-augmented-active-directory]]
=== Syncing groups by using augmented Active Directory

In the augmented Active Directory schema, both users (Jane and Jim) and groups
exist in the LDAP server as first-class entries, and group membership is stored
in attributes on the user. The following snippet of `ldif` defines the users and
group for this schema:

.LDAP entries that use augmented Active Directory schema: *_augmented_active_directory.ldif_*
[source,ldif]
----
dn: ou=users,dc=example,dc=com
objectClass: organizationalUnit
ou: users

dn: cn=Jane,ou=users,dc=example,dc=com
objectClass: person
objectClass: organizationalPerson
objectClass: inetOrgPerson
objectClass: testPerson
cn: Jane
sn: Smith
displayName: Jane Smith
mail: jane.smith@example.com
memberOf: cn=admins,ou=groups,dc=example,dc=com <1>

dn: cn=Jim,ou=users,dc=example,dc=com
objectClass: person
objectClass: organizationalPerson
objectClass: inetOrgPerson
objectClass: testPerson
cn: Jim
sn: Adams
displayName: Jim Adams
mail: jim.adams@example.com
memberOf: cn=admins,ou=groups,dc=example,dc=com

dn: ou=groups,dc=example,dc=com
objectClass: organizationalUnit
ou: groups

dn: cn=admins,ou=groups,dc=example,dc=com <2>
objectClass: groupOfNames
cn: admins
owner: cn=admin,dc=example,dc=com
description: System Administrators
member: cn=Jane,ou=users,dc=example,dc=com
member: cn=Jim,ou=users,dc=example,dc=com
----
<1> The user's group memberships are listed as attributes on the user.
<2> The group is a first-class entry on the LDAP server.

To sync this group, you must first create the configuration file. The
augmented Active Directory schema requires you to provide an LDAP query
definition for both user entries and group entries, as well as the attributes
with which to represent them in the internal {product-title} group records.

For clarity, the group you create in {product-title} should use attributes other
than the distinguished name whenever possible for user- or administrator-facing
fields. For example, identify the users of an {product-title} group by their e-mail,
and use the name of the group as the common name. The following configuration
file creates these relationships.

.LDAP sync configuration that uses augmented Active Directory schema: *_augmented_active_directory_config.yaml_*
[source,yaml]
----
kind: LDAPSyncConfig
apiVersion: v1
url: ldap://LDAP_SERVICE_IP:389
augmentedActiveDirectory:
    groupsQuery:
        baseDN: ""ou=groups,dc=example,dc=com""
        scope: sub
        derefAliases: never
        pageSize: 0
    groupUIDAttribute: dn <1>
    groupNameAttributes: [ cn ] <2>
    usersQuery:
        baseDN: ""ou=users,dc=example,dc=com""
        scope: sub
        derefAliases: never
        filter: (objectclass=inetOrgPerson)
        pageSize: 0
    userNameAttributes: [ mail ] <3>
    groupMembershipAttributes: [ memberOf ] <4>
----
<1> The attribute that uniquely identifies a group on the LDAP server. You
cannot specify `groupsQuery` filters when using DN for groupUIDAttribute. For
fine-grained filtering, use the
xref:../install_config/syncing_groups_with_ldap.adoc#running-ldap-sync[whitelist / blacklist method].
<2> The attribute to use as the name of the group.
<3> The attribute to use as the name of the user in the {product-title} group record.
<4> The attribute on the user that stores the membership information.

To run sync with the *_augmented_active_directory_config.yaml_* file:

----
$ oc adm groups sync --sync-config=augmented_active_directory_config.yaml --confirm
----

{product-title} creates the following group record as a result of the above sync
operation:

.OpenShift group created by using the *_augmented_active_directory_config.yaml_* file

[source,yaml]
----
apiVersion: user.openshift.io/v1
kind: Group
metadata:
  annotations:
    openshift.io/ldap.sync-time: 2015-10-13T10:08:38-0400 <1>
    openshift.io/ldap.uid: cn=admins,ou=groups,dc=example,dc=com <2>
    openshift.io/ldap.url: LDAP_SERVER_IP:389 <3>
  creationTimestamp:
  name: admins <4>
users: <5>
- jane.smith@example.com
- jim.adams@example.com
----
<1> The last time this {product-title} group was synchronized with the LDAP server, in ISO 6801 format.
<2> The unique identifier for the group on the LDAP server.
<3> The IP address and host of the LDAP server where this group's record is stored.
<4> The name of the group as specified by the sync file.
<5> The users that are members of the group, named as specified by the sync file.


[[sync-ldap-nested-example]]
== Nested membership sync example

Groups in {product-title} do not nest. The LDAP server must flatten group
membership before the data can be consumed. Microsoft's Active Directory Server
supports this feature via the
link:https://msdn.microsoft.com/en-us/library/aa746475(v=vs.85).aspx[`LDAP_MATCHING_RULE_IN_CHAIN`]
rule, which has the OID `1.2.840.113556.1.4.1941`. Furthermore, only explicitly
xref:../install_config/syncing_groups_with_ldap.adoc#running-ldap-sync[whitelisted]
groups can be synced when using this matching rule.

This section has an example for the augmented Active Directory schema, which
synchronizes a group named `admins` that has one user `Jane` and one group
`otheradmins` as members. The `otheradmins` group has one user member: `Jim`.
This example explains:

* How the group and users are added to the LDAP server.
* What the LDAP sync configuration file looks like.
* What the resulting group record in {product-title} will be after synchronization.

In the augmented Active Directory schema, both users (`Jane` and `Jim`) and
groups exist in the LDAP server as first-class entries, and group membership is
stored in attributes on the user or the group. The following snippet of `ldif`
defines the users and groups for this schema:

.LDAP entries that use augmented Active Directory schema with nested members: *_augmented_active_directory_nested.ldif_*
[source,ldif]
----
dn: ou=users,dc=example,dc=com
objectClass: organizationalUnit
ou: users

dn: cn=Jane,ou=users,dc=example,dc=com
objectClass: person
objectClass: organizationalPerson
objectClass: inetOrgPerson
objectClass: testPerson
cn: Jane
sn: Smith
displayName: Jane Smith
mail: jane.smith@example.com
memberOf: cn=admins,ou=groups,dc=example,dc=com <1>

dn: cn=Jim,ou=users,dc=example,dc=com
objectClass: person
objectClass: organizationalPerson
objectClass: inetOrgPerson
objectClass: testPerson
cn: Jim
sn: Adams
displayName: Jim Adams
mail: jim.adams@example.com
memberOf: cn=otheradmins,ou=groups,dc=example,dc=com <1>

dn: ou=groups,dc=example,dc=com
objectClass: organizationalUnit
ou: groups

dn: cn=admins,ou=groups,dc=example,dc=com <2>
objectClass: group
cn: admins
owner: cn=admin,dc=example,dc=com
description: System Administrators
member: cn=Jane,ou=users,dc=example,dc=com
member: cn=otheradmins,ou=groups,dc=example,dc=com

dn: cn=otheradmins,ou=groups,dc=example,dc=com <2>
objectClass: group
cn: otheradmins
owner: cn=admin,dc=example,dc=com
description: Other System Administrators
memberOf: cn=admins,ou=groups,dc=example,dc=com <1> <3>
member: cn=Jim,ou=users,dc=example,dc=com
----
<1> The user's and group's memberships are listed as attributes on the object.
<2> The groups are first-class entries on the LDAP server.
<3> The `otheradmins` group is a member of the `admins` group.

To sync nested groups with Active Directory, you must provide an LDAP query
definition for both user entries and group entries, as well as the attributes
with which to represent them in the internal {product-title} group records.
Furthermore, certain changes are required in this configuration:

- The `oc adm groups sync` command must explicitly
xref:../install_config/syncing_groups_with_ldap.adoc#running-ldap-sync[whitelist]
groups.
- The user's `groupMembershipAttributes` must include
`""memberOf:1.2.840.113556.1.4.1941:""` to comply with the
https://msdn.microsoft.com/en-us/library/aa746475(v=vs.85).aspx[`LDAP_MATCHING_RULE_IN_CHAIN`]
rule.
- The `groupUIDAttribute` must be set to `dn`.
- The `groupsQuery`:
  * Must not set `filter`.
  * Must set a valid `derefAliases`.
  * Should not set `baseDN` as that value is ignored.
  * Should not set `scope` as that value is ignored.

For clarity, the group you create in {product-title} should use attributes other
than the distinguished name whenever possible for user- or administrator-facing
fields. For example, identify the users of an {product-title} group by their e-mail, and use the
name of the group as the common name. The following configuration file creates
these relationships:

.LDAP sync configuration that uses augmented Active Directory schema with nested members: *_augmented_active_directory_config_nested.yaml_*
[source,yaml]
----
kind: LDAPSyncConfig
apiVersion: v1
url: ldap://LDAP_SERVICE_IP:389
augmentedActiveDirectory:
    groupsQuery: <1>
        derefAliases: never
        pageSize: 0
    groupUIDAttribute: dn <2>
    groupNameAttributes: [ cn ] <3>
    usersQuery:
        baseDN: ""ou=users,dc=example,dc=com""
        scope: sub
        derefAliases: never
        filter: (objectclass=inetOrgPerson)
        pageSize: 0
    userNameAttributes: [ mail ] <4>
    groupMembershipAttributes: [ ""memberOf:1.2.840.113556.1.4.1941:"" ] <5>
----
<1> `groupsQuery` filters cannot be specified. The `groupsQuery` base DN and scope
values are ignored. `groupsQuery` must set a valid `derefAliases`.
<2> The attribute that uniquely identifies a group on the LDAP server. It must be set to `dn`.
<3> The attribute to use as the name of the group.
<4> The attribute to use as the name of the user in the {product-title} group
record. `mail` or `sAMAccountName` are preferred choices in most installations.
<5> The attribute on the user that stores the membership information. Note the use
of https://msdn.microsoft.com/en-us/library/aa746475(v=vs.85).aspx[`LDAP_MATCHING_RULE_IN_CHAIN`].

To run sync with the *_augmented_active_directory_config_nested.yaml_* file:

----
$ oc adm groups sync \\
    'cn=admins,ou=groups,dc=example,dc=com' \\
    --sync-config=augmented_active_directory_config_nested.yaml \\
    --confirm
----

[NOTE]
====
You must explicitly
xref:../install_config/syncing_groups_with_ldap.adoc#running-ldap-sync[whitelist]
the `cn=admins,ou=groups,dc=example,dc=com` group.
====

{product-title} creates the following group record as a result of the above sync
operation:

.OpenShift group created by using the *_augmented_active_directory_config_nested.yaml_* file
[source,yaml]
----
apiVersion: user.openshift.io/v1
kind: Group
metadata:
  annotations:
    openshift.io/ldap.sync-time: 2015-10-13T10:08:38-0400 <1>
    openshift.io/ldap.uid: cn=admins,ou=groups,dc=example,dc=com <2>
    openshift.io/ldap.url: LDAP_SERVER_IP:389 <3>
  creationTimestamp:
  name: admins <4>
users: <5>
- jane.smith@example.com
- jim.adams@example.com
----
<1> The last time this {product-title} group was synchronized with the LDAP server, in ISO 6801 format.
<2> The unique identifier for the group on the LDAP server.
<3> The IP address and host of the LDAP server where this group's record is stored.
<4> The name of the group as specified by the sync file.
<5> The users that are members of the group, named as specified by the sync file.
Note that members of nested groups are included since the group membership was
flattened by the Microsoft Active Directory Server.

[[sync-ldap-configuration]]
== LDAP sync configuration specification

The object specification for the configuration file is below.  Note that the different schema
objects have different fields.  For example, xref:sync-ldap-v1-activedirectoryconfig[v1.ActiveDirectoryConfig] has no `groupsQuery`
field whereas xref:sync-ldap-v1-rfc2307config[v1.RFC2307Config] and xref:sync-ldap-v1-augmentedactivedirectoryconfig[v1.AugmentedActiveDirectoryConfig] both do.

[IMPORTANT]
====
There is no support for binary attributes. All attribute data coming from the
LDAP server must be in the format of a UTF-8 encoded string. For example, never
use a binary attribute, such as `objectGUID`, as an ID attribute. You must use
string attributes, such as `sAMAccountName` or `userPrincipalName`, instead.
====

[[sync-ldap-v1-ldapsyncconfig]]
=== v1.LDAPSyncConfig

`LDAPSyncConfig` holds the necessary configuration options to define an LDAP
group sync.

[options=""header""]
|===
|Name |Description |Schema

|`kind`
|String value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: link:https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#types-kinds[]
|string

|`apiVersion`
|Defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: link:https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#resources[]
|string

|`url`
|Host is the scheme, host and port of the LDAP server to connect to: `scheme://host:port`
|string

|`bindDN`
|Optional DN to bind to the LDAP server with.
|string

|`bindPassword`
|Optional password to bind with during the search phase. |xref:sync-ldap-v1-stringsource[v1.StringSource]

|`insecure`
|If `true`, indicates the connection should not use TLS. Cannot be set to true with a URL scheme of `ldaps://` If `false`, `ldaps://` URLs connect using TLS, and `ldap://` URLs are upgraded to a TLS connection using StartTLS as specified in link:https://tools.ietf.org/html/rfc2830[].
|boolean

|`ca`
|Optional trusted certificate authority bundle to use when making requests to the server. If empty, the default system roots are used.
|string

|`groupUIDNameMapping`
|Optional direct mapping of LDAP group UIDs to {product-title} group names.
|object

|`rfc2307`
|Holds the configuration for extracting data from an LDAP server set up in a fashion similar to RFC2307: first-class group and user entries, with group membership determined by a multi-valued attribute on the group entry listing its members.
|xref:sync-ldap-v1-rfc2307config[v1.RFC2307Config]

|`activeDirectory`
|Holds the configuration for extracting data from an LDAP server set up in a fashion similar to that used in Active Directory: first-class user entries, with group membership determined by a multi-valued attribute on members listing groups they are a member of.
|xref:sync-ldap-v1-activedirectoryconfig[v1.ActiveDirectoryConfig]

|`augmentedActiveDirectory`
|Holds the configuration for extracting data from an LDAP server set up in a fashion similar to that used in Active Directory as described above, with one addition: first-class group entries exist and are used to hold metadata but not group membership.
|xref:sync-ldap-v1-augmentedactivedirectoryconfig[v1.AugmentedActiveDirectoryConfig]
|===

[[sync-ldap-v1-stringsource]]
=== v1.StringSource

`StringSource` allows specifying a string inline, or externally via environment
variable or file. When it contains only a string value, it marshals to a simple
JSON string.

[options=""header""]
|===
|Name |Description |Schema

|`value`
|Specifies the cleartext value, or an encrypted value if `keyFile` is specified.
|string

|`env`
|Specifies an environment variable containing the cleartext value, or an
encrypted value if the `keyFile` is specified.
|string

|`file`
|References a file containing the cleartext value, or an encrypted value if a `keyFile` is specified.
|string

|`keyFile`
|References a file containing the key to use to decrypt the value.
|string
|===

[[sync-ldap-v1-ldapquery]]
=== v1.LDAPQuery

`LDAPQuery` holds the options necessary to build an LDAP query.

[options=""header""]
|===
|Name |Description |Schema

|`baseDN`
|DN of the branch of the directory where all searches should start from.
|string

|`scope`
|The (optional) scope of the search. Can be `base` (only the base object), `one`
(all objects on the base level), `sub` (the entire subtree). Defaults to `sub`
if not set.
|string

|`derefAliases`
|The (optional) behavior of the search with regards to alisases. Can be `never`
(never dereference aliases), `search` (only dereference in searching), `base`
(only dereference in finding the base object), `always` (always dereference).
Defaults to `always` if not set.
|string

|`timeout`
|Holds the limit of time in seconds that any request to the server can remain outstanding before the wait for a response is given up. If this is `0`, no client-side limit is imposed.
|integer

|`filter`
|A valid LDAP search filter that retrieves all relevant entries from the LDAP server with the base DN.
|string

|`pageSize`
|Maximum preferred page size, measured in LDAP entries. A page size of `0` means no paging will be done.
|integer
|===

[[sync-ldap-v1-rfc2307config]]
=== v1.RFC2307Config

`RFC2307Config` holds the necessary configuration options to define how an LDAP
group sync interacts with an LDAP server using the RFC2307 schema.

[options=""header""]
|===
|Name |Description |Schema

|`groupsQuery`
|Holds the template for an LDAP query that returns group entries.
|xref:sync-ldap-v1-ldapquery[v1.LDAPQuery]

|`groupUIDAttribute`
|Defines which attribute on an LDAP group entry will be interpreted as its unique identifier. (`ldapGroupUID`)
|string

|`groupNameAttributes`
|Defines which attributes on an LDAP group entry will be interpreted as its name to use for an {product-title} group.
|string array

|`groupMembershipAttributes`
|Defines which attributes on an LDAP group entry will be interpreted as its members. The values contained in those attributes must be queryable by your `UserUIDAttribute`.
|string array

|`usersQuery`
|Holds the template for an LDAP query that returns user entries.
|xref:sync-ldap-v1-ldapquery[v1.LDAPQuery]

|`userUIDAttribute`
|Defines which attribute on an LDAP user entry will be interpreted as its unique identifier. It must correspond to values that will be found from the `GroupMembershipAttributes`.
|string

|`userNameAttributes`
|Defines which attributes on an LDAP user entry will be used, in order, as its {product-title} user name. The first attribute with a non-empty value is used. This should match your `PreferredUsername` setting for your `LDAPPasswordIdentityProvider`. The attribute to use as the name of the user in the {product-title} group
record. `mail` or `sAMAccountName` are preferred choices in most installations.
|string array

|`tolerateMemberNotFoundErrors`
|Determines the behavior of the LDAP sync job when missing user entries are encountered. If `true`, an LDAP query for users that does not find any will be tolerated and an only and error will be logged. If `false`, the LDAP sync job will fail if a query for users doesn't find any. The default value is 'false'. Misconfigured LDAP sync jobs with this flag set to 'true' can cause group membership to be removed, so it is recommended to use this flag with caution.
|boolean

|`tolerateMemberOutOfScopeErrors`
|Determines the behavior of the LDAP sync job when out-of-scope user entries are encountered. If `true`, an LDAP query for a user that falls outside of the base DN given for the all user query will be tolerated and only an error will be logged. If `false`, the LDAP sync job will fail if a user query would search outside of the base DN specified by the all user query. Misconfigured LDAP sync jobs with this flag set to `true` can result in groups missing users, so it is recommended to use this flag with caution.
|boolean
|===

[[sync-ldap-v1-activedirectoryconfig]]
=== v1.ActiveDirectoryConfig

`ActiveDirectoryConfig` holds the necessary configuration options to define how
an LDAP group sync interacts with an LDAP server using the Active Directory
schema.

[options=""header""]
|===
|Name |Description |Schema

|`usersQuery`
|Holds the template for an LDAP query that returns user entries.
|xref:sync-ldap-v1-ldapquery[v1.LDAPQuery]

|`userNameAttributes`
|Defines which attributes on an LDAP user entry will be interpreted as its {product-title} user name. The attribute to use as the name of the user in the {product-title} group
record. `mail` or `sAMAccountName` are preferred choices in most installations.
|string array

|`groupMembershipAttributes`
|Defines which attributes on an LDAP user entry will be interpreted as the groups it is a member of.
|string array
|===

[[sync-ldap-v1-augmentedactivedirectoryconfig]]
=== v1.AugmentedActiveDirectoryConfig

`AugmentedActiveDirectoryConfig` holds the necessary configuration options to
define how an LDAP group sync interacts with an LDAP server using the augmented
Active Directory schema.

[options=""header""]
|===
|Name |Description |Schema

|`usersQuery`
|Holds the template for an LDAP query that returns user entries.
|xref:sync-ldap-v1-ldapquery[v1.LDAPQuery]

|`userNameAttributes`
|Defines which attributes on an LDAP user entry will be interpreted as its {product-title} user name. The attribute to use as the name of the user in the {product-title} group
record. `mail` or `sAMAccountName` are preferred choices in most installations.
|string array

|`groupMembershipAttributes`
|Defines which attributes on an LDAP user entry will be interpreted as the groups it is a member of.
|string array

|`groupsQuery`
|Holds the template for an LDAP query that returns group entries.
|xref:sync-ldap-v1-ldapquery[v1.LDAPQuery]

|`groupUIDAttribute`
|Defines which attribute on an LDAP group entry will be interpreted as its unique identifier. (`ldapGroupUID`)
|string

|`groupNameAttributes`
|Defines which attributes on an LDAP group entry will be interpreted as its name to use for an {product-title} group.
|string array
|===
",12054,True,2602.1515708421757,median
"ifdef::env-github[]
NOTE: Release notes are best read in our documentation at
https://www.elastic.co/guide/en/apm/agent/python/current/release-notes.html[elastic.co]
endif::[]

////
[[release-notes-x.x.x]]
==== x.x.x - YYYY/MM/DD

[float]
===== Breaking changes

[float]
===== Features
* Cool new feature: {pull}2526[#2526]

[float]
===== Bug fixes
////

//=== Unreleased

// Unreleased changes go here
// When the next release happens, nest these changes under the ""Python Agent version 6.x"" heading
//[float]
//===== Features
//
//
//[float]
//===== Bug fixes


[[release-notes-6.x]]
=== Python Agent version 6.x

[[release-notes-6.7.2]]
=== 6.7.2 - 2021-12-07

[float]
===== Bug fixes
* fix AttributeError in sync instrumentation of httpx {pull}1423[#1423]
* add setting to disable span compression, default to disabled {pull}1429[#1429]

[[release-notes-6.7.1]]
=== 6.7.1 - 2021-11-29

[float]
===== Bug fixes

* fix an issue with Sanic exception tracking {pull}1414[#1414]
* asyncpg: Limit SQL queries in context data to 10000 characters {pull}1416[#1416]


[[release-notes-6.7.0]]
=== 6.7.0 - 2021-11-17

[float]
===== Features

* Add support for Sanic framework {pull}1390[#1390]

[float]
===== Bug fixes

* fix compatibility issues with httpx 0.21 {pull}1403[#1403]
* fix `span_compression_exact_match_max_duration` default value {pull}1407[#1407]

[[release-notes-6.6.3]]
==== 6.6.3 - 2021-11-15

[float]
===== Bug fixes

 * fix an issue with `metrics_sets` configuration referencing the `TransactionMetricSet` removed in 6.6.2 {pull}1397[#1397]

[[release-notes-6.6.2]]
==== 6.6.2 - 2021-11-10

[float]
===== Bug fixes

* Fix an issue where compressed spans would count against `transaction_max_spans` {pull}1377[#1377]
* Make sure HTTP connections are not re-used after a process fork {pull}1374[#1374]
* Fix an issue with psycopg2 instrumentation when multiple hosts are defined {pull}1386[#1386]
* Update the `User-Agent` header to the new https://github.com/elastic/apm/pull/514[spec] {pull}1378[#1378]
* Improve status_code handling in AWS Lambda integration {pull}1382[#1382]
* Fix `aiohttp` exception handling to allow for non-500 responses including `HTTPOk` {pull}1384[#1384]
* Force transaction names to strings {pull}1389[#1389]

[float]
===== Other

* Remove unused `http.request.socket.encrypted` context field {pull}1332[#1332]
* Remove unused transaction metrics (APM Server handles these metrics instead) {pull}1388[#1388]

[[release-notes-6.6.1]]
==== 6.6.1 - 2021-11-02

[float]
===== Bug fixes

* Fix some context fields and metadata handling in AWS Lambda support {pull}1368[#1368]

[[release-notes-6.6.0]]
==== 6.6.0 - 2021-10-18

[float]
===== Features

* Add experimental support for AWS lambda instrumentation {pull}1193[#1193]
* Add support for span compression {pull}1321[#1321]
* Auto-infer destination resources for easier instrumentation of new resources {pull}1359[#1359]
* Add support for dropped span statistics {pull}1327[#1327]

[float]
===== Bug fixes

* Ensure that Prometheus histograms are encoded correctly for APM Server {pull}1354[#1354]
* Remove problematic (and duplicate) `event.dataset` from logging integrations {pull}1365[#1365]
* Fix for memcache instrumentation when configured with a unix socket {pull}1357[#1357]


[[release-notes-6.5.0]]
==== 6.5.0 - 2021-10-04

[float]
===== Features

* Add instrumentation for Azure Storage (blob/table/fileshare) and Azure Queue {pull}1316[#1316]

[float]
===== Bug fixes

* Improve span coverage for `asyncpg` {pull}1328[#1328]
* aiohttp: Correctly pass custom client to tracing middleware {pull}1345[#1345]
* Fixed an issue with httpx instrumentation {pull}1337[#1337]
* Fixed an issue with Django 4.0 removing a private method {pull}1347[#1347]


[[release-notes-6.4.0]]
==== 6.4.0 - 2021-08-31

[float]
===== Features

* Rename the experimental `log_ecs_formatting` config to `log_ecs_reformatting` {pull}1300[#1300]
* Add support for Prometheus histograms {pull}1165[#1165]

[float]
===== Bug fixes

* Fixed cookie sanitization when Cookie is capitalized {pull}1301[#1301]
* Fix a bug with exception capturing for bad UUIDs {pull}1304[#1304]
* Fix potential errors in json serialization {pull}1203[#1203]
* Fix an issue with certain aioredis commands {pull}1308[#1308]

[[release-notes-6.3.3]]
==== 6.3.3 - 2021-07-14

[float]
===== Bug fixes

* ensure that the elasticsearch instrumentation handles DroppedSpans correctly {pull}1190[#1190]

[[release-notes-6.3.2]]
==== 6.3.2 - 2021-07-07

[float]
===== Bug fixes

* Fix handling of non-http scopes in Starlette/FastAPI middleware {pull}1187[#1187]

[[release-notes-6.3.1]]
==== 6.3.1 - 2021/07/07

[float]
===== Bug fixes

* Fix issue with Starlette/FastAPI hanging on startup {pull}1185[#1185]

[[release-notes-6.3.0]]
==== 6.3.0 - 2021/07/06

[float]
===== Features

* Add additional context information about elasticsearch client requests {pull}1108[#1108]
* Add `use_certifi` config option to allow users to disable `certifi` {pull}1163[#1163]

[float]
===== Bug fixes

* Fix for Starlette 0.15.0 error collection {pull}1174[#1174]
* Fix for Starlette static files {pull}1137[#1137]

[[release-notes-6.2.3]]
==== 6.2.3 - 2021/06/28

[float]
===== Bug fixes
 * suppress the default_app_config attribute in Django 3.2+ {pull}1155[#1155]
 * bump log level for multiple set_client calls to WARNING {pull}1164[#1164]
 * fix issue with adding disttracing to SQS messages when dropping spans {pull}1170[#1170]

[[release-notes-6.2.2]]
==== 6.2.2 - 2021/06/07

[float]
===== Bug fixes
 * Fix an attribute access bug introduced in 6.2.0 {pull}1149[#1149]

[[release-notes-6.2.1]]
==== 6.2.1 - 2021/06/03

[float]
===== Bug fixes
 * catch and log exceptions in interval timer threads {pull}1145[#1145]

[[release-notes-6.2.0]]
==== 6.2.0 - 2021/05/31

[float]
===== Features
 * Added support for aioredis 1.x {pull}1082[#2526]
 * Added support for aiomysql {pull}1107[#1107]
 * Added Redis pub/sub instrumentation {pull}1129[#1129]
 * Added specific instrumentation for AWS SQS {pull}1123[#1123]

[float]
===== Bug fixes
 * ensure metrics are flushed before agent shutdown {pull}1139[#1139]
 * added safeguard for exceptions in processors {pull}1138[#1138]
 * ensure sockets are closed which were opened for cloud environment detection {pull}1134[#1134]

[[release-notes-6.1.3]]
==== 6.1.3 - 2021/04/28

[float]
===== Bug fixes
 * added destination information to asyncpg instrumentation {pull}1115[#1115]
 * fixed issue with collecting request meta data with Django REST Framework {pull}1117[#1117]
 * fixed httpx instrumentation for newly released httpx 0.18.0 {pull}1118[#1118]


[[release-notes-6.1.2]]
==== 6.1.2 - 2021/04/14

[float]
===== Bug fixes

 * fixed issue with empty transaction name for the root route with Django {pull}1095[#1095]
 * fixed on-the-fly initialisation of Flask apps {pull}1099[#1099]

[[release-notes-6.1.1]]
==== v6.1.1 - 2021/04/08

[float]
===== Bug fixes

 * fixed a validation issue with the newly introduced instrumentation for S3, SNS and DynamoDB {pull}1090[#1090]

[[release-notes-6.1.0]]
==== v6.1.0 - 2021/03/31

[float]
===== Features

* Add global access to Client singleton object at `elasticapm.get_client()` {pull}1043[#1043]
* Add `log_ecs_formatting` config option {pull}1058[#1058] {pull}1063[#1063]
* Add instrumentation for httplib2 {pull}1031[#1031]
* Add better instrumentation for some AWS services (S3, SNS, DynamoDB) {pull}1054[#1054]
* Added beta support for collecting metrics from prometheus_client {pull}1083[#1083]


[float]
===== Bug fixes

* Fix for potential `capture_body: error` hang in Starlette/FastAPI {pull}1038[#1038]
* Fix a rare error around processing stack frames {pull}1012[#1012]
* Fix for Starlette/FastAPI to correctly capture request bodies as strings {pull}1042[#1041]
* Fix transaction names for Starlette Mount routes {pull}1037[#1037]
* Fix for elastic excepthook arguments {pull}1050[#1050]
* Fix issue with remote configuration when resetting config values {pull}1068[#1068]
* Use a label for the elasticapm Django app that is compatible with Django 3.2 validation {pull}1064[#1064]
* Fix an issue with undefined routes in Starlette {pull}1076[#1076]

[[release-notes-6.0.0]]
==== v6.0.0 - 2021/02/01

[float]
===== Breaking changes

* Python 2.7 and 3.5 support has been deprecated. The Python agent now requires Python 3.6+ {pull}1021[#1021]
* No longer collecting body for `elasticsearch-py` `update` and `delete_by_query` {pull}1013[#1013]
* Align `sanitize_field_names` config with the
  https://github.com/elastic/apm/blob/3fa78e2a1eeea81c73c2e16e96dbf6b2e79f3c64/specs/agents/sanitization.md[cross-agent spec].
  If you are using a non-default `sanitize_field_names`, surrounding each of your entries with stars (e.g.
  `*secret*`) will retain the old behavior. {pull}982[#982]
* Remove credit card sanitization for field values. This improves performance, and the security value of this check was
  dubious anyway. {pull}982[#982]
* Remove HTTP querystring sanitization. This improves performance, and is meant to standardize behavior across the
  agents, as defined in https://github.com/elastic/apm/pull/334. {pull}982[#982]
* Remove `elasticapm.tag()` (deprecated since 5.0.0) {pull}1034[#1034]

[float]
===== Bug fixes

* Fix for GraphQL span spamming from scalar fields with required flag {pull}1015[#1015]

[[release-notes-5.x]]
=== Python Agent version 5.x


[[release-notes-5.10.1]]
==== v5.10.1 - 2021/01/20

[float]
===== Bug fixes

* Fix for custom serializers in elasticsearch-py {pull}998[#998]
* Fix large query truncation in psycopg2 {pull}994[#994]
* Fix memory metrics reporting when `memory.usage_in_bytes` is unavailable {pull}987[#987]
* Fix for Starlette/FastAPI integration to properly obey `enabled` config {pull}1000[#1000]

[[release-notes-5.10.0]]
==== v5.10.0 - 2020/11/18
[float]
===== Features

* Implement ""sample_rate"" property for transactions and spans, and propagate through tracestate {pull}891[#891]
* Add support for callbacks on config changes {pull}912[#912]
* Override `sys.excepthook` to catch all exceptions {pull}943[#943]
* Implement `log_level` config (supports central config) {pull}946[#946]
* Implement `transaction_ignore_urls` config (supports central config) {pull}923[#923]
* Add public API to retrieve trace parent header {pull}956[#956]
* Added support for cgroup memory metrics {pull}846[#846]


[float]
===== Bug fixes

* Fix to collect the whole query body in `elasticsearch-py` {pull}940[#940]
* Fix for GraphQL transaction naming {pull}881[#881]
* Ensure that query string max length is maintained after sanitization {pull}968[#968]
* Adapted kubernetes kubepod regex for detecting kubernetes metadata {pull}958[#958]
* Updated Starlette integration to use the route as transaction name if possible {pull}957[#957]

[[release-notes-5.9.0]]
==== v5.9.0 - 2020/09/23

[float]
===== Features

* Add instrumentation support for https://github.com/encode/httpx[`httpx`] and https://github.com/encode/httpcore[`httpcore`] {pull}898[#898]
* Implement ""outcome"" property for transactions and spans {pull}899[#899]
* Add support for `asyncpg` {pull}889[#889]

[float]
===== Bug fixes

* Fix validation of config to properly require `required` config items. {pull}927[#927]

[[release-notes-5.8.1]]
==== v5.8.1 - 2020/07/13

[float]
===== Bug fixes

* Updated CLOUD_PROVIDER config to allow for new options defined in https://github.com/elastic/apm/issues/289[#289] {pull}878[#878]
* Fixed a bug in AWS metadata collection on docker containers in AWS Elastic Beanstalk {pull}884[#884]
* Fixed a bug in local variable serialization that could occur in multi-threaded applications {pull}885[#885]

[[release-notes-5.8.0]]
==== v5.8.0 - 2020/06/30

[float]
===== Features

* Added graphql (graphene) support {pull}850[#850]
* Collect cloud provider metadata {pull}826[#826]
* Added `sanitize_field_names` config {pull}860[#860]

[float]
===== Bug fixes

* Fix header fetching for ASGI implementations {pull}856[#856]


[[release-notes-5.7.0]]
==== v5.7.0 - 2020/06/11

[float]
===== Features

 * capture number of affected rows for INSERT/UPDATE/DELETE SQL queries {pull}614[#614]
 * Added instrumentation for AsyncElasticsearch {pull}843[#843]

[float]
===== Bug fixes

* Added error handling around frame processing in Django {pull}837[#837]
* Limit SQL queries in context data to 10000 characters {pull}842[#842]
* Omit the ""sync"" property on spans by default {pull}854[#854]
* Update the pid/ppid in transport metadata when they change {pull}825[#825]
* Added better error handling around closing the transport {pull}838[#838]
* Fixed an issue with the django admin command not detecting misconfigured server urls {pull}855[#855]


[[release-notes-5.6.0]]
==== v5.6.0 - 2020/05/06

[float]
===== New features
 * Added SERVICE_NODE_NAME config {pull}592[#592]
 * Added instrumentation support for https://github.com/pinterest/pymemcache[`pymemcache`] {pull}812[#812]
 * Added new configuration options `enabled` and `recording` {pull}790[#790]

[float]
===== Bug fixes
 * Fixed an issue with metrics collection raising RuntimeErrors {pull}802[#802]
 * Fixed an issue with getting extended destination data from pymongo {pull}797[#797]
 * Fixed an issue with Tornado instrumentation when Tornado isn't the ""main"" framework {pull}813[#813]
 * Fixed an issue with streaming requests being consumed by the agent even if capture_body is disabled {pull}817[#817]

[float]
===== Pending Deprecations

 * Python 2.7 suppot will be dropped in version 6.0 of the agent.

[[release-notes-5.5.2]]
==== v5.5.2 - 2020/03/20

[float]
===== Bug fixes
* Fixed an issue with Redis using unix domain sockets and destination information {pull}766[#766]

[[release-notes-5.5.1]]
==== v5.5.1 - 2020/03/19

[float]
===== Bug fixes
* Fixed Starlette middleware when capturing request body while the content-type header is absent {pull}763[#763]

[[release-notes-5.5.0]]
==== v5.5.0 - 2020/03/19

[float]
===== Features
* Added destination information to database/HTTP spans, used for service maps {pull}618[#618]

[float]
===== Deprecations

 * *Python 3.4 is no longer supported.*


[[release-notes-5.4.3]]
==== v5.4.3 - 2020/02/27

https://github.com/elastic/apm-agent-python/compare/v5.4.2\\...v5.4.3[Check the diff]

[float]
===== Bug fixes

 * fixed a bug in our aiohttp.client support if used with a yarl URL {pull}733[#733]

[[release-notes-5.4.2]]
==== v5.4.2 - 2020/02/18

https://github.com/elastic/apm-agent-python/compare/v5.4.1\\...v5.4.2[Check the diff]

[float]
===== Bug fixes

 * fixed a bug in our celery implementation related to the threading refactor in 5.4.0 {pull}724[#724]

[[release-notes-5.4.1]]
==== v5.4.1 - 2020/02/18

https://github.com/elastic/apm-agent-python/compare/v5.4.0\\...v5.4.1[Check the diff]

[float]
===== Bug fixes

 * fixed an issue with a DEBUG log message raising an error in some cases {pull}722[#722]

[[release-notes-5.4.0]]
==== v5.4.0 - 2020/02/17

https://github.com/elastic/apm-agent-python/compare/v5.3.3\\...v5.4.0[Check the diff]

[float]
===== Deprecations

This will be the last minor release to support the following versions:

 * Python 3.4
 * Django 1.8, 1.9 and 1.10
 * Flask < 1.0

In addition, as of this release we only supported capturing extended
information on Elasticsearch queries when using keyword arguments with the
elasticsearch-py API. This is in keeping with the
https://elasticsearch-py.readthedocs.io/en/master/api.html#api-documentation[upstream policy]
of positional arguments being unsupported. {pull}697[#697]

[float]
===== New Features

 * Refactored spawning of background threads {pull}636[#636]
 * Added support for aiohttp client and server {pull}659[#659]
 * Added support for tornado web framework {pull}661[#661]
 * Added support for starlette/fastapi {pull}694[#694]
 * Added support for W3C `traceparent` and `tracestate` headers {pull}660[#660]
 * Added Django 3.0 and Flask 1.1 to the support matrix {pull}667[#667]
 * Added support for aiopg {pull}668[#668]
 * Use Span ID as parent ID in errors if an error happens inside a span {pull}669[#669]
 * Added experimental support for API Key authentication {pull}679[#679]

[float]
===== Bug fixes

 * introduced workaround to avoid instrumenting twice in rare cases {pull}708[#708]


[[release-notes-5.3.3]]
==== v5.3.3 - 2020/01/14

https://github.com/elastic/apm-agent-python/compare/v5.3.2\\...v5.3.3[Check the diff]

[float]
===== Bug fixes

 * Fixed an issue with OpenTracing bridge and dropped spans {pull}687[#687]
 * Fixed bug that would make the agent ignore the `hostname` configuration setting {pull}689[#689]

[[release-notes-5.3.2]]
==== v5.3.2 - 2019/11/25

https://github.com/elastic/apm-agent-python/compare/v5.3.1\\...v5.3.2[Check the diff]

[float]
===== Bug fixes

 * Added support for IPv6 address format when parsing urls {pull}649[#649]

[[release-notes-5.3.1]]
==== v5.3.1 - 2019/11/18

https://github.com/elastic/apm-agent-python/compare/v5.3.0\\...v5.3.1[Check the diff]

[float]
===== New Features

* Added support for shortening dicts in local variables {pull}638[#638]

[[release-notes-5.3.0]]
==== v5.3.0 - 2019/11/14

https://github.com/elastic/apm-agent-python/compare/v5.2.3\\...v5.3.0[Check the diff]

[float]
===== New Features

* Added instrumentation for mysql-connector and pymysql {pull}603[#603]
* Implemented stack_trace_limit configuration option {pull}623[#623]
* Autoinsert tracing middleware in django settings {pull}625[#625]

[float]
===== Bug fixes

* Fixed issue with transactions not being captured when errors occur in Flask {pull}635[#635]

[[release-notes-5.2.3]]
==== v5.2.3 - 2019/11/13

https://github.com/elastic/apm-agent-python/compare/v5.2.2\\...v5.2.3[Check the diff]

[float]
===== Bug fixes

* Ensure that metrics with value 0 are not collected if they have the `reset_on_collect` flag set {pull}615[#615]
* Unwrap postgres cursor for newly introduced psycopg2 extensions {pull}621[#621]
* Fix pod ID for kubernetes when using the systemd cgroup driver {pull}631[#631]

[[release-notes-5.2.2]]
==== v5.2.2 - 2019/10/16

https://github.com/elastic/apm-agent-python/compare/v5.2.1\\...v5.2.2[Check the diff]

[float]
===== Bug fixes
* Fixed an issue where a `cpu_total` of `0` could cause an exception {pull}610[#610], {pull}611[#611]

[[release-notes-5.2.1]]
==== v5.2.1 - 2019/10/09

https://github.com/elastic/apm-agent-python/compare/v5.2.0\\...v5.2.1[Check the diff]

[float]
===== Bug fixes
* Fixed an issue with DroppedSpans and logging integration {pull}602[#602]
* Fixed an issue with processors not being applied to chained exceptions {pull}604[#604]

[[release-notes-5.2.0]]
==== v5.2.0 - 2019/10/02

https://github.com/elastic/apm-agent-python/compare/v5.1.2\\...v5.2.0[Check the diff]

[float]
===== New Features
* Added automatic tagging of LogRecord objects with transaction, trace, and span IDs via a LogRecordFactory (Python 3.2+) {pull}520[#520], {pull}586[#586]
* Added `logging` filter and record factory for adding transaction, trace, and span IDs {pull}520[#520], {pull}586[#586]
* Added `structlog` processor for adding transaction, trace, and span IDs {pull}520[#520], {pull}586[#586]
* Added new public API calls for getting transaction, trace, and span IDs {pull}520[#520], {pull}586[#586]
* Added support for chained exceptions in Python 3 {pull}596[#596].
Note that chained exceptions will be captured and stored in Elasticsearch, but not yet
visualized in the APM UI. The UI component will be released in an upcoming Kibana release (7.5 or later).
* Added support for using `structlog` for agent logging {pull}591[#591]

[float]
===== Bug fixes
* Drop events immediately if a processor returns a falsy value {pull}585[#585]

[[release-notes-5.1.2]]
==== v5.1.2 - 2019/09/04

https://github.com/elastic/apm-agent-python/compare/v5.1.1\\...v5.1.2[Check the diff]

[float]
===== Bugfixes
* Fixed an issue with http server_url and `'VERIFY_SERVER_CERT': False` {pull}570[#570], {pull}578[#578]
* Fixed instrumenting of psycopg2 when using their context manager interface {pull}577[#577], {pull}580[#580]
* Fixed zerorpc tests {pull}581[#581]
* Fixed to correctly check if gevent has patched threading.local {pull}579[#579]

[[release-notes-5.1.1]]
==== v5.1.1 - 2019/08/22

https://github.com/elastic/apm-agent-python/compare/v5.1.0\\...v5.1.1[Check the diff]

[float]
===== Bug fixes
* Fixed an issue with empty responses from APM Server's config endpoint {pull}562[#562], {pull}563[#563]
* Fixed Windows tests by avoiding time.sleep in breakdown metrics tests {pull}537[#537], {pull}550[#550]
* Fixed container ID matching to match CloudFoundry Garden container IDs {pull}523[#523], {pull}564[#564]
* Fixed an issue in the urllib instrumentation if no port is set {pull}567[#567]

[float]
===== Other
* Added Python 3.8 RC to the test matrix {pull}565[#565]

[[release-notes-5.1.0]]
==== v5.1.0 - 2019/08/14

https://github.com/elastic/apm-agent-python/compare/v5.0.0\\...v5.1.0[Check the diff]

[float]
===== Security issues

* This release fixes CVE-2019-7617

[float]
===== New Features

* Added support for global labels which will be applied to every transaction/error/metric {pull}549[#549]
* Added support for `NO_PROXY` environment variable {pull}458[#458], {pull}551[#551]

[float]
===== Bugfixes

* Fixed an issue with using callables in set_context with unsampled transactions {pull}541[#541], {pull}542[#542]
* Limited the length of error.culprit to 1024 characters {pull}491[#491], {pull}543[#543]
* Fixed an issue with the `instrument` config option {pull}546[#546], {pull}547[#547]
* Limited the amount of distinct metrics to 1000 {pull}540[#540], {pull}544[#544]

[[release-notes-5.0.0]]
==== v5.0.0 - 2019/07/31

https://github.com/elastic/apm-agent-python/compare/v4.2.2\\...v5.0.0[Check the diff]

[float]
===== Breaking changes

* Implemented type/subtype/action hierachy for spans. Ensure that you run at least APM Server 6.6 {pull}377[#377]
* renamed tags to labels and changed API. The old API remains for backwards compatibility until 6.0 of the agent {pull}538[#538]

[float]
===== Other changes

* Added support for recording breakdown metrics {pull}535[#535]
* Added support for central config management {pull}511[#511]
* Added instrumentation for `urllib2` (Python 2) / `urllib.request` (Python 3) {pull}464[#464]
* Added `disable_metrics` setting {pull}399[#399]
* Updated elasticsearch instrumentation for 7.x {pull}482[#482], {pull}483[#483]
* Fixed an issue with opentracing-python 2.1 {pull}471[#471]
* Fixed an issue with certificate pinning {pull}497[#497]
* Lowered log level of transport success messages {pull}527[#527], {pull}531[#531]

[[release-notes-4.x]]
=== Python Agent version 4.x

[[release-notes-4.2.2]]
==== v4.2.2 - 2019/04/10

https://github.com/elastic/apm-agent-python/compare/v4.2.1\\...v4.2.2[Check the diff]

* Fixed an issue with Celery and the prefork worker pool {pull}444[#444]
* Fixed an issue when running uwsgi without a master process {pull}446[#446]
* Fixed an issue with gevent/eventlet on Python 3.7 {pull}451[#451], {pull}454[#454]
* Introduced `IntervalTimer` and use it instead of `threading.Timer` {pull}452[#452]
* Added license header check as pre-commit hook {pull}456[#456]

[[release-notes-4.2.1]]
==== v4.2.1 - 2019/03/22

https://github.com/elastic/apm-agent-python/compare/v4.2.0\\...v4.2.1[Check the diff]

* Fixed an issue with the certificate pinning feature introduced in 4.2.0 {pull}433[#433], {pull}434[#434]
* Fixed incompatibility with eventlet introduced in 4.2.0 {pull}435[#435], {pull}436[#436]

[[release-notes-4.2.0]]
==== v4.2.0 - 2019/03/20

https://github.com/elastic/apm-agent-python/compare/v4.1.0\\...v4.2.0[Check the diff]

* Implemented a new transport queue, which should avoid certain deadlock scenarios {pull}411[#411]
* Implemented server certificate pinning {pull}405[#405]
* Moved context.url to context.http.url for requests/urllib3 spans {pull}393[#393], {pull}394[#394]
* Added support for using route as transaction name in Django 2.2+ {pull}86[#86], {pull}396[#396]
* Added some randomness to time between requests to APM Server {pull}426[#426]
* Fixed an issue with custom user models in Django using non-string usernames {pull}397[#397], {pull}398[#398]
* Fixed an issue with sending kubernetes metadata to the API {pull}401[#401], {pull}402[#402]
* Fixed an issue with parsing /proc/stat in RHEL/centos 6 {pull}406[#406], {pull}407[#407]
* Added copyright header to all files, and a CI check {pull}429[#429]

[[release-notes-4.1.0]]
==== v4.1.0 - 2019/01/29

https://github.com/elastic/apm-agent-python/compare/v4.0.3\\...v4.1.0[Check the diff]

* Added support for collecting system and process metrics {pull}361[#361]
* Added an OpenTracing bridge {pull}388[#388]
* Added `transaction.sampled` to errors {pull}371[#371]
* Added `transaction.type` to errors {pull}391[#391]
* Added parsing of `/proc/self/cgroup` to capture container meta data {pull}352[#352]
* Added option to configure logging for Flask using a log level {pull}344[#344]
* Added `capture_headers` config option {pull}392[#392]

[[release-notes-4.0.3]]
==== v4.0.3 - 2018/12/24

https://github.com/elastic/apm-agent-python/compare/v4.0.2\\...v4.0.3[Check the diff]

* Implemented de-dotting of tag names and context keys {pull}353[#353]
* wrote a quickfix for the boto3/botocore instrumentation {pull}367[#367]
* Fixed an issue with psycopg2 and encoded strings {pull}366[#366]

[[release-notes-4.0.2]]
==== v4.0.2 - 2018/12/05

https://github.com/elastic/apm-agent-python/compare/v4.0.1\\...v4.0.2[Check the diff]

* Fixed another issue in the new v2 transport {pull}351[#351]

[[release-notes-4.0.1]]
==== v4.0.1 - 2018/11/16

https://github.com/elastic/apm-agent-python/compare/v4.0.0\\...v4.0.1[Check the diff]

* Fixed an issue with instrumenting redis-py 3.0+
* Fixed a multithreading issue that occurs when using threaded workers {pull}335[#335]

[[release-notes-4.0.0]]
==== v4.0.0 - 2018/11/14

https://github.com/elastic/apm-agent-python/compare/v3.0.2\\...v4.0.0[Check the diff]

**BREAKING** Version 4 of the agent implements a new wire protocol for communicating with
the APM Server. This format is only supported in *APM Server 6.5+*.

Further breaking changes:

* The undocumented `AsyncioHTTPTransport` has been removed.
* The `flush_interval` and `max_queue_size` settings have been removed.
* new settings introduced: `api_request_time` and `api_request_size`.
* Some settings now require a unit for duration or size. See documentation on
configuration for more information.
* The option to provide a custom date for exceptions and messages has been removed.

Other changes:
* on Python 3.7, use https://docs.python.org/3/library/contextvars.html[contextvars] instead of threadlocals for storing
current transaction and span. This is a necessary precursor for full asyncio support. {pull}291[#291]

[[release-notes-3.x]]
=== Python Agent version 3.x

[[release-notes-3.0.2]]
==== v3.0.2 - 2018/10/17

https://github.com/elastic/apm-agent-python/compare/v3.0.1\\...v3.0.2[Check the diff]

* Fixed an issue with detecting names of wrapped functions that are partials {pull}294[#294]
* Fixed a bug in Flask instrumentation that could appear together with FlaskAPI {pull}286[#286]

[[release-notes-3.0.1]]
==== v3.0.1 - 2018/08/30


https://github.com/elastic/apm-agent-python/compare/v3.0.0\\...v3.0.1[Check the diff]

* Added sanitization for `Set-Cookie` response headers {pull}264[#264]
* Added instrumentation for the non-standard `Connection.execute()` method for SQLite3 {pull}271[#271]
* Added ""authorization"" to list of sensitive keywords, to ensure that ""Authorization""
HTTP headers are properly sanitized {pull}275[#275]
* Taught the Logbook handler how to handle the `stack=False` option {pull}278[#278]
* Fixed a race condition with managing the timer-send thread {pull}279[#279]

[[release-notes-3.0.0]]
==== v3.0.0 - 2018/07/20


https://github.com/elastic/apm-agent-python/compare/v2.2.1\\...v3.0.0[Check the diff]

- adapted ""black"" code formatter for this repository {pull}262[#262]
- **BREAKING**: dropped support for Python 3.3 {pull}242[#242]
- **BREAKING**: changed order of precedence when evaluating configuration {pull}255[#255], {pull}261[#261]
- **BREAKING**: changed default value of `span_frames_min_duration` setting
from `-1` (always collect) to `5` (only collect for spans longer than 5 ms) {pull}243[#243]
- added instrumentation for pymssql {pull}241[#241]
- added instrumentation for pyodbc {pull}238[#238]

[[release-notes-2.x]]
=== Python Agent version 2.x

[[release-notes-2.2.1]]
==== v2.2.1 - 2018/06/13


https://github.com/elastic/apm-agent-python/compare/v2.2.0\\...v2.2.1[Check the diff]

- fixed an issue with Django Channels {pull}232[#232], {pull}233[#233]

[[release-notes-2.2.0]]
==== v2.2.0 - 2018/06/13


https://github.com/elastic/apm-agent-python/compare/v2.1.1\\...v2.2.0[Check the diff]

- introduced consistent logger name scheme for all elasticapm internal log messages {pull}212[#212]
- added instrumentation of cassandra-driver {pull}205[#205]
- added instrumentation of elasticsearch-py {pull}191[#191]
- added Flask 1.0 to the test matrix {pull}207[#207]
- fixed an issue with our minimalistic SQL parser and ""fully qualified"" table names {pull}206[#206]
- fixed issue with spans in Django’s `StreamingHTTPResponse` not being captured {pull}201[#201], {pull}202[#202]
- fixed issue with spans with Flask’s streaming response not being captured {pull}201[#201], {pull}202[#202]

**NOTE**: This will be the last release with support for Python 3.3.

[[release-notes-2.1.1]]
==== v2.1.1 - 2018/04/09


https://github.com/elastic/apm-agent-python/compare/v2.1.0\\...v2.1.1[Check the diff]

- fixed bug in Django management command that would be triggered on Django 1.10 or 1.11 while using the `MIDDLEWARE_CLASSES` setting {pull}186[#186], {pull}187[#187]
- fix an encoding issue with log messages that are hit in rare cases {pull}188[#188], {pull}189[#189]

[[release-notes-2.1.0]]
==== v2.1.0 - 2018/03/19


https://github.com/elastic/apm-agent-python/compare/v2.0.1\\...v2.1.0[Check the diff]

- made skipping of initial `elasticapm` frames for span stack traces more generic {pull}167[#167]
- added `context.process.ppid` field (supported in apm-server 6.3+) {pull}168[#168]
- added option to disable stack frame collection for very short spans {pull}142[#142]
- several bug fixes:
    - fix an issue in boto3 instrumentation with nonstandard endpoint URLs {pull}178[#178]
    - fix bug with OPTIONS requests and body capturing {pull}174[#174]
    - fix issue when message has `%` character, but no params {pull}175[#175]

[[release-notes-2.0.1]]
==== v2.0.1 - 2018/02/15


https://github.com/elastic/apm-agent-python/compare/v2.0.0\\...v2.0.1[Check the diff]

- fixed compatibility issue with aiohttp 3.0 {pull}157[#157]
- Added truncation for fields that have a `maxLength` in the JSON Schema {pull}159[#159]

[[release-notes-2.0.0]]
==== v2.0.0 - 2018/02/06


https://github.com/elastic/apm-agent-python/compare/v1.0.0\\...v2.0.0[Check the diff]

- moved the library-frame detection from a processor to the stacktrace collection {pull}113[#113].
- added settings to enable/disable source code collection and local variables collection for errors and transactions {pull}117[#117]
- added `service.environment` to provide an environment name (e.g. ""production"", ""staging"") {pull}123[#123]
- added `transaction.id` to errors to better correlate errors with transactions {pull}122[#122]
- added `transaction_sample_rate` to define a rate with which transactions are sampled {pull}116[#116]
- added `error.handled` to indicate if an exception was handled or not {pull}124[#124].
- added `transaction_max_spans` setting to limit the amount of spans that are recorded per transaction {pull}127[#127]
- added configuration options to limit captured local variables to a certain length {pull}130[#130]
- added options for configuring the amount of context lines that are captured with each frame {pull}136[#136]
- added support for tracing queries formatted as http://initd.org/psycopg/docs/sql.html[`psycopg2.sql.SQL`] objects {pull}148[#148]
- switched to `time.perf_counter` as timing function on Python 3 {pull}138[#138]
- added option to disable capturing of request body {pull}151[#151]
- BREAKING: Several settings and APIs have been renamed (#111, #119, #143):
    - The decorator for custom instrumentation, `elasticapm.trace`, is now `elasticapm.capture_span`
    - The setting `traces_send_frequency` has been renamed to `flush_interval`. The name of the analogous environment variable changed from `ELASTIC_APM_TRACES_SEND_FREQ` to `ELASTIC_APM_FLUSH_INTERVAL`
    - The `app_name` setting has been renamed to `service_name`. The name of the analogous environment variable changed from `ELASTIC_APM_APP_NAME` to `ELASTIC_APM_SERVICE_NAME`.
    - `app_name` arguments to API calls in the whole code base changed to `service_name`.
    - The `app_version` setting has been renamed to `service_version`. The name of the analogous environment variable changed from `ELASTIC_APM_APP_VERSION` to `ELASTIC_APM_SERVICE_VERSION`.
    - `context.request.url.raw` has been renamed to `context.request.url.full` {pull}121[#121]
- BREAKING: added `elasticapm.set_custom_context` in favor of the more generic `set_custom_data` function {pull}133[#133]
- BREAKING: `include_patterns` and `exclude_patterns` now use shell globs instead of regular expressions, and are matched against the full path file path of the module, not against the module name {pull}137[#137]
- BREAKING: renamed several configuration options to align better with other language agents {pull}145[#145]:
    - `disable_instrumentation` became `instrument` and inverted its meaning
    - `max_event_queue_length` became `max_queue_size`
    - `timeout` became `server_timeout`

[[release-notes-1.x]]
=== Python Agent version 1.x

[[release-notes-1.0.0]]
==== v1.0.0 - 2017/12/11


https://github.com/elastic/apm-agent-python/compare/v1.0.0.dev3\\...v1.0.0[Check the diff]

- added `max-event-queue-length` setting. {pull}67[#67]
- changed name that the agent reports itself with to the APM server from `elasticapm-python` to `python`. This aligns the Python agent with other languages. {pull}104[#104]
- changed Celery integration to store the task state (e.g. `SUCCESS` or `FAILURE`) in `transaction.result` {pull}100[#100]
- added setting to disable SSL certificate verification {pull}108[#108]
- BREAKING: renamed `server` configuration variable to `server_url` to better align with other language agents {pull}105[#105]
- BREAKING: removed the old and unused urllib2-based HTTP transport, and renamed the urllib3 transport {pull}107[#107]
- BREAKING: several API changes to `capture_exception`, `capture_message`, and added documentation for these and other APIs {pull}112[#112]

[[release-notes-1.0.0-dev3]]
==== v1.0.0.dev3 - 2017/11/13


https://github.com/elastic/apm-agent-python/compare/v1.0.0.dev2\\...v1.0.0.dev2[Check the diff]

- added a background thread to process the transactions queue every 60 seconds (configurable) {pull}68[#68]
- adapted trace context for SQL traces to new API {pull}77[#77]
- ensured that transaction data is also passed through processors {pull}84[#84]
- added `uninstrument` function to reverse instrumentation, and exposed both `instrument` and `uninstrument` as public API in the `elasticapm` namespace {pull}90[#90]
- added normalization of HTTP status codes into classes for the `transaction.result` field. A HTTP status of `200` will be turned into `HTTP 2xx`. The unchanged status code is still available in `context.response.status_code`. {pull}85[#85]

[[release-notes-1.0.0-dev2]]
==== v1.0.0.dev2 - 2017/09/29


https://github.com/elastic/apm-agent-python/compare/v1.0.0.dev1\\...v1.0.0.dev2[Check the diff]

- added request context information for Flask {pull}58[#58]
- added response context information for Flask {pull}65[#65]
- BREAKING: changed the `SERVERS` list setting to a single `SERVER` string setting. With this change, we now only support sending events to a single server {pull}59[#59]
- BREAKING: removed root trace. Due to historical reason, we used to create a ""root trace"" which was equivalent to the transaction. This is no longer necessary. #61

[[release-notes-1.0.0-dev1]]
==== v1.0.0.dev1 - 2017/09/18


https://github.com/elastic/apm-agent-python/compare/v1.0.0.dev0\\...v1.0.0.dev1[Check the diff]

- unified configuration across supported frameworks {pull}33[#33]
- added in-app frame detection {pull}36[#36]
- added tagging functionality {pull}28[#28]
- preliminary support for Django 2.0 {pull}26[#26]
- initial set of documentation

[[release-notes-1.0.0-dev0]]
==== v1.0.0.dev0 - 2017/08/17

First release of the Python agent for Elastic APM
",12176,True,2778.9583113563654,median
"/*
 *  Copyright (c) 2019, The OpenThread Authors.
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *  3. Neither the name of the copyright holder nor the
 *     names of its contributors may be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ""AS IS""
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 */

#if __ORDER_BIG_ENDIAN__
#define BYTE_ORDER_BIG_ENDIAN 1
#endif

#define OTBR_LOG_TAG ""UBUS""

#include ""openwrt/ubus/otubus.hpp""

#include <mutex>

#include <arpa/inet.h>
#include <sys/eventfd.h>

#include <openthread/commissioner.h>
#include <openthread/thread.h>
#include <openthread/thread_ftd.h>

#include ""common/logging.hpp""
#include ""ncp/ncp_openthread.hpp""

namespace otbr {
namespace ubus {

static UbusServer *sUbusServerInstance = nullptr;
static int         sUbusEfd            = -1;
static void *      sJsonUri            = nullptr;
static int         sBufNum;

const static int PANID_LENGTH      = 10;
const static int XPANID_LENGTH     = 64;
const static int NETWORKKEY_LENGTH = 64;

UbusServer::UbusServer(Ncp::ControllerOpenThread *aController, std::mutex *aMutex)
    : mIfFinishScan(false)
    , mContext(nullptr)
    , mSockPath(nullptr)
    , mController(aController)
    , mNcpThreadMutex(aMutex)
    , mSecond(0)
{
    memset(&mNetworkdataBuf, 0, sizeof(mNetworkdataBuf));
    memset(&mBuf, 0, sizeof(mBuf));

    blob_buf_init(&mBuf, 0);
    blob_buf_init(&mNetworkdataBuf, 0);
}

UbusServer &UbusServer::GetInstance(void)
{
    return *sUbusServerInstance;
}

void UbusServer::Initialize(Ncp::ControllerOpenThread *aController, std::mutex *aMutex)
{
    sUbusServerInstance = new UbusServer(aController, aMutex);
}

enum
{
    SETNETWORK,
    SET_NETWORK_MAX,
};

enum
{
    PSKD,
    EUI64,
    ADD_JOINER_MAX,
};

enum
{
    NETWORKKEY,
    NETWORKNAME,
    EXTPANID,
    PANID,
    CHANNEL,
    PSKC,
    MGMTSET_MAX,
};

static const struct blobmsg_policy setNetworknamePolicy[SET_NETWORK_MAX] = {
    [SETNETWORK] = {.name = ""networkname"", .type = BLOBMSG_TYPE_STRING},
};

static const struct blobmsg_policy setPanIdPolicy[SET_NETWORK_MAX] = {
    [SETNETWORK] = {.name = ""panid"", .type = BLOBMSG_TYPE_STRING},
};

static const struct blobmsg_policy setExtPanIdPolicy[SET_NETWORK_MAX] = {
    [SETNETWORK] = {.name = ""extpanid"", .type = BLOBMSG_TYPE_STRING},
};

static const struct blobmsg_policy setChannelPolicy[SET_NETWORK_MAX] = {
    [SETNETWORK] = {.name = ""channel"", .type = BLOBMSG_TYPE_INT32},
};

static const struct blobmsg_policy setPskcPolicy[SET_NETWORK_MAX] = {
    [SETNETWORK] = {.name = ""pskc"", .type = BLOBMSG_TYPE_STRING},
};

static const struct blobmsg_policy setNetworkkeyPolicy[SET_NETWORK_MAX] = {
    [SETNETWORK] = {.name = ""networkkey"", .type = BLOBMSG_TYPE_STRING},
};

static const struct blobmsg_policy setModePolicy[SET_NETWORK_MAX] = {
    [SETNETWORK] = {.name = ""mode"", .type = BLOBMSG_TYPE_STRING},
};

static const struct blobmsg_policy macfilterAddPolicy[SET_NETWORK_MAX] = {
    [SETNETWORK] = {.name = ""addr"", .type = BLOBMSG_TYPE_STRING},
};

static const struct blobmsg_policy macfilterRemovePolicy[SET_NETWORK_MAX] = {
    [SETNETWORK] = {.name = ""addr"", .type = BLOBMSG_TYPE_STRING},
};

static const struct blobmsg_policy macfilterSetStatePolicy[SET_NETWORK_MAX] = {
    [SETNETWORK] = {.name = ""state"", .type = BLOBMSG_TYPE_STRING},
};

static const struct blobmsg_policy removeJoinerPolicy[SET_NETWORK_MAX] = {
    [SETNETWORK] = {.name = ""eui64"", .type = BLOBMSG_TYPE_STRING},
};

static const struct blobmsg_policy addJoinerPolicy[ADD_JOINER_MAX] = {
    [PSKD]  = {.name = ""pskd"", .type = BLOBMSG_TYPE_STRING},
    [EUI64] = {.name = ""eui64"", .type = BLOBMSG_TYPE_STRING},
};

static const struct blobmsg_policy mgmtsetPolicy[MGMTSET_MAX] = {
    [NETWORKKEY]  = {.name = ""networkkey"", .type = BLOBMSG_TYPE_STRING},
    [NETWORKNAME] = {.name = ""networkname"", .type = BLOBMSG_TYPE_STRING},
    [EXTPANID]    = {.name = ""extpanid"", .type = BLOBMSG_TYPE_STRING},
    [PANID]       = {.name = ""panid"", .type = BLOBMSG_TYPE_STRING},
    [CHANNEL]     = {.name = ""channel"", .type = BLOBMSG_TYPE_STRING},
    [PSKC]        = {.name = ""pskc"", .type = BLOBMSG_TYPE_STRING},
};

static const struct ubus_method otbrMethods[] = {
    {""scan"", &UbusServer::UbusScanHandler, 0, 0, nullptr, 0},
    {""channel"", &UbusServer::UbusChannelHandler, 0, 0, nullptr, 0},
    {""setchannel"", &UbusServer::UbusSetChannelHandler, 0, 0, setChannelPolicy, ARRAY_SIZE(setChannelPolicy)},
    {""networkname"", &UbusServer::UbusNetworknameHandler, 0, 0, nullptr, 0},
    {""setnetworkname"", &UbusServer::UbusSetNetworknameHandler, 0, 0, setNetworknamePolicy,
     ARRAY_SIZE(setNetworknamePolicy)},
    {""state"", &UbusServer::UbusStateHandler, 0, 0, nullptr, 0},
    {""panid"", &UbusServer::UbusPanIdHandler, 0, 0, nullptr, 0},
    {""setpanid"", &UbusServer::UbusSetPanIdHandler, 0, 0, setPanIdPolicy, ARRAY_SIZE(setPanIdPolicy)},
    {""rloc16"", &UbusServer::UbusRloc16Handler, 0, 0, nullptr, 0},
    {""extpanid"", &UbusServer::UbusExtPanIdHandler, 0, 0, nullptr, 0},
    {""setextpanid"", &UbusServer::UbusSetExtPanIdHandler, 0, 0, setExtPanIdPolicy, ARRAY_SIZE(setExtPanIdPolicy)},
    {""networkkey"", &UbusServer::UbusNetworkkeyHandler, 0, 0, nullptr, 0},
    {""setnetworkkey"", &UbusServer::UbusSetNetworkkeyHandler, 0, 0, setNetworkkeyPolicy,
     ARRAY_SIZE(setNetworkkeyPolicy)},
    {""pskc"", &UbusServer::UbusPskcHandler, 0, 0, nullptr, 0},
    {""setpskc"", &UbusServer::UbusSetPskcHandler, 0, 0, setPskcPolicy, ARRAY_SIZE(setPskcPolicy)},
    {""threadstart"", &UbusServer::UbusThreadStartHandler, 0, 0, nullptr, 0},
    {""threadstop"", &UbusServer::UbusThreadStopHandler, 0, 0, nullptr, 0},
    {""neighbor"", &UbusServer::UbusNeighborHandler, 0, 0, nullptr, 0},
    {""parent"", &UbusServer::UbusParentHandler, 0, 0, nullptr, 0},
    {""mode"", &UbusServer::UbusModeHandler, 0, 0, nullptr, 0},
    {""setmode"", &UbusServer::UbusSetModeHandler, 0, 0, setModePolicy, ARRAY_SIZE(setModePolicy)},
    {""partitionid"", &UbusServer::UbusPartitionIdHandler, 0, 0, nullptr, 0},
    {""leave"", &UbusServer::UbusLeaveHandler, 0, 0, nullptr, 0},
    {""leaderdata"", &UbusServer::UbusLeaderdataHandler, 0, 0, nullptr, 0},
    {""networkdata"", &UbusServer::UbusNetworkdataHandler, 0, 0, nullptr, 0},
    {""commissionerstart"", &UbusServer::UbusCommissionerStartHandler, 0, 0, nullptr, 0},
    {""joinernum"", &UbusServer::UbusJoinerNumHandler, 0, 0, nullptr, 0},
    {""joinerremove"", &UbusServer::UbusJoinerRemoveHandler, 0, 0, nullptr, 0},
    {""macfiltersetstate"", &UbusServer::UbusMacfilterSetStateHandler, 0, 0, macfilterSetStatePolicy,
     ARRAY_SIZE(macfilterSetStatePolicy)},
    {""macfilteradd"", &UbusServer::UbusMacfilterAddHandler, 0, 0, macfilterAddPolicy, ARRAY_SIZE(macfilterAddPolicy)},
    {""macfilterremove"", &UbusServer::UbusMacfilterRemoveHandler, 0, 0, macfilterRemovePolicy,
     ARRAY_SIZE(macfilterRemovePolicy)},
    {""macfilterclear"", &UbusServer::UbusMacfilterClearHandler, 0, 0, nullptr, 0},
    {""macfilterstate"", &UbusServer::UbusMacfilterStateHandler, 0, 0, nullptr, 0},
    {""macfilteraddr"", &UbusServer::UbusMacfilterAddrHandler, 0, 0, nullptr, 0},
    {""joineradd"", &UbusServer::UbusJoinerAddHandler, 0, 0, addJoinerPolicy, ARRAY_SIZE(addJoinerPolicy)},
    {""mgmtset"", &UbusServer::UbusMgmtsetHandler, 0, 0, mgmtsetPolicy, ARRAY_SIZE(mgmtsetPolicy)},
};

static struct ubus_object_type otbrObjType = {""otbr_prog"", 0, otbrMethods, ARRAY_SIZE(otbrMethods)};

static struct ubus_object otbr = {
    avl : {},
    name : ""otbr"",
    id : 0,
    path : nullptr,
    type : &otbrObjType,
    subscribe_cb : nullptr,
    has_subscribers : false,
    methods : otbrMethods,
    n_methods : ARRAY_SIZE(otbrMethods),
};

void UbusServer::ProcessScan(void)
{
    otError  error        = OT_ERROR_NONE;
    uint32_t scanChannels = 0;
    uint16_t scanDuration = 0;

    mNcpThreadMutex->lock();
    SuccessOrExit(error = otLinkActiveScan(mController->GetInstance(), scanChannels, scanDuration,
                                           &UbusServer::HandleActiveScanResult, this));
exit:
    mNcpThreadMutex->unlock();
    return;
}

void UbusServer::HandleActiveScanResult(otActiveScanResult *aResult, void *aContext)
{
    static_cast<UbusServer *>(aContext)->HandleActiveScanResultDetail(aResult);
}

void UbusServer::OutputBytes(const uint8_t *aBytes, uint8_t aLength, char *aOutput)
{
    char byte2char[5] = """";
    for (int i = 0; i < aLength; i++)
    {
        sprintf(byte2char, ""%02x"", aBytes[i]);
        strcat(aOutput, byte2char);
    }
}

void UbusServer::AppendResult(otError aError, struct ubus_context *aContext, struct ubus_request_data *aRequest)
{
    blobmsg_add_u16(&mBuf, ""Error"", aError);
    ubus_send_reply(aContext, aRequest, mBuf.head);
}

void UbusServer::HandleActiveScanResultDetail(otActiveScanResult *aResult)
{
    void *jsonList = nullptr;

    char panidstring[PANID_LENGTH];
    char xpanidstring[XPANID_LENGTH] = """";

    if (aResult == nullptr)
    {
        blobmsg_close_array(&mBuf, sJsonUri);
        mIfFinishScan = true;
        goto exit;
    }

    jsonList = blobmsg_open_table(&mBuf, nullptr);

    blobmsg_add_string(&mBuf, ""NetworkName"", aResult->mNetworkName.m8);

    OutputBytes(aResult->mExtendedPanId.m8, OT_EXT_PAN_ID_SIZE, xpanidstring);
    blobmsg_add_string(&mBuf, ""ExtendedPanId"", xpanidstring);

    sprintf(panidstring, ""0x%04x"", aResult->mPanId);
    blobmsg_add_string(&mBuf, ""PanId"", panidstring);

    blobmsg_add_u32(&mBuf, ""Channel"", aResult->mChannel);

    blobmsg_add_u32(&mBuf, ""Rssi"", aResult->mRssi);

    blobmsg_add_u32(&mBuf, ""Lqi"", aResult->mLqi);

    blobmsg_close_table(&mBuf, jsonList);

exit:
    return;
}

int UbusServer::UbusScanHandler(struct ubus_context *     aContext,
                                struct ubus_object *      aObj,
                                struct ubus_request_data *aRequest,
                                const char *              aMethod,
                                struct blob_attr *        aMsg)
{
    return GetInstance().UbusScanHandlerDetail(aContext, aObj, aRequest, aMethod, aMsg);
}

int UbusServer::UbusScanHandlerDetail(struct ubus_context *     aContext,
                                      struct ubus_object *      aObj,
                                      struct ubus_request_data *aRequest,
                                      const char *              aMethod,
                                      struct blob_attr *        aMsg)
{
    OT_UNUSED_VARIABLE(aObj);
    OT_UNUSED_VARIABLE(aMethod);
    OT_UNUSED_VARIABLE(aMsg);

    otError  error = OT_ERROR_NONE;
    uint64_t eventNum;
    ssize_t  retval;

    blob_buf_init(&mBuf, 0);
    sJsonUri = blobmsg_open_array(&mBuf, ""scan_list"");

    mIfFinishScan = 0;
    sUbusServerInstance->ProcessScan();

    eventNum = 1;
    retval   = write(sUbusEfd, &eventNum, sizeof(uint64_t));
    if (retval != sizeof(uint64_t))
    {
        error = OT_ERROR_FAILED;
        goto exit;
    }

    while (!mIfFinishScan)
    {
        sleep(1);
    }

exit:
    AppendResult(error, aContext, aRequest);
    return 0;
}

int UbusServer::UbusChannelHandler(struct ubus_context *     aContext,
                                   struct ubus_object *      aObj,
                                   struct ubus_request_data *aRequest,
                                   const char *              aMethod,
                                   struct blob_attr *        aMsg)
{
    return GetInstance().UbusGetInformation(aContext, aObj, aRequest, aMethod, aMsg, ""channel"");
}

int UbusServer::UbusSetChannelHandler(struct ubus_context *     aContext,
                                      struct ubus_object *      aObj,
                                      struct ubus_request_data *aRequest,
                                      const char *              aMethod,
                                      struct blob_attr *        aMsg)
{
    return GetInstance().UbusSetInformation(aContext, aObj, aRequest, aMethod, aMsg, ""channel"");
}

int UbusServer::UbusJoinerNumHandler(struct ubus_context *     aContext,
                                     struct ubus_object *      aObj,
                                     struct ubus_request_data *aRequest,
                                     const char *              aMethod,
                                     struct blob_attr *        aMsg)
{
    return GetInstance().UbusGetInformation(aContext, aObj, aRequest, aMethod, aMsg, ""joinernum"");
}

int UbusServer::UbusNetworknameHandler(struct ubus_context *     aContext,
                                       struct ubus_object *      aObj,
                                       struct ubus_request_data *aRequest,
                                       const char *              aMethod,
                                       struct blob_attr *        aMsg)
{
    return GetInstance().UbusGetInformation(aContext, aObj, aRequest, aMethod, aMsg, ""networkname"");
}

int UbusServer::UbusSetNetworknameHandler(struct ubus_context *     aContext,
                                          struct ubus_object *      aObj,
                                          struct ubus_request_data *aRequest,
                                          const char *              aMethod,
                                          struct blob_attr *        aMsg)
{
    return GetInstance().UbusSetInformation(aContext, aObj, aRequest, aMethod, aMsg, ""networkname"");
}

int UbusServer::UbusStateHandler(struct ubus_context *     aContext,
                                 struct ubus_object *      aObj,
                                 struct ubus_request_data *aRequest,
                                 const char *              aMethod,
                                 struct blob_attr *        aMsg)
{
    return GetInstance().UbusGetInformation(aContext, aObj, aRequest, aMethod, aMsg, ""state"");
}

int UbusServer::UbusRloc16Handler(struct ubus_context *     aContext,
                                  struct ubus_object *      aObj,
                                  struct ubus_request_data *aRequest,
                                  const char *              aMethod,
                                  struct blob_attr *        aMsg)
{
    return GetInstance().UbusGetInformation(aContext, aObj, aRequest, aMethod, aMsg, ""rloc16"");
}

int UbusServer::UbusPanIdHandler(struct ubus_context *     aContext,
                                 struct ubus_object *      aObj,
                                 struct ubus_request_data *aRequest,
                                 const char *              aMethod,
                                 struct blob_attr *        aMsg)
{
    return GetInstance().UbusGetInformation(aContext, aObj, aRequest, aMethod, aMsg, ""panid"");
}

int UbusServer::UbusSetPanIdHandler(struct ubus_context *     aContext,
                                    struct ubus_object *      aObj,
                                    struct ubus_request_data *aRequest,
                                    const char *              aMethod,
                                    struct blob_attr *        aMsg)
{
    return GetInstance().UbusSetInformation(aContext, aObj, aRequest, aMethod, aMsg, ""panid"");
}

int UbusServer::UbusExtPanIdHandler(struct ubus_context *     aContext,
                                    struct ubus_object *      aObj,
                                    struct ubus_request_data *aRequest,
                                    const char *              aMethod,
                                    struct blob_attr *        aMsg)
{
    return GetInstance().UbusGetInformation(aContext, aObj, aRequest, aMethod, aMsg, ""extpanid"");
}

int UbusServer::UbusSetExtPanIdHandler(struct ubus_context *     aContext,
                                       struct ubus_object *      aObj,
                                       struct ubus_request_data *aRequest,
                                       const char *              aMethod,
                                       struct blob_attr *        aMsg)
{
    return GetInstance().UbusSetInformation(aContext, aObj, aRequest, aMethod, aMsg, ""extpanid"");
}

int UbusServer::UbusPskcHandler(struct ubus_context *     aContext,
                                struct ubus_object *      aObj,
                                struct ubus_request_data *aRequest,
                                const char *              aMethod,
                                struct blob_attr *        aMsg)
{
    return GetInstance().UbusGetInformation(aContext, aObj, aRequest, aMethod, aMsg, ""pskc"");
}

int UbusServer::UbusSetPskcHandler(struct ubus_context *     aContext,
                                   struct ubus_object *      aObj,
                                   struct ubus_request_data *aRequest,
                                   const char *              aMethod,
                                   struct blob_attr *        aMsg)
{
    return GetInstance().UbusSetInformation(aContext, aObj, aRequest, aMethod, aMsg, ""pskc"");
}

int UbusServer::UbusNetworkkeyHandler(struct ubus_context *     aContext,
                                      struct ubus_object *      aObj,
                                      struct ubus_request_data *aRequest,
                                      const char *              aMethod,
                                      struct blob_attr *        aMsg)
{
    return GetInstance().UbusGetInformation(aContext, aObj, aRequest, aMethod, aMsg, ""networkkey"");
}

int UbusServer::UbusSetNetworkkeyHandler(struct ubus_context *     aContext,
                                         struct ubus_object *      aObj,
                                         struct ubus_request_data *aRequest,
                                         const char *              aMethod,
                                         struct blob_attr *        aMsg)
{
    return GetInstance().UbusSetInformation(aContext, aObj, aRequest, aMethod, aMsg, ""networkkey"");
}

int UbusServer::UbusThreadStartHandler(struct ubus_context *     aContext,
                                       struct ubus_object *      aObj,
                                       struct ubus_request_data *aRequest,
                                       const char *              aMethod,
                                       struct blob_attr *        aMsg)
{
    return GetInstance().UbusThreadHandler(aContext, aObj, aRequest, aMethod, aMsg, ""start"");
}

int UbusServer::UbusThreadStopHandler(struct ubus_context *     aContext,
                                      struct ubus_object *      aObj,
                                      struct ubus_request_data *aRequest,
                                      const char *              aMethod,
                                      struct blob_attr *        aMsg)
{
    return GetInstance().UbusThreadHandler(aContext, aObj, aRequest, aMethod, aMsg, ""stop"");
}

int UbusServer::UbusParentHandler(struct ubus_context *     aContext,
                                  struct ubus_object *      aObj,
                                  struct ubus_request_data *aRequest,
                                  const char *              aMethod,
                                  struct blob_attr *        aMsg)
{
    return GetInstance().UbusParentHandlerDetail(aContext, aObj, aRequest, aMethod, aMsg);
}

int UbusServer::UbusNeighborHandler(struct ubus_context *     aContext,
                                    struct ubus_object *      aObj,
                                    struct ubus_request_data *aRequest,
                                    const char *              aMethod,
                                    struct blob_attr *        aMsg)
{
    return GetInstance().UbusNeighborHandlerDetail(aContext, aObj, aRequest, aMethod, aMsg);
}

int UbusServer::UbusModeHandler(struct ubus_context *     aContext,
                                struct ubus_object *      aObj,
                                struct ubus_request_data *aRequest,
                                const char *              aMethod,
                                struct blob_attr *        aMsg)
{
    return GetInstance().UbusGetInformation(aContext, aObj, aRequest, aMethod, aMsg, ""mode"");
}

int UbusServer::UbusSetModeHandler(struct ubus_context *     aContext,
                                   struct ubus_object *      aObj,
                                   struct ubus_request_data *aRequest,
                                   const char *              aMethod,
                                   struct blob_attr *        aMsg)
{
    return GetInstance().UbusSetInformation(aContext, aObj, aRequest, aMethod, aMsg, ""mode"");
}

int UbusServer::UbusPartitionIdHandler(struct ubus_context *     aContext,
                                       struct ubus_object *      aObj,
                                       struct ubus_request_data *aRequest,
                                       const char *              aMethod,
                                       struct blob_attr *        aMsg)
{
    return GetInstance().UbusGetInformation(aContext, aObj, aRequest, aMethod, aMsg, ""partitionid"");
}

int UbusServer::UbusLeaveHandler(struct ubus_context *     aContext,
                                 struct ubus_object *      aObj,
                                 struct ubus_request_data *aRequest,
                                 const char *              aMethod,
                                 struct blob_attr *        aMsg)
{
    return GetInstance().UbusLeaveHandlerDetail(aContext, aObj, aRequest, aMethod, aMsg);
}

int UbusServer::UbusLeaderdataHandler(struct ubus_context *     aContext,
                                      struct ubus_object *      aObj,
                                      struct ubus_request_data *aRequest,
                                      const char *              aMethod,
                                      struct blob_attr *        aMsg)
{
    return GetInstance().UbusGetInformation(aContext, aObj, aRequest, aMethod, aMsg, ""leaderdata"");
}

int UbusServer::UbusNetworkdataHandler(struct ubus_context *     aContext,
                                       struct ubus_object *      aObj,
                                       struct ubus_request_data *aRequest,
                                       const char *              aMethod,
                                       struct blob_attr *        aMsg)
{
    return GetInstance().UbusGetInformation(aContext, aObj, aRequest, aMethod, aMsg, ""networkdata"");
}

int UbusServer::UbusCommissionerStartHandler(struct ubus_context *     aContext,
                                             struct ubus_object *      aObj,
                                             struct ubus_request_data *aRequest,
                                             const char *              aMethod,
                                             struct blob_attr *        aMsg)
{
    return GetInstance().UbusCommissioner(aContext, aObj, aRequest, aMethod, aMsg, ""start"");
}

int UbusServer::UbusJoinerRemoveHandler(struct ubus_context *     aContext,
                                        struct ubus_object *      aObj,
                                        struct ubus_request_data *aRequest,
                                        const char *              aMethod,
                                        struct blob_attr *        aMsg)
{
    return GetInstance().UbusCommissioner(aContext, aObj, aRequest, aMethod, aMsg, ""joinerremove"");
}

int UbusServer::UbusMgmtsetHandler(struct ubus_context *     aContext,
                                   struct ubus_object *      aObj,
                                   struct ubus_request_data *aRequest,
                                   const char *              aMethod,
                                   struct blob_attr *        aMsg)
{
    return GetInstance().UbusMgmtset(aContext, aObj, aRequest, aMethod, aMsg);
}

int UbusServer::UbusJoinerAddHandler(struct ubus_context *     aContext,
                                     struct ubus_object *      aObj,
                                     struct ubus_request_data *aRequest,
                                     const char *              aMethod,
                                     struct blob_attr *        aMsg)
{
    return GetInstance().UbusCommissioner(aContext, aObj, aRequest, aMethod, aMsg, ""joineradd"");
}

int UbusServer::UbusMacfilterAddrHandler(struct ubus_context *     aContext,
                                         struct ubus_object *      aObj,
                                         struct ubus_request_data *aRequest,
                                         const char *              aMethod,
                                         struct blob_attr *        aMsg)
{
    return GetInstance().UbusGetInformation(aContext, aObj, aRequest, aMethod, aMsg, ""macfilteraddr"");
}

int UbusServer::UbusMacfilterStateHandler(struct ubus_context *     aContext,
                                          struct ubus_object *      aObj,
                                          struct ubus_request_data *aRequest,
                                          const char *              aMethod,
                                          struct blob_attr *        aMsg)
{
    return GetInstance().UbusGetInformation(aContext, aObj, aRequest, aMethod, aMsg, ""macfilterstate"");
}

int UbusServer::UbusMacfilterAddHandler(struct ubus_context *     aContext,
                                        struct ubus_object *      aObj,
                                        struct ubus_request_data *aRequest,
                                        const char *              aMethod,
                                        struct blob_attr *        aMsg)
{
    return GetInstance().UbusSetInformation(aContext, aObj, aRequest, aMethod, aMsg, ""macfilteradd"");
}

int UbusServer::UbusMacfilterRemoveHandler(struct ubus_context *     aContext,
                                           struct ubus_object *      aObj,
                                           struct ubus_request_data *aRequest,
                                           const char *              aMethod,
                                           struct blob_attr *        aMsg)
{
    return GetInstance().UbusSetInformation(aContext, aObj, aRequest, aMethod, aMsg, ""macfilterremove"");
}

int UbusServer::UbusMacfilterSetStateHandler(struct ubus_context *     aContext,
                                             struct ubus_object *      aObj,
                                             struct ubus_request_data *aRequest,
                                             const char *              aMethod,
                                             struct blob_attr *        aMsg)
{
    return GetInstance().UbusSetInformation(aContext, aObj, aRequest, aMethod, aMsg, ""macfiltersetstate"");
}

int UbusServer::UbusMacfilterClearHandler(struct ubus_context *     aContext,
                                          struct ubus_object *      aObj,
                                          struct ubus_request_data *aRequest,
                                          const char *              aMethod,
                                          struct blob_attr *        aMsg)
{
    return GetInstance().UbusSetInformation(aContext, aObj, aRequest, aMethod, aMsg, ""macfilterclear"");
}

int UbusServer::UbusLeaveHandlerDetail(struct ubus_context *     aContext,
                                       struct ubus_object *      aObj,
                                       struct ubus_request_data *aRequest,
                                       const char *              aMethod,
                                       struct blob_attr *        aMsg)
{
    OT_UNUSED_VARIABLE(aObj);
    OT_UNUSED_VARIABLE(aMethod);
    OT_UNUSED_VARIABLE(aMsg);

    otError  error = OT_ERROR_NONE;
    uint64_t eventNum;
    ssize_t  retval;

    mNcpThreadMutex->lock();
    otInstanceFactoryReset(mController->GetInstance());

    eventNum = 1;
    retval   = write(sUbusEfd, &eventNum, sizeof(uint64_t));
    if (retval != sizeof(uint64_t))
    {
        error = OT_ERROR_FAILED;
        goto exit;
    }

    blob_buf_init(&mBuf, 0);

exit:
    mNcpThreadMutex->unlock();
    AppendResult(error, aContext, aRequest);
    return 0;
}
int UbusServer::UbusThreadHandler(struct ubus_context *     aContext,
                                  struct ubus_object *      aObj,
                                  struct ubus_request_data *aRequest,
                                  const char *              aMethod,
                                  struct blob_attr *        aMsg,
                                  const char *              aAction)
{
    OT_UNUSED_VARIABLE(aObj);
    OT_UNUSED_VARIABLE(aMethod);
    OT_UNUSED_VARIABLE(aMsg);

    otError error = OT_ERROR_NONE;

    blob_buf_init(&mBuf, 0);

    if (!strcmp(aAction, ""start""))
    {
        mNcpThreadMutex->lock();
        SuccessOrExit(error = otIp6SetEnabled(mController->GetInstance(), true));
        SuccessOrExit(error = otThreadSetEnabled(mController->GetInstance(), true));
    }
    else if (!strcmp(aAction, ""stop""))
    {
        mNcpThreadMutex->lock();
        SuccessOrExit(error = otThreadSetEnabled(mController->GetInstance(), false));
        SuccessOrExit(error = otIp6SetEnabled(mController->GetInstance(), false));
    }

exit:
    mNcpThreadMutex->unlock();
    AppendResult(error, aContext, aRequest);
    return 0;
}

int UbusServer::UbusParentHandlerDetail(struct ubus_context *     aContext,
                                        struct ubus_object *      aObj,
                                        struct ubus_request_data *aRequest,
                                        const char *              aMethod,
                                        struct blob_attr *        aMsg)
{
    OT_UNUSED_VARIABLE(aObj);
    OT_UNUSED_VARIABLE(aMethod);
    OT_UNUSED_VARIABLE(aMsg);

    otError      error = OT_ERROR_NONE;
    otRouterInfo parentInfo;
    char         extAddress[XPANID_LENGTH] = """";
    char         transfer[XPANID_LENGTH]   = """";
    void *       jsonList                  = nullptr;
    void *       jsonArray                 = nullptr;

    blob_buf_init(&mBuf, 0);

    mNcpThreadMutex->lock();
    SuccessOrExit(error = otThreadGetParentInfo(mController->GetInstance(), &parentInfo));

    jsonArray = blobmsg_open_array(&mBuf, ""parent_list"");
    jsonList  = blobmsg_open_table(&mBuf, ""parent"");
    blobmsg_add_string(&mBuf, ""Role"", ""R"");

    sprintf(transfer, ""0x%04x"", parentInfo.mRloc16);
    blobmsg_add_string(&mBuf, ""Rloc16"", transfer);

    sprintf(transfer, ""%3d"", parentInfo.mAge);
    blobmsg_add_string(&mBuf, ""Age"", transfer);

    OutputBytes(parentInfo.mExtAddress.m8, sizeof(parentInfo.mExtAddress.m8), extAddress);
    blobmsg_add_string(&mBuf, ""ExtAddress"", extAddress);

    blobmsg_add_u16(&mBuf, ""LinkQualityIn"", parentInfo.mLinkQualityIn);

    blobmsg_close_table(&mBuf, jsonList);
    blobmsg_close_array(&mBuf, jsonArray);

exit:
    mNcpThreadMutex->unlock();
    AppendResult(error, aContext, aRequest);
    return error;
}

int UbusServer::UbusNeighborHandlerDetail(struct ubus_context *     aContext,
                                          struct ubus_object *      aObj,
                                          struct ubus_request_data *aRequest,
                                          const char *              aMethod,
                                          struct blob_attr *        aMsg)
{
    OT_UNUSED_VARIABLE(aObj);
    OT_UNUSED_VARIABLE(aMethod);
    OT_UNUSED_VARIABLE(aMsg);

    otError                error = OT_ERROR_NONE;
    otNeighborInfo         neighborInfo;
    otNeighborInfoIterator iterator                  = OT_NEIGHBOR_INFO_ITERATOR_INIT;
    char                   transfer[XPANID_LENGTH]   = """";
    void *                 jsonList                  = nullptr;
    char                   mode[5]                   = """";
    char                   extAddress[XPANID_LENGTH] = """";

    blob_buf_init(&mBuf, 0);

    sJsonUri = blobmsg_open_array(&mBuf, ""neighbor_list"");

    mNcpThreadMutex->lock();
    while (otThreadGetNextNeighborInfo(mController->GetInstance(), &iterator, &neighborInfo) == OT_ERROR_NONE)
    {
        jsonList = blobmsg_open_table(&mBuf, nullptr);

        blobmsg_add_string(&mBuf, ""Role"", neighborInfo.mIsChild ? ""C"" : ""R"");

        sprintf(transfer, ""0x%04x"", neighborInfo.mRloc16);
        blobmsg_add_string(&mBuf, ""Rloc16"", transfer);

        sprintf(transfer, ""%3d"", neighborInfo.mAge);
        blobmsg_add_string(&mBuf, ""Age"", transfer);

        sprintf(transfer, ""%8d"", neighborInfo.mAverageRssi);
        blobmsg_add_string(&mBuf, ""AvgRssi"", transfer);

        sprintf(transfer, ""%9d"", neighborInfo.mLastRssi);
        blobmsg_add_string(&mBuf, ""LastRssi"", transfer);

        if (neighborInfo.mRxOnWhenIdle)
        {
            strcat(mode, ""r"");
        }

        if (neighborInfo.mFullThreadDevice)
        {
            strcat(mode, ""d"");
        }

        if (neighborInfo.mFullNetworkData)
        {
            strcat(mode, ""n"");
        }
        blobmsg_add_string(&mBuf, ""Mode"", mode);

        OutputBytes(neighborInfo.mExtAddress.m8, sizeof(neighborInfo.mExtAddress.m8), extAddress);
        blobmsg_add_string(&mBuf, ""ExtAddress"", extAddress);

        blobmsg_add_u16(&mBuf, ""LinkQualityIn"", neighborInfo.mLinkQualityIn);

        blobmsg_close_table(&mBuf, jsonList);

        memset(mode, 0, sizeof(mode));
        memset(extAddress, 0, sizeof(extAddress));
    }

    blobmsg_close_array(&mBuf, sJsonUri);

    mNcpThreadMutex->unlock();

    AppendResult(error, aContext, aRequest);
    return 0;
}

int UbusServer::UbusMgmtset(struct ubus_context *     aContext,
                            struct ubus_object *      aObj,
                            struct ubus_request_data *aRequest,
                            const char *              aMethod,
                            struct blob_attr *        aMsg)
{
    OT_UNUSED_VARIABLE(aObj);
    OT_UNUSED_VARIABLE(aMethod);
    OT_UNUSED_VARIABLE(aMsg);

    otError              error = OT_ERROR_NONE;
    struct blob_attr *   tb[MGMTSET_MAX];
    otOperationalDataset dataset;
    uint8_t              tlvs[128];
    long                 value;
    int                  length = 0;

    SuccessOrExit(error = otDatasetGetActive(mController->GetInstance(), &dataset));

    blobmsg_parse(mgmtsetPolicy, MGMTSET_MAX, tb, blob_data(aMsg), blob_len(aMsg));
    if (tb[NETWORKKEY] != nullptr)
    {
        dataset.mComponents.mIsNetworkKeyPresent = true;
        VerifyOrExit((length = Hex2Bin(blobmsg_get_string(tb[NETWORKKEY]), dataset.mNetworkKey.m8,
                                       sizeof(dataset.mNetworkKey.m8))) == OT_NETWORK_KEY_SIZE,
                     error = OT_ERROR_PARSE);
        length = 0;
    }
    if (tb[NETWORKNAME] != nullptr)
    {
        dataset.mComponents.mIsNetworkNamePresent = true;
        VerifyOrExit((length = static_cast<int>(strlen(blobmsg_get_string(tb[NETWORKNAME])))) <=
                         OT_NETWORK_NAME_MAX_SIZE,
                     error = OT_ERROR_PARSE);
        memset(&dataset.mNetworkName, 0, sizeof(dataset.mNetworkName));
        memcpy(dataset.mNetworkName.m8, blobmsg_get_string(tb[NETWORKNAME]), static_cast<size_t>(length));
        length = 0;
    }
    if (tb[EXTPANID] != nullptr)
    {
        dataset.mComponents.mIsExtendedPanIdPresent = true;
        VerifyOrExit(Hex2Bin(blobmsg_get_string(tb[EXTPANID]), dataset.mExtendedPanId.m8,
                             sizeof(dataset.mExtendedPanId.m8)) >= 0,
                     error = OT_ERROR_PARSE);
    }
    if (tb[PANID] != nullptr)
    {
        dataset.mComponents.mIsPanIdPresent = true;
        SuccessOrExit(error = ParseLong(blobmsg_get_string(tb[PANID]), value));
        dataset.mPanId = static_cast<otPanId>(value);
    }
    if (tb[CHANNEL] != nullptr)
    {
        dataset.mComponents.mIsChannelPresent = true;
        SuccessOrExit(error = ParseLong(blobmsg_get_string(tb[CHANNEL]), value));
        dataset.mChannel = static_cast<uint16_t>(value);
    }
    if (tb[PSKC] != nullptr)
    {
        dataset.mComponents.mIsPskcPresent = true;
        VerifyOrExit((length = Hex2Bin(blobmsg_get_string(tb[PSKC]), dataset.mPskc.m8, sizeof(dataset.mPskc.m8))) ==
                         OT_PSKC_MAX_SIZE,
                     error = OT_ERROR_PARSE);
        length = 0;
    }
    dataset.mActiveTimestamp.mSeconds++;
    if (otCommissionerGetState(mController->GetInstance()) == OT_COMMISSIONER_STATE_DISABLED)
    {
        otCommissionerStop(mController->GetInstance());
    }
    SuccessOrExit(error = otDatasetSendMgmtActiveSet(mController->GetInstance(), &dataset, tlvs,
                                                     static_cast<uint8_t>(length), /* aCallback */ nullptr,
                                                     /* aContext */ nullptr));
exit:
    AppendResult(error, aContext, aRequest);
    return 0;
}

int UbusServer::UbusCommissioner(struct ubus_context *     aContext,
                                 struct ubus_object *      aObj,
                                 struct ubus_request_data *aRequest,
                                 const char *              aMethod,
                                 struct blob_attr *        aMsg,
                                 const char *              aAction)
{
    OT_UNUSED_VARIABLE(aObj);
    OT_UNUSED_VARIABLE(aMethod);
    OT_UNUSED_VARIABLE(aMsg);

    otError error = OT_ERROR_NONE;

    mNcpThreadMutex->lock();

    if (!strcmp(aAction, ""start""))
    {
        if (otCommissionerGetState(mController->GetInstance()) == OT_COMMISSIONER_STATE_DISABLED)
        {
            error = otCommissionerStart(mController->GetInstance(), &UbusServer::HandleStateChanged,
                                        &UbusServer::HandleJoinerEvent, this);
        }
    }
    else if (!strcmp(aAction, ""joineradd""))
    {
        struct blob_attr *  tb[ADD_JOINER_MAX];
        otExtAddress        addr;
        const otExtAddress *addrPtr = nullptr;
        char *              pskd    = nullptr;

        blobmsg_parse(addJoinerPolicy, ADD_JOINER_MAX, tb, blob_data(aMsg), blob_len(aMsg));
        if (tb[PSKD] != nullptr)
        {
            pskd = blobmsg_get_string(tb[PSKD]);
        }
        if (tb[EUI64] != nullptr)
        {
            if (!strcmp(blobmsg_get_string(tb[EUI64]), ""*""))
            {
                addrPtr = nullptr;
                memset(&addr, 0, sizeof(addr));
            }
            else
            {
                VerifyOrExit(Hex2Bin(blobmsg_get_string(tb[EUI64]), addr.m8, sizeof(addr)) == sizeof(addr),
                             error = OT_ERROR_PARSE);
                addrPtr = &addr;
            }
        }

        unsigned long timeout = kDefaultJoinerTimeout;
        SuccessOrExit(
            error = otCommissionerAddJoiner(mController->GetInstance(), addrPtr, pskd, static_cast<uint32_t>(timeout)));
    }
    else if (!strcmp(aAction, ""joinerremove""))
    {
        struct blob_attr *  tb[SET_NETWORK_MAX];
        otExtAddress        addr;
        const otExtAddress *addrPtr = nullptr;

        blobmsg_parse(removeJoinerPolicy, SET_NETWORK_MAX, tb, blob_data(aMsg), blob_len(aMsg));
        if (tb[SETNETWORK] != nullptr)
        {
            if (strcmp(blobmsg_get_string(tb[SETNETWORK]), ""*"") == 0)
            {
                addrPtr = nullptr;
            }
            else
            {
                VerifyOrExit(Hex2Bin(blobmsg_get_string(tb[SETNETWORK]), addr.m8, sizeof(addr)) == sizeof(addr),
                             error = OT_ERROR_PARSE);
                addrPtr = &addr;
            }
        }

        SuccessOrExit(error = otCommissionerRemoveJoiner(mController->GetInstance(), addrPtr));
    }

exit:
    mNcpThreadMutex->unlock();
    blob_buf_init(&mBuf, 0);
    AppendResult(error, aContext, aRequest);
    return 0;
}

void UbusServer::HandleStateChanged(otCommissionerState aState, void *aContext)
{
    static_cast<UbusServer *>(aContext)->HandleStateChanged(aState);
}

void UbusServer::HandleStateChanged(otCommissionerState aState)
{
    switch (aState)
    {
    case OT_COMMISSIONER_STATE_DISABLED:
        otbrLogInfo(""Commissioner state disabled"");
        break;
    case OT_COMMISSIONER_STATE_ACTIVE:
        otbrLogInfo(""Commissioner state active"");
        break;
    case OT_COMMISSIONER_STATE_PETITION:
        otbrLogInfo(""Commissioner state petition"");
        break;
    }
}

void UbusServer::HandleJoinerEvent(otCommissionerJoinerEvent aEvent,
                                   const otJoinerInfo *      aJoinerInfo,
                                   const otExtAddress *      aJoinerId,
                                   void *                    aContext)
{
    static_cast<UbusServer *>(aContext)->HandleJoinerEvent(aEvent, aJoinerInfo, aJoinerId);
}

void UbusServer::HandleJoinerEvent(otCommissionerJoinerEvent aEvent,
                                   const otJoinerInfo *      aJoinerInfo,
                                   const otExtAddress *      aJoinerId)
{
    OT_UNUSED_VARIABLE(aJoinerInfo);
    OT_UNUSED_VARIABLE(aJoinerId);

    switch (aEvent)
    {
    case OT_COMMISSIONER_JOINER_START:
        otbrLogInfo(""Joiner start"");
        break;
    case OT_COMMISSIONER_JOINER_CONNECTED:
        otbrLogInfo(""Joiner connected"");
        break;
    case OT_COMMISSIONER_JOINER_FINALIZE:
        otbrLogInfo(""Joiner finalize"");
        break;
    case OT_COMMISSIONER_JOINER_END:
        otbrLogInfo(""Joiner end"");
        break;
    case OT_COMMISSIONER_JOINER_REMOVED:
        otbrLogInfo(""Joiner remove"");
        break;
    }
}

int UbusServer::UbusGetInformation(struct ubus_context *     aContext,
                                   struct ubus_object *      aObj,
                                   struct ubus_request_data *aRequest,
                                   const char *              aMethod,
                                   struct blob_attr *        aMsg,
                                   const char *              aAction)
{
    OT_UNUSED_VARIABLE(aObj);
    OT_UNUSED_VARIABLE(aMethod);
    OT_UNUSED_VARIABLE(aMsg);

    otError error = OT_ERROR_NONE;

    blob_buf_init(&mBuf, 0);

    mNcpThreadMutex->lock();
    if (!strcmp(aAction, ""networkname""))
        blobmsg_add_string(&mBuf, ""NetworkName"", otThreadGetNetworkName(mController->GetInstance()));
    else if (!strcmp(aAction, ""state""))
    {
        char state[10];
        GetState(mController->GetInstance(), state);
        blobmsg_add_string(&mBuf, ""State"", state);
    }
    else if (!strcmp(aAction, ""channel""))
        blobmsg_add_u32(&mBuf, ""Channel"", otLinkGetChannel(mController->GetInstance()));
    else if (!strcmp(aAction, ""panid""))
    {
        char panIdString[PANID_LENGTH];
        sprintf(panIdString, ""0x%04x"", otLinkGetPanId(mController->GetInstance()));
        blobmsg_add_string(&mBuf, ""PanId"", panIdString);
    }
    else if (!strcmp(aAction, ""rloc16""))
    {
        char rloc[PANID_LENGTH];
        sprintf(rloc, ""0x%04x"", otThreadGetRloc16(mController->GetInstance()));
        blobmsg_add_string(&mBuf, ""rloc16"", rloc);
    }
    else if (!strcmp(aAction, ""networkkey""))
    {
        char         outputKey[NETWORKKEY_LENGTH] = """";
        otNetworkKey key;

        otThreadGetNetworkKey(mController->GetInstance(), &key);
        OutputBytes(key.m8, OT_NETWORK_KEY_SIZE, outputKey);
        blobmsg_add_string(&mBuf, ""Networkkey"", outputKey);
    }
    else if (!strcmp(aAction, ""pskc""))
    {
        char   outputPskc[NETWORKKEY_LENGTH] = """";
        otPskc pskc;

        otThreadGetPskc(mController->GetInstance(), &pskc);
        OutputBytes(pskc.m8, OT_PSKC_MAX_SIZE, outputPskc);
        blobmsg_add_string(&mBuf, ""pskc"", outputPskc);
    }
    else if (!strcmp(aAction, ""extpanid""))
    {
        char           outputExtPanId[XPANID_LENGTH] = """";
        const uint8_t *extPanId =
            reinterpret_cast<const uint8_t *>(otThreadGetExtendedPanId(mController->GetInstance()));
        OutputBytes(extPanId, OT_EXT_PAN_ID_SIZE, outputExtPanId);
        blobmsg_add_string(&mBuf, ""ExtPanId"", outputExtPanId);
    }
    else if (!strcmp(aAction, ""mode""))
    {
        otLinkModeConfig linkMode;
        char             mode[5] = """";

        memset(&linkMode, 0, sizeof(otLinkModeConfig));

        linkMode = otThreadGetLinkMode(mController->GetInstance());

        if (linkMode.mRxOnWhenIdle)
        {
            strcat(mode, ""r"");
        }

        if (linkMode.mDeviceType)
        {
            strcat(mode, ""d"");
        }

        if (linkMode.mNetworkData)
        {
            strcat(mode, ""n"");
        }
        blobmsg_add_string(&mBuf, ""Mode"", mode);
    }
    else if (!strcmp(aAction, ""partitionid""))
    {
        blobmsg_add_u32(&mBuf, ""Partitionid"", otThreadGetPartitionId(mController->GetInstance()));
    }
    else if (!strcmp(aAction, ""leaderdata""))
    {
        otLeaderData leaderData;

        SuccessOrExit(error = otThreadGetLeaderData(mController->GetInstance(), &leaderData));

        sJsonUri = blobmsg_open_table(&mBuf, ""leaderdata"");

        blobmsg_add_u32(&mBuf, ""PartitionId"", leaderData.mPartitionId);
        blobmsg_add_u32(&mBuf, ""Weighting"", leaderData.mWeighting);
        blobmsg_add_u32(&mBuf, ""DataVersion"", leaderData.mDataVersion);
        blobmsg_add_u32(&mBuf, ""StableDataVersion"", leaderData.mStableDataVersion);
        blobmsg_add_u32(&mBuf, ""LeaderRouterId"", leaderData.mLeaderRouterId);

        blobmsg_close_table(&mBuf, sJsonUri);
    }
    else if (!strcmp(aAction, ""networkdata""))
    {
        ubus_send_reply(aContext, aRequest, mNetworkdataBuf.head);
        if (time(nullptr) - mSecond > 10)
        {
            struct otIp6Address address;
            uint8_t             tlvTypes[OT_NETWORK_DIAGNOSTIC_TYPELIST_MAX_ENTRIES];
            uint8_t             count             = 0;
            char                multicastAddr[10] = ""ff03::2"";

            blob_buf_init(&mNetworkdataBuf, 0);

            SuccessOrExit(error = otIp6AddressFromString(multicastAddr, &address));

            tlvTypes[count++] = static_cast<uint8_t>(OT_NETWORK_DIAGNOSTIC_TLV_ROUTE);
            tlvTypes[count++] = static_cast<uint8_t>(OT_NETWORK_DIAGNOSTIC_TLV_CHILD_TABLE);

            sBufNum = 0;
            otThreadSendDiagnosticGet(mController->GetInstance(), &address, tlvTypes, count,
                                      &UbusServer::HandleDiagnosticGetResponse, this);
            mSecond = time(nullptr);
        }
        goto exit;
    }
    else if (!strcmp(aAction, ""joinernum""))
    {
        void *       jsonTable = nullptr;
        void *       jsonArray = nullptr;
        otJoinerInfo joinerInfo;
        uint16_t     iterator        = 0;
        int          joinerNum       = 0;
        char         eui64[EXTPANID] = """";

        blob_buf_init(&mBuf, 0);

        jsonArray = blobmsg_open_array(&mBuf, ""joinerList"");
        while (otCommissionerGetNextJoinerInfo(mController->GetInstance(), &iterator, &joinerInfo) == OT_ERROR_NONE)
        {
            memset(eui64, 0, sizeof(eui64));

            jsonTable = blobmsg_open_table(&mBuf, nullptr);

            blobmsg_add_string(&mBuf, ""pskd"", joinerInfo.mPskd.m8);

            switch (joinerInfo.mType)
            {
            case OT_JOINER_INFO_TYPE_ANY:
                blobmsg_add_u16(&mBuf, ""isAny"", 1);
                break;
            case OT_JOINER_INFO_TYPE_EUI64:
                blobmsg_add_u16(&mBuf, ""isAny"", 0);
                OutputBytes(joinerInfo.mSharedId.mEui64.m8, sizeof(joinerInfo.mSharedId.mEui64.m8), eui64);
                blobmsg_add_string(&mBuf, ""eui64"", eui64);
                break;
            case OT_JOINER_INFO_TYPE_DISCERNER:
                blobmsg_add_u16(&mBuf, ""isAny"", 0);
                blobmsg_add_u64(&mBuf, ""discernerValue"", joinerInfo.mSharedId.mDiscerner.mValue);
                blobmsg_add_u16(&mBuf, ""discernerLength"", joinerInfo.mSharedId.mDiscerner.mLength);
                break;
            }

            blobmsg_close_table(&mBuf, jsonTable);

            joinerNum++;
        }
        blobmsg_close_array(&mBuf, jsonArray);

        blobmsg_add_u32(&mBuf, ""joinernum"", joinerNum);
    }
    else if (!strcmp(aAction, ""macfilterstate""))
    {
        otMacFilterAddressMode mode = otLinkFilterGetAddressMode(mController->GetInstance());

        blob_buf_init(&mBuf, 0);

        if (mode == OT_MAC_FILTER_ADDRESS_MODE_DISABLED)
        {
            blobmsg_add_string(&mBuf, ""state"", ""disable"");
        }
        else if (mode == OT_MAC_FILTER_ADDRESS_MODE_ALLOWLIST)
        {
            blobmsg_add_string(&mBuf, ""state"", ""allowlist"");
        }
        else if (mode == OT_MAC_FILTER_ADDRESS_MODE_DENYLIST)
        {
            blobmsg_add_string(&mBuf, ""state"", ""denylist"");
        }
        else
        {
            blobmsg_add_string(&mBuf, ""state"", ""error"");
        }
    }
    else if (!strcmp(aAction, ""macfilteraddr""))
    {
        otMacFilterEntry    entry;
        otMacFilterIterator iterator = OT_MAC_FILTER_ITERATOR_INIT;

        blob_buf_init(&mBuf, 0);

        sJsonUri = blobmsg_open_array(&mBuf, ""addrlist"");

        while (otLinkFilterGetNextAddress(mController->GetInstance(), &iterator, &entry) == OT_ERROR_NONE)
        {
            char extAddress[XPANID_LENGTH] = """";
            OutputBytes(entry.mExtAddress.m8, sizeof(entry.mExtAddress.m8), extAddress);
            blobmsg_add_string(&mBuf, ""addr"", extAddress);
        }

        blobmsg_close_array(&mBuf, sJsonUri);
    }
    else
    {
        perror(""invalid argument in get information ubus\\n"");
    }

    AppendResult(error, aContext, aRequest);
exit:
    mNcpThreadMutex->unlock();
    return 0;
}

void UbusServer::HandleDiagnosticGetResponse(otError              aError,
                                             otMessage *          aMessage,
                                             const otMessageInfo *aMessageInfo,
                                             void *               aContext)
{
    static_cast<UbusServer *>(aContext)->HandleDiagnosticGetResponse(aError, aMessage, aMessageInfo);
}

static bool IsRoutingLocator(const otIp6Address *aAddress)
{
    enum
    {
        kAloc16Mask            = 0xfc, ///< The mask for Aloc16.
        kRloc16ReservedBitMask = 0x02, ///< The mask for the reserved bit of Rloc16.
    };

    return (aAddress->mFields.m32[2] == htonl(0x000000ff) && aAddress->mFields.m16[6] == htons(0xfe00) &&
            aAddress->mFields.m8[14] < kAloc16Mask && (aAddress->mFields.m8[14] & kRloc16ReservedBitMask) == 0);
}

void UbusServer::HandleDiagnosticGetResponse(otError aError, otMessage *aMessage, const otMessageInfo *aMessageInfo)
{
    uint16_t              rloc16;
    uint16_t              sockRloc16 = 0;
    void *                jsonArray  = nullptr;
    void *                jsonItem   = nullptr;
    char                  xrloc[10];
    otNetworkDiagTlv      diagTlv;
    otNetworkDiagIterator iterator = OT_NETWORK_DIAGNOSTIC_ITERATOR_INIT;

    SuccessOrExit(aError);

    char networkdata[20];
    sprintf(networkdata, ""networkdata%d"", sBufNum);
    sJsonUri = blobmsg_open_table(&mNetworkdataBuf, networkdata);
    sBufNum++;

    if (IsRoutingLocator(&aMessageInfo->mSockAddr))
    {
        sockRloc16 = ntohs(aMessageInfo->mPeerAddr.mFields.m16[7]);
        sprintf(xrloc, ""0x%04x"", sockRloc16);
        blobmsg_add_string(&mNetworkdataBuf, ""rloc"", xrloc);
    }

    while (otThreadGetNextDiagnosticTlv(aMessage, &iterator, &diagTlv) == OT_ERROR_NONE)
    {
        switch (diagTlv.mType)
        {
        case OT_NETWORK_DIAGNOSTIC_TLV_ROUTE:
        {
            const otNetworkDiagRoute &route = diagTlv.mData.mRoute;

            jsonArray = blobmsg_open_array(&mNetworkdataBuf, ""routedata"");

            for (uint16_t i = 0; i < route.mRouteCount; ++i)
            {
                uint8_t in, out;
                in  = route.mRouteData[i].mLinkQualityIn;
                out = route.mRouteData[i].mLinkQualityOut;
                if (in != 0 && out != 0)
                {
                    jsonItem = blobmsg_open_table(&mNetworkdataBuf, ""router"");
                    rloc16   = route.mRouteData[i].mRouterId << 10;
                    blobmsg_add_u32(&mNetworkdataBuf, ""routerid"", route.mRouteData[i].mRouterId);
                    sprintf(xrloc, ""0x%04x"", rloc16);
                    blobmsg_add_string(&mNetworkdataBuf, ""rloc"", xrloc);
                    blobmsg_close_table(&mNetworkdataBuf, jsonItem);
                }
            }
            blobmsg_close_array(&mNetworkdataBuf, jsonArray);
            break;
        }

        case OT_NETWORK_DIAGNOSTIC_TLV_CHILD_TABLE:
        {
            jsonArray = blobmsg_open_array(&mNetworkdataBuf, ""childdata"");
            for (uint16_t i = 0; i < diagTlv.mData.mChildTable.mCount; ++i)
            {
                enum
                {
                    kModeRxOnWhenIdle     = 1 << 3, ///< If the device has its receiver on when not transmitting.
                    kModeFullThreadDevice = 1 << 1, ///< If the device is an FTD.
                    kModeFullNetworkData  = 1 << 0, ///< If the device requires the full Network Data.
                };
                const otNetworkDiagChildEntry &entry = diagTlv.mData.mChildTable.mTable[i];

                uint8_t mode = 0;

                jsonItem = blobmsg_open_table(&mNetworkdataBuf, ""child"");
                sprintf(xrloc, ""0x%04x"", (sockRloc16 | entry.mChildId));
                blobmsg_add_string(&mNetworkdataBuf, ""rloc"", xrloc);

                mode = (entry.mMode.mRxOnWhenIdle ? kModeRxOnWhenIdle : 0) |
                       (entry.mMode.mDeviceType ? kModeFullThreadDevice : 0) |
                       (entry.mMode.mNetworkData ? kModeFullNetworkData : 0);
                blobmsg_add_u16(&mNetworkdataBuf, ""mode"", mode);
                blobmsg_close_table(&mNetworkdataBuf, jsonItem);
            }
            blobmsg_close_array(&mNetworkdataBuf, jsonArray);
            break;
        }

        default:
            // Ignore other network diagnostics data.
            break;
        }
    }

    blobmsg_close_table(&mNetworkdataBuf, sJsonUri);

exit:
    if (aError != OT_ERROR_NONE)
    {
        otbrLogWarning(""Failed to receive diagnostic response: %s"", otThreadErrorToString(aError));
    }
}

int UbusServer::UbusSetInformation(struct ubus_context *     aContext,
                                   struct ubus_object *      aObj,
                                   struct ubus_request_data *aRequest,
                                   const char *              aMethod,
                                   struct blob_attr *        aMsg,
                                   const char *              aAction)
{
    OT_UNUSED_VARIABLE(aObj);
    OT_UNUSED_VARIABLE(aMethod);
    OT_UNUSED_VARIABLE(aMsg);

    otError error = OT_ERROR_NONE;

    blob_buf_init(&mBuf, 0);

    mNcpThreadMutex->lock();
    if (!strcmp(aAction, ""networkname""))
    {
        struct blob_attr *tb[SET_NETWORK_MAX];

        blobmsg_parse(setNetworknamePolicy, SET_NETWORK_MAX, tb, blob_data(aMsg), blob_len(aMsg));
        if (tb[SETNETWORK] != nullptr)
        {
            char *newName = blobmsg_get_string(tb[SETNETWORK]);
            SuccessOrExit(error = otThreadSetNetworkName(mController->GetInstance(), newName));
        }
    }
    else if (!strcmp(aAction, ""channel""))
    {
        struct blob_attr *tb[SET_NETWORK_MAX];

        blobmsg_parse(setChannelPolicy, SET_NETWORK_MAX, tb, blob_data(aMsg), blob_len(aMsg));
        if (tb[SETNETWORK] != nullptr)
        {
            uint32_t channel = blobmsg_get_u32(tb[SETNETWORK]);
            SuccessOrExit(error = otLinkSetChannel(mController->GetInstance(), static_cast<uint8_t>(channel)));
        }
    }
    else if (!strcmp(aAction, ""panid""))
    {
        struct blob_attr *tb[SET_NETWORK_MAX];

        blobmsg_parse(setPanIdPolicy, SET_NETWORK_MAX, tb, blob_data(aMsg), blob_len(aMsg));
        if (tb[SETNETWORK] != nullptr)
        {
            long  value;
            char *panid = blobmsg_get_string(tb[SETNETWORK]);
            SuccessOrExit(error = ParseLong(panid, value));
            error = otLinkSetPanId(mController->GetInstance(), static_cast<otPanId>(value));
        }
    }
    else if (!strcmp(aAction, ""networkkey""))
    {
        struct blob_attr *tb[SET_NETWORK_MAX];

        blobmsg_parse(setNetworkkeyPolicy, SET_NETWORK_MAX, tb, blob_data(aMsg), blob_len(aMsg));
        if (tb[SETNETWORK] != nullptr)
        {
            otNetworkKey key;
            char *       networkkey = blobmsg_get_string(tb[SETNETWORK]);

            VerifyOrExit(Hex2Bin(networkkey, key.m8, sizeof(key.m8)) == OT_NETWORK_KEY_SIZE, error = OT_ERROR_PARSE);
            SuccessOrExit(error = otThreadSetNetworkKey(mController->GetInstance(), &key));
        }
    }
    else if (!strcmp(aAction, ""pskc""))
    {
        struct blob_attr *tb[SET_NETWORK_MAX];

        blobmsg_parse(setPskcPolicy, SET_NETWORK_MAX, tb, blob_data(aMsg), blob_len(aMsg));
        if (tb[SETNETWORK] != nullptr)
        {
            otPskc pskc;

            VerifyOrExit(Hex2Bin(blobmsg_get_string(tb[SETNETWORK]), pskc.m8, sizeof(pskc)) == OT_PSKC_MAX_SIZE,
                         error = OT_ERROR_PARSE);
            SuccessOrExit(error = otThreadSetPskc(mController->GetInstance(), &pskc));
        }
    }
    else if (!strcmp(aAction, ""extpanid""))
    {
        struct blob_attr *tb[SET_NETWORK_MAX];

        blobmsg_parse(setExtPanIdPolicy, SET_NETWORK_MAX, tb, blob_data(aMsg), blob_len(aMsg));
        if (tb[SETNETWORK] != nullptr)
        {
            otExtendedPanId extPanId;
            char *          input = blobmsg_get_string(tb[SETNETWORK]);
            VerifyOrExit(Hex2Bin(input, extPanId.m8, sizeof(extPanId)) >= 0, error = OT_ERROR_PARSE);
            error = otThreadSetExtendedPanId(mController->GetInstance(), &extPanId);
        }
    }
    else if (!strcmp(aAction, ""mode""))
    {
        otLinkModeConfig  linkMode;
        struct blob_attr *tb[SET_NETWORK_MAX];

        blobmsg_parse(setModePolicy, SET_NETWORK_MAX, tb, blob_data(aMsg), blob_len(aMsg));
        if (tb[SETNETWORK] != nullptr)
        {
            char *inputMode = blobmsg_get_string(tb[SETNETWORK]);
            for (char *ch = inputMode; *ch != '\\0'; ch++)
            {
                switch (*ch)
                {
                case 'r':
                    linkMode.mRxOnWhenIdle = 1;
                    break;

                case 'd':
                    linkMode.mDeviceType = 1;
                    break;

                case 'n':
                    linkMode.mNetworkData = 1;
                    break;

                default:
                    ExitNow(error = OT_ERROR_PARSE);
                }
            }

            SuccessOrExit(error = otThreadSetLinkMode(mController->GetInstance(), linkMode));
        }
    }
    else if (!strcmp(aAction, ""macfilteradd""))
    {
        struct blob_attr *tb[SET_NETWORK_MAX];
        otExtAddress      extAddr;

        blobmsg_parse(macfilterAddPolicy, SET_NETWORK_MAX, tb, blob_data(aMsg), blob_len(aMsg));
        if (tb[SETNETWORK] != nullptr)
        {
            char *addr = blobmsg_get_string(tb[SETNETWORK]);

            VerifyOrExit(Hex2Bin(addr, extAddr.m8, OT_EXT_ADDRESS_SIZE) == OT_EXT_ADDRESS_SIZE, error = OT_ERROR_PARSE);

            error = otLinkFilterAddAddress(mController->GetInstance(), &extAddr);

            VerifyOrExit(error == OT_ERROR_NONE || error == OT_ERROR_ALREADY);
        }
    }
    else if (!strcmp(aAction, ""macfilterremove""))
    {
        struct blob_attr *tb[SET_NETWORK_MAX];
        otExtAddress      extAddr;

        blobmsg_parse(macfilterRemovePolicy, SET_NETWORK_MAX, tb, blob_data(aMsg), blob_len(aMsg));
        if (tb[SETNETWORK] != nullptr)
        {
            char *addr = blobmsg_get_string(tb[SETNETWORK]);
            VerifyOrExit(Hex2Bin(addr, extAddr.m8, OT_EXT_ADDRESS_SIZE) == OT_EXT_ADDRESS_SIZE, error = OT_ERROR_PARSE);

            otLinkFilterRemoveAddress(mController->GetInstance(), &extAddr);
        }
    }
    else if (!strcmp(aAction, ""macfiltersetstate""))
    {
        struct blob_attr *tb[SET_NETWORK_MAX];

        blobmsg_parse(macfilterSetStatePolicy, SET_NETWORK_MAX, tb, blob_data(aMsg), blob_len(aMsg));
        if (tb[SETNETWORK] != nullptr)
        {
            char *state = blobmsg_get_string(tb[SETNETWORK]);

            if (strcmp(state, ""disable"") == 0)
            {
                otLinkFilterSetAddressMode(mController->GetInstance(), OT_MAC_FILTER_ADDRESS_MODE_DISABLED);
            }
            else if (strcmp(state, ""allowlist"") == 0)
            {
                otLinkFilterSetAddressMode(mController->GetInstance(), OT_MAC_FILTER_ADDRESS_MODE_ALLOWLIST);
            }
            else if (strcmp(state, ""denylist"") == 0)
            {
                otLinkFilterSetAddressMode(mController->GetInstance(), OT_MAC_FILTER_ADDRESS_MODE_DENYLIST);
            }
        }
    }
    else if (!strcmp(aAction, ""macfilterclear""))
    {
        otLinkFilterClearAddresses(mController->GetInstance());
    }
    else
    {
        perror(""invalid argument in get information ubus\\n"");
    }

exit:
    mNcpThreadMutex->unlock();
    AppendResult(error, aContext, aRequest);
    return 0;
}

void UbusServer::GetState(otInstance *aInstance, char *aState)
{
    switch (otThreadGetDeviceRole(aInstance))
    {
    case OT_DEVICE_ROLE_DISABLED:
        strcpy(aState, ""disabled"");
        break;

    case OT_DEVICE_ROLE_DETACHED:
        strcpy(aState, ""detached"");
        break;

    case OT_DEVICE_ROLE_CHILD:
        strcpy(aState, ""child"");
        break;

    case OT_DEVICE_ROLE_ROUTER:
        strcpy(aState, ""router"");
        break;

    case OT_DEVICE_ROLE_LEADER:
        strcpy(aState, ""leader"");
        break;
    default:
        strcpy(aState, ""invalid aState"");
        break;
    }
}

void UbusServer::UbusAddFd()
{
    // ubus library function
    ubus_add_uloop(mContext);

#ifdef FD_CLOEXEC
    fcntl(mContext->sock.fd, F_SETFD, fcntl(mContext->sock.fd, F_GETFD) | FD_CLOEXEC);
#endif
}

void UbusServer::UbusReconnTimer(struct uloop_timeout *aTimeout)
{
    GetInstance().UbusReconnTimerDetail(aTimeout);
}

void UbusServer::UbusReconnTimerDetail(struct uloop_timeout *aTimeout)
{
    OT_UNUSED_VARIABLE(aTimeout);

    static struct uloop_timeout retry = {
        list : {},
        pending : false,
        cb : UbusReconnTimer,
        time : {},
    };
    int time = 2;

    if (ubus_reconnect(mContext, mSockPath) != 0)
    {
        uloop_timeout_set(&retry, time * 1000);
        return;
    }

    UbusAddFd();
}

void UbusServer::UbusConnectionLost(struct ubus_context *aContext)
{
    OT_UNUSED_VARIABLE(aContext);

    UbusReconnTimer(nullptr);
}

int UbusServer::DisplayUbusInit(const char *aPath)
{
    uloop_init();
    signal(SIGPIPE, SIG_IGN);

    mSockPath = aPath;

    mContext = ubus_connect(aPath);
    if (!mContext)
    {
        otbrLogErr(""Ubus connect failed"");
        return -1;
    }

    otbrLogInfo(""Connected as %08x\\n"", mContext->local_id);
    mContext->connection_lost = UbusConnectionLost;

    /* file description */
    UbusAddFd();

    /* Add a object */
    if (ubus_add_object(mContext, &otbr) != 0)
    {
        otbrLogErr(""Ubus add obj failed"");
        return -1;
    }

    return 0;
}

void UbusServer::DisplayUbusDone(void)
{
    if (mContext)
    {
        ubus_free(mContext);
        mContext = nullptr;
    }
}

void UbusServer::InstallUbusObject(void)
{
    char *path = nullptr;

    if (-1 == DisplayUbusInit(path))
    {
        otbrLogErr(""Ubus connect failed"");
        return;
    }

    otbrLogInfo(""Uloop run"");
    uloop_run();

    DisplayUbusDone();

    uloop_done();
}

otError UbusServer::ParseLong(char *aString, long &aLong)
{
    char *endptr;
    aLong = strtol(aString, &endptr, 0);
    return (*endptr == '\\0') ? OT_ERROR_NONE : OT_ERROR_PARSE;
}

int UbusServer::Hex2Bin(const char *aHex, uint8_t *aBin, uint16_t aBinLength)
{
    size_t      hexLength = strlen(aHex);
    const char *hexEnd    = aHex + hexLength;
    uint8_t *   cur       = aBin;
    uint8_t     numChars  = hexLength & 1;
    uint8_t     byte      = 0;
    int         rval;

    VerifyOrExit((hexLength + 1) / 2 <= aBinLength, rval = -1);

    while (aHex < hexEnd)
    {
        if ('A' <= *aHex && *aHex <= 'F')
        {
            byte |= 10 + (*aHex - 'A');
        }
        else if ('a' <= *aHex && *aHex <= 'f')
        {
            byte |= 10 + (*aHex - 'a');
        }
        else if ('0' <= *aHex && *aHex <= '9')
        {
            byte |= *aHex - '0';
        }
        else
        {
            ExitNow(rval = -1);
        }

        aHex++;
        numChars++;

        if (numChars >= 2)
        {
            numChars = 0;
            *cur++   = byte;
            byte     = 0;
        }
        else
        {
            byte <<= 4;
        }
    }

    rval = static_cast<int>(cur - aBin);

exit:
    return rval;
}

void UBusAgent::Init(void)
{
    otbr::ubus::sUbusEfd = eventfd(0, 0);

    otbr::ubus::UbusServer::Initialize(&mNcp, &mThreadMutex);

    if (otbr::ubus::sUbusEfd == -1)
    {
        perror(""Failed to create eventfd for ubus"");
        exit(EXIT_FAILURE);
    }

    std::thread(UbusServerRun).detach();
}

void UBusAgent::Update(MainloopContext &aMainloop)
{
    VerifyOrExit(otbr::ubus::sUbusEfd != -1);

    FD_SET(otbr::ubus::sUbusEfd, &aMainloop.mReadFdSet);

    if (aMainloop.mMaxFd < otbr::ubus::sUbusEfd)
    {
        aMainloop.mMaxFd = otbr::ubus::sUbusEfd;
    }

exit:
    mThreadMutex.unlock();
    return;
}

void UBusAgent::Process(const MainloopContext &aMainloop)
{
    ssize_t  retval;
    uint64_t num;

    mThreadMutex.lock();

    VerifyOrExit(otbr::ubus::sUbusEfd != -1);

    if (FD_ISSET(otbr::ubus::sUbusEfd, &aMainloop.mReadFdSet))
    {
        retval = read(otbr::ubus::sUbusEfd, &num, sizeof(uint64_t));
        if (retval != sizeof(uint64_t))
        {
            perror(""read ubus eventfd failed\\n"");
            exit(EXIT_FAILURE);
        }
    }

exit:
    return;
}

} // namespace ubus
} // namespace otbr
",16243,True,3221.421071043207,median
"// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.

#include <algorithm>
#include <cfenv>
#include <vector>

#include ""gtest/gtest.h""
#include ""test/common/quantization_test_utils.h""
#include ""test/common/tensor_op_test_utils.h""
#include ""test/common/cuda_op_test_utils.h""
#include ""test/providers/provider_test_utils.h""
#include ""core/util/qmath.h""
#include ""core/quantization/quantization.h""

namespace onnxruntime {
namespace test {

enum class EP : char {
  CPU,
  CUDA
};


// input:      [batch_size, sequence_length, hidden_size]
// weights:    [hidden_size, 3 * hidden_size]
// bias:       [3 * hidden_size]
// mask_index: [batch_size]
// output:     [batch_size, sequence_length, hidden_size]
template <typename QInput, typename QWeight, EP ep>
void RunQAttention(const std::vector<float>& input_data,
                   const std::vector<float>& weights_data,
                   const std::vector<float>& bias_data,
                   const std::vector<int32_t>& mask_index_data,
                   const std::vector<float>& output_data,
                   quantization::Params<QInput>& input_quant_params,
                   quantization::Params<QWeight>& weight_quant_params,
                   int batch_size,
                   int sequence_length,
                   int hidden_size,
                   int number_of_heads,
                   bool is_unidirectional = false,
                   bool use_float16 = false,
                   int input_hidden_size = 0) {
  input_hidden_size = (input_hidden_size == 0) ? hidden_size : input_hidden_size;

  OpTester tester(""QAttention"", 1, onnxruntime::kMSDomain);
  tester.AddAttribute<int64_t>(""num_heads"", static_cast<int64_t>(number_of_heads));
  if (is_unidirectional) {
    tester.AddAttribute<int64_t>(""unidirectional"", 1);
  }

  std::vector<int64_t> input_dims = {batch_size, sequence_length, input_hidden_size};
  std::vector<int64_t> weights_dims = {input_hidden_size, static_cast<int64_t>(3 * hidden_size)};
  std::vector<int64_t> bias_dims = {static_cast<int64_t>(3 * hidden_size)};
  std::vector<int64_t> mask_index_dims = {batch_size};
  std::vector<int64_t> output_dims = {batch_size, sequence_length, hidden_size};

  if (input_quant_params.scale != 0.0f) {
    tester.AddInput<QInput>(""input"",
                            input_dims,
                            QuantizeTestVector<QInput>(input_data, input_quant_params));
    tester.AddInput<QWeight>(""weight"",
                             weights_dims,
                             QuantizeTestVector<QWeight>(weights_data, weight_quant_params));
  } else {
    bool force_symmetric = false;
    if constexpr (ep == EP::CUDA) {
      force_symmetric = true;
    }
    tester.AddInput<QInput>(
        ""input"",
        input_dims,
        QuantizeLinearTestVector<QInput>(input_data, input_quant_params, force_symmetric));
    tester.AddInput<QWeight>(
        ""weight"",
        weights_dims,
        QuantizeLinearTestVector<QWeight>(weights_data, weight_quant_params, force_symmetric));
  }
  if (use_float16) {
    tester.AddInput<MLFloat16>(""bias"", bias_dims, ToFloat16(bias_data));
    tester.AddInput<MLFloat16>(""input_scale"", {1}, ToFloat16({input_quant_params.scale}));
    tester.AddInput<MLFloat16>(""weight_scale"", {1}, ToFloat16({weight_quant_params.scale}));
    tester.AddOutput<MLFloat16>(""output"", output_dims, ToFloat16(output_data));
  } else {
    tester.AddInput<float>(""bias"", bias_dims, bias_data);
    tester.AddInput<float>(""input_scale"", {1}, {input_quant_params.scale});
    tester.AddInput<float>(""weight_scale"", {1}, {weight_quant_params.scale});
    tester.AddOutput<float>(""output"", output_dims, output_data);
  }

  if (mask_index_data.size() > 0) {
    tester.AddInput<int32_t>(""mask_index"", mask_index_dims, mask_index_data);
  } else {
    // mask index is optional.
    tester.AddOptionalInputEdge<int32_t>();
  }

  tester.AddInput<QInput>(""input_zero_point"", {1}, {input_quant_params.zero_point});
  tester.AddInput<QWeight>(""weight_zero_point"", {1}, {weight_quant_params.zero_point});

  if constexpr (ep == EP::CUDA) {
    std::vector<std::unique_ptr<IExecutionProvider>> execution_providers;
    execution_providers.push_back(DefaultCudaExecutionProvider());
    tester.Run(OpTester::ExpectResult::kExpectSuccess, """", {kTensorrtExecutionProvider}, nullptr, &execution_providers);
  } else {
    std::vector<std::unique_ptr<IExecutionProvider>> execution_providers;
    execution_providers.push_back(DefaultCpuExecutionProvider());
    tester.Run(OpTester::ExpectResult::kExpectSuccess, """", {kTensorrtExecutionProvider}, nullptr, &execution_providers);
  }
}

static void RunQAttentionCUDA(
    const std::vector<float>& input_data,
    const std::vector<float>& weights_data,
    const std::vector<float>& bias_data,
    const std::vector<int32_t>& mask_index_data,
    const std::vector<float>& output_data,
    int batch_size,
    int sequence_length,
    int hidden_size,
    int number_of_heads,
    bool use_special_quantize_parameter = true,
    bool is_unidirectional = false,
    bool use_float16 = false,
    int input_hidden_size = 0) {
  int min_cuda_architecture = 530;
  bool enable_cuda = HasCudaEnvironment(min_cuda_architecture);

  if (enable_cuda) {
    quantization::Params<int8_t> input_quant_params = {0.0f, 0};
    quantization::Params<int8_t> weights_quant_params = {0.0f, 0};
    if (use_special_quantize_parameter) {
      input_quant_params.scale = 0.1f;
      weights_quant_params.scale = 0.1f;
    }
    RunQAttention<int8_t, int8_t, EP::CUDA>(
        input_data, weights_data, bias_data, mask_index_data, output_data, input_quant_params, weights_quant_params,
        batch_size, sequence_length, hidden_size, number_of_heads, is_unidirectional, use_float16, input_hidden_size);
  }
}

static void RunQAttentionU8U8(
    const std::vector<float>& input_data,
    const std::vector<float>& weights_data,
    const std::vector<float>& bias_data,
    const std::vector<int32_t>& mask_index_data,
    const std::vector<float>& output_data,
    int batch_size,
    int sequence_length,
    int hidden_size,
    int number_of_heads,
    bool use_special_quantize_parameter = true,
    bool is_unidirectional = false,
    int input_hidden_size = 0) {
  quantization::Params<uint8_t> input_quant_params = {0.0f, 0};
  quantization::Params<uint8_t> weights_quant_params = {0.0f, 0};
  if (use_special_quantize_parameter) {
    input_quant_params.scale = 0.1f;
    weights_quant_params.scale = 0.1f;
    input_quant_params.zero_point = 128;
    weights_quant_params.zero_point = 128;
  }

  RunQAttention<uint8_t, uint8_t, EP::CPU>(
      input_data, weights_data, bias_data, mask_index_data, output_data, input_quant_params, weights_quant_params,
      batch_size, sequence_length, hidden_size, number_of_heads, is_unidirectional, false, input_hidden_size);
}

static void RunQAttentionU8S8(
    const std::vector<float>& input_data,
    const std::vector<float>& weights_data,
    const std::vector<float>& bias_data,
    const std::vector<int32_t>& mask_index_data,
    const std::vector<float>& output_data,
    int batch_size,
    int sequence_length,
    int hidden_size,
    int number_of_heads,
    bool use_special_quantize_parameter = true,
    bool is_unidirectional = false,
    int input_hidden_size = 0) {
  quantization::Params<uint8_t> input_quant_params(/*scale=*/0.0f, /*zero_point=*/0);
  quantization::Params<int8_t> weights_quant_params(/*scale=*/0.0f, /*zero_point=*/0);
  if (use_special_quantize_parameter) {
    input_quant_params.scale = 0.1f;
    weights_quant_params.scale = 0.1f;
    input_quant_params.zero_point = 128;
    weights_quant_params.zero_point = 1;
  }

  RunQAttention<uint8_t, int8_t, EP::CPU>(
      input_data, weights_data, bias_data, mask_index_data, output_data, input_quant_params, weights_quant_params,
      batch_size, sequence_length, hidden_size, number_of_heads, is_unidirectional, false, input_hidden_size);
}

static void RunQAttentionAll(
    const std::vector<float>& input_data,
    const std::vector<float>& weight_data,
    const std::vector<float>& bias_data,
    const std::vector<int32_t>& mask_index_data,
    const std::vector<float>& output_data,
    int batch_size,
    int sequence_length,
    int hidden_size,
    int number_of_heads,
    bool use_special_quantize_parameter = true,
    bool is_unidirectional = false,
    bool use_float16 = false,
    int input_hidden_size = 0) {
  RunQAttentionU8U8(input_data, weight_data, bias_data, mask_index_data, output_data,
                    batch_size, sequence_length, hidden_size, number_of_heads,
                    use_special_quantize_parameter, is_unidirectional, input_hidden_size);
  RunQAttentionU8S8(input_data, weight_data, bias_data, mask_index_data, output_data,
                    batch_size, sequence_length, hidden_size, number_of_heads,
                    use_special_quantize_parameter, is_unidirectional, input_hidden_size);
  RunQAttentionCUDA(input_data, weight_data, bias_data, mask_index_data, output_data,
                    batch_size, sequence_length, hidden_size, number_of_heads,
                    use_special_quantize_parameter, is_unidirectional, use_float16, input_hidden_size);
}

TEST(QAttentionTest, QAttentionBatch1) {
  int batch_size = 1;
  int sequence_length = 2;
  int hidden_size = 4;
  int number_of_heads = 2;

  std::vector<float> input_data = {
      0.8f, -0.5f, 0.0f, 1.f,
      0.5f, 0.2f, 0.3f, -0.6f};

  std::vector<float> weight_data = {
      0.1f, -0.2f, 0.3f, 1.0f, 1.1f, 0.3f, 0.5f, 0.2f, 0.3f, -0.6f, 1.5f, 2.0f,
      0.5f, 0.1f, 0.4f, 1.6f, 1.0f, 2.0f, 0.4f, 0.8f, 0.9f, 0.1f, -1.3f, 0.7f,
      0.3f, 0.2f, 4.0f, 2.2f, 1.6f, 1.1f, 0.7f, 0.2f, 0.4f, 1.0f, 1.2f, 0.5f,
      0.2f, 0.1f, 0.4f, 1.6f, 2.4f, 3.3f, 2.1f, 4.2f, 8.4f, 0.0f, 2.1f, 3.2f};

  std::vector<float> bias_data = {
      -0.5f, 0.6f, 1.2f, 2.1f, 0.5f, 0.7f, 0.2f, 1.2f, 0.5f, 0.4f, 0.3f, 1.2f};

  std::vector<int32_t> mask_index_data = {2L};

  std::vector<float> output_data = {
      3.1495983600616455f, 0.10843668878078461f, 4.25f, 5.6499996185302734f,
      3.9696791172027588f, 0.073143675923347473f, 4.2499995231628418f, 5.6499991416931152f};

  RunQAttentionAll(input_data, weight_data, bias_data, mask_index_data, output_data,
                   batch_size, sequence_length, hidden_size, number_of_heads);
}

TEST(QAttentionTest, QAttentionBatch1_Float16) {
  int batch_size = 1;
  int sequence_length = 2;
  int hidden_size = 4;
  int number_of_heads = 2;

  std::vector<float> input_data = {
      0.8f, -0.5f, 0.0f, 1.f,
      0.5f, 0.2f, 0.3f, -0.6f};

  std::vector<float> weight_data = {
      0.1f, -0.2f, 0.3f, 1.0f, 1.1f, 0.3f, 0.5f, 0.2f, 0.3f, -0.6f, 1.5f, 2.0f,
      0.5f, 0.1f, 0.4f, 1.6f, 1.0f, 2.0f, 0.4f, 0.8f, 0.9f, 0.1f, -1.3f, 0.7f,
      0.3f, 0.2f, 4.0f, 2.2f, 1.6f, 1.1f, 0.7f, 0.2f, 0.4f, 1.0f, 1.2f, 0.5f,
      0.2f, 0.1f, 0.4f, 1.6f, 2.4f, 3.3f, 2.1f, 4.2f, 8.4f, 0.0f, 2.1f, 3.2f};

  std::vector<float> bias_data = {
      -0.5f, 0.6f, 1.2f, 2.1f, 0.5f, 0.7f, 0.2f, 1.2f, 0.5f, 0.4f, 0.3f, 1.2f};

  std::vector<int32_t> mask_index_data = {2L};

  std::vector<float> output_data = {
      3.15039f, 0.1082763671875f, 4.24609375f, 5.6484375f,
      3.96679f, 0.072998046875f, 4.24609f, 5.6484375f};

  RunQAttentionCUDA(input_data, weight_data, bias_data, mask_index_data, output_data,
                    batch_size, sequence_length, hidden_size, number_of_heads,
                    true /*use_special_quantize_parameter*/,
                    false /*is_unidirectional*/,
                    true /*use_float16*/);
}

TEST(QAttentionTest, QAttentionBatch2) {
  int batch_size = 2;
  int sequence_length = 2;
  int hidden_size = 4;
  int number_of_heads = 2;

  std::vector<float> input_data = {
      0.8f, -0.5f, 0.0f, 1.f,
      0.5f, 0.2f, 0.3f, -0.6f,
      0.8f, -0.5f, 0.0f, 1.f,
      0.5f, 0.2f, 0.3f, -0.6f};

  std::vector<float> weight_data = {
      0.1f, -0.2f, 0.3f, 1.0f, 1.1f, 0.3f, 0.5f, 0.2f, 0.3f, -0.6f, 1.5f, 2.0f,
      0.5f, 0.1f, 0.4f, 1.6f, 1.0f, 2.0f, 0.4f, 0.8f, 0.9f, 0.1f, -1.3f, 0.7f,
      0.3f, 0.2f, 4.0f, 2.2f, 1.6f, 1.1f, 0.7f, 0.2f, 0.4f, 1.0f, 1.2f, 0.5f,
      0.2f, 0.1f, 0.4f, 1.6f, 2.4f, 3.3f, 2.1f, 4.2f, 8.4f, 0.0f, 2.1f, 3.2f};

  std::vector<float> bias_data = {
      -0.5f, 0.6f, 1.2f, 2.1f, 0.5f, 0.7f, 0.2f, 1.2f, 0.5f, 0.4f, 0.3f, 1.2f};

  std::vector<int32_t> mask_index_data = {2L, 2L};

  std::vector<float> output_data = {
      3.1495983600616455f, 0.10843668878078461f, 4.25f, 5.6499996185302734f,
      3.9696791172027588f, 0.073143675923347473f, 4.2499995231628418f, 5.6499991416931152f,
      3.1495983600616455f, 0.10843668878078461f, 4.25f, 5.6499996185302734f,
      3.9696791172027588f, 0.073143675923347473f, 4.2499995231628418f, 5.6499991416931152f};

  RunQAttentionAll(input_data, weight_data, bias_data, mask_index_data, output_data,
                   batch_size, sequence_length, hidden_size, number_of_heads);
}

TEST(QAttentionTest, QAttentionMaskPartialSequence) {
  int batch_size = 1;
  int sequence_length = 2;
  int hidden_size = 4;
  int number_of_heads = 2;

  std::vector<float> input_data = {
      0.8f, -0.5f, 0.0f, 1.f,
      0.5f, 0.2f, 0.3f, -0.6f};

  std::vector<float> weight_data = {
      0.1f, -0.2f, 0.3f, 1.0f, 1.1f, 0.3f, 0.5f, 0.2f, 0.3f, -0.6f, 1.5f, 2.0f,
      0.5f, 0.1f, 0.4f, 1.6f, 1.0f, 2.0f, 0.4f, 0.8f, 0.9f, 0.1f, -1.3f, 0.7f,
      0.3f, 0.2f, 4.0f, 2.2f, 1.6f, 1.1f, 0.7f, 0.2f, 0.4f, 1.0f, 1.2f, 0.5f,
      0.2f, 0.1f, 0.4f, 1.6f, 2.4f, 3.3f, 2.1f, 4.2f, 8.4f, 0.0f, 2.1f, 3.2f};

  std::vector<float> bias_data = {
      -0.5f, 0.6f, 1.2f, 2.1f, 0.5f, 0.7f, 0.2f, 1.2f, 0.5f, 0.4f, 0.3f, 1.2f};

  // Test mask_index < sequence_length
  std::vector<int32_t> mask_index_data = {1L};

  std::vector<float> output_data = {
      8.6899995803833008f, -0.13000002503395081f, 4.25f, 5.6499996185302734f,
      8.6899995803833008f, -0.13000002503395081f, 4.2499995231628418f, 5.6499991416931152f};

  RunQAttentionAll(input_data, weight_data, bias_data, mask_index_data, output_data,
                   batch_size, sequence_length, hidden_size, number_of_heads);
}

TEST(QAttentionTest, QAttentionMaskExceedSequence) {
  int batch_size = 1;
  int sequence_length = 2;
  int hidden_size = 4;
  int number_of_heads = 2;

  std::vector<float> input_data = {
      0.8f, -0.5f, 0.0f, 1.f,
      0.5f, 0.2f, 0.3f, -0.6f};

  std::vector<float> weight_data = {
      0.1f, -0.2f, 0.3f, 1.0f, 1.1f, 0.3f, 0.5f, 0.2f, 0.3f, -0.6f, 1.5f, 2.0f,
      0.5f, 0.1f, 0.4f, 1.6f, 1.0f, 2.0f, 0.4f, 0.8f, 0.9f, 0.1f, -1.3f, 0.7f,
      0.3f, 0.2f, 4.0f, 2.2f, 1.6f, 1.1f, 0.7f, 0.2f, 0.4f, 1.0f, 1.2f, 0.5f,
      0.2f, 0.1f, 0.4f, 1.6f, 2.4f, 3.3f, 2.1f, 4.2f, 8.4f, 0.0f, 2.1f, 3.2f};

  std::vector<float> bias_data = {
      -0.5f, 0.6f, 1.2f, 2.1f, 0.5f, 0.7f, 0.2f, 1.2f, 0.5f, 0.4f, 0.3f, 1.2f};

  // Test mask_index > sequence_length
  std::vector<int32_t> mask_index_data = {3L};

  std::vector<float> output_data = {
      3.1495983600616455f, 0.10843668878078461f, 4.25f, 5.6499996185302734f,
      3.9696791172027588f, 0.073143675923347473f, 4.2499995231628418f, 5.6499991416931152f};

  RunQAttentionAll(input_data, weight_data, bias_data, mask_index_data, output_data,
                   batch_size, sequence_length, hidden_size, number_of_heads);
}

TEST(QAttentionTest, QAttentionNoMaskIndex) {
  int batch_size = 1;
  int sequence_length = 2;
  int hidden_size = 4;
  int number_of_heads = 2;

  std::vector<float> input_data = {
      0.8f, -0.5f, 0.0f, 1.f,
      0.5f, 0.2f, 0.3f, -0.6f};

  std::vector<float> weight_data = {
      0.1f, -0.2f, 0.3f, 1.0f, 1.1f, 0.3f, 0.5f, 0.2f, 0.3f, -0.6f, 1.5f, 2.0f,
      0.5f, 0.1f, 0.4f, 1.6f, 1.0f, 2.0f, 0.4f, 0.8f, 0.9f, 0.1f, -1.3f, 0.7f,
      0.3f, 0.2f, 4.0f, 2.2f, 1.6f, 1.1f, 0.7f, 0.2f, 0.4f, 1.0f, 1.2f, 0.5f,
      0.2f, 0.1f, 0.4f, 1.6f, 2.4f, 3.3f, 2.1f, 4.2f, 8.4f, 0.0f, 2.1f, 3.2f};

  std::vector<float> bias_data = {
      -0.5f, 0.6f, 1.2f, 2.1f, 0.5f, 0.7f, 0.2f, 1.2f, 0.5f, 0.4f, 0.3f, 1.2f};

  // No mask_index
  std::vector<int32_t> mask_index_data = {};

  std::vector<float> output_data = {
      3.1495983600616455f, 0.10843668878078461f, 4.25f, 5.6499996185302734f,
      3.9696791172027588f, 0.073143675923347473f, 4.2499995231628418f, 5.6499991416931152f};

  RunQAttentionAll(input_data, weight_data, bias_data, mask_index_data, output_data,
                   batch_size, sequence_length, hidden_size, number_of_heads);
}

TEST(QAttentionTest, QAttentionUnidirectional_U8U8) {
  int batch_size = 1;
  int sequence_length = 2;
  int hidden_size = 4;
  int number_of_heads = 2;

  std::vector<float> input_data = {
      0.91099896f, -0.18294459f, -0.36594841f, 0.28410032f,
      -0.12125026f, -0.66160089f, 0.38809127f, -0.22455512f};

  std::vector<float> weight_data = {
      -0.2659236192703247f,
      0.2789675071835518f,
      0.7280516624450684f,
      0.50951678305864334f,
      0.20417947322130203f,
      -0.4751841351389885f,
      0.43815530836582184f,
      0.6015353370457888f,
      -0.11496957391500473f,
      -0.1773347705602646f,
      0.30928605794906616f,
      0.5648412741720676f,

      0.8960387855768204f,
      -0.27270448207855225f,
      0.14847396314144135f,
      -0.17960812151432037f,
      0.1788954995572567f,
      0.9993876516819f,
      0.3943513706326485f,
      -0.2484400011599064f,
      -0.12958766520023346f,
      0.220433309674263f,
      0.1720484346151352f,
      0.22024005651474f,

      0.59368450194597244f,
      0.1710093915462494f,
      -0.3967452347278595f,
      -0.1591450721025467f,
      0.1446179747581482f,
      -0.20505407452583313f,
      0.12749597430229187f,
      0.32139700651168823f,
      0.139958456158638f,
      -0.10619817674160004f,
      0.4528557509183884f,
      0.45598603785037994f,

      -0.7152545265853405f,
      0.109454445540905f,
      -0.1582530289888382f,
      -0.2646341919898987f,
      0.920850858092308f,
      0.701494812965393f,
      -0.19062495231628418f,
      -0.24360455572605133f,
      -0.9368397295475006f,
      0.7878211885690689f,
      0.2973634898662567f,
      0.11210034042596817f};

  std::vector<float> bias_data = {
      -0.0540979839861393f,
      -0.06444740295410156f,
      0.03112877532839775f,
      -0.08288222551345825f,
      0.07840359210968018f,
      0.039143580943346024f,
      -0.45591455698013306f,
      -0.11876055598258972f,
      0.3670335114002228f,
      0.028461361303925514f,
      -0.08913630992174149f,
      0.28048714995384216f};

  // No mask_index
  std::vector<int32_t> mask_index_data = {};

  std::vector<float> output_data = {
      -0.027716159820556641f, 0.091021925210952759f,
      0.080938525497913361f, 0.61913836002349854f,
      0.36089283227920532f, -0.11653690040111542f,
      -0.030121456831693649f, 0.40923327207565308f};

  RunQAttentionU8U8(input_data, weight_data, bias_data, mask_index_data, output_data,
                    batch_size, sequence_length, hidden_size, number_of_heads,
                    false /*use_special_quantize_parameter*/,
                    true /*is_unidirectional*/);
}

TEST(QAttentionTest, QAttentionUnidirectional_U8S8) {
  int batch_size = 1;
  int sequence_length = 2;
  int hidden_size = 4;
  int number_of_heads = 2;

  std::vector<float> input_data = {
      0.91099896f, -0.18294459f, -0.36594841f, 0.28410032f,
      -0.12125026f, -0.66160089f, 0.38809127f, -0.22455512f};

  std::vector<float> weight_data = {
      -0.2659236192703247f,
      0.2789675071835518f,
      0.7280516624450684f,
      0.50951678305864334f,
      0.20417947322130203f,
      -0.4751841351389885f,
      0.43815530836582184f,
      0.6015353370457888f,
      -0.11496957391500473f,
      -0.1773347705602646f,
      0.30928605794906616f,
      0.5648412741720676f,

      0.8960387855768204f,
      -0.27270448207855225f,
      0.14847396314144135f,
      -0.17960812151432037f,
      0.1788954995572567f,
      0.9993876516819f,
      0.3943513706326485f,
      -0.2484400011599064f,
      -0.12958766520023346f,
      0.220433309674263f,
      0.1720484346151352f,
      0.22024005651474f,

      0.59368450194597244f,
      0.1710093915462494f,
      -0.3967452347278595f,
      -0.1591450721025467f,
      0.1446179747581482f,
      -0.20505407452583313f,
      0.12749597430229187f,
      0.32139700651168823f,
      0.139958456158638f,
      -0.10619817674160004f,
      0.4528557509183884f,
      0.45598603785037994f,

      -0.7152545265853405f,
      0.109454445540905f,
      -0.1582530289888382f,
      -0.2646341919898987f,
      0.920850858092308f,
      0.701494812965393f,
      -0.19062495231628418f,
      -0.24360455572605133f,
      -0.9368397295475006f,
      0.7878211885690689f,
      0.2973634898662567f,
      0.11210034042596817f};

  std::vector<float> bias_data = {
      -0.0540979839861393f,
      -0.06444740295410156f,
      0.03112877532839775f,
      -0.08288222551345825f,
      0.07840359210968018f,
      0.039143580943346024f,
      -0.45591455698013306f,
      -0.11876055598258972f,
      0.3670335114002228f,
      0.028461361303925514f,
      -0.08913630992174149f,
      0.28048714995384216f};

  // No mask_index
  std::vector<int32_t> mask_index_data = {};

  std::vector<float> output_data = {
      -0.029270321130752563f, 0.089105717837810516f,
      0.084381766617298126f, 0.62047165632247925f,
      0.36089283227920532f, -0.11732138693332672f,
      -0.029981952160596848f, 0.40998253226280212f};

  RunQAttentionU8S8(input_data, weight_data, bias_data, mask_index_data, output_data,
                    batch_size, sequence_length, hidden_size, number_of_heads,
                    false /*use_special_quantize_parameter*/,
                    true /*is_unidirectional*/);
}

TEST(QAttentionTest, QAttentionUnidirectional_CUDA) {
  int batch_size = 1;
  int sequence_length = 2;
  int hidden_size = 4;
  int number_of_heads = 2;

  std::vector<float> input_data = {
      0.91099896f, -0.18294459f, -0.36594841f, 0.28410032f,
      -0.12125026f, -0.66160089f, 0.38809127f, -0.22455512f};

  std::vector<float> weight_data = {
      -0.2659236192703247f,
      0.2789675071835518f,
      0.7280516624450684f,
      0.50951678305864334f,
      0.20417947322130203f,
      -0.4751841351389885f,
      0.43815530836582184f,
      0.6015353370457888f,
      -0.11496957391500473f,
      -0.1773347705602646f,
      0.30928605794906616f,
      0.5648412741720676f,

      0.8960387855768204f,
      -0.27270448207855225f,
      0.14847396314144135f,
      -0.17960812151432037f,
      0.1788954995572567f,
      0.9993876516819f,
      0.3943513706326485f,
      -0.2484400011599064f,
      -0.12958766520023346f,
      0.220433309674263f,
      0.1720484346151352f,
      0.22024005651474f,

      0.59368450194597244f,
      0.1710093915462494f,
      -0.3967452347278595f,
      -0.1591450721025467f,
      0.1446179747581482f,
      -0.20505407452583313f,
      0.12749597430229187f,
      0.32139700651168823f,
      0.139958456158638f,
      -0.10619817674160004f,
      0.4528557509183884f,
      0.45598603785037994f,

      -0.7152545265853405f,
      0.109454445540905f,
      -0.1582530289888382f,
      -0.2646341919898987f,
      0.920850858092308f,
      0.701494812965393f,
      -0.19062495231628418f,
      -0.24360455572605133f,
      -0.9368397295475006f,
      0.7878211885690689f,
      0.2973634898662567f,
      0.11210034042596817f};

  std::vector<float> bias_data = {
      -0.0540979839861393f,
      -0.06444740295410156f,
      0.03112877532839775f,
      -0.08288222551345825f,
      0.07840359210968018f,
      0.039143580943346024f,
      -0.45591455698013306f,
      -0.11876055598258972f,
      0.3670335114002228f,
      0.028461361303925514f,
      -0.08913630992174149f,
      0.28048714995384216f};

  // No mask_index
  std::vector<int32_t> mask_index_data = {};

  std::vector<float> output_data = {
      -0.037525445222854614f, 0.089105717837810516f,
      0.076988570392131805f, 0.62047165632247925f,
      0.36089283227920532f, -0.11732138693332672f,
      -0.029981952160596848f, 0.40998253226280212f};

  RunQAttentionCUDA(input_data, weight_data, bias_data, mask_index_data, output_data,
                    batch_size, sequence_length, hidden_size, number_of_heads,
                    false /*use_special_quantize_parameter*/,
                    true /*is_unidirectional*/);
}

template <typename InputT, typename WeightT>
void TestQuantizedAttentionPastState(int64_t batch,
                                     int64_t seq_len,
                                     int64_t past_seq_len,
                                     int64_t hidden_size,
                                     int64_t head_number,
                                     int64_t head_size,
                                     const std::string& reference_model,
                                     bool is_weight_constant,
                                     bool per_column = false) {
  // create rand inputs
  RandomValueGenerator random{};

  constexpr InputT input_min = std::numeric_limits<InputT>::min();
  constexpr InputT input_max = std::numeric_limits<InputT>::max();
  constexpr int32_t input_range = input_max - input_min;

  int64_t weight_scale_zp_size = per_column ? 3 * hidden_size : 1;

  InputT input_mean = (input_min + input_max) / 2 + 1;
  std::vector<InputT> input_zero_point{input_mean};

  std::vector<int64_t> input_dims{batch, seq_len, hidden_size};
  std::vector<InputT> input_data = random.Gaussian<InputT>(input_dims, input_mean, static_cast<InputT>(input_range / 6), input_min, input_max);

  constexpr WeightT weight_min = std::numeric_limits<WeightT>::min();
  constexpr WeightT weight_max = std::numeric_limits<WeightT>::max();
  constexpr int32_t weight_range = weight_max - weight_min;

  std::vector<WeightT> weight_zero_point(weight_scale_zp_size);
  for (auto& zp : weight_zero_point) {
    zp = static_cast<WeightT>(random.Uniform<int32_t>(std::array<int64_t, 1>{1}, weight_min, weight_max)[0]);
  }

  WeightT weight_mean = (weight_min + weight_max) / 2 + 1;
  std::vector<int64_t> weight_dims{hidden_size, 3 * hidden_size};
  std::vector<WeightT> weight_data = random.Gaussian<WeightT>(weight_dims, weight_mean, static_cast<WeightT>(weight_range / 6), weight_min, weight_max);

  std::vector<int64_t> bias_dims{3 * hidden_size};
  std::vector<float> bias_data = random.Gaussian<float>(bias_dims, 0.0f, 0.3f);

  std::vector<float> input_scale{0.005f};
  std::vector<float> weight_scale(random.Uniform<float>({weight_scale_zp_size}, -0.01f, 0.01f));

  std::vector<int64_t> past_dims{2, batch, head_number, past_seq_len, head_size};
  std::vector<float> past_data = random.Gaussian<float>(past_dims, 0.0f, 0.3f);

  OpTester test(""QAttention"", 1, onnxruntime::kMSDomain);
  test.AddAttribute<int64_t>(""num_heads"", head_number);
  test.AddAttribute<int64_t>(""unidirectional"", 1);
  test.AddInput<InputT>(""input"", input_dims, input_data);
  test.AddInput<WeightT>(""weight"", weight_dims, weight_data, is_weight_constant);
  test.AddInput<float>(""bias"", bias_dims, bias_data);
  test.AddInput<float>(""input_scale"", {1}, input_scale);
  test.AddInput<float>(""weight_scale"", {weight_scale_zp_size}, weight_scale);
  test.AddOptionalInputEdge<int32_t>();
  test.AddInput<InputT>(""input_zero_point"", {1}, input_zero_point);
  test.AddInput<WeightT>(""weight_zero_point"", {weight_scale_zp_size}, weight_zero_point);
  test.AddInput<float>(""past"", past_dims, past_data);

  test.AddReferenceOutputs(reference_model);
  test.Run();
}

TEST(QAttentionTest, QAttentionPastState_u8u8) {
  TestQuantizedAttentionPastState<uint8_t, uint8_t>(2, 5, 15, 768, 12, 64,
                                                    ""testdata/attention_past_state.u8u8.onnx"",
                                                    false /*is_weight_constant*/);

  TestQuantizedAttentionPastState<uint8_t, uint8_t>(2, 5, 15, 768, 12, 64,
                                                    ""testdata/attention_past_state.u8u8.onnx"",
                                                    true /*is_weight_constant*/);

  TestQuantizedAttentionPastState<uint8_t, uint8_t>(2, 5, 15, 768, 12, 64,
                                                    ""testdata/attention_past_state.u8u8.onnx"",
                                                    false /*is_weight_constant*/,
                                                    true /*per_column*/);

  TestQuantizedAttentionPastState<uint8_t, uint8_t>(2, 5, 15, 768, 12, 64,
                                                    ""testdata/attention_past_state.u8u8.onnx"",
                                                    true /*is_weight_constant*/,
                                                    true /*per_column*/);
}

TEST(QAttentionTest, QAttentionPastState_u8s8) {
  TestQuantizedAttentionPastState<uint8_t, int8_t>(2, 5, 15, 768, 12, 64,
                                                   ""testdata/attention_past_state.u8s8.onnx"",
                                                   false /*is_weight_constant*/);

  TestQuantizedAttentionPastState<uint8_t, int8_t>(2, 5, 15, 768, 12, 64,
                                                   ""testdata/attention_past_state.u8s8.onnx"",
                                                   true /*is_weight_constant*/);

  TestQuantizedAttentionPastState<uint8_t, int8_t>(2, 5, 15, 768, 12, 64,
                                                   ""testdata/attention_past_state.u8s8.onnx"",
                                                   false /*is_weight_constant*/,
                                                   true /*per_column*/);

  TestQuantizedAttentionPastState<uint8_t, int8_t>(2, 5, 15, 768, 12, 64,
                                                   ""testdata/attention_past_state.u8s8.onnx"",
                                                   true /*is_weight_constant*/,
                                                   true /*per_column*/);
}

TEST(QAttentionTest, QAttentionPrunedModel) {
  int batch_size = 2;
  int sequence_length = 2;
  // test input_hidden_size > hidden_size
  int input_hidden_size = 6;
  int hidden_size = 4;
  int number_of_heads = 2;

  std::vector<float> input_data = {
      0.5f, 0.2f, 0.3f, -0.6f, 0.0f, 1.0f,
      0.8f, -0.5f, 0.0f, 1.f, 2.0f, 3.0f,
      0.8f, -0.5f, 0.0f, 1.f, 4.0f, 5.0f,
      0.5f, 0.2f, 0.3f, -0.6f, 6.0f, 7.0f};

  std::vector<float> weight_data = {
      0.1f, -0.2f, 0.3f, 1.0f, 1.1f, 0.3f, 0.5f, 0.2f, 0.3f, -0.6f, 1.5f, 2.0f,
      0.5f, 0.1f, 0.4f, 1.6f, 1.0f, 2.0f, 0.4f, 0.8f, 0.9f, 0.1f, -1.3f, 0.7f,
      0.3f, 0.2f, 4.0f, 2.2f, 1.6f, 1.1f, 0.7f, 0.2f, 0.4f, 1.0f, 1.2f, 0.5f,
      0.2f, 0.1f, 0.4f, 1.6f, 2.4f, 3.3f, 2.1f, 4.2f, 8.4f, 0.0f, 2.1f, 3.2f,
      0.1f, 0.2f, 0.3f, 0.4f, 0.5f, 0.6f, 0.7f, 0.8f, 0.9f, 1.0f, 1.1f, 1.2f,
      1.2f, 1.1f, 1.0f, 0.9f, 0.8f, 0.7f, 0.6f, 0.5f, 0.4f, 0.3f, 0.2f, 0.1f};

  std::vector<float> bias_data = {
      -0.5f, 0.6f, 1.2f, 2.1f, 0.5f, 0.7f, 0.2f, 1.2f, 0.5f, 0.4f, 0.3f, 1.2f};

  std::vector<int32_t> mask_data = {};

  std::vector<float> output_data = {
      11.689527f, 2.769937f, 7.05f, 8.35f,
      11.69f, 2.77f, 7.05f, 8.35f,
      14.276558f, 5.374159f, 9.65f, 10.95f,
      14.289073f, 5.370287f, 9.65f, 10.95f};

  bool use_special_quantize_parameter = true;
  bool is_unidirectional = false;
  bool use_float16 = false;
  RunQAttentionAll(input_data, weight_data, bias_data, mask_data, output_data,
                   batch_size, sequence_length, hidden_size, number_of_heads,
                   use_special_quantize_parameter, is_unidirectional, use_float16,
                   input_hidden_size);
}

#ifndef ENABLE_TRAINING  // Prepacking is enabled only on non-training builds
TEST(QAttentionTest, SharedPrepackedWeights) {
  int batch_size = 1;
  int sequence_length = 2;
  int hidden_size = 4;
  int number_of_heads = 2;

  std::vector<float> input_data = {
      0.8f, -0.5f, 0.0f, 1.f,
      0.5f, 0.2f, 0.3f, -0.6f};

  std::vector<float> weight_data = {
      0.1f, -0.2f, 0.3f, 1.0f, 1.1f, 0.3f, 0.5f, 0.2f, 0.3f, -0.6f, 1.5f, 2.0f,
      0.5f, 0.1f, 0.4f, 1.6f, 1.0f, 2.0f, 0.4f, 0.8f, 0.9f, 0.1f, -1.3f, 0.7f,
      0.3f, 0.2f, 4.0f, 2.2f, 1.6f, 1.1f, 0.7f, 0.2f, 0.4f, 1.0f, 1.2f, 0.5f,
      0.2f, 0.1f, 0.4f, 1.6f, 2.4f, 3.3f, 2.1f, 4.2f, 8.4f, 0.0f, 2.1f, 3.2f};

  std::vector<float> bias_data = {
      -0.5f, 0.6f, 1.2f, 2.1f, 0.5f, 0.7f, 0.2f, 1.2f, 0.5f, 0.4f, 0.3f, 1.2f};

  std::vector<int32_t> mask_index_data = {2L};

  std::vector<float> output_data = {
      3.1495983600616455f, 0.10843668878078461f, 4.25f, 5.6499996185302734f,
      3.9696791172027588f, 0.073143675923347473f, 4.2499995231628418f, 5.6499991416931152f};

  std::vector<int64_t> input_dims = {batch_size, sequence_length, hidden_size};
  std::vector<int64_t> weights_dims = {hidden_size, 3 * hidden_size};
  std::vector<int64_t> bias_dims = {3 * hidden_size};
  std::vector<int64_t> mask_index_dims = {batch_size};
  std::vector<int64_t> output_dims = {batch_size, sequence_length, hidden_size};

  OpTester tester(""QAttention"", 1, onnxruntime::kMSDomain);
  tester.AddAttribute<int64_t>(""num_heads"", static_cast<int64_t>(number_of_heads));

  tester.AddInput<uint8_t>(
      ""input"",
      input_dims,
      QuantizeTestVector<uint8_t>(
          input_data,
          quantization::Params<uint8_t>(/*scale=*/0.1f, /*zero_point=*/128)));

  auto weight_data_converted_to_int = QuantizeTestVector<uint8_t>(
      weight_data,
      quantization::Params<uint8_t>(/*scale=*/0.1f, /*zero_point=*/128));
  tester.AddInput<uint8_t>(""weight"",
                           weights_dims,
                           weight_data_converted_to_int,
                           /*is_initializer=*/true);  // Trigger pre-packing

  tester.AddInput<float>(""bias"", bias_dims, bias_data);
  tester.AddInput<float>(""input_scale"", {1}, {0.1f});
  tester.AddInput<float>(""weight_scale"", {1}, {0.1f});
  tester.AddOutput<float>(""output"", output_dims, output_data);

  tester.AddInput<int32_t>(""mask_index"", mask_index_dims, mask_index_data);

  tester.AddInput<uint8_t>(""input_zero_point"", {1}, {128});
  tester.AddInput<uint8_t>(""weight_zero_point"", {1}, {128});

  OrtValue weight;
  Tensor::InitOrtValue(DataTypeImpl::GetType<uint8_t>(), TensorShape(weights_dims),
                       weight_data_converted_to_int.data(),
                       OrtMemoryInfo(CPU, OrtAllocatorType::OrtDeviceAllocator), weight);

  SessionOptions so;

  // Set up weight as a shared initializer to be shared between sessions
  ASSERT_EQ(so.AddInitializer(""weight"", &weight), Status::OK());

  // We want all sessions running using this OpTester to be able to share pre-packed weights if applicable
  tester.EnableSharingOfPrePackedWeightsAcrossSessions();

  // Pre-packing is limited just to the CPU EP for now and we will only test the CPU EP
  // and we want to ensure that it is available in this build
  auto cpu_ep = []() -> std::vector<std::unique_ptr<IExecutionProvider>> {
    std::vector<std::unique_ptr<IExecutionProvider>> execution_providers;
    execution_providers.push_back(DefaultCpuExecutionProvider());
    return execution_providers;
  };

  size_t number_of_pre_packed_weights_counter_session_1 = 0;
  size_t number_of_shared_pre_packed_weights_counter = 0;

  // Session 1
  {
    auto ep_vec = cpu_ep();
    tester.Run(so, OpTester::ExpectResult::kExpectSuccess, """", {}, nullptr,
               &ep_vec, {}, &number_of_pre_packed_weights_counter_session_1, &number_of_shared_pre_packed_weights_counter);
    // Assert that no pre-packed weights have been shared thus far
    ASSERT_EQ(number_of_shared_pre_packed_weights_counter, static_cast<size_t>(0));
  }

  auto number_of_elements_in_shared_prepacked_buffers_container =
      tester.GetNumPrePackedWeightsShared();
  // Assert that the number of elements in the shared container
  // is the same as the number of weights that have been pre-packed
  ASSERT_EQ(number_of_pre_packed_weights_counter_session_1, number_of_elements_in_shared_prepacked_buffers_container);

  // On some platforms/architectures MLAS may choose to not do any pre-packing and the number of elements
  // that have been pre-packed will be zero in which case we do not continue with the testing
  // of ""sharing"" of pre-packed weights as there are no pre-packed weights to be shared at all.
  if (number_of_pre_packed_weights_counter_session_1 == 0)
    return;

  // Session 2
  {
    size_t number_of_pre_packed_weights_counter_session_2 = 0;
    auto ep_vec = cpu_ep();
    tester.Run(so, OpTester::ExpectResult::kExpectSuccess, """", {}, nullptr,
               &ep_vec, {}, &number_of_pre_packed_weights_counter_session_2, &number_of_shared_pre_packed_weights_counter);

    // Assert that the same number of weights were pre-packed in both sessions
    ASSERT_EQ(number_of_pre_packed_weights_counter_session_1, number_of_pre_packed_weights_counter_session_2);

    // Assert that the number of pre-packed weights that were shared equals
    // the number of pre-packed weights in the second session
    ASSERT_EQ(number_of_pre_packed_weights_counter_session_2,
              static_cast<size_t>(number_of_shared_pre_packed_weights_counter));
  }
}
#endif

}  // namespace test
}  // namespace onnxruntime
",16278,True,3743.0894445213908,median
"// Copyright 2008-present Contributors to the OpenImageIO project.
// SPDX-License-Identifier: BSD-3-Clause
// https://github.com/OpenImageIO/oiio

#include <cmath>
#include <iostream>
#ifndef _WIN32
#    include <unistd.h>
#endif
#include <vector>

#include ""imageviewer.h""
#include ""ivgl.h""

#include <QApplication>
#include <QComboBox>
#include <QDesktopWidget>
#include <QFileDialog>
#include <QKeyEvent>
#include <QLabel>
#include <QMenu>
#include <QMenuBar>
#include <QMessageBox>
#include <QProgressBar>
#include <QResizeEvent>
#include <QSettings>
#include <QSpinBox>
#include <QStatusBar>
#include <QTimer>

#include <OpenImageIO/dassert.h>
#include <OpenImageIO/filesystem.h>
#include <OpenImageIO/imagecache.h>
#include <OpenImageIO/strutil.h>
#include <OpenImageIO/sysutil.h>
#include <OpenImageIO/timer.h>

#include ""ivutils.h""


namespace {

inline bool
IsSpecSrgb(const ImageSpec& spec)
{
    return Strutil::iequals(spec.get_string_attribute(""oiio:ColorSpace""),
                            ""sRGB"");
}

}  // namespace


// clang-format off
static const char *s_file_filters = """"
    ""Image Files (*.bmp *.cin *.dcm *.dds *.dpx *.fits *.gif *.hdr *.ico *.iff ""
    ""*.jpg *.jpe *.jpeg *.jif *.jfif *.jfi *.jp2 *.j2k *.exr *.png *.pbm *.pgm ""
    ""*.ppm *.psd *.ptex *.rla *.sgi *.rgb *.rgba *.bw *.int *.inta *.pic *.tga ""
    ""*.tpic *.tif *.tiff *.tx *.env *.sm *.vsm *.vdb *.webp *.zfile);;""
    ""BMP (*.bmp);;""
    ""Cineon (*.cin);;""
    ""Direct Draw Surface (*.dds);;""
    ""DICOM (*.dcm);;""
    ""DPX (*.dpx);;""
    ""FITS (*.fits);;""
    ""GIF (*.gif);;""
    ""HDR/RGBE (*.hdr);;""
    ""Icon (*.ico);;""
    ""IFF (*.iff);;""
    ""JPEG (*.jpg *.jpe *.jpeg *.jif *.jfif *.jfi);;""
    ""JPEG-2000 (*.jp2 *.j2k);;""
    ""OpenEXR (*.exr);;""
    ""OpenVDB (*.vdb);;""
    ""PhotoShop (*.psd);;""
    ""Portable Network Graphics (*.png);;""
    ""PNM / Netpbm (*.pbm *.pgm *.ppm);;""
    ""Ptex (*.ptex);;""
    ""RLA (*.rla);;""
    ""SGI (*.sgi *.rgb *.rgba *.bw *.int *.inta);;""
    ""Softimage PIC (*.pic);;""
    ""Targa (*.tga *.tpic);;""
    ""TIFF (*.tif *.tiff *.tx *.env *.sm *.vsm);;""
    ""Webp (*.webp);;""
    ""Zfile (*.zfile);;""
    ""All Files (*)"";
// clang-format on



ImageViewer::ImageViewer()
    : infoWindow(NULL)
    , preferenceWindow(NULL)
    , darkPaletteBox(NULL)
    , m_current_image(-1)
    , m_current_channel(0)
    , m_color_mode(RGBA)
    , m_last_image(-1)
    , m_zoom(1)
    , m_fullscreen(false)
    , m_default_gamma(1)
    , m_darkPalette(false)
{
    readSettings(false);

    float gam = Strutil::stof(Sysutil::getenv(""GAMMA""));
    if (gam >= 0.1 && gam <= 5)
        m_default_gamma = gam;
    // FIXME -- would be nice to have a more nuanced approach to display
    // color space, in particular knowing whether the display is sRGB.
    // Also, some time in the future we may want a real 3D LUT for
    // ""film look"", etc.

    if (darkPalette())
        m_palette = QPalette(Qt::darkGray);  // darkGray?
    else
        m_palette = QPalette();
    QApplication::setPalette(m_palette);  // FIXME -- why not work?
    this->setPalette(m_palette);

    slideTimer       = new QTimer();
    slideDuration_ms = 5000;
    slide_loop       = true;
    glwin            = new IvGL(this, *this);
    glwin->setPalette(m_palette);
    glwin->resize(m_default_width, m_default_height);
    setCentralWidget(glwin);

    createActions();
    createMenus();
    createToolBars();
    createStatusBar();

    readSettings();

    setWindowTitle(tr(""Image Viewer""));
    resize(m_default_width, m_default_height);
    //    setSizePolicy (QSizePolicy::Ignored, QSizePolicy::Ignored);
}



ImageViewer::~ImageViewer()
{
    for (auto i : m_images)
        delete i;
}



void
ImageViewer::closeEvent(QCloseEvent*)
{
    writeSettings();
}



void
ImageViewer::createActions()
{
    openAct = new QAction(tr(""&Open...""), this);
    openAct->setShortcut(tr(""Ctrl+O""));
    connect(openAct, SIGNAL(triggered()), this, SLOT(open()));

    for (auto& i : openRecentAct) {
        i = new QAction(this);
        i->setVisible(false);
        connect(i, SIGNAL(triggered()), this, SLOT(openRecentFile()));
    }

    reloadAct = new QAction(tr(""&Reload image""), this);
    reloadAct->setShortcut(tr(""Ctrl+R""));
    connect(reloadAct, SIGNAL(triggered()), this, SLOT(reload()));

    closeImgAct = new QAction(tr(""&Close Image""), this);
    closeImgAct->setShortcut(tr(""Ctrl+W""));
    connect(closeImgAct, SIGNAL(triggered()), this, SLOT(closeImg()));

    saveAsAct = new QAction(tr(""&Save As...""), this);
    saveAsAct->setShortcut(tr(""Ctrl+S""));
    connect(saveAsAct, SIGNAL(triggered()), this, SLOT(saveAs()));

    saveWindowAsAct = new QAction(tr(""Save Window As...""), this);
    connect(saveWindowAsAct, SIGNAL(triggered()), this, SLOT(saveWindowAs()));

    saveSelectionAsAct = new QAction(tr(""Save Selection As...""), this);
    connect(saveSelectionAsAct, SIGNAL(triggered()), this,
            SLOT(saveSelectionAs()));

    printAct = new QAction(tr(""&Print...""), this);
    printAct->setShortcut(tr(""Ctrl+P""));
    printAct->setEnabled(false);
    connect(printAct, SIGNAL(triggered()), this, SLOT(print()));

    deleteCurrentImageAct = new QAction(tr(""&Delete from disk""), this);
    deleteCurrentImageAct->setShortcut(tr(""Delete""));
    connect(deleteCurrentImageAct, SIGNAL(triggered()), this,
            SLOT(deleteCurrentImage()));

    editPreferencesAct = new QAction(tr(""&Preferences...""), this);
    editPreferencesAct->setShortcut(tr(""Ctrl+,""));
    editPreferencesAct->setEnabled(true);
    connect(editPreferencesAct, SIGNAL(triggered()), this,
            SLOT(editPreferences()));

    exitAct = new QAction(tr(""E&xit""), this);
    exitAct->setShortcut(tr(""Ctrl+Q""));
    connect(exitAct, SIGNAL(triggered()), this, SLOT(close()));

    exposurePlusOneTenthStopAct = new QAction(tr(""Exposure +1/10 stop""), this);
    exposurePlusOneTenthStopAct->setShortcut(tr(""]""));
    connect(exposurePlusOneTenthStopAct, SIGNAL(triggered()), this,
            SLOT(exposurePlusOneTenthStop()));

    exposurePlusOneHalfStopAct = new QAction(tr(""Exposure +1/2 stop""), this);
    exposurePlusOneHalfStopAct->setShortcut(tr(""}""));
    connect(exposurePlusOneHalfStopAct, SIGNAL(triggered()), this,
            SLOT(exposurePlusOneHalfStop()));

    exposureMinusOneTenthStopAct = new QAction(tr(""Exposure -1/10 stop""), this);
    exposureMinusOneTenthStopAct->setShortcut(tr(""[""));
    connect(exposureMinusOneTenthStopAct, SIGNAL(triggered()), this,
            SLOT(exposureMinusOneTenthStop()));

    exposureMinusOneHalfStopAct = new QAction(tr(""Exposure -1/2 stop""), this);
    exposureMinusOneHalfStopAct->setShortcut(tr(""{""));
    connect(exposureMinusOneHalfStopAct, SIGNAL(triggered()), this,
            SLOT(exposureMinusOneHalfStop()));

    gammaPlusAct = new QAction(tr(""Gamma +0.1""), this);
    gammaPlusAct->setShortcut(tr("")""));
    connect(gammaPlusAct, SIGNAL(triggered()), this, SLOT(gammaPlus()));

    gammaMinusAct = new QAction(tr(""Gamma -0.1""), this);
    gammaMinusAct->setShortcut(tr(""(""));
    connect(gammaMinusAct, SIGNAL(triggered()), this, SLOT(gammaMinus()));

    viewChannelFullAct = new QAction(tr(""Full Color""), this);
    viewChannelFullAct->setShortcut(tr(""c""));
    viewChannelFullAct->setCheckable(true);
    viewChannelFullAct->setChecked(true);
    connect(viewChannelFullAct, SIGNAL(triggered()), this,
            SLOT(viewChannelFull()));

    viewChannelRedAct = new QAction(tr(""Red""), this);
    viewChannelRedAct->setShortcut(tr(""r""));
    viewChannelRedAct->setCheckable(true);
    connect(viewChannelRedAct, SIGNAL(triggered()), this,
            SLOT(viewChannelRed()));

    viewChannelGreenAct = new QAction(tr(""Green""), this);
    viewChannelGreenAct->setShortcut(tr(""g""));
    viewChannelGreenAct->setCheckable(true);
    connect(viewChannelGreenAct, SIGNAL(triggered()), this,
            SLOT(viewChannelGreen()));

    viewChannelBlueAct = new QAction(tr(""Blue""), this);
    viewChannelBlueAct->setShortcut(tr(""b""));
    viewChannelBlueAct->setCheckable(true);
    connect(viewChannelBlueAct, SIGNAL(triggered()), this,
            SLOT(viewChannelBlue()));

    viewChannelAlphaAct = new QAction(tr(""Alpha""), this);
    viewChannelAlphaAct->setShortcut(tr(""a""));
    viewChannelAlphaAct->setCheckable(true);
    connect(viewChannelAlphaAct, SIGNAL(triggered()), this,
            SLOT(viewChannelAlpha()));

    viewColorLumAct = new QAction(tr(""Luminance""), this);
    viewColorLumAct->setShortcut(tr(""l""));
    viewColorLumAct->setCheckable(true);
    connect(viewColorLumAct, SIGNAL(triggered()), this,
            SLOT(viewChannelLuminance()));

    viewColorRGBAAct = new QAction(tr(""RGBA""), this);
    //viewColorRGBAAct->setShortcut (tr(""Ctrl+c""));
    viewColorRGBAAct->setCheckable(true);
    viewColorRGBAAct->setChecked(true);
    connect(viewColorRGBAAct, SIGNAL(triggered()), this, SLOT(viewColorRGBA()));

    viewColorRGBAct = new QAction(tr(""RGB""), this);
    //viewColorRGBAct->setShortcut (tr(""Ctrl+a""));
    viewColorRGBAct->setCheckable(true);
    connect(viewColorRGBAct, SIGNAL(triggered()), this, SLOT(viewColorRGB()));

    viewColor1ChAct = new QAction(tr(""Single channel""), this);
    viewColor1ChAct->setShortcut(tr(""1""));
    viewColor1ChAct->setCheckable(true);
    connect(viewColor1ChAct, SIGNAL(triggered()), this, SLOT(viewColor1Ch()));

    viewColorHeatmapAct = new QAction(tr(""Single channel (Heatmap)""), this);
    viewColorHeatmapAct->setShortcut(tr(""h""));
    viewColorHeatmapAct->setCheckable(true);
    connect(viewColorHeatmapAct, SIGNAL(triggered()), this,
            SLOT(viewColorHeatmap()));

    viewChannelPrevAct = new QAction(tr(""Prev Channel""), this);
    viewChannelPrevAct->setShortcut(tr("",""));
    connect(viewChannelPrevAct, SIGNAL(triggered()), this,
            SLOT(viewChannelPrev()));

    viewChannelNextAct = new QAction(tr(""Next Channel""), this);
    viewChannelNextAct->setShortcut(tr("".""));
    connect(viewChannelNextAct, SIGNAL(triggered()), this,
            SLOT(viewChannelNext()));

    viewSubimagePrevAct = new QAction(tr(""Prev Subimage""), this);
    viewSubimagePrevAct->setShortcut(tr(""<""));
    connect(viewSubimagePrevAct, SIGNAL(triggered()), this,
            SLOT(viewSubimagePrev()));

    viewSubimageNextAct = new QAction(tr(""Next Subimage""), this);
    viewSubimageNextAct->setShortcut(tr("">""));
    connect(viewSubimageNextAct, SIGNAL(triggered()), this,
            SLOT(viewSubimageNext()));

    zoomInAct = new QAction(tr(""Zoom &In""), this);
    zoomInAct->setShortcut(tr(""Ctrl++""));
    connect(zoomInAct, SIGNAL(triggered()), this, SLOT(zoomIn()));

    zoomOutAct = new QAction(tr(""Zoom &Out""), this);
    zoomOutAct->setShortcut(tr(""Ctrl+-""));
    connect(zoomOutAct, SIGNAL(triggered()), this, SLOT(zoomOut()));

    normalSizeAct = new QAction(tr(""&Normal Size (1:1)""), this);
    normalSizeAct->setShortcut(tr(""Ctrl+0""));
    connect(normalSizeAct, SIGNAL(triggered()), this, SLOT(normalSize()));

    fitWindowToImageAct = new QAction(tr(""&Fit Window to Image""), this);
    fitWindowToImageAct->setShortcut(tr(""f""));
    connect(fitWindowToImageAct, SIGNAL(triggered()), this,
            SLOT(fitWindowToImage()));

    fitImageToWindowAct = new QAction(tr(""Fit Image to Window""), this);
    //    fitImageToWindowAct->setEnabled(false);
    fitImageToWindowAct->setCheckable(true);
    fitImageToWindowAct->setShortcut(tr(""Alt+f""));
    connect(fitImageToWindowAct, SIGNAL(triggered()), this,
            SLOT(fitImageToWindow()));

    fullScreenAct = new QAction(tr(""Full screen""), this);
    //    fullScreenAct->setEnabled(false);
    //    fullScreenAct->setCheckable(true);
    fullScreenAct->setShortcut(tr(""Ctrl+f""));
    connect(fullScreenAct, SIGNAL(triggered()), this, SLOT(fullScreenToggle()));

    aboutAct = new QAction(tr(""&About""), this);
    connect(aboutAct, SIGNAL(triggered()), this, SLOT(about()));

    prevImageAct = new QAction(tr(""Previous Image""), this);
    prevImageAct->setShortcut(tr(""PgUp""));
    //    prevImageAct->setEnabled(true);
    connect(prevImageAct, SIGNAL(triggered()), this, SLOT(prevImage()));

    nextImageAct = new QAction(tr(""Next Image""), this);
    nextImageAct->setShortcut(tr(""PgDown""));
    //    nextImageAct->setEnabled(true);
    connect(nextImageAct, SIGNAL(triggered()), this, SLOT(nextImage()));

    toggleImageAct = new QAction(tr(""Toggle image""), this);
    toggleImageAct->setShortcut(tr(""T""));
    //    toggleImageAct->setEnabled(true);
    connect(toggleImageAct, SIGNAL(triggered()), this, SLOT(toggleImage()));

    slideShowAct = new QAction(tr(""Start Slide Show""), this);
    connect(slideShowAct, SIGNAL(triggered()), this, SLOT(slideShow()));

    slideLoopAct = new QAction(tr(""Loop slide show""), this);
    slideLoopAct->setCheckable(true);
    slideLoopAct->setChecked(true);
    connect(slideLoopAct, SIGNAL(triggered()), this, SLOT(slideLoop()));

    slideNoLoopAct = new QAction(tr(""Stop at end""), this);
    slideNoLoopAct->setCheckable(true);
    connect(slideNoLoopAct, SIGNAL(triggered()), this, SLOT(slideNoLoop()));

    sortByNameAct = new QAction(tr(""By Name""), this);
    connect(sortByNameAct, SIGNAL(triggered()), this, SLOT(sortByName()));

    sortByPathAct = new QAction(tr(""By File Path""), this);
    connect(sortByPathAct, SIGNAL(triggered()), this, SLOT(sortByPath()));

    sortByImageDateAct = new QAction(tr(""By Image Date""), this);
    connect(sortByImageDateAct, SIGNAL(triggered()), this,
            SLOT(sortByImageDate()));

    sortByFileDateAct = new QAction(tr(""By File Date""), this);
    connect(sortByFileDateAct, SIGNAL(triggered()), this,
            SLOT(sortByFileDate()));

    sortReverseAct = new QAction(tr(""Reverse current order""), this);
    connect(sortReverseAct, SIGNAL(triggered()), this, SLOT(sortReverse()));

    showInfoWindowAct = new QAction(tr(""&Image info...""), this);
    showInfoWindowAct->setShortcut(tr(""Ctrl+I""));
    //    showInfoWindowAct->setEnabled(true);
    connect(showInfoWindowAct, SIGNAL(triggered()), this,
            SLOT(showInfoWindow()));

    showPixelviewWindowAct = new QAction(tr(""&Pixel closeup view...""), this);
    showPixelviewWindowAct->setCheckable(true);
    showPixelviewWindowAct->setShortcut(tr(""P""));
    connect(showPixelviewWindowAct, SIGNAL(triggered()), this,
            SLOT(showPixelviewWindow()));

    pixelviewFollowsMouseBox = new QCheckBox(tr(""Pixel view follows mouse""));
    pixelviewFollowsMouseBox->setChecked(false);
    linearInterpolationBox = new QCheckBox(tr(""Linear interpolation""));
    linearInterpolationBox->setChecked(true);
    darkPaletteBox = new QCheckBox(tr(""Dark palette""));
    darkPaletteBox->setChecked(true);
    autoMipmap = new QCheckBox(tr(""Generate mipmaps (requires restart)""));
    autoMipmap->setChecked(false);

    maxMemoryICLabel = new QLabel(
        tr(""Image Cache max memory (requires restart)""));
    maxMemoryIC = new QSpinBox();
    if (sizeof(void*) == 4)
        maxMemoryIC->setRange(128, 2048);  //2GB is enough for 32 bit machines
    else
        maxMemoryIC->setRange(128, 8192);  //8GB probably ok for 64 bit
    maxMemoryIC->setSingleStep(64);
    maxMemoryIC->setSuffix("" MB"");

    slideShowDurationLabel = new QLabel(tr(""Slide Show delay""));
    slideShowDuration      = new QSpinBox();
    slideShowDuration->setRange(1, 3600);
    slideShowDuration->setSingleStep(1);
    slideShowDuration->setSuffix("" s"");
    slideShowDuration->setAccelerated(true);
    connect(slideShowDuration, SIGNAL(valueChanged(int)), this,
            SLOT(setSlideShowDuration(int)));
}



void
ImageViewer::createMenus()
{
    openRecentMenu = new QMenu(tr(""Open recent...""), this);
    for (auto& i : openRecentAct)
        openRecentMenu->addAction(i);

    fileMenu = new QMenu(tr(""&File""), this);
    fileMenu->addAction(openAct);
    fileMenu->addMenu(openRecentMenu);
    fileMenu->addAction(reloadAct);
    fileMenu->addAction(closeImgAct);
    fileMenu->addSeparator();
    fileMenu->addAction(saveAsAct);
    fileMenu->addAction(saveWindowAsAct);
    fileMenu->addAction(saveSelectionAsAct);
    fileMenu->addSeparator();
    fileMenu->addAction(printAct);
    fileMenu->addAction(deleteCurrentImageAct);
    fileMenu->addSeparator();
    fileMenu->addAction(editPreferencesAct);
    fileMenu->addAction(exitAct);
    menuBar()->addMenu(fileMenu);

    // Copy
    // Paste
    // Clear selection
    // radio: prioritize selection, crop selection

    expgamMenu = new QMenu(tr(""Exposure/gamma""));  // submenu
    expgamMenu->addAction(exposureMinusOneHalfStopAct);
    expgamMenu->addAction(exposureMinusOneTenthStopAct);
    expgamMenu->addAction(exposurePlusOneHalfStopAct);
    expgamMenu->addAction(exposurePlusOneTenthStopAct);
    expgamMenu->addAction(gammaMinusAct);
    expgamMenu->addAction(gammaPlusAct);

    //    imageMenu = new QMenu(tr(""&Image""), this);
    //    menuBar()->addMenu (imageMenu);
    slideMenu = new QMenu(tr(""Slide Show""));
    slideMenu->addAction(slideShowAct);
    slideMenu->addAction(slideLoopAct);
    slideMenu->addAction(slideNoLoopAct);

    sortMenu = new QMenu(tr(""Sort""));
    sortMenu->addAction(sortByNameAct);
    sortMenu->addAction(sortByPathAct);
    sortMenu->addAction(sortByImageDateAct);
    sortMenu->addAction(sortByFileDateAct);
    sortMenu->addAction(sortReverseAct);

    channelMenu = new QMenu(tr(""Channels""));
    // Color mode: true, random, falsegrgbacCrgR
    channelMenu->addAction(viewChannelFullAct);
    channelMenu->addAction(viewChannelRedAct);
    channelMenu->addAction(viewChannelGreenAct);
    channelMenu->addAction(viewChannelBlueAct);
    channelMenu->addAction(viewChannelAlphaAct);
    channelMenu->addAction(viewChannelPrevAct);
    channelMenu->addAction(viewChannelNextAct);

    colormodeMenu = new QMenu(tr(""Color mode""));
    colormodeMenu->addAction(viewColorRGBAAct);
    colormodeMenu->addAction(viewColorRGBAct);
    colormodeMenu->addAction(viewColor1ChAct);
    colormodeMenu->addAction(viewColorLumAct);
    colormodeMenu->addAction(viewColorHeatmapAct);

    viewMenu = new QMenu(tr(""&View""), this);
    viewMenu->addAction(prevImageAct);
    viewMenu->addAction(nextImageAct);
    viewMenu->addAction(toggleImageAct);
    viewMenu->addSeparator();
    viewMenu->addAction(zoomInAct);
    viewMenu->addAction(zoomOutAct);
    viewMenu->addAction(normalSizeAct);
    viewMenu->addAction(fitWindowToImageAct);
    viewMenu->addAction(fitImageToWindowAct);
    viewMenu->addAction(fullScreenAct);
    viewMenu->addSeparator();
    viewMenu->addAction(viewSubimagePrevAct);
    viewMenu->addAction(viewSubimageNextAct);
    viewMenu->addMenu(channelMenu);
    viewMenu->addMenu(colormodeMenu);
    viewMenu->addMenu(expgamMenu);
    menuBar()->addMenu(viewMenu);
    // Full screen mode
    // prev subimage <, next subimage >
    // fg/bg image...

    toolsMenu = new QMenu(tr(""&Tools""), this);
    // Mode: select, zoom, pan, wipe
    toolsMenu->addAction(showInfoWindowAct);
    toolsMenu->addAction(showPixelviewWindowAct);
    toolsMenu->addMenu(slideMenu);
    toolsMenu->addMenu(sortMenu);

    // Menus, toolbars, & status
    // Annotate
    // [check] overwrite render
    // connect renderer
    // kill renderer
    // store render
    // Playback: forward, reverse, faster, slower, loop/pingpong
    menuBar()->addMenu(toolsMenu);

    helpMenu = new QMenu(tr(""&Help""), this);
    helpMenu->addAction(aboutAct);
    menuBar()->addMenu(helpMenu);
    // Bring up user's guide
}



void
ImageViewer::createToolBars()
{
#if 0
    fileToolBar = addToolBar(tr(""File""));
    fileToolBar->addAction(newAct);
    fileToolBar->addAction(openAct);
    fileToolBar->addAction(saveAct);

    editToolBar = addToolBar(tr(""Edit""));
    editToolBar->addAction(cutAct);
    editToolBar->addAction(copyAct);
    editToolBar->addAction(pasteAct);
#endif
}



void
ImageViewer::createStatusBar()
{
    statusImgInfo = new QLabel;
    statusBar()->addWidget(statusImgInfo);

    statusViewInfo = new QLabel;
    statusBar()->addWidget(statusViewInfo);

    statusProgress = new QProgressBar;
    statusProgress->setRange(0, 100);
    statusProgress->reset();
    statusBar()->addWidget(statusProgress);

    mouseModeComboBox = new QComboBox;
    mouseModeComboBox->addItem(tr(""Zoom""));
    mouseModeComboBox->addItem(tr(""Pan""));
    mouseModeComboBox->addItem(tr(""Wipe""));
    mouseModeComboBox->addItem(tr(""Select""));
    mouseModeComboBox->addItem(tr(""Annotate""));
    // Note: the order of the above MUST match the order of enum MouseMode
    statusBar()->addWidget(mouseModeComboBox);
    mouseModeComboBox->hide();
}



void
ImageViewer::readSettings(bool ui_is_set_up)
{
    QSettings settings(""OpenImageIO"", ""iv"");
    m_darkPalette = settings.value(""darkPalette"").toBool();
    if (!ui_is_set_up)
        return;
    pixelviewFollowsMouseBox->setChecked(
        settings.value(""pixelviewFollowsMouse"").toBool());
    linearInterpolationBox->setChecked(
        settings.value(""linearInterpolation"").toBool());
    darkPaletteBox->setChecked(settings.value(""darkPalette"").toBool());
    QStringList recent = settings.value(""RecentFiles"").toStringList();
    for (auto&& s : recent)
        addRecentFile(s.toStdString());
    updateRecentFilesMenu();  // only safe because it's called after menu setup

    autoMipmap->setChecked(settings.value(""autoMipmap"", false).toBool());
    if (sizeof(void*) == 4)  // 32 bit or 64?
        maxMemoryIC->setValue(settings.value(""maxMemoryIC"", 512).toInt());
    else
        maxMemoryIC->setValue(settings.value(""maxMemoryIC"", 2048).toInt());
    slideShowDuration->setValue(
        settings.value(""slideShowDuration"", 10).toInt());

    ImageCache* imagecache = ImageCache::create(true);
    imagecache->attribute(""automip"", autoMipmap->isChecked());
    imagecache->attribute(""max_memory_MB"", (float)maxMemoryIC->value());
}



void
ImageViewer::writeSettings()
{
    QSettings settings(""OpenImageIO"", ""iv"");
    settings.setValue(""pixelviewFollowsMouse"",
                      pixelviewFollowsMouseBox->isChecked());
    settings.setValue(""linearInterpolation"",
                      linearInterpolationBox->isChecked());
    settings.setValue(""darkPalette"", darkPaletteBox->isChecked());
    settings.setValue(""autoMipmap"", autoMipmap->isChecked());
    settings.setValue(""maxMemoryIC"", maxMemoryIC->value());
    settings.setValue(""slideShowDuration"", slideShowDuration->value());
    QStringList recent;
    for (auto&& s : m_recent_files)
        recent.push_front(QString(s.c_str()));
    settings.setValue(""RecentFiles"", recent);
}



bool
image_progress_callback(void* opaque, float done)
{
    ImageViewer* viewer = (ImageViewer*)opaque;
    viewer->statusProgress->setValue((int)(done * 100));
    QApplication::processEvents();
    return false;
}



void
ImageViewer::open()
{
    static QString openPath = QDir::currentPath();
    QFileDialog dialog(NULL, tr(""Open File(s)""), openPath, tr(s_file_filters));
    dialog.setAcceptMode(QFileDialog::AcceptOpen);
    dialog.setFileMode(QFileDialog::ExistingFiles);
    if (!dialog.exec())
        return;
    openPath          = dialog.directory().path();
    QStringList names = dialog.selectedFiles();

    int old_lastimage = m_images.size() - 1;
    for (auto& name : names) {
        std::string filename = name.toUtf8().data();
        if (filename.empty())
            continue;
        add_image(filename);
        //        int n = m_images.size()-1;
        //        IvImage *newimage = m_images[n];
        //        newimage->read_iv (0, false, image_progress_callback, this);
    }
    if (old_lastimage >= 0) {
        // Otherwise, add_image already did this for us.
        current_image(old_lastimage + 1);
        fitWindowToImage(true, true);
    }
}



void
ImageViewer::openRecentFile()
{
    QAction* action = qobject_cast<QAction*>(sender());
    if (action) {
        std::string filename = action->data().toString().toStdString();
        // If it's an image we already have loaded, just switch to it
        // (and reload) rather than loading a second copy.
        for (size_t i = 0; i < m_images.size(); ++i) {
            if (m_images[i]->name() == filename) {
                current_image(i);
                reload();
                return;
            }
        }
        // It's not an image we already have loaded
        add_image(filename);
        if (m_images.size() > 1) {
            // Otherwise, add_image already did this for us.
            current_image(m_images.size() - 1);
            fitWindowToImage(true, true);
        }
    }
}



void
ImageViewer::addRecentFile(const std::string& name)
{
    removeRecentFile(name);
    m_recent_files.insert(m_recent_files.begin(), name);
    if (m_recent_files.size() > MaxRecentFiles)
        m_recent_files.resize(MaxRecentFiles);
}



void
ImageViewer::removeRecentFile(const std::string& name)
{
    for (size_t i = 0; i < m_recent_files.size(); ++i) {
        if (m_recent_files[i] == name) {
            m_recent_files.erase(m_recent_files.begin() + i);
            --i;
        }
    }
}



void
ImageViewer::updateRecentFilesMenu()
{
    for (size_t i = 0; i < MaxRecentFiles; ++i) {
        if (i < m_recent_files.size()) {
            std::string name = Filesystem::filename(m_recent_files[i]);
            openRecentAct[i]->setText(QString::fromStdString(name));
            openRecentAct[i]->setData(m_recent_files[i].c_str());
            openRecentAct[i]->setVisible(true);
        } else {
            openRecentAct[i]->setVisible(false);
        }
    }
}



void
ImageViewer::reload()
{
    if (m_images.empty())
        return;
    IvImage* newimage = m_images[m_current_image];
    newimage->invalidate();
    //glwin->trigger_redraw ();
    displayCurrentImage();
}



void
ImageViewer::add_image(const std::string& filename)
{
    if (filename.empty())
        return;
    IvImage* newimage = nullptr;
    if (rawcolor()) {
        ImageSpec config;
        config.attribute(""oiio:RawColor"", 1);
        newimage = new IvImage(filename, &config);
    } else {
        newimage = new IvImage(filename);
    }
    newimage->gamma(m_default_gamma);
    m_images.push_back(newimage);
    addRecentFile(filename);
    updateRecentFilesMenu();

#if 0
    if (getspec) {
        if (! newimage->init_spec (filename)) {
            QMessageBox::information (this, tr(""iv Image Viewer""),
                              tr(""%1"").arg(newimage->geterror().c_str()));
        } else {
            std::cerr << ""Added image "" << filename << "": "" 
<< newimage->spec().width << "" x "" << newimage->spec().height << ""\\n"";
        }
        return;
    }
#endif
    if (m_images.size() == 1) {
        // If this is the first image, resize to fit it
        displayCurrentImage();
        fitWindowToImage(true, true);
    }
}



void
ImageViewer::saveAs()
{
    IvImage* img = cur();
    if (!img)
        return;
    QString name;
    name = QFileDialog::getSaveFileName(this, tr(""Save Image""),
                                        QString(img->uname().c_str()),
                                        tr(s_file_filters));
    if (name.isEmpty())
        return;
    bool ok = img->write(name.toStdString(), TypeUnknown, """",
                         image_progress_callback, this);
    if (!ok) {
        std::cerr << ""Save failed: "" << img->geterror() << ""\\n"";
    }
}



void
ImageViewer::saveWindowAs()
{
    IvImage* img = cur();
    if (!img)
        return;
    QString name;
    name = QFileDialog::getSaveFileName(this, tr(""Save Window""),
                                        QString(img->uname().c_str()));
    if (name.isEmpty())
        return;
    img->write(name.toStdString(), TypeUnknown, """", image_progress_callback,
               this);
}



void
ImageViewer::saveSelectionAs()
{
    IvImage* img = cur();
    if (!img)
        return;
    QString name;
    name = QFileDialog::getSaveFileName(this, tr(""Save Selection""),
                                        QString(img->uname().c_str()));
    if (name.isEmpty())
        return;
    img->write(name.toStdString(), TypeUnknown, """", image_progress_callback,
               this);
}



void
ImageViewer::updateTitle()
{
    IvImage* img = cur();
    if (!img) {
        setWindowTitle(tr(""iv Image Viewer (no image loaded)""));
        return;
    }
    std::string message;
    message = Strutil::sprintf(""%s - iv Image Viewer"", img->name());
    setWindowTitle(QString::fromLocal8Bit(message.c_str()));
}



void
ImageViewer::updateStatusBar()
{
    const ImageSpec* spec = curspec();
    if (!spec) {
        statusImgInfo->setText(tr(""No image loaded""));
        statusViewInfo->setText(tr(""""));
        return;
    }
    std::string message;
    message = Strutil::sprintf(""(%d/%d) : "", m_current_image + 1,
                               (int)m_images.size());
    message += cur()->shortinfo();
    statusImgInfo->setText(message.c_str());

    message.clear();
    switch (m_color_mode) {
    case RGBA:
        message = Strutil::sprintf(""RGBA (%d-%d)"", m_current_channel,
                                   m_current_channel + 3);
        break;
    case RGB:
        message = Strutil::sprintf(""RGB (%d-%d)"", m_current_channel,
                                   m_current_channel + 2);
        break;
    case LUMINANCE:
        message = Strutil::sprintf(""Lum (%d-%d)"", m_current_channel,
                                   m_current_channel + 2);
        break;
    case HEATMAP: message = ""Heat "";
    case SINGLE_CHANNEL:
        if ((int)spec->channelnames.size() > m_current_channel
            && spec->channelnames[m_current_channel].size())
            message += spec->channelnames[m_current_channel];
        else if (m_color_mode == HEATMAP) {
            message += Strutil::sprintf(""%d"", m_current_channel);
        } else {
            message = Strutil::sprintf(""chan %d"", m_current_channel);
        }
        break;
    }
    message += Strutil::sprintf(""  %g:%g  exp %+.1f  gam %.2f"",
                                zoom() >= 1 ? zoom() : 1.0f,
                                zoom() >= 1 ? 1.0f : 1.0f / zoom(),
                                cur()->exposure(), cur()->gamma());
    if (cur()->nsubimages() > 1) {
        if (cur()->auto_subimage()) {
            message += Strutil::sprintf(""  subimg AUTO (%d/%d)"",
                                        cur()->subimage() + 1,
                                        cur()->nsubimages());
        } else {
            message += Strutil::sprintf(""  subimg %d/%d"", cur()->subimage() + 1,
                                        cur()->nsubimages());
        }
    }
    if (cur()->nmiplevels() > 1) {
        message += Strutil::sprintf(""  MIP %d/%d"", cur()->miplevel() + 1,
                                    cur()->nmiplevels());
    }

    statusViewInfo->setText(message.c_str());  // tr(""iv status""));
}



bool
ImageViewer::loadCurrentImage(int subimage, int miplevel)
{
    if (m_current_image < 0 || m_current_image >= (int)m_images.size()) {
        m_current_image = 0;
    }
    IvImage* img = cur();
    if (img) {
        // We need the spec available to compare the image format with
        // opengl's capabilities.
        if (!img->init_spec(img->name(), subimage, miplevel)) {
            statusImgInfo->setText(
                tr(""Could not display image: %1."").arg(img->uname().c_str()));
            statusViewInfo->setText(tr(""""));
            return false;
        }

        // Used to check whether we'll need to do adjustments in the
        // CPU. If true, images should be loaded as UINT8.
        bool allow_transforms = false;
        bool srgb_transform   = false;

        // By default, we try to load into OpenGL with the same format,
        TypeDesc read_format        = TypeDesc::UNKNOWN;
        const ImageSpec& image_spec = img->spec();

        if (image_spec.format.basetype == TypeDesc::DOUBLE) {
            // AFAIK, OpenGL doesn't support 64-bit floats as pixel size.
            read_format = TypeDesc::FLOAT;
        }
        if (glwin->is_glsl_capable()) {
            if (image_spec.format.basetype == TypeDesc::HALF
                && !glwin->is_half_capable()) {
                //std::cerr << ""Loading HALF-FLOAT as FLOAT\\n"";
                read_format = TypeDesc::FLOAT;
            }
            if (IsSpecSrgb(image_spec) && !glwin->is_srgb_capable()) {
                // If the image is in sRGB, but OpenGL can't load sRGB textures then
                // we'll need to do the transformation on the CPU after loading the
                // image. We (so far) can only do this with UINT8 images, so make
                // sure that it gets loaded in this format.
                //std::cerr << ""Loading as UINT8 to do sRGB\\n"";
                read_format      = TypeDesc::UINT8;
                srgb_transform   = true;
                allow_transforms = true;
            }
        } else {
            //std::cerr << ""Loading as UINT8\\n"";
            read_format      = TypeDesc::UINT8;
            allow_transforms = true;

            if (IsSpecSrgb(image_spec) && !glwin->is_srgb_capable())
                srgb_transform = true;
        }

        // FIXME: This actually won't work since the ImageCacheFile has already
        // been created when we did the init_spec.
        // Check whether IvGL recommends generating mipmaps for this image.
        //ImageCache *imagecache = ImageCache::create (true);
        //if (glwin->is_too_big (img) && autoMipmap->isChecked ()) {
        //    imagecache->attribute (""automip"", 1);
        //} else {
        //    imagecache->attribute (""automip"", 0);
        //}

        // Read the image from disk or from the ImageCache if available.
        if (img->read_iv(subimage, miplevel, false, read_format,
                         image_progress_callback, this, allow_transforms)) {
            // The image was read successfully.
            // Check if we've got to do sRGB to linear (ie, when not supported
            // by OpenGL).
            // Do the first pixel transform to fill-in the secondary image
            // buffer.
            if (allow_transforms) {
                img->pixel_transform(srgb_transform, (int)current_color_mode(),
                                     current_channel());
            }
            return true;
        } else {
            statusImgInfo->setText(
                tr(""Could not display image: %1."").arg(img->uname().c_str()));
            statusViewInfo->setText(tr(""""));
            return false;
        }
    }
    return false;
}



void
ImageViewer::displayCurrentImage(bool update)
{
    if (m_current_image < 0 || m_current_image >= (int)m_images.size())
        m_current_image = 0;
    IvImage* img = cur();
    if (img) {
        if (!img->image_valid()) {
            bool load_result = false;

            statusViewInfo->hide();
            statusProgress->show();
            load_result = loadCurrentImage(std::max(0, img->subimage()),
                                           std::max(0, img->miplevel()));
            statusProgress->hide();
            statusViewInfo->show();

            if (load_result) {
                update = true;
            } else {
                return;
            }
        }
    } else {
        m_current_image = m_last_image = -1;
        ((QOpenGLWidget*)(glwin))->update();
    }

    if (update) {
        glwin->update();
    }
    float z = zoom();
    if (fitImageToWindowAct->isChecked())
        z = zoom_needed_to_fit(glwin->width(), glwin->height());
    zoom(z);
    //    glwin->trigger_redraw ();

    updateTitle();
    updateStatusBar();
    if (infoWindow)
        infoWindow->update(img);

    //    printAct->setEnabled(true);
    //    fitImageToWindowAct->setEnabled(true);
    //    fullScreenAct->setEnabled(true);
    updateActions();
}



void
ImageViewer::deleteCurrentImage()
{
    IvImage* img = cur();
    if (img) {
        const char* filename = img->uname().c_str();
        QString message(""Are you sure you want to remove <b>"");
        message = message + QString(filename) + QString(""</b> file from disk?"");
        QMessageBox::StandardButton button;
        button = QMessageBox::question(this, """", message,
                                       QMessageBox::Yes | QMessageBox::No);
        if (button == QMessageBox::Yes) {
            closeImg();
            int r = remove(filename);
            if (r)
                QMessageBox::information(this, """", ""Unable to delete file"");
        }
    }
}



void
ImageViewer::current_image(int newimage)
{
#ifndef NDEBUG
    Timer swap_image_time;
    swap_image_time.start();
#endif
    if (m_images.empty() || newimage < 0 || newimage >= (int)m_images.size())
        m_current_image = 0;
    if (m_current_image != newimage) {
        m_last_image    = (m_current_image >= 0) ? m_current_image : newimage;
        m_current_image = newimage;
        displayCurrentImage();
    } else {
        displayCurrentImage(false);
    }
#ifndef NDEBUG
    swap_image_time.stop();
    std::cerr << ""Current Image change elapsed time: "" << swap_image_time()
              << "" seconds \\n"";
#endif
}



void
ImageViewer::prevImage()
{
    if (m_images.empty())
        return;
    if (m_current_image == 0)
        current_image((int)m_images.size() - 1);
    else
        current_image(current_image() - 1);
}


void
ImageViewer::nextImage()
{
    if (m_images.empty())
        return;
    if (m_current_image >= (int)m_images.size() - 1)
        current_image(0);
    else
        current_image(current_image() + 1);
}



void
ImageViewer::toggleImage()
{
    current_image(m_last_image);
}



void
ImageViewer::exposureMinusOneTenthStop()
{
    if (m_images.empty())
        return;
    IvImage* img = m_images[m_current_image];
    img->exposure(img->exposure() - 0.1);
    if (!glwin->is_glsl_capable()) {
        bool srgb_transform = (!glwin->is_srgb_capable()
                               && IsSpecSrgb(img->spec()));
        img->pixel_transform(srgb_transform, (int)current_color_mode(),
                             current_channel());
        displayCurrentImage();
    } else {
        displayCurrentImage(false);
    }
}


void
ImageViewer::exposureMinusOneHalfStop()
{
    if (m_images.empty())
        return;
    IvImage* img = m_images[m_current_image];
    img->exposure(img->exposure() - 0.5);
    if (!glwin->is_glsl_capable()) {
        bool srgb_transform = (!glwin->is_srgb_capable()
                               && IsSpecSrgb(img->spec()));
        img->pixel_transform(srgb_transform, (int)current_color_mode(),
                             current_channel());
        displayCurrentImage();
    } else {
        displayCurrentImage(false);
    }
}


void
ImageViewer::exposurePlusOneTenthStop()
{
    if (m_images.empty())
        return;
    IvImage* img = m_images[m_current_image];
    img->exposure(img->exposure() + 0.1);
    if (!glwin->is_glsl_capable()) {
        bool srgb_transform = (!glwin->is_srgb_capable()
                               && IsSpecSrgb(img->spec()));
        img->pixel_transform(srgb_transform, (int)current_color_mode(),
                             current_channel());
        displayCurrentImage();
    } else {
        displayCurrentImage(false);
    }
}


void
ImageViewer::exposurePlusOneHalfStop()
{
    if (m_images.empty())
        return;
    IvImage* img = m_images[m_current_image];
    img->exposure(img->exposure() + 0.5);
    if (!glwin->is_glsl_capable()) {
        bool srgb_transform = (!glwin->is_srgb_capable()
                               && IsSpecSrgb(img->spec()));
        img->pixel_transform(srgb_transform, (int)current_color_mode(),
                             current_channel());
        displayCurrentImage();
    } else {
        displayCurrentImage(false);
    }
}



void
ImageViewer::gammaMinus()
{
    if (m_images.empty())
        return;
    IvImage* img = m_images[m_current_image];
    img->gamma(img->gamma() - 0.05);
    if (!glwin->is_glsl_capable()) {
        bool srgb_transform = (!glwin->is_srgb_capable()
                               && IsSpecSrgb(img->spec()));
        img->pixel_transform(srgb_transform, (int)current_color_mode(),
                             current_channel());
        displayCurrentImage();
    } else {
        displayCurrentImage(false);
    }
}


void
ImageViewer::gammaPlus()
{
    if (m_images.empty())
        return;
    IvImage* img = m_images[m_current_image];
    img->gamma(img->gamma() + 0.05);
    if (!glwin->is_glsl_capable()) {
        bool srgb_transform = (!glwin->is_srgb_capable()
                               && IsSpecSrgb(img->spec()));
        img->pixel_transform(srgb_transform, (int)current_color_mode(),
                             current_channel());
        displayCurrentImage();
    } else {
        displayCurrentImage(false);
    }
}



void
ImageViewer::slide(long /*t*/, bool b)
{
    slideLoopAct->setChecked(b == true);
    slideNoLoopAct->setChecked(b == false);
}



void
ImageViewer::viewChannel(int c, COLOR_MODE colormode)
{
#ifndef NDEBUG
    Timer change_channel_time;
    change_channel_time.start();
#endif
    if (m_current_channel != c || colormode != m_color_mode) {
        bool update = true;
        if (!glwin->is_glsl_capable()) {
            IvImage* img = cur();
            if (img) {
                bool srgb_transform = (!glwin->is_srgb_capable()
                                       && IsSpecSrgb(img->spec()));
                img->pixel_transform(srgb_transform, (int)colormode, c);
            }
        } else {
            // FIXME: There are even more chances to avoid updating the textures
            // if we can keep trac of which channels are in the texture.
            if (m_current_channel == c) {
                if (m_color_mode == SINGLE_CHANNEL || m_color_mode == HEATMAP) {
                    if (colormode == HEATMAP || colormode == SINGLE_CHANNEL)
                        update = false;
                } else if (m_color_mode == RGB || m_color_mode == LUMINANCE) {
                    if (colormode == RGB || colormode == LUMINANCE)
                        update = false;
                }
            }
        }
        m_current_channel = c;
        m_color_mode      = colormode;
        displayCurrentImage(update);

        viewChannelFullAct->setChecked(c == 0 && m_color_mode == RGBA);
        viewChannelRedAct->setChecked(c == 0 && m_color_mode == SINGLE_CHANNEL);
        viewChannelGreenAct->setChecked(c == 1
                                        && m_color_mode == SINGLE_CHANNEL);
        viewChannelBlueAct->setChecked(c == 2
                                       && m_color_mode == SINGLE_CHANNEL);
        viewChannelAlphaAct->setChecked(c == 3
                                        && m_color_mode == SINGLE_CHANNEL);
        viewColorLumAct->setChecked(m_color_mode == LUMINANCE);
        viewColorRGBAAct->setChecked(m_color_mode == RGBA);
        viewColorRGBAct->setChecked(m_color_mode == RGB);
        viewColor1ChAct->setChecked(m_color_mode == SINGLE_CHANNEL);
        viewColorHeatmapAct->setChecked(m_color_mode == HEATMAP);
    }
#ifndef NDEBUG
    change_channel_time.stop();
    std::cerr << ""Change channel elapsed time: "" << change_channel_time()
              << "" seconds \\n"";
#endif
}


void
ImageViewer::slideImages()
{
    if (m_images.empty())
        return;
    if (m_current_image >= (int)m_images.size() - 1) {
        if (slide_loop == true)
            current_image(0);
        else {
            slideTimer->stop();
            disconnect(slideTimer, 0, 0, 0);
        }
    } else
        current_image(current_image() + 1);
}


void
ImageViewer::slideShow()
{
    fullScreenToggle();
    connect(slideTimer, SIGNAL(timeout()), this, SLOT(slideImages()));
    slideTimer->start(slideDuration_ms);
    updateActions();
}



void
ImageViewer::slideLoop()
{
    slide_loop = true;
    slide(slideDuration_ms, slide_loop);
}


void
ImageViewer::slideNoLoop()
{
    slide_loop = false;
    slide(slideDuration_ms, slide_loop);
}


void
ImageViewer::setSlideShowDuration(int seconds)
{
    slideDuration_ms = seconds * 1000;
}



static bool
compName(IvImage* first, IvImage* second)
{
    std::string firstFile  = Filesystem::filename(first->name());
    std::string secondFile = Filesystem::filename(second->name());
    return (firstFile.compare(secondFile) < 0);
}



void
ImageViewer::sortByName()
{
    int numImg = m_images.size();
    if (numImg < 2)
        return;
    std::sort(m_images.begin(), m_images.end(), &compName);
    current_image(0);
    displayCurrentImage();
    // updateActions();
}



static bool
compPath(IvImage* first, IvImage* second)
{
    std::string firstFile  = first->name();
    std::string secondFile = second->name();
    return (firstFile.compare(secondFile) < 0);
}



void
ImageViewer::sortByPath()
{
    int numImg = m_images.size();
    if (numImg < 2)
        return;
    std::sort(m_images.begin(), m_images.end(), &compPath);
    current_image(0);
    displayCurrentImage();
    // updateActions();
}



static bool
DateTime_to_time_t(string_view datetime, time_t& timet)
{
    int year, month, day, hour, min, sec;
    if (!Strutil::scan_datetime(datetime, year, month, day, hour, min, sec))
        return false;
    // print(""{}:{}:{} {}:{}:{}\\n"", year, month, day, hour, min, sec);
    struct tm tmtime;
    time_t now;
    Sysutil::get_local_time(&now, &tmtime);  // fill in defaults
    tmtime.tm_sec  = sec;
    tmtime.tm_min  = min;
    tmtime.tm_hour = hour;
    tmtime.tm_mday = day;
    tmtime.tm_mon  = month - 1;
    tmtime.tm_year = year - 1900;
    timet          = mktime(&tmtime);
    return true;
}



static bool
compImageDate(IvImage* first, IvImage* second)
{
    std::time_t firstFile  = time(NULL);
    std::time_t secondFile = time(NULL);
    double diff;
    std::string metadatatime = first->spec().get_string_attribute(""DateTime"");
    if (metadatatime.empty()) {
        if (first->init_spec(first->name(), 0, 0)) {
            metadatatime = first->spec().get_string_attribute(""DateTime"");
            if (metadatatime.empty()) {
                if (!Filesystem::exists(first->name()))
                    return false;
                firstFile = Filesystem::last_write_time(first->name());
            }
        } else
            return false;
    }
    DateTime_to_time_t(metadatatime.c_str(), firstFile);
    metadatatime = second->spec().get_string_attribute(""DateTime"");
    if (metadatatime.empty()) {
        if (second->init_spec(second->name(), 0, 0)) {
            metadatatime = second->spec().get_string_attribute(""DateTime"");
            if (metadatatime.empty()) {
                if (!Filesystem::exists(second->name()))
                    return true;
                secondFile = Filesystem::last_write_time(second->name());
            }
        } else
            return true;
    }
    DateTime_to_time_t(metadatatime.c_str(), secondFile);
    diff = difftime(firstFile, secondFile);
    if (diff == 0)
        return compName(first, second);
    return (diff < 0);
}



void
ImageViewer::sortByImageDate()
{
    int numImg = m_images.size();
    if (numImg < 2)
        return;
    std::sort(m_images.begin(), m_images.end(), &compImageDate);
    current_image(0);
    displayCurrentImage();
    // updateActions();
}



static bool
compFileDate(IvImage* first, IvImage* second)
{
    std::time_t firstFile, secondFile;
    double diff;
    if (!Filesystem::exists(first->name()))
        return false;
    firstFile = Filesystem::last_write_time(first->name());
    if (!Filesystem::exists(second->name()))
        return true;
    secondFile = Filesystem::last_write_time(second->name());
    diff       = difftime(firstFile, secondFile);
    if (diff == 0)
        return compName(first, second);
    return (diff < 0);
}



void
ImageViewer::sortByFileDate()
{
    int numImg = m_images.size();
    if (numImg < 2)
        return;
    std::sort(m_images.begin(), m_images.end(), &compFileDate);
    current_image(0);
    displayCurrentImage();
    // updateActions();
}



void
ImageViewer::sortReverse()
{
    int numImg = m_images.size();
    if (numImg < 2)
        return;
    std::reverse(m_images.begin(), m_images.end());
    current_image(0);
    displayCurrentImage();
    // updateActions();
}



void
ImageViewer::viewChannelFull()
{
    viewChannel(0, RGBA);
}


void
ImageViewer::viewChannelRed()
{
    viewChannel(0, SINGLE_CHANNEL);
}


void
ImageViewer::viewChannelGreen()
{
    viewChannel(1, SINGLE_CHANNEL);
}


void
ImageViewer::viewChannelBlue()
{
    viewChannel(2, SINGLE_CHANNEL);
}


void
ImageViewer::viewChannelAlpha()
{
    viewChannel(3, SINGLE_CHANNEL);
}


void
ImageViewer::viewChannelLuminance()
{
    viewChannel(m_current_channel, LUMINANCE);
}


void
ImageViewer::viewColorRGBA()
{
    viewChannel(m_current_channel, RGBA);
}


void
ImageViewer::viewColorRGB()
{
    viewChannel(m_current_channel, RGB);
}


void
ImageViewer::viewColor1Ch()
{
    viewChannel(m_current_channel, SINGLE_CHANNEL);
}


void
ImageViewer::viewColorHeatmap()
{
    viewChannel(m_current_channel, HEATMAP);
}


void
ImageViewer::viewChannelPrev()
{
    if (glwin->is_glsl_capable()) {
        if (m_current_channel > 0)
            viewChannel(m_current_channel - 1, m_color_mode);
    } else {
        // Simulate old behavior.
        if (m_color_mode == RGBA || m_color_mode == RGB) {
            viewChannel(m_current_channel, LUMINANCE);
        } else if (m_color_mode == SINGLE_CHANNEL) {
            if (m_current_channel == 0)
                viewChannelFull();
            else
                viewChannel(m_current_channel - 1, SINGLE_CHANNEL);
        }
    }
}


void
ImageViewer::viewChannelNext()
{
    if (glwin->is_glsl_capable()) {
        viewChannel(m_current_channel + 1, m_color_mode);
    } else {
        // Simulate old behavior.
        if (m_color_mode == LUMINANCE) {
            viewChannelFull();
        } else if (m_color_mode == RGBA || m_color_mode == RGB) {
            viewChannelRed();
        } else if (m_color_mode == SINGLE_CHANNEL) {
            viewChannel(m_current_channel + 1, SINGLE_CHANNEL);
        }
    }
}



void
ImageViewer::viewSubimagePrev()
{
    IvImage* img = cur();
    if (!img)
        return;
    bool ok = false;
    if (img->miplevel() > 0) {
        ok = loadCurrentImage(img->subimage(), img->miplevel() - 1);
    } else if (img->subimage() > 0) {
        ok = loadCurrentImage(img->subimage() - 1);
    } else if (img->nsubimages() > 0) {
        img->auto_subimage(true);
        ok = loadCurrentImage(0);
    }
    if (ok) {
        if (fitImageToWindowAct->isChecked())
            fitImageToWindow();
        displayCurrentImage();
    }
}


void
ImageViewer::viewSubimageNext()
{
    IvImage* img = cur();
    if (!img)
        return;
    bool ok = false;
    if (img->auto_subimage()) {
        img->auto_subimage(false);
        ok = loadCurrentImage(0);
    } else if (img->miplevel() < img->nmiplevels() - 1) {
        ok = loadCurrentImage(img->subimage(), img->miplevel() + 1);
    } else if (img->subimage() < img->nsubimages() - 1) {
        ok = loadCurrentImage(img->subimage() + 1);
    }
    if (ok) {
        if (fitImageToWindowAct->isChecked())
            fitImageToWindow();
        displayCurrentImage();
    }
}



void
ImageViewer::keyPressEvent(QKeyEvent* event)
{
    switch (event->key()) {
    case Qt::Key_Left:
    case Qt::Key_Up:
    case Qt::Key_PageUp: prevImage(); return;  //break;
    case Qt::Key_Right:
        //        std::cerr << ""Modifier is "" << (int)event->modifiers() << '\\n';
        //        fprintf (stderr, ""%x\\n"", (int)event->modifiers());
        //        if (event->modifiers() & Qt::ShiftModifier)
        //            std::cerr << ""hey, ctrl right\\n"";
    case Qt::Key_Down:
    case Qt::Key_PageDown: nextImage(); return;  //break;
    case Qt::Key_Escape:
        if (m_fullscreen)
            fullScreenToggle();
        return;
    case Qt::Key_Minus:
    case Qt::Key_Underscore: zoomOut(); break;
    case Qt::Key_Plus:
    case Qt::Key_Equal: zoomIn(); break;
    default:
        // std::cerr << ""ImageViewer key "" << (int)event->key() << '\\n';
        QMainWindow::keyPressEvent(event);
    }
}



void
ImageViewer::resizeEvent(QResizeEvent* event)
{
    if (fitImageToWindowAct->isChecked())
        fitImageToWindow();
    QMainWindow::resizeEvent(event);
}



void
ImageViewer::closeImg()
{
    if (m_images.empty())
        return;
    delete m_images[m_current_image];
    m_images[m_current_image] = NULL;
    m_images.erase(m_images.begin() + m_current_image);

    // Update image indices
    // This should be done for all image indices we may be storing
    if (m_last_image == m_current_image) {
        if (!m_images.empty() && m_last_image > 0)
            m_last_image = 0;
        else
            m_last_image = -1;
    }
    if (m_last_image > m_current_image)
        m_last_image--;

    m_current_image = m_current_image < (int)m_images.size() ? m_current_image
                                                             : 0;
    displayCurrentImage();
}



void
ImageViewer::print()
{
#if 0
    Q_ASSERT(imageLabel->pixmap());
    QPrintDialog dialog(&printer, this);
    if (dialog.exec()) {
        QPainter painter(&printer);
        QRect rect = painter.viewport();
        QSize size = imageLabel->pixmap()->size();
        size.scale(rect.size(), Qt::KeepAspectRatio);
        painter.setViewport(rect.x(), rect.y(), size.width(), size.height());
        painter.setWindow(imageLabel->pixmap()->rect());
        painter.drawPixmap(0, 0, *imageLabel->pixmap());
    }
#endif
}



void
ImageViewer::zoomIn()
{
    IvImage* img = cur();
    if (!img)
        return;
    if (zoom() >= 64)
        return;
    float oldzoom = zoom();
    float newzoom = ceil2f(oldzoom);

    float xc, yc;  // Center view position
    glwin->get_center(xc, yc);
    int xm, ym;  // Mouse position
    glwin->get_focus_image_pixel(xm, ym);
    float xoffset      = xc - xm;
    float yoffset      = yc - ym;
    float maxzoomratio = std::max(oldzoom / newzoom, newzoom / oldzoom);
    int nsteps         = (int)OIIO::clamp(20 * (maxzoomratio - 1), 2.0f, 10.0f);
    for (int i = 1; i <= nsteps; ++i) {
        float a         = (float)i / (float)nsteps;  // Interpolation amount
        float z         = OIIO::lerp(oldzoom, newzoom, a);
        float zoomratio = z / oldzoom;
        view(xm + xoffset / zoomratio, ym + yoffset / zoomratio, z, false);
        if (i != nsteps) {
            QApplication::processEvents();
            Sysutil::usleep(1000000 / 4 / nsteps);
        }
    }

    fitImageToWindowAct->setChecked(false);
}



void
ImageViewer::zoomOut()
{
    IvImage* img = cur();
    if (!img)
        return;
    if (zoom() <= 1.0f / 64)
        return;
    float oldzoom = zoom();
    float newzoom = floor2f(oldzoom);

    float xcpel, ycpel;  // Center view position
    glwin->get_center(xcpel, ycpel);
    int xmpel, ympel;  // Mouse position
    glwin->get_focus_image_pixel(xmpel, ympel);
    float xoffset      = xcpel - xmpel;
    float yoffset      = ycpel - ympel;
    float maxzoomratio = std::max(oldzoom / newzoom, newzoom / oldzoom);
    int nsteps         = (int)OIIO::clamp(20 * (maxzoomratio - 1), 2.0f, 10.0f);
    for (int i = 1; i <= nsteps; ++i) {
        float a         = (float)i / (float)nsteps;  // Interpolation amount
        float z         = OIIO::lerp(oldzoom, newzoom, a);
        float zoomratio = z / oldzoom;
        view(xmpel + xoffset / zoomratio, ympel + yoffset / zoomratio, z,
             false);
        if (i != nsteps) {
            QApplication::processEvents();
            Sysutil::usleep(1000000 / 4 / nsteps);
        }
    }

    fitImageToWindowAct->setChecked(false);
}


void
ImageViewer::normalSize()
{
    IvImage* img = cur();
    if (!img)
        return;
    fitImageToWindowAct->setChecked(false);
    float xcenter = img->oriented_full_x() + 0.5 * img->oriented_full_width();
    float ycenter = img->oriented_full_y() + 0.5 * img->oriented_full_height();
    view(xcenter, ycenter, 1.0, true);
    fitWindowToImage(false);
}



float
ImageViewer::zoom_needed_to_fit(int w, int h)
{
    IvImage* img = cur();
    if (!img)
        return 1;
    float zw = (float)w / img->oriented_width();
    float zh = (float)h / img->oriented_height();
    return std::min(zw, zh);
}



void
ImageViewer::fitImageToWindow()
{
    IvImage* img = cur();
    if (!img)
        return;
    fitImageToWindowAct->setChecked(true);
    zoom(zoom_needed_to_fit(glwin->width(), glwin->height()));
}



void
ImageViewer::fitWindowToImage(bool zoomok, bool minsize)
{
    IvImage* img = cur();
    // Don't resize when there's no image or the image hasn't been opened yet
    // (or we failed to open it).
    if (!img || !img->image_valid())
        return;
        // FIXME -- figure out a way to make it exactly right, even for the
        // main window border, etc.
#ifdef __APPLE__
    int extraw = 0;  //12; // width() - minimumWidth();
    int extrah = statusBar()->height()
                 + 0;  //40; // height() - minimumHeight();
#else
    int extraw = 4;  //12; // width() - minimumWidth();
    int extrah = statusBar()->height()
                 + 4;  //40; // height() - minimumHeight();
#endif
    //    std::cerr << ""extra wh = "" << extraw << ' ' << extrah << '\\n';

    float z = zoom();
    int w   = (int)(img->oriented_full_width() * z) + extraw;
    int h   = (int)(img->oriented_full_height() * z) + extrah;
    if (minsize) {
        if (w < m_default_width) {
            w = m_default_width;
        }
        if (h < m_default_height) {
            h = m_default_height;
        }
    }

    if (!m_fullscreen) {
        QDesktopWidget* desktop = QApplication::desktop();
        QRect availgeom         = desktop->availableGeometry(this);
        int availwidth          = availgeom.width() - extraw - 20;
        int availheight = availgeom.height() - extrah - menuBar()->height()
                          - 20;
#if 0
        QRect screengeom = desktop->screenGeometry (this);
        std::cerr << ""available desktop geom "" << availgeom.x() << ' ' << availgeom.y() << ' ' << availgeom.width() << ""x"" << availgeom.height() << ""\\n"";
        std::cerr << ""screen desktop geom "" << screengeom.x() << ' ' << screengeom.y() << ' ' << screengeom.width() << ""x"" << screengeom.height() << ""\\n"";
#endif
        if (w > availwidth || h > availheight) {
            w = std::min(w, availwidth);
            h = std::min(h, availheight);
            if (zoomok) {
                z = zoom_needed_to_fit(w, h);
                w = (int)(img->oriented_full_width() * z) + extraw;
                h = (int)(img->oriented_full_height() * z) + extrah;
                // std::cerr << ""must rezoom to "" << z << "" to fit\\n"";
            }
            // std::cerr << ""New window geom "" << w << ""x"" << h << ""\\n"";
            int posx = x(), posy = y();
            if (posx + w > availwidth || posy + h > availheight) {
                if (posx + w > availwidth)
                    posx = std::max(0, availwidth - w) + availgeom.x();
                if (posy + h > availheight)
                    posy = std::max(0, availheight - h) + availgeom.y();
                // std::cerr << ""New position "" << posx << ' ' << posy << ""\\n"";
                move(QPoint(posx, posy));
            }
        }
    }

    float midx = img->oriented_full_x() + 0.5 * img->oriented_full_width();
    float midy = img->oriented_full_y() + 0.5 * img->oriented_full_height();
    view(midx, midy, z, false, false);
    resize(w, h);  // Resize will trigger a repaint.

#if 0
    QRect g = geometry();
    std::cerr << ""geom "" << g.x() << ' ' << g.y() << ' ' << g.width() << ""x"" << g.height() << ""\\n"";
    g = frameGeometry();
    std::cerr << ""frame geom "" << g.x() << ' ' << g.y() << ' ' << g.width() << ""x"" << g.height() << ""\\n"";
    g = glwin->geometry();
    std::cerr << ""ogl geom "" << g.x() << ' ' << g.y() << ' ' << g.width() << ""x"" << g.height() << ""\\n"";
    std::cerr << ""Status bar height = "" << statusBar()->height() << ""\\n"";
#endif

#if 0
    bool fit = fitWindowToImageAct->isChecked();
    if (!fit) {
        normalSize();
    }
#endif
    updateActions();
}



void
ImageViewer::fullScreenToggle()
{
    if (m_fullscreen) {
        menuBar()->show();
        statusBar()->show();
        showNormal();
        m_fullscreen = false;
        slideTimer->stop();
        disconnect(slideTimer, 0, 0, 0);
    } else {
        menuBar()->hide();
        statusBar()->hide();
        showFullScreen();
        m_fullscreen = true;
        fitImageToWindow();
    }
}



void
ImageViewer::about()
{
    QMessageBox::about(
        this, tr(""About iv""),
        tr(""<p><b>iv</b> is the image viewer for OpenImageIO.</p>""
           ""<p>(c) Copyright Contributors to the OpenImageIO project.</p>""
           ""<p>See <a href='http://openimageio.org'>http://openimageio.org</a> for details.</p>""));
}


void
ImageViewer::updateActions()
{
    //    zoomInAct->setEnabled(!fitImageToWindowAct->isChecked());
    //    zoomOutAct->setEnabled(!fitImageToWindowAct->isChecked());
    //    normalSizeAct->setEnabled(!fitImageToWindowAct->isChecked());
}



static inline void
calc_subimage_from_zoom(const IvImage* img, int& subimage, float& zoom,
                        float& xcenter, float& ycenter)
{
    int rel_subimage = std::trunc(std::log2(1.0f / zoom));
    subimage         = clamp<int>(img->subimage() + rel_subimage, 0,
                          img->nsubimages() - 1);
    if (!(img->subimage() == 0 && zoom > 1)
        && !(img->subimage() == img->nsubimages() - 1 && zoom < 1)) {
        float pow_zoom = powf(2.0f, (float)rel_subimage);
        zoom *= pow_zoom;
        xcenter /= pow_zoom;
        ycenter /= pow_zoom;
    }
}



void
ImageViewer::view(float xcenter, float ycenter, float newzoom, bool smooth,
                  bool redraw)
{
    IvImage* img = cur();
    if (!img)
        return;

    float oldzoom = m_zoom;
    float oldxcenter, oldycenter;
    glwin->get_center(oldxcenter, oldycenter);
    float zoomratio = std::max(oldzoom / newzoom, newzoom / oldzoom);
    int nsteps      = (int)OIIO::clamp(20 * (zoomratio - 1), 2.0f, 10.0f);
    if (!smooth || !redraw)
        nsteps = 1;
    for (int i = 1; i <= nsteps; ++i) {
        float a  = (float)i / (float)nsteps;  // Interpolation amount
        float xc = OIIO::lerp(oldxcenter, xcenter, a);
        float yc = OIIO::lerp(oldycenter, ycenter, a);
        m_zoom   = OIIO::lerp(oldzoom, newzoom, a);

        glwin->view(xc, yc, m_zoom, redraw);  // Triggers redraw automatically
        if (i != nsteps) {
            QApplication::processEvents();
            Sysutil::usleep(1000000 / 4 / nsteps);
        }
    }

    if (img->auto_subimage()) {
        int subimage = 0;
        calc_subimage_from_zoom(img, subimage, m_zoom, xcenter, ycenter);
        if (subimage != img->subimage()) {
            //std::cerr << ""Changing to subimage "" << subimage;
            //std::cerr << "" With zoom: "" << m_zoom << '\\n';
            loadCurrentImage(subimage);
            glwin->update();
            glwin->view(xcenter, ycenter, m_zoom, redraw);
        }
    }

    //    zoomInAct->setEnabled (zoom() < 64.0);
    //    zoomOutAct->setEnabled (zoom() > 1.0/64);

    updateStatusBar();
}



void
ImageViewer::zoom(float newzoom, bool smooth)
{
    float xcenter, ycenter;
    glwin->get_center(xcenter, ycenter);
    view(xcenter, ycenter, newzoom, smooth);
}



void
ImageViewer::showInfoWindow()
{
    if (!infoWindow) {
        infoWindow = new IvInfoWindow(*this, true);
        infoWindow->setPalette(m_palette);
    }
    infoWindow->update(cur());
    if (infoWindow->isHidden())
        infoWindow->show();
    else
        infoWindow->hide();
}



void
ImageViewer::showPixelviewWindow()
{
    ((QOpenGLWidget*)(glwin))->update();
}



void
ImageViewer::editPreferences()
{
    if (!preferenceWindow) {
        preferenceWindow = new IvPreferenceWindow(*this);
        preferenceWindow->setPalette(m_palette);
    }
    preferenceWindow->show();
}
",16199,True,2628.537474332979,median
"= jbang - Unleash the power of Java
:idprefix:
:idseparator: -
ifndef::env-github[]
:toc: left
:icons: font
endif::[]
ifdef::env-github[]
:toc: macro
:caution-caption: :fire:
:important-caption: :exclamation:
:note-caption: :paperclip:
:tip-caption: :bulb:
:warning-caption: :warning:
endif::[]

image:https://img.shields.io/github/release/jbangdev/jbang.svg[Release,link=https://github.com/jbangdev/jbang/releases]
image:https://github.com/jbangdev/jbang/workflows/ci-build/badge.svg[Build Status,link=https://github.com/jbangdev/jbang/actions]
image:https://www.eclipse.org/che/contribute.svg[Che, link=https://che.openshift.io/f?url=https://github.com/jbangdev/jbang]
image:https://img.shields.io/badge/Gitpod-Workspace-blue?logo=gitpodp[Gitpod, link=https://gitpod.io/#https://github.com/jbangdev/jbang]
image:https://badges.gitter.im/jbangdev/community.svg[Gitter, link=https://gitter.im/jbangdev/community]


image:images/jbang_logo.svg[JBang Logo, title=""JBang Logo""]

== Intro

Want to learn, explore or use Java instantly without setup ?

Do you like Java but use python, groovy, kotlin or similar languages for scripts, experimentation and exploration ?

Ever wanted to just be able to run java from anywhere without any or very minimal setup ?
Ever tried out Java 11+ support for running `.java` files directly in your shell but felt it was a bit too cumbersome ?

Then try `jbang` which lets you do this:

image:https://asciinema.org/a/4AiobRxUwPUPztCtrDYcmoKjs.svg[link=https://asciinema.org/a/4AiobRxUwPUPztCtrDYcmoKjs?autoplay=true&theme=solarized-dark]

[source, bash]
----
$ jbang init --template=cli hello.java
$ jbang hello.java Max!
[jbang] Resolving dependencies...
[jbang]     Resolving info.picocli:picocli:4.5.0...Done
[jbang] Dependencies resolved
[jbang] Building jar...
Hello Max!
$ jbang hello.java -h
Usage: hello [-hV] <greeting>
hello made with jbang
      <greeting>   The greeting to print
  -h, --help       Show this help message and exit.
  -V, --version    Print version information and exit.
----

Instant cli app generated built using java and picocli as a dependency that was fetched as needed for the compilation and execution.

JBang goes beyond more than just easy scripting; you can use `jbang` to launch any kind of java application or library packaged as a jar available locally, via http/https download or in a Maven repository.

toc::[]

== Features

* `.java` Scripting for Java 8 and upwards
* `.jsh` via JShell from Java 9 and upwards
* Works on icon:windows[] Windows, icon:apple[] OSX and icon:linux[] Linux
* Install using curl, power shell, SDKMan (icon:apple[]/icon:linux[]), Homebrew (icon:apple[]), Chocolatey (icon:windows[]) or Scoop (icon:windows[])
* If needed will automatically install Java and even a Java editor (vscodium) for editing
* Installation of scripts to user `PATH`
* Include multiple files and sources
* Dependency declarations using `//DEPS <gav>` for automatic dependency resolution
* Control compile and runtime options with `//JAVAC_OPTIONS <flags>` and `//JAVA_OPTIONS <flags>`
* Compiled jar and Dependency resolution caching
* native-image generation (`--native`)
* Launch with debug enabled for instant debugging from your favorite IDE
* Transparent launch of JavaFX Applications on Java 8 and higher
* Can be used for writing plugins to other cli's like `kubectl`
* Init templates to get started easily (`jbang init -t cli hello.java`)
* Generate gradle and IDE config with dependencies for easy editing in your favorite IDE (`jbang edit myfile.java`)

To use it install `jbang` and run `jbang yourscript.java`

== Requirements

Tested and verified to use on OSX, Linux and Windows (incl. command.exe, cygwin and mingw shells).

== Installation

To use `jbang` Java 8 is the minimum required version, however Java 11 or higher is recommended.

Note: `jbang` will download and install `java` from Adopt OpenJDK if no `java` is available.

Once you have installed from one of the below approaches it is recommended you run `jbang app setup`
to have it setup your `PATH` to include jbang app scripts + it will on operating systems that supports
it setup a `j!` alias you can use instead of `jbang`.

=== SDKMan icon:linux[] / icon:apple[]

To install both java and `jbang` we recommend https://sdkman.io[sdkman] on Linux and OSX.

[source, bash]
----
curl -s ""https://get.sdkman.io"" | bash # <.>
source ~/.bash_profile # <.>

sdk install java # <.>
----

Once Java is installed and ready, you install `jbang` with

[source, bash]
----
sdk install jbang
----

To test your installation run:

[source, bash]
----
jbang --help
----

This should print out usage information.

To update run:

[source]
----
sdk update jbang
----

=== Chocolatey icon:windows[]

On Windows you can install both `java` and jbang` with https://chocolatey.org[Chocolatey].

From a command prompt with enough rights to install with choco:

  choco install jdk11

Once Java in installed run:

  choco install jbang

To upgrade to latest version:

  choco upgrade jbang

The latest package will be published to https://chocolatey.org/packages/jbang[jbang choco package page],
it might be a bit delayed as the review is still manual. In case the default version is not
the latest you can see the https://chocolatey.org/packages/jbang/#versionhistory[version list] and install specific version using:

  choco install jbang --version=<version number>

=== Scoop icon:windows[]

On Windows you can also install `jbang` with https://scoop.sh[Scoop].

[source, bash]
----
scoop bucket add jbangdev https://github.com/jbangdev/scoop-bucket
scoop install jbang
----

To upgrade to latest version:

  scoop update jbang

=== Homebrew icon:apple[]

On OSX you can install 'java' and `jbang` with https://brew.sh[Homebrew] using custom taps.

To install Java 11:

[source, bash]
----
brew tap AdoptOpenJDK/openjdk
brew cask install adoptopenjdk11
----

Once Java is installed you can use brew with https://github.com/jbangdev/homebrew-tap/[jbangdev/tap] to get `jbang`:

  brew install jbangdev/tap/jbang

To upgrade to latest version:

  brew upgrade jbangdev/tap/jbang

=== (Experimental) Linux packages icon:linux[]

WARNING: These builds are not fully automated yet thus might be slightly behind.

You can install rpm packages from https://copr.fedorainfracloud.org/coprs/maxandersen/jbang/[Fedora Copr]
by doing the following:

[source]
----
dnf copr enable maxandersen/jbang
dnf install jbang
----

The COPR currently includes builds from various versions of CentOS, Fedora, Mageia and OpenSuse.

=== Docker / GitHub Action icon:docker[]

You can run `jbang` via Docker:

[source, bash]
----
docker run -v `pwd`:/ws --workdir=/ws jbangdev/jbang-action helloworld.java
----

or if you prefer using Quay.io:

[source, bash]
----
docker run -v `pwd`:/ws --workdir=/ws quay.io/jbangdev/jbang-action helloworld.java
----

The same container images can be used with GitHub Actions, see https://github.com/jbangdev/jbang-action[jbang-action] for details.

=== Manual install

Unzip the https://github.com/jbangdev/jbang/releases/latest[latest binary release], add the `jbang-<version>/bin` folder to your `$PATH` and you are set.

=== Wrapper install

If you would like to have `jbang` available in a local directory and committed into a source code repository (akin to Maven and Gradle wrappers) you can use the `jbang wrapper` command.

If you have `jbang` already installed you call `jbang wrapper install` in a folder to install a local `jbang`
that will run out of that directory using `./jbang`.

The `./.jbang` directory which `jbang wrapper install` creates is just a cache which you typically would not commit to a source code repository, so you can e.g. `echo .jbang/ >>.gitignore`.

=== ""Zero"" Install

If you want to try out jbang without a package manager or similar you can run the following to download jbang in `~/.jbang` and if necessary `java`.

Linux/OSX/Windows Bash:

[source, bash]
----
curl -Ls https://sh.jbang.dev | bash -s - <arguments>
----

For example `curl -Ls https://sh.jbang.dev | bash -s - properties@jbangdev`

Windows Powershell:

[source, powershell]
----
iex ""& { $(iwr -useb https://ps.jbang.dev) } <arguments>""
----

For example `iex ""& { $(iwr -useb https://ps.jbang.dev) } properties@jbangdev""`

== Usage

A script is just a single `.java` file with a classic static main method or a `.jsh` file which will be passed to `jshell`.

Below is an (almost) minimal example you can save in `helloworld.java` or simply run `jbang init helloworld.java`:

[source,java]
----
///usr/bin/env jbang ""$0"" ""$@"" ; exit $? # <.>

class helloworld { // <.>

    public static void main(String[] args) {
        if(args.length==0) {
            System.out.println(""Hello World!"");
        } else {
            System.out.println(""Hello "" + args[0]);
        }
    }
}
----
<.> By using this `//` style instead of shebang `#!` you trick `bash`, `zsh` etc. to run this as a script while still being valid java code.
<.> A classname, can be anything when using `jbang` but to be valid java for most IDEs you'll want to name it the same as the source file.

Now to run this you can call it via `jbang`:

[source]
----
jbang helloworld.java
----

or if on Linux/OSX run it directly. If you created it manually you need to mark it as executable before running it.

[source]
----
chmod +x helloworld.java
./helloworld.java jbang!
----

[WARNING]
====
When no <<java-version,JDK version>> is available in the PATH, JDK 11 will be downloaded by default to bootstrap jbang.
If your script requires a higher version and you don' want to download two JDK's, you can define an alternative default with `JBANG_DEFAULT_JAVA_VERSION` env variable.

 $ JBANG_DEFAULT_JAVA_VERSION=14 jbang my-script.java

Note that if JDK is found in the PATH, `JBANG_DEFAULT_JAVA_VERSION` will be ignored.
====

=== Default application

If you pass a directory or a url ending in `/` jbang will look for `main.java` to run as default application for that directory / location.

=== URLs from Trusted Sources

You can use `http(s):/` and `file:/` url's for input:.

[source]
----
jbang https://gist.github.com/maxandersen/f43b4c52dfcfc42dcd59a04e49acf6ec
----

For safety reasons jbang will not run arbitrary urls before you indicated you trust their source.
Thus when running the above for the first time you will see the following warning about the url not being a trusted source:

[source,bash]
----
jbang https://gist.github.com/maxandersen/f43b4c52dfcfc42dcd59a04e49acf6ec
[jbang] https://gist.github.com/maxandersen/f43b4c52dfcfc42dcd59a04e49acf6ec is not from a trusted source thus not running it automatically.

If you trust the url to be safe to run you can do one of the following:
0) Trust once: Add no trust, just run this time
1) Trust this url in future:
    jbang trust add https://gist.github.com/maxandersen/


Any other response will result in exit.

[jbang] Type in your choice (0 or 1) and hit enter. Times out after 10 seconds.
----

You can then choose 0 to run once or 1 to trust the suggested url. If you don't answer within 10 seconds jbang will exit.

To enable running it without such question you need to mark that url or a sub part of it as a trusted source.
i.e. `jbang trust add https://github.com/maxandersen/` will tell `jbang` to trust anything with that base url.

You can see more in the comments of the `~/.jbang/trusted-sources.json`.

[TIP]
====
Sites such as GitHub, gitlab, bitbucket, gist, carbon.now.sh jbang will try and extract the proper source rather than the raw html.
i.e. doing `jbang https://carbon.now.sh/ae51bf967c98f31a13cba976903030d5 carbon!` is possible.
====

[TIP]
====
URL's will follow redirects. In case you need to use it with sites with self-signed/non-trusted certificates you can
if you trust the site use `--insecure`.
====

=== Build and run native image (Experimental)

There is support for using `native-image` from GraalVM project to produce a binary executable.

Since not all java libraries can automatically be built with `native-image` - especially if using reflection feature are considered highly experimental.

Just run `jbang --native helloworld.java` and `jbang` will use `native-image` from either `$JAVA_HOME/bin` or `$GRAALVM_HOME/bin` or `$PATH` to
produce a native image binary.

You can install the `native-image` utility binary e.g. by installing GraalVM from https://www.graalvm.org/downloads, and then once running `gu install native-image` as per https://www.graalvm.org/reference-manual/native-image.


[TIP]
====
If you use `--native` with picocli remember to add `info.picocli:picocli-codegen` as that will ensure it will actually work with `native-image`.
====


=== Using `.jsh` for `jshell`

There is support to run `.jsh` via `jshell`. The advantage of `jshell` is that you do not need to have a class or static main method.

Classic `jshell` does not support passing in arguments nor system properties, `jbang` does.

In the case of `.jsh` files `jbang` injects a startup script that declares a `String[] args` which will contain any passed in arguments,
and it sets any properties passed in as `-Dkey=value` as parameters to `jbang`.

That means you can run a script as `jbang -Dkey=value helloworld.jsh World` and retrieve arguments and properties as:

[source,java]
----
System.out.println(""Hello "" + (args.length>0?args[0]:""World"")); // <.>
System.out.println(System.getProperty(""key"")); // <.>
----
<.> Line where `args` are accessible without previous declaration.
<.> System properties set when passed as `-D` arguments to `jbang`

The script will have the output:

 Hello World
 value

Please note that `.jsh` files are source only, they are not compiled thus they are https://github.com/jbangdev/jbang/issues/506[not cached] nor can they be https://github.com/jbangdev/jbang/issues/510[built as native images].

[TIP]
====
If you use `-Dkey` where no value is specified `jbang` will interpret this as `-Dkey=true` allowing you to easily have
flags passed into, i.e. `jbang -DskipTests mytestrunner.java`. Now within your script `Boolean.getBoolean('skipTests') will return true.
====

==== Running script from standard input

jbang can run scripts directly from standard input using `-` or `/dev/stdin` as input.

i.e.

`echo 'System.out.println(""Hello World!"");' | jbang -`

[TIP]
====
If you use `--interactive` `jbang` will let `jshell` enter into interactive/REPL mode. You can write `/exit` to leave this mode.
====

[TIP]
====
If your own code needs to handle chained pipes well it is recommended to add the following code:

[source,java]
----
import sun.misc.Signal;

if (!""Windows"".equals(System.getProperty(""os.name""))) {
    Signal.handle(new Signal(""PIPE""), (final Signal sig) -> System.exit(1));
}
----

It will give a compiler warning as it is internal API; but for now it works.
====

=== Running ``.jar``'s

`jbang` will also run `.jar` files directly.

i.e. `jbang helloworld.jar` will run `helloworld.jar` if found on your local file system.

The `.jar` can be a local file or a http/https url.

You can also run a `.jar` file referenced by a Maven coordinate, i.e.:

  jbang info.picocli:picocli-codegen:4.5.0

This will fetch the dependency stated and put the transitive dependencies on the class-path.

If you need to specify a main class you can do so by using `--main` i.e.

  jbang --main picocli.codegen.aot.graalvm.ReflectionConfigGenerator info.picocli:picocli-codegen:4.5.0

[TIP]
====
A side effect of running GAV as a jar, the GAV could also be a `.java` or `.jsh` file and it would be launched as a script instead of a jar.
No one would want to do that (right?) but now you know.
====

== Init templates

To get started you can run `jbang init helloworld.java` and a simple java class with a static main is generated.

Using `jbang init --template=cli helloworld.java` you get a more complete Hello World CLI using https://picocli.info/[picocli] as dependency.

== Declare dependencies

If you want to write real scripts you will want to use some java libraries.
To specify dependencies you use gradle-style locators or links to Git sources. Below are examples for `log4j`.

=== Using `//DEPS`

[source,java]
----
///usr/bin/env jbang ""$0"" ""$@"" ; exit $?
// <.>
//DEPS log4j:log4j:1.2.17

import static java.lang.System.out;

import org.apache.log4j.Logger;
import org.apache.log4j.BasicConfigurator;

import java.util.Arrays;

class classpath_example {

	static final Logger logger = Logger.getLogger(classpath_example.class);

	public static void main(String[] args) {
		BasicConfigurator.configure(); // <.>
		logger.info(""Welcome to jbang"");

		Arrays.asList(args).forEach(arg -> logger.warn(""arg: "" + arg));
		logger.info(""Hello from Java!"");
	}
}
----
<.> `//DEPS` must be placed at the start of line and can be one or more space separated dependencies.
<.> Minimal logging setup - required by log4j.

Now when you run this, the first time with no existing dependencies installed you should get an output like this:

[source]
----
$ ./classpath_example.java
[jbang] Resolving dependencies...
[jbang]     Resolving log4j:log4j:1.2.17...Done
[jbang] Dependencies resolved
0 [main] INFO classpath_example  - Welcome to jbang
1 [main] INFO classpath_example  - Hello from Java!
----

=== Using links to Git sources

Instead of gradle-style locators you can also use URLs to projects on GitHub, GitLab or BitBucket.
Links to those projects will then be converted to artifacts references on https://jitpack.io/[jitpack].
You can use links to the root of the project, to the root of a tag/release and to specific commits.

If the project you link to has multiple modules and you want only a specific module you can specify the
name of the module by appending `#name-of-module` to the URL.

And finally if the link you provide is to a specific branch of the project then you need to append
`#:SNAPSHOT` to the URL. (If you have both a branch and a module name then use `#name-of-module:SNAPSHOT`)

.Examples of links and their resulting locator:
|===
|Link | Locator
|https://github.com/jbangdev/jbang
|com.github.jbangdev:jbang:HEAD-SNAPSHOT

|https://github.com/jbangdev/jbang/tree/v1.2.3
|com.github.jbangdev:jbang:v1.2.3

|https://github.com/jbangdev/jbang/tree/f1f34b031d2163e0cdc6f9a3725b59f47129c923[https://github.com/jbangdev/jbang/tree/f1f34b031...]
|com.github.jbangdev:jbang:f1f34b031d

|https://github.com/jbangdev/jbang#mymodule
|com.github.jbangdev.jbang:mymodule:HEAD-SNAPSHOT

|https://github.com/jbangdev/jbang/tree/mybranch#:SNAPSHOT
|com.github.jbangdev:jbang:mybranch-SNAPSHOT

|https://github.com/jbangdev/jbang/tree/mybranch#mymodule:SNAPSHOT
|com.github.jbangdev.jbang.mymodule:mybranch-SNAPSHOT
|===

=== Offline mode

In case you prefer `jbang` to just fail-fast when dependencies cannot be found locally you can run `jbang` in offline mode using
`jbang -o` or `jbang --offline`. In this mode `jbang` will simply fail if dependencies have not been cached already.

=== Repositories

By default `jbang` uses https://jcenter.bintray.com/[jcenter] as its repository as it is a superset of Maven Central
and supposedly should be faster.

And if you are using the above mentioned URL dependencies https://jitpack.io[jitpack] will be added automatically as well.

If that is not sufficient for you or need some custom repo you can use `//REPOS id=repourl` to
state which repository URL to use.

For ease of use there are also a few shorthands to use popular commonly available repositories.

|===
|Short name | Description
|`mavencentral`
|Maven Central

|`jcenter`
|`https://jcenter.bintray.com/`

|`google`
|`https://maven.google.com/`

|`jitpack`
|`https://jitpack.io/`
|===

Following example enables use of Maven Central and add a custom `acme` repository.

[source,java]
----
//REPOS mavenCentral,acme=https://maven.acme.local/maven
----

[WARNING]
====
If you add any `//REPOS` lines `jbang` will no longer consult `jcenter` thus you need to explicitly add it if needed.
====

[TIP]
====
For secure authentication `jbang` will honor `~/.m2/settings-security.xml` for configuring
username/passwords.
====


=== Using `@Grab`

There is also support for using Groovy lang style `@Grab` syntax.

[source,java]
----
///usr/bin/env jbang ""$0"" ""$@"" ; exit $?

import static java.lang.System.out;

import org.apache.log4j.Logger;
import org.apache.log4j.BasicConfigurator;

import java.util.Arrays;

import groovy.lang.Grab; // <.>
import groovy.lang.Grapes;
import groovy.lang.GrabResolver;

@GrabResolver(""mavenCentral"") // <.>
@GrabResolver(name='acme', root='https://maven.acme.local/maven')
@Grapes({ // <.>
		@Grab(group=""org.codehaus.groovy"", module=""groovy"", version=""2.5.8""), // <.>
		@Grab(module = ""log4j"", group = ""log4j"", version = ""1.2.17"")
})
class classpath_example {

	static final Logger logger = Logger.getLogger(classpath_example.class);

	public static void main(String[] args) {
		BasicConfigurator.configure();
		Arrays.asList(args).forEach(arg -> out.println(arg));
	}
}
----
<.> Import needed to make the compiler be okey with `@Grab` annotation.
<.> Using `GrabResolver` to enable `mavenCentral` and custom `acme` repository
<.> In Groovy you normally put `@Grab` on import statements. That is not allowed in Java thus when having multiple imports you need to put them in a `@Grapes` annotation first.
<.> `jbang` will grab any `@Grab` annotation and assume it is declaring dependencies.

=== System properties and Environment variables

In dependencies you can refer to environment and system properties to parameterize the dependencies.
It uses the format `${[env.]propertyname:<defaultvalue>}`.

Furthermore to align with properties commonly used to make dependency resolution portable
`jbang` exposes properties similar to what the `https://github.com/trustin/os-maven-plugin[os-maven-plugin]` does.
Plus for ease of use for javafx dependencies it also setups a property named `${os.detected.jfxname}`.

Examples:

[source,bash]
----
${env.USER} = 'max'
${os.name} = 'Mac OS X'
${non.existing.key:empty} = 'empty'
${os.detected.jfxname} = 'mac'
----

This can be put to use in `//DEPS` like so:

  //DEPS org.openjfx:javafx-graphics:11.0.2:${os.detected.jfxname}

Here we use the properties to avoid hardcoding your script to a specific operating system.

=== JavaFX

If `jbang` detects you have a `javafx-` dependency in your list of dependencies
it will if you `java` command supports Java modules automatically set the necessary
`--module-path` and `--add-modules`.

See `link:examples/jfx.java[]` and `link:examples/jfxtiles.java[]` for examples of this.

== Multiple source files

It is possible to use multiple source files just by having the files in the same source directory, it will
even work for a limited extent with packages.

For example the example below works by just calling `jbang Main.java`:

.Main.java
[source,java]
----
import model.Person;

public class Main {

    public static void main(String... args) {
        Person p = new Person(args[0]);
        System.out.println(""Hello "" + p.getName());
    }
}
----

.model/Person.java
[source,java]
----
package model;

public class Person {
    String name;
    public String getName() { return name; }
    public Person(String n) { this.name = n; }
}
----

There are some cases where the above does not work; i.e. if two packages refer to each other - i.e. `model.Person` referring to `util.Generator`
will fail. Also `jbang edit` does not know about multiple sources as it runs and must run before compilation occurs.

Thus version 0.46 there is now support for having that all work with multiple source files. The main script file defines all the
dependencies and you add more source files into the application using `//SOURCES <filename>`.
If included source has `//SOURCES` that will also get included recursively.

The listed file name(s) gets added to source list when compiling.

Currently there are not `*.java` style matching or support for these `.java` files to declare `//DEPS` or other jbang configuration.
That will currently only be honored by the main script/app. These will be loosened up in future based on feedback.

== Adding more resources

If you want to add a `META-INF/application.properties` or `META-INF/resource.index.html` or other files to the generated jar
you can use `//FILES` to add them.

The format is `//FILES <mountpoint>[=<sourcefile>]`.

Example:

  //FILES resource.properties
  //FILES META-INF/resources/index.html=index.html

Here `resource.properties` will be copied as is and `META-INF/resources/index.html` gets its content from `index.html`.

All locations are relative to the script location.

WARNING: Currently `jbang edit` and http(s) based script do not work with `//FILES`. Will be added later.

== Extension-less/non-java files for cli-plugins

You can use `jbang` to write plugins for cli's like `kubectl`, `git`, etc.
They expect their plugins to be named like `<cmd>-<plugin>`, i.e. `kubectl-myplugin`.

Furthermore some of them, particularly `kubectl` currently require the file to start with `#!` otherwise you get a `exec format error`.

There are two ways to have that work. The first recommended way is to use `jbang app install` which setups an intermediate script
to avoid the issue, i.e. `jbang app install --name kubectl-my-plugin myplugin.java`.

The second is to use a bit of auto-magic `jbang` has to help in case you only want a single file, no intermediate script. That
is described below.

=== Kebab casing of filename

`jbang` lets you name your file without a `.java` or `.jsh` extension, such
as `kubectl-my-plugin` or `myjavascript.sh`. `jbang` will in this case copy the file to a temporary
directory using kebab-case to map the name to a proper java class name.

For example, if you make a file called `kubectl-my-plugin` then `jbang` will assume the actual class name to launch
to be `KubectlMyPlugin`.

Note, similar is done when using `jbang edit`, here the symbolic link will be made so the IDE will treat it as
regular camel cased java class.

NOTE: If you do not follow this naming pattern you will get a compile error as `javac` expects both the public class and file names to be equal.

=== she-bang auto-stripped

For extension less scripts, you can put `#!' header at the beginning to let apps recognize
it is to be treated as a script. To avoid issues when compiling, `jbang` will remove
that line before compilation.

For now this is required for `kubectl` plugin but not `git`. https://github.com/kubernetes/kubectl/issues/822[Issue opened] on this limitation.

== Java version

`jbang` will by default use `JAVA_HOME` and if not available, check the `PATH` to locate the `java` executable to run the script with.

If your script requires a specific or minimal version of Java you can use `//JAVA <version>(+)`.

If Jbang finds a java executable using `JAVA_HOME` or `PATH` which satisfies the stated java version jbang will use it.
If no such version is found it will automatically download and install it.

Examples:

`//JAVA 11` will force use of Java 11. +
`//JAVA 13+` will require at least java 13. Java 13 or higher will be used.

In case no matching `java` is found `jbang` will fail.

You can always force running with specific version of `java` using `--java` command line option, i.e.
`jbang --java 8 hello.java`

== Managing JDKs

In the previous section it was mentioned that Jbang will automatically download and install JDKs when necessary.
You can use the `jdk` command to manage JDKs, for example you can run the following:

  jbang jdk list

which will list all the JDKs that are currently installed by Jbang.

It's easy to `install` additional JDKs by running:

  jbang jdk install 14

which will download and install JDK version 14 into Jbang's cache (`~/.jbang/cache/jdks` by default).
The list of versions that are available for installation can be found here: https://adoptopenjdk.net/releases.html

The first JDK that gets installed by Jbang will be set as the ""default"" JDK. This is from then on the JDK that will be
used by Jbang if no Java could be found on the system (meaning `javac` wasn't found on the `PATH` and no `JAVA_HOME` is set).
You can change the default JDK by running:

  jbang jdk default 12

Running it without an argument will return the version of the JDK that is currently set as the default.

NOTE: On Windows you might need elevated privileges to create symbolic links. If you don't have permissions then
running the above command  will result in an error. To use it https://stackoverflow.com/a/24353758[enable symbolic links]
for your user or run your shell/terminal as administrator to have this feature working.

When you `uninstall` a JDK by running:

  jbang jdk uninstall 12

and that JDK was set as the default, Jbang will set the next higher version JDK as the default. If no higher version is
available it will select the next lower version.

=== Using managed JDKs yourself

Given the fact that Jbang is able to easily download and install JDKs we thought that it might be a good option for
our users to be able to access those JDKs for their own use instead of having to install yet another version themselves.

To make that easy we added a couple of useful commands. The first can be used to set retrieve to location where the JDK
is installed:

  jbang jdk home

This will return the path to the ""default"" JDK (by default `~/.jbang/currentjdk)`, if you want to know the location of a
specific JDK you can pass the version as an argument: `jbang jdk home 14`. This command could be used by scripts to find
a JDK to use to run a Java program for example (eg: `JAVA_HOME=$(jbang jdk home)`.

For setting up your current command line environment there's something simpler. You can run:

  jbang jdk java-env

On Linux and Mac this will output something like:

[source]
----
export PATH=""/home/user/.jbang/currentjdk/bin:$PATH""
export JAVA_HOME=""/home/user/.jbang/currentjdk""
# Run this command to configure your shell:
# eval $(jbang jdk java-env)
----

And the output itself shows how to properly use it to configure your command line to use the JDK. In this case it's by
running:

  eval $(jbang jdk java-env)

To do this by default for all shells you start simply add the above line to your `~/.bashrc` file.

Unfortunately on Windows using CMD things are not as easy as is show by the output of `jbang jdk java-env` on that  platform:

[source]
----
set PATH=C:\\Users\\user\\.jbang\\currentjdk\\bin;%PATH%
set JAVA_HOME=C:\\Users\\user\\.jbang\\currentjdk
rem Copy & paste the above commands in your CMD window or add
rem them to your Environment Variables in the System Settings.
----

Instead of copying and pasting lines you could also redirect the output to a .bat file and execute that instead:

  > jbang jdk java-env > setenv.bat
  > setenv

== Editing

You can edit your script in an IDE/editor by using `jbang edit helloworld.java`. This will generate a project in a temporary location with symbolic links to your script
and output the generated folder name. The easiest way to use that is to use it in a call to your IDE:

[source, bash]
----
code `jbang edit helloworld.java`
----

If you add further dependencies to your file just re-run the edit command and the relevant files will be regenerated with the updated dependencies.

Above does require using a shell that allows for variable evaluation, if you are on i.e. Windows then you might prefer using:

[source, bash]
----
jbang edit --open=[editor] helloworld.java
----

The editor used will be what is specified as the argument to `--open` or value of `JBANG_EDITOR` environment variable.
The editor command must be available on the PATH to be executed from jbang. If you are executing `jbang edit --open=code helloworld.java` a `code` executable (visual studio code) must be on the PATH. Next to this you can pass the full path to the `open` parameter like in `--open=/usr/bin/code`.


NOTE: On Windows you might need elevated privileges to create symbolic links. If you don't have permissions then
the `edit` option will result in an error. To use it https://stackoverflow.com/a/24353758[enable symbolic links]
for your user or run your shell/terminal as administrator to have this feature working.

=== Install of default vscodium editor [EXPERIMENTAL]

If no editor available at all jbang will offer to install https://vscodium.com[VSCodium] (free/libre version of Visual Studio code) with
default java extensions enabled in so called https://code.visualstudio.com/docs/editor/portable[""portable mode""]. Portable mode means all 
the installed binaries and configuration does not affect rest of your system; everything is stored in `~/.jbang/editor`.

This automatic install and setup of editor is fully optional and if you have another IDE or editor already installed
use it using `jbang edit --open=<editor>` or set JBANG_EDITOR environment variable to have jbang use it by default.

=== Live Editing

You can also use `jbang edit --live` and `jbang` will launch your editor while watching
for file changes and regenerate the temporary project to pick up changes in dependencies.


=== IDE and Editor support

The `edit` feature been tested with the following IDE's:

:sicons: https://simpleicons.org/icons
.IDE's and Editors tested with `jbang`
[width=75%,frame=none,grid=none]
|===
|image:{sicons}/visualstudiocode.svg[50,50] https://code.visualstudio.com[Visual Studio Code]
|image:{sicons}/eclipseide.svg[50,50] https://www.eclipse.org/downloads/download.php[Eclipse]
|image:{sicons}/intellijidea.svg[50,50] https://www.jetbrains.com/idea/download[IntelliJ Idea]
|image:{sicons}/apachenetbeanside.svg[50,50] https://netbeans.apache.org/download/[Apache NetBeans]
|image:{sicons}/neovim.svg[50,50] https://github.com/neovim/neovim/wiki/Installing-Neovim[Neovim] w/ https://spacevim.org/use-vim-as-a-java-ide/[spacevim Java]
|image:{sicons}/gnuemacs.svg[50,50] https://www.gnu.org/software/emacs/[Emacs] w/ https://www.spacemacs.org[Spacemacs Java]
|===

The `edit` feature works with various IDE's - it generates a `build.gradle` to use with IDE's that understands Gradle directly.
For speed and consistency `jbang` also generates IDE specific settings.

Currently launchers and project files are generated for Eclipse and vscode. Intellij just reads `build.gradle` for now thus
to run/debug you will need to manually set it up.

Some editors like Code or IDEA are not per default executable / startable from the command line. Here are some helpfull documentations for supporting command line usage of different editors:

* https://www.jetbrains.com/help/idea/working-with-the-ide-features-from-command-line.html[CLI support for IDEA]
* https://code.visualstudio.com/docs/setup/mac[Terminal support for VS Code on macOS]

== Debugging

When running `.java` scripts with `jbang` you can pass the `--debug`-flag and the script will enable debug,
suspend the execution and wait until you connect a debugger to port 4004.

[source, bash]
----
jbang --debug helloworld.java
Listening for transport dt_socket at address: 4004
----

You can change the debug port and host by passing in a interface pattern and number to the debug argument, e.g., `--debug=*:4321`.

This will make it use port 4321 and make it listen on all ('*') network interfaces.

NOTE: Be sure to put a breakpoint in your IDE/debugger before you connect to make the debugger actually stop when you need it.

=== Debug jbang itself

Java itself will add `JAVA_TOOL_OPTIONS` which will apply to `jbang` too.

For finer and more explicit control the scripts, `jbang` will add `JBANG_JAVA_OPTIONS` to the call to `jbang` itself.
Thus if you want to enable debug or other details for `jbang` set that environment variable.

== Flight Recorder

Flight recorder is a feature of the Java VM that lets you gather diagnostic and profiling data about your script.

You can use `//JAVA_OPTIONS` to have full control over it; but for the easiest setup `jbang` lets you just run with `--jfr`, e.g.,

  jbang --jfr myapp.java

By default `--jfr` will start flight recorder and tell it to dump event recordings to `myapp.jfr` (i.e. using base name of the script as its filename).

Then you can use tools like `jvisualvm` or `jmc` to explore the data.

If you want to tweak the configuration you can pass flight recorder options, like `jbang --jfr=filename={baseName}.jfr,maxage=24h` where `{baseName}` will be replaced
by the filename and then added `maxage=24h` to flight recording options.

If you want further control use `//JAVAC_OPTS -XX:StartFlightRecording=<your options>` instead.

== `java` and `javac` Options

If you want to tweak memory settings or enable preview features you can setup the necessary options using
`//JAVA_OPTS` and `//COMPILER_OPTS` as in the following example using Java 14 experimental `record` feature:

[source, java]
----
///usr/bin/env jbang ""$0"" ""$@"" ; exit $?
//JAVAC_OPTIONS --enable-preview -source 14 <.>
//JAVA_OPTIONS --enable-preview // <.>

import static java.lang.System.*;

public class records {

    record Point(int x, int y) {}

    public static void main(String[] args) {
        var p = new Point(2,4);
        out.println(p);
    }
}
----

Since Java 9 https://docs.oracle.com/javase/9/tools/java.htm#GUID-3B1CE181-CD30-4178-9602-230B800D4FAE__USINGTHEJDK_JAVA_OPTIONSLAUNCHERENV-F3C0E3BA[JDK_JAVA_OPTIONS] and https://docs.oracle.com/javase/9/tools/javac.htm#GUID-AEEC9F07-CB49-4E96-8BC7-BCC2C7F725C9\\_\\_USINGJDK_JAVAC_OPTIONSENVIRONMENTVA-F3C76845[JDK_JAVAC_OPTIONS] are also picked up by the Java runtime and compiler automatically.

For Java 8 and if you want to set explicitly only for `jbang` you can also add flags by setting `JBANG_JAVA_OPTIONS` and `JBANG_JAVAC_OPTIONS` respectively.

=== (Experimental) Application Class Data Sharing

If your scripts uses a lot of classes Class Data Sharing might help on your startup. The following requires Java 13+.

Using `--cds` jbang will build the jar with Application Class Data Sharing enabled and when run have it load shared class data.

You can put `//CDS` in the java file to enable it by default, or simply use `--cds` to force it or `--no-cds` to turn it off no matter what the jbang script file contains.

== Aliases

To avoid remembering long paths and to enable easy launch of jbang scripts there is an `alias` command
to setup and manage aliases to actual scripts.

  jbang alias add hello https://github.com/jbangdev/jbang-examples/blob/master/examples/helloworld.java

will add an alias named `hello` pointing to that github url which then can be run using `jbang hello`.

  jbang alias list

will show you all the aliases that are defined locally.

=== Implicit Alias Catalogs

The aliases you create are stored locally (see <<Local Alias Catalogs>>), but Jbang can also use remote catalogs.
You can access those catalogs explicitly (see <<Catalogs>>) but it is much easier to use what we call ""implicit catalogs"", which
are aliases that have a special format and Jbang is smart enough to know where to find their definition.

Examples:

`jbang hello@jbangdev` will run the alias `hello` as defined in `jbang-catalog.json` found in https://github.com/jbangdev/jbang-catalog.

This allows anyone to provide a set of jbang scripts defined in their github, gitlab or bitbucket repositories.

The full format is `<alias>@<user/org>(/repository)(/branch)(~path)` allowing you to do things like:

.Implicit Catalog Examples:
|====
|Command | Description

|`jbang hello@acme`
|`hello` alias found in `acme/jbang-catalog/jbang-catalog.json` of the default branch searched on github, gitlab and bitbucket in that order.

|`jbang hello@acme/mycatalog`
|`hello` found in `acme/mycatalog/jbang-catalog.json` searched on github, gitlab and bitbucket in that order.

|`jbang hello@acme/mycatalog/dev`
|`hello` found in `acme/mycatalog/jbang-catalog.json` in the `dev` branch searched on github, gitlab and bitbucket in that order.

|`jbang hello@acme~experimental`
|`hello` found in `acme/jbang-catalog/experimental/jbang-catalog.json`

|====

=== Local Alias Catalogs

Jbang will also look in the current directory for a `jbang-catalog.json` file and if it exists it will look up any aliases
in there too. In fact it will look in several places in the following order:

 1. Current directory, `./jbang-catalog.json`
 2. In `.jbang/jbang-catalog.json`
 3. In the parent directory, `../jbang-catalog.json`
 4. In the parent's `.jbang` directory, ../.jbang/jbang-catalog.json`
 5. And repeating steps 3 and 4 recursively upwards to the root of the file system
 6. As the last step it will look in `$HOME/.jbang/jbang-catalog.json`

Jbang will use any aliases defined in those files, but on top of that it will also look at the aliases defined in any
catalogs mentioned in those files as well. Aliases defined in the file have preference over aliases found in any catalogs
defined in the same file.

When you create aliases using `jbang alias add`, or add catalogs using `jbang catalog add` the _same_ ordering will be used
to determine where to store the alias or catalog. Btw, this will only take into account _existing_ files!
So if no `jbang-catalog.json` file exists in the local directory it will _not_ be created for you, but Jbang will keep
looking until it finds a file to use (as a last option it will always be written to `$HOME/.jbang/jbang-catalog.json`).

This means that if you want to write the alias to `jbang-catalog.json` in your local folder you will either have to create
the file first (eg by running `touch jbang-catalog.json`) or by explicitly specifying the file location:

  jbang alias add -f jbang-catalog.json hello https://github.com/jbangdev/jbang-examples/blob/master/examples/helloworld.java

Btw, the flag `--show-origin` is very useful when listing aliases to find out where exactly an alias is defined:

  jbang alias list --show-origin

== Catalogs

Catalogs are lists of Aliases as defined in the previous section, but while the `alias` command is used to manage aliases
within a catalog, the `catalog` command is for managing references to catalogs. This is mostly useful when dealing with
remote catalogs. You can for example add a catalog like this:

  jbang catalog add demo https://github.com/jbangdev/jbang-catalog/blob/master/jbang-catalog.json

or simply by using the same ""implicit"" catalog system described in <<Implicit Alias Catalogs>>:

  jbang catalog add demo jbangdev

The aliases in that catalog are now available by adding `@demo` to their names. For example:

  $ jbang alias list demo
  env@demo = Dump table of Environment Variables
  gavsearch@demo = Search search.maven.org for maven artifacts.
  hello@demo = Script that says hello back for each argument
  properties@demo = Dump table of System properties
  $ jbang run hello@demo World!
  [jbang] Building jar...
  Hello World!

In fact it's possible to run the alias just by using `jbang run hello`, the `@demo` part is only necessary when trying to
disambiguate between aliases with the same name from different catalogs.

You can list the available catalogs by running:

  jbang catalog list

NB: The output will not only show the catalogs you defined yourself but also the ones that get added implicitly when
running aliases as described in the section <<Implicit Alias Catalogs>>.

== Java Agents

You can activate a javaagent using `--javaagent=<agent>[=<options>]` where agent can be a already packaged agent jar from file, http url or Maven Coordinate.

It can also be a jbang script itself where you have put `//JAVAAGENT` to activate agent packaging.

You can create a basic agent using `jbang init -t agent myagent.java` to get started.

== Bash/Zsh auto-completion

If you are using bash or zsh in your terminal you can get auto-completion by running the following:

[source, bash]
----
source <(jbang completion)
----

== Caching

In previous versions of `jbang`, Java 10+ direct launch of `.java` was used, but since v0.6 `jbang` works with Java 8 and thus it
needs to do a separate compile step. Besides now working with Java 8 this also allows to cache the compiled script and thus
launch faster on consecutive runs.

The caching goes to `~/.jbang/cache` by default, you can run `jbang cache clear` to remove all cache data from this folder.

== Install apps [EXPERIMENTAL]

Since version 0.56 jbang comes with ability to setup jbang to put scripts/apps into your `PATH`
using `jbang app`. This is useful to easily make scripts available from anywhere on any Operating System;

To get started run `jbang app setup` this will on Windows modify your system wide `PATH` to include a folder managed by jbang.
On bash/zsh based shells it will setup `PATH` in your `bashrc` or `zshrc` file(s.)

Once setup, you can use `jbang app install <scriptRef>` to install that script into the jbang managed path.

i.e. `jbang app install myscript.java` will add `myscript` as a command you can run.

You can also use aliases, like `jbang app install gavsearch@jbangdev`.

If you have two script/apps with same name or just want to use a specific name you can use `--name` to
control the generated command: `jbang app install --name mvnsearch gavsearch@jbangdev`

If you want to see which are already installed use `jbang list` and you can use `jbang uinstall <name>` to uninstall
the script/app.

== Build Integration [EXPERIMENTAL]

While `jbang` prepares and builds the underlying jar used for launch there is since v0.40 (for now) experimental API allowing
user included dependencies to influence the generated jar and possible native image.

An example use case enabled by this is to have full Quarkus integration, `jbang quarkuscode.java` will have Quarkus participate to perform its build time optimizations rather than doing it at runtime every time.

It works as following:

Before the jar is created `jbang` will scan the classpath for `META-INF/jbang-integration.list`.
Any classes listed in this file will be loaded and jbang will expect and call the following method on these classes:

[source,java]
----
/**
*
* @param param build dir directory which will be made into a jar when build is done
* @param pomFile location of pom.xml representing the projects dependencies
* @param dependencies list of GAV to Path of artifact/classpath dependencies
* @param nativeImage true if --native been requested
* @return Map<String, Object> map of returns; special keys are ""native-image"" which is a and ""files"" to
*          return native-image to be run and list of files to get written to the output directory.
*
*/
Map<String, Object> postBuild(Path builddir, Path pomFile, List<Map.Entry<String, Path>> dependencies,
            boolean nativeImage)
----

Still very experimental and bound to change. Example of its use can be found in https://github.com/quarkusio/quarkus/pull/11542[Quarkus].

== Cheatsheet

You can get examples on running/using `jbang` using https://github.com/cheat/cheat[cheat] command with `cheat jbang`.

== FAQ

[qanda]
Why the name j'bang?::
  I was reading up on how to use the new shebang (#!) feature support in Java 10 and came up with the idea of port `kscript` to Java and needed a name.
From there came j'bang which is a ""bad"" spelling of how shebang is pronounced in French.

Why use gradle resource locators rather than ?::
  kscript used it and it's nice as it is a one-liner and easily parsable.

How does this compare to ?::
After doing `jbang` I've learned about similar projects and thought it would be nice with some comparison;
+
https://github.com/scijava/jgo[jgo]: an alternative way to launch jars using maven coordinates. Implemented in python, depends on Java and Maven to be available. Not really for scripting but a novel way to launch java apps already packaged as a maven dependency.
+

Why would I use Java to write scripts ? Java sucks for that... Use groovy, kotlin, scala, etc. instead!::
  Well, does it really suck ? With Java 8 streams, static imports and greatly improved standard java libraries it is very close to what kscript and grape look like.
With the following advantages:
+
* works with plain Java without installing additional compiler/build tools
* all IDE's support editing .java files very well, content assist, etc.
* great debugging
+
And to be honest I built `jbang` just to see if I could and get my Java skills refreshed for the newer features in the language.
Use it at your own risk :)

Why not use normal shebang(`#!`) in the header ?::
  You can use normal shebang (`#!/usr/bin/env jbang`) and Java 10+ will actually work with it from the command line. Not recommended though as
many tools and especially IDE's will start complaining about syntax errors as they don't ignore the first line in this case.
+
By using the `//` form it is treated as both a bash/shell file AND a valid java file and thus works everywhere a java file will work.
+
It's worth noting that Go https://golangcookbook.com/chapters/running/shebang/[uses a similar approach] which is also where I learned it from.

HELP! My code formatter keeps breaking my `//` directives!::
  When using automated code formatting tools, some care and configuration must be made to prevent the tooling from rewriting and preventing `jbang` from working as expected.
+
Use the following configuration blocks to correctly configure your tool:
+
.Configuration Tool Settings:
|====
| Formatting Tool | Configuration

| Clang Format
a|
[source]
----
CommentPragmas:  '^[^ ]'
----
|====

== Thanks

`jbang` was heavily inspired by how `https://github.com/holgerbrandl/kscript[kscript]` by Holger Brand works.
",12496,False,2276.6752367999516,median
"

// DO NOT EDIT !
// This file is generated using the MantaFlow preprocessor (prep generate).

/******************************************************************************
 *
 * MantaFlow fluid solver framework
 * Copyright 2011 Tobias Pfaff, Nils Thuerey
 *
 * This program is free software, distributed under the terms of the
 * GNU General Public License (GPL)
 * http://www.gnu.org/licenses
 *
 * Set boundary conditions, gravity
 *
 ******************************************************************************/

#include ""vectorbase.h""
#include ""grid.h""
#include ""commonkernels.h""
#include ""particle.h""

using namespace std;

namespace Manta {

//! add constant force between fl/fl and fl/em cells
struct KnApplyForceField : public KernelBase {
  KnApplyForceField(const FlagGrid &flags,
                    MACGrid &vel,
                    const Grid<Vec3> &force,
                    const Grid<Real> *include,
                    bool additive,
                    bool isMAC)
      : KernelBase(&flags, 1),
        flags(flags),
        vel(vel),
        force(force),
        include(include),
        additive(additive),
        isMAC(isMAC)
  {
    runMessage();
    run();
  }
  inline void op(int i,
                 int j,
                 int k,
                 const FlagGrid &flags,
                 MACGrid &vel,
                 const Grid<Vec3> &force,
                 const Grid<Real> *include,
                 bool additive,
                 bool isMAC) const
  {
    bool curFluid = flags.isFluid(i, j, k);
    bool curEmpty = flags.isEmpty(i, j, k);
    if (!curFluid && !curEmpty)
      return;
    if (include && ((*include)(i, j, k) > 0.))
      return;

    Real forceX = (isMAC) ? force(i, j, k).x : 0.5 * (force(i - 1, j, k).x + force(i, j, k).x);
    Real forceY = (isMAC) ? force(i, j, k).y : 0.5 * (force(i, j - 1, k).y + force(i, j, k).y);

    Real forceZ = 0.;
    if (vel.is3D())
      forceZ = (isMAC) ? force(i, j, k).z : 0.5 * (force(i, j, k - 1).z + force(i, j, k).z);

    if (flags.isFluid(i - 1, j, k) || (curFluid && flags.isEmpty(i - 1, j, k)))
      vel(i, j, k).x = (additive) ? vel(i, j, k).x + forceX : forceX;
    if (flags.isFluid(i, j - 1, k) || (curFluid && flags.isEmpty(i, j - 1, k)))
      vel(i, j, k).y = (additive) ? vel(i, j, k).y + forceY : forceY;
    if (vel.is3D() && (flags.isFluid(i, j, k - 1) || (curFluid && flags.isEmpty(i, j, k - 1))))
      vel(i, j, k).z = (additive) ? vel(i, j, k).z + forceZ : forceZ;
  }
  inline const FlagGrid &getArg0()
  {
    return flags;
  }
  typedef FlagGrid type0;
  inline MACGrid &getArg1()
  {
    return vel;
  }
  typedef MACGrid type1;
  inline const Grid<Vec3> &getArg2()
  {
    return force;
  }
  typedef Grid<Vec3> type2;
  inline const Grid<Real> *getArg3()
  {
    return include;
  }
  typedef Grid<Real> type3;
  inline bool &getArg4()
  {
    return additive;
  }
  typedef bool type4;
  inline bool &getArg5()
  {
    return isMAC;
  }
  typedef bool type5;
  void runMessage()
  {
    debMsg(""Executing kernel KnApplyForceField "", 3);
    debMsg(""Kernel range""
               << "" x "" << maxX << "" y "" << maxY << "" z "" << minZ << "" - "" << maxZ << "" "",
           4);
  };
  void operator()(const tbb::blocked_range<IndexInt> &__r) const
  {
    const int _maxX = maxX;
    const int _maxY = maxY;
    if (maxZ > 1) {
      for (int k = __r.begin(); k != (int)__r.end(); k++)
        for (int j = 1; j < _maxY; j++)
          for (int i = 1; i < _maxX; i++)
            op(i, j, k, flags, vel, force, include, additive, isMAC);
    }
    else {
      const int k = 0;
      for (int j = __r.begin(); j != (int)__r.end(); j++)
        for (int i = 1; i < _maxX; i++)
          op(i, j, k, flags, vel, force, include, additive, isMAC);
    }
  }
  void run()
  {
    if (maxZ > 1)
      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
    else
      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
  }
  const FlagGrid &flags;
  MACGrid &vel;
  const Grid<Vec3> &force;
  const Grid<Real> *include;
  bool additive;
  bool isMAC;
};

//! add constant force between fl/fl and fl/em cells
struct KnApplyForce : public KernelBase {
  KnApplyForce(
      const FlagGrid &flags, MACGrid &vel, Vec3 force, const Grid<Real> *exclude, bool additive)
      : KernelBase(&flags, 1),
        flags(flags),
        vel(vel),
        force(force),
        exclude(exclude),
        additive(additive)
  {
    runMessage();
    run();
  }
  inline void op(int i,
                 int j,
                 int k,
                 const FlagGrid &flags,
                 MACGrid &vel,
                 Vec3 force,
                 const Grid<Real> *exclude,
                 bool additive) const
  {
    bool curFluid = flags.isFluid(i, j, k);
    bool curEmpty = flags.isEmpty(i, j, k);
    if (!curFluid && !curEmpty)
      return;
    if (exclude && ((*exclude)(i, j, k) < 0.))
      return;

    if (flags.isFluid(i - 1, j, k) || (curFluid && flags.isEmpty(i - 1, j, k)))
      vel(i, j, k).x = (additive) ? vel(i, j, k).x + force.x : force.x;
    if (flags.isFluid(i, j - 1, k) || (curFluid && flags.isEmpty(i, j - 1, k)))
      vel(i, j, k).y = (additive) ? vel(i, j, k).y + force.y : force.y;
    if (vel.is3D() && (flags.isFluid(i, j, k - 1) || (curFluid && flags.isEmpty(i, j, k - 1))))
      vel(i, j, k).z = (additive) ? vel(i, j, k).z + force.z : force.z;
  }
  inline const FlagGrid &getArg0()
  {
    return flags;
  }
  typedef FlagGrid type0;
  inline MACGrid &getArg1()
  {
    return vel;
  }
  typedef MACGrid type1;
  inline Vec3 &getArg2()
  {
    return force;
  }
  typedef Vec3 type2;
  inline const Grid<Real> *getArg3()
  {
    return exclude;
  }
  typedef Grid<Real> type3;
  inline bool &getArg4()
  {
    return additive;
  }
  typedef bool type4;
  void runMessage()
  {
    debMsg(""Executing kernel KnApplyForce "", 3);
    debMsg(""Kernel range""
               << "" x "" << maxX << "" y "" << maxY << "" z "" << minZ << "" - "" << maxZ << "" "",
           4);
  };
  void operator()(const tbb::blocked_range<IndexInt> &__r) const
  {
    const int _maxX = maxX;
    const int _maxY = maxY;
    if (maxZ > 1) {
      for (int k = __r.begin(); k != (int)__r.end(); k++)
        for (int j = 1; j < _maxY; j++)
          for (int i = 1; i < _maxX; i++)
            op(i, j, k, flags, vel, force, exclude, additive);
    }
    else {
      const int k = 0;
      for (int j = __r.begin(); j != (int)__r.end(); j++)
        for (int i = 1; i < _maxX; i++)
          op(i, j, k, flags, vel, force, exclude, additive);
    }
  }
  void run()
  {
    if (maxZ > 1)
      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
    else
      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
  }
  const FlagGrid &flags;
  MACGrid &vel;
  Vec3 force;
  const Grid<Real> *exclude;
  bool additive;
};

//! add gravity forces to all fluid cells, optionally  adapts to different grid sizes automatically
void addGravity(const FlagGrid &flags,
                MACGrid &vel,
                Vec3 gravity,
                const Grid<Real> *exclude = NULL,
                bool scale = true)
{
  float gridScale = (scale) ? flags.getDx() : 1;
  Vec3 f = gravity * flags.getParent()->getDt() / gridScale;
  KnApplyForce(flags, vel, f, exclude, true);
}
static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
{
  try {
    PbArgs _args(_linargs, _kwds);
    FluidSolver *parent = _args.obtainParent();
    bool noTiming = _args.getOpt<bool>(""notiming"", -1, 0);
    pbPreparePlugin(parent, ""addGravity"", !noTiming);
    PyObject *_retval = 0;
    {
      ArgLocker _lock;
      const FlagGrid &flags = *_args.getPtr<FlagGrid>(""flags"", 0, &_lock);
      MACGrid &vel = *_args.getPtr<MACGrid>(""vel"", 1, &_lock);
      Vec3 gravity = _args.get<Vec3>(""gravity"", 2, &_lock);
      const Grid<Real> *exclude = _args.getPtrOpt<Grid<Real>>(""exclude"", 3, NULL, &_lock);
      bool scale = _args.getOpt<bool>(""scale"", 4, true, &_lock);
      _retval = getPyNone();
      addGravity(flags, vel, gravity, exclude, scale);
      _args.check();
    }
    pbFinalizePlugin(parent, ""addGravity"", !noTiming);
    return _retval;
  }
  catch (std::exception &e) {
    pbSetError(""addGravity"", e.what());
    return 0;
  }
}
static const Pb::Register _RP_addGravity("""", ""addGravity"", _W_0);
extern ""C"" {
void PbRegister_addGravity()
{
  KEEP_UNUSED(_RP_addGravity);
}
}

//! Deprecated: use addGravity(scale=false) instead
void addGravityNoScale(const FlagGrid &flags,
                       MACGrid &vel,
                       const Vec3 &gravity,
                       const Grid<Real> *exclude = NULL)
{
  addGravity(flags, vel, gravity, exclude, false);
}
static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
{
  try {
    PbArgs _args(_linargs, _kwds);
    FluidSolver *parent = _args.obtainParent();
    bool noTiming = _args.getOpt<bool>(""notiming"", -1, 0);
    pbPreparePlugin(parent, ""addGravityNoScale"", !noTiming);
    PyObject *_retval = 0;
    {
      ArgLocker _lock;
      const FlagGrid &flags = *_args.getPtr<FlagGrid>(""flags"", 0, &_lock);
      MACGrid &vel = *_args.getPtr<MACGrid>(""vel"", 1, &_lock);
      const Vec3 &gravity = _args.get<Vec3>(""gravity"", 2, &_lock);
      const Grid<Real> *exclude = _args.getPtrOpt<Grid<Real>>(""exclude"", 3, NULL, &_lock);
      _retval = getPyNone();
      addGravityNoScale(flags, vel, gravity, exclude);
      _args.check();
    }
    pbFinalizePlugin(parent, ""addGravityNoScale"", !noTiming);
    return _retval;
  }
  catch (std::exception &e) {
    pbSetError(""addGravityNoScale"", e.what());
    return 0;
  }
}
static const Pb::Register _RP_addGravityNoScale("""", ""addGravityNoScale"", _W_1);
extern ""C"" {
void PbRegister_addGravityNoScale()
{
  KEEP_UNUSED(_RP_addGravityNoScale);
}
}

//! kernel to add Buoyancy force
struct KnAddBuoyancy : public KernelBase {
  KnAddBuoyancy(const FlagGrid &flags, const Grid<Real> &factor, MACGrid &vel, Vec3 strength)
      : KernelBase(&flags, 1), flags(flags), factor(factor), vel(vel), strength(strength)
  {
    runMessage();
    run();
  }
  inline void op(int i,
                 int j,
                 int k,
                 const FlagGrid &flags,
                 const Grid<Real> &factor,
                 MACGrid &vel,
                 Vec3 strength) const
  {
    if (!flags.isFluid(i, j, k))
      return;
    if (flags.isFluid(i - 1, j, k))
      vel(i, j, k).x += (0.5 * strength.x) * (factor(i, j, k) + factor(i - 1, j, k));
    if (flags.isFluid(i, j - 1, k))
      vel(i, j, k).y += (0.5 * strength.y) * (factor(i, j, k) + factor(i, j - 1, k));
    if (vel.is3D() && flags.isFluid(i, j, k - 1))
      vel(i, j, k).z += (0.5 * strength.z) * (factor(i, j, k) + factor(i, j, k - 1));
  }
  inline const FlagGrid &getArg0()
  {
    return flags;
  }
  typedef FlagGrid type0;
  inline const Grid<Real> &getArg1()
  {
    return factor;
  }
  typedef Grid<Real> type1;
  inline MACGrid &getArg2()
  {
    return vel;
  }
  typedef MACGrid type2;
  inline Vec3 &getArg3()
  {
    return strength;
  }
  typedef Vec3 type3;
  void runMessage()
  {
    debMsg(""Executing kernel KnAddBuoyancy "", 3);
    debMsg(""Kernel range""
               << "" x "" << maxX << "" y "" << maxY << "" z "" << minZ << "" - "" << maxZ << "" "",
           4);
  };
  void operator()(const tbb::blocked_range<IndexInt> &__r) const
  {
    const int _maxX = maxX;
    const int _maxY = maxY;
    if (maxZ > 1) {
      for (int k = __r.begin(); k != (int)__r.end(); k++)
        for (int j = 1; j < _maxY; j++)
          for (int i = 1; i < _maxX; i++)
            op(i, j, k, flags, factor, vel, strength);
    }
    else {
      const int k = 0;
      for (int j = __r.begin(); j != (int)__r.end(); j++)
        for (int i = 1; i < _maxX; i++)
          op(i, j, k, flags, factor, vel, strength);
    }
  }
  void run()
  {
    if (maxZ > 1)
      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
    else
      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
  }
  const FlagGrid &flags;
  const Grid<Real> &factor;
  MACGrid &vel;
  Vec3 strength;
};

//! add Buoyancy force based on factor (e.g. smoke density), optionally adapts to different grid
//! sizes automatically
void addBuoyancy(const FlagGrid &flags,
                 const Grid<Real> &density,
                 MACGrid &vel,
                 Vec3 gravity,
                 Real coefficient = 1.,
                 bool scale = true)
{
  float gridScale = (scale) ? flags.getDx() : 1;
  Vec3 f = -gravity * flags.getParent()->getDt() / gridScale * coefficient;
  KnAddBuoyancy(flags, density, vel, f);
}
static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
{
  try {
    PbArgs _args(_linargs, _kwds);
    FluidSolver *parent = _args.obtainParent();
    bool noTiming = _args.getOpt<bool>(""notiming"", -1, 0);
    pbPreparePlugin(parent, ""addBuoyancy"", !noTiming);
    PyObject *_retval = 0;
    {
      ArgLocker _lock;
      const FlagGrid &flags = *_args.getPtr<FlagGrid>(""flags"", 0, &_lock);
      const Grid<Real> &density = *_args.getPtr<Grid<Real>>(""density"", 1, &_lock);
      MACGrid &vel = *_args.getPtr<MACGrid>(""vel"", 2, &_lock);
      Vec3 gravity = _args.get<Vec3>(""gravity"", 3, &_lock);
      Real coefficient = _args.getOpt<Real>(""coefficient"", 4, 1., &_lock);
      bool scale = _args.getOpt<bool>(""scale"", 5, true, &_lock);
      _retval = getPyNone();
      addBuoyancy(flags, density, vel, gravity, coefficient, scale);
      _args.check();
    }
    pbFinalizePlugin(parent, ""addBuoyancy"", !noTiming);
    return _retval;
  }
  catch (std::exception &e) {
    pbSetError(""addBuoyancy"", e.what());
    return 0;
  }
}
static const Pb::Register _RP_addBuoyancy("""", ""addBuoyancy"", _W_2);
extern ""C"" {
void PbRegister_addBuoyancy()
{
  KEEP_UNUSED(_RP_addBuoyancy);
}
}

// inflow / outflow boundaries

//! helper to parse openbounds string [xXyYzZ] , convert to vec3
inline void convertDescToVec(const string &desc, Vector3D<bool> &lo, Vector3D<bool> &up)
{
  for (size_t i = 0; i < desc.size(); i++) {
    if (desc[i] == 'x')
      lo.x = true;
    else if (desc[i] == 'y')
      lo.y = true;
    else if (desc[i] == 'z')
      lo.z = true;
    else if (desc[i] == 'X')
      up.x = true;
    else if (desc[i] == 'Y')
      up.y = true;
    else if (desc[i] == 'Z')
      up.z = true;
    else
      errMsg(""invalid character in boundary description string. Only [xyzXYZ] allowed."");
  }
}

//! add empty and outflow flag to cells of open boundaries
void setOpenBound(FlagGrid &flags,
                  int bWidth,
                  string openBound = """",
                  int type = FlagGrid::TypeOutflow | FlagGrid::TypeEmpty)
{
  if (openBound == """")
    return;
  Vector3D<bool> lo, up;
  convertDescToVec(openBound, lo, up);

  FOR_IJK(flags)
  {
    bool loX = lo.x && i <= bWidth;  // a cell which belongs to the lower x open bound
    bool loY = lo.y && j <= bWidth;
    bool upX = up.x && i >= flags.getSizeX() - bWidth -
                                1;  // a cell which belongs to the upper x open bound
    bool upY = up.y && j >= flags.getSizeY() - bWidth - 1;
    bool innerI = i > bWidth &&
                  i < flags.getSizeX() - bWidth -
                          1;  // a cell which does not belong to the lower or upper x bound
    bool innerJ = j > bWidth && j < flags.getSizeY() - bWidth - 1;

    // when setting boundaries to open: don't set shared part of wall to empty if neighboring wall
    // is not open
    if ((!flags.is3D()) && (loX || upX || loY || upY)) {
      if ((loX || upX || innerI) && (loY || upY || innerJ) && flags.isObstacle(i, j, k))
        flags(i, j, k) = type;
    }
    else {
      bool loZ = lo.z && k <= bWidth;  // a cell which belongs to the lower z open bound
      bool upZ = up.z && k >= flags.getSizeZ() - bWidth -
                                  1;  // a cell which belongs to the upper z open bound
      bool innerK = k > bWidth &&
                    k < flags.getSizeZ() - bWidth -
                            1;  // a cell which does not belong to the lower or upper z bound
      if (loX || upX || loY || upY || loZ || upZ) {
        if ((loX || upX || innerI) && (loY || upY || innerJ) && (loZ || upZ || innerK) &&
            flags.isObstacle(i, j, k))
          flags(i, j, k) = type;
      }
    }
  }
}
static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
{
  try {
    PbArgs _args(_linargs, _kwds);
    FluidSolver *parent = _args.obtainParent();
    bool noTiming = _args.getOpt<bool>(""notiming"", -1, 0);
    pbPreparePlugin(parent, ""setOpenBound"", !noTiming);
    PyObject *_retval = 0;
    {
      ArgLocker _lock;
      FlagGrid &flags = *_args.getPtr<FlagGrid>(""flags"", 0, &_lock);
      int bWidth = _args.get<int>(""bWidth"", 1, &_lock);
      string openBound = _args.getOpt<string>(""openBound"", 2, """", &_lock);
      int type = _args.getOpt<int>(""type"", 3, FlagGrid::TypeOutflow | FlagGrid::TypeEmpty, &_lock);
      _retval = getPyNone();
      setOpenBound(flags, bWidth, openBound, type);
      _args.check();
    }
    pbFinalizePlugin(parent, ""setOpenBound"", !noTiming);
    return _retval;
  }
  catch (std::exception &e) {
    pbSetError(""setOpenBound"", e.what());
    return 0;
  }
}
static const Pb::Register _RP_setOpenBound("""", ""setOpenBound"", _W_3);
extern ""C"" {
void PbRegister_setOpenBound()
{
  KEEP_UNUSED(_RP_setOpenBound);
}
}

//! delete fluid and ensure empty flag in outflow cells, delete particles and density and set phi
//! to 0.5
void resetOutflow(FlagGrid &flags,
                  Grid<Real> *phi = 0,
                  BasicParticleSystem *parts = 0,
                  Grid<Real> *real = 0,
                  Grid<int> *index = 0,
                  ParticleIndexSystem *indexSys = 0)
{
  // check if phi and parts -> pindex and gpi already created -> access particles from cell index,
  // avoid extra looping over particles
  if (parts && (!index || !indexSys)) {
    if (phi)
      debMsg(
          ""resetOpenBound for phi and particles, but missing index and indexSys for enhanced ""
          ""particle access!"",
          1);
    for (int idx = 0; idx < (int)parts->size(); idx++)
      if (parts->isActive(idx) && flags.isInBounds(parts->getPos(idx)) &&
          flags.isOutflow(parts->getPos(idx)))
        parts->kill(idx);
  }
  FOR_IJK(flags)
  {
    if (flags.isOutflow(i, j, k)) {
      flags(i, j, k) = (flags(i, j, k) | FlagGrid::TypeEmpty) &
                       ~FlagGrid::TypeFluid;  // make sure there is not fluid flag set and to reset
                                              // the empty flag
      // the particles in a cell i,j,k are particles[index(i,j,k)] to particles[index(i+1,j,k)-1]
      if (parts && index && indexSys) {
        int isysIdxS = index->index(i, j, k);
        int pStart = (*index)(isysIdxS), pEnd = 0;
        if (flags.isInBounds(isysIdxS + 1))
          pEnd = (*index)(isysIdxS + 1);
        else
          pEnd = indexSys->size();
        // now loop over particles in cell
        for (int p = pStart; p < pEnd; ++p) {
          int psrc = (*indexSys)[p].sourceIndex;
          if (parts->isActive(psrc) && flags.isInBounds(parts->getPos(psrc)))
            parts->kill(psrc);
        }
      }
      if (phi)
        (*phi)(i, j, k) = 0.5;
      if (real)
        (*real)(i, j, k) = 0;
    }
  }
  if (parts)
    parts->doCompress();
}
static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
{
  try {
    PbArgs _args(_linargs, _kwds);
    FluidSolver *parent = _args.obtainParent();
    bool noTiming = _args.getOpt<bool>(""notiming"", -1, 0);
    pbPreparePlugin(parent, ""resetOutflow"", !noTiming);
    PyObject *_retval = 0;
    {
      ArgLocker _lock;
      FlagGrid &flags = *_args.getPtr<FlagGrid>(""flags"", 0, &_lock);
      Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>(""phi"", 1, 0, &_lock);
      BasicParticleSystem *parts = _args.getPtrOpt<BasicParticleSystem>(""parts"", 2, 0, &_lock);
      Grid<Real> *real = _args.getPtrOpt<Grid<Real>>(""real"", 3, 0, &_lock);
      Grid<int> *index = _args.getPtrOpt<Grid<int>>(""index"", 4, 0, &_lock);
      ParticleIndexSystem *indexSys = _args.getPtrOpt<ParticleIndexSystem>(
          ""indexSys"", 5, 0, &_lock);
      _retval = getPyNone();
      resetOutflow(flags, phi, parts, real, index, indexSys);
      _args.check();
    }
    pbFinalizePlugin(parent, ""resetOutflow"", !noTiming);
    return _retval;
  }
  catch (std::exception &e) {
    pbSetError(""resetOutflow"", e.what());
    return 0;
  }
}
static const Pb::Register _RP_resetOutflow("""", ""resetOutflow"", _W_4);
extern ""C"" {
void PbRegister_resetOutflow()
{
  KEEP_UNUSED(_RP_resetOutflow);
}
}

//! enforce a constant inflow/outflow at the grid boundaries
struct KnSetInflow : public KernelBase {
  KnSetInflow(MACGrid &vel, int dim, int p0, const Vec3 &val)
      : KernelBase(&vel, 0), vel(vel), dim(dim), p0(p0), val(val)
  {
    runMessage();
    run();
  }
  inline void op(int i, int j, int k, MACGrid &vel, int dim, int p0, const Vec3 &val) const
  {
    Vec3i p(i, j, k);
    if (p[dim] == p0 || p[dim] == p0 + 1)
      vel(i, j, k) = val;
  }
  inline MACGrid &getArg0()
  {
    return vel;
  }
  typedef MACGrid type0;
  inline int &getArg1()
  {
    return dim;
  }
  typedef int type1;
  inline int &getArg2()
  {
    return p0;
  }
  typedef int type2;
  inline const Vec3 &getArg3()
  {
    return val;
  }
  typedef Vec3 type3;
  void runMessage()
  {
    debMsg(""Executing kernel KnSetInflow "", 3);
    debMsg(""Kernel range""
               << "" x "" << maxX << "" y "" << maxY << "" z "" << minZ << "" - "" << maxZ << "" "",
           4);
  };
  void operator()(const tbb::blocked_range<IndexInt> &__r) const
  {
    const int _maxX = maxX;
    const int _maxY = maxY;
    if (maxZ > 1) {
      for (int k = __r.begin(); k != (int)__r.end(); k++)
        for (int j = 0; j < _maxY; j++)
          for (int i = 0; i < _maxX; i++)
            op(i, j, k, vel, dim, p0, val);
    }
    else {
      const int k = 0;
      for (int j = __r.begin(); j != (int)__r.end(); j++)
        for (int i = 0; i < _maxX; i++)
          op(i, j, k, vel, dim, p0, val);
    }
  }
  void run()
  {
    if (maxZ > 1)
      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
    else
      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
  }
  MACGrid &vel;
  int dim;
  int p0;
  const Vec3 &val;
};

//! enforce a constant inflow/outflow at the grid boundaries
void setInflowBcs(MACGrid &vel, string dir, Vec3 value)
{
  for (size_t i = 0; i < dir.size(); i++) {
    if (dir[i] >= 'x' && dir[i] <= 'z') {
      int dim = dir[i] - 'x';
      KnSetInflow(vel, dim, 0, value);
    }
    else if (dir[i] >= 'X' && dir[i] <= 'Z') {
      int dim = dir[i] - 'X';
      KnSetInflow(vel, dim, vel.getSize()[dim] - 1, value);
    }
    else
      errMsg(""invalid character in direction string. Only [xyzXYZ] allowed."");
  }
}
static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
{
  try {
    PbArgs _args(_linargs, _kwds);
    FluidSolver *parent = _args.obtainParent();
    bool noTiming = _args.getOpt<bool>(""notiming"", -1, 0);
    pbPreparePlugin(parent, ""setInflowBcs"", !noTiming);
    PyObject *_retval = 0;
    {
      ArgLocker _lock;
      MACGrid &vel = *_args.getPtr<MACGrid>(""vel"", 0, &_lock);
      string dir = _args.get<string>(""dir"", 1, &_lock);
      Vec3 value = _args.get<Vec3>(""value"", 2, &_lock);
      _retval = getPyNone();
      setInflowBcs(vel, dir, value);
      _args.check();
    }
    pbFinalizePlugin(parent, ""setInflowBcs"", !noTiming);
    return _retval;
  }
  catch (std::exception &e) {
    pbSetError(""setInflowBcs"", e.what());
    return 0;
  }
}
static const Pb::Register _RP_setInflowBcs("""", ""setInflowBcs"", _W_5);
extern ""C"" {
void PbRegister_setInflowBcs()
{
  KEEP_UNUSED(_RP_setInflowBcs);
}
}

// set obstacle boundary conditions

//! set no-stick wall boundary condition between ob/fl and ob/ob cells
struct KnSetWallBcs : public KernelBase {
  KnSetWallBcs(const FlagGrid &flags, MACGrid &vel, const MACGrid *obvel)
      : KernelBase(&flags, 0), flags(flags), vel(vel), obvel(obvel)
  {
    runMessage();
    run();
  }
  inline void op(
      int i, int j, int k, const FlagGrid &flags, MACGrid &vel, const MACGrid *obvel) const
  {

    bool curFluid = flags.isFluid(i, j, k);
    bool curObs = flags.isObstacle(i, j, k);
    Vec3 bcsVel(0., 0., 0.);
    if (!curFluid && !curObs)
      return;

    if (obvel) {
      bcsVel.x = (*obvel)(i, j, k).x;
      bcsVel.y = (*obvel)(i, j, k).y;
      if ((*obvel).is3D())
        bcsVel.z = (*obvel)(i, j, k).z;
    }

    // we use i>0 instead of bnd=1 to check outer wall
    if (i > 0 && flags.isObstacle(i - 1, j, k))
      vel(i, j, k).x = bcsVel.x;
    if (i > 0 && curObs && flags.isFluid(i - 1, j, k))
      vel(i, j, k).x = bcsVel.x;
    if (j > 0 && flags.isObstacle(i, j - 1, k))
      vel(i, j, k).y = bcsVel.y;
    if (j > 0 && curObs && flags.isFluid(i, j - 1, k))
      vel(i, j, k).y = bcsVel.y;

    if (!vel.is3D()) {
      vel(i, j, k).z = 0;
    }
    else {
      if (k > 0 && flags.isObstacle(i, j, k - 1))
        vel(i, j, k).z = bcsVel.z;
      if (k > 0 && curObs && flags.isFluid(i, j, k - 1))
        vel(i, j, k).z = bcsVel.z;
    }

    if (curFluid) {
      if ((i > 0 && flags.isStick(i - 1, j, k)) ||
          (i < flags.getSizeX() - 1 && flags.isStick(i + 1, j, k)))
        vel(i, j, k).y = vel(i, j, k).z = 0;
      if ((j > 0 && flags.isStick(i, j - 1, k)) ||
          (j < flags.getSizeY() - 1 && flags.isStick(i, j + 1, k)))
        vel(i, j, k).x = vel(i, j, k).z = 0;
      if (vel.is3D() && ((k > 0 && flags.isStick(i, j, k - 1)) ||
                         (k < flags.getSizeZ() - 1 && flags.isStick(i, j, k + 1))))
        vel(i, j, k).x = vel(i, j, k).y = 0;
    }
  }
  inline const FlagGrid &getArg0()
  {
    return flags;
  }
  typedef FlagGrid type0;
  inline MACGrid &getArg1()
  {
    return vel;
  }
  typedef MACGrid type1;
  inline const MACGrid *getArg2()
  {
    return obvel;
  }
  typedef MACGrid type2;
  void runMessage()
  {
    debMsg(""Executing kernel KnSetWallBcs "", 3);
    debMsg(""Kernel range""
               << "" x "" << maxX << "" y "" << maxY << "" z "" << minZ << "" - "" << maxZ << "" "",
           4);
  };
  void operator()(const tbb::blocked_range<IndexInt> &__r) const
  {
    const int _maxX = maxX;
    const int _maxY = maxY;
    if (maxZ > 1) {
      for (int k = __r.begin(); k != (int)__r.end(); k++)
        for (int j = 0; j < _maxY; j++)
          for (int i = 0; i < _maxX; i++)
            op(i, j, k, flags, vel, obvel);
    }
    else {
      const int k = 0;
      for (int j = __r.begin(); j != (int)__r.end(); j++)
        for (int i = 0; i < _maxX; i++)
          op(i, j, k, flags, vel, obvel);
    }
  }
  void run()
  {
    if (maxZ > 1)
      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
    else
      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
  }
  const FlagGrid &flags;
  MACGrid &vel;
  const MACGrid *obvel;
};

//! set wall BCs for fill fraction mode, note - only needs obstacle SDF

struct KnSetWallBcsFrac : public KernelBase {
  KnSetWallBcsFrac(const FlagGrid &flags,
                   const MACGrid &vel,
                   MACGrid &velTarget,
                   const MACGrid *obvel,
                   const Grid<Real> *phiObs,
                   const int &boundaryWidth = 0)
      : KernelBase(&flags, 0),
        flags(flags),
        vel(vel),
        velTarget(velTarget),
        obvel(obvel),
        phiObs(phiObs),
        boundaryWidth(boundaryWidth)
  {
    runMessage();
    run();
  }
  inline void op(int i,
                 int j,
                 int k,
                 const FlagGrid &flags,
                 const MACGrid &vel,
                 MACGrid &velTarget,
                 const MACGrid *obvel,
                 const Grid<Real> *phiObs,
                 const int &boundaryWidth = 0) const
  {
    bool curFluid = flags.isFluid(i, j, k);
    bool curObs = flags.isObstacle(i, j, k);
    velTarget(i, j, k) = vel(i, j, k);
    if (!curFluid && !curObs)
      return;

    // zero normal component in all obstacle regions
    if (flags.isInBounds(Vec3i(i, j, k), 1)) {

      if (curObs | flags.isObstacle(i - 1, j, k)) {
        Vec3 dphi(0., 0., 0.);
        const Real tmp1 = (phiObs->get(i, j, k) + phiObs->get(i - 1, j, k)) * .5;
        Real tmp2 = (phiObs->get(i, j + 1, k) + phiObs->get(i - 1, j + 1, k)) * .5;
        Real phi1 = (tmp1 + tmp2) * .5;
        tmp2 = (phiObs->get(i, j - 1, k) + phiObs->get(i - 1, j - 1, k)) * .5;
        Real phi2 = (tmp1 + tmp2) * .5;

        dphi.x = phiObs->get(i, j, k) - phiObs->get(i - 1, j, k);
        dphi.y = phi1 - phi2;

        if (phiObs->is3D()) {
          tmp2 = (phiObs->get(i, j, k + 1) + phiObs->get(i - 1, j, k + 1)) * .5;
          phi1 = (tmp1 + tmp2) * .5;
          tmp2 = (phiObs->get(i, j, k - 1) + phiObs->get(i - 1, j, k - 1)) * .5;
          phi2 = (tmp1 + tmp2) * .5;
          dphi.z = phi1 - phi2;
        }

        normalize(dphi);
        Vec3 velMAC = vel.getAtMACX(i, j, k);
        velTarget(i, j, k).x = velMAC.x - dot(dphi, velMAC) * dphi.x;
      }

      if (curObs | flags.isObstacle(i, j - 1, k)) {
        Vec3 dphi(0., 0., 0.);
        const Real tmp1 = (phiObs->get(i, j, k) + phiObs->get(i, j - 1, k)) * .5;
        Real tmp2 = (phiObs->get(i + 1, j, k) + phiObs->get(i + 1, j - 1, k)) * .5;
        Real phi1 = (tmp1 + tmp2) * .5;
        tmp2 = (phiObs->get(i - 1, j, k) + phiObs->get(i - 1, j - 1, k)) * .5;
        Real phi2 = (tmp1 + tmp2) * .5;

        dphi.x = phi1 - phi2;
        dphi.y = phiObs->get(i, j, k) - phiObs->get(i, j - 1, k);
        if (phiObs->is3D()) {
          tmp2 = (phiObs->get(i, j, k + 1) + phiObs->get(i, j - 1, k + 1)) * .5;
          phi1 = (tmp1 + tmp2) * .5;
          tmp2 = (phiObs->get(i, j, k - 1) + phiObs->get(i, j - 1, k - 1)) * .5;
          phi2 = (tmp1 + tmp2) * .5;
          dphi.z = phi1 - phi2;
        }

        normalize(dphi);
        Vec3 velMAC = vel.getAtMACY(i, j, k);
        velTarget(i, j, k).y = velMAC.y - dot(dphi, velMAC) * dphi.y;
      }

      if (phiObs->is3D() && (curObs | flags.isObstacle(i, j, k - 1))) {
        Vec3 dphi(0., 0., 0.);
        const Real tmp1 = (phiObs->get(i, j, k) + phiObs->get(i, j, k - 1)) * .5;

        Real tmp2;
        tmp2 = (phiObs->get(i + 1, j, k) + phiObs->get(i + 1, j, k - 1)) * .5;
        Real phi1 = (tmp1 + tmp2) * .5;
        tmp2 = (phiObs->get(i - 1, j, k) + phiObs->get(i - 1, j, k - 1)) * .5;
        Real phi2 = (tmp1 + tmp2) * .5;
        dphi.x = phi1 - phi2;

        tmp2 = (phiObs->get(i, j + 1, k) + phiObs->get(i, j + 1, k - 1)) * .5;
        phi1 = (tmp1 + tmp2) * .5;
        tmp2 = (phiObs->get(i, j - 1, k) + phiObs->get(i, j - 1, k - 1)) * .5;
        phi2 = (tmp1 + tmp2) * .5;
        dphi.y = phi1 - phi2;

        dphi.z = phiObs->get(i, j, k) - phiObs->get(i, j, k - 1);

        normalize(dphi);
        Vec3 velMAC = vel.getAtMACZ(i, j, k);
        velTarget(i, j, k).z = velMAC.z - dot(dphi, velMAC) * dphi.z;
      }
    }  // not at boundary
  }
  inline const FlagGrid &getArg0()
  {
    return flags;
  }
  typedef FlagGrid type0;
  inline const MACGrid &getArg1()
  {
    return vel;
  }
  typedef MACGrid type1;
  inline MACGrid &getArg2()
  {
    return velTarget;
  }
  typedef MACGrid type2;
  inline const MACGrid *getArg3()
  {
    return obvel;
  }
  typedef MACGrid type3;
  inline const Grid<Real> *getArg4()
  {
    return phiObs;
  }
  typedef Grid<Real> type4;
  inline const int &getArg5()
  {
    return boundaryWidth;
  }
  typedef int type5;
  void runMessage()
  {
    debMsg(""Executing kernel KnSetWallBcsFrac "", 3);
    debMsg(""Kernel range""
               << "" x "" << maxX << "" y "" << maxY << "" z "" << minZ << "" - "" << maxZ << "" "",
           4);
  };
  void operator()(const tbb::blocked_range<IndexInt> &__r) const
  {
    const int _maxX = maxX;
    const int _maxY = maxY;
    if (maxZ > 1) {
      for (int k = __r.begin(); k != (int)__r.end(); k++)
        for (int j = 0; j < _maxY; j++)
          for (int i = 0; i < _maxX; i++)
            op(i, j, k, flags, vel, velTarget, obvel, phiObs, boundaryWidth);
    }
    else {
      const int k = 0;
      for (int j = __r.begin(); j != (int)__r.end(); j++)
        for (int i = 0; i < _maxX; i++)
          op(i, j, k, flags, vel, velTarget, obvel, phiObs, boundaryWidth);
    }
  }
  void run()
  {
    if (maxZ > 1)
      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
    else
      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
  }
  const FlagGrid &flags;
  const MACGrid &vel;
  MACGrid &velTarget;
  const MACGrid *obvel;
  const Grid<Real> *phiObs;
  const int &boundaryWidth;
};

//! set zero normal velocity boundary condition on walls
// (optionally with second order accuracy using the obstacle SDF , fractions grid currentlyl not
// needed)
void setWallBcs(const FlagGrid &flags,
                MACGrid &vel,
                const MACGrid *obvel = 0,
                const MACGrid *fractions = 0,
                const Grid<Real> *phiObs = 0,
                int boundaryWidth = 0)
{
  if (!phiObs || !fractions) {
    KnSetWallBcs(flags, vel, obvel);
  }
  else {
    MACGrid tmpvel(vel.getParent());
    KnSetWallBcsFrac(flags, vel, tmpvel, obvel, phiObs, boundaryWidth);
    vel.swap(tmpvel);
  }
}
static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
{
  try {
    PbArgs _args(_linargs, _kwds);
    FluidSolver *parent = _args.obtainParent();
    bool noTiming = _args.getOpt<bool>(""notiming"", -1, 0);
    pbPreparePlugin(parent, ""setWallBcs"", !noTiming);
    PyObject *_retval = 0;
    {
      ArgLocker _lock;
      const FlagGrid &flags = *_args.getPtr<FlagGrid>(""flags"", 0, &_lock);
      MACGrid &vel = *_args.getPtr<MACGrid>(""vel"", 1, &_lock);
      const MACGrid *obvel = _args.getPtrOpt<MACGrid>(""obvel"", 2, 0, &_lock);
      const MACGrid *fractions = _args.getPtrOpt<MACGrid>(""fractions"", 3, 0, &_lock);
      const Grid<Real> *phiObs = _args.getPtrOpt<Grid<Real>>(""phiObs"", 4, 0, &_lock);
      int boundaryWidth = _args.getOpt<int>(""boundaryWidth"", 5, 0, &_lock);
      _retval = getPyNone();
      setWallBcs(flags, vel, obvel, fractions, phiObs, boundaryWidth);
      _args.check();
    }
    pbFinalizePlugin(parent, ""setWallBcs"", !noTiming);
    return _retval;
  }
  catch (std::exception &e) {
    pbSetError(""setWallBcs"", e.what());
    return 0;
  }
}
static const Pb::Register _RP_setWallBcs("""", ""setWallBcs"", _W_6);
extern ""C"" {
void PbRegister_setWallBcs()
{
  KEEP_UNUSED(_RP_setWallBcs);
}
}

//! add Forces between fl/fl and fl/em cells (interpolate cell centered forces to MAC grid)
struct KnAddForceIfLower : public KernelBase {
  KnAddForceIfLower(const FlagGrid &flags, MACGrid &vel, const Grid<Vec3> &force)
      : KernelBase(&flags, 1), flags(flags), vel(vel), force(force)
  {
    runMessage();
    run();
  }
  inline void op(
      int i, int j, int k, const FlagGrid &flags, MACGrid &vel, const Grid<Vec3> &force) const
  {
    bool curFluid = flags.isFluid(i, j, k);
    bool curEmpty = flags.isEmpty(i, j, k);
    if (!curFluid && !curEmpty)
      return;

    if (flags.isFluid(i - 1, j, k) || (curFluid && flags.isEmpty(i - 1, j, k))) {
      Real forceMACX = 0.5 * (force(i - 1, j, k).x + force(i, j, k).x);
      Real min = std::min(vel(i, j, k).x, forceMACX);
      Real max = std::max(vel(i, j, k).x, forceMACX);
      Real sum = vel(i, j, k).x + forceMACX;
      vel(i, j, k).x = (forceMACX > 0) ? std::min(sum, max) : std::max(sum, min);
    }
    if (flags.isFluid(i, j - 1, k) || (curFluid && flags.isEmpty(i, j - 1, k))) {
      Real forceMACY = 0.5 * (force(i, j - 1, k).y + force(i, j, k).y);
      Real min = std::min(vel(i, j, k).y, forceMACY);
      Real max = std::max(vel(i, j, k).y, forceMACY);
      Real sum = vel(i, j, k).y + forceMACY;
      vel(i, j, k).y = (forceMACY > 0) ? std::min(sum, max) : std::max(sum, min);
    }
    if (vel.is3D() && (flags.isFluid(i, j, k - 1) || (curFluid && flags.isEmpty(i, j, k - 1)))) {
      Real forceMACZ = 0.5 * (force(i, j, k - 1).z + force(i, j, k).z);
      Real min = std::min(vel(i, j, k).z, forceMACZ);
      Real max = std::max(vel(i, j, k).z, forceMACZ);
      Real sum = vel(i, j, k).z + forceMACZ;
      vel(i, j, k).z = (forceMACZ > 0) ? std::min(sum, max) : std::max(sum, min);
    }
  }
  inline const FlagGrid &getArg0()
  {
    return flags;
  }
  typedef FlagGrid type0;
  inline MACGrid &getArg1()
  {
    return vel;
  }
  typedef MACGrid type1;
  inline const Grid<Vec3> &getArg2()
  {
    return force;
  }
  typedef Grid<Vec3> type2;
  void runMessage()
  {
    debMsg(""Executing kernel KnAddForceIfLower "", 3);
    debMsg(""Kernel range""
               << "" x "" << maxX << "" y "" << maxY << "" z "" << minZ << "" - "" << maxZ << "" "",
           4);
  };
  void operator()(const tbb::blocked_range<IndexInt> &__r) const
  {
    const int _maxX = maxX;
    const int _maxY = maxY;
    if (maxZ > 1) {
      for (int k = __r.begin(); k != (int)__r.end(); k++)
        for (int j = 1; j < _maxY; j++)
          for (int i = 1; i < _maxX; i++)
            op(i, j, k, flags, vel, force);
    }
    else {
      const int k = 0;
      for (int j = __r.begin(); j != (int)__r.end(); j++)
        for (int i = 1; i < _maxX; i++)
          op(i, j, k, flags, vel, force);
    }
  }
  void run()
  {
    if (maxZ > 1)
      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
    else
      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
  }
  const FlagGrid &flags;
  MACGrid &vel;
  const Grid<Vec3> &force;
};

// Initial velocity for smoke
void setInitialVelocity(const FlagGrid &flags, MACGrid &vel, const Grid<Vec3> &invel)
{
  KnAddForceIfLower(flags, vel, invel);
}
static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
{
  try {
    PbArgs _args(_linargs, _kwds);
    FluidSolver *parent = _args.obtainParent();
    bool noTiming = _args.getOpt<bool>(""notiming"", -1, 0);
    pbPreparePlugin(parent, ""setInitialVelocity"", !noTiming);
    PyObject *_retval = 0;
    {
      ArgLocker _lock;
      const FlagGrid &flags = *_args.getPtr<FlagGrid>(""flags"", 0, &_lock);
      MACGrid &vel = *_args.getPtr<MACGrid>(""vel"", 1, &_lock);
      const Grid<Vec3> &invel = *_args.getPtr<Grid<Vec3>>(""invel"", 2, &_lock);
      _retval = getPyNone();
      setInitialVelocity(flags, vel, invel);
      _args.check();
    }
    pbFinalizePlugin(parent, ""setInitialVelocity"", !noTiming);
    return _retval;
  }
  catch (std::exception &e) {
    pbSetError(""setInitialVelocity"", e.what());
    return 0;
  }
}
static const Pb::Register _RP_setInitialVelocity("""", ""setInitialVelocity"", _W_7);
extern ""C"" {
void PbRegister_setInitialVelocity()
{
  KEEP_UNUSED(_RP_setInitialVelocity);
}
}

//! Kernel: gradient norm operator
struct KnConfForce : public KernelBase {
  KnConfForce(Grid<Vec3> &force,
              const Grid<Real> &grid,
              const Grid<Vec3> &curl,
              Real str,
              const Grid<Real> *strGrid)
      : KernelBase(&force, 1), force(force), grid(grid), curl(curl), str(str), strGrid(strGrid)
  {
    runMessage();
    run();
  }
  inline void op(int i,
                 int j,
                 int k,
                 Grid<Vec3> &force,
                 const Grid<Real> &grid,
                 const Grid<Vec3> &curl,
                 Real str,
                 const Grid<Real> *strGrid) const
  {
    Vec3 grad = 0.5 * Vec3(grid(i + 1, j, k) - grid(i - 1, j, k),
                           grid(i, j + 1, k) - grid(i, j - 1, k),
                           0.);
    if (grid.is3D())
      grad[2] = 0.5 * (grid(i, j, k + 1) - grid(i, j, k - 1));
    normalize(grad);
    if (strGrid)
      str += (*strGrid)(i, j, k);
    force(i, j, k) = str * cross(grad, curl(i, j, k));
  }
  inline Grid<Vec3> &getArg0()
  {
    return force;
  }
  typedef Grid<Vec3> type0;
  inline const Grid<Real> &getArg1()
  {
    return grid;
  }
  typedef Grid<Real> type1;
  inline const Grid<Vec3> &getArg2()
  {
    return curl;
  }
  typedef Grid<Vec3> type2;
  inline Real &getArg3()
  {
    return str;
  }
  typedef Real type3;
  inline const Grid<Real> *getArg4()
  {
    return strGrid;
  }
  typedef Grid<Real> type4;
  void runMessage()
  {
    debMsg(""Executing kernel KnConfForce "", 3);
    debMsg(""Kernel range""
               << "" x "" << maxX << "" y "" << maxY << "" z "" << minZ << "" - "" << maxZ << "" "",
           4);
  };
  void operator()(const tbb::blocked_range<IndexInt> &__r) const
  {
    const int _maxX = maxX;
    const int _maxY = maxY;
    if (maxZ > 1) {
      for (int k = __r.begin(); k != (int)__r.end(); k++)
        for (int j = 1; j < _maxY; j++)
          for (int i = 1; i < _maxX; i++)
            op(i, j, k, force, grid, curl, str, strGrid);
    }
    else {
      const int k = 0;
      for (int j = __r.begin(); j != (int)__r.end(); j++)
        for (int i = 1; i < _maxX; i++)
          op(i, j, k, force, grid, curl, str, strGrid);
    }
  }
  void run()
  {
    if (maxZ > 1)
      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
    else
      tbb::parallel_for(tbb::blocked_range<IndexInt>(1, maxY), *this);
  }
  Grid<Vec3> &force;
  const Grid<Real> &grid;
  const Grid<Vec3> &curl;
  Real str;
  const Grid<Real> *strGrid;
};

void vorticityConfinement(MACGrid &vel,
                          const FlagGrid &flags,
                          Real strength = 0,
                          const Grid<Real> *strengthCell = NULL)
{
  Grid<Vec3> velCenter(flags.getParent()), curl(flags.getParent()), force(flags.getParent());
  Grid<Real> norm(flags.getParent());

  GetCentered(velCenter, vel);
  CurlOp(velCenter, curl);
  GridNorm(norm, curl);
  KnConfForce(force, norm, curl, strength, strengthCell);
  KnApplyForceField(flags, vel, force, NULL, true, false);
}
static PyObject *_W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
{
  try {
    PbArgs _args(_linargs, _kwds);
    FluidSolver *parent = _args.obtainParent();
    bool noTiming = _args.getOpt<bool>(""notiming"", -1, 0);
    pbPreparePlugin(parent, ""vorticityConfinement"", !noTiming);
    PyObject *_retval = 0;
    {
      ArgLocker _lock;
      MACGrid &vel = *_args.getPtr<MACGrid>(""vel"", 0, &_lock);
      const FlagGrid &flags = *_args.getPtr<FlagGrid>(""flags"", 1, &_lock);
      Real strength = _args.getOpt<Real>(""strength"", 2, 0, &_lock);
      const Grid<Real> *strengthCell = _args.getPtrOpt<Grid<Real>>(
          ""strengthCell"", 3, NULL, &_lock);
      _retval = getPyNone();
      vorticityConfinement(vel, flags, strength, strengthCell);
      _args.check();
    }
    pbFinalizePlugin(parent, ""vorticityConfinement"", !noTiming);
    return _retval;
  }
  catch (std::exception &e) {
    pbSetError(""vorticityConfinement"", e.what());
    return 0;
  }
}
static const Pb::Register _RP_vorticityConfinement("""", ""vorticityConfinement"", _W_8);
extern ""C"" {
void PbRegister_vorticityConfinement()
{
  KEEP_UNUSED(_RP_vorticityConfinement);
}
}

void addForceField(const FlagGrid &flags,
                   MACGrid &vel,
                   const Grid<Vec3> &force,
                   const Grid<Real> *region = NULL,
                   bool isMAC = false)
{
  KnApplyForceField(flags, vel, force, region, true, isMAC);
}
static PyObject *_W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
{
  try {
    PbArgs _args(_linargs, _kwds);
    FluidSolver *parent = _args.obtainParent();
    bool noTiming = _args.getOpt<bool>(""notiming"", -1, 0);
    pbPreparePlugin(parent, ""addForceField"", !noTiming);
    PyObject *_retval = 0;
    {
      ArgLocker _lock;
      const FlagGrid &flags = *_args.getPtr<FlagGrid>(""flags"", 0, &_lock);
      MACGrid &vel = *_args.getPtr<MACGrid>(""vel"", 1, &_lock);
      const Grid<Vec3> &force = *_args.getPtr<Grid<Vec3>>(""force"", 2, &_lock);
      const Grid<Real> *region = _args.getPtrOpt<Grid<Real>>(""region"", 3, NULL, &_lock);
      bool isMAC = _args.getOpt<bool>(""isMAC"", 4, false, &_lock);
      _retval = getPyNone();
      addForceField(flags, vel, force, region, isMAC);
      _args.check();
    }
    pbFinalizePlugin(parent, ""addForceField"", !noTiming);
    return _retval;
  }
  catch (std::exception &e) {
    pbSetError(""addForceField"", e.what());
    return 0;
  }
}
static const Pb::Register _RP_addForceField("""", ""addForceField"", _W_9);
extern ""C"" {
void PbRegister_addForceField()
{
  KEEP_UNUSED(_RP_addForceField);
}
}

void setForceField(const FlagGrid &flags,
                   MACGrid &vel,
                   const Grid<Vec3> &force,
                   const Grid<Real> *region = NULL,
                   bool isMAC = false)
{
  KnApplyForceField(flags, vel, force, region, false, isMAC);
}
static PyObject *_W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
{
  try {
    PbArgs _args(_linargs, _kwds);
    FluidSolver *parent = _args.obtainParent();
    bool noTiming = _args.getOpt<bool>(""notiming"", -1, 0);
    pbPreparePlugin(parent, ""setForceField"", !noTiming);
    PyObject *_retval = 0;
    {
      ArgLocker _lock;
      const FlagGrid &flags = *_args.getPtr<FlagGrid>(""flags"", 0, &_lock);
      MACGrid &vel = *_args.getPtr<MACGrid>(""vel"", 1, &_lock);
      const Grid<Vec3> &force = *_args.getPtr<Grid<Vec3>>(""force"", 2, &_lock);
      const Grid<Real> *region = _args.getPtrOpt<Grid<Real>>(""region"", 3, NULL, &_lock);
      bool isMAC = _args.getOpt<bool>(""isMAC"", 4, false, &_lock);
      _retval = getPyNone();
      setForceField(flags, vel, force, region, isMAC);
      _args.check();
    }
    pbFinalizePlugin(parent, ""setForceField"", !noTiming);
    return _retval;
  }
  catch (std::exception &e) {
    pbSetError(""setForceField"", e.what());
    return 0;
  }
}
static const Pb::Register _RP_setForceField("""", ""setForceField"", _W_10);
extern ""C"" {
void PbRegister_setForceField()
{
  KEEP_UNUSED(_RP_setForceField);
}
}

struct KnDissolveSmoke : public KernelBase {
  KnDissolveSmoke(const FlagGrid &flags,
                  Grid<Real> &density,
                  Grid<Real> *heat,
                  Grid<Real> *red,
                  Grid<Real> *green,
                  Grid<Real> *blue,
                  int speed,
                  bool logFalloff,
                  float dydx,
                  float fac)
      : KernelBase(&flags, 0),
        flags(flags),
        density(density),
        heat(heat),
        red(red),
        green(green),
        blue(blue),
        speed(speed),
        logFalloff(logFalloff),
        dydx(dydx),
        fac(fac)
  {
    runMessage();
    run();
  }
  inline void op(int i,
                 int j,
                 int k,
                 const FlagGrid &flags,
                 Grid<Real> &density,
                 Grid<Real> *heat,
                 Grid<Real> *red,
                 Grid<Real> *green,
                 Grid<Real> *blue,
                 int speed,
                 bool logFalloff,
                 float dydx,
                 float fac) const
  {

    bool curFluid = flags.isFluid(i, j, k);
    if (!curFluid)
      return;

    if (logFalloff) {
      density(i, j, k) *= fac;
      if (heat) {
        (*heat)(i, j, k) *= fac;
      }
      if (red) {
        (*red)(i, j, k) *= fac;
        (*green)(i, j, k) *= fac;
        (*blue)(i, j, k) *= fac;
      }
    }
    else {  // linear falloff
      float d = density(i, j, k);
      density(i, j, k) -= dydx;
      if (density(i, j, k) < 0.0f)
        density(i, j, k) = 0.0f;
      if (heat) {
        if (fabs((*heat)(i, j, k)) < dydx)
          (*heat)(i, j, k) = 0.0f;
        else if ((*heat)(i, j, k) > 0.0f)
          (*heat)(i, j, k) -= dydx;
        else if ((*heat)(i, j, k) < 0.0f)
          (*heat)(i, j, k) += dydx;
      }
      if (red && notZero(d)) {
        (*red)(i, j, k) *= (density(i, j, k) / d);
        (*green)(i, j, k) *= (density(i, j, k) / d);
        (*blue)(i, j, k) *= (density(i, j, k) / d);
      }
    }
  }
  inline const FlagGrid &getArg0()
  {
    return flags;
  }
  typedef FlagGrid type0;
  inline Grid<Real> &getArg1()
  {
    return density;
  }
  typedef Grid<Real> type1;
  inline Grid<Real> *getArg2()
  {
    return heat;
  }
  typedef Grid<Real> type2;
  inline Grid<Real> *getArg3()
  {
    return red;
  }
  typedef Grid<Real> type3;
  inline Grid<Real> *getArg4()
  {
    return green;
  }
  typedef Grid<Real> type4;
  inline Grid<Real> *getArg5()
  {
    return blue;
  }
  typedef Grid<Real> type5;
  inline int &getArg6()
  {
    return speed;
  }
  typedef int type6;
  inline bool &getArg7()
  {
    return logFalloff;
  }
  typedef bool type7;
  inline float &getArg8()
  {
    return dydx;
  }
  typedef float type8;
  inline float &getArg9()
  {
    return fac;
  }
  typedef float type9;
  void runMessage()
  {
    debMsg(""Executing kernel KnDissolveSmoke "", 3);
    debMsg(""Kernel range""
               << "" x "" << maxX << "" y "" << maxY << "" z "" << minZ << "" - "" << maxZ << "" "",
           4);
  };
  void operator()(const tbb::blocked_range<IndexInt> &__r) const
  {
    const int _maxX = maxX;
    const int _maxY = maxY;
    if (maxZ > 1) {
      for (int k = __r.begin(); k != (int)__r.end(); k++)
        for (int j = 0; j < _maxY; j++)
          for (int i = 0; i < _maxX; i++)
            op(i, j, k, flags, density, heat, red, green, blue, speed, logFalloff, dydx, fac);
    }
    else {
      const int k = 0;
      for (int j = __r.begin(); j != (int)__r.end(); j++)
        for (int i = 0; i < _maxX; i++)
          op(i, j, k, flags, density, heat, red, green, blue, speed, logFalloff, dydx, fac);
    }
  }
  void run()
  {
    if (maxZ > 1)
      tbb::parallel_for(tbb::blocked_range<IndexInt>(minZ, maxZ), *this);
    else
      tbb::parallel_for(tbb::blocked_range<IndexInt>(0, maxY), *this);
  }
  const FlagGrid &flags;
  Grid<Real> &density;
  Grid<Real> *heat;
  Grid<Real> *red;
  Grid<Real> *green;
  Grid<Real> *blue;
  int speed;
  bool logFalloff;
  float dydx;
  float fac;
};

void dissolveSmoke(const FlagGrid &flags,
                   Grid<Real> &density,
                   Grid<Real> *heat = NULL,
                   Grid<Real> *red = NULL,
                   Grid<Real> *green = NULL,
                   Grid<Real> *blue = NULL,
                   int speed = 5,
                   bool logFalloff = true)
{
  float dydx = 1.0f / (float)speed;  // max density/speed = dydx
  float fac = 1.0f - dydx;
  KnDissolveSmoke(flags, density, heat, red, green, blue, speed, logFalloff, dydx, fac);
}
static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
{
  try {
    PbArgs _args(_linargs, _kwds);
    FluidSolver *parent = _args.obtainParent();
    bool noTiming = _args.getOpt<bool>(""notiming"", -1, 0);
    pbPreparePlugin(parent, ""dissolveSmoke"", !noTiming);
    PyObject *_retval = 0;
    {
      ArgLocker _lock;
      const FlagGrid &flags = *_args.getPtr<FlagGrid>(""flags"", 0, &_lock);
      Grid<Real> &density = *_args.getPtr<Grid<Real>>(""density"", 1, &_lock);
      Grid<Real> *heat = _args.getPtrOpt<Grid<Real>>(""heat"", 2, NULL, &_lock);
      Grid<Real> *red = _args.getPtrOpt<Grid<Real>>(""red"", 3, NULL, &_lock);
      Grid<Real> *green = _args.getPtrOpt<Grid<Real>>(""green"", 4, NULL, &_lock);
      Grid<Real> *blue = _args.getPtrOpt<Grid<Real>>(""blue"", 5, NULL, &_lock);
      int speed = _args.getOpt<int>(""speed"", 6, 5, &_lock);
      bool logFalloff = _args.getOpt<bool>(""logFalloff"", 7, true, &_lock);
      _retval = getPyNone();
      dissolveSmoke(flags, density, heat, red, green, blue, speed, logFalloff);
      _args.check();
    }
    pbFinalizePlugin(parent, ""dissolveSmoke"", !noTiming);
    return _retval;
  }
  catch (std::exception &e) {
    pbSetError(""dissolveSmoke"", e.what());
    return 0;
  }
}
static const Pb::Register _RP_dissolveSmoke("""", ""dissolveSmoke"", _W_11);
extern ""C"" {
void PbRegister_dissolveSmoke()
{
  KEEP_UNUSED(_RP_dissolveSmoke);
}
}

}  // namespace Manta
",16368,True,3851.547885293186,median
"= Asciidoctor Changelog
:uri-asciidoctor: http://asciidoctor.org
:uri-asciidoc: {uri-asciidoctor}/docs/what-is-asciidoc
:uri-repo: https://github.com/asciidoctor/asciidoctor
:icons: font
:star: icon:star[role=red]
ifndef::icons[]
:star: &#9733;
endif::[]

{uri-asciidoctor}[Asciidoctor] is a _fast_, open source text processor and publishing toolchain for converting {uri-asciidoc}[AsciiDoc] content into HTML5, DocBook 5 (or 4.5) and other formats.

This document provides a high-level view of the changes introduced in Asciidoctor by release.
For a detailed view of what has changed, refer to the {uri-repo}/commits/master[commit history] on GitHub.

// tag::compact[]
== 1.5.4 (2016-01-03) - @mojavelinux

Enhancements::
  * translate README into French (@anthonny, @mogztter, @gscheibel, @mgreau) (#1630)
  * allow linkstyle in manpage output to be configured (#1610)

Improvements::
  * upgrade to MathJax 2.6.0 and disable loading messages
  * upgrade to Font Awesome 4.5.0
  * disable toc if document has no sections (#1633)
  * convert inline asciimath to MathML (using asciimath gem) in DocBook converter (#1622)
  * add attribute to control build reproducibility (@bk2204) (#1453)
  * recognize \\file:/// as a file root in Opal browser env (#1561)
  * honor icon attribute on admonition block when font-based icons are enabled (@robertpanzer) (#1593)
  * resolve custom icon relative to iconsdir; add file extension if absent (#1634)
  * allow asciidoctor cli to resolve library path when invoked without leading ./

Compliance::
  * allow special section to be nested at any depth (#1591)
  * ensure colpcwidth values add up to 100%; increase precision of values to 4 decimal places (#1647)
  * ignore blank cols attribute on table (#1647)
  * support shorthand syntax for block attributes on document title (#1650)

Bug fixes::
  * don't include default toc in AsciiDoc table cell; don't pass toc location attributes to nested document (#1582)
  * guard against nil dlist list item in find_by (#1618)
  * don't swallow trailing line when include file is not readable (#1602)
  * change xlink namespace to xl in DocBook 5 output to prevent parse error (#1597)
  * make callouts globally unique within document, including AsciiDoc table cells (#1626)
  * initialize Slim-related attributes regardless of when Slim was loaded (@terceiro) (#1576)
  * differentiate literal backslash from escape sequence in manpage output (@ds26gte) (#1604)
  * don't mistake line beginning with \\. for troff macro in manpage output (@ds26gte) (#1589)
  * escape leading dots so user content doesn't trigger troff macros in manpage output (@ds26gte) (#1631)
  * use \\c after .URL macro to remove extraneous space in manpage output (@ds26gte) (#1590)
  * fix missing endline after .URL macro in manpage output (#1613)
  * properly handle spacing around .URL/.MTO macro in manpage output (@ds26gte) (#1641)
  * don't swallow doctitle attribute followed by block title (#1587)
  * change strategy for splitting names of author; fixes bug in Opal/Asciidoctor.js
  * don't fail if library is loaded more than once

Infrastructure::
  * remove trailing endlines in project source code
  * update contributing guidelines
  * explicitly test ifeval scenario raised in issue #1585
  * remove backreference substitution hack for Opal/Asciidoctor.js
  * fix assignment of default Hash value for Opal/Asciidoctor.js
  * add JRuby 9.0.4.0 and Ruby 2.3.0 to the Travis CI build matrix

Distribution Packages::

  * http://rubygems.org/gems/asciidoctor[RubyGem (asciidoctor)]
  * https://apps.fedoraproject.org/packages/rubygem-asciidoctor[Fedora (rubygem-asciidoctor)]
  * http://packages.debian.org/sid/asciidoctor[Debian (asciidoctor)]
  * http://packages.ubuntu.com/saucy/asciidoctor[Ubuntu (asciidoctor)]

https://github.com/asciidoctor/asciidoctor/issues?q=milestone%3Av1.5.4[issues resolved] |
https://github.com/asciidoctor/asciidoctor/releases/tag/v1.5.4[git tag] |
https://github.com/asciidoctor/asciidoctor/compare/v1.5.3...v1.5.4[full diff]

== 1.5.3 (2015-10-31) - @mojavelinux

Enhancements::
  * add support for interactive & inline SVGs (#1301, #1224)
  * add built-in manpage backend (@davidgamba) (#651)
  * create Mallard backend; asciidoctor/asciidoctor-mallard (@bk2204) (#425)
  * add AsciiMath to MathML converter to support AsciiMath in DocBook converter (@pepijnve) (#954)
  * allow text of selected lines to be highlighted in source block by Pygments or CodeRay (#1429)
  * use value of `docinfo` attribute to control docinfo behavior (#1510)
  * add `docinfosubs` attribute to control which substitutions are performed on docinfo files (@mogztter) (#405)
  * drop ability to specify multiple attributes with a single `-a` flag when using the CLI (@mogztter) (#405)
  * make subtitle separator chars for document title configurable (@rmannibucau) (#1350)
  * make XrefInlineRx regexp more permissive (Mathieu Boespflug) (#844)

Improvements::
  * load JavaScript and CSS at bottom of HTML document (@mogztter) (#1238)
  * list available backends in help text (@plaindocs) (#1271)
  * properly expand tabs in literal text (#1170, #841)
  * add `source-indent` as document attribute (@mogztter) (#1169)
  * upgrade MathJax to 2.5.3 (#1329)
  * upgrade Font Awesome to 4.4.0 (@mogztter) (#1465)
  * upgrade highlight.js to 8.6 (now 8.9.1) (#1390)
  * don't abort if syntax highlighter isn't available (#1253)
  * insert docinfo footer below footer div (#1503)
  * insert toc at default location in embeddable HTML (#1443)
  * replace _ and - in generated alt text for inline images
  * restore attributes to header attributes after parse (#1255)
  * allow docdate and doctime to be overridden (#1495)
  * add CSS class `.center` for center block alignment (#1456)
  * recognize U+2022 as alternative marker for unordered lists (@mogztter) (#1177)
  * allow videos to work for local files by prepending asset-uri-scheme (Chris) (#1320)
  * always assign playlist param when loop option is enabled for YouTube video
  * parse isolated version in revision line (@bk2204) (#790)
  * autoload Tilt when template converter is instantiated (#1313)
  * don't overwrite existing id entry in references table (#1256)
  * use outfilesuffix attribute defined in header when resolving outfile (#1412)
  * make AsciiDoc safe mode option on Slim engine match document (#1347)
  * honor htmlsyntax attribute when backend is html/html5 (#1530)
  * tighten spacing of wrapped lines in TOC (#1542)
  * tune padding around table cells in horizontal dlist (#1418)
  * load Droid Sans Mono 700 in default stylesheet
  * set line height of table cells used for syntax highlighting
  * set font-family of kbd; refine styling (#1423)
  * extract condition into `quote_lines?` method (@mogztter)
  * extract inline code into `read_paragraph` method (@mogztter)
  * parent of block in ListItem should be ListItem (#1359)
  * add helper methods to List and ListItem (#1551)
  * add method `AbstractNode#add_role` and `AbstractNode#remove_role` (@robertpanzer) (#1366)
  * introduce helper methods for sniffing URIs (#1422)
  * add helper to calculate basename without file extension
  * document `-I` and `-r` options in the manual page (@bk2204)
  * fix `+--help+` output text for `-I` (@bk2204)
  * don't require open-uri-cached if already loaded
  * do not attempt to scan pattern of non-existent directory in template converter

Compliance::
  * use `<sup>` for footnote reference in text instead of `<span>` (#1523)
  * fix alignment of wrapped text in footnote (#1524)
  * include full stop after footnote number in embeddable HTML
  * show manpage title & name section in embeddable HTML (#1179)
  * resolve missing attribute in ifeval to empty string (#1387)
  * support unbreakable & breakable options on table (rockyallen) (#1140)

Bug fixes::
  * don't truncate exception stack in `Asciidoctor.load` (#1248)
  * don't fail to save cause of Java exception (@robertpanzer) (#1458)
  * fix precision error in timings report (#1342)
  * resolve regexp for inline macro lazily (#1336)
  * block argument to `find_by` should filter results (#1393)
  * strip comment lines in indented text of dlist item (#1537)
  * preserve escaped delimiter at end of line in a table (#1306)
  * correctly calculate colnames for implicit columns (#1556)
  * don't crash if colspan exceeds colspec (#1460)
  * account for empty records in colspec (#1375)
  * ignore empty cols attribute on table
  * use `.inspect` to print MathJax delimiters (again) (#1198)
  * use while loop instead of begin/while loop to address bug in Asciidoctor.js (#1408)
  * force encoding of attribute values passed from cli (#1191)
  * don't copy css if stylesheet or stylesdir is a URI (#1400)
  * fix invalid color value in default CodeRay theme
  * built-in writer no longer fails if output is nil (#1544)
  * custom template engine options should take precedence
  * fallback to require with a non-relative path to support Debian package (@mogztter)
  * pass opts to recursive invocations of `PathResolver#system_path`
  * fix and test external links in docbook backend
  * use format symbol `:html` instead of `:html5` for Slim to fix warnings
  * fix documentation for inline_macro and block_macro (Andrea Bedini)
  * fix grammar in warning messages regarding thread_safe gem

Infrastructure::
  * migrate opal_ext from core to Asciidoctor.js (#1517)
  * add Ruby 2.2 to CI build; only specify minor Ruby versions
  * enable containerized builds on Travis CI
  * add config to run CI build on AppVeyor
  * exclude benchmark folder from gem (#1522)

Distribution Packages::

  * http://rubygems.org/gems/asciidoctor[RubyGem (asciidoctor)]
  * https://apps.fedoraproject.org/packages/rubygem-asciidoctor[Fedora (rubygem-asciidoctor)]
  * http://packages.debian.org/sid/asciidoctor[Debian (asciidoctor)]
  * http://packages.ubuntu.com/saucy/asciidoctor[Ubuntu (asciidoctor)]

https://github.com/asciidoctor/asciidoctor/issues?q=milestone%3Av1.5.3[issues resolved] |
https://github.com/asciidoctor/asciidoctor/releases/tag/v1.5.3[git tag] |
https://github.com/asciidoctor/asciidoctor/compare/v1.5.2...v1.5.3[full diff]

== 1.5.2 (2014-11-27) - @mojavelinux

Enhancements::

  * add docinfo extension (@mogztter) (#1162)
  * allow docinfo to be in separate directory from content, specified by `docinfodir` attribute (@mogztter) (#511)
  * enable TeX equation auto-numbering if `eqnums` attribute is set (@jxxcarlson) (#1110)

Improvements::

  * recognize `--` as valid line comment for callout numbers; make line comment configurable (#1068)
  * upgrade highlight.js to version 8.4 (#1216)
  * upgrade Font Awesome to version 4.2.0 (@clojens) (#1201)
  * define JAVASCRIPT_PLATFORM constant to simplify conditional logic in the JavaScript environment (#897)
  * provide access to destination directory, outfile and outdir via Document object (#1203)
  * print encoding information in version report produced by `asciidoctor -v` (#1210)
  * add intrinsic attribute named `cpp` with value `C++` (#1208)
  * preserve URI targets passed to `stylesheet` and related attributes (#1192)
  * allow numeric characters in block attribute name (#1103)
  * support custom YouTube playlists (#1105)
  * make start number for unique id generation configurable (#1148)
  * normalize and force UTF-8 encoding of docinfo content (#831)
  * allow subs and default_subs to be specified in Block constructor (#749)
  * enhance error message when reading binary input files (@mogztter) (#1158)
  * add `append` method as alias to `<<` method on AbstractBlock (#1085)
  * assign value of `preface-title` as title of preface node (#1090)
  * fix spacing around checkbox in checklist (#1138)
  * automatically load Slim's include plugin when using slim templates (@jirutka) (#1151)
  * mixin Slim helpers into execution scope of slim templates (@jirutka) (#1143)
  * improve DocBook output for manpage doctype (@bk2204) (#1134, #1142)

Compliance::

  * substitute attribute entry value in attributes defined outside of header (#1130)
  * allow empty cell to appear at end of table row (#1106)
  * only produce one row for table in CSV or DSV format with a single cell (#1180)

Bug fixes::

  * add explicit to_s call to generate delimiter settings for MathJax config (#1198)
  * fix includes that reference absolute Windows paths (#1144)
  * apply DSL to extension block in a way compatible with Opal

Distribution Packages::

  * http://rubygems.org/gems/asciidoctor[RubyGem (asciidoctor)]
  * https://apps.fedoraproject.org/packages/rubygem-asciidoctor[Fedora (rubygem-asciidoctor)]
  * http://packages.debian.org/sid/asciidoctor[Debian (asciidoctor)]
  * http://packages.ubuntu.com/saucy/asciidoctor[Ubuntu (asciidoctor)]

https://github.com/asciidoctor/asciidoctor/issues?q=milestone%3Av1.5.2[issues resolved] |
https://github.com/asciidoctor/asciidoctor/releases/tag/v1.5.2[git tag] |
https://github.com/asciidoctor/asciidoctor/compare/v1.5.1...v1.5.2[full diff]
// end::compact[]

== 1.5.1 (2014-09-29) - @mojavelinux

Bug fixes::

  * recognize tag directives inside comments within XML files for including tagged regions
  * restore passthroughs inside footnotes when more than one footnote appears on the same line
  * -S flag in cli recognizes safe mode name as lowercase string
  * do not match # in character reference when looking for marked text
  * add namespace to lang attribute in DocBook 5 backend
  * restore missing space before conum on last line of listing when highlighting with Pygments
  * place conums on correct lines when line numbers are enabled when highlighting with Pygments
  * don't expand mailto links in print styles

Improvements::

  * implement File.read in Node (JavaScript) environment
  * assign sectnumlevels and toclevels values to maxdepth attribute on AsciiDoc processing instructions in DocBook output
  * add test for usage of image block macro with data URI
  * use badges from shields.io in README

Distribution Packages::

  * http://rubygems.org/gems/asciidoctor[RubyGem (asciidoctor)]
  * https://apps.fedoraproject.org/packages/rubygem-asciidoctor[Fedora (rubygem-asciidoctor)]
  * http://packages.debian.org/sid/asciidoctor[Debian (asciidoctor)]
  * http://packages.ubuntu.com/saucy/asciidoctor[Ubuntu (asciidoctor)]

https://github.com/asciidoctor/asciidoctor/issues?q=milestone%3Av1.5.1[issues resolved] |
https://github.com/asciidoctor/asciidoctor/releases/tag/v1.5.1[git tag] |
https://github.com/asciidoctor/asciidoctor/compare/v1.5.0...v1.5.1[full diff]

== 1.5.0 (2014-08-12) - @mojavelinux

Performance::

  * 10% increase in speed compared to 0.1.4
  * rewrite built-in converters in Ruby instead of ERB

Enhancements::

  * {star} introduce new curved quote syntax (pass:[""`double quotes`""], pass:['`single quotes`']) if compat-mode attribute not set (#1046)
  * {star} add single curved quote replacement for pass:[`'] (#715)
  * {star} use backtick (`) for monospaced text if compat-mode attribute not set (#714, #718)
  * {star} use single and double plus (pass:[+], pass:[++]) for inline passthrough if compat-mode attribute not set (#714, #718)
  * {star} disable single quotes as formatting marks for emphasized text if compat-mode attribute not set (#717)
  * {star} enable compat-mode by default if document has atx-style doctitle
  * {star} output phrase surrounded by # as marked text (i.e., <mark>) (#225)
  * {star} add MathJax integration and corresponding blocks and macros (#492, #760)
  * {star} switch to open source fonts (Open Sans, Noto Serif and Droid Sans Mono) in default stylesheet, major refinements to theme (#879)
  * {star} embed remote images when data-uri and allow-uri-read attributes are set (#612)
  * {star} support leveloffset on include directive and honor relative leveloffset values (#530)
  * {star} switch default docbook backend to docbook5 (@bk2204) (#554)
  * {star} added hide-uri-scheme attribute to hide uri scheme in automatic links (#800)
  * {star} allow substitutions to be incrementally added & removed (#522)
  * {star} add compatibility with Opal, add shim compat library, use compatibility regexp, require libraries properly (@mogztter) (#679, #836, #846)
  * {star} output XHTML when backend is xhtml or xhtml5 (#494)
  * {star} add shorthand subs and specialchars as an alias for specialcharacters (#579)
  * {star} deprecate toc2 attribute in favor of position and placement values on toc attribute (e.g., toc=left) (#706)
  * {star} add source map (file and line number) information to blocks (#861)
  * {star} write to file by default if input is file (#907)
  * {star} add -r and -I flags from ruby command to asciidoctor command for loading additional libraries (#574)
  * support backslash (\\) as line continuation character in the value of an attribute entry (#1022)
  * disable subs on pass block by default (#737)
  * add basic support for resolving xref target from reftext (#589)
  * add time range anchor to video element (#886)
  * match implicit URLs that use the file scheme (#853)
  * added sectnumlevels to control depth of section numbering (#549)
  * add hardbreaks option to block (#630)
  * sub attributes in manname (e.g., pass:[{docname}])
  * warn on reference to missing attribute if attribute-missing is ""warn""
  * only enable toc macro if toc is enabled and toc-placement attribute has the value macro (#706)
  * add sectnums attribute as alternative alias to numbered attribute (#684)

Improvements::

  * {star} don't select lines that contain a tag directive when including tagged lines, make tag regexp more strict (#1027)
  * {star} use https scheme for assets by default
  * {star} upgrade to Font Awesome 4.1 (@mogztter) (#752)
  * {star} improve print styles, add print styles for book doctype (@leif81) (#997, #952)
  * {star} add proper grid and frame styles for tables (@leif81) (#569)
  * {star} use glyphs for checkboxes when not using font icons (#878)
  * {star} prefer source-language attribute over language attribute for defining default source language (#888)
  * {star} pass document as first argument to process method on Preprocessor
  * don't parse link attributes when linkattrs is set unless text contains equal sign
  * detect bare links, mark with bare class; don't repeat URL of bare link in print styles
  * allow Treeprocessor#process method to replace tree (#1035)
  * add AbstractNode#find_by method to locate nodes in tree (#862)
  * add API for parsing title and subtitle (#1000)
  * add use_fallback option to doctitle, document method
  * constrain subscript & superscript markup (#564, #936)
  * match cell specs when cell separator is customized (#985)
  * use stylesheet to set default table width (#975)
  * display nested elements correctly in toc (@kenfinnigan) (#967)
  * add support for id attribute on links (@mogztter) (#935)
  * add support for title attribute on links (@aslakknutsen)
  * add -t flag to cli to control output of timing information (@mogztter) (#909)
  * rewrite converter API (#778)
  * rewrite extensions to support extension instances for AsciidoctorJ (#804)
  * integrate thread_safe gem (#638)
  * allow inline macro extensions that define a custom regexp to be matched (#792)
  * make Reader#push_include work with default file, path and dir (@bk2204) (#743)
  * honor custom outfilesuffix and introduce relfileprefix (#801)
  * add author and copyright to meta in HTML5 backend (#838)
  * output attribution in front of citetitle for quote and verse blocks
  * recognize float style with shorthand syntax outside block (#818)
  * honor background color in syntax highlighting themes (#813)
  * print runtime environment in version output, support -v as version flag (#785)
  * unwrap preamble if standalone (#533)
  * drop leading & trailing blank lines in verbatim & raw content (#724)
  * remove trailing endlines from source data (#727)
  * add flag to cli to suppress warnings (#557)
  * emit warning if tag(s) not found in include file (#639)
  * use <th> element for vertical table headers instead of header class (@davidgamba) (#738)
  * share select references between AsciiDoc-style cell & main document (#729)
  * number chapters sequentially, always (#685)
  * add vbar attribute, make brvbar resolve properly (#643)
  * add implicit user-home attribute that resolves to user's home directory (#629)
  * enable sidebar toc for small screens (#628)
  * add square brackets around button in HTML output (#631)
  * make language hover text work for all languages in listing block
  * set background color on toc2 to cover scrolling content (@neher)
  * make document parsing a discrete step, make Reader accessible as property on Document
  * allow custom converter to set backend info such as outfilesuffix and htmlsyntax
  * report an informative error message when a converter cannot be resolved (@mogztter)
  * add conum class to b element when icons are disabled, make conum CSS selector more specific
  * expose Document object to extension point IncludeProcessor (@aslakknutsen)
  * style audioblock title, simplify rules for block titles
  * alias :name_attributes to :positional_attributes in extension DSL
  * upgrade to highlight.js 7.4 (and later 8.0) (@mogztter) (#756)

Compliance::

  * only include xmlns in docbook45 backend if xmlns attribute is specified (#929)
  * add xmlns attribute for xhtml output (@bk2204)
  * warn if table without a body is converted to DocBook (#961)
  * wrap <para> around admonition inside example block in DocBook 4.5 (#931)
  * use <informalfigure> if block image doesn't have a title (#927)
  * fix invalid docbook when adding role to formatted text (#956)
  * move all compliance flags to Compliance module (#624)
  * add compliance setting to control use of shorthand property syntax (#789)
  * wrap top-level content inside preamble in DocBook backend when doctype is book (#971)
  * escape special chars in image alt text (#972)
  * set starting number in ordered list for docbook (@megathaum) (#925)
  * match word characters in regular expressions as defined by Unicode (#892)
  * put source language class names on child code element of pre element (#921)
  * ignore case of attribute in conditional directives (#903)
  * allow attribute entry to reset / reseed counter (#870)
  * allow doctype to be set in AsciiDoc table cell (#863)
  * match URL macro following entity (@jmbruel) (#819)
  * handle BOM when normalizing source (#824)
  * don't output revhistory if revdate is not set (#802)
  * perform normal subs on verse content (#799)
  * automatically wrap part intro content in partintro block, emit warning if part is invalid (#768)
  * force encoding of docinfo content to UTF-8 (#773)
  * add scaling & alignment attributes to block image in DocBook backend (#763)
  * add support for pass:[anchor:<id>[<reftext>\\]] macro (#531)
  * substitute anchor and xref macros in footnotes (#676)
  * remove all string mutation operations for compatibility with Opal (#735)
  * honor reftext defined in embedded section title anchor (#697)
  * allow spaces in reftext defined in block anchor (#695)
  * use reftext of section or block in text of xref link (#693)
  * number sections in appendix using appendix number (#683)
  * unescape escaped square closing bracket in footnote text (#677)
  * support quoted index terms that may contain commas (#597)
  * don't assign role attribute if quoted text has no roles (#647)
  * disallow quoted values in block and inline anchors
  * add % to scaledwidth if no units given
  * ignore block attribute with unquoted value None
  * preserve entity references with 5 digits

Bug Fixes::

  * resolve relative paths relative to base_dir in unsafe mode (#690)
  * properly handle nested passthroughs (#1034)
  * don't clobber outfilesuffix attribute if locked (#1024)
  * correctly calculate columns if colspan used in first row of table (#924)
  * pass theme to Pygments when pygments-css=style (#919)
  * fallback to text lexer when using pygments for source highlighting (#987)
  * only make special section if style is specified (#917)
  * an unresolved footnote ref should not crash processor (#876)
  * rescue failure to resolve ::Dir.home (#896)
  * recognize Windows UNC path as absolute and preserve it (#806)
  * adjust file glob to account for backslash in Windows paths (#805)
  * don't match e-mail address inside URL (#866)
  * test include directive resolves file with space in name (#798)
  * return nil from Reader#push_include and Reader#pop_include methods (#745)
  * fixed broken passthroughs caused by source highlighting (#720)
  * copy custom stylesheet if linkcss is set (#300)
  * honor list continuations for indented, nested list items (#664)
  * fix syntax errors in converters (@jljouannic)
  * fix iconfont-remote setting
  * fix syntax error (target -> node.target) in Docbook 5 converter (@jf647)
  * output and style HTML for toc macro correctly

Infrastructure::

  * add Ruby 2.1 to list of supported platforms
  * reenable rbx in Travis build
  * switch tests to minitest (@ktdreyer)
  * update RPM for Fedora Rawhide (@ktdreyer)
  * refactor unit tests so they work in RubyMine (@cmoulliard)
  * add preliminary benchmark files to repository (#1021)
  * clean out old fixtures from test suite (#960)
  * add initial Cucumber test infrastructure (#731)
  * use gem tasks from Bundler in Rakefile (#654)
  * build gemspec files using git ls-tree (#653)
  * use in-process web server for URI tests
  * update manpage to reflect updates in 1.5.0
  * rework README (@mogztter) (#651)

Distribution Packages::

  * http://rubygems.org/gems/asciidoctor[RubyGem (asciidoctor)]
  * https://apps.fedoraproject.org/packages/rubygem-asciidoctor[Fedora (rubygem-asciidoctor)]
  * http://packages.debian.org/sid/asciidoctor[Debian (asciidoctor)]
  * http://packages.ubuntu.com/saucy/asciidoctor[Ubuntu (asciidoctor)]

https://github.com/asciidoctor/asciidoctor/issues?milestone=8&state=closed[issues resolved] |
https://github.com/asciidoctor/asciidoctor/releases/tag/v1.5.0[git tag] |
https://github.com/asciidoctor/asciidoctor/compare/v0.1.4...v1.5.0[full diff]

== 0.1.4 (2013-09-05) - @mojavelinux

Performance::

  * 15% increase in speed compared to 0.1.3

Enhancements::

  * updated xref inline macro to support inter-document references (#417)
  * added extension API for document processing (#79)
  * added include directive processor extension (#100)
  * added id and role shorthand for formatted (quoted) text (#517)
  * added shorthand syntax for specifying block options (#481)
  * added support for checklists in unordered list (#200)
  * added support for inline style for unordered lists (#620)
  * added DocBook 5 backend (#411)
  * added docinfo option for footer (#486)
  * added Pygments as source highlighter option (pygments) (#538)
  * added icon inline macro (#529)
  * recognize implicit table header row (#387)
  * uri can be used in inline image (#470)
  * add float attribute to inline image (#616)
  * allow role to be specified on text enclosed in backticks (#419)
  * added XML comment-style callouts for use in XML listings (#582)
  * made callout bullets non-selectable in HTML output (#478)
  * pre-wrap literal blocks, added nowrap option to listing blocks (#303)
  * skip (retain) missing attribute references by default (#523)
  * added attribute-missing attribute to control how a missing attribute is handled (#495)
  * added attribute-undefined attribute to control how an undefined attribute is handled (#495)
  * permit !name syntax for undefining attribute (#498)
  * ignore front matter used by static site generators if skip-front-matter attribute is set (#502)
  * sanitize contents of HTML title element in html5 backend (#504)
  * support toc position for toc2 (#467)
  * cli accepts multiple files as input (@lordofthejars) (#227)
  * added Markdown-style horizontal rules and pass Markdown tests (#455)
  * added float clearing classes (.clearfix, .float-group) (#602)
  * don't disable syntax highlighting when explicit subs is used on listing block
  * asciidoctor package now available in Debian Sid and Ubuntu Saucy (@avtobiff) (#216)

Compliance::

  * embed CSS by default, copy stylesheet when linkcss is set unless copycss! is set (#428)
  * refactor reader to track include stack (#572)
  * made include directive resolve relative to current file (#572)
  * track include stack to enforce maximum depth (#581)
  * fixed greedy comment blocks and paragraphs (#546)
  * enable toc and numbered by default in DocBook backend (#540)
  * ignore comment lines when matching labeled list item (#524)
  * correctly parse footnotes that contain a URL (#506)
  * parse manpage metadata, output manpage-specific HTML, set docname and outfilesuffix (#488, #489)
  * recognize preprocessor directives on first line of AsciiDoc table cell (#453)
  * include directive can retrieve data from uri if allow-uri-read attribute is set (#445)
  * support escaping attribute list that precedes formatted (quoted) text (#421)
  * made improvements to list processing (#472, #469, #364)
  * support percentage for column widths (#465)
  * substitute attributes in docinfo files (#403)
  * numbering no longer increments on unnumbered sections (#393)
  * fixed false detection of list item with hyphen marker
  * skip include directives when processing comment blocks
  * added xmlns to root element in docbook45 backend, set noxmlns attribute to disable
  * added a Compliance module to control compliance-related behavior
  * added linkattrs feature to AsciiDoc compatibility file (#441)
  * added level-5 heading to AsciiDoc compatibility file (#388)
  * added new XML-based callouts to AsciiDoc compatibility file
  * added absolute and uri image target matching to AsciiDoc compatibility file
  * added float attribute on inline image macro to AsciiDoc compatibility file
  * removed linkcss in AsciiDoc compatibility file
  * fixed fenced code entry in compatibility file

Bug Fixes::

  * lowercase attribute names passed to API (#508)
  * numbered can still be toggled even when enabled in API (#393)
  * allow JRuby Map as attributes (#396)
  * don't attempt to highlight callouts when using CodeRay and Pygments (#534)
  * correctly calculate line length in Ruby 1.8 (#167)
  * write to specified outfile even when input is stdin (#500)
  * only split quote attribution on first comma in Markdown blockquotes (#389)
  * don't attempt to print render times when doc is not rendered
  * don't recognize line with four backticks as a fenced code block (#611)

Improvements::

  * upgraded Font Awesome to 3.2.1 (#451)
  * improved the built-in CodeRay theme to match Asciidoctor styles
  * link to CodeRay stylesheet if linkcss is set (#381)
  * style the video block (title & margin) (#590)
  * added Groovy, Clojure, Python and YAML to floating language hint
  * only process callouts for blocks in which callouts are found
  * added content_model to AbstractBlock, rename buffer to lines
  * use Untitled as document title in rendered output if document has no title
  * rename include-depth attribute to max-include-depth, set 64 as default value (#591)
  * the tag attribute can be used on the include directive to identify a single tagged region
  * output multiple authors in HTML backend (#399)
  * allow multiple template directories to be specified, document in usage and manpage (#437)
  * added option to cli to specify template engine (#406)
  * added support for external video hosting services in video block macro (@xcoulon) (#587)
  * strip leading separator(s) on section id if idprefix is blank (#551)
  * customized styling of toc placed inside body content (#507)
  * consolidate toc attribute so toc with or without toc-position can make sidebar toc (#618)
  * properly style floating images (inline & block) (#460)
  * add float attribute to inline images (#616)
  * use ul list for TOC in HTML5 backend (#431)
  * support multiple terms per labeled list item in model (#532)
  * added role?, has_role?, option? and roles methods to AbstractNode (#423, 474)
  * added captioned_title method to AbstractBlock
  * honor showtitle attribute as alternate to notitle! (#457)
  * strip leading indent from literal paragraph blocks assigned the style normal
  * only process lines in AsciiDoc files
  * emit message that tilt gem is required to use custom backends if missing (#433)
  * use attributes for version and last updated messages in footer (#596)
  * added a basic template cache (#438)
  * include line info in several of the warnings (for lists and tables)
  * print warning/error messages using warn (#556)
  * lines are not preprocessed when peeking ahead for section underline
  * introduced Cursor object to track line info
  * fixed table valign classes, no underline on image link
  * removed dependency on pending library, lock Nokogiri version to 1.5.10
  * removed require rubygems line in asciidoctor.rb, add to cli if RUBY_VERSION < 1.9
  * added tests for custom backends
  * added test that shorthand doesn't clobber explicit options (#481)
  * removed unnecessary monospace class from literal and listing blocks

Distribution Packages::

  * http://rubygems.org/gems/asciidoctor[RubyGem (asciidoctor)]
  * https://apps.fedoraproject.org/packages/rubygem-asciidoctor[Fedora (rubygem-asciidoctor)]
  * http://packages.debian.org/sid/asciidoctor[Debian (asciidoctor)]
  * http://packages.ubuntu.com/saucy/asciidoctor[Ubuntu (asciidoctor)]

https://github.com/asciidoctor/asciidoctor/issues?milestone=7&state=closed[issues resolved] |
https://github.com/asciidoctor/asciidoctor/releases/tag/v0.1.4[git tag] |
https://github.com/asciidoctor/asciidoctor/compare/v0.1.3...v0.1.4[full diff]

== 0.1.3 (2013-05-30) - @mojavelinux

Performance::

  * 10% increase in speed compared to 0.1.2

Enhancements::

  * added support for inline rendering by setting doctype to inline (#328)
  * added support for using font-based icons (#115)
  * honor haml/slim/jade-style shorthand for id and role attributes (#313)
  * support Markdown-style headings as section titles (#373)
  * support Markdown-style quote blocks
  * added section level 5 (maps to h6 element in the html5 backend) (#334)
  * added btn inline macro (#259)
  * added menu inline menu to identify a menu selection (@bleathem) (#173)
  * added kbd inline macro to identify a key or key combination (@bleathem) (#172)
  * support alternative quote forms (#196)
  * added indent attribute to verbatim blocks (#365)
  * added prettify source-highlighter (#202)
  * link section titles (#122)
  * introduce shorthand syntax for table format (#350)
  * parse attributes in link when use-link-attrs attribute is set (#214)
  * support preamble toc-placement (#295)
  * exclude attribute div if quote has no attribution (#309)
  * support attributes passed to API as string or string array (#289)
  * allow safe mode to be set using string, symbol or int in API (#290)
  * make level 0 section titles more prominent in TOC (#369)

Compliance::

  * ~ 99.5% compliance with AsciiDoc
  * drop line if target of include directive is blank (#376)
  * resolve attribute references in target of include directive (#367)
  * added irc scheme to link detection (#314)
  * toc should honor numbered attribute (#341)
  * added toc2 layout to default stylesheet (#285)
  * consecutive terms in labeled list share same entry (#315)
  * support set:name:value attribute syntax (#228)
  * block title not allowed above document title (#175)
  * assign caption even if no title (#321)
  * horizontal dlist layout in docbook backend (#298)
  * set doctitle attribute (#337)
  * allow any backend to be specified in cli (@lightguard) (#320)
  * support for abstract and partintro (#297)

Bug Fixes::

  * fixed file path resolution on Windows (#330)
  * fixed bad variable name that was causing crash, add test for it (#335)
  * set proper encoding on input data (#308)
  * don't leak doctitle into nested document (#382)
  * handle author(s) defined using attributes (#301)

Improvements::

  * added tests for all special sections (#80)
  * added test for attributes defined as string or string array (@lightguard) (#291)

Distribution Packages::

  * http://rubygems.org/gems/asciidoctor[RubyGem (asciidoctor)]
  * https://apps.fedoraproject.org/packages/rubygem-asciidoctor[Fedora (rubygem-asciidoctor)]

http://asciidoctor.org/news/2013/05/31/asciidoctor-0-1-3-released[release notes] |
https://github.com/asciidoctor/asciidoctor/issues?milestone=4&state=closed[issues resolved] |
https://github.com/asciidoctor/asciidoctor/releases/tag/v0.1.3[git tag] |
https://github.com/asciidoctor/asciidoctor/compare/v0.1.2...v0.1.3[full diff]

== 0.1.2 (2013-04-25) - @mojavelinux

Performance::

  * 28% increase in speed compared to 0.1.1, 32% increase compared to 0.1.0

Enhancements::

  * new website at http://asciidoctor.org
  * added a default stylesheet (#76)
  * added viewport meta tag for mobile browsers (#238)
  * set attributes based on safe mode (#244)
  * added admonition name as style class (#265)
  * removed hardcoded CSS, no one likes hardcoded CSS (#165)
  * support multiple authors in document header (#223)
  * include footnotes block in embedded document (#206)
  * allow comma delimiter in include attribute values (#226)
  * support including tagged lines (#226)
  * added line selection to include directive (#226)
  * Asciidoctor#render APIs return Document when document is written to file

Compliance::

  * added AsciiDoc compatibility file to make AsciiDoc behave like Asciidoctor (#257)
  * restore alpha-based xml entities (#211)
  * implement video and audio block macros (#155)
  * implement toc block macro (#269)
  * correctly handle multi-part books (#222)
  * complete masquerade functionality for blocks & paragraphs (#187)
  * support explicit subs on blocks (#220)
  * use code element instead of tt (#260)
  * honor toc2 attribute (#221)
  * implement leveloffset feature (#212)
  * include docinfo files in header when safe mode < SERVER (#116)
  * support email links and mailto inline macros (#213)
  * question must be wrapped in simpara (#231)
  * allow round bracket in link (#218)

Bug Fixes::

  * trailing comma shouldn't be included in link (#280)
  * warn if file in include directive doesn't exist (#262)
  * negative case for inline ifndef should only affect current line (#241)
  * don't compact nested documents (#217)
  * nest revision info inside revision element (#236)

Distribution Packages::

  * http://rubygems.org/gems/asciidoctor[RubyGem (asciidoctor)]

http://asciidoctor.org/news/2013/04/25/asciidoctor-0-1-2-released[release notes] |
https://github.com/asciidoctor/asciidoctor/issues?milestone=3&state=closed[issues resolved] |
https://github.com/asciidoctor/asciidoctor/releases/tag/v0.1.2[git tag] |
https://github.com/asciidoctor/asciidoctor/compare/v0.1.1...v0.1.2[full diff]

== 0.1.1 (2013-02-26) - @erebor

Performance::

  * 15% increase in speed compared to 0.1.0

Enhancements::

  * migrated repository to asciidoctor organization on GitHub (#77)
  * include document title when header/footer disabled and notitle attribute is unset (#103)
  * honor GitHub-flavored Markdown fenced code blocks (#118)
  * added :doctype and :backend keys to options hash in API (#163)
  * added :to_dir option to the Asciidoctor#render API
  * added option :header_only to stop parsing after reading the header
  * preliminary line number tracking
  * auto-select backend sub-folder containing custom templates
  * rubygem-asciidoctor package now available in Fedora (#92)

Compliance::

  * refactor reader, process attribute entries and conditional blocks while parsing (#143)
  * support limited value comparison functionality of ifeval (#83)
  * added support for multiple attributes in ifdef and ifndef directives
  * don't attempt to embed image with uri reference when data-uri is set (#157)
  * accomodate trailing dot in author name (#156)
  * don't hardcode language attribute in html backend (#185)
  * removed language from DocBook root node (#188)
  * fixed revinfo line swallowing attribute entry
  * auto-generate caption for listing blocks if listing-caption attribute is set
  * support nested includes
  * support literal and listing paragraphs
  * support em dash shorthand at the end of a line
  * added ftp support to link inline macro
  * added support for the page break block macro

Bug Fixes::

  * pass through image with uri reference when data-uri is set (#157)
  * print message for failed arg (#152)
  * normalize whitespace at the end of lines (improved)
  * properly load custom templates and required libraries

Improvements::

  * parse document header in distinct parsing step
  * moved hardcoded english captions to attributes

Distribution Packages::

  * http://rubygems.org/gems/asciidoctor[RubyGem (asciidoctor)]

https://github.com/asciidoctor/asciidoctor/issues?milestone=1&state=closed[issues resolved] |
https://github.com/asciidoctor/asciidoctor/releases/tag/v0.1.1[git tag] |
https://github.com/asciidoctor/asciidoctor/compare/v0.1.0...v0.1.1[full diff]

== 0.1.0 (2013-02-04) - @erebor

Enhancements::

  * introduced Asciidoctor API (Asciidoctor#load and Asciidoctor#render methods) (#34)
  * added SERVER safe mode level (minimum recommended security for serverside usage) (#93)
  * added the asciidoctor commandline interface (cli)
  * added asciidoctor-safe command, enables safe mode by default
  * added man page for the asciidoctor command
  * use blockquote tag for quote block content (#124)
  * added hardbreaks option to preserve line breaks in paragraph text (#119)
  * :header_footer option defaults to false when using the API, unless rendering to file
  * added idseparator attribute to customized separator used in generated section ids
  * do not number special sections (differs from AsciiDoc)

Compliance::

  * use callout icons if icons are enabled, unless safe mode is SECURE
  * added support for name=value@ attribute syntax passed via cli (#97)
  * attr refs no longer case sensitive (#109)
  * fixed several cases of incorrect list handling
  * don't allow links to consume endlines or surrounding angled brackets
  * recognize single quote in author name
  * support horizontal labeled list style
  * added support for the d cell style
  * added support for bibliography anchors
  * added support for special sections (e.g., appendix)
  * added support for index term inline macros
  * added support for footnote and footnoteref inline macros
  * added auto-generated numbered captions for figures, tables and examples
  * added counter inline macros
  * added support for floating (discrete) section titles

Bug Fixes::

  * fixed UTF-8 encoding issue by adding magic encoding line to ERB templates (#144)
  * resolved Windows compatibility issues
  * clean CRLF from end of lines (#125)
  * enabled warnings when running tests, fixed warnings (#69)

Improvements::

  * renamed iconstype attribute to icontype

Distribution Packages::

  * http://rubygems.org/gems/asciidoctor[RubyGem (asciidoctor)]

https://github.com/asciidoctor/asciidoctor/issues?milestone=12&state=closed[issues resolved] |
https://github.com/asciidoctor/asciidoctor/releases/tag/v0.1.0[git tag] |
https://github.com/asciidoctor/asciidoctor/compare/v0.0.9...v0.1.0[full diff]

== Older releases (pre-0.0.1)

For information about older releases, refer to the https://github.com/asciidoctor/asciidoctor/tags[commit history] on GitHub.
",12092,True,2686.451255200877,median
"namespace openstudio {
namespace model {

/** \\mainpage OpenStudio Model
 *
 *  \\section overview_model Overview
 *
 *  An OpenStudio Model (\\ref introduction_model) represents a single building energy model,
 *  either complete (simulatable with EnergyPlus) or partial. It is composed of a collection of
 *  \\link ModelObject ModelObjects \\endlink (\\ref modelobject), which are polymorphic, that is,
 *  ModelObject is the base class from which more specific object types are derived. Each leaf of
 *  the inheritance tree wraps a specific data object type that is ultimately defined by the
 *  OpenStudio.idd file. The following classes form the foundation of the OpenStudio Model:
 *
 *  \\li Model
 *  \\li Component
 *  \\li ModelObject
 *  \\li ParentObject
 *  \\li ResourceObject
 *
 *  The specific model object types can largely be broken down into the categories of simulation
 *  settings; output data; resources; site and location; geometry; building loads; advanced daylighting;
 *  heating, ventilation and air conditioning (HVAC) systems;
 *  economics; and standards. We will now list the most important classes in each of these
 *  categories. The lists are not meant to be exhaustive, but rather to give an intuitive sense
 *  of what is and is not currently covered by the OpenStudio Model. Throughout, some of the
 *  classes will be concrete (have a one-to-one mapping with an object in OpenStudio.idd), and
 *  some will be abstract (provide a higher level interface to multiple Idd objects).
 *
 *  \\subsection simulation_settings_classes Simulation Settings
 *
 *  \\li Version
 *  \\li YearDescription
 *  \\li SimulationControl
 *  \\li LightingSimulationControl
 *  \\li Timestep
 *  \\li RunPeriod
 *  \\li ConvergenceLimits
 *  \\li SizingParameters
 *
 *  \\subsection output_data_classes Output Data
 *
 *  \\li Meter
 *  \\li OutputVariable
 *
 *  \\subsection resource_classes Resources
 *
 *  \\li Schedule
 *  \\li ScheduleTypeLimits
 *  \\li DefaultScheduleSet
 *  \\li Construction
 *  \\li DefaultConstructionSet
 *  \\li OpaqueMaterial
 *  \\li FenestrationMaterial
 *  \\li ModelPartitionMaterial
 *  \\li SpaceType
 *  \\li ElectricEquipmentDefinition
 *  \\li GasEquipmentDefinition
 *  \\li InternalMassDefinition
 *  \\li LightsDefinition
 *  \\li LuminaireDefinition
 *  \\li PeopleDefinition
 *  \\li ExteriorLightsDefinition
 *  \\li ExteriorFuelEquipmentDefinition
 *  \\li ExteriorWaterEquipmentDefinition
 *
 *  \\subsection site_location_classes Site and Location
 *
 *  \\li Site
 *  \\li DesignDay
 *  \\li LightingDesignDay
 *  \\li WeatherFile
 *  \\li SiteWaterMainsTemperature
 *
 *  \\subsection geometry_classes Geometry
 *
 *  \\li Facility
 *  \\li Building
 *  \\li BuildingStory
 *  \\li Space
 *  \\li Surface
 *  \\li SubSurface
 *  \\li ShadingSurfaceGroup
 *  \\li ShadingSurface
 *  \\li InteriorPartitionSurfaceGroup
 *  \\li InteriorPartitionSurface
 *
 *  \\subsection building_loads_classes Building Loads
 *
 *  \\li ElectricEquipment
 *  \\li GasEquipment
 *  \\li InternalMass
 *  \\li Lights
 *  \\li Luminaire
 *  \\li People
 *  \\li SpaceInfiltrationDesignFlowRate
 *  \\li DesignSpecificationOutdoorAir
 *  \\li ExteriorLights
 *  \\li ExteriorFuelEquipment
 *  \\li ExteriorWaterEquipment
 *
 *  \\subsection advanced_daylighting_classes Advanced Daylighting
 *
 *  \\li DaylightingControl
 *  \\li GlareSensor
 *  \\li IlluminanceMap
 *  \\li DaylightingDeviceShelf
 *  \\li LightingSimulationZone
 *
 *  \\subsection hvac_classes HVAC Systems
 *
 *  \\li AirLoopHVAC
 *  \\li PlantLoop
 *  \\li ThermalZone
 *  \\li SizingZone
 *  \\li SizingSystem
 *  \\li Splitter
 *  \\li Mixer
 *  \\li Node
 *  \\li HVACComponent
 *  \\li ZoneHVACComponent
 *  \\li StraightComponent
 *  \\li WaterToAirComponent
 *  \\li Curve
 *  \\li ThermostatSetpointDualSetpoint
 *  \\li AvailabilityManagerScheduled
 *  \\li ControllerMechanicalVentilation
 *  \\li ControllerOutdoorAir
 *  \\li ControllerWaterCoil
 *
 *  \\subsection economics_classes Economics
 *
 *  This subsection of the model is not fully developed. Classes like ComponentCost_LineItem
 *  are available, but we expect to do a full refactor of this area of
 *  the model as time allows.
 *
 *  \\subsection standards_classes Standards
 *
 *  This subsection of the model is not fully developed. BuildingStandardsInformation,
 *  ConstructionBaseStandardsInformation, and ClimateZones are examples of this type
 *  of object.
 *
 *  \\subsection other_links Other Links
 *
 *  The following links may also be of general interest:
 *
 *  \\li \\ref components
 *  \\li \\link ConcreteModelObjects.hpp Alphabetical List of Concrete ModelObjects \\endlink
 *  \\li \\ref modelobject_hierachy ""Concrete ModelObjects in Parent-Child Tree""
 *
 *  \\section introduction_model What is the Openstudio Model?
 *
 *  The OpenStudio Model is a hierarchical, object-oriented model of a partial or complete building
 *  that exists to support annual energy and other simulations and related analyses. Complete
 *  building models may be simulated with EnergyPlus, which is developed by the Department of Energy
 *  and is our primary simulation target (http://apps1.eere.energy.gov/buildings/energyplus/).
 *  Daylighting simulation with Radiance is also supported, and OpenStudio can conduct some economic
 *  analyses natively. The OpenStudio Model aims to integrate input and output data into a seamless
 *  whole. EnergyPlus output data is accessed through the Model by connecting to an appropriate SqlFile (see the
 *  utilities documentation), which provides a basic interface to the EnergyPlus SQLite output. Once
 *  the basic connection to an output file is established, intuitive interfaces to specific pieces of
 *  output data are provided at the object level. For instance, see Facility, ThermalZone,
 *  and \\ref modelobjectOutputDataAccessMethods.
 *
 *  \\subsection underlying_data Foundation: Data Model
 *
 *  The underlying input data for Model is adapted from the EnergyPlus IDD/IDF file formats, where
 *  an IDD (input data definition) file is a data schema, analogous to an XML Schema file, and an
 *  IDF (input data file) is an instantiation of that schema, analogous to an XML file. The
 *  OpenStudio IDD has been developed using a subset of objects in the EnergyPlus IDD as a starting point so
 *  that OpenStudio can directly leverage EnergyPlus's numerous and extensively documented data
 *  objects.  Over time the OpenStudio IDD has grown to include more objects from the EnergyPlus IDD, with a
 *  focus on including the most important types for energy simulation first.  Additionally, new object types
 *  have been added to the OpenStudio IDD to provide functionalities such as:
 *
 *  <ol>
 *    <li> File/run management ('OS:WeatherFile', WeatherFile)</li>
 *    <li> Output data integration ('OS:Facility', Facility)</li>
 *    <li> Radiance integration ('OS:Luminaire', Luminaire)</li>
 *    <li> HVAC abstractions ('OS:Node', Node)</li>
 *    <li> Data sharing ('OS:ComponentData', ComponentData, Component)</li>
 *    <li> Codes and standards support ('OS:ClimateZones', ClimateZones;
 *         'OS:StandardsInforamtion:Building', BuildingStandardsInformation)</li>
 *  </ol>
 *
 *  Each OpenStudio IDD object is wrapped by a corresponding ModelObject which provides an intelligent API for working
 *  with that data object in an OpenStudio Model.
 *
 *  \\link Model Models\\endlink are serialized to files with the extension '.osm', which are
 *  instance files of the OpenStudio data schema. OSM files are clear text and look very similar
 *  to IDF.
 *
 *  \\subsection object_model Raison D'Etre: Object Model
 *
 *  The last thing the building energy modeling community needs is yet another data model. So why
 *  did we create the OpenStudio Model?
 *
 *  <b>To harness object-oriented programming techniques to provide a powerful interface for
 *  building energy modeling at all fidelity levels, for various software development and user
 *  communities.</b>
 *
 *  By formalizing relationships among data objects (\\ref modelobjectRelationships); and by placing
 *  high-level, big-knob methods in appropriate data objects (\\ref modelobjectCompoundMethods); by
 *  making it possible to access related input and output data from the same location ( \\ref
 *  modelobjectOutputDataAccessMethods); and by supporting multiple types of simulation engines,
 *  the OpenStudio Model provides a number of advantages over direct manipulation and analysis of
 *  EnergyPlus input and output formats.
 *
 *  \\subsection model_implementation Implementation Details
 *
 *  Model serves as a container for \\link ModelObject ModelObjects \\endlink and a SqlFile. Model
 *  inherits its functionality for storing and querying objects from openstudio::Workspace, which is
 *  essentially an in-memory, custom database for openstudio::WorkspaceObject. The hierarchy of
 *  object types will be described in full in \\ref object_implementation. For now it is important
 *  to note that all of Workspace's methods (listed in the utilities documentation) are also
 *  available to Model. Ideally, the underlying Workspace methods should only be called in model .cpp files; Model and ModelObject provides
 *  methods for adding and removing objects with more built in intelligence. However, the basic
 *  getters (e.g., getObjectByNameAndReference) and query methods (e.g., numObjects,
 *  numObjectsOfType) may be of general interest.
 *
 *  Model is implemented using the pImpl (pointer to implementation) idiom. In this pattern, each
 *  public class (e.g. openstudio::model::Model) holds a pointer to an
 *  implementation class (e.g.
 *  openstudio::model::detail::Model_Impl) that actually holds the object data and implements its
 *  methods. The public classes forward almost all user requests to the implementation class. This
 *  idiom was adopted because it results in data sharing between copies of public class instances,
 *  without the need for exposed pointers; and because it provides consistency of interface across
 *  native C++ and the SWIG bindings. (At this time, the OpenStudio SDK is available in Ruby and
 *  C#, in addition to C++, by way of SWIG.)
 *
 *  Example of data sharing:
 *
 *  \\code
 *  openstudio::path modelPath = toPath(pathString);
 *  OptionalModel oModel = Model::load(modelPath);
 *  if (oModel) {
 *    Model model = *oModel;     // model accesses the same data as *oModel or oModel->
 *    Model anotherCopy = model; // anotherCopy accesses the same data as model
 *    Building buildingObject = model.getUniqueModelObject<Building>();
 *    // now all of these asserts will pass, because every copy of the model public object provides
 *    // access to the same Building object
 *    OS_ASSERT(model.numObjects() == 1u);
 *    OS_ASSERT(model.numObjects() == anotherCopy.numObjects());
 *    OS_ASSERT(model.numObjects() == oModel->numObjects());
 *    // the equality operator tests for whether two public objects point to the exact same
 *    // implementation object
 *    OS_ASSERT(buildingObject == anotherCopy.getUniqueModelObject<Building>());
 *  }
 *  \\endcode
 *
 *  \\section modelobject What is a ModelObject?
 *
 *  At its most basic, ModelObject is the OpenStudio class that represents an IDF object. Just
 *  like a text IDF object, it consists of a number of ordered string fields, some of which may be
 *  in extensible groups, and all of which conform to the corresponding IDD object. Please see the
 *  utilities IDD and IDF documentation (specifically openstudio::IddObject,
 *  openstudio::ExtensibleIndex, and openstudio::IdfObject) for more information. \\link ModelObject
 *  ModelObjects \\endlink are always owned by/live in a containing Model, which makes it possible
 *  for \\link ModelObject ModelObjects \\endlink to point to each other in a meaningful way, even
 *  when multiple \\link Model Models \\endlink are being operated on side-by-side.
 *
 *  Although, strictly speaking, ModelObject provides access to its underlying string fields, a user
 *  of the OpenStudio SDK should not need to resort to that low-level interface in most
 *  circumstances. ModelObject is the base class for a large inheritance hierarchy, the terminating
 *  nodes of which each wrap a specific object in the OpenStudio IDD. Each data field that should
 *  be publicly accessible is wrapped into a getter and a setter method (see \\ref
 *  modelobjectGetSet), several types of \\ref modelobjectCompoundMethods and \\ref
 *  modelobjectOutputDataAccessMethods are provided, as are object getters and setters appropriate
 *  to the various \\ref modelobjectRelationships in the Model. Methods for creating and deleting
 *  data are also provided and available through a uniform interface, see \\ref modelobjectKeyBehaviors.
 *
 *  At this time, \\link ModelObject ModelObjects \\endlink are uniquely identifiable by their
 *  IddObjectType and name. \\link ModelObject ModelObjects \\endlink also have a unique handle that
 *  is available and used in memory, but is currently not serialized to file. A number of objects
 *  are unique in a given model. Unique objects may or may not have a name, as a name is not strictly
 *  necessary for identification. For example:
 *
 *  \\code
 *  Model model;
 *  Building building = model.getUniqueModelObject<Building>();
 *  OptionalString oName = building.name();
 *  OS_ASSERT(oName); // passes, because Building has a name
 *  Version version = model.getUniqueModelObject<Version>();
 *  oName = version.name();
 *  OS_ASSERT(!oName); // passes, because Version does not have (and does not need) a name
 *  \\endcode
 *
 *  ModelObjects of different types can share a name as long as they are not be in the same IDD
 *  reference list; ModelObjects of the same IddObjectType cannot.
 *
 *  \\subsection modelobjectGetSet Field Getters and Setters
 *
 *  \\todo The OpenStudio development team is currently in the process of fully implementing these
 *  coding standards.
 *
 *  Every data field that the user should be able to directly manipulate (possibly with side effects,
 *  as in Lights::setLightingLevel), is exposed through getter and setter methods tailored to the
 *  specifics of that field as specified by the IDD. For instance, the IDD slash code '\\\\type real'
 *  results in getters and setters on double or boost::optional<double>. The name of the field
 *  is generated off of the IDD field name, keeping the names as close to the same as possible, but
 *  removing non-word characters, and transforming to lower camel case. Fields that point to other
 *  objects (\\\\type object-list) are not exposed in quite the same way, see
 *  \\ref modelobjectRelationships.
 *
 *  By maintaining the field names defined in the IDD, and by listing the name of the IDD object
 *  wrapped by a given ModelObject in each \\link ConcreteModelObjects.hpp concrete object's\\endlink
 *  documentation, we maintain a link with the EnergyPlus Input-Output reference for those \\link
 *  ModelObject ModelObjects \\endlink that directly or essentially wrap a particular EnergyPlus IDD
 *  object. We therefore do not provide detailed documentation for these methods, unless the field
 *  was introduced by the OpenStudio IDD. However, side effects, like multiple fields being touched
 *  by one setter, are documented.
 *
 *  Data fields in extensible groups also have getters and setters, but may be exposed in different
 *  ways, for instance, in a getter that takes the extensible group's index as an argument
 *  (e.g., GasMixture::getGasType, GasMixture::setGasType), as part of a class that derives from
 *  ModelExtensibleGroup (e.g. ClimateZone), or through the introduction of a specialized data
 *  structure (e.g. PlanarSurface::vertices, PlanarSurface::setVertices). Classes that derive from
 *  ModelExtensibleGroup are generally preferred, as they let the extensible groups be dealt with
 *  on their own terms as individual objects. An exception to this is the case where there are just
 *  a few simple pieces of data in the group, then a small struct (like the one used by
 *  PlanarSurface::vertices) may be preferable. A ModelObject with a companion ModelExtensibleGroup
 *  should provide a wrapper method for numExtensibleGroups with the name of the ModelExtesibleGroup
 *  derived class replacing ""ExtensibleGroups"", and similar wrappers for getExtensibleGroup,
 *  extensibleGroups, clearExtensibleGroups and pushExtensibleGroup (perhaps replacing ""push"" with
 *  ""add""), at a minimum.
 *
 *  \\todo Streamline the Idf and Workspace-level ExtensibleGroup interface and port any applicable
 *  changes over to Model.
 *
 *  In general, we make the following translations from IDD slash codes to C++ syntax.
 *
 *  \\subsubsection allDataFields All Data Fields
 *
 *  IDD fields that are '\\\\required' are provided in the object constructors, and are
 *  always returned by value (double, int, or std::string, as opposed to boost::optional<double>,
 *  boost::optional<int>, or boost::optional<std::string>, respectively), unless the field can accept
 *  different data types (as is the case with '\\\\autocalculatable' and '\\\\autosizable' fields). IDD
 *  fields with '\\\\default' values are also returned by value if the field can only accept one data
 *  type (e.g. it is not '\\\\autocalculatable' or '\\\\autosizable'). Note that some fields in the EnergyPlus
 *  IDD are marked as '\\\\required' and '\\\\default', this is logically inconsistent so these fields are treated
 *  as if they were marked only as '\\\\default' and not as '\\\\required'.  It is preferable to mark fields as
 *  '\\\\default' in the OpenStudio IDD if there is a suitable default value instead of providing default
 *  arguments to the ModelObject constructor.
 *
 *  If, the field is not required and does not have a default or the field can contain
 *  multiple data types (e.g. such as '\\\\autocalculatable' or '\\\\autosizable' fields), the return value is wrapped in a boost::optional. If such an optional
 *  return value evaluates to false, then there is no underlying data, and the user must not
 *  dereference the optional container. If the return value evaluates to true, the actual returned
 *  data may be accessed by dereferencing with '*' or '->', for example:
 *
 *  \\code
 *  Model model;
 *  Lights lights(model); // by default, sets lightingLevel to 0 W
 *  // OptionalDouble is typedef for boost::optional<double> provided in utilities/core/Optional.hpp
 *  OptionalDouble oLightingLevel = lights.lightingLevel();
 *  OS_ASSERT(oLightingLevel);
 *  double lightingLevel = *oLightingLevel; // or oLightingLevel.get()
 *  std::cout << ""Default lighting level for a new Lights object is "" << lightingLevel << "" W."";
 *  \\endcode
 *
 *  If the user goes around the Model getter and setter methods by hand editing files or using the
 *  WorkspaceObject interface directly, it is possible to break the return-by-value getters, in
 *  which case a fatal error will be logged, and an openstudio::Exception will be thrown. To make it
 *  clear to a user when a default value is set (the underlying field is empty), fields with default
 *  values are provided with a query bool [fieldName]IsSetToDefault() const.
 *
 *  If it is possible for a setter to fail, the setter will return a boolean to indicate success
 *  (true) or failure (false). Otherwise, the return type will be void, and the user can trust that
 *  the specified action will execute as expected.
 *
 *  \\subsubsection numericFields Numeric Fields
 *
 *  Numeric fields are based on the C++ data types double (if '\\\\type real') or int (if
 *  '\\\\type integer'). The getters return a value if the field is required or has a numeric default, and is not
 *  '\\\\autocalculatable' or '\\\\autosizable'; and return an optional otherwise. The setters accept a
 *  double or int depending on the appropriate type. If the IDD specifies a minimum or maximum value then
 *  setter may fail and thus returns a bool; otherwise the set operation cannot fail and void is returned.
 *  If the field has a default, the user can check if the field is defaulted using [fieldName]IsSetToDefault,
 *  the user can set the field to default value using set[FieldName]ToDefault. If the field has can be autocalculated,
 *  the user can check if the field is autocalculated using [fieldName]IsSetToAutocalculate,
 *  the user can set the field to autocalculate using set[FieldName]ToAutocalculate.
 *
 *  \\todo Implement autosize/autocalculate getters and setters.
 *
 *  \\subsubsection choiceFields Choice Fields
 *
 *  Fields of '\\\\type choice' are IDD defined enumerations. Originally, enum classes were used for choice fields.
 *  However, those classes greatly increased the size of the Model library. Therefore, the following rules were
 *  developed.
 *
 *  If the IddKeys associated with
 *  a choice field are (case-insensitive) 'Yes'/'No', 'On'/'Off', or 'True'/'False'; then the OpenStudo getters and setters use bool
 *  values. Two additional methods 'std::string [fieldName]String() const' and 'bool set[FieldName]String(const std::string&)' are provided
 *  if the user needs to work with the string values.  The general rules concerning getter return values, and setter return values apply to
 *  string versions of the field getters and setters. The general rules concerning default fields apply to the bool version of the getter and setter.
 *  However the bool setters cannot fail, and so always return void.  Finally, if there is no default value and the field is not required
 *  the bool getter will return a boost::optional<bool> the user must be careful not to confuse whether this optional is initialized with
 *  the actual value of the field.
 *
 *  Other choice fields operate solely off of std::string. The allowable values are case insensitive,
 *  defined by the IDD and exposed through static methods like Gas::validGasTypes(). The setters can
 *  always fail; whether a boost::optional<std::string> is returned by the getter or accepted by the
 *  setter conforms to the general rules.
 *
 *  \\todo Return OptionalString() for unset choice fields (rather than empty strings)?
 *
 *  \\subsubsection urlFields URL Fields
 *
 *  The OpenStudio IDD introduces the '\\\\type url' field to help with locating files other than the
 *  OSM on which a simulation depends. (See WeatherFile for instance.)
 *  RunManager provides functionality to normalize url fields at job creation time.  RunManager
 *  looks for the file across all URLSearchPaths (see utilities documentation) passed in to the
 *  job creation. In this process, if the referenced file can be found, RunManager ensures that the
 *  file is copied to the local computer running the job and that the url field is set to a valid
 *  absolute path to that file for all child jobs (the url field is unchanged in the original input
 *  Model). If the field immediately following a url field is named 'Checksum' and is of type alpha,
 *  that field contains a checksum (computed by openstudio::checksum()) that RunManager uses to
 *  verify that the file found is the desired file. External files may be referenced using url
 *  fields in several ways:
 *
 *  \\li The url field may contain a single file name (e.g. 'Chicago.epw'). URLSearchPaths are used
 *      to look for relative urls and may be specified as relative to the job's working directory
 *      or to the original input Model.
 *
 *  \\li The url field may contain a relative file path (e.g. '../../Chicago.epw'). URLSearchPaths
 *      are used to look for relative urls and may be specified as relative to the job's working
 *      directory or to the original input Model.
 *
 *  \\li The url field may contain an absolute file path (e.g. 'C:/weatherData/Chicago.epw' or
 *      '/weatherData/Chicago.epw'). URLSearchPaths are not used to look for absolute file paths.
 *
 *  \\li The url field may contain an absolute url (e.g. 'file://C:/weatherData/Chicago.epw' or
 *      'http://www.weatherdata.org/Chicago.epw'). URLSearchPaths are not used to look for absolute
 *      urls.
 *
 *  \\li The url field may contain the UUID of a file in a Building Component Library (e.g.
 *      '{550e8400-e29b-41d4-a716-446655440000}'). (This is not yet implemented).
 *
 *  Url fields are implemented with two overloaded set methods which each return void; one taking
 *  a string and one taking an openstudio::path. The get method returns a
 *  string.  Normal rules for required and default fields apply.
 *
 *  \\subsubsection otherFields Other Fields
 *
 *  All other types of fields ('\\\\type alpha' or '\\\\type external-list') are treated as strings and
 *  conform to the general rules.
 *
 *  \\todo Return OptionalString() for unset string fields (rather than empty strings)?
 *
 *  An extended example of data field getter and setter usage:
 *
 *  \\code
 *  Model model;
 *  ScheduleCompact scheduleCompact(model);
 *
 *  //the curve
 *  CurveBiquadratic ccFofT(model);
 *  CurveBiquadratic eirFofT(model);
 *  CurveQuadratic ccFofF(model);
 *  CurveQuadratic eirFofF(model);
 *  CurveQuadratic plf(model);
 *
 *  ccFofT.setCoefficient1Constant(1.0);
 *  ccFofT.setCoefficient2x(2.0);
 *  ccFofT.setCoefficient3xPOW2(3.0);
 *  ccFofT.setCoefficient4y(4.0);
 *  ccFofT.setCoefficient5yPOW2(5.0);
 *  ccFofT.setCoefficient6xTIMESY(6.0);
 *  ccFofT.setMinimumValueofx(-10.0);
 *  ccFofT.setMaximumValueofx(100.03);
 *  ccFofT.setMinimumValueofy(-99999);
 *  ccFofT.setMaximumValueofy(100232);
 *  ccFofT.setMinimumCurveOutput(-1000);
 *  ccFofT.setMaximumCurveOutput(99999);
 *  ccFofT.setInputUnitTypeforX(""Temperature"");
 *  ccFofT.setOutputUnitType(""MassFlow"");
 *
 *  CoilCoolingDXSingleSpeed cool(model,
 *                                scheduleCompact,
 *                                ccFofT,
 *                                ccFofF,
 *                                eirFofT,
 *                                eirFofF,
 *                                plf);
 *
 *  Schedule s = cool.getAvailabilitySchedule();
 *  OS_ASSERT(s == scheduleCompact)
 *  OptionalDouble od;
 *  cool.setRatedTotalCoolingCapacity(od); // set to ""AutoCalculate""
 *
 *  // this passes because the constructor set it to ""AirCooled""for you.
 *  OS_ASSERT(cool.getCondenserType() == ""AiRCoolEd"")
 *
 *  OptionalSchedule s2 = cool.getBasinHeaterOperatingSchedule();
 *  OS_ASSERT(!s2)
 *  // s2 evaluates to false because this schedule is not required and not set
 *  \\endcode
 *
 *  \\subsection modelobjectCompoundMethods Compound Methods
 *
 *  OpenStudio \\link ModelObject ModelObjects \\endlink provide ""big knob"" compound methods to enable
 *  high-level modeling and various types of analysis (perturbation, optimization, standards, etc.)
 *  For example, Space::lightingPowerPerFloorArea calculates lighting power in the space by adding up
 *  lighting power from all Lights and Luminaire objects directly assigned to the space or it's space type,
 *  then dividing by the floor area of these space. Furthermore,
 *  that method, and the Space compound ""getter"" that corresponds to it are wrapped up together in
 *  an Attribute named ""lightingPowerDensity"" available through the ModelObject::getAttribute
 *  interface.
 *
 *  PlanarSurface::uFactor and PlanarSurface::setUFactor (and the associated Attribute) is another
 *  example that brings a lot of pieces together to expose a high-level piece of data. Depending on
 *  the underlying construction type, these methods may operate directly on a SimpleGlazing object;
 *  may use static film resistance data in conjunction with one or more Material objects, and maybe
 *  a ConstructionBaseStandardsInformation object (the latter is sometimes needed for the u-factor
 *  setter); or may query the output data in the SqlFile. If u-factor is available through input and
 *  output data, the output data is returned, but in the meantime the two values are compared and a
 *  message is logged if their difference exceeds some tolerance. Related methods are available
 *  through ConstructionBase.
 *
 *  Several objects include a number of methods (some static) provided to give the user access to
 *  basic physical information used in EnergyPlus or in building energy standards. The film
 *  resistances alluded to above are available through PlanarSurface::filmResistance and
 *  PlanarSurface::stillAirFilmResistance. Physical properties of gases commonly found in
 *  multi-paned windows are available from FenestrationMaterial.
 *
 *  Overall, the compound methods are difficult to characterize as a whole. We encourage users to
 *  peruse the documentation for each individual object in which they have an interest. Compound
 *  methods are generally listed outside of the ""Getters"" and ""Setters"" sections, even though some
 *  methods' functionality will be similar to a get or a set. In general, these methods should be
 *  well documented since they are native to OpenStudio.
 *
 *  \\subsection modelobjectOutputDataAccessMethods Output Data Access Methods
 *
 *  The model.setSqlFile(const SqlFile& sqlFile) method is used to attach a Model to related EnergyPlus
 *  simulation output.  Because the OpenStudio Model must be translated to EnergyPlus IDF for simulation, the
 *  results of the EnergyPlus simulation will not map exactly to the Model.  However, the Model will perform
 *  some checks to verify that the given SqlFile does relate to the given Model, the setSqlFile operation will
 *  fail if these checks are not satisfied.  If model.sqlFile() evaluates to true, then a given model is hooked
 *  up to its EnergyPlus simulation output data in the form of a SQLite file, and a number of ways to retrieve output data become
 *  active.
 *
 *  \\li \\link Meter Meters \\endlink provide access to related data once the SqlFile is attached.  Meters
 *      may be present at the Facility, Building, ThermalZone, System, and Plant levels.
 *
 *  \\li Every concrete ModelObject must implement the method \\link ModelObject::outputVariables
 *      outputVariables() \\endlink. With the SqlFile attached, the TimeSeries (see the utilities
 *      documentation) associated with those \\link OutputVariable OutputVariables \\endlink may be
 *      retrieved, given an appropriate environment period string (see SimulationControl).
 *
 *  \\li High level simulation results are available through methods of appropriate ModelObjects.
 *
 *  \\li When possible, calculation of a result (e.g. floorArea) from the input data only is preferred to
 *      requiring simulation output be attached to the Model.  In these cases, the method always
 *      computes its value from input data alone, the method does not check simulation results.
 *      At least one unit test ensures that the value calculated from input data matches the value in the
 *      simulation results.
 *
 *  \\li Results which require simulation to report (e.g. annualNetSiteEnergy) return an uninitialized optional value
 *      unless a valid SqlFile is attached.  Results that are not specific to a particular environment period (e.g. u-factor) may be accessed
 *      without specifying an environment period.  Results that are specific to a particular environment period (e.g. totalLightingEnergy) require
 *      the environment period to report results as an input. Results that presume an annual simulation or some other condition
 *      (e.g. annualNetSiteEnergy presumes the presence of one and only one annual simulation run period) do not require
 *      an environment period as an input but return an uninitialized optional value if that condition is not met.
 *
 *  \\li Finally some virtual methods may be implemented by some concrete classes to require output data but by other classes
*       to not require output data. For instance,
 *      PlanarSurface::uFactor may require simulation data in order to return an actual value,
 *      depending on the exact construction type. (And the u-factor may not be available at all if output data is required
 *      and the surface is not adjacent to the outside environment.)  In this case, the operation of any specific class always uses either
 *      input or output data, the user must refer to the documentation for the specific derived types to understand how the virtual method
 *      will operate in all situations.
 *
 *  The connection to the SqlFile can be reset using model.resetSqlFile().  Closing the SqlFile connection is necessary in order
 *  to resimulate the Model using EnergyPlus.
 *
 *  \\subsection modelobjectRelationships Relationships
 *
 *  There are three primary types of relationships among \\link ModelObject ModelObjects\\endlink:
 *  Parent-Child, Resource-ResourceUser, and (HVAC) Connection.
 *
 *  The Parent-Child relationship is used to represent containment relationships in the building.
 *  For example, Building parents Space, which parents a number of objects including Lights, People, and
 *  ElectricEquipment. If a ParentObject is removed,
 *  its children (and on down the line recursively to grandchildren, etc.) should also
 *  be removed; and if a ParentObject is cloned (copied), its children (recursively) should also
 *  be cloned.
 *
 *  In addition to helping define behaviors, the Parent-Child relationship is useful for model
 *  visualization and navigation. Navigating using ModelObject::parent() and ParentObject::children()
 *  in a Ruby script, for instance, can give the user intuition about how the various aspects of a
 *  Model conceptually fit together in OpenStudio and EnergyPlus.
 *
 *  A ResourceObject is a ModelObject that can be used by multiple other data objects. For instance,
 *  unlike a Lights object which can only be associated with one Space or SpaceType, a Schedule can be used by
 *  any number of objects, so long as the data type of the Schedule (fractional, on/off,
 *  temperature, etc.) is appropriate for the context. Every ModelObject can return the \\link
 *  ResourceObject ResourceObjects \\endlink that is uses with the method ModelObject::resources().
 *  \\link ResourceObject ResourceObjects \\endlink can report their use counts, see
 *  ResourceObject::directUseCount and ResourceObject::nonResourceObjectUseCount. Unused resources
 *  can be removed in one fell swoop with Model::purgeUnusedResourceObjects.
 *
 *  Unlike children, resources are meant to be shared, so they are not removed when a user of the
 *  resource is removed, and they are not automatically cloned when one of their users is cloned
 *  (see \\ref modelobjectKeyBehaviors).
 *
 *  Parents, children and resources are available through generic and typed interfaces. For
 *  instance, Building::children() will return all of the \\link Space Spaces \\endlink in a
 *  std::vector<ModelObject>, and Building also has a method \\link Building::spaces() spaces()
 *  \\endlink that returns the same data as a std::vector<Space>. The Schedule associated with a
 *  Lights object can be found through the std::vector<ResourceObject> returned by
 *  Schedule::resources(), and also through the method Lights::schedule(). Lights also has the
 *  method \\link Lights::setSchedule setSchedule(const Schedule&) \\endlink.
 *
 *  Connections join multiple ModelObjects together via designated points called ports. Connections
 *  between ModelObjects are directional and they are created by identifying a source ModelObject and port
 *  as well as a target ModelObject object and port. Once a connection is made, it is easy to access the ModelObject
 *  connected to a particular port using ModelObject::connectedObject.  New Connections are made using the
 *  openstudio::model::Model::connect function.
 *
 *  ModelObject connections are similar to EnergyPlus nodes, however a connection between ports is
 *  more general than a node connection in Energyplus.  In the OpenStudio model, connections serve
 *  the same role as nodes in EnergyPlus, but OpenStudio connections can be applied in contexts other
 *  than the EnergyPlus system nodes. OpenStudio's connections and ports can be used any time one
 *  ModelObject can be arbitrarily connected to another ModelObject. For example, EnergyPlus EMS
 *  sensors and actuators could be thought of as source and target ports, and a connection could be
 *  made between the two.
 *
 *  \\subsection modelobject_hierachy Parent-Child Hierarchy
 *
 *  As described above, objects in the OpenStudio Model can be organized into a tree (actually a
 *  forest) by linking ModelObject types based on their Parent-Child relationships. The following
 *  is a complete listing of the concrete \\link ModelObject ModelObjects \\endlink displayed in
 *  Parent-Child hierarchical form. The immediate base class of each object is listed in
 *  parentheses. Some object types are listed more than once because they can be the child of
 *  multiple concrete types (in which case the Parent-Child relationship is often defined by an
 *  abstract base class). If the class name is somewhat different from the IddObjectType valueName,
 *  the name of the IDD object is also listed for reference.
 *
 *  <ul>
 *    <li> Version (ModelObject, unique)
 *    <li> Site (ParentObject, unique) – wraps 'Site:Location'
 *      <ul>
 *        <li> ClimateZones (ModelObject, unique)
 *        <li> DesignDay (SizingPeriod) – wraps 'SizingPeriod:DesignDay'
 *          <ul>
 *            <li> SkyTemperature (ModelObject) – wraps 'OS:WeatherProperty:SkyTemperature'
 *          </ul>
 *        <li> LightingDesignDay (ModelObject)
 *        <li> SkyTemperature (ModelObject) – wraps 'OS:WeatherProperty:SkyTemperature'
 *        <li> SiteGroundReflectance (ModelObject, unique)
 *        <li> SiteGroundTemperatureBuildingSurface (ModelObject, unique)
 *        <li> SiteWaterMainsTemperature (ModelObject, unique)
 *        <li> WeatherFile (ModelObject, unique)
 *        <li> WeatherFileConditionType (SizingPeriod)
 *          <ul>
 *            <li> SkyTemperature (ModelObject) – wraps 'OS:WeatherProperty:SkyTemperature'
 *          </ul>
 *        <li> WeatherFileDays (SizingPeriod)
 *          <ul>
 *            <li> SkyTemperature (ModelObject) – wraps 'OS:WeatherProperty:SkyTemperature'
 *          </ul>
 *        <li> ShadingSurfaceGroup (PlanarSurfaceGroup)
 *          <ul>
 *            <li>ShadingSurface (PlanarSurface)
 *          </ul>
 *      </ul>
 *    <li> YearDescription (ParentObject, unique)
 *      <ul>
 *        <li> RunPeriodControlSpecialDays (ModelObject)
 *        <li> RunPeriodControlDaylightSavingTime (ModelObject, unique)
 *      </ul>
 *    <li> SimulationControl (ParentObject, unique)
 *      <ul>
 *        <li> Timestep (ModelObject, unique)
 *        <li> RunPeriod (ParentObject)
 *          <ul>
 *            <li> SkyTemperature (ModelObject) – wraps 'OS:WeatherProperty:SkyTemperature'
 *          </ul>
 *        <li> ConvergenceLimits (ModelObject, unique)
 *        <li> ShadowCalculation (ModelObject, unique)
 *        <li> HeatBalanceAlgorithm (ModelObject, unique)
 *        <li> InsideSurfaceConvectionAlgorithm (ModelObject, unique)
 *        <li> OutsideSurfaceConvectionAlgorithm (ModelObject, unique)
 *        <li> SizingParameters (ModelObject, unique)
 *        <li> ZoneAirContaminantBalance (ModelObject, unique)
 *        <li> ZoneAirHeatBalanceAlgorithm (ModelObject, unique)
 *        <li> ZoneCapacitanceMultiplierResearchSpecial (ModelObject, unique)
 *      </ul>
 *    <li> LightingSimulationControl (ModelObject)
 *    <li> Facility (ParentObject, unique)
 *      <ul>
 *        <li> Meter (ModelObject)
 *        <li> ExteriorLights (ExteriorLoadInstance)
 *        <li> ExteriorFuelEquipment (ExteriorLoadInstance)
 *        <li> ExteriorWaterEquipment (ExteriorLoadInstance)
 *        <li> Building (ParentObject, unique)
 *          <ul>
 *            <li> BuildingStandardsInformation (ModelObject, unique)
 *            <li> Meter (ModelObject)
 *            <li> BuildingStory (ModelObject)
 *            <li> ShadingSurfaceGroup (PlanarSurfaceGroup)
 *              <ul>
 *                <li> ShadingSurface (PlanarSurface)
 *              </ul>
 *            <li> Space (PlanarSurfaceGroup)
 *              <ul>
 *                <li> ShadingSurfaceGroup (PlanarSurfaceGroup)
 *                  <ul>
 *                    <li> ShadingSurface (PlanarSurface)
 *                  </ul>
 *                <li> InteriorPartitionSurfaceGroup (PlanarSurfaceGroup)
 *                  <ul>
 *                    <li> InteriorPartitionSurface (PlanarSurface)
 *                  </ul>
 *                <li> Surface (PlanarSurface)
 *                  <ul>
 *                    <li> SubSurface (PlanarSurface)
 *                      <ul>
 *                        <li> DaylightingDeviceShelf (ModelObject)
 *                      </ul>
 *                  </ul>
 *                <li> ElectricEquipment (SpaceLoadInstance)
 *                <li> GasEquipment (SpaceLoadInstance)
 *                <li> HotWaterEquipment (SpaceLoadInstance)
 *                <li> SteamEquipment (SpaceLoadInstance)
 *                <li> OtherEquipment (SpaceLoadInstance)
 *                <li> InternalMass (SpaceLoadInstance)
 *                <li> Lights (SpaceLoadInstance)
 *                <li> Luminaire (SpaceLoadInstance)
 *                <li> People (SpaceLoadInstance)
 *                <li> SpaceInfiltrationDesignFlowRate (SpaceLoad)
 *                <li> SpaceInfiltrationEffectiveLeakageArea (SpaceLoad)
 *                <li> DaylightingControl (SpaceItem)
 *                <li> IlluminanceMap (SpaceItem)
 *                <li> GlareSensor (SpaceItem)
 *              </ul>
 *            <li> ThermalZone (HVACComponent)
 *          </ul>
 *      </ul>
 *    <li> AirLoopHVAC (Loop)
 *    <li> PlantLoop (Loop)
 *    <li> AirLoopHVACZoneSplitter (Splitter)
 *    <li> AirLoopHVACZoneMixer (Mixer)
 *    <li> ConnectorSplitter (Splitter)
 *    <li> ConnectorMixer (Mixer)
 *    <li> Connection (ModelObject)
 *    <li> SizingZone (ModelObject)
 *    <li> SizingSystem (ModelObject)
 *    <li> ThermostatSetpointDualSetpoint (ModelObject)
 *    <li> AvailabilityManagerScheduled (ParentObject)
 *    <li> ControllerMechanicalVentilation (ParentObject)
 *    <li> AirLoopHVACOutdoorAirSystem (HVACComponent)
 *      <ul>
 *        <li> ControllerOutdoorAir (ParentObject)
 *      </ul>
 *    <li> ControllerWaterCoil (HVACComponent)
 *    <li> Node (StraightComponent)
 *      <ul>
 *        <li> SetpointManagerSingleZoneReheat (HVACComponent)
 *        <li> SetpointManagerScheduled (HVACComponent)
 *        <li> SetpointManagerMixedAir (HVACComponent)
 *      </ul>
 *    <li> AirLoopHVACUnitaryHeatPumpAirToAir (StraightComponent)
 *      <ul>
 *        <li> (HVACComponent)
 *      </ul>
 *    <li> AirTerminalSingleDuctParallelPIUReheat (StraightComponent)
 *      <ul>
 *        <li> (HVACComponent)
 *      </ul>
 *    <li> AirTerminalSingleDuctConstantVolumeNoReheat (StraightComponent)
 *    <li> AirTerminalSingleDuctVAVReheat (StraightComponent)
 *    <li> FanConstantVolume (StraightComponent)
 *    <li> FanVariableVolume (StraightComponent)
 *    <li> CoilHeatingGas (StraightComponent)
 *    <li> EvaporativeCoolerDirectResearchSpecial (StraightComponent)
 *    <li> CoilHeatingDXSingleSpeed (StraightComponent)
 *      <ul>
 *        <li> (Curve)
 *      </ul>
 *    <li> CoilCoolingDXSingleSpeed (StraightComponent)
 *      <ul>
 *        <li> (Curve)
 *      </ul>
 *    <li> CoilCoolingDXTwoSpeed (StraightComponent)
 *      <ul>
 *        <li> (Curve)
 *      </ul>
 *    <li> CoilHeatingElectric (StraightComponent)
 *    <li> PumpVariableSpeed (StraightComponent)
 *      <ul>
 *        <li> (Curve)
 *      </ul>
 *    <li> BoilerHotWater (StraightComponent)
 *      <ul>
 *        <li> (Curve)
 *      </ul>
 *    <li> CoilCoolingWater (WaterToAirComponent)
 *    <li> CoilHeatingWater (WaterToAirComponent)
 *    <li> ZoneHVACFourPipeFanCoil (ZoneHVACComponent)
 *      <ul>
 *        <li> (HVACComponent)
 *      </ul>
 *    <li> ZoneHVACPackagedTerminalAirConditioner (ZoneHVACComponent)
 *      <ul>
 *        <li> (HVACComponent)
 *      </ul>
 *    <li> ZoneHVACPackagedTerminalHeatPump (ZoneHVACComponent)
 *      <ul>
 *        <li> (HVACComponent)
 *      </ul>
 *    <li> CurveBicubic (Curve)
 *    <li> CurveBiquadratic (Curve)
 *    <li> CurveCubic (Curve)
 *    <li> CurveDoubleExponentialDecay (Curve)
 *    <li> CurveExponent (Curve)
 *    <li> CurveExponentialDecay (Curve)
 *    <li> CurveExponentialSkewNormal (Curve)
 *    <li> CurveFanPressureRise (Curve)
 *    <li> CurveFunctionalPressureDrop (Curve)
 *    <li> CurveLinear (Curve)
 *    <li> CurveQuadratic (Curve)
 *    <li> CurveQuadraticLinear (Curve)
 *    <li> CurveQuartic (Curve)
 *    <li> CurveRectangularHyperbola1 (Curve)
 *    <li> CurveRectangularHyperbola2 (Curve)
 *    <li> CurveSigmoid (Curve)
 *    <li> CurveTriquadratic (Curve)
 *    <li> LightingSimulationZone (ModelObject)
 *    <li> ScheduleTypeLimits (ResourceObject)
 *    <li> ScheduleConstant (Schedule)
 *    <li> ScheduleCompact (Schedule)
 *    <li> ScheduleRuleset (Schedule)
 *      <ul>
 *        <li> ScheduleDay (ScheduleBase)
 *        <li> ScheduleRule (ParentObject)
 *          <ul>
 *            <li> ScheduleDay (ScheduleBase)
 *          </ul>
 *      </ul>
 *    <li> ScheduleYear (Schedule)
 *    <li> ScheduleWeek (ResourceObject)
 *    <li> ScheduleDay (ScheduleBase)
 *    <li> ScheduleVariableInterval (ScheduleInterval)
 *    <li> ScheduleFixedInterval (ScheduleInterval)
 *    <li> DefaultScheduleSet (ResourceObject)
 *    <li> Construction (LayeredConstruction)
 *      <ul>
 *        <li> ConstructionBaseStandardsInformation (ModelObject) – wraps 'OS:StandardsInformation:%Construction'
 *      </ul>
 *    <li> ConstructionWithInternalSource (LayeredConstruction) – wraps 'OS:%Construction:InternalSource'
 *      <ul>
 *        <li> ConstructionBaseStandardsInformation (ModelObject) – wraps 'OS:StandardsInformation:%Construction'
 *      </ul>
 *    <li> CFactorUndergroundWallConstruction (ConstructionBase) – wraps 'OS:%Construction:CfactorUndergroundWall'
 *      <ul>
 *        <li> ConstructionBaseStandardsInformation (ModelObject) – wraps 'OS:StandardsInformation:%Construction'
 *      </ul>
 *    <li> FFactorGroundFloorConstruction (ConstructionBase) – wraps 'OS:%Construction:FfactorGroundFloor'
 *      <ul>
 *        <li> ConstructionBaseStandardsInformation (ModelObject) – wraps 'OS:StandardsInformation:%Construction'
 *      </ul>
 *    <li> WindowDataFile (ConstructionBase) – wraps 'OS:%Construction:%WindowDataFile'
 *      <ul>
 *        <li> ConstructionBaseStandardsInformation (ModelObject) – wraps 'OS:StandardsInformation:%Construction'
 *      </ul>
 *    <li> DefaultConstructionSet (ResourceObject)
 *    <li> DefaultSubSurfaceConstructions (ResourceObject)
 *    <li> DefaultSurfaceConstructions (ResourceObject)
 *    <li> StandardOpaqueMaterial (OpaqueMaterial) – wraps 'OS:%Material'
 *    <li> MasslessOpaqueMaterial (OpaqueMaterial) – wraps 'OS:%Material:NoMass'
 *    <li> Gas (GasLayer) – wraps 'OS:WindowMaterial:%Gas'
 *    <li> GasMixture (GasLayer) – wraps 'OS:WindowMaterial:%GasMixture'
 *    <li> InfraredTransparentMaterial (ModelPartitionMaterial) – wraps 'OS:%Material:InfraredTransparent'
 *    <li> AirWallMaterial (ModelPartitionMaterial) – wraps 'OS:%Material:AirWall'
 *    <li> Shade (ShadingMaterial) – wraps 'OS:WindowMaterial:%Shade'
 *    <li> Screen (ShadingMaterial) – wraps 'OS:WindowMaterial:%Screen'
 *    <li> Blind (ShadingMaterial) – wraps 'OS:WindowMaterial:%Blind'
 *    <li> AirGap (OpaqueMaterial) – wraps 'OS:%Material:%AirGap'
 *    <li> RoofVegetation (OpaqueMaterial) – wraps 'OS:%Material:%RoofVegetation'
 *    <li> StandardGlazing (Glazing) – wraps 'OS:WindowMaterial:%Glazing'
 *    <li> SimpleGlazing (Glazing) – wraps 'OS:WindowMaterial:SimpleGlazingSystem'
 *    <li> ThermochromicGlazing (Glazing) – wraps 'OS:WindowMaterial:GlazingGroup:Thermochromic'
 *    <li> RefractionExtinctionGlazing (Glazing) – wraps 'OS:WindowMaterial:Glazing:RefractionExtinctionMethod'
 *    <li> SpaceType (ResourceObject)
 *      <ul>
 *        <li> ElectricEquipment (SpaceLoadInstance)
 *        <li> GasEquipment (SpaceLoadInstance)
 *        <li> HotWaterEquipment (SpaceLoadInstance)
 *        <li> SteamEquipment (SpaceLoadInstance)
 *        <li> OtherEquipment (SpaceLoadInstance)
 *        <li> InternalMass (SpaceLoadInstance)
 *        <li> Lights (SpaceLoadInstance)
 *        <li> Luminaire (SpaceLoadInstance)
 *        <li> People (SpaceLoadInstance)
 *        <li> SpaceInfiltrationDesignFlowRate (SpaceLoad)
 *        <li> SpaceInfiltrationEffectiveLeakageArea (SpaceLoad)
 *      </ul>
 *    <li> RenderingColor (ResourceObject)
 *    <li> ElectricEquipmentDefinition (SpaceLoadDefinition)
 *    <li> GasEquipmentDefinition (SpaceLoadDefinition)
 *    <li> HotWaterEquipmentDefinition (SpaceLoadDefinition)
 *    <li> SteamEquipmentDefinition (SpaceLoadDefinition)
 *    <li> OtherEquipmentDefinition (SpaceLoadDefinition)
 *    <li> InternalMassDefinition (SpaceLoadDefinition)
 *    <li> LightsDefinition (SpaceLoadDefinition)
 *    <li> LuminaireDefinition (SpaceLoadDefinition)
 *    <li> PeopleDefinition (SpaceLoadDefinition)
 *    <li> ExteriorLightsDefinition (ExteriorLoadDefinition)
 *    <li> ExteriorFuelEquipmentDefinition (ExteriorLoadDefinition)
 *    <li> ExteriorWaterEquipmentDefinition (ExteriorLoadDefinition)
 *    <li> DesignSpecificationOutdoorAir (ResourceObject)
 *    <li> CurrencyType (ParentObject)
 *    <li> LifeCycleCost_UsePriceEscalation (ParentObject)
 *    <li> LifeCycleCost_UseAdjustment (ParentObject)
 *    <li> LifeCycleCost_Parameters (ParentObject)
 *    <li> ComponentCost_Adjustments (ParentObject)
 *    <li> ComponentCost_Reference (ParentObject)
 *  </ul>
 *
 *  Special Cases that can be Parented by many \\link ModelObject ModelObjects \\endlink
 *
 *  <ul>
 *    <li> OutputVariable (ModelObject)
 *    <li> ComponentCost_LineItem (ModelObject)
 *    <li> LifeCycleCost_RecurringCosts (ParentObject)
 *    <li> LifeCycleCost_NonrecurringCost (ParentObject)
 *  </ul>
 *
 *  Special Cases related to the Building Component Library
 *
 *  <ul>
 *    <li> ComponentData (ParentObject)</li>
 *  </ul>
 *
 *  \\subsection modelobjectKeyBehaviors Key Behaviors
 *
 *  \\subsubsection newmodel Create a New Model
 *
 *  There are four constructors available for Model. The default constructor creates a new Model
 *  with a single Version object in it. Version objects are not returned by Model::objects or
 *  counted by Model::numObjects.
 *
 *  \\code
 *  Model model;
 *  OS_ASSERT(model.versionObject());
 *  OS_ASSERT(model.numObjects() == 0u);
 *  OS_ASSERT(model.iddFileType() == IddFileType::OpenStudio);
 *  OS_ASSERT(model.strictnessLevel() == StrictnessLevel::Draft);
 *  \\endcode
 *
 *  The preferred method for creating a Model from an OSM file is
 *
 *  \\code
 *  OptionalModel oModel = Model::load(modelFilePath);
 *  if (!oModel) { LOG_AND_THROW(""Unable to open '"" << toString(modelFilePath) << ""'.""); }
 *  Model model = *oModel;
 *  \\endcode
 *
 *  UNLESS that OSM file might be from an old version of OpenStudio, in which case the version
 *  translator should be used:
 *
 *  \\code
 *  osversion::VersionTranslator translator;
 *  OptionalModel oModel = translator.loadModel(modelFilePath);
 *  if (!oModel) {
 *    LOG_AND_THROW(""Unable to open and translate '"" << toString(modelFilePath) << ""'."");
 *  }
 *  Model model = *oModel;
 *  \\endcode
 *
 *  The preferred method for creating a Model from IDF file is
 *
 *  \\code
 *  #include <energyplus/ReverseTranslator.hpp>
 *
 *  OptionalModel oModel = energyplus::loadAndTranslateIdf(idfFilePath);
 *  \\endcode
 *
 *  In addition, constructors are provided from IdfFile and Workspace (see the utilities
 *  documentation). Those constructors will throw if IdfFile or Workspace uses the wrong IDD file.
 *
 *  Because Model is required to support partial (unsimulatable) building models for data
 *  sharing, and to provide a flexible interface for editing, it is ultimately up to the user to
 *  ensure that a Model is ready for simulation. Model::validityReport and similar methods (see
 *  the utilities documentation, especially Workspace::validityReport,
 *  WorkspaceObject::validityReport, and ValidityEnums.hpp) are provided to help users bring their
 *  models up to the standard set by the IDD. (And there are a few places in Model where validity
 *  checking goes beyond the data schema to rules internal to EnergyPlus, see for instance
 *  LayeredConstruction::layersAreValid, which is used by the virtual implementation of
 *  validityReport for \\link LayeredConstruction LayeredConstructions \\endlink.) Beyond that, users
 *  will sometimes need to go through an iterative process of modeling, trying to run EnergyPlus
 *  (or another simulation engine), addressing simulation errors, etc.
 *
 *  \\subsubsection newmodelobject Create a New ModelObject
 *
 *  Every concrete ModelObject has one or more public constructors, unless
 *  it is marked unique by the IDD. In this case, there is no public constructor in order to
 *  prevent the accidental construction of multiple instance of that type in the same model. Instead,
 *  these objects are made available through Model::getUniqueModelObject and
 *  Model::getOptionalUniqueModelObject:
 *
 *  \\code
 *  Model model;
 *
 *  // getOptionalUniqueModelObject only returns an object if it is already in the Model.
 *  // It constructs any new objects.
 *  OptionalBuilding oBuilding = model.getOptionalUniqueModelObject<Building>();
 *  OS_ASSERT(!oBuilding);
 *  OS_ASSERT(model.numObjects() == 0u);
 *
 *  // getUniqueModelObject constructs the object if it is not yet present.
 *  Building building = model.getUniqueModelObject<Building>();
 *  OS_ASSERT(model.numObjects() == 1u);
 *
 *  // now getOptionalUniqueModelObject can return the object that was just created
 *  oBuilding = model.getOptionalUniqueModelObject<Building>();
 *  OS_ASSERT(oBuilding);
 *  OS_ASSERT(model.numObjects() == 1u);
 *  OS_ASSERT(oBuilding.get() == building);
 *  \\endcode
 *
 *  For non-unique objects, all public constructors will ensure that required fields, children,
 *  and resources are present as a post-condition. Depending on the constructor, the user may be
 *  required to explicitly provide those objects, or they may be default constructed. For example
 *  the LightsDefinition object is a required argument to the Lights object constructor.  Parents
 *  are often not required by the public constructors; as appropriate, convenience constructors
 *  that take the parent as an argument may be provided. (Orphan construction is allowed in order
 *  to better support data sharing. For instance, if someone wants to create a lighting component
 *  for the Building Component Library, requiring Lights to be constructed with a Space or
 *  SpaceType would be inconvenient.)
 *
 *  \\subsubsection removemodelobject Delete a ModelObject
 *
 *  ModelObject::remove is used to remove a ModelObject from a Model. When a model object is
 *  removed, all of its children are also removed. Objects related to the removed object through
 *  a resource or connection relationship are not deleted. Resources persist so they can be used
 *  by other objects. Connections are broken by object removal, but the adjacent object is left
 *  behind, unless it happens to also be a child of the removed object. However, when a resource or
 *  child object is removed, its user objects or parents may also be removed, if the relationship
 *  is a required one for the user/parent. For instance, SpaceLoadDefinition::remove also removes
 *  all of its SpaceLoadDefinition::instances, since a SpaceLoadInstance cannot exist without its
 *  definition.
 *
 *  For all deleted objects, when all the instances of that object go out of scope and stop
 *  referencing the shared implementation pointer, the memory will be automatically freed for you.
 *
 *  \\subsubsection clonemodelobject Clone a ModelObject
 *
 *  ModelObject::clone is used to duplicate a ModelObject.  The clone method may be used to copy
 *  an object into another model, or to duplicate an object in the same model. The act of cloning
 *  an object will change the duplicate object's name if an object of the same type and name
 *  already exists in the target model. Therefore, cloning into the same model will always result
 *  in name change for the duplicate so as to avoid a name collision with the original object.
 *  Cloning a ModelObject also clones all of its children (recursively). Resources are cloned as
 *  necessary (when an equivalent object cannot be located, see IdfObject::dataFieldsEqual and
 *  IdfObject::managedObjectListFieldsNonConflicting in the utilities documentation) when the
 *  original and target models are different.
 *
 *  Examples:
 *  \\code
 *  LightsVector originalLights = space.lights();
 *  clonedSpace= space.clone(space.model());
 *  LightsVector clonedLights = clonedSpace.lights();
 *  OS_ASSERT(originalLights.size() == clonedLights.size())
 *
 *  if (originalLights.size() > 0) {
 *    LightVector::iterator i = std::find(originalLights.begin(),originalLights.end(),clonedLights[0]);
 *    OS_ASSERT(i == originalLights.end()); // clonedLights[0] not found in originalLights
 *                                             // (std::find uses ==, which for ModelObjects checks
 *                                             // to see if the objects point to the exact same
 *                                             // implementation object)
 *  }
 *  \\endcode
 *
 *  The following code would also pass its OS_ASSERTs. Because we cloned into the same model, the
 *  schedule (a ResourceObject) was NOT cloned.
 *
 *  \\code
 *  // continuing from above
 *
 *  if (originalLights.size() > 0) {
 *    // originalLights[0] and clonedLights[0] share the exact same schedule ...
 *    // ... == verifies it.
 *    OS_ASSERT(originalLights[0].schedule() == clonedLights[0].schedule());
 *    // ... as does making a change in clonedLights[0].schedule()
 *    clonedLights[0].schedule().setName(""Some Cool Name"")
 *    // ... and then looking for the change in originalLights[0].schedule().
 *    OS_ASSERT(originalLights[0].schedule().name().get() == ""Some Cool Name"")
 *  }
 *  \\endcode
 *
 *  \\subsection object_implementation Implementation Details
 *
 *  Similar to Model inheriting from openstudio::Workspace, ModelObject inherits from
 *  openstudio::WorkspaceObject, which in turn inherits from openstudio::IdfObject. Briefly,
 *  IdfObject corresponds to a single data object in an IDF file. It has an IddObject, which defines
 *  its type, and it otherwise consists of a vector (ordered list) of string fields, accessible by
 *  index and with an optional user comment. (If you never specify an IDF field comment, default
 *  comments are generated for you from the IddField::name()'s.) WorkspaceObject provides the added
 *  functionality of turning the '\\\\type object-list' fields that in clear text point to other data
 *  objects by name reference into bi-directional, name-independent pointers to particular objects.
 *  Please see the utilities/idf documentation for more information.
 *
 *  In this way, IdfObject, WorkspaceObject, and Workspace form the underlying data model used by
 *  OpenStudio to represent a single building (assuming the OpenStudio, rather than the EnergyPlus
 *  or other, IDD is referenced). Model, ModelObject and everything else in the openstudio::model
 *  namespace exists to turn that data model into a full-featured object model.
 *
 *  Because Model and ModelObject publicly inherit from Workspace and WorkspaceObject, methods of
 *  Workspace and WorkspaceObject are directly available for use through Model and ModelObject.
 *  Use of these methods is discouraged where it is not necessary as these data model-level
 *  modifications bypass the best-practice logic built into classes derived from ModelObject.
 *
 *  \\link ModelObject ModelObjects \\endlink (and WorkspaceObjects and IdfObjects) also use the
 *  pImpl idiom described \\ref model_implementation ""above"". So basic copying
 *  and assignment results in data sharing, for example:
 *
 *  \\code
 *  Space spaceA(model);
 *  spaceA.setName(""Space A"");
 *  OS_ASSERT(spaceA.name().get() == ""Space A"");
 *  Space spaceB = spaceA;
 *  spaceB.setName(""Space B"");
 *  OS_ASSERT(spaceA.name().get() == ""Space B""); // may not be the intended behavior ...
 *                                                  // use clone() to get a deep copy
 *
 *  // Sharing also happens just by passing objects around as arguments.
 *  // For instance, this function takes a non-const copy, it does not pass by reference.
 *  void changeName(ModelObject object) {
 *    object.setName(""New Name"");
 *  }
 *
 *  Space spaceC(model);
 *  // function looks like all changes are local to it ...
 *  changeName(spaceC);
 *  // ... but they are not because of pImpl.
 *  OS_ASSERT(spaceC.name().get() == ""New Name"");
 *  \\endcode
 *
 *  The pointer to the implementation is managed by a reference counting pointer, so the
 *  implementation object is destroyed when the last wrapper class goes out of scope. Because the
 *  implementation is shared between copies of the public class, signal and slot connections will
 *  remain active after the public object is destroyed provided that another object still references
 *  the same implementation. Note that at the very least this other object is typically the Model
 *  of which the ModelObject is a member, as Model (actually Workspace) maintains a map of all of its
 *  objects' implementation reference counting pointers.
 *
 *  The combined use of template methods such as Model::getModelObjects<T>() with the pImpl idiom
 *  has led to the unfortunate case where users of a class may need to also include the
 *  corresponding implementation class, for example:
 *
 *  \\code
 *  // user will have to include Space.hpp and Space_Impl.hpp
 *  std::vector<Space> spaces = model.getModelObjects<Space>();
 *  \\endcode
 *
 *  Another important detail about the OpenStudio Model is that ModelObjects are only valid when
 *  they are part of a Model. The benefit of this requirement is that any ModelObject can access the
 *  entire Model to search for related ModelObjects.  For the most part, the Model interface
 *  enforces this requirement. However, there are some cases where it is possible to break this
 *  invariant, for example:
 *
 *  \\code
 *
 *  // EXAMPLE OF WHAT NOT TO DO
 *
 *  // vector to hold ModelObjects
 *  std::vector<ModelObject> modelObjects;
 *
 *  { // create new scope
 *
 *    // create new Model
 *    Model model;
 *
 *    // add some objects
 *    model.getUniqueModelObject<Building>();
 *    model.getUniqueModelObject<Facility>();
 *    Space space1(model);
 *    Space space2(model);
 *
 *    // get objects, they are valid here
 *    modelObjects = model.modelObjects();
 *
 *  }  // model goes out of scope
 *
 *  // modelObjects now contains invalid ModelObjects
 *  OS_ASSERT(!modelObjects[0].initialized()); // Model_Impl destructor disconnects objects
 *
 *  \\endcode
 *
 *  \\section components What is a Component?
 *
 *  A Component is a partial Model that can be created from a ModelObject and then shared between
 *  models or with other modelers. When ModelObject::createComponent is called, ModelObject::clone
 *  is used to copy that object (the primary object) and related objects (often the children and
 *  resources of the object, evaluated recursively) into a new, blank Component. A Component is a
 *  Model that satisfies a few additional constraints.
 *
 *  \\link Component Components\\endlink always contain one ComponentData object, which
 *  provides a place to list all the objects in the Component, as well as universal identifiers
 *  and timestamps used to keep track of the Component as it travels to and from local and remote
 *  Building Component Libraries (BCLs). The contents list is always headed by the primary object,
 *  which induces a parent-child tree plus resource and connection relationships on the rest of
 *  objects. For instance, a Construction Component would have a Construction object as its
 *  primary object, and would likely also contain a number of Material objects (resources of
 *  the Construction), and a ComponentCost_LineItem object (child of the Construction).
 *
 *  A component creation example follows:
 *  \\code
 *  OptionalModel oModel = Model::load(osmFilepath);
 *  OS_ASSERT(oModel);
 *  model = *oModel;
 *  ConstructionVector constructions = model.getModelObjects<Construction>();
 *  if (constructions.size() > 0) {
 *    Component constructionComponent = constructions[0].createComponent();
 *    ModelObject primary = constructionComponent.primaryObject();
 *    OS_ASSERT(primary.optionalCast<Construction>());
 *    OS_ASSERT(primary.cast<Construction>().layers().size() == constructions[0].layers().size());
 *    OS_ASSERT(primary.cast<Construction>() != constructions[0]);
 *    OS_ASSERT(primary.model() != constructions[0].model());
 *  }
 *  \\endcode
 *
 *  The Component class disallows some of the non-const operations of Model. In particular, no
 *  objects can be added to or inserted into a Component. Objects can be removed, except for the
 *  primary ModelObject and the ComponentData object. If either of those objects are removed, the
 *  Component is invalidated and throws an exception. Once created, Components can be saved for
 *  future use, or directly used in another Model. To save a Component for future use, it should be
 *  added to a local BCL, and/or uploaded to the online %Building %Component Library. (These
 *  features are currently under development. Please see the documentation for utilities/bcl and
 *  http://bcl.nrel.gov/.)
 *
 *  To use a Component (either directly, or deserialized from a building component library) in a
 *  Model, use the method Model::insertComponent(const Component& ). This method first looks to see
 *  if a copy of the Component is already present in the Model; if not, it clones all of the
 *  objects into the Model. In either case, if successful, the method returns the resulting
 *  ComponentData object. After an insertComponent operation, Model watches the contents of the
 *  inserted Component, changing the ComponentData::versionUUID if data is modified, and deleting
 *  the ComponentData object (and discontinuing the watching operation) if it is invalidated (by
 *  removal of the primaryObject, for instance). In this way, Model can be queried to find out what
 *  \\link Component Components \\endlink it uses, and one can ascertain whether any data has changed
 *  as compared to the original version. Therefore, this is a mechanism that can be used to trace
 *  coherent pieces of input data through a series of related models, between similar research
 *  project models, or to ensure that the appropriate components are used for building energy
 *  standards compliance.
 *
 *  An example of using the component created above:
 *  \\code
 *  if (constructions.size() > 0) {
 *    Model newModel;
 *    OptionalComponentData ocd = newModel.insertComponent(constructionComponent);
 *    OS_ASSERT(ocd);
 *    unsigned n = newModel.numObjects();
 *    ComponentData cd = *ocd;
 *    Construction clonedConstruction = cd.primaryComponentObject().cast<Construction>();
 *    // now I can make some geometry and assign the construction to a planar surface
 *    // ... or I can remove the new construction, thereby ""destroying"" the component:
 *    clonedConstruction.remove();
 *    OS_ASSERT(clonedConstruction.handle().isNull()); // clonedConstruction removed from model
 *    OS_ASSERT(cd.handle().isNull());                 // ComponentData object also removed
 *    OS_ASSERT(newModel.numObjects() < n);
 *    OS_ASSERT(newModel.getModelObjects<Construction>().empty());
 *    // there may be some orphaned resources (Materials) still hanging around …
 *    newModel.purgeUnusedResources();
 *    OS_ASSERT(newModel.numObjects() == 0u);
 *  }
 *  \\endcode
 */
 } // model
 } // openstudio
",16276,True,2997.3489538028357,median
"[[smpp-component]]
= SMPP Component

*Since Camel 2.2*

// HEADER START
*Both Producer and Consumer are supported*
// HEADER END

This component provides access to an SMSC (Short Message Service Center)
over the http://smsforum.net/SMPP_v3_4_Issue1_2.zip[SMPP] protocol to
send and receive SMS. The http://jsmpp.org[JSMPP] library is used for
the protocol implementation.

The Camel component currently operates as an
http://en.wikipedia.org/wiki/ESME[ESME] (External Short Messaging
Entity) and not as an SMSC itself.

You are also able to execute ReplaceSm,
QuerySm, SubmitMulti, CancelSm and DataSm.

Maven users will need to add the following dependency to their `pom.xml`
for this component:

[source,xml]
------------------------------------------------------------
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-smpp</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>
------------------------------------------------------------

== SMS limitations

SMS is neither reliable or secure.  Users who require reliable and
secure delivery may want to consider using the XMPP or SIP components
instead, combined with a smartphone app supporting the chosen protocol.

* Reliability: although the SMPP standard offers a range of feedback
mechanisms to indicate errors, non-delivery and confirmation of delivery
it is not uncommon for mobile networks to hide or simulate these
responses.  For example, some networks automatically send a delivery
confirmation for every message even if the destination number is invalid
or not switched on.  Some networks silently drop messages if they think
they are spam.  Spam detection rules in the network may be very crude,
sometimes more than 100 messages per day from a single sender may be
considered spam.
* Security: there is basic encryption for the last hop from the radio
tower down to the recipient handset.  SMS messages are not encrypted or
authenticated in any other part of the network.  Some operators allow
staff in retail outlets or call centres to browse through the SMS
message histories of their customers.  Message sender identity can be
easily forged.  Regulators and even the mobile telephone industry itself
has cautioned against the use of SMS in two-factor authentication
schemes and other purposes where security is important.

While the Camel component makes it as easy as possible to send messages
to the SMS network, it can not offer an easy solution to these problems.

== Data coding, alphabet and international character sets

Data coding and alphabet can be specified on a per-message basis. 
Default values can be specified for the endpoint.  It is important to
understand the relationship between these options and the way the
component acts when more than one value is set.

Data coding is an 8 bit field in the SMPP wire format.

Alphabet corresponds to bits 0-3 of the data coding field.  For some
types of message, where a message class is used (by setting bit 5 of the
data coding field), the lower two bits of the data coding field are not
interpreted as alphabet and only bits 2 and 3 impact the alphabet.

Furthermore, current version of the JSMPP library only seems to support
bits 2 and 3, assuming that bits 0 and 1 are used for message class. 
This is why the Alphabet class in JSMPP doesn't support the value 3
(binary 0011) which indicates ISO-8859-1.

Although JSMPP provides a representation of the message class parameter,
the Camel component doesn't currently provide a way to set it other than
manually setting the corresponding bits in the data coding field.

When setting the data coding field in the outgoing message, the Camel
component considers the following values and uses the first one it can
find:

* the data coding specified in a header
* the alphabet specified in a header
* the data coding specified in the endpoint configuration (URI
parameter)

Older versions of Camel had bugs in support for international character
sets.  This feature only worked when a single encoding was used for all
messages and was troublesome when users wanted to change it on a
per-message basis.  Users who require this to work should ensure their
version of Camel includes the fix for 

JIRA Issues Macro: com.atlassian.sal.api.net.ResponseStatusException:
Unexpected response received. Status code: 404

.

In addition to trying to send the data coding value to the SMSC, the
Camel component also tries to analyze the message body, convert it to a
Java String (Unicode) and convert that to a byte array in the
corresponding alphabet  When deciding which alphabet to use in the byte
array, the Camel SMPP component does not consider the data coding value
(header or configuration), it only considers the specified alphabet
(from either the header or endpoint parameter).

If some characters in the String can't be represented in the chosen
alphabet, they may be replaced by the question mark ( ? ) symbol.  Users
of the API may want to consider checking if their message body can be
converted to ISO-8859-1 before passing it to the component and if not,
setting the alphabet header to request UCS-2 encoding.  If the alphabet
and data coding options are not specified at all then the component may
try to detect the required encoding and set the data coding for you.

The list of alphabet codes are specified in the SMPP specification v3.4,
section 5.2.19.  One notable limitation of the SMPP specification is
that there is no alphabet code for explicitly requesting use of the GSM
3.38 (7 bit) character set.  Choosing the value 0 for the alphabet
selects the SMSC _default_ alphabet, this usually means GSM 3.38 but it
is not guaranteed.  The SMPP gateway Nexmo
https://help.nexmo.com/hc/en-us/articles/204015813-How-to-change-the-character-encoding-in-SMPP-[actually
allows the default to be mapped to any other character set with a
control panel option]. It is suggested that users check with their SMSC
operator to confirm exactly which character set is being used as the
default.

== Message splitting and throttling

After transforming a message body from a String to a byte array, the
Camel component is also responsible for splitting the message into parts
(within the 140 byte SMS size limit) before passing it to JSMPP.  This
is completed automatically.

If the GSM 3.38 alphabet is used, the component will pack up to 160
characters into the 140 byte message body.  If an 8 bit character set is
used (e.g. ISO-8859-1 for western Europe) then 140 characters will be
allowed within the 140 byte message body.  If 16 bit UCS-2 encoding is
used then just 70 characters fit into each 140 byte message.

Some SMSC providers implement throttling rules.  Each part of a message
that has been split may be counted separately by the provider's
throttling mechanism.  The Camel Throttler component can be useful for
throttling messages in the SMPP route before handing them to the SMSC.

== URI format

[source,java]
--------------------------------------------
smpp://[username@]hostname[:port][?options]
smpps://[username@]hostname[:port][?options]
--------------------------------------------

If no *username* is provided, then Camel will provide the default value
`smppclient`. +
 If no *port* number is provided, then Camel will provide the default
value `2775`. +
If the protocol name is ""smpps"", camel-smpp with try to
use SSLSocket to init a connection to the server.

You can append query options to the URI in the following format,
`?option=value&option=value&...`

== URI Options




// component options: START
The SMPP component supports 4 options, which are listed below.



[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *configuration* (advanced) | To use the shared SmppConfiguration as configuration. |  | SmppConfiguration
| *basicPropertyBinding* (advanced) | Whether the component should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | boolean
| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing. | false | boolean
| *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | boolean
|===
// component options: END






// endpoint options: START
The SMPP endpoint is configured using URI syntax:

----
smpp:host:port
----

with the following path and query parameters:

=== Path Parameters (2 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *host* | Hostname for the SMSC server to use. | localhost | String
| *port* | Port number for the SMSC server to use. | 2775 | Integer
|===


=== Query Parameters (40 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *initialReconnectDelay* (common) | Defines the initial delay in milliseconds after the consumer/producer tries to reconnect to the SMSC, after the connection was lost. | 5000 | long
| *maxReconnect* (common) | Defines the maximum number of attempts to reconnect to the SMSC, if SMSC returns a negative bind response | 2147483647 | int
| *reconnectDelay* (common) | Defines the interval in milliseconds between the reconnect attempts, if the connection to the SMSC was lost and the previous was not succeed. | 5000 | long
| *splittingPolicy* (common) | You can specify a policy for handling long messages: ALLOW - the default, long messages are split to 140 bytes per message TRUNCATE - long messages are split and only the first fragment will be sent to the SMSC. Some carriers drop subsequent fragments so this reduces load on the SMPP connection sending parts of a message that will never be delivered. REJECT - if a message would need to be split, it is rejected with an SMPP NegativeResponseException and the reason code signifying the message is too long. | ALLOW | SmppSplittingPolicy
| *systemType* (common) | This parameter is used to categorize the type of ESME (External Short Message Entity) that is binding to the SMSC (max. 13 characters). |  | String
| *addressRange* (consumer) | You can specify the address range for the SmppConsumer as defined in section 5.2.7 of the SMPP 3.4 specification. The SmppConsumer will receive messages only from SMSC's which target an address (MSISDN or IP address) within this range. |  | String
| *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | boolean
| *exceptionHandler* (consumer) | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this option is not in use. By default the consumer will deal with exceptions, that will be logged at WARN or ERROR level and ignored. |  | ExceptionHandler
| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. |  | ExchangePattern
| *destAddr* (producer) | Defines the destination SME address. For mobile terminated messages, this is the directory number of the recipient MS. Only for SubmitSm, SubmitMulti, CancelSm and DataSm. | 1717 | String
| *destAddrNpi* (producer) | Defines the type of number (TON) to be used in the SME destination address parameters. Only for SubmitSm, SubmitMulti, CancelSm and DataSm. The following NPI values are defined: 0: Unknown 1: ISDN (E163/E164) 2: Data (X.121) 3: Telex (F.69) 6: Land Mobile (E.212) 8: National 9: Private 10: ERMES 13: Internet (IP) 18: WAP Client Id (to be defined by WAP Forum) |  | byte
| *destAddrTon* (producer) | Defines the type of number (TON) to be used in the SME destination address parameters. Only for SubmitSm, SubmitMulti, CancelSm and DataSm. The following TON values are defined: 0: Unknown 1: International 2: National 3: Network Specific 4: Subscriber Number 5: Alphanumeric 6: Abbreviated |  | byte
| *lazySessionCreation* (producer) | Sessions can be lazily created to avoid exceptions, if the SMSC is not available when the Camel producer is started. Camel will check the in message headers 'CamelSmppSystemId' and 'CamelSmppPassword' of the first exchange. If they are present, Camel will use these data to connect to the SMSC. | false | boolean
| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing. | false | boolean
| *numberingPlanIndicator* (producer) | Defines the numeric plan indicator (NPI) to be used in the SME. The following NPI values are defined: 0: Unknown 1: ISDN (E163/E164) 2: Data (X.121) 3: Telex (F.69) 6: Land Mobile (E.212) 8: National 9: Private 10: ERMES 13: Internet (IP) 18: WAP Client Id (to be defined by WAP Forum) |  | byte
| *priorityFlag* (producer) | Allows the originating SME to assign a priority level to the short message. Only for SubmitSm and SubmitMulti. Four Priority Levels are supported: 0: Level 0 (lowest) priority 1: Level 1 priority 2: Level 2 priority 3: Level 3 (highest) priority |  | byte
| *protocolId* (producer) | The protocol id |  | byte
| *registeredDelivery* (producer) | Is used to request an SMSC delivery receipt and/or SME originated acknowledgements. The following values are defined: 0: No SMSC delivery receipt requested. 1: SMSC delivery receipt requested where final delivery outcome is success or failure. 2: SMSC delivery receipt requested where the final delivery outcome is delivery failure. |  | byte
| *replaceIfPresentFlag* (producer) | Used to request the SMSC to replace a previously submitted message, that is still pending delivery. The SMSC will replace an existing message provided that the source address, destination address and service type match the same fields in the new message. The following replace if present flag values are defined: 0: Don't replace 1: Replace |  | byte
| *serviceType* (producer) | The service type parameter can be used to indicate the SMS Application service associated with the message. The following generic service_types are defined: CMT: Cellular Messaging CPT: Cellular Paging VMN: Voice Mail Notification VMA: Voice Mail Alerting WAP: Wireless Application Protocol USSD: Unstructured Supplementary Services Data |  | String
| *sourceAddr* (producer) | Defines the address of SME (Short Message Entity) which originated this message. | 1616 | String
| *sourceAddrNpi* (producer) | Defines the numeric plan indicator (NPI) to be used in the SME originator address parameters. The following NPI values are defined: 0: Unknown 1: ISDN (E163/E164) 2: Data (X.121) 3: Telex (F.69) 6: Land Mobile (E.212) 8: National 9: Private 10: ERMES 13: Internet (IP) 18: WAP Client Id (to be defined by WAP Forum) |  | byte
| *sourceAddrTon* (producer) | Defines the type of number (TON) to be used in the SME originator address parameters. The following TON values are defined: 0: Unknown 1: International 2: National 3: Network Specific 4: Subscriber Number 5: Alphanumeric 6: Abbreviated |  | byte
| *typeOfNumber* (producer) | Defines the type of number (TON) to be used in the SME. The following TON values are defined: 0: Unknown 1: International 2: National 3: Network Specific 4: Subscriber Number 5: Alphanumeric 6: Abbreviated |  | byte
| *basicPropertyBinding* (advanced) | Whether the endpoint should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | boolean
| *enquireLinkTimer* (advanced) | Defines the interval in milliseconds between the confidence checks. The confidence check is used to test the communication path between an ESME and an SMSC. | 5000 | Integer
| *sessionStateListener* (advanced) | You can refer to a org.jsmpp.session.SessionStateListener in the Registry to receive callbacks when the session state changed. |  | SessionStateListener
| *synchronous* (advanced) | Sets whether synchronous processing should be strictly used, or Camel is allowed to use asynchronous processing (if supported). | false | boolean
| *transactionTimer* (advanced) | Defines the maximum period of inactivity allowed after a transaction, after which an SMPP entity may assume that the session is no longer active. This timer may be active on either communicating SMPP entity (i.e. SMSC or ESME). | 10000 | Integer
| *alphabet* (codec) | Defines encoding of data according the SMPP 3.4 specification, section 5.2.19. 0: SMSC Default Alphabet 4: 8 bit Alphabet 8: UCS2 Alphabet |  | byte
| *dataCoding* (codec) | Defines the data coding according the SMPP 3.4 specification, section 5.2.19. Example data encodings are: 0: SMSC Default Alphabet 3: Latin 1 (ISO-8859-1) 4: Octet unspecified (8-bit binary) 8: UCS2 (ISO/IEC-10646) 13: Extended Kanji JIS(X 0212-1990) |  | byte
| *encoding* (codec) | Defines the encoding scheme of the short message user data. Only for SubmitSm, ReplaceSm and SubmitMulti. | ISO-8859-1 | String
| *httpProxyHost* (proxy) | If you need to tunnel SMPP through a HTTP proxy, set this attribute to the hostname or ip address of your HTTP proxy. |  | String
| *httpProxyPassword* (proxy) | If your HTTP proxy requires basic authentication, set this attribute to the password required for your HTTP proxy. |  | String
| *httpProxyPort* (proxy) | If you need to tunnel SMPP through a HTTP proxy, set this attribute to the port of your HTTP proxy. | 3128 | Integer
| *httpProxyUsername* (proxy) | If your HTTP proxy requires basic authentication, set this attribute to the username required for your HTTP proxy. |  | String
| *proxyHeaders* (proxy) | These headers will be passed to the proxy server while establishing the connection. |  | Map
| *password* (security) | The password for connecting to SMSC server. |  | String
| *systemId* (security) | The system id (username) for connecting to SMSC server. | smppclient | String
| *usingSSL* (security) | Whether using SSL with the smpps protocol | false | boolean
|===
// endpoint options: END
// spring-boot-auto-configure options: START
== Spring Boot Auto-Configuration

When using Spring Boot make sure to use the following Maven dependency to have support for auto configuration:

[source,xml]
----
<dependency>
  <groupId>org.apache.camel</groupId>
  <artifactId>camel-smpp-starter</artifactId>
  <version>x.x.x</version>
  <!-- use the same version as your Camel core version -->
</dependency>
----


The component supports 40 options, which are listed below.



[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *camel.component.smpp.basic-property-binding* | Whether the component should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | Boolean
| *camel.component.smpp.bridge-error-handler* | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | Boolean
| *camel.component.smpp.configuration.address-range* | You can specify the address range for the SmppConsumer as defined in section 5.2.7 of the SMPP 3.4 specification. The SmppConsumer will receive messages only from SMSC's which target an address (MSISDN or IP address) within this range. |  | String
| *camel.component.smpp.configuration.alphabet* | Defines encoding of data according the SMPP 3.4 specification, section 5.2.19. <ul> <li>0: SMSC Default Alphabet <li>4: 8 bit Alphabet</li> <li>8: UCS2 Alphabet</li></li> </ul> |  | Byte
| *camel.component.smpp.configuration.data-coding* | Defines the data coding according the SMPP 3.4 specification, section 5.2.19. Example data encodings are: <ul> <li>0: SMSC Default Alphabet</li> <li>3: Latin 1 (ISO-8859-1)</li> <li>4: Octet unspecified (8-bit binary)</li> <li>8: UCS2 (ISO/IEC-10646)</li> <li>13: Extended Kanji JIS(X 0212-1990)</li> </ul> |  | Byte
| *camel.component.smpp.configuration.dest-addr* | Defines the destination SME address. For mobile terminated messages, this is the directory number of the recipient MS. Only for SubmitSm, SubmitMulti, CancelSm and DataSm. | 1717 | String
| *camel.component.smpp.configuration.dest-addr-npi* | Defines the type of number (TON) to be used in the SME destination address parameters. Only for SubmitSm, SubmitMulti, CancelSm and DataSm. The following NPI values are defined: <ul> <li>0: Unknown</li> <li>1: ISDN (E163/E164)</li> <li>2: Data (X.121)</li> <li>3: Telex (F.69)</li> <li>6: Land Mobile (E.212)</li> <li>8: National</li> <li>9: Private</li> <li>10: ERMES</li> <li>13: Internet (IP)</li> <li>18: WAP Client Id (to be defined by WAP Forum)</li> </ul> |  | Byte
| *camel.component.smpp.configuration.dest-addr-ton* | Defines the type of number (TON) to be used in the SME destination address parameters. Only for SubmitSm, SubmitMulti, CancelSm and DataSm. The following TON values are defined: <ul> <li>0: Unknown</li> <li>1: International</li> <li>2: National</li> <li>3: Network Specific</li> <li>4: Subscriber Number</li> <li>5: Alphanumeric</li> <li>6: Abbreviated</li> </ul> |  | Byte
| *camel.component.smpp.configuration.encoding* | Defines the encoding scheme of the short message user data. Only for SubmitSm, ReplaceSm and SubmitMulti. | ISO-8859-1 | String
| *camel.component.smpp.configuration.enquire-link-timer* | Defines the interval in milliseconds between the confidence checks. The confidence check is used to test the communication path between an ESME and an SMSC. | 5000 | Integer
| *camel.component.smpp.configuration.host* | Hostname for the SMSC server to use. | localhost | String
| *camel.component.smpp.configuration.http-proxy-host* | If you need to tunnel SMPP through a HTTP proxy, set this attribute to the hostname or ip address of your HTTP proxy. |  | String
| *camel.component.smpp.configuration.http-proxy-password* | If your HTTP proxy requires basic authentication, set this attribute to the password required for your HTTP proxy. |  | String
| *camel.component.smpp.configuration.http-proxy-port* | If you need to tunnel SMPP through a HTTP proxy, set this attribute to the port of your HTTP proxy. | 3128 | Integer
| *camel.component.smpp.configuration.http-proxy-username* | If your HTTP proxy requires basic authentication, set this attribute to the username required for your HTTP proxy. |  | String
| *camel.component.smpp.configuration.initial-reconnect-delay* | Defines the initial delay in milliseconds after the consumer/producer tries to reconnect to the SMSC, after the connection was lost. | 5000 | Long
| *camel.component.smpp.configuration.lazy-session-creation* | Sessions can be lazily created to avoid exceptions, if the SMSC is not available when the Camel producer is started. Camel will check the in message headers 'CamelSmppSystemId' and 'CamelSmppPassword' of the first exchange. If they are present, Camel will use these data to connect to the SMSC. | false | Boolean
| *camel.component.smpp.configuration.max-reconnect* | Defines the maximum number of attempts to reconnect to the SMSC, if SMSC returns a negative bind response | 2147483647 | Integer
| *camel.component.smpp.configuration.numbering-plan-indicator* | Defines the numeric plan indicator (NPI) to be used in the SME. The following NPI values are defined: <ul> <li>0: Unknown</li> <li>1: ISDN (E163/E164)</li> <li>2: Data (X.121)</li> <li>3: Telex (F.69)</li> <li>6: Land Mobile (E.212)</li> <li>8: National</li> <li>9: Private</li> <li>10: ERMES</li> <li>13: Internet (IP)</li> <li>18: WAP Client Id (to be defined by WAP Forum)</li> </ul> |  | Byte
| *camel.component.smpp.configuration.password* | Defines the encoding scheme of the short message user data. Only for SubmitSm, ReplaceSm and SubmitMulti. |  | String
| *camel.component.smpp.configuration.port* | Port number for the SMSC server to use. | 2775 | Integer
| *camel.component.smpp.configuration.priority-flag* | Allows the originating SME to assign a priority level to the short message. Only for SubmitSm and SubmitMulti. Four Priority Levels are supported: <ul> <li>0: Level 0 (lowest) priority</li> <li>1: Level 1 priority</li> <li>2: Level 2 priority</li> <li>3: Level 3 (highest) priority</li> </ul> |  | Byte
| *camel.component.smpp.configuration.protocol-id* | The protocol id |  | Byte
| *camel.component.smpp.configuration.proxy-headers* | These headers will be passed to the proxy server while establishing the connection. |  | Map
| *camel.component.smpp.configuration.reconnect-delay* | Defines the interval in milliseconds between the reconnect attempts, if the connection to the SMSC was lost and the previous was not succeed. | 5000 | Long
| *camel.component.smpp.configuration.registered-delivery* | Is used to request an SMSC delivery receipt and/or SME originated acknowledgements. The following values are defined: <ul> <li>0: No SMSC delivery receipt requested.</li> <li>1: SMSC delivery receipt requested where final delivery outcome is success or failure.</li> <li>2: SMSC delivery receipt requested where the final delivery outcome is delivery failure.</li> </ul> |  | Byte
| *camel.component.smpp.configuration.replace-if-present-flag* | Used to request the SMSC to replace a previously submitted message, that is still pending delivery. The SMSC will replace an existing message provided that the source address, destination address and service type match the same fields in the new message. The following replace if present flag values are defined: <ul> <li>0: Don't replace</li> <li>1: Replace</li> </ul> |  | Byte
| *camel.component.smpp.configuration.service-type* | The service type parameter can be used to indicate the SMS Application service associated with the message. The following generic service_types are defined: <ul> <li>CMT: Cellular Messaging</li> <li>CPT: Cellular Paging</li> <li>VMN: Voice Mail Notification</li> <li>VMA: Voice Mail Alerting</li> <li>WAP: Wireless Application Protocol</li> <li>USSD: Unstructured Supplementary Services Data</li> </ul> |  | String
| *camel.component.smpp.configuration.session-state-listener* | You can refer to a org.jsmpp.session.SessionStateListener in the Registry to receive callbacks when the session state changed. |  | SessionStateListener
| *camel.component.smpp.configuration.source-addr* | Defines the address of SME (Short Message Entity) which originated this message. | 1616 | String
| *camel.component.smpp.configuration.source-addr-npi* | Defines the numeric plan indicator (NPI) to be used in the SME originator address parameters. The following NPI values are defined: <ul> <li>0: Unknown</li> <li>1: ISDN (E163/E164)</li> <li>2: Data (X.121)</li> <li>3: Telex (F.69)</li> <li>6: Land Mobile (E.212)</li> <li>8: National</li> <li>9: Private</li> <li>10: ERMES</li> <li>13: Internet (IP)</li> <li>18: WAP Client Id (to be defined by WAP Forum)</li> </ul> |  | Byte
| *camel.component.smpp.configuration.source-addr-ton* | Defines the type of number (TON) to be used in the SME originator address parameters. The following TON values are defined: <ul> <li>0: Unknown</li> <li>1: International</li> <li>2: National</li> <li>3: Network Specific</li> <li>4: Subscriber Number</li> <li>5: Alphanumeric</li> <li>6: Abbreviated</li> </ul> |  | Byte
| *camel.component.smpp.configuration.splitting-policy* | You can specify a policy for handling long messages: <ul> <li>ALLOW - the default, long messages are split to 140 bytes per message</li> <li>TRUNCATE - long messages are split and only the first fragment will be sent to the SMSC. Some carriers drop subsequent fragments so this reduces load on the SMPP connection sending parts of a message that will never be delivered.</li> <li>REJECT - if a message would need to be split, it is rejected with an SMPP NegativeResponseException and the reason code signifying the message is too long.</li> </ul> |  | SmppSplittingPolicy
| *camel.component.smpp.configuration.system-id* | The system id (username) for connecting to SMSC server. | smppclient | String
| *camel.component.smpp.configuration.system-type* | This parameter is used to categorize the type of ESME (External Short Message Entity) that is binding to the SMSC (max. 13 characters). |  | String
| *camel.component.smpp.configuration.transaction-timer* | Defines the maximum period of inactivity allowed after a transaction, after which an SMPP entity may assume that the session is no longer active. This timer may be active on either communicating SMPP entity (i.e. SMSC or ESME). | 10000 | Integer
| *camel.component.smpp.configuration.type-of-number* | Defines the type of number (TON) to be used in the SME. The following TON values are defined: <ul> <li>0: Unknown</li> <li>1: International</li> <li>2: National</li> <li>3: Network Specific</li> <li>4: Subscriber Number</li> <li>5: Alphanumeric</li> <li>6: Abbreviated</li> </ul> |  | Byte
| *camel.component.smpp.configuration.using-s-s-l* | Whether using SSL with the smpps protocol | false | Boolean
| *camel.component.smpp.enabled* | Enable smpp component | true | Boolean
| *camel.component.smpp.lazy-start-producer* | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing. | false | Boolean
|===
// spring-boot-auto-configure options: END




You can have as many of these options as you like.

[source,java]
------------------------------------------------------------------------------------------------------------------
smpp://smppclient@localhost:2775?password=password&enquireLinkTimer=3000&transactionTimer=5000&systemType=consumer
------------------------------------------------------------------------------------------------------------------

== Producer Message Headers

The following message headers can be used to affect the behavior of the
SMPP producer

[width=""100%"",cols=""10%,10%,80%"",options=""header"",]
|=======================================================================
|Header |Type |Description

|`CamelSmppDestAddr` |`List`/`String` |*only for SubmitSm, SubmitMulti, CancelSm and DataSm* Defines the
destination SME address(es). For mobile terminated messages, this is the
directory number of the recipient MS. Is must be a `List<String>` for
SubmitMulti and a `String` otherwise.

|`CamelSmppDestAddrTon` |`Byte` |*only for SubmitSm, SubmitMulti, CancelSm and DataSm* Defines the type
of number (TON) to be used in the SME destination address parameters.
Use the `sourceAddrTon` URI option values defined above.

|`CamelSmppDestAddrNpi` |`Byte` |*only for SubmitSm, SubmitMulti, CancelSm and DataSm* Defines the
numeric plan indicator (NPI) to be used in the SME destination address
parameters. Use the URI option `sourceAddrNpi` values defined above.

|`CamelSmppSourceAddr` |`String` |Defines the address of SME (Short Message Entity) which originated this
message.

|`CamelSmppSourceAddrTon` |`Byte` |Defines the type of number (TON) to be used in the SME originator
address parameters. Use the `sourceAddrTon` URI option values defined
above.

|`CamelSmppSourceAddrNpi` |`Byte` |Defines the numeric plan indicator (NPI) to be used in the SME
originator address parameters. Use the URI option `sourceAddrNpi` values
defined above.

|`CamelSmppServiceType` |`String` |The service type parameter can be used to indicate the SMS Application
service associated with the message. Use the URI option `serviceType`
settings above.

|`CamelSmppRegisteredDelivery` |`Byte` |*only for SubmitSm, ReplaceSm, SubmitMulti and DataSm* Is used to
request an SMSC delivery receipt and/or SME originated acknowledgements.
Use the URI option `registeredDelivery` settings above.

|`CamelSmppPriorityFlag` |`Byte` |*only for SubmitSm and SubmitMulti* Allows the originating SME to assign
a priority level to the short message. Use the URI option `priorityFlag`
settings above.

|`CamelSmppScheduleDeliveryTime` |`Date` |*only for SubmitSm, SubmitMulti and ReplaceSm* This parameter specifies
the scheduled time at which the message delivery should be first
attempted. It defines either the absolute date and time or relative time
from the current SMSC time at which delivery of this message will be
attempted by the SMSC. It can be specified in either absolute time
format or relative time format. The encoding of a time format is
specified in chapter 7.1.1. in the smpp specification v3.4.

|`CamelSmppValidityPeriod` |`String`/`Date` |*only for SubmitSm, SubmitMulti and ReplaceSm* The validity period
parameter indicates the SMSC expiration time, after which the message
should be discarded if not delivered to the destination. If it's
provided as `Date`, it's interpreted as absolute time or relative time
format if you provide it as `String` as specified in chapter 7.1.1 in
the smpp specification v3.4.

|`CamelSmppReplaceIfPresentFlag` |`Byte` |*only for SubmitSm and SubmitMulti* The replace if present flag
parameter is used to request the SMSC to replace a previously submitted
message, that is still pending delivery. The SMSC will replace an
existing message provided that the source address, destination address
and service type match the same fields in the new message. The following
values are defined: `0`, Don't replace and `1`, Replace

|`CamelSmppAlphabet` / `CamelSmppDataCoding` |`Byte` |*For SubmitSm, SubmitMulti and ReplaceSm*  The data
coding according to the SMPP 3.4 specification, section 5.2.19. Use the
URI option `alphabet` settings above.

|`CamelSmppOptionalParameter` |`Map<Short, Object>` |*only for SubmitSm, SubmitMulti and
DataSm* The optional parameter which are send to the SMSC. The value is
converted in the following way: `String` -> `org.jsmpp.bean.OptionalParameter.COctetString`, 
`byte[]` -> `org.jsmpp.bean.OptionalParameter.OctetString`, 
`Byte` -> `org.jsmpp.bean.OptionalParameter.Byte`,
`Integer` -> `org.jsmpp.bean.OptionalParameter.Int`,
`Short` -> `org.jsmpp.bean.OptionalParameter.Short`, 
`null` -> `org.jsmpp.bean.OptionalParameter.Null`

|CamelSmppEncoding |String |*only for SubmitSm,
SubmitMulti and DataSm*.  Specifies the encoding (character set name) of
the bytes in the message body.  If the message body is a string then
this is not relevant because Java Strings are always Unicode.  If the
body is a byte array then this header can be used to indicate that it is
ISO-8859-1 or some other value.  Default value is specified by the
endpoint configuration parameter _encoding_

|CamelSmppSplittingPolicy |String |*only for SubmitSm,
SubmitMulti and DataSm*.  Specifies the policy for message splitting for
this exchange.  Possible values are described in the endpoint
configuration parameter _splittingPolicy_
|=======================================================================

The following message headers are used by the SMPP producer to set the
response from the SMSC in the message header

[width=""100%"",cols=""10%,10%,80%"",options=""header"",]
|=======================================================================
|Header |Type |Description

|`CamelSmppId` |`List<String>`/`String` |The id to identify the submitted short message(s) for later use.
In case of a ReplaceSm, QuerySm, CancelSm and DataSm this
header vaule is a `String`. In case of a SubmitSm or SubmitMultiSm this
header vaule is a `List<String>`.

|`CamelSmppSentMessageCount` |`Integer` |*only for SubmitSm and SubmitMultiSm* The total
number of messages which has been sent.

|`CamelSmppError` |`Map<String, List<Map<String, Object>>>` |*only for SubmitMultiSm* The errors which
occurred by sending the short message(s) the form `Map<String, List<Map<String, Object>>>` (messageID : (destAddr :
address, error : errorCode)).

|`CamelSmppOptionalParameter` |`Map<Short, Object>` |*only for DataSm* The optional
parameter which are returned from the SMSC by sending the message. The
key is the `Short` code for the optional parameter. The value is
converted in the following way: 
`org.jsmpp.bean.OptionalParameter.COctetString` -> `String`,
`org.jsmpp.bean.OptionalParameter.OctetString` -> `byte[]`,
`org.jsmpp.bean.OptionalParameter.Byte` -> `Byte`,
`org.jsmpp.bean.OptionalParameter.Int` -> `Integer`,
`org.jsmpp.bean.OptionalParameter.Short` -> `Short`, 
`org.jsmpp.bean.OptionalParameter.Null` -> `null`
|=======================================================================

== Consumer Message Headers

The following message headers are used by the SMPP consumer to set the
request data from the SMSC in the message header

[width=""100%"",cols=""10%,10%,80%"",options=""header"",]
|=======================================================================
|Header |Type |Description

|`CamelSmppSequenceNumber` |`Integer` |*only for AlertNotification, DeliverSm and DataSm* A sequence number
allows a response PDU to be correlated with a request PDU. The
associated SMPP response PDU must preserve this field.

|`CamelSmppCommandId` |`Integer` |*only for AlertNotification, DeliverSm and DataSm* The command id field
identifies the particular SMPP PDU. For the complete list of defined
values see chapter 5.1.2.1 in the smpp specification v3.4.

|`CamelSmppSourceAddr` |`String` |*only for AlertNotification, DeliverSm and DataSm* Defines the address
of SME (Short Message Entity) which originated this message.

|`CamelSmppSourceAddrNpi` |`Byte` |*only for AlertNotification and DataSm* Defines the numeric plan
indicator (NPI) to be used in the SME originator address parameters. Use
the URI option `sourceAddrNpi` values defined above.

|`CamelSmppSourceAddrTon` |`Byte` |*only for AlertNotification and DataSm* Defines the type of number (TON)
to be used in the SME originator address parameters. Use the
`sourceAddrTon` URI option values defined above.

|`CamelSmppEsmeAddr` |`String` |*only for AlertNotification* Defines the destination ESME address. For
mobile terminated messages, this is the directory number of the
recipient MS.

|`CamelSmppEsmeAddrNpi` |`Byte` |*only for AlertNotification* Defines the numeric plan indicator (NPI) to
be used in the ESME originator address parameters. Use the URI option
`sourceAddrNpi` values defined above.

|`CamelSmppEsmeAddrTon` |`Byte` |*only for AlertNotification* Defines the type of number (TON) to be used
in the ESME originator address parameters. Use the `sourceAddrTon` URI
option values defined above.

|`CamelSmppId` |`String` |*only for smsc DeliveryReceipt and DataSm* The message ID allocated to
the message by the SMSC when originally submitted.

|`CamelSmppDelivered` |`Integer` |*only for smsc DeliveryReceipt* Number of short messages delivered. This
is only relevant where the original message was submitted to a
distribution list.The value is padded with leading zeros if necessary.

|`CamelSmppDoneDate` |`Date` |*only for smsc DeliveryReceipt* The time and date at which the short
message reached it's final state. The format is as follows: YYMMDDhhmm.

|`CamelSmppStatus` |`DeliveryReceiptState` |*only for smsc DeliveryReceipt:* The final status of the message. The
following values are defined: `DELIVRD`: Message is delivered to destination,
`EXPIRED`: Message validity period has expired,
`DELETED`: Message has been deleted, 
`UNDELIV`: Message is undeliverable, 
`ACCEPTD`: Message is in accepted state (i.e. has been manually read on
behalf of the subscriber by customer service),
`UNKNOWN`: Message is in invalid state,
`REJECTD`: Message is in a rejected state

|`CamelSmppCommandStatus` |`Integer` |*only for DataSm* The Command status of the message.

|`CamelSmppError` |`String` |*only for smsc DeliveryReceipt* Where appropriate this may hold a
Network specific error code or an SMSC error code for the attempted
delivery of the message. These errors are Network or SMSC specific and
are not included here.

|`CamelSmppSubmitDate` |`Date` |*only for smsc DeliveryReceipt* The time and date at which the short
message was submitted. In the case of a message which has been replaced,
this is the date that the original message was replaced. The format is
as follows: YYMMDDhhmm.

|`CamelSmppSubmitted` |`Integer` |*only for smsc DeliveryReceipt* Number of short messages originally
submitted. This is only relevant when the original message was submitted
to a distribution list.The value is padded with leading zeros if
necessary.

|`CamelSmppDestAddr` |`String` |*only for DeliverSm and DataSm:* Defines the destination SME address.
For mobile terminated messages, this is the directory number of the
recipient MS.

|`CamelSmppScheduleDeliveryTime` |`String` |*only for DeliverSm:* This parameter specifies the scheduled time at
which the message delivery should be first attempted. It defines either
the absolute date and time or relative time from the current SMSC time
at which delivery of this message will be attempted by the SMSC. It can
be specified in either absolute time format or relative time format. The
encoding of a time format is specified in Section 7.1.1. in the smpp
specification v3.4.

|`CamelSmppValidityPeriod` |`String` |*only for DeliverSm* The validity period parameter indicates the SMSC
expiration time, after which the message should be discarded if not
delivered to the destination. It can be defined in absolute time format
or relative time format. The encoding of absolute and relative time
format is specified in Section 7.1.1 in the smpp specification v3.4.

|`CamelSmppServiceType` |`String` |*only for DeliverSm and DataSm* The service type parameter indicates the
SMS Application service associated with the message.

|`CamelSmppRegisteredDelivery` |`Byte` |*only for DataSm* Is used to request an delivery receipt and/or SME
originated acknowledgements. Same values as in Producer header list
above.

|`CamelSmppDestAddrNpi` |`Byte` |*only for DataSm* Defines the numeric plan indicator (NPI) in the
destination address parameters. Use the URI option `sourceAddrNpi`
values defined above.

|`CamelSmppDestAddrTon` |`Byte` |*only for DataSm* Defines the type of number (TON) in the destination
address parameters. Use the `sourceAddrTon` URI option values defined
above.

|`CamelSmppMessageType` |`String` |Identifies the type of an incoming message:
`AlertNotification`: an SMSC alert notification,
`DataSm`: an SMSC data short message,
`DeliveryReceipt`: an SMSC delivery receipt,
`DeliverSm`: an SMSC deliver short message

|`CamelSmppOptionalParameter` |`Map<Short, Object>` |*only for DeliverSm* The optional
parameters send back by the SMSC. The key is the `Short` code for the
optional parameter. The value is converted in the following way: 
`org.jsmpp.bean.OptionalParameter.COctetString` -> `String`,
`org.jsmpp.bean.OptionalParameter.OctetString` -> `byte[]`,
`org.jsmpp.bean.OptionalParameter.Byte` -> `Byte`,
`org.jsmpp.bean.OptionalParameter.Int` -> `Integer`,
`org.jsmpp.bean.OptionalParameter.Short` -> `Short`,
`org.jsmpp.bean.OptionalParameter.Null` -> `null`
|=======================================================================

TIP: *JSMPP library*
See the documentation of the http://jsmpp.org[JSMPP Library] for more
details about the underlying library.

== Exception handling

This component supports the general Camel exception handling
capabilities

When an error occurs sending a message with SubmitSm (the default
action), the org.apache.camel.component.smpp.SmppException is thrown
with a nested exception, org.jsmpp.extra.NegativeResponseException. 
Call NegativeResponseException.getCommandStatus() to obtain the exact
SMPP negative response code, the values are explained in the SMPP
specification 3.4, section 5.1.3. +
When the SMPP consumer receives a `DeliverSm` or
`DataSm` short message and the processing of these messages fails, you
can also throw a `ProcessRequestException` instead of handle the
failure. In this case, this exception is forwarded to the underlying
http://jsmpp.org[JSMPP library] which will return the included error
code to the SMSC. This feature is useful to e.g. instruct the SMSC to
resend the short message at a later time. This could be done with the
following lines of code:

[source,java]
--------------------------------------------------------------------------------------------------------------------------
from(""smpp://smppclient@localhost:2775?password=password&enquireLinkTimer=3000&transactionTimer=5000&systemType=consumer"")
  .doTry()
    .to(""bean:dao?method=updateSmsState"")
  .doCatch(Exception.class)
    .throwException(new ProcessRequestException(""update of sms state failed"", 100))
  .end();
--------------------------------------------------------------------------------------------------------------------------

Please refer to the http://smsforum.net/SMPP_v3_4_Issue1_2.zip[SMPP
specification] for the complete list of error codes and their meanings.

== Samples

A route which sends an SMS using the Java DSL:

[source,java]
------------------------------------------------------------------------------------------
from(""direct:start"")
  .to(""smpp://smppclient@localhost:2775?
      password=password&enquireLinkTimer=3000&transactionTimer=5000&systemType=producer"");
------------------------------------------------------------------------------------------

A route which sends an SMS using the Spring XML DSL:

[source,xml]
-----------------------------------------------------------------------------------------------------------
<route>
  <from uri=""direct:start""/>
  <to uri=""smpp://smppclient@localhost:2775?
           password=password&amp;enquireLinkTimer=3000&amp;transactionTimer=5000&amp;systemType=producer""/>
</route>
-----------------------------------------------------------------------------------------------------------

A route which receives an SMS using the Java DSL:

[source,java]
--------------------------------------------------------------------------------------------------------------------------
from(""smpp://smppclient@localhost:2775?password=password&enquireLinkTimer=3000&transactionTimer=5000&systemType=consumer"")
  .to(""bean:foo"");
--------------------------------------------------------------------------------------------------------------------------

A route which receives an SMS using the Spring XML DSL:

[source,xml]
----------------------------------------------------------------------------------------------------------------
  <route>
     <from uri=""smpp://smppclient@localhost:2775?
                password=password&amp;enquireLinkTimer=3000&amp;transactionTimer=5000&amp;systemType=consumer""/>
     <to uri=""bean:foo""/>
  </route>
----------------------------------------------------------------------------------------------------------------


TIP: *SMSC simulator*
If you need an SMSC simulator for your test, you can use the simulator
provided by
http://opensmpp.logica.com/CommonPart/Download/download2.html#simulator[Logica].

== Debug logging

This component has log level *DEBUG*, which can be helpful in debugging
problems. If you use log4j, you can add the following line to your
configuration:

[source,java]
--------------------------------------------------
log4j.logger.org.apache.camel.component.smpp=DEBUG
--------------------------------------------------

",12108,False,2387.8617610949022,median
"// Copyright (c) 2011-2015 The Bitcoin Core developers
// Copyright (c) 2014-2020 The Vuicoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include <qt/guiutil.h>

#include <qt/appearancewidget.h>
#include <qt/bitcoinaddressvalidator.h>
#include <qt/bitcoingui.h>
#include <qt/bitcoinunits.h>
#include <qt/optionsdialog.h>
#include <qt/qvalidatedlineedit.h>
#include <qt/walletmodel.h>

#include <primitives/transaction.h>
#include <init.h>
#include <policy/policy.h>
#include <protocol.h>
#include <script/script.h>
#include <script/standard.h>
#include <ui_interface.h>
#include <util.h>

#ifdef WIN32
#ifdef _WIN32_WINNT
#undef _WIN32_WINNT
#endif
#define _WIN32_WINNT 0x0501
#ifdef _WIN32_IE
#undef _WIN32_IE
#endif
#define _WIN32_IE 0x0501
#define WIN32_LEAN_AND_MEAN 1
#ifndef NOMINMAX
#define NOMINMAX
#endif
#include <shellapi.h>
#include <shlobj.h>
#include <shlwapi.h>
#endif

#include <boost/scoped_array.hpp>

#include <QAbstractButton>
#include <QAbstractItemView>
#include <QApplication>
#include <QClipboard>
#include <QDateTime>
#include <QDebug>
#include <QDesktopServices>
#include <QDesktopWidget>
#include <QDialogButtonBox>
#include <QDoubleValidator>
#include <QFileDialog>
#include <QFont>
#include <QLineEdit>
#include <QPointer>
#include <QSettings>
#include <QTextDocument> // for Qt::mightBeRichText
#include <QThread>
#include <QTimer>
#include <QMouseEvent>
#include <QVBoxLayout>

#if QT_VERSION < 0x050000
#include <QUrl>
#else
#include <QUrlQuery>
#endif

#if QT_VERSION >= 0x50200
#include <QFontDatabase>
#endif

static fs::detail::utf8_codecvt_facet utf8;

#if defined(Q_OS_MAC)
extern double NSAppKitVersionNumber;
#if !defined(NSAppKitVersionNumber10_8)
#define NSAppKitVersionNumber10_8 1187
#endif
#if !defined(NSAppKitVersionNumber10_9)
#define NSAppKitVersionNumber10_9 1265
#endif

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored ""-Wdeprecated-declarations""

#include <CoreServices/CoreServices.h>
#include <QProcess>

void ForceActivation();
#endif

namespace GUIUtil {

static CCriticalSection cs_css;
// The default stylesheet directory
static const QString defaultStylesheetDirectory = "":css"";
// The actual stylesheet directory
static QString stylesheetDirectory = defaultStylesheetDirectory;
// The name of the traditional theme
static const QString traditionalTheme = ""Traditional"";
// The theme to set by default if settings are missing or incorrect
static const QString defaultTheme = ""Light"";
// The prefix a theme name should have if we want to apply dark colors and styles to it
static const QString darkThemePrefix = ""Dark"";
// Mapping css file => theme.
static const std::map<QString, QString> mapStyleToTheme{
    {""general.css"", """"},
    {""dark.css"", ""Dark""},
    {""light.css"", ""Light""},
    {""traditional.css"", ""Traditional""}
};

/** loadFonts stores the SystemDefault font in osDefaultFont to be able to reference it later again */
static std::unique_ptr<QFont> osDefaultFont;
/** Font related default values. */
static const FontFamily defaultFontFamily = FontFamily::SystemDefault;
static const int defaultFontSize = 12;
static const double fontScaleSteps = 0.01;
#ifdef Q_OS_MAC
static const QFont::Weight defaultFontWeightNormal = QFont::ExtraLight;
static const QFont::Weight defaultFontWeightBold = QFont::Medium;
static const int defaultFontScale = 0;
#else
static const QFont::Weight defaultFontWeightNormal = QFont::Light;
static const QFont::Weight defaultFontWeightBold = QFont::Medium;
static const int defaultFontScale = 0;
#endif

/** Font related variables. */
// Application font family. May be overwritten by -font-family.
static FontFamily fontFamily = defaultFontFamily;
// Application font scale value. May be overwritten by -font-scale.
static int fontScale = defaultFontScale;
// Application font weight for normal text. May be overwritten by -font-weight-normal.
static QFont::Weight fontWeightNormal = defaultFontWeightNormal;
// Application font weight for bold text. May be overwritten by -font-weight-bold.
static QFont::Weight fontWeightBold = defaultFontWeightBold;

// Contains all widgets and its font attributes (weight, italic, size) with font changes due to GUIUtil::setFont
static std::map<QPointer<QWidget>, std::tuple<FontWeight, bool, int>> mapFontUpdates;
// Contains a list of supported font weights for all members of GUIUtil::FontFamily
static std::map<FontFamily, std::vector<QFont::Weight>> mapSupportedWeights;

#ifdef Q_OS_MAC
// Contains all widgets where the macOS focus rect has been disabled.
static std::set<QWidget*> setRectsDisabled;
#endif

static const std::map<ThemedColor, QColor> themedColors = {
    { ThemedColor::DEFAULT, QColor(85, 85, 85) },
    { ThemedColor::UNCONFIRMED, QColor(128, 128, 128) },
    { ThemedColor::BLUE, QColor(0, 141, 228) },
    { ThemedColor::ORANGE, QColor(199, 147, 4) },
    { ThemedColor::RED, QColor(168, 72, 50) },
    { ThemedColor::GREEN, QColor(94, 140, 65) },
    { ThemedColor::BAREADDRESS, QColor(140, 140, 140) },
    { ThemedColor::TX_STATUS_OPENUNTILDATE, QColor(64, 64, 255) },
    { ThemedColor::BACKGROUND_WIDGET, QColor(234, 234, 236) },
    { ThemedColor::BORDER_WIDGET, QColor(220, 220, 220) },
    { ThemedColor::BACKGROUND_NETSTATS, QColor(210, 210, 210, 230) },
    { ThemedColor::BORDER_NETSTATS, QColor(180, 180, 180) },
    { ThemedColor::QR_PIXEL, QColor(85, 85, 85) },
    { ThemedColor::ICON_ALTERNATIVE_COLOR, QColor(167, 167, 167) },
};

static const std::map<ThemedColor, QColor> themedDarkColors = {
    { ThemedColor::DEFAULT, QColor(199, 199, 199) },
    { ThemedColor::UNCONFIRMED, QColor(170, 170, 170) },
    { ThemedColor::BLUE, QColor(0, 89, 154) },
    { ThemedColor::ORANGE, QColor(199, 147, 4) },
    { ThemedColor::RED, QColor(168, 72, 50) },
    { ThemedColor::GREEN, QColor(94, 140, 65) },
    { ThemedColor::BAREADDRESS, QColor(140, 140, 140) },
    { ThemedColor::TX_STATUS_OPENUNTILDATE, QColor(64, 64, 255) },
    { ThemedColor::BACKGROUND_WIDGET, QColor(45, 45, 46) },
    { ThemedColor::BORDER_WIDGET, QColor(74, 74, 75) },
    { ThemedColor::BACKGROUND_NETSTATS, QColor(45, 45, 46, 230) },
    { ThemedColor::BORDER_NETSTATS, QColor(74, 74, 75) },
    { ThemedColor::QR_PIXEL, QColor(199, 199, 199) },
    { ThemedColor::ICON_ALTERNATIVE_COLOR, QColor(74, 74, 75) },
};

static const std::map<ThemedStyle, QString> themedStyles = {
    { ThemedStyle::TS_INVALID, ""background:#a84832;"" },
    { ThemedStyle::TS_ERROR, ""color:#a84832;"" },
    { ThemedStyle::TS_SUCCESS, ""color:#5e8c41;"" },
    { ThemedStyle::TS_COMMAND, ""color:#008de4;"" },
    { ThemedStyle::TS_PRIMARY, ""color:#333;"" },
    { ThemedStyle::TS_SECONDARY, ""color:#444;"" },
};

static const std::map<ThemedStyle, QString> themedDarkStyles = {
    { ThemedStyle::TS_INVALID, ""background:#a84832;"" },
    { ThemedStyle::TS_ERROR, ""color:#a84832;"" },
    { ThemedStyle::TS_SUCCESS, ""color:#5e8c41;"" },
    { ThemedStyle::TS_COMMAND, ""color:#00599a;"" },
    { ThemedStyle::TS_PRIMARY, ""color:#c7c7c7;"" },
    { ThemedStyle::TS_SECONDARY, ""color:#aaa;"" },
};

QColor getThemedQColor(ThemedColor color)
{
    QString theme = QSettings().value(""theme"", """").toString();
    return theme.startsWith(darkThemePrefix) ? themedDarkColors.at(color) : themedColors.at(color);
}

QString getThemedStyleQString(ThemedStyle style)
{
    QString theme = QSettings().value(""theme"", """").toString();
    return theme.startsWith(darkThemePrefix) ? themedDarkStyles.at(style) : themedStyles.at(style);
}

QIcon getIcon(const QString& strIcon, const ThemedColor color, const ThemedColor colorAlternative, const QString& strIconPath)
{
    QColor qcolor = getThemedQColor(color);
    QColor qcolorAlternative = getThemedQColor(colorAlternative);
    QIcon icon(strIconPath + strIcon);
    QIcon themedIcon;
    for (const QSize& size : icon.availableSizes()) {
        QImage image(icon.pixmap(size).toImage());
        image = image.convertToFormat(QImage::Format_ARGB32);
        for (int x = 0; x < image.width(); ++x) {
            for (int y = 0; y < image.height(); ++y) {
                const QRgb rgb = image.pixel(x, y);
                QColor* pColor;
                if ((rgb & RGB_MASK) < RGB_HALF) {
                    pColor = &qcolor;
                } else {
                    pColor = &qcolorAlternative;
                }
                image.setPixel(x, y, qRgba(pColor->red(), pColor->green(), pColor->blue(), qAlpha(rgb)));
            }
        }
        themedIcon.addPixmap(QPixmap::fromImage(image));
    }
    return themedIcon;
}

QIcon getIcon(const QString& strIcon, const ThemedColor color, const QString& strIconPath)
{
    return getIcon(strIcon, color, ThemedColor::ICON_ALTERNATIVE_COLOR, strIconPath);
}

void setIcon(QAbstractButton* button, const QString& strIcon, const ThemedColor color, const ThemedColor colorAlternative, const QSize& size)
{
    button->setIcon(getIcon(strIcon, color, colorAlternative));
    button->setIconSize(size);
}

void setIcon(QAbstractButton* button, const QString& strIcon, const ThemedColor color, const QSize& size)
{
    setIcon(button, strIcon, color, ThemedColor::ICON_ALTERNATIVE_COLOR, size);
}

QString dateTimeStr(const QDateTime &date)
{
    return date.date().toString(Qt::SystemLocaleShortDate) + QString("" "") + date.toString(""hh:mm"");
}

QString dateTimeStr(qint64 nTime)
{
    return dateTimeStr(QDateTime::fromTime_t((qint32)nTime));
}

// Just some dummy data to generate an convincing random-looking (but consistent) address
static const uint8_t dummydata[] = {0xeb,0x15,0x23,0x1d,0xfc,0xeb,0x60,0x92,0x58,0x86,0xb6,0x7d,0x06,0x52,0x99,0x92,0x59,0x15,0xae,0xb1,0x72,0xc0,0x66,0x47};

// Generate a dummy address with invalid CRC, starting with the network prefix.
static std::string DummyAddress(const CChainParams &params)
{
    std::vector<unsigned char> sourcedata = params.Base58Prefix(CChainParams::PUBKEY_ADDRESS);
    sourcedata.insert(sourcedata.end(), dummydata, dummydata + sizeof(dummydata));
    for(int i=0; i<256; ++i) { // Try every trailing byte
        std::string s = EncodeBase58(sourcedata.data(), sourcedata.data() + sourcedata.size());
        if (!IsValidDestinationString(s)) {
            return s;
        }
        sourcedata[sourcedata.size()-1] += 1;
    }
    return """";
}

void setupAddressWidget(QValidatedLineEdit *widget, QWidget *parent, bool fAllowURI)
{
    parent->setFocusProxy(widget);

#if QT_VERSION >= 0x040700
    // We don't want translators to use own addresses in translations
    // and this is the only place, where this address is supplied.
    widget->setPlaceholderText(QObject::tr(""Enter a Vuicoin address (e.g. %1)"").arg(
        QString::fromStdString(DummyAddress(Params()))));
#endif
    widget->setValidator(new BitcoinAddressEntryValidator(parent, fAllowURI));
    widget->setCheckValidator(new BitcoinAddressCheckValidator(parent));
}

void setupAmountWidget(QLineEdit *widget, QWidget *parent)
{
    QDoubleValidator *amountValidator = new QDoubleValidator(parent);
    amountValidator->setDecimals(8);
    amountValidator->setBottom(0.0);
    widget->setValidator(amountValidator);
    widget->setAlignment(Qt::AlignRight|Qt::AlignVCenter);
}

void setupAppearance(QWidget* parent, OptionsModel* model)
{
    if (!QSettings().value(""fAppearanceSetupDone"", false).toBool()) {
        // First make sure SystemDefault has reasonable default values if it does not support the full range of weights.
        if (fontFamily == FontFamily::SystemDefault && getSupportedWeights().size() < 4) {
            fontWeightNormal = mapSupportedWeights[FontFamily::SystemDefault].front();
            fontWeightBold = mapSupportedWeights[FontFamily::SystemDefault].back();
            QSettings().setValue(""fontWeightNormal"", weightToArg(fontWeightNormal));
            QSettings().setValue(""fontWeightBold"", weightToArg(fontWeightBold));
        }
        // Create the dialog
        QDialog dlg(parent);
        dlg.setObjectName(""AppearanceSetup"");
        dlg.setWindowTitle(QObject::tr(""Appearance Setup""));
        dlg.setWindowIcon(QIcon("":icons/bitcoin""));
        // And the widgets we add to it
        QLabel lblHeading(QObject::tr(""Please choose your preferred settings for the appearance of %1"").arg(QObject::tr(PACKAGE_NAME)), &dlg);
        lblHeading.setObjectName(""lblHeading"");
        lblHeading.setWordWrap(true);
        QLabel lblSubHeading(QObject::tr(""This can also be adjusted later in the \\""Appearance\\"" tab of the preferences.""), &dlg);
        lblSubHeading.setObjectName(""lblSubHeading"");
        lblSubHeading.setWordWrap(true);
        AppearanceWidget appearance(&dlg);
        appearance.setModel(model);
        QFrame line(&dlg);
        line.setFrameShape(QFrame::HLine);
        QDialogButtonBox buttonBox(QDialogButtonBox::Save);
        // Put them into a vbox and add the vbox to the dialog
        QVBoxLayout layout;
        layout.addWidget(&lblHeading);
        layout.addWidget(&lblSubHeading);
        layout.addWidget(&line);
        layout.addWidget(&appearance);
        layout.addWidget(&buttonBox);
        dlg.setLayout(&layout);
        // Adjust the headings
        setFont({&lblHeading}, FontWeight::Bold, 16);
        setFont({&lblSubHeading}, FontWeight::Normal, 14, true);
        // Make sure the dialog closes and accepts the settings if save has been pressed
        QObject::connect(&buttonBox, &QDialogButtonBox::accepted, [&]() {
            QSettings().setValue(""fAppearanceSetupDone"", true);
            appearance.accept();
            dlg.accept();
        });
        // And fire it!
        dlg.exec();
    }
}

bool parseBitcoinURI(const QUrl &uri, SendCoinsRecipient *out)
{
    // return if URI is not valid or is no vuicoin: URI
    if(!uri.isValid() || uri.scheme() != QString(""vuicoin""))
        return false;

    SendCoinsRecipient rv;
    rv.address = uri.path();
    // Trim any following forward slash which may have been added by the OS
    if (rv.address.endsWith(""/"")) {
        rv.address.truncate(rv.address.length() - 1);
    }
    rv.amount = 0;

#if QT_VERSION < 0x050000
    QList<QPair<QString, QString> > items = uri.queryItems();
#else
    QUrlQuery uriQuery(uri);
    QList<QPair<QString, QString> > items = uriQuery.queryItems();
#endif

    for (QList<QPair<QString, QString> >::iterator i = items.begin(); i != items.end(); i++)
    {
        bool fShouldReturnFalse = false;
        if (i->first.startsWith(""req-""))
        {
            i->first.remove(0, 4);
            fShouldReturnFalse = true;
        }

        if (i->first == ""label"")
        {
            rv.label = i->second;
            fShouldReturnFalse = false;
        }
        if (i->first == ""IS"")
        {
            // we simply ignore IS
            fShouldReturnFalse = false;
        }
        if (i->first == ""message"")
        {
            rv.message = i->second;
            fShouldReturnFalse = false;
        }
        else if (i->first == ""amount"")
        {
            if(!i->second.isEmpty())
            {
                if(!BitcoinUnits::parse(BitcoinUnits::VUICOIN, i->second, &rv.amount))
                {
                    return false;
                }
            }
            fShouldReturnFalse = false;
        }

        if (fShouldReturnFalse)
            return false;
    }
    if(out)
    {
        *out = rv;
    }
    return true;
}

bool parseBitcoinURI(QString uri, SendCoinsRecipient *out)
{
    // Convert vuicoin:// to vuicoin:
    //
    //    Cannot handle this later, because vuicoin:// will cause Qt to see the part after // as host,
    //    which will lower-case it (and thus invalidate the address).
    if(uri.startsWith(""vuicoin://"", Qt::CaseInsensitive))
    {
        uri.replace(0, 7, ""vuicoin:"");
    }
    QUrl uriInstance(uri);
    return parseBitcoinURI(uriInstance, out);
}

bool validateBitcoinURI(const QString& uri)
{
    SendCoinsRecipient rcp;
    return parseBitcoinURI(uri, &rcp);
}

QString formatBitcoinURI(const SendCoinsRecipient &info)
{
    QString ret = QString(""vuicoin:%1"").arg(info.address);
    int paramCount = 0;

    if (info.amount)
    {
        ret += QString(""?amount=%1"").arg(BitcoinUnits::format(BitcoinUnits::VUICOIN, info.amount, false, BitcoinUnits::separatorNever));
        paramCount++;
    }

    if (!info.label.isEmpty())
    {
        QString lbl(QUrl::toPercentEncoding(info.label));
        ret += QString(""%1label=%2"").arg(paramCount == 0 ? ""?"" : ""&"").arg(lbl);
        paramCount++;
    }

    if (!info.message.isEmpty())
    {
        QString msg(QUrl::toPercentEncoding(info.message));
        ret += QString(""%1message=%2"").arg(paramCount == 0 ? ""?"" : ""&"").arg(msg);
        paramCount++;
    }

    return ret;
}

bool isDust(const QString& address, const CAmount& amount)
{
    CTxDestination dest = DecodeDestination(address.toStdString());
    CScript script = GetScriptForDestination(dest);
    CTxOut txOut(amount, script);
    return IsDust(txOut, ::dustRelayFee);
}

QString HtmlEscape(const QString& str, bool fMultiLine)
{
#if QT_VERSION < 0x050000
    QString escaped = Qt::escape(str);
#else
    QString escaped = str.toHtmlEscaped();
#endif
    escaped = escaped.replace("" "", ""&nbsp;"");
    if(fMultiLine)
    {
        escaped = escaped.replace(""\\n"", ""<br>\\n"");
    }
    return escaped;
}

QString HtmlEscape(const std::string& str, bool fMultiLine)
{
    return HtmlEscape(QString::fromStdString(str), fMultiLine);
}

void copyEntryData(QAbstractItemView *view, int column, int role)
{
    if(!view || !view->selectionModel())
        return;
    QModelIndexList selection = view->selectionModel()->selectedRows(column);

    if(!selection.isEmpty())
    {
        // Copy first item
        setClipboard(selection.at(0).data(role).toString());
    }
}

QList<QModelIndex> getEntryData(QAbstractItemView *view, int column)
{
    if(!view || !view->selectionModel())
        return QList<QModelIndex>();
    return view->selectionModel()->selectedRows(column);
}

QString getSaveFileName(QWidget *parent, const QString &caption, const QString &dir,
    const QString &filter,
    QString *selectedSuffixOut)
{
    QString selectedFilter;
    QString myDir;
    if(dir.isEmpty()) // Default to user documents location
    {
#if QT_VERSION < 0x050000
        myDir = QDesktopServices::storageLocation(QDesktopServices::DocumentsLocation);
#else
        myDir = QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
#endif
    }
    else
    {
        myDir = dir;
    }
    /* Directly convert path to native OS path separators */
    QString result = QDir::toNativeSeparators(QFileDialog::getSaveFileName(parent, caption, myDir, filter, &selectedFilter));

    /* Extract first suffix from filter pattern ""Description (*.foo)"" or ""Description (*.foo *.bar ...) */
    QRegExp filter_re("".* \\\\(\\\\*\\\\.(.*)[ \\\\)]"");
    QString selectedSuffix;
    if(filter_re.exactMatch(selectedFilter))
    {
        selectedSuffix = filter_re.cap(1);
    }

    /* Add suffix if needed */
    QFileInfo info(result);
    if(!result.isEmpty())
    {
        if(info.suffix().isEmpty() && !selectedSuffix.isEmpty())
        {
            /* No suffix specified, add selected suffix */
            if(!result.endsWith("".""))
                result.append(""."");
            result.append(selectedSuffix);
        }
    }

    /* Return selected suffix if asked to */
    if(selectedSuffixOut)
    {
        *selectedSuffixOut = selectedSuffix;
    }
    return result;
}

QString getOpenFileName(QWidget *parent, const QString &caption, const QString &dir,
    const QString &filter,
    QString *selectedSuffixOut)
{
    QString selectedFilter;
    QString myDir;
    if(dir.isEmpty()) // Default to user documents location
    {
#if QT_VERSION < 0x050000
        myDir = QDesktopServices::storageLocation(QDesktopServices::DocumentsLocation);
#else
        myDir = QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
#endif
    }
    else
    {
        myDir = dir;
    }
    /* Directly convert path to native OS path separators */
    QString result = QDir::toNativeSeparators(QFileDialog::getOpenFileName(parent, caption, myDir, filter, &selectedFilter));

    if(selectedSuffixOut)
    {
        /* Extract first suffix from filter pattern ""Description (*.foo)"" or ""Description (*.foo *.bar ...) */
        QRegExp filter_re("".* \\\\(\\\\*\\\\.(.*)[ \\\\)]"");
        QString selectedSuffix;
        if(filter_re.exactMatch(selectedFilter))
        {
            selectedSuffix = filter_re.cap(1);
        }
        *selectedSuffixOut = selectedSuffix;
    }
    return result;
}

Qt::ConnectionType blockingGUIThreadConnection()
{
    if(QThread::currentThread() != qApp->thread())
    {
        return Qt::BlockingQueuedConnection;
    }
    else
    {
        return Qt::DirectConnection;
    }
}

bool checkPoint(const QPoint &p, const QWidget *w)
{
    QWidget *atW = QApplication::widgetAt(w->mapToGlobal(p));
    if (!atW) return false;
    return atW->topLevelWidget() == w;
}

bool isObscured(QWidget *w)
{
    return !(checkPoint(QPoint(0, 0), w)
        && checkPoint(QPoint(w->width() - 1, 0), w)
        && checkPoint(QPoint(0, w->height() - 1), w)
        && checkPoint(QPoint(w->width() - 1, w->height() - 1), w)
        && checkPoint(QPoint(w->width() / 2, w->height() / 2), w));
}

void bringToFront(QWidget* w)
{
#ifdef Q_OS_MAC
    ForceActivation();
#endif

    if (w) {
        // activateWindow() (sometimes) helps with keyboard focus on Windows
        if (w->isMinimized()) {
            w->showNormal();
        } else {
            w->show();
        }
        w->activateWindow();
        w->raise();
    }
}

void openDebugLogfile()
{
    fs::path pathDebug = GetDataDir() / ""debug.log"";

    /* Open debug.log with the associated application */
    if (fs::exists(pathDebug))
        QDesktopServices::openUrl(QUrl::fromLocalFile(boostPathToQString(pathDebug)));
}

void openConfigfile()
{
    fs::path pathConfig = GetConfigFile(gArgs.GetArg(""-conf"", BITCOIN_CONF_FILENAME));

    /* Open vuicoin.conf with the associated application */
    if (fs::exists(pathConfig))
        QDesktopServices::openUrl(QUrl::fromLocalFile(boostPathToQString(pathConfig)));
}

void showBackups()
{
    fs::path backupsDir = GetBackupsDir();

    /* Open folder with default browser */
    if (fs::exists(backupsDir))
        QDesktopServices::openUrl(QUrl::fromLocalFile(boostPathToQString(backupsDir)));
}

void SubstituteFonts(const QString& language)
{
#if defined(Q_OS_MAC)
// Background:
// OSX's default font changed in 10.9 and Qt is unable to find it with its
// usual fallback methods when building against the 10.7 sdk or lower.
// The 10.8 SDK added a function to let it find the correct fallback font.
// If this fallback is not properly loaded, some characters may fail to
// render correctly.
//
// The same thing happened with 10.10. .Helvetica Neue DeskInterface is now default.
//
// Solution: If building with the 10.7 SDK or lower and the user's platform
// is 10.9 or higher at runtime, substitute the correct font. This needs to
// happen before the QApplication is created.
#if defined(MAC_OS_X_VERSION_MAX_ALLOWED) && MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_8
    if (floor(NSAppKitVersionNumber) > NSAppKitVersionNumber10_8)
    {
        if (floor(NSAppKitVersionNumber) <= NSAppKitVersionNumber10_9)
            /* On a 10.9 - 10.9.x system */
            QFont::insertSubstitution("".Lucida Grande UI"", ""Lucida Grande"");
        else
        {
            /* 10.10 or later system */
            if (language == ""zh_CN"" || language == ""zh_TW"" || language == ""zh_HK"") // traditional or simplified Chinese
              QFont::insertSubstitution("".Helvetica Neue DeskInterface"", ""Heiti SC"");
            else if (language == ""ja"") // Japanese
              QFont::insertSubstitution("".Helvetica Neue DeskInterface"", ""Songti SC"");
            else
              QFont::insertSubstitution("".Helvetica Neue DeskInterface"", ""Lucida Grande"");
        }
    }
#endif
#endif
}

ToolTipToRichTextFilter::ToolTipToRichTextFilter(int _size_threshold, QObject *parent) :
    QObject(parent),
    size_threshold(_size_threshold)
{

}

bool ToolTipToRichTextFilter::eventFilter(QObject *obj, QEvent *evt)
{
    if(evt->type() == QEvent::ToolTipChange)
    {
        QWidget *widget = static_cast<QWidget*>(obj);
        QString tooltip = widget->toolTip();
        if(tooltip.size() > size_threshold && !tooltip.startsWith(""<qt""))
        {
            // Escape the current message as HTML and replace \\n by <br> if it's not rich text
            if(!Qt::mightBeRichText(tooltip))
                tooltip = HtmlEscape(tooltip, true);
            // Envelop with <qt></qt> to make sure Qt detects every tooltip as rich text
            // and style='white-space:pre' to preserve line composition
            tooltip = ""<qt style='white-space:pre'>"" + tooltip + ""</qt>"";
            widget->setToolTip(tooltip);
            return true;
        }
    }
    return QObject::eventFilter(obj, evt);
}

void TableViewLastColumnResizingFixer::connectViewHeadersSignals()
{
    connect(tableView->horizontalHeader(), SIGNAL(sectionResized(int,int,int)), this, SLOT(on_sectionResized(int,int,int)));
    connect(tableView->horizontalHeader(), SIGNAL(geometriesChanged()), this, SLOT(on_geometriesChanged()));
}

// We need to disconnect these while handling the resize events, otherwise we can enter infinite loops.
void TableViewLastColumnResizingFixer::disconnectViewHeadersSignals()
{
    disconnect(tableView->horizontalHeader(), SIGNAL(sectionResized(int,int,int)), this, SLOT(on_sectionResized(int,int,int)));
    disconnect(tableView->horizontalHeader(), SIGNAL(geometriesChanged()), this, SLOT(on_geometriesChanged()));
}

// Setup the resize mode, handles compatibility for Qt5 and below as the method signatures changed.
// Refactored here for readability.
void TableViewLastColumnResizingFixer::setViewHeaderResizeMode(int logicalIndex, QHeaderView::ResizeMode resizeMode)
{
#if QT_VERSION < 0x050000
    tableView->horizontalHeader()->setResizeMode(logicalIndex, resizeMode);
#else
    tableView->horizontalHeader()->setSectionResizeMode(logicalIndex, resizeMode);
#endif
}

void TableViewLastColumnResizingFixer::resizeColumn(int nColumnIndex, int width)
{
    tableView->setColumnWidth(nColumnIndex, width);
    tableView->horizontalHeader()->resizeSection(nColumnIndex, width);
}

int TableViewLastColumnResizingFixer::getColumnsWidth()
{
    int nColumnsWidthSum = 0;
    for (int i = 0; i < columnCount; i++)
    {
        nColumnsWidthSum += tableView->horizontalHeader()->sectionSize(i);
    }
    return nColumnsWidthSum;
}

int TableViewLastColumnResizingFixer::getAvailableWidthForColumn(int column)
{
    int nResult = lastColumnMinimumWidth;
    int nTableWidth = tableView->horizontalHeader()->width();

    if (nTableWidth > 0)
    {
        int nOtherColsWidth = getColumnsWidth() - tableView->horizontalHeader()->sectionSize(column);
        nResult = std::max(nResult, nTableWidth - nOtherColsWidth);
    }

    return nResult;
}

// Make sure we don't make the columns wider than the table's viewport width.
void TableViewLastColumnResizingFixer::adjustTableColumnsWidth()
{
    disconnectViewHeadersSignals();
    resizeColumn(lastColumnIndex, getAvailableWidthForColumn(lastColumnIndex));
    connectViewHeadersSignals();

    int nTableWidth = tableView->horizontalHeader()->width();
    int nColsWidth = getColumnsWidth();
    if (nColsWidth > nTableWidth)
    {
        resizeColumn(secondToLastColumnIndex,getAvailableWidthForColumn(secondToLastColumnIndex));
    }
}

// Make column use all the space available, useful during window resizing.
void TableViewLastColumnResizingFixer::stretchColumnWidth(int column)
{
    disconnectViewHeadersSignals();
    resizeColumn(column, getAvailableWidthForColumn(column));
    connectViewHeadersSignals();
}

// When a section is resized this is a slot-proxy for ajustAmountColumnWidth().
void TableViewLastColumnResizingFixer::on_sectionResized(int logicalIndex, int oldSize, int newSize)
{
    adjustTableColumnsWidth();
    int remainingWidth = getAvailableWidthForColumn(logicalIndex);
    if (newSize > remainingWidth)
    {
       resizeColumn(logicalIndex, remainingWidth);
    }
}

// When the table's geometry is ready, we manually perform the stretch of the ""Message"" column,
// as the ""Stretch"" resize mode does not allow for interactive resizing.
void TableViewLastColumnResizingFixer::on_geometriesChanged()
{
    if ((getColumnsWidth() - this->tableView->horizontalHeader()->width()) != 0)
    {
        disconnectViewHeadersSignals();
        resizeColumn(secondToLastColumnIndex, getAvailableWidthForColumn(secondToLastColumnIndex));
        connectViewHeadersSignals();
    }
}

/**
 * Initializes all internal variables and prepares the
 * the resize modes of the last 2 columns of the table and
 */
TableViewLastColumnResizingFixer::TableViewLastColumnResizingFixer(QTableView* table, int lastColMinimumWidth, int allColsMinimumWidth, QObject *parent) :
    QObject(parent),
    tableView(table),
    lastColumnMinimumWidth(lastColMinimumWidth),
    allColumnsMinimumWidth(allColsMinimumWidth)
{
    columnCount = tableView->horizontalHeader()->count();
    lastColumnIndex = columnCount - 1;
    secondToLastColumnIndex = columnCount - 2;
    tableView->horizontalHeader()->setMinimumSectionSize(allColumnsMinimumWidth);
    setViewHeaderResizeMode(secondToLastColumnIndex, QHeaderView::Interactive);
    setViewHeaderResizeMode(lastColumnIndex, QHeaderView::Interactive);
}

#ifdef WIN32
fs::path static StartupShortcutPath()
{
    std::string chain = gArgs.GetChainName();
    if (chain == CBaseChainParams::MAIN)
        return GetSpecialFolderPath(CSIDL_STARTUP) / ""Vuicoin Core.lnk"";
    if (chain == CBaseChainParams::TESTNET) // Remove this special case when CBaseChainParams::TESTNET = ""testnet4""
        return GetSpecialFolderPath(CSIDL_STARTUP) / ""Vuicoin Core (testnet).lnk"";
    return GetSpecialFolderPath(CSIDL_STARTUP) / strprintf(""Vuicoin Core (%s).lnk"", chain);
}

bool GetStartOnSystemStartup()
{
    // check for ""Vuicoin Core*.lnk""
    return fs::exists(StartupShortcutPath());
}

bool SetStartOnSystemStartup(bool fAutoStart)
{
    // If the shortcut exists already, remove it for updating
    fs::remove(StartupShortcutPath());

    if (fAutoStart)
    {
        CoInitialize(nullptr);

        // Get a pointer to the IShellLink interface.
        IShellLink* psl = nullptr;
        HRESULT hres = CoCreateInstance(CLSID_ShellLink, nullptr,
            CLSCTX_INPROC_SERVER, IID_IShellLink,
            reinterpret_cast<void**>(&psl));

        if (SUCCEEDED(hres))
        {
            // Get the current executable path
            TCHAR pszExePath[MAX_PATH];
            GetModuleFileName(nullptr, pszExePath, sizeof(pszExePath));

            // Start client minimized
            QString strArgs = ""-min"";
            // Set -testnet /-regtest options
            strArgs += QString::fromStdString(strprintf("" -testnet=%d -regtest=%d"", gArgs.GetBoolArg(""-testnet"", false), gArgs.GetBoolArg(""-regtest"", false)));

#ifdef UNICODE
            boost::scoped_array<TCHAR> args(new TCHAR[strArgs.length() + 1]);
            // Convert the QString to TCHAR*
            strArgs.toWCharArray(args.get());
            // Add missing '\\0'-termination to string
            args[strArgs.length()] = '\\0';
#endif

            // Set the path to the shortcut target
            psl->SetPath(pszExePath);
            PathRemoveFileSpec(pszExePath);
            psl->SetWorkingDirectory(pszExePath);
            psl->SetShowCmd(SW_SHOWMINNOACTIVE);
#ifndef UNICODE
            psl->SetArguments(strArgs.toStdString().c_str());
#else
            psl->SetArguments(args.get());
#endif

            // Query IShellLink for the IPersistFile interface for
            // saving the shortcut in persistent storage.
            IPersistFile* ppf = nullptr;
            hres = psl->QueryInterface(IID_IPersistFile, reinterpret_cast<void**>(&ppf));
            if (SUCCEEDED(hres))
            {
                WCHAR pwsz[MAX_PATH];
                // Ensure that the string is ANSI.
                MultiByteToWideChar(CP_ACP, 0, StartupShortcutPath().string().c_str(), -1, pwsz, MAX_PATH);
                // Save the link by calling IPersistFile::Save.
                hres = ppf->Save(pwsz, TRUE);
                ppf->Release();
                psl->Release();
                CoUninitialize();
                return true;
            }
            psl->Release();
        }
        CoUninitialize();
        return false;
    }
    return true;
}
#elif defined(Q_OS_LINUX)

// Follow the Desktop Application Autostart Spec:
// http://standards.freedesktop.org/autostart-spec/autostart-spec-latest.html

fs::path static GetAutostartDir()
{
    char* pszConfigHome = getenv(""XDG_CONFIG_HOME"");
    if (pszConfigHome) return fs::path(pszConfigHome) / ""autostart"";
    char* pszHome = getenv(""HOME"");
    if (pszHome) return fs::path(pszHome) / "".config"" / ""autostart"";
    return fs::path();
}

fs::path static GetAutostartFilePath()
{
    std::string chain = gArgs.GetChainName();
    if (chain == CBaseChainParams::MAIN)
        return GetAutostartDir() / ""vuicoincore.desktop"";
    return GetAutostartDir() / strprintf(""vuicoincore-%s.lnk"", chain);
}

bool GetStartOnSystemStartup()
{
    fs::ifstream optionFile(GetAutostartFilePath());
    if (!optionFile.good())
        return false;
    // Scan through file for ""Hidden=true"":
    std::string line;
    while (!optionFile.eof())
    {
        getline(optionFile, line);
        if (line.find(""Hidden"") != std::string::npos &&
            line.find(""true"") != std::string::npos)
            return false;
    }
    optionFile.close();

    return true;
}

bool SetStartOnSystemStartup(bool fAutoStart)
{
    if (!fAutoStart)
        fs::remove(GetAutostartFilePath());
    else
    {
        char pszExePath[MAX_PATH+1];
        ssize_t r = readlink(""/proc/self/exe"", pszExePath, sizeof(pszExePath) - 1);
        if (r == -1)
            return false;
        pszExePath[r] = '\\0';

        fs::create_directories(GetAutostartDir());

        fs::ofstream optionFile(GetAutostartFilePath(), std::ios_base::out|std::ios_base::trunc);
        if (!optionFile.good())
            return false;
        std::string chain = gArgs.GetChainName();
        // Write a vuicoincore.desktop file to the autostart directory:
        optionFile << ""[Desktop Entry]\\n"";
        optionFile << ""Type=Application\\n"";
        if (chain == CBaseChainParams::MAIN)
            optionFile << ""Name=Vuicoin Core\\n"";
        else
            optionFile << strprintf(""Name=Vuicoin Core (%s)\\n"", chain);
        optionFile << ""Exec="" << pszExePath << strprintf("" -min -testnet=%d -regtest=%d\\n"", gArgs.GetBoolArg(""-testnet"", false), gArgs.GetBoolArg(""-regtest"", false));
        optionFile << ""Terminal=false\\n"";
        optionFile << ""Hidden=false\\n"";
        optionFile.close();
    }
    return true;
}


#elif defined(Q_OS_MAC)
// based on: https://github.com/Mozketo/LaunchAtLoginController/blob/master/LaunchAtLoginController.m

LSSharedFileListItemRef findStartupItemInList(LSSharedFileListRef list, CFURLRef findUrl);
LSSharedFileListItemRef findStartupItemInList(LSSharedFileListRef list, CFURLRef findUrl)
{
    CFArrayRef listSnapshot = LSSharedFileListCopySnapshot(list, nullptr);
    if (listSnapshot == nullptr) {
        return nullptr;
    }

    // loop through the list of startup items and try to find the Vuicoin Core app
    for(int i = 0; i < CFArrayGetCount(listSnapshot); i++) {
        LSSharedFileListItemRef item = (LSSharedFileListItemRef)CFArrayGetValueAtIndex(listSnapshot, i);
        UInt32 resolutionFlags = kLSSharedFileListNoUserInteraction | kLSSharedFileListDoNotMountVolumes;
        CFURLRef currentItemURL = nullptr;

#if defined(MAC_OS_X_VERSION_MAX_ALLOWED) && MAC_OS_X_VERSION_MAX_ALLOWED >= 10100
        if(&LSSharedFileListItemCopyResolvedURL)
            currentItemURL = LSSharedFileListItemCopyResolvedURL(item, resolutionFlags, nullptr);
#if defined(MAC_OS_X_VERSION_MIN_REQUIRED) && MAC_OS_X_VERSION_MIN_REQUIRED < 10100
        else
            LSSharedFileListItemResolve(item, resolutionFlags, &currentItemURL, nullptr);
#endif
#else
        LSSharedFileListItemResolve(item, resolutionFlags, &currentItemURL, nullptr);
#endif

        if(currentItemURL) {
            if (CFEqual(currentItemURL, findUrl)) {
                // found
                CFRelease(listSnapshot);
                CFRelease(currentItemURL);
                return item;
            }
            CFRelease(currentItemURL);
        }
    }

    CFRelease(listSnapshot);
    return nullptr;
}

bool GetStartOnSystemStartup()
{
    CFURLRef bitcoinAppUrl = CFBundleCopyBundleURL(CFBundleGetMainBundle());
    if (bitcoinAppUrl == nullptr) {
        return false;
    }

    LSSharedFileListRef loginItems = LSSharedFileListCreate(nullptr, kLSSharedFileListSessionLoginItems, nullptr);
    LSSharedFileListItemRef foundItem = findStartupItemInList(loginItems, bitcoinAppUrl);

    CFRelease(bitcoinAppUrl);
    return !!foundItem; // return boolified object
}

bool SetStartOnSystemStartup(bool fAutoStart)
{
    CFURLRef bitcoinAppUrl = CFBundleCopyBundleURL(CFBundleGetMainBundle());
    if (bitcoinAppUrl == nullptr) {
        return false;
    }

    LSSharedFileListRef loginItems = LSSharedFileListCreate(nullptr, kLSSharedFileListSessionLoginItems, nullptr);
    LSSharedFileListItemRef foundItem = findStartupItemInList(loginItems, bitcoinAppUrl);

    if(fAutoStart && !foundItem) {
        // add Vuicoin Core app to startup item list
        LSSharedFileListInsertItemURL(loginItems, kLSSharedFileListItemBeforeFirst, nullptr, nullptr, bitcoinAppUrl, nullptr, nullptr);
    }
    else if(!fAutoStart && foundItem) {
        // remove item
        LSSharedFileListItemRemove(loginItems, foundItem);
    }

    CFRelease(bitcoinAppUrl);
    return true;
}
#pragma GCC diagnostic pop
#else

bool GetStartOnSystemStartup() { return false; }
bool SetStartOnSystemStartup(bool fAutoStart) { return false; }

#endif

void migrateQtSettings()
{
    // Migration (12.1)
    QSettings settings;
    if(!settings.value(""fMigrationDone121"", false).toBool()) {
        settings.remove(""theme"");
        settings.remove(""nWindowPos"");
        settings.remove(""nWindowSize"");
        settings.setValue(""fMigrationDone121"", true);
    }
}

void setStyleSheetDirectory(const QString& path)
{
    stylesheetDirectory = path;
}

bool isStyleSheetDirectoryCustom()
{
    return stylesheetDirectory != defaultStylesheetDirectory;
}

const std::vector<QString> listStyleSheets()
{
    std::vector<QString> vecStylesheets;
    for (const auto& it : mapStyleToTheme) {
        vecStylesheets.push_back(it.first);
    }
    return vecStylesheets;
}

const std::vector<QString> listThemes()
{
    std::vector<QString> vecThemes;
    for (const auto& it : mapStyleToTheme) {
        if (!it.second.isEmpty()) {
            vecThemes.push_back(it.second);
        }
    }
    return vecThemes;
}

const QString getDefaultTheme()
{
    return defaultTheme;
}

const bool isValidTheme(const QString& strTheme)
{
    return strTheme == defaultTheme || strTheme == darkThemePrefix || strTheme == traditionalTheme;
}

void loadStyleSheet(QWidget* widget, bool fForceUpdate)
{
    AssertLockNotHeld(cs_css);
    LOCK(cs_css);

    static std::unique_ptr<QString> stylesheet;
    static std::set<QWidget*> setWidgets;

    bool fDebugCustomStyleSheets = gArgs.GetBoolArg(""-debug-ui"", false) && isStyleSheetDirectoryCustom();
    bool fStyleSheetChanged = false;

    if (stylesheet == nullptr || fForceUpdate || fDebugCustomStyleSheets) {
        auto hasModified = [](const std::vector<QString>& vecFiles) -> bool {
            static std::map<const QString, QDateTime> mapLastModified;

            bool fModified = false;
            for (auto file = vecFiles.begin(); file != vecFiles.end() && !fModified; ++file) {
                QFileInfo info(*file);
                QDateTime lastModified = info.lastModified(), prevLastModified;
                auto it = mapLastModified.emplace(std::make_pair(*file, lastModified));
                prevLastModified = it.second ? QDateTime() : it.first->second;
                it.first->second = lastModified;
                fModified = prevLastModified != lastModified;
            }
            return fModified;
        };

        auto loadFiles = [&](const std::vector<QString>& vecFiles) -> bool {
            if (!fForceUpdate && fDebugCustomStyleSheets && !hasModified(vecFiles)) {
                return false;
            }

            std::string platformName = gArgs.GetArg(""-uiplatform"", BitcoinGUI::DEFAULT_UIPLATFORM);
            stylesheet = std::make_unique<QString>();

            for (const auto& file : vecFiles) {
                QFile qFile(file);
                if (!qFile.open(QFile::ReadOnly)) {
                    throw std::runtime_error(strprintf(""%s: Failed to open file: %s"", __func__, file.toStdString()));
                }

                QString strStyle = QLatin1String(qFile.readAll());
                // Process all <os=...></os> groups in the stylesheet first
                QRegularExpressionMatch osStyleMatch;
                QRegularExpression osStyleExp(
                        ""^""
                        ""(<os=(?:'|\\"").+(?:'|\\"")>)"" // group 1
                        ""((?:.|\\n)+?)""              // group 2
                        ""(</os>?)""                  // group 3
                        ""$"");
                osStyleExp.setPatternOptions(QRegularExpression::MultilineOption);
                QRegularExpressionMatchIterator it = osStyleExp.globalMatch(strStyle);

                // For all <os=...></os> sections
                while (it.hasNext() && (osStyleMatch = it.next()).isValid()) {
                    QStringList listMatches = osStyleMatch.capturedTexts();

                    // Full match + 3 group matches
                    if (listMatches.size() % 4) {
                        throw std::runtime_error(strprintf(""%s: Invalid <os=...></os> section in file %s"", __func__, file.toStdString()));
                    }

                    for (int i = 0; i < listMatches.size(); i += 4) {
                        if (!listMatches[i + 1].contains(QString::fromStdString(platformName))) {
                            // If os is not supported for this styles
                            // just remove the full match
                            strStyle.replace(listMatches[i], """");
                        } else {
                            // If its supported remove the <os=...></os> tags
                            strStyle.replace(listMatches[i + 1], """");
                            strStyle.replace(listMatches[i + 3], """");
                        }
                    }
                }
                stylesheet->append(strStyle);
            }
            return true;
        };

        auto pathToFile = [&](const QString& file) -> QString {
            return stylesheetDirectory + ""/"" + file + (isStyleSheetDirectoryCustom() ? "".css"" : """");
        };

        std::vector<QString> vecFiles;
        // If light/dark theme is used load general styles first
        if (vuicoinThemeActive()) {
            vecFiles.push_back(pathToFile(""general""));
        }
        vecFiles.push_back(pathToFile(getActiveTheme()));

        fStyleSheetChanged = loadFiles(vecFiles);
    }

    bool fUpdateStyleSheet = fForceUpdate || (fDebugCustomStyleSheets && fStyleSheetChanged);

    if (widget) {
        setWidgets.insert(widget);
        widget->setStyleSheet(*stylesheet);
    }

    QWidgetList allWidgets = QApplication::allWidgets();
    auto it = setWidgets.begin();
    while (it != setWidgets.end()) {
        if (!allWidgets.contains(*it)) {
            it = setWidgets.erase(it);
            continue;
        }
        if (fUpdateStyleSheet && *it != widget) {
            (*it)->setStyleSheet(*stylesheet);
        }
        ++it;
    }

    if (!ShutdownRequested() && fDebugCustomStyleSheets && !fForceUpdate) {
        QTimer::singleShot(200, [] { loadStyleSheet(); });
    }
}

FontFamily fontFamilyFromString(const QString& strFamily)
{
    if (strFamily == ""SystemDefault"") {
        return FontFamily::SystemDefault;
    }
    if (strFamily == ""Montserrat"") {
        return FontFamily::Montserrat;
    }
    throw std::invalid_argument(strprintf(""Invalid font-family: %s"", strFamily.toStdString()));
}

QString fontFamilyToString(FontFamily family)
{
    switch (family) {
    case FontFamily::SystemDefault:
        return ""SystemDefault"";
    case FontFamily::Montserrat:
        return ""Montserrat"";
    default:
        assert(false);
    }
}

void setFontFamily(FontFamily family)
{
    fontFamily = family;
    setApplicationFont();
    updateFonts();
}

FontFamily getFontFamilyDefault()
{
    return defaultFontFamily;
}

FontFamily getFontFamily()
{
    return fontFamily;
}

bool weightFromArg(int nArg, QFont::Weight& weight)
{
    const std::map<int, QFont::Weight> mapWeight{
        {0, QFont::Thin},
        {1, QFont::ExtraLight},
        {2, QFont::Light},
        {3, QFont::Normal},
        {4, QFont::Medium},
        {5, QFont::DemiBold},
        {6, QFont::Bold},
        {7, QFont::ExtraBold},
        {8, QFont::Black}
    };
    auto it = mapWeight.find(nArg);
    if (it == mapWeight.end()) {
        return false;
    }
    weight = it->second;
    return true;
}

int weightToArg(const QFont::Weight weight)
{
    const std::map<QFont::Weight, int> mapWeight{
        {QFont::Thin, 0},
        {QFont::ExtraLight, 1},
        {QFont::Light, 2},
        {QFont::Normal, 3},
        {QFont::Medium, 4},
        {QFont::DemiBold, 5},
        {QFont::Bold, 6},
        {QFont::ExtraBold, 7},
        {QFont::Black, 8}
    };
    assert(mapWeight.count(weight));
    return mapWeight.find(weight)->second;
}

QFont::Weight getFontWeightNormalDefault()
{
    return defaultFontWeightNormal;
}

QFont::Weight toQFontWeight(FontWeight weight)
{
    return weight == FontWeight::Bold ? getFontWeightBold() : getFontWeightNormal();
}

QFont::Weight getFontWeightNormal()
{
    return fontWeightNormal;
}

void setFontWeightNormal(QFont::Weight weight)
{
    fontWeightNormal = weight;
    updateFonts();
}

QFont::Weight getFontWeightBoldDefault()
{
    return defaultFontWeightBold;
}

QFont::Weight getFontWeightBold()
{
    return fontWeightBold;
}

void setFontWeightBold(QFont::Weight weight)
{
    fontWeightBold = weight;
    updateFonts();
}

int getFontScaleDefault()
{
    return defaultFontScale;
}

int getFontScale()
{
    return fontScale;
}

void setFontScale(int nScale)
{
    fontScale = nScale;
    updateFonts();
}

double getScaledFontSize(int nSize)
{
    return std::round(nSize * (1 + (fontScale * fontScaleSteps)) * 4) / 4.0;
}

bool loadFonts()
{
    // Before any font changes store the applications default font to use it as SystemDefault.
    osDefaultFont = std::make_unique<QFont>(QApplication::font());

    QString family = fontFamilyToString(FontFamily::Montserrat);
    QString italic = ""Italic"";

    std::map<QString, bool> mapStyles{
        {""Thin"", true},
        {""ExtraLight"", true},
        {""Light"", true},
        {""Italic"", false},
        {""Regular"", false},
        {""Medium"", true},
        {""SemiBold"", true},
        {""Bold"", true},
        {""ExtraBold"", true},
        {""Black"", true},
    };

    QFontDatabase database;
    std::vector<int> vecFontIds;

    for (const auto& it : mapStyles) {
        QString font = "":fonts/"" + family + ""-"" + it.first;
        vecFontIds.push_back(QFontDatabase::addApplicationFont(font));
        qDebug() << __func__ << "": "" << font << "" loaded with id "" << vecFontIds.back();
        if (it.second) {
            vecFontIds.push_back(QFontDatabase::addApplicationFont(font + italic));
            qDebug() << __func__ << "": "" << font + italic << "" loaded with id "" << vecFontIds.back();
        }
    }

    // Fail if an added id is -1 which means QFontDatabase::addApplicationFont failed.
    if (std::find(vecFontIds.begin(), vecFontIds.end(), -1) != vecFontIds.end()) {
        return false;
    }

    // Print debug logs for added fonts fetched by the added ids
    for (const auto& i : vecFontIds) {
        auto families = QFontDatabase::applicationFontFamilies(i);
        for (const QString& f : families) {
            qDebug() << __func__ << "": - Font id "" << i << "" is family: "" << f;
            const QStringList fontStyles = database.styles(f);
            for (const QString& style : fontStyles) {
                qDebug() << __func__ << "": Style for family "" << f << "" with id: "" << i << "": "" << style;
            }
        }
    }
    // Print debug logs for added fonts fetched by the family name
    const QStringList fontFamilies = database.families();
    for (const QString& f : fontFamilies) {
        if (f.contains(family)) {
            const QStringList fontStyles = database.styles(f);
            for (const QString& style : fontStyles) {
                qDebug() << __func__ << "": Family: "" << f << "", Style: "" << style;
            }
        }
    }

    // Load font related settings
    QSettings settings;
    QFont::Weight weight;

    if (!gArgs.IsArgSet(""-font-family"")) {
        fontFamily = fontFamilyFromString(settings.value(""fontFamily"").toString());
    }

    if (!gArgs.IsArgSet(""-font-scale"")) {
        fontScale = settings.value(""fontScale"").toInt();
    }

    if (!gArgs.IsArgSet(""-font-weight-normal"") && weightFromArg(settings.value(""fontWeightNormal"").toInt(), weight)) {
        fontWeightNormal = weight;
    }

    if (!gArgs.IsArgSet(""-font-weight-bold"") && weightFromArg(settings.value(""fontWeightBold"").toInt(), weight)) {
        fontWeightBold = weight;
    }

    setApplicationFont();

    // Initialize supported font weights for all available fonts
    // Generate a vector with supported font weights by comparing the width of a certain test text for all font weights
    auto supportedWeights = [](FontFamily family) -> std::vector<QFont::Weight> {
        auto getTestWidth = [&](QFont::Weight weight) -> int {
            QFont font = getFont(family, weight, false, defaultFontSize);
            return QFontMetrics(font).width(""Check the width of this text to see if the weight change has an impact!"");
        };
        std::vector<QFont::Weight> vecWeights{QFont::Thin, QFont::ExtraLight, QFont::Light,
                                              QFont::Normal, QFont::Medium, QFont::DemiBold,
                                              QFont::Bold, QFont::Black};
        std::vector<QFont::Weight> vecSupported;
        QFont::Weight prevWeight = vecWeights.front();
        for (auto weight = vecWeights.begin() + 1; weight != vecWeights.end(); ++weight) {
            if (getTestWidth(prevWeight) != getTestWidth(*weight)) {
                if (vecSupported.empty()) {
                    vecSupported.push_back(prevWeight);
                }
                vecSupported.push_back(*weight);
            }
            prevWeight = *weight;
        }
        return vecSupported;
    };

    mapSupportedWeights.insert(std::make_pair(FontFamily::SystemDefault, supportedWeights(FontFamily::SystemDefault)));
    mapSupportedWeights.insert(std::make_pair(FontFamily::Montserrat, supportedWeights(FontFamily::Montserrat)));

    return true;
}

void setApplicationFont()
{
    std::unique_ptr<QFont> font;

    if (fontFamily == FontFamily::Montserrat) {
        QString family = fontFamilyToString(FontFamily::Montserrat);
#ifdef Q_OS_MAC
        if (getFontWeightNormal() != getFontWeightNormalDefault()) {
            font = std::make_unique<QFont>(getFontNormal());
        } else {
            font = std::make_unique<QFont>(family);
            font->setWeight(getFontWeightNormalDefault());
        }
#else
        font = std::make_unique<QFont>(family);
        font->setWeight(getFontWeightNormal());
#endif
    } else {
        font = std::make_unique<QFont>(*osDefaultFont);
    }

    font->setPointSizeF(defaultFontSize);
    qApp->setFont(*font);

    qDebug() << __func__ << "": "" << qApp->font().toString() <<
                "" family: "" << qApp->font().family() <<
                "", style: "" << qApp->font().styleName() <<
                "" match: "" << qApp->font().exactMatch();
}

void setFont(const std::vector<QWidget*>& vecWidgets, FontWeight weight, int nPointSize, bool fItalic)
{
    for (auto it : vecWidgets) {
        auto fontAttributes = std::make_tuple(weight, fItalic, nPointSize);
        auto itFontUpdate = mapFontUpdates.emplace(std::make_pair(it, fontAttributes));
        if (!itFontUpdate.second) {
            itFontUpdate.first->second = fontAttributes;
        }
    }
}

void updateFonts()
{
    // Fonts need to be loaded by GUIIUtil::loadFonts(), if not just return.
    if (!osDefaultFont) {
        return;
    }

    static std::map<QPointer<QWidget>, int> mapWidgetDefaultFontSizes;

    // QPointer becomes nullptr for objects that were deleted.
    // Remove them from mapDefaultFontSize and mapFontUpdates
    // before proceeding any further.
    size_t nRemovedDefaultFonts{0};
    auto itd = mapWidgetDefaultFontSizes.begin();
    while (itd != mapWidgetDefaultFontSizes.end()) {
        if (itd->first.isNull()) {
            itd = mapWidgetDefaultFontSizes.erase(itd);
            ++nRemovedDefaultFonts;
        } else {
            ++itd;
        }
    }

    size_t nRemovedFontUpdates{0};
    auto itn = mapFontUpdates.begin();
    while (itn != mapFontUpdates.end()) {
        if (itn->first.isNull()) {
            itn = mapFontUpdates.erase(itn);
            ++nRemovedFontUpdates;
        } else {
            ++itn;
        }
    }

    size_t nUpdatable{0}, nUpdated{0};
    std::map<QWidget*, QFont> mapWidgetFonts;
    // Loop through all widgets
    for (QWidget* w : qApp->allWidgets()) {
        std::vector<QString> vecIgnore{
            ""QWidget"", ""QDialog"", ""QFrame"", ""QStackedWidget"", ""QDesktopWidget"", ""QDesktopScreenWidget"",
            ""QTipLabel"", ""QMessageBox"", ""QMenu"", ""QComboBoxPrivateScroller"", ""QComboBoxPrivateContainer"",
            ""QScrollBar"", ""QListView"", ""BitcoinGUI"", ""WalletView"", ""WalletFrame""
        };
        if (std::find(vecIgnore.begin(), vecIgnore.end(), w->metaObject()->className()) != vecIgnore.end()) {
            continue;
        }
        ++nUpdatable;

        QFont font = w->font();
        assert(font.pointSize() > 0);
        font.setFamily(qApp->font().family());
        font.setWeight(getFontWeightNormal());
        font.setStyleName(qApp->font().styleName());
        font.setStyle(qApp->font().style());

        // Insert/Get the default font size of the widget
        auto itDefault = mapWidgetDefaultFontSizes.emplace(w, font.pointSize());

        auto it = mapFontUpdates.find(w);
        if (it != mapFontUpdates.end()) {
            int nSize = std::get<2>(it->second);
            if (nSize == -1) {
                nSize = itDefault.first->second;
            }
            font = getFont(std::get<0>(it->second), std::get<1>(it->second), nSize);
        } else {
            font.setPointSizeF(getScaledFontSize(itDefault.first->second));
        }

        if (w->font() != font) {
            auto itWidgetFont = mapWidgetFonts.emplace(w, font);
            assert(itWidgetFont.second);
            ++nUpdated;
        }
    }
    qDebug().nospace() << __func__ << "" - widget counts: updated/updatable/total("" << nUpdated << ""/"" << nUpdatable << ""/"" << qApp->allWidgets().size() << "")""
             << "", removed items: mapWidgetDefaultFontSizes/mapFontUpdates("" << nRemovedDefaultFonts << ""/"" << nRemovedFontUpdates << "")"";

    // Perform the required font updates
    // NOTE: This is done as seperate step to avoid scaling issues due to font inheritance
    //       hence all fonts are calculated and stored in mapWidgetFonts above.
    for (auto it : mapWidgetFonts) {
        it.first->setFont(it.second);
    }

    // Scale the global font size for the classes in the map below
    static std::map<std::string, int> mapClassFontUpdates{
        {""QTipLabel"", -1}, {""QMenu"", -1}, {""QMessageBox"", -1}
    };
    for (auto& it : mapClassFontUpdates) {
        QFont fontClass = qApp->font(it.first.c_str());
        if (it.second == -1) {
            it.second = fontClass.pointSize();
        }
        double dSize = getScaledFontSize(it.second);
        if (fontClass.pointSizeF() != dSize) {
            fontClass.setPointSizeF(dSize);
            qApp->setFont(fontClass, it.first.c_str());
        }
    }
}

QFont getFont(FontFamily family, QFont::Weight qWeight, bool fItalic, int nPointSize)
{
    QFont font;

    if (family == FontFamily::Montserrat) {
        static std::map<QFont::Weight, QString> mapMontserratMapping{
            {QFont::Thin, ""Thin""},
            {QFont::ExtraLight, ""ExtraLight""},
            {QFont::Light, ""Light""},
            {QFont::Medium, ""Medium""},
            {QFont::DemiBold, ""SemiBold""},
            {QFont::ExtraBold, ""ExtraBold""},
            {QFont::Black, ""Black""},
#ifdef Q_OS_MAC
            {QFont::Normal, ""Regular""},
            {QFont::Bold, ""Bold""},
#else
            {QFont::Normal, """"},
            {QFont::Bold, """"},
#endif
        };

        assert(mapMontserratMapping.count(qWeight));

#ifdef Q_OS_MAC

        QString styleName = mapMontserratMapping[qWeight];

        if (fItalic) {
            if (styleName == ""Regular"") {
                styleName = ""Italic"";
            } else {
                styleName += "" Italic"";
            }
        }

        font.setFamily(fontFamilyToString(FontFamily::Montserrat));
        font.setStyleName(styleName);
#else
        font.setFamily(fontFamilyToString(FontFamily::Montserrat) + "" "" + mapMontserratMapping[qWeight]);
        font.setWeight(qWeight);
        font.setStyle(fItalic ? QFont::StyleItalic : QFont::StyleNormal);
#endif
    } else {
        font.setFamily(osDefaultFont->family());
        font.setWeight(qWeight);
        font.setStyle(fItalic ? QFont::StyleItalic : QFont::StyleNormal);
    }

    if (nPointSize != -1) {
        font.setPointSizeF(getScaledFontSize(nPointSize));
    }

    if (gArgs.GetBoolArg(""-debug-ui"", false)) {
        qDebug() << __func__ << "": font size: "" << font.pointSizeF() << "" family: "" << font.family() << "", style: "" << font.styleName() << "", weight:"" << font.weight() << "" match: "" << font.exactMatch();
    }

    return font;
}

QFont getFont(QFont::Weight qWeight, bool fItalic, int nPointSize)
{
    return getFont(fontFamily, qWeight, fItalic, nPointSize);
}
QFont getFont(FontWeight weight, bool fItalic, int nPointSize)
{
    return getFont(toQFontWeight(weight), fItalic, nPointSize);
}

QFont getFontNormal()
{
    return getFont(FontWeight::Normal);
}

QFont getFontBold()
{
    return getFont(FontWeight::Bold);
}

std::vector<QFont::Weight> getSupportedWeights()
{
    assert(mapSupportedWeights.count(fontFamily));
    return mapSupportedWeights[fontFamily];
}

QFont::Weight supportedWeightFromIndex(int nIndex)
{
    auto vecWeights = getSupportedWeights();
    assert(vecWeights.size() > nIndex);
    return vecWeights[nIndex];
}

int supportedWeightToIndex(QFont::Weight weight)
{
    auto vecWeights = getSupportedWeights();
    for (int index = 0; index < vecWeights.size(); ++index) {
        if (weight == vecWeights[index]) {
            return index;
        }
    }
    assert(false);
}

QString getActiveTheme()
{
    QSettings settings;
    return settings.value(""theme"", defaultTheme).toString();
}

bool vuicoinThemeActive()
{
    QSettings settings;
    QString theme = settings.value(""theme"", """").toString();
    return theme != traditionalTheme;
}

void loadTheme(QWidget* widget, bool fForce)
{
    loadStyleSheet(widget, fForce);
    updateFonts();
    updateMacFocusRects();
}

void disableMacFocusRect(const QWidget* w)
{
#ifdef Q_OS_MAC
    for (const auto& c : w->findChildren<QWidget*>()) {
        if (c->testAttribute(Qt::WA_MacShowFocusRect)) {
            c->setAttribute(Qt::WA_MacShowFocusRect, !vuicoinThemeActive());
            setRectsDisabled.emplace(c);
        }
    }
#endif
}

void updateMacFocusRects()
{
#ifdef Q_OS_MAC
    QWidgetList allWidgets = QApplication::allWidgets();
    auto it = setRectsDisabled.begin();
    while (it != setRectsDisabled.end()) {
        if (allWidgets.contains(*it)) {
            (*it)->setAttribute(Qt::WA_MacShowFocusRect, !vuicoinThemeActive());
            ++it;
        } else {
            it = setRectsDisabled.erase(it);
        }
    }
#endif
}

void setClipboard(const QString& str)
{
    QApplication::clipboard()->setText(str, QClipboard::Clipboard);
    QApplication::clipboard()->setText(str, QClipboard::Selection);
}

fs::path qstringToBoostPath(const QString &path)
{
    return fs::path(path.toStdString(), utf8);
}

QString boostPathToQString(const fs::path &path)
{
    return QString::fromStdString(path.string(utf8));
}

QString formatDurationStr(int secs)
{
    QStringList strList;
    int days = secs / 86400;
    int hours = (secs % 86400) / 3600;
    int mins = (secs % 3600) / 60;
    int seconds = secs % 60;

    if (days)
        strList.append(QString(QObject::tr(""%1 d"")).arg(days));
    if (hours)
        strList.append(QString(QObject::tr(""%1 h"")).arg(hours));
    if (mins)
        strList.append(QString(QObject::tr(""%1 m"")).arg(mins));
    if (seconds || (!days && !hours && !mins))
        strList.append(QString(QObject::tr(""%1 s"")).arg(seconds));

    return strList.join("" "");
}

QString formatServicesStr(quint64 mask)
{
    QStringList strList;

    // Just scan the last 8 bits for now.
    for (int i = 0; i < 8; i++) {
        uint64_t check = 1 << i;
        if (mask & check)
        {
            switch (check)
            {
            case NODE_NETWORK:
                strList.append(""NETWORK"");
                break;
            case NODE_GETUTXO:
                strList.append(""GETUTXO"");
                break;
            case NODE_BLOOM:
                strList.append(""BLOOM"");
                break;
            case NODE_XTHIN:
                strList.append(""XTHIN"");
                break;
            default:
                strList.append(QString(""%1[%2]"").arg(""UNKNOWN"").arg(check));
            }
        }
    }

    if (strList.size())
        return strList.join("" & "");
    else
        return QObject::tr(""None"");
}

QString formatPingTime(double dPingTime)
{
    return (dPingTime == std::numeric_limits<int64_t>::max()/1e6 || dPingTime == 0) ? QObject::tr(""N/A"") : QString(QObject::tr(""%1 ms"")).arg(QString::number((int)(dPingTime * 1000), 10));
}

QString formatTimeOffset(int64_t nTimeOffset)
{
  return QString(QObject::tr(""%1 s"")).arg(QString::number((int)nTimeOffset, 10));
}

QString formatNiceTimeOffset(qint64 secs)
{
    // Represent time from last generated block in human readable text
    QString timeBehindText;
    const int HOUR_IN_SECONDS = 60*60;
    const int DAY_IN_SECONDS = 24*60*60;
    const int WEEK_IN_SECONDS = 7*24*60*60;
    const int YEAR_IN_SECONDS = 31556952; // Average length of year in Gregorian calendar
    if(secs < 60)
    {
        timeBehindText = QObject::tr(""%n second(s)"","""",secs);
    }
    else if(secs < 2*HOUR_IN_SECONDS)
    {
        timeBehindText = QObject::tr(""%n minute(s)"","""",secs/60);
    }
    else if(secs < 2*DAY_IN_SECONDS)
    {
        timeBehindText = QObject::tr(""%n hour(s)"","""",secs/HOUR_IN_SECONDS);
    }
    else if(secs < 2*WEEK_IN_SECONDS)
    {
        timeBehindText = QObject::tr(""%n day(s)"","""",secs/DAY_IN_SECONDS);
    }
    else if(secs < YEAR_IN_SECONDS)
    {
        timeBehindText = QObject::tr(""%n week(s)"","""",secs/WEEK_IN_SECONDS);
    }
    else
    {
        qint64 years = secs / YEAR_IN_SECONDS;
        qint64 remainder = secs % YEAR_IN_SECONDS;
        timeBehindText = QObject::tr(""%1 and %2"").arg(QObject::tr(""%n year(s)"", """", years)).arg(QObject::tr(""%n week(s)"","""", remainder/WEEK_IN_SECONDS));
    }
    return timeBehindText;
}

QString formatBytes(uint64_t bytes)
{
    if(bytes < 1024)
        return QString(QObject::tr(""%1 B"")).arg(bytes);
    if(bytes < 1024 * 1024)
        return QString(QObject::tr(""%1 KB"")).arg(bytes / 1024);
    if(bytes < 1024 * 1024 * 1024)
        return QString(QObject::tr(""%1 MB"")).arg(bytes / 1024 / 1024);

    return QString(QObject::tr(""%1 GB"")).arg(bytes / 1024 / 1024 / 1024);
}

qreal calculateIdealFontSize(int width, const QString& text, QFont font, qreal minPointSize, qreal font_size) {
    while(font_size >= minPointSize) {
        font.setPointSizeF(font_size);
        QFontMetrics fm(font);
        if (fm.width(text) < width) {
            break;
        }
        font_size -= 0.5;
    }
    return font_size;
}

void ClickableLabel::mouseReleaseEvent(QMouseEvent *event)
{
    Q_EMIT clicked(event->pos());
}

void ClickableProgressBar::mouseReleaseEvent(QMouseEvent *event)
{
    Q_EMIT clicked(event->pos());
}

} // namespace GUIUtil
",16183,False,2458.363003019611,median
"// kafka-connector options: START
[[camel-vertx-kafka-kafka-connector-sink]]
= camel-vertx-kafka-kafka-connector sink configuration

Connector Description: Sent and receive messages to/from an Apache Kafka broker using vert.x Kafka client

When using camel-vertx-kafka-kafka-connector as sink make sure to use the following Maven dependency to have support for the connector:

[source,xml]
----
<dependency>
  <groupId>org.apache.camel.kafkaconnector</groupId>
  <artifactId>camel-vertx-kafka-kafka-connector</artifactId>
  <version>x.x.x</version>
  <!-- use the same version as your Camel Kafka connector version -->
</dependency>
----

To use this Sink connector in Kafka connect you'll need to set the following connector.class

[source,java]
----
connector.class=org.apache.camel.kafkaconnector.vertxkafka.CamelVertxkafkaSinkConnector
----


The camel-vertx-kafka sink connector supports 144 options, which are listed below.



[width=""100%"",cols=""2,5,^1,1,1"",options=""header""]
|===
| Name | Description | Default | Required | Priority
| *camel.sink.path.topic* | Name of the topic to use. On the consumer you can use comma to separate multiple topics. A producer can only send a message to a single topic. | null | true | HIGH
| *camel.sink.endpoint.additionalProperties* | Sets additional properties for either kafka consumer or kafka producer in case they can't be set directly on the camel configurations (e.g: new Kafka properties that are not reflected yet in Camel configurations), the properties have to be prefixed with additionalProperties.. E.g: additionalProperties.transactional.id=12345&additionalProperties.schema.registry.url=\\http://localhost:8811/avro | null | false | MEDIUM
| *camel.sink.endpoint.bootstrapServers* | A list of host/port pairs to use for establishing the initial connection to the Kafka cluster. The client will make use of all servers irrespective of which servers are specified here for bootstrapping&mdash;this list only impacts the initial hosts used to discover the full set of servers. This list should be in the form host1:port1,host2:port2,.... Since these servers are just used for the initial connection to discover the full cluster membership (which may change dynamically), this list need not contain the full set of servers (you may want more than one, though, in case a server is down). | null | false | MEDIUM
| *camel.sink.endpoint.clientDnsLookup* | Controls how the client uses DNS lookups. If set to use_all_dns_ips, connect to each returned IP address in sequence until a successful connection is established. After a disconnection, the next IP is used. Once all IPs have been used once, the client resolves the IP(s) from the hostname again (both the JVM and the OS cache DNS name lookups, however). If set to resolve_canonical_bootstrap_servers_only, resolve each bootstrap address into a list of canonical names. After the bootstrap phase, this behaves the same as use_all_dns_ips. If set to default (deprecated), attempt to connect to the first IP address returned by the lookup, even if the lookup returns multiple IP addresses. One of: [default] [use_all_dns_ips] [resolve_canonical_bootstrap_servers_only] | ""use_all_dns_ips"" | false | MEDIUM
| *camel.sink.endpoint.clientId* | An id string to pass to the server when making requests. The purpose of this is to be able to track the source of requests beyond just ip/port by allowing a logical application name to be included in server-side request logging. | null | false | MEDIUM
| *camel.sink.endpoint.connectionsMaxIdleMs* | Close idle connections after the number of milliseconds specified by this config. | 540000L | false | MEDIUM
| *camel.sink.endpoint.headerFilterStrategy* | To use a custom HeaderFilterStrategy to filter header to and from Camel message. | null | false | MEDIUM
| *camel.sink.endpoint.interceptorClasses* | A list of classes to use as interceptors. Implementing the org.apache.kafka.clients.producer.ProducerInterceptor interface allows you to intercept (and possibly mutate) the records received by the producer before they are published to the Kafka cluster. By default, there are no interceptors. | null | false | MEDIUM
| *camel.sink.endpoint.metadataMaxAgeMs* | The period of time in milliseconds after which we force a refresh of metadata even if we haven't seen any partition leadership changes to proactively discover any new brokers or partitions. | 300000L | false | MEDIUM
| *camel.sink.endpoint.metricReporters* | A list of classes to use as metrics reporters. Implementing the org.apache.kafka.common.metrics.MetricsReporter interface allows plugging in classes that will be notified of new metric creation. The JmxReporter is always included to register JMX statistics. | null | false | MEDIUM
| *camel.sink.endpoint.metricsNumSamples* | The number of samples maintained to compute metrics. | 2 | false | MEDIUM
| *camel.sink.endpoint.metricsRecordingLevel* | The highest recording level for metrics. One of: [INFO] [DEBUG] | ""INFO"" | false | MEDIUM
| *camel.sink.endpoint.metricsSampleWindowMs* | The window of time a metrics sample is computed over. | 30000L | false | MEDIUM
| *camel.sink.endpoint.partitionId* | The partition to which the record will be sent (or null if no partition was specified) or read from a particular partition if set. Header VertxKafkaConstants#PARTITION_ID If configured, it will take precedence over this config | null | false | MEDIUM
| *camel.sink.endpoint.receiveBufferBytes* | The size of the TCP receive buffer (SO_RCVBUF) to use when reading data. If the value is -1, the OS default will be used. | 32768 | false | MEDIUM
| *camel.sink.endpoint.reconnectBackoffMaxMs* | The maximum amount of time in milliseconds to wait when reconnecting to a broker that has repeatedly failed to connect. If provided, the backoff per host will increase exponentially for each consecutive connection failure, up to this maximum. After calculating the backoff increase, 20% random jitter is added to avoid connection storms. | 1000L | false | MEDIUM
| *camel.sink.endpoint.reconnectBackoffMs* | The base amount of time to wait before attempting to reconnect to a given host. This avoids repeatedly connecting to a host in a tight loop. This backoff applies to all connection attempts by the client to a broker. | 50L | false | MEDIUM
| *camel.sink.endpoint.requestTimeoutMs* | The configuration controls the maximum amount of time the client will wait for the response of a request. If the response is not received before the timeout elapses the client will resend the request if necessary or fail the request if retries are exhausted. This should be larger than replica.lag.time.max.ms (a broker configuration) to reduce the possibility of message duplication due to unnecessary producer retries. | 30000 | false | MEDIUM
| *camel.sink.endpoint.retryBackoffMs* | The amount of time to wait before attempting to retry a failed request to a given topic partition. This avoids repeatedly sending requests in a tight loop under some failure scenarios. | 100L | false | MEDIUM
| *camel.sink.endpoint.sendBufferBytes* | The size of the TCP send buffer (SO_SNDBUF) to use when sending data. If the value is -1, the OS default will be used. | 131072 | false | MEDIUM
| *camel.sink.endpoint.acks* | The number of acknowledgments the producer requires the leader to have received before considering a request complete. This controls the durability of records that are sent. The following settings are allowed: acks=0 If set to zero then the producer will not wait for any acknowledgment from the server at all. The record will be immediately added to the socket buffer and considered sent. No guarantee can be made that the server has received the record in this case, and the retries configuration will not take effect (as the client won't generally know of any failures). The offset given back for each record will always be set to -1. acks=1 This will mean the leader will write the record to its local log but will respond without awaiting full acknowledgement from all followers. In this case should the leader fail immediately after acknowledging the record but before the followers have replicated it then the record will be lost. acks=all This means the leader will wait for the full set of in-sync replicas to acknowledge the record. This guarantees that the record will not be lost as long as at least one in-sync replica remains alive. This is the strongest available guarantee. This is equivalent to the acks=-1 setting. One of: [all] [-1] [0] [1] | ""1"" | false | MEDIUM
| *camel.sink.endpoint.batchSize* | The producer will attempt to batch records together into fewer requests whenever multiple records are being sent to the same partition. This helps performance on both the client and the server. This configuration controls the default batch size in bytes. No attempt will be made to batch records larger than this size. Requests sent to brokers will contain multiple batches, one for each partition with data available to be sent. A small batch size will make batching less common and may reduce throughput (a batch size of zero will disable batching entirely). A very large batch size may use memory a bit more wastefully as we will always allocate a buffer of the specified batch size in anticipation of additional records. | 16384 | false | MEDIUM
| *camel.sink.endpoint.bufferMemory* | The total bytes of memory the producer can use to buffer records waiting to be sent to the server. If records are sent faster than they can be delivered to the server the producer will block for max.block.ms after which it will throw an exception.This setting should correspond roughly to the total memory the producer will use, but is not a hard bound since not all memory the producer uses is used for buffering. Some additional memory will be used for compression (if compression is enabled) as well as for maintaining in-flight requests. | 33554432L | false | MEDIUM
| *camel.sink.endpoint.compressionType* | The compression type for all data generated by the producer. The default is none (i.e. no compression). Valid values are none, gzip, snappy, lz4, or zstd. Compression is of full batches of data, so the efficacy of batching will also impact the compression ratio (more batching means better compression). | ""none"" | false | MEDIUM
| *camel.sink.endpoint.deliveryTimeoutMs* | An upper bound on the time to report success or failure after a call to send() returns. This limits the total time that a record will be delayed prior to sending, the time to await acknowledgement from the broker (if expected), and the time allowed for retriable send failures. The producer may report failure to send a record earlier than this config if either an unrecoverable error is encountered, the retries have been exhausted, or the record is added to a batch which reached an earlier delivery expiration deadline. The value of this config should be greater than or equal to the sum of request.timeout.ms and linger.ms. | 120000 | false | MEDIUM
| *camel.sink.endpoint.enableIdempotence* | When set to 'true', the producer will ensure that exactly one copy of each message is written in the stream. If 'false', producer retries due to broker failures, etc., may write duplicates of the retried message in the stream. Note that enabling idempotence requires max.in.flight.requests.per.connection to be less than or equal to 5, retries to be greater than 0 and acks must be 'all'. If these values are not explicitly set by the user, suitable values will be chosen. If incompatible values are set, a ConfigException will be thrown. | false | false | MEDIUM
| *camel.sink.endpoint.keySerializer* | Serializer class for key that implements the org.apache.kafka.common.serialization.Serializer interface. | ""org.apache.kafka.common.serialization.StringSerializer"" | false | MEDIUM
| *camel.sink.endpoint.lazyStartProducer* | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing. | false | false | MEDIUM
| *camel.sink.endpoint.lingerMs* | The producer groups together any records that arrive in between request transmissions into a single batched request. Normally this occurs only under load when records arrive faster than they can be sent out. However in some circumstances the client may want to reduce the number of requests even under moderate load. This setting accomplishes this by adding a small amount of artificial delay&mdash;that is, rather than immediately sending out a record the producer will wait for up to the given delay to allow other records to be sent so that the sends can be batched together. This can be thought of as analogous to Nagle's algorithm in TCP. This setting gives the upper bound on the delay for batching: once we get batch.size worth of records for a partition it will be sent immediately regardless of this setting, however if we have fewer than this many bytes accumulated for this partition we will 'linger' for the specified time waiting for more records to show up. This setting defaults to 0 (i.e. no delay). Setting linger.ms=5, for example, would have the effect of reducing the number of requests sent but would add up to 5ms of latency to records sent in the absence of load. | 0L | false | MEDIUM
| *camel.sink.endpoint.maxBlockMs* | The configuration controls how long KafkaProducer.send() and KafkaProducer.partitionsFor() will block.These methods can be blocked either because the buffer is full or metadata unavailable.Blocking in the user-supplied serializers or partitioner will not be counted against this timeout. | 60000L | false | MEDIUM
| *camel.sink.endpoint.maxInFlightRequestsPer Connection* | The maximum number of unacknowledged requests the client will send on a single connection before blocking. Note that if this setting is set to be greater than 1 and there are failed sends, there is a risk of message re-ordering due to retries (i.e., if retries are enabled). | 5 | false | MEDIUM
| *camel.sink.endpoint.maxRequestSize* | The maximum size of a request in bytes. This setting will limit the number of record batches the producer will send in a single request to avoid sending huge requests. This is also effectively a cap on the maximum uncompressed record batch size. Note that the server has its own cap on the record batch size (after compression if compression is enabled) which may be different from this. | 1048576 | false | MEDIUM
| *camel.sink.endpoint.metadataMaxIdleMs* | Controls how long the producer will cache metadata for a topic that's idle. If the elapsed time since a topic was last produced to exceeds the metadata idle duration, then the topic's metadata is forgotten and the next access to it will force a metadata fetch request. | 300000L | false | MEDIUM
| *camel.sink.endpoint.partitionerClass* | Partitioner class that implements the org.apache.kafka.clients.producer.Partitioner interface. | ""org.apache.kafka.clients.producer.internals.DefaultPartitioner"" | false | MEDIUM
| *camel.sink.endpoint.retries* | Setting a value greater than zero will cause the client to resend any record whose send fails with a potentially transient error. Note that this retry is no different than if the client resent the record upon receiving the error. Allowing retries without setting max.in.flight.requests.per.connection to 1 will potentially change the ordering of records because if two batches are sent to a single partition, and the first fails and is retried but the second succeeds, then the records in the second batch may appear first. Note additionally that produce requests will be failed before the number of retries has been exhausted if the timeout configured by delivery.timeout.ms expires first before successful acknowledgement. Users should generally prefer to leave this config unset and instead use delivery.timeout.ms to control retry behavior. | 2147483647 | false | MEDIUM
| *camel.sink.endpoint.transactionalId* | The TransactionalId to use for transactional delivery. This enables reliability semantics which span multiple producer sessions since it allows the client to guarantee that transactions using the same TransactionalId have been completed prior to starting any new transactions. If no TransactionalId is provided, then the producer is limited to idempotent delivery. If a TransactionalId is configured, enable.idempotence is implied. By default the TransactionId is not configured, which means transactions cannot be used. Note that, by default, transactions require a cluster of at least three brokers which is the recommended setting for production; for development you can change this, by adjusting broker setting transaction.state.log.replication.factor. | null | false | MEDIUM
| *camel.sink.endpoint.transactionTimeoutMs* | The maximum amount of time in ms that the transaction coordinator will wait for a transaction status update from the producer before proactively aborting the ongoing transaction.If this value is larger than the transaction.max.timeout.ms setting in the broker, the request will fail with a InvalidTransactionTimeout error. | 60000 | false | MEDIUM
| *camel.sink.endpoint.valueSerializer* | Serializer class for value that implements the org.apache.kafka.common.serialization.Serializer interface. | ""org.apache.kafka.common.serialization.StringSerializer"" | false | MEDIUM
| *camel.sink.endpoint.synchronous* | Sets whether synchronous processing should be strictly used, or Camel is allowed to use asynchronous processing (if supported). | false | false | MEDIUM
| *camel.sink.endpoint.saslClientCallbackHandlerClass* | The fully qualified name of a SASL client callback handler class that implements the AuthenticateCallbackHandler interface. | null | false | MEDIUM
| *camel.sink.endpoint.saslJaasConfig* | JAAS login context parameters for SASL connections in the format used by JAAS configuration files. JAAS configuration file format is described here. The format for the value is: 'loginModuleClass controlFlag (optionName=optionValue);'. For brokers, the config must be prefixed with listener prefix and SASL mechanism name in lower-case. For example, listener.name.sasl_ssl.scram-sha-256.sasl.jaas.config=com.example.ScramLoginModule required; | null | false | MEDIUM
| *camel.sink.endpoint.saslKerberosKinitCmd* | Kerberos kinit command path. | ""/usr/bin/kinit"" | false | MEDIUM
| *camel.sink.endpoint.saslKerberosMinTimeBefore Relogin* | Login thread sleep time between refresh attempts. | 60000L | false | MEDIUM
| *camel.sink.endpoint.saslKerberosServiceName* | The Kerberos principal name that Kafka runs as. This can be defined either in Kafka's JAAS config or in Kafka's config. | null | false | MEDIUM
| *camel.sink.endpoint.saslKerberosTicketRenewJitter* | Percentage of random jitter added to the renewal time. | 0.05D | false | MEDIUM
| *camel.sink.endpoint.saslKerberosTicketRenewWindow Factor* | Login thread will sleep until the specified window factor of time from last refresh to ticket's expiry has been reached, at which time it will try to renew the ticket. | 0.8D | false | MEDIUM
| *camel.sink.endpoint.saslLoginCallbackHandlerClass* | The fully qualified name of a SASL login callback handler class that implements the AuthenticateCallbackHandler interface. For brokers, login callback handler config must be prefixed with listener prefix and SASL mechanism name in lower-case. For example, listener.name.sasl_ssl.scram-sha-256.sasl.login.callback.handler.class=com.example.CustomScramLoginCallbackHandler | null | false | MEDIUM
| *camel.sink.endpoint.saslLoginClass* | The fully qualified name of a class that implements the Login interface. For brokers, login config must be prefixed with listener prefix and SASL mechanism name in lower-case. For example, listener.name.sasl_ssl.scram-sha-256.sasl.login.class=com.example.CustomScramLogin | null | false | MEDIUM
| *camel.sink.endpoint.saslLoginRefreshBufferSeconds* | The amount of buffer time before credential expiration to maintain when refreshing a credential, in seconds. If a refresh would otherwise occur closer to expiration than the number of buffer seconds then the refresh will be moved up to maintain as much of the buffer time as possible. Legal values are between 0 and 3600 (1 hour); a default value of 300 (5 minutes) is used if no value is specified. This value and sasl.login.refresh.min.period.seconds are both ignored if their sum exceeds the remaining lifetime of a credential. Currently applies only to OAUTHBEARER. | 300 | false | MEDIUM
| *camel.sink.endpoint.saslLoginRefreshMinPeriod Seconds* | The desired minimum time for the login refresh thread to wait before refreshing a credential, in seconds. Legal values are between 0 and 900 (15 minutes); a default value of 60 (1 minute) is used if no value is specified. This value and sasl.login.refresh.buffer.seconds are both ignored if their sum exceeds the remaining lifetime of a credential. Currently applies only to OAUTHBEARER. | 60 | false | MEDIUM
| *camel.sink.endpoint.saslLoginRefreshWindowFactor* | Login refresh thread will sleep until the specified window factor relative to the credential's lifetime has been reached, at which time it will try to refresh the credential. Legal values are between 0.5 (50%) and 1.0 (100%) inclusive; a default value of 0.8 (80%) is used if no value is specified. Currently applies only to OAUTHBEARER. | 0.8D | false | MEDIUM
| *camel.sink.endpoint.saslLoginRefreshWindowJitter* | The maximum amount of random jitter relative to the credential's lifetime that is added to the login refresh thread's sleep time. Legal values are between 0 and 0.25 (25%) inclusive; a default value of 0.05 (5%) is used if no value is specified. Currently applies only to OAUTHBEARER. | 0.05D | false | MEDIUM
| *camel.sink.endpoint.saslMechanism* | SASL mechanism used for client connections. This may be any mechanism for which a security provider is available. GSSAPI is the default mechanism. | ""GSSAPI"" | false | MEDIUM
| *camel.sink.endpoint.securityProtocol* | Protocol used to communicate with brokers. Valid values are: PLAINTEXT, SSL, SASL_PLAINTEXT, SASL_SSL. | ""PLAINTEXT"" | false | MEDIUM
| *camel.sink.endpoint.securityProviders* | A list of configurable creator classes each returning a provider implementing security algorithms. These classes should implement the org.apache.kafka.common.security.auth.SecurityProviderCreator interface. | null | false | MEDIUM
| *camel.sink.endpoint.sslCipherSuites* | A list of cipher suites. This is a named combination of authentication, encryption, MAC and key exchange algorithm used to negotiate the security settings for a network connection using TLS or SSL network protocol. By default all the available cipher suites are supported. | null | false | MEDIUM
| *camel.sink.endpoint.sslEnabledProtocols* | The list of protocols enabled for SSL connections. The default is 'TLSv1.2,TLSv1.3' when running with Java 11 or newer, 'TLSv1.2' otherwise. With the default value for Java 11, clients and servers will prefer TLSv1.3 if both support it and fallback to TLSv1.2 otherwise (assuming both support at least TLSv1.2). This default should be fine for most cases. Also see the config documentation for ssl.protocol. | ""TLSv1.2,TLSv1.3"" | false | MEDIUM
| *camel.sink.endpoint.sslEndpointIdentification Algorithm* | The endpoint identification algorithm to validate server hostname using server certificate. | ""https"" | false | MEDIUM
| *camel.sink.endpoint.sslEngineFactoryClass* | The class of type org.apache.kafka.common.security.auth.SslEngineFactory to provide SSLEngine objects. Default value is org.apache.kafka.common.security.ssl.DefaultSslEngineFactory | null | false | MEDIUM
| *camel.sink.endpoint.sslKeymanagerAlgorithm* | The algorithm used by key manager factory for SSL connections. Default value is the key manager factory algorithm configured for the Java Virtual Machine. | ""SunX509"" | false | MEDIUM
| *camel.sink.endpoint.sslKeyPassword* | The password of the private key in the key store file. This is optional for client. | null | false | MEDIUM
| *camel.sink.endpoint.sslKeystoreLocation* | The location of the key store file. This is optional for client and can be used for two-way authentication for client. | null | false | MEDIUM
| *camel.sink.endpoint.sslKeystorePassword* | The store password for the key store file. This is optional for client and only needed if ssl.keystore.location is configured. | null | false | MEDIUM
| *camel.sink.endpoint.sslKeystoreType* | The file format of the key store file. This is optional for client. | ""JKS"" | false | MEDIUM
| *camel.sink.endpoint.sslProtocol* | The SSL protocol used to generate the SSLContext. The default is 'TLSv1.3' when running with Java 11 or newer, 'TLSv1.2' otherwise. This value should be fine for most use cases. Allowed values in recent JVMs are 'TLSv1.2' and 'TLSv1.3'. 'TLS', 'TLSv1.1', 'SSL', 'SSLv2' and 'SSLv3' may be supported in older JVMs, but their usage is discouraged due to known security vulnerabilities. With the default value for this config and 'ssl.enabled.protocols', clients will downgrade to 'TLSv1.2' if the server does not support 'TLSv1.3'. If this config is set to 'TLSv1.2', clients will not use 'TLSv1.3' even if it is one of the values in ssl.enabled.protocols and the server only supports 'TLSv1.3'. | ""TLSv1.2"" | false | MEDIUM
| *camel.sink.endpoint.sslProvider* | The name of the security provider used for SSL connections. Default value is the default security provider of the JVM. | null | false | MEDIUM
| *camel.sink.endpoint.sslSecureRandomImplementation* | The SecureRandom PRNG implementation to use for SSL cryptography operations. | null | false | MEDIUM
| *camel.sink.endpoint.sslTrustmanagerAlgorithm* | The algorithm used by trust manager factory for SSL connections. Default value is the trust manager factory algorithm configured for the Java Virtual Machine. | ""PKIX"" | false | MEDIUM
| *camel.sink.endpoint.sslTruststoreLocation* | The location of the trust store file. | null | false | MEDIUM
| *camel.sink.endpoint.sslTruststorePassword* | The password for the trust store file. If a password is not set access to the truststore is still available, but integrity checking is disabled. | null | false | MEDIUM
| *camel.sink.endpoint.sslTruststoreType* | The file format of the trust store file. | ""JKS"" | false | MEDIUM
| *camel.component.vertx-kafka.additionalProperties* | Sets additional properties for either kafka consumer or kafka producer in case they can't be set directly on the camel configurations (e.g: new Kafka properties that are not reflected yet in Camel configurations), the properties have to be prefixed with additionalProperties.. E.g: additionalProperties.transactional.id=12345&additionalProperties.schema.registry.url=\\http://localhost:8811/avro | null | false | MEDIUM
| *camel.component.vertx-kafka.bootstrapServers* | A list of host/port pairs to use for establishing the initial connection to the Kafka cluster. The client will make use of all servers irrespective of which servers are specified here for bootstrapping&mdash;this list only impacts the initial hosts used to discover the full set of servers. This list should be in the form host1:port1,host2:port2,.... Since these servers are just used for the initial connection to discover the full cluster membership (which may change dynamically), this list need not contain the full set of servers (you may want more than one, though, in case a server is down). | null | false | MEDIUM
| *camel.component.vertx-kafka.clientDnsLookup* | Controls how the client uses DNS lookups. If set to use_all_dns_ips, connect to each returned IP address in sequence until a successful connection is established. After a disconnection, the next IP is used. Once all IPs have been used once, the client resolves the IP(s) from the hostname again (both the JVM and the OS cache DNS name lookups, however). If set to resolve_canonical_bootstrap_servers_only, resolve each bootstrap address into a list of canonical names. After the bootstrap phase, this behaves the same as use_all_dns_ips. If set to default (deprecated), attempt to connect to the first IP address returned by the lookup, even if the lookup returns multiple IP addresses. One of: [default] [use_all_dns_ips] [resolve_canonical_bootstrap_servers_only] | ""use_all_dns_ips"" | false | MEDIUM
| *camel.component.vertx-kafka.clientId* | An id string to pass to the server when making requests. The purpose of this is to be able to track the source of requests beyond just ip/port by allowing a logical application name to be included in server-side request logging. | null | false | MEDIUM
| *camel.component.vertx-kafka.configuration* | The component configurations | null | false | MEDIUM
| *camel.component.vertx-kafka.connectionsMaxIdleMs* | Close idle connections after the number of milliseconds specified by this config. | 540000L | false | MEDIUM
| *camel.component.vertx-kafka.headerFilterStrategy* | To use a custom HeaderFilterStrategy to filter header to and from Camel message. | null | false | MEDIUM
| *camel.component.vertx-kafka.interceptorClasses* | A list of classes to use as interceptors. Implementing the org.apache.kafka.clients.producer.ProducerInterceptor interface allows you to intercept (and possibly mutate) the records received by the producer before they are published to the Kafka cluster. By default, there are no interceptors. | null | false | MEDIUM
| *camel.component.vertx-kafka.metadataMaxAgeMs* | The period of time in milliseconds after which we force a refresh of metadata even if we haven't seen any partition leadership changes to proactively discover any new brokers or partitions. | 300000L | false | MEDIUM
| *camel.component.vertx-kafka.metricReporters* | A list of classes to use as metrics reporters. Implementing the org.apache.kafka.common.metrics.MetricsReporter interface allows plugging in classes that will be notified of new metric creation. The JmxReporter is always included to register JMX statistics. | null | false | MEDIUM
| *camel.component.vertx-kafka.metricsNumSamples* | The number of samples maintained to compute metrics. | 2 | false | MEDIUM
| *camel.component.vertx-kafka.metricsRecordingLevel* | The highest recording level for metrics. One of: [INFO] [DEBUG] | ""INFO"" | false | MEDIUM
| *camel.component.vertx-kafka.metricsSampleWindowMs* | The window of time a metrics sample is computed over. | 30000L | false | MEDIUM
| *camel.component.vertx-kafka.partitionId* | The partition to which the record will be sent (or null if no partition was specified) or read from a particular partition if set. Header VertxKafkaConstants#PARTITION_ID If configured, it will take precedence over this config | null | false | MEDIUM
| *camel.component.vertx-kafka.receiveBufferBytes* | The size of the TCP receive buffer (SO_RCVBUF) to use when reading data. If the value is -1, the OS default will be used. | 32768 | false | MEDIUM
| *camel.component.vertx-kafka.reconnectBackoffMaxMs* | The maximum amount of time in milliseconds to wait when reconnecting to a broker that has repeatedly failed to connect. If provided, the backoff per host will increase exponentially for each consecutive connection failure, up to this maximum. After calculating the backoff increase, 20% random jitter is added to avoid connection storms. | 1000L | false | MEDIUM
| *camel.component.vertx-kafka.reconnectBackoffMs* | The base amount of time to wait before attempting to reconnect to a given host. This avoids repeatedly connecting to a host in a tight loop. This backoff applies to all connection attempts by the client to a broker. | 50L | false | MEDIUM
| *camel.component.vertx-kafka.requestTimeoutMs* | The configuration controls the maximum amount of time the client will wait for the response of a request. If the response is not received before the timeout elapses the client will resend the request if necessary or fail the request if retries are exhausted. This should be larger than replica.lag.time.max.ms (a broker configuration) to reduce the possibility of message duplication due to unnecessary producer retries. | 30000 | false | MEDIUM
| *camel.component.vertx-kafka.retryBackoffMs* | The amount of time to wait before attempting to retry a failed request to a given topic partition. This avoids repeatedly sending requests in a tight loop under some failure scenarios. | 100L | false | MEDIUM
| *camel.component.vertx-kafka.sendBufferBytes* | The size of the TCP send buffer (SO_SNDBUF) to use when sending data. If the value is -1, the OS default will be used. | 131072 | false | MEDIUM
| *camel.component.vertx-kafka.acks* | The number of acknowledgments the producer requires the leader to have received before considering a request complete. This controls the durability of records that are sent. The following settings are allowed: acks=0 If set to zero then the producer will not wait for any acknowledgment from the server at all. The record will be immediately added to the socket buffer and considered sent. No guarantee can be made that the server has received the record in this case, and the retries configuration will not take effect (as the client won't generally know of any failures). The offset given back for each record will always be set to -1. acks=1 This will mean the leader will write the record to its local log but will respond without awaiting full acknowledgement from all followers. In this case should the leader fail immediately after acknowledging the record but before the followers have replicated it then the record will be lost. acks=all This means the leader will wait for the full set of in-sync replicas to acknowledge the record. This guarantees that the record will not be lost as long as at least one in-sync replica remains alive. This is the strongest available guarantee. This is equivalent to the acks=-1 setting. One of: [all] [-1] [0] [1] | ""1"" | false | MEDIUM
| *camel.component.vertx-kafka.batchSize* | The producer will attempt to batch records together into fewer requests whenever multiple records are being sent to the same partition. This helps performance on both the client and the server. This configuration controls the default batch size in bytes. No attempt will be made to batch records larger than this size. Requests sent to brokers will contain multiple batches, one for each partition with data available to be sent. A small batch size will make batching less common and may reduce throughput (a batch size of zero will disable batching entirely). A very large batch size may use memory a bit more wastefully as we will always allocate a buffer of the specified batch size in anticipation of additional records. | 16384 | false | MEDIUM
| *camel.component.vertx-kafka.bufferMemory* | The total bytes of memory the producer can use to buffer records waiting to be sent to the server. If records are sent faster than they can be delivered to the server the producer will block for max.block.ms after which it will throw an exception.This setting should correspond roughly to the total memory the producer will use, but is not a hard bound since not all memory the producer uses is used for buffering. Some additional memory will be used for compression (if compression is enabled) as well as for maintaining in-flight requests. | 33554432L | false | MEDIUM
| *camel.component.vertx-kafka.compressionType* | The compression type for all data generated by the producer. The default is none (i.e. no compression). Valid values are none, gzip, snappy, lz4, or zstd. Compression is of full batches of data, so the efficacy of batching will also impact the compression ratio (more batching means better compression). | ""none"" | false | MEDIUM
| *camel.component.vertx-kafka.deliveryTimeoutMs* | An upper bound on the time to report success or failure after a call to send() returns. This limits the total time that a record will be delayed prior to sending, the time to await acknowledgement from the broker (if expected), and the time allowed for retriable send failures. The producer may report failure to send a record earlier than this config if either an unrecoverable error is encountered, the retries have been exhausted, or the record is added to a batch which reached an earlier delivery expiration deadline. The value of this config should be greater than or equal to the sum of request.timeout.ms and linger.ms. | 120000 | false | MEDIUM
| *camel.component.vertx-kafka.enableIdempotence* | When set to 'true', the producer will ensure that exactly one copy of each message is written in the stream. If 'false', producer retries due to broker failures, etc., may write duplicates of the retried message in the stream. Note that enabling idempotence requires max.in.flight.requests.per.connection to be less than or equal to 5, retries to be greater than 0 and acks must be 'all'. If these values are not explicitly set by the user, suitable values will be chosen. If incompatible values are set, a ConfigException will be thrown. | false | false | MEDIUM
| *camel.component.vertx-kafka.keySerializer* | Serializer class for key that implements the org.apache.kafka.common.serialization.Serializer interface. | ""org.apache.kafka.common.serialization.StringSerializer"" | false | MEDIUM
| *camel.component.vertx-kafka.lazyStartProducer* | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing. | false | false | MEDIUM
| *camel.component.vertx-kafka.lingerMs* | The producer groups together any records that arrive in between request transmissions into a single batched request. Normally this occurs only under load when records arrive faster than they can be sent out. However in some circumstances the client may want to reduce the number of requests even under moderate load. This setting accomplishes this by adding a small amount of artificial delay&mdash;that is, rather than immediately sending out a record the producer will wait for up to the given delay to allow other records to be sent so that the sends can be batched together. This can be thought of as analogous to Nagle's algorithm in TCP. This setting gives the upper bound on the delay for batching: once we get batch.size worth of records for a partition it will be sent immediately regardless of this setting, however if we have fewer than this many bytes accumulated for this partition we will 'linger' for the specified time waiting for more records to show up. This setting defaults to 0 (i.e. no delay). Setting linger.ms=5, for example, would have the effect of reducing the number of requests sent but would add up to 5ms of latency to records sent in the absence of load. | 0L | false | MEDIUM
| *camel.component.vertx-kafka.maxBlockMs* | The configuration controls how long KafkaProducer.send() and KafkaProducer.partitionsFor() will block.These methods can be blocked either because the buffer is full or metadata unavailable.Blocking in the user-supplied serializers or partitioner will not be counted against this timeout. | 60000L | false | MEDIUM
| *camel.component.vertx-kafka.maxInFlightRequestsPer Connection* | The maximum number of unacknowledged requests the client will send on a single connection before blocking. Note that if this setting is set to be greater than 1 and there are failed sends, there is a risk of message re-ordering due to retries (i.e., if retries are enabled). | 5 | false | MEDIUM
| *camel.component.vertx-kafka.maxRequestSize* | The maximum size of a request in bytes. This setting will limit the number of record batches the producer will send in a single request to avoid sending huge requests. This is also effectively a cap on the maximum uncompressed record batch size. Note that the server has its own cap on the record batch size (after compression if compression is enabled) which may be different from this. | 1048576 | false | MEDIUM
| *camel.component.vertx-kafka.metadataMaxIdleMs* | Controls how long the producer will cache metadata for a topic that's idle. If the elapsed time since a topic was last produced to exceeds the metadata idle duration, then the topic's metadata is forgotten and the next access to it will force a metadata fetch request. | 300000L | false | MEDIUM
| *camel.component.vertx-kafka.partitionerClass* | Partitioner class that implements the org.apache.kafka.clients.producer.Partitioner interface. | ""org.apache.kafka.clients.producer.internals.DefaultPartitioner"" | false | MEDIUM
| *camel.component.vertx-kafka.retries* | Setting a value greater than zero will cause the client to resend any record whose send fails with a potentially transient error. Note that this retry is no different than if the client resent the record upon receiving the error. Allowing retries without setting max.in.flight.requests.per.connection to 1 will potentially change the ordering of records because if two batches are sent to a single partition, and the first fails and is retried but the second succeeds, then the records in the second batch may appear first. Note additionally that produce requests will be failed before the number of retries has been exhausted if the timeout configured by delivery.timeout.ms expires first before successful acknowledgement. Users should generally prefer to leave this config unset and instead use delivery.timeout.ms to control retry behavior. | 2147483647 | false | MEDIUM
| *camel.component.vertx-kafka.transactionalId* | The TransactionalId to use for transactional delivery. This enables reliability semantics which span multiple producer sessions since it allows the client to guarantee that transactions using the same TransactionalId have been completed prior to starting any new transactions. If no TransactionalId is provided, then the producer is limited to idempotent delivery. If a TransactionalId is configured, enable.idempotence is implied. By default the TransactionId is not configured, which means transactions cannot be used. Note that, by default, transactions require a cluster of at least three brokers which is the recommended setting for production; for development you can change this, by adjusting broker setting transaction.state.log.replication.factor. | null | false | MEDIUM
| *camel.component.vertx-kafka.transactionTimeoutMs* | The maximum amount of time in ms that the transaction coordinator will wait for a transaction status update from the producer before proactively aborting the ongoing transaction.If this value is larger than the transaction.max.timeout.ms setting in the broker, the request will fail with a InvalidTransactionTimeout error. | 60000 | false | MEDIUM
| *camel.component.vertx-kafka.valueSerializer* | Serializer class for value that implements the org.apache.kafka.common.serialization.Serializer interface. | ""org.apache.kafka.common.serialization.StringSerializer"" | false | MEDIUM
| *camel.component.vertx-kafka.autowiredEnabled* | Whether autowiring is enabled. This is used for automatic autowiring options (the option must be marked as autowired) by looking up in the registry to find if there is a single instance of matching type, which then gets configured on the component. This can be used for automatic configuring JDBC data sources, JMS connection factories, AWS Clients, etc. | true | false | MEDIUM
| *camel.component.vertx-kafka.vertx* | To use an existing vertx instead of creating a new instance | null | false | MEDIUM
| *camel.component.vertx-kafka.vertxOptions* | To provide a custom set of vertx options for configuring vertx | null | false | MEDIUM
| *camel.component.vertx-kafka.saslClientCallback HandlerClass* | The fully qualified name of a SASL client callback handler class that implements the AuthenticateCallbackHandler interface. | null | false | MEDIUM
| *camel.component.vertx-kafka.saslJaasConfig* | JAAS login context parameters for SASL connections in the format used by JAAS configuration files. JAAS configuration file format is described here. The format for the value is: 'loginModuleClass controlFlag (optionName=optionValue);'. For brokers, the config must be prefixed with listener prefix and SASL mechanism name in lower-case. For example, listener.name.sasl_ssl.scram-sha-256.sasl.jaas.config=com.example.ScramLoginModule required; | null | false | MEDIUM
| *camel.component.vertx-kafka.saslKerberosKinitCmd* | Kerberos kinit command path. | ""/usr/bin/kinit"" | false | MEDIUM
| *camel.component.vertx-kafka.saslKerberosMinTime BeforeRelogin* | Login thread sleep time between refresh attempts. | 60000L | false | MEDIUM
| *camel.component.vertx-kafka.saslKerberosService Name* | The Kerberos principal name that Kafka runs as. This can be defined either in Kafka's JAAS config or in Kafka's config. | null | false | MEDIUM
| *camel.component.vertx-kafka.saslKerberosTicket RenewJitter* | Percentage of random jitter added to the renewal time. | 0.05D | false | MEDIUM
| *camel.component.vertx-kafka.saslKerberosTicket RenewWindowFactor* | Login thread will sleep until the specified window factor of time from last refresh to ticket's expiry has been reached, at which time it will try to renew the ticket. | 0.8D | false | MEDIUM
| *camel.component.vertx-kafka.saslLoginCallback HandlerClass* | The fully qualified name of a SASL login callback handler class that implements the AuthenticateCallbackHandler interface. For brokers, login callback handler config must be prefixed with listener prefix and SASL mechanism name in lower-case. For example, listener.name.sasl_ssl.scram-sha-256.sasl.login.callback.handler.class=com.example.CustomScramLoginCallbackHandler | null | false | MEDIUM
| *camel.component.vertx-kafka.saslLoginClass* | The fully qualified name of a class that implements the Login interface. For brokers, login config must be prefixed with listener prefix and SASL mechanism name in lower-case. For example, listener.name.sasl_ssl.scram-sha-256.sasl.login.class=com.example.CustomScramLogin | null | false | MEDIUM
| *camel.component.vertx-kafka.saslLoginRefreshBuffer Seconds* | The amount of buffer time before credential expiration to maintain when refreshing a credential, in seconds. If a refresh would otherwise occur closer to expiration than the number of buffer seconds then the refresh will be moved up to maintain as much of the buffer time as possible. Legal values are between 0 and 3600 (1 hour); a default value of 300 (5 minutes) is used if no value is specified. This value and sasl.login.refresh.min.period.seconds are both ignored if their sum exceeds the remaining lifetime of a credential. Currently applies only to OAUTHBEARER. | 300 | false | MEDIUM
| *camel.component.vertx-kafka.saslLoginRefreshMin PeriodSeconds* | The desired minimum time for the login refresh thread to wait before refreshing a credential, in seconds. Legal values are between 0 and 900 (15 minutes); a default value of 60 (1 minute) is used if no value is specified. This value and sasl.login.refresh.buffer.seconds are both ignored if their sum exceeds the remaining lifetime of a credential. Currently applies only to OAUTHBEARER. | 60 | false | MEDIUM
| *camel.component.vertx-kafka.saslLoginRefreshWindow Factor* | Login refresh thread will sleep until the specified window factor relative to the credential's lifetime has been reached, at which time it will try to refresh the credential. Legal values are between 0.5 (50%) and 1.0 (100%) inclusive; a default value of 0.8 (80%) is used if no value is specified. Currently applies only to OAUTHBEARER. | 0.8D | false | MEDIUM
| *camel.component.vertx-kafka.saslLoginRefreshWindow Jitter* | The maximum amount of random jitter relative to the credential's lifetime that is added to the login refresh thread's sleep time. Legal values are between 0 and 0.25 (25%) inclusive; a default value of 0.05 (5%) is used if no value is specified. Currently applies only to OAUTHBEARER. | 0.05D | false | MEDIUM
| *camel.component.vertx-kafka.saslMechanism* | SASL mechanism used for client connections. This may be any mechanism for which a security provider is available. GSSAPI is the default mechanism. | ""GSSAPI"" | false | MEDIUM
| *camel.component.vertx-kafka.securityProtocol* | Protocol used to communicate with brokers. Valid values are: PLAINTEXT, SSL, SASL_PLAINTEXT, SASL_SSL. | ""PLAINTEXT"" | false | MEDIUM
| *camel.component.vertx-kafka.securityProviders* | A list of configurable creator classes each returning a provider implementing security algorithms. These classes should implement the org.apache.kafka.common.security.auth.SecurityProviderCreator interface. | null | false | MEDIUM
| *camel.component.vertx-kafka.sslCipherSuites* | A list of cipher suites. This is a named combination of authentication, encryption, MAC and key exchange algorithm used to negotiate the security settings for a network connection using TLS or SSL network protocol. By default all the available cipher suites are supported. | null | false | MEDIUM
| *camel.component.vertx-kafka.sslEnabledProtocols* | The list of protocols enabled for SSL connections. The default is 'TLSv1.2,TLSv1.3' when running with Java 11 or newer, 'TLSv1.2' otherwise. With the default value for Java 11, clients and servers will prefer TLSv1.3 if both support it and fallback to TLSv1.2 otherwise (assuming both support at least TLSv1.2). This default should be fine for most cases. Also see the config documentation for ssl.protocol. | ""TLSv1.2,TLSv1.3"" | false | MEDIUM
| *camel.component.vertx-kafka.sslEndpoint IdentificationAlgorithm* | The endpoint identification algorithm to validate server hostname using server certificate. | ""https"" | false | MEDIUM
| *camel.component.vertx-kafka.sslEngineFactoryClass* | The class of type org.apache.kafka.common.security.auth.SslEngineFactory to provide SSLEngine objects. Default value is org.apache.kafka.common.security.ssl.DefaultSslEngineFactory | null | false | MEDIUM
| *camel.component.vertx-kafka.sslKeymanagerAlgorithm* | The algorithm used by key manager factory for SSL connections. Default value is the key manager factory algorithm configured for the Java Virtual Machine. | ""SunX509"" | false | MEDIUM
| *camel.component.vertx-kafka.sslKeyPassword* | The password of the private key in the key store file. This is optional for client. | null | false | MEDIUM
| *camel.component.vertx-kafka.sslKeystoreLocation* | The location of the key store file. This is optional for client and can be used for two-way authentication for client. | null | false | MEDIUM
| *camel.component.vertx-kafka.sslKeystorePassword* | The store password for the key store file. This is optional for client and only needed if ssl.keystore.location is configured. | null | false | MEDIUM
| *camel.component.vertx-kafka.sslKeystoreType* | The file format of the key store file. This is optional for client. | ""JKS"" | false | MEDIUM
| *camel.component.vertx-kafka.sslProtocol* | The SSL protocol used to generate the SSLContext. The default is 'TLSv1.3' when running with Java 11 or newer, 'TLSv1.2' otherwise. This value should be fine for most use cases. Allowed values in recent JVMs are 'TLSv1.2' and 'TLSv1.3'. 'TLS', 'TLSv1.1', 'SSL', 'SSLv2' and 'SSLv3' may be supported in older JVMs, but their usage is discouraged due to known security vulnerabilities. With the default value for this config and 'ssl.enabled.protocols', clients will downgrade to 'TLSv1.2' if the server does not support 'TLSv1.3'. If this config is set to 'TLSv1.2', clients will not use 'TLSv1.3' even if it is one of the values in ssl.enabled.protocols and the server only supports 'TLSv1.3'. | ""TLSv1.2"" | false | MEDIUM
| *camel.component.vertx-kafka.sslProvider* | The name of the security provider used for SSL connections. Default value is the default security provider of the JVM. | null | false | MEDIUM
| *camel.component.vertx-kafka.sslSecureRandom Implementation* | The SecureRandom PRNG implementation to use for SSL cryptography operations. | null | false | MEDIUM
| *camel.component.vertx-kafka.sslTrustmanager Algorithm* | The algorithm used by trust manager factory for SSL connections. Default value is the trust manager factory algorithm configured for the Java Virtual Machine. | ""PKIX"" | false | MEDIUM
| *camel.component.vertx-kafka.sslTruststoreLocation* | The location of the trust store file. | null | false | MEDIUM
| *camel.component.vertx-kafka.sslTruststorePassword* | The password for the trust store file. If a password is not set access to the truststore is still available, but integrity checking is disabled. | null | false | MEDIUM
| *camel.component.vertx-kafka.sslTruststoreType* | The file format of the trust store file. | ""JKS"" | false | MEDIUM
|===



The camel-vertx-kafka sink connector has no converters out of the box.





The camel-vertx-kafka sink connector has no transforms out of the box.





The camel-vertx-kafka sink connector has no aggregation strategies out of the box.
// kafka-connector options: END
",12066,True,3368.38462745506,median
"= ExpenseLa - Developer Guide
:site-section: DeveloperGuide
:toc:
:toc-title:
:toc-placement: preamble
:sectnums:
:imagesDir: images
:stylesDir: stylesheets
:xrefstyle: full
ifdef::env-github[]
:tip-caption: :bulb:
:note-caption: :information_source:
:warning-caption: :warning:
endif::[]
:repoURL: https://github.com/AY1920S2-CS2103-T09-3/main/tree/master

image:logos/ExpenseLa_Logo.png[]

By: `Team AY1920S2-CS2103-T09-3`      Since: `Feb 2020`      Licence: `MIT`

== Introduction

ExpenseLa is an application for NUS students to be able to track their spending and also gain insights to their monthly spending through data analytics. The data analytics portion of ExpenseLa aims to aid students in viewing and comparing their monthly expenditure on items of different categories such as shopping and groceries, as well as keeping track of their monthly budgets. ExpenseLa records daily incoming and outgoing transactions and constantly keeps track of the user's budget, income and spending. ExpenseLa is optimised for users who prefer to work with a Command Line Interface (CLI) which works in parallel with a Graphical User Interface (GUI). It is an easy, insight-driven application that hopes to help students keep better track of their expenses.

=== Purpose

This developer guide aims to communicate the design and architecture of the software implementation to developers working on ExpenseLa. It also includes future implementations to give developers an idea of the direction that ExpenseLa intends to take on both current and future features. A developer should be able to understand the design, architecture and future goals of ExpenseLa upon reading this guide.

=== Scope

This developer guide specifies the technical and non-technical details of ExpenseLa. The technical aspects include the design and architecture of the software and the non-technical aspects include the user stories, use cases and non-functional requirements.

== Setting up

Pleas refer to the guide <<SettingUp#, here>>.

== Design

[[Design-Architecture]]
=== Architecture (Pang Kim Jin)

In this section, we will be introducing the individual components that form ExpenseLa using various diagrams.

.Architecture Diagram
image::ArchitectureDiagram.png[]

The *_Architecture Diagram_* given above explains the high-level design of the App. Given below is a quick overview of each component.

[TIP]
The `.puml` files used to create diagrams in this document can be found in the link:{repoURL}/docs/diagrams/[diagrams] folder.
Refer to the <<UsingPlantUml#, Using PlantUML guide>> to learn how to create and edit diagrams.

`Main` has two classes called link:{repoURL}/src/main/java/seedu/expensela/Main.java[`Main`] and link:{repoURL}/src/main/java/seedu/expensela/MainApp.java[`MainApp`]. It is responsible for,

* At app launch: Initializes the components in the correct sequence, and connects them up with each other.
* At shut down: Shuts down the components and invokes cleanup method where necessary.

<<Design-Commons,*`Commons`*>> represents a collection of classes used by multiple other components.
The following class plays an important role at the architecture level:

* `LogsCenter` : Used by many classes to write log messages to the App's log file.

The rest of the App consists of four components.

* <<Design-Ui,*`UI`*>>: The UI of the App.
* <<Design-Logic,*`Logic`*>>: The command executor.
* <<Design-Model,*`Model`*>>: Holds the data of the App in-memory.
* <<Design-Storage,*`Storage`*>>: Reads data from, and writes data to, the hard disk.

Each of the four components

* Defines its _API_ in an `interface` with the same name as the Component.
* Exposes its functionality using a `{Component Name}Manager` class.

For example, the `Logic` component (see the class diagram given below) defines it's API in the `Logic.java` interface and exposes its functionality using the `LogicManager.java` class.

.Class Diagram of the `Logic` Component
image::LogicClassDiagram.png[]

[discrete]
==== How the architecture components interact with each other

The _Sequence Diagram_ below shows how the components interact with each other for the scenario where the user issues the command `delete 1`.

.Component interactions for `delete 1` command
image::ArchitectureSequenceDiagram.png[]

The sections below give more details of each component.

[[Design-Ui]]
=== UI component (Choi Min Suk)

.Structure of the UI Component
image::UiClassDiagram.png[]

*API* : link:{repoURL}/src/main/java/seedu/expensela/ui/Ui.java[`Ui.java`]

The UI consists of a `MainWindow` that is made up of parts e.g.`CommandBox`, `ResultDisplay`, `TransactionListPanel`, `StatusBarFooter` etc. All these, including the `MainWindow`, inherit from the abstract `UiPart` class.

The `UI` component uses JavaFx UI framework. The layout of these UI parts are defined in matching `.fxml` files that are in the `src/main/resources/view` folder. For example, the layout of the link:{repoURL}/src/main/java/seedu/expensela/ui/MainWindow.java[`MainWindow`] is specified in link:{repoURL}/src/main/resources/view/MainWindow.fxml[`MainWindow.fxml`]

The `UI` component does the following actions:

* Executes user commands using the `Logic` component.
* Listens for changes to `Model` data so that the UI can be updated with the modified data.


[[Design-Logic]]

=== Logic component (Hubert Halim)

[[fig-LogicClassDiagram]]
.Structure of the Logic Component
image::LogicClassDiagram.png[]

*API* :
link:{repoURL}/src/main/java/seedu/expensela/logic/Logic.java[`Logic.java`]

Logic is an interface which `LogicManager` implements, allowing access to the API. The following items are examples on how the LogicManager class can be interacted with:

.  `Logic` uses the `ExpenseLaParser` class to parse the user command.
.  This results in a `Command` object which is executed by the `LogicManager`.
.  The command execution can affect the `Model` (e.g. adding a `Transaction`).
.  The result of the command execution is encapsulated as a `CommandResult` object which is passed back to the `Ui`.
.  In addition, the `CommandResult` object can also instruct the `Ui` to perform certain actions, such as displaying help to the user.

Given below is the Sequence Diagram for interactions within the `Logic` component for the `execute(""delete 1"")` API call.

.Interactions Inside the Logic Component for the `delete 1` Command
image::DeleteSequenceDiagram.png[]

NOTE: The lifeline for `DeleteCommandParser` should end at the destroy marker (X) but due to a limitation of PlantUML, the lifeline reaches the end of diagram.

.Interactions Inside the Logic Component for the `clear` Command
image::ClearSequenceDiagram.png[]

[[Design-Model]]
=== Model component (Pang Kim Jin)

.Structure of the Model Component
image::ModelClassDiagram.png[]

*API* : link:{repoURL}/src/main/java/seedu/expensela/model/Model.java[`Model.java`]

The `Model`,

* stores an ArrayList which contains the user's command history.
* stores a `UserPref` object that represents the user's preferences.
* stores the `ExpenseLa` data.
* stores the `GlobalData` which contains the recurring budget, transactions, total balance, and last updated date.
* stores a `MonthlyData` object which contains budget, expense, and income information set by the user.
* stores a `ToggleView` object that represents the nature of transaction information displayed to the user.
* stores a `Filter` object which represents the filter on the transactions as set by the user
* stores `TransactionList` which contains the list of all transactions
* exposes an unmodifiable `ObservableList<Transaction>` that can be 'observed' e.g. the UI can be bound to this list
so that the UI automatically updates when the data in the list change.
* does not depend on any of the other three components.



[[Design-Storage]]
=== Storage component (BenjaminFheng)

.Structure of the Storage Component
image::StorageClassDiagram.png[]

*API* : link:{repoURL}/src/main/java/seedu/expensela/storage/Storage.java[`Storage.java`]

The `Storage` component,

* can save `UserPref` objects in json format and read it back.
* can save the `ExpenseLa` data in json format and read it back.
* can save `GlobalData` data in json format and read it back.

[[Design-Commons]]
=== Common classes

Classes used by multiple components are in the `seedu.ExpenseLa.commons` package.

== Implementation

This section describes some noteworthy details on how certain features are implemented.

// tag::addtransactions[]
=== Adding transactions (BenjaminFheng)
We allow users to add Expense/Income transactions into ExpenseLa which denotes a positive or negative inflow of money. This section shows how we handle these requests from the user.

==== Implementation

We store every single `Transaction` added by the user into an `ObservableList<Transaction>`, which is a list object in `TransactionList`. We used an `ObservableList` to easily reflect changes to the list by any other component of ExpenseLa using the list.

These are the ways of implementing either a positive or negative Transaction:

* Adding an expense (negative transaction): add
* Adding an income (positive transaction): add i/

These two commands will indicate whether the transaction is positive or negative.

Indicating whether it is a recurring transaction or not will depend if rc/ is present in the input

When inserting a new Expense/Income, the `AddCommandParser` will determine which object to initialise depending on whether the ""i/"" CLI syntax is present. Afterwhich, the AddCommandParser will parse the values of the transaction depending on whether the respective CLI Syntaxes are present.

* `**Name**` is parsed by `AddCommandParser#parseName(ArgumentMultimap)`, CLI Syntax is n/.
* `**Amount**` is parsed by `AddCommandParser#parseAmount(ArgumentMultimap)`, CLI Syntax is a/.
* `**Date**` is parsed by `AddCommandParser#parseDate(ArgumentMultimap)`, CLI Syntax is d/.
* `**Category**` is parsed by `AddCommandParser#parseCategory(ArgumentMultimap)`, CLI Syntax is c/.
* `**Remark**` is parsed by `AddCommandParser#parseRemark(ArgumentMultimap)`, CLI Syntax is r/.
* CLI Syntax ""rc/"" will set the transaction to be a monthly recurring transaction.

NOTE: `**ArgumentMultimap**` is a class that stores all the parsed parameters taken from the user input.

NOTE: `**Category**` has a set enum list of values FOOD, SHOPPING, TRANSPORT, GROCERIES, HEALTH, RECREATION, MISC, UTILITIES, INCOME.

The following sequence diagram shows how the add transaction operation works:

image::add-command/AddCommandSequenceDiagram.png[]

Figure 9. Sequence diagram of how adding a new `Transaction` is processed depending on syntax.

`Transaction` are normally instantiated by `AddCommandParser#parse(String args)`, which attempts to parse the various parameters supplied in args and return either a positive or negative `Transaction`. The following conditions will cause a `ParseException` to be thrown by the parser:

* Missing parameters
* Incorrect syntax (i.e. missing prefix if required)
* Illegal values in parameters (i.e. special character and symbols entered for an integer only field)
* Multiple occurence of parameters which only expects single entry

[NOTE]
Incorrect user input will display `ParseException` message.


*We will demonstrate how a `Transaction` is added into `ExpenseLa` below:*

Step 1. The user executes the command **add n/Pizza a/20.5 d/2020-02-02** to insert a negative transaction with its `Name` set to ""Pizza"", its `Amount` set to ""20.50"" and the `Date` set to 02 Feb 2020. The input is now checked and an attempt to parse each parameter occurs:

NOTE: `**Category**` is set to default category `MISC`

Since the user input is valid, the `Transaction` is successfully created and inserted into the transaction list. The transaction list now contains 1 `Transaction` object.

image::add-command/AddTransactionToList1.png[]

Step 2. The user executes **add i/ n/Salary a/3000 d/2020-02-03 r/Monthly Salary c/income rc/ ** to indicate his monthly pay, to insert a positive `**Transaction**`.

NOTE: ""rc/"" CLI Syntax will set the transaction to be a recurring transaction.

Again, since the input is valid, the positive `Transaction` is successfully added into the transaction list. The transaction list
now contains 2 `**Transaction**` objects.

image::add-command/AddTransactionToList2.png[]

The following activity diagram summarizes what happens when the user executes a command to add a new `Transaction`:

:figure-caption: Figure
.Activity diagram of adding a `Transaction` into the transaction list.
image::add-command/AddTransactionActivityDiagram.png[,650]

==== Design considerations

There are many different ways to implement how a transaction is added into `**ExpenseLa**`. In this section, we will justify why we chose to implement it the way we did.

===== Aspect: Differentiating between **positive** and **negative** transactions.
* **Alternative 1: (current choice):** Adding a simple ""i/"" syntax in the input to differentiate between positive and negative transactions
** Pros: Increases the speed and simplicity of adding a positive or negative transaction. Updating balance in `MonthlyData` information only requires an iteration through
all the transaction amounts in transaction list for calculation.
** Cons: Transactions may not be easily distinguishable as positive or negative transactions on first sight, and may only be distinguished when the transaction amount is inspected.
This may cause slower processing times when extracting all only positive or only negative transactions.

* **Alternative 2: Having separate classes for **positive** and **negative** transactions.
** Pros: Maintains an intuitive design: `**NegativeTransaction**` deducts money and `**PositiveTransaction**` increases money.
** Cons: May incur significant overhead since it is likely that both `**NegativeTransaction**` and `**PositiveTransaction**` will
have very similar methods.

Alternative 1 was chosen because we want the application to be as simple and quick as possible to indicate positive and negative transactions. We focused on separating
the data between months so that the analytics function could calculate data faster.

===== Aspect: Managing how `**RecurringTransactions**` are handled.
* **Alternative 1: (current choice):** Adding a simple ""rc/"" syntax in the input to differentiate between recurring and non-recurring transactions. ""rc/"" is quickly parsed by the
AddCommandParser and the transaction is labelled as recurring, which is added to RecurringTransactionsList before the command is added to the TransactionsList in Model.
** Pros: ""rc/"" is quick and intuitive to indicate during input. Almost no hassle to add the information to RecurringTransactionsList.
** Cons: Inability for existing transactions to set as recurring transactions.

* **Alternative 2:** Create a separate command to indicate which transactions are recurring and the range of when it recurs.
** Pros: Transactions are more customizable for users. Users are able to set recurring transactions to repeat over required months.
** Cons: Users may easily lose track of the transactions that are recurring which will affect their monthly budgeting.

Alternative 1 was chosen because we want to again keep the recurring transactions intuitive and simple. Users can clear their recurring transaction lists whenever
they become invalid, and input the new recurring transactions whenever there are changes

//end::addtransaction[]

// tag::editTransactions[]
=== Editing transactions (BenjaminFheng)
The **edit **functionality modifies details of a specified `**Transaction**` in the existing list and saves
modifications to the external storage file.

==== Implementation
**Edit** mechanism utilizes `**Logic**` operations with the `**EditCommand**` class in place of
`**Command**`, and a unique `**EditCommandParser**` class. The following methods are the implementation for
**edit** operations:

* `EditCommandParser#parse()` - Parses the user's input via the index of the transaction and creates an `**EditCommand**` to execute the command.
* `EditCommand#execute()` - Modifies the `**Transaction**` in `**Model**` with new details and returns a
`**CommandResult**`.
* `TransactionList#setTransaction(Transaction target, Transaction editedTransaction)` - Sets the modified `**Transaction**` to its correct position in the
existing `**TransactionList**`.

Command example: **edit 1 n/[NAME] a/[AMOUNT] r/[REMARK]** will edit the name, amount and remark of transaction of index 1 with
the respective inputs.

*Below is an example usage scenario for editing a transaction and explanation of how the edit mechanism
behaves at each step:*

Step 1. The user starts up the application with an initial list loaded from a sample transaction list.

:figure-caption!:
.Initial transaction list
image::edit-command/editCommand1.png[,650]

Step 2. The user inputs **edit 1 n/Laksa Noodle a/6.00** to edit the transaction (with index 1) name to ""Laksa Noodle"" and value
to ""6"". Input is parsed by `EditCommandParser#parse()` which creates an `**EditCommand**`.

Step 3. `EditCommand#execute()` creates a new transaction that reflects the changes and gets the index of current
transaction to be edited.

.New edited transaction in transaction list
image::edit-command/editCommand2.png[,650]

Step 4. `EditCommand#execute()` replaces original transaction in the list with the eddited transaction.

The following activity diagram gives an overview of what ExpenseLa shows the user when executing **edit** command:

:figure-caption: Figure
.Activity diagram for execution of edit command
image::edit-command/EditActivityDiagram.png[,650]

==== Design considerations
This subsection explores some alternative designs considered for certain aspects of the feature's implementation.

===== Aspect: Modifying details of a transaction
* **Alternative 1 (current choice)**: Replace the values of the original transaction with new editd values.
- Pros: Can easily check for inputs that result in no changes.
- Cons: May incur overhead when creating new instance of `**Transaction**`.

* **Alternative 2**: Modify the transaction directly using setter methods.
- Pros: Easy to implement and efficient.
- Cons: Modifying transactions violates the immutability principle, possibly resulting in bugs for UI or
accessing modified transaction fields.

**Alternative 1 chosen** to maintain better coding practices and maintain immutability of transactions for the entire project.
Overhead of creating new `**Transaction**` is insignificant due to relatively small object size.

===== Aspect: Edit transaction by getting it's index or by unique transaction ID
* **Alternative 1 (current choice)**: Get the index of original transaction in the transactions list and edit its values in the list.
- Pros: High certainty of obtaining the correct transaction, editing its values and replacing the same index in the transaction list.
- Cons: If there are too many transactions in the list, it might be tedious to obtain the transaction index by scrolling.

* **Alternative 2**: Iterate through the transactions list and edit the transaction with the correct transaction ID.
- Pros: Virtually impossible to not be able to distinguish between similar transactions of different IDs.
- Cons: Transactions ID would cause significant overhead when looking into each transaction for it's ID.
// end::edit[]


// tag::setbudget[]
=== Setting budgets (Hubert Halim)
We allow the user to maintain a `**Budget**` for the current month and subsequent months. This section details how `**ExpenseLa**` handles
requests made by the user who is trying to set a budget both for a one time and recurring budget. `**Budget**` is contained inside
`**MonthlyData**` object along with `**Expense**` and `**Income**` and application only has 1 `**MonthlyData**` object for the current month.
object looks like:

image::set-budget/BudgetClassDiagram.png[]

If user decides to create a recurring budget, there'll be additional step of updating the `**recurringBudget**` variable in
`**GlobalData**`. `**BudgetCommand**` in addition to modifying `**Budget**` in `**MonthlyData**`, it will also modify `**recurringBudget**`
in `**GlobalData**`.

image::set-budget/GlobalDataClassDiagram.png[]


==== Implementation
Whenever the user attempts to set a new `**Budget**`, `**ExpenseLa**` will create a new MonthlyData object with the given amount.
The application will then call `ModelManager#setMonthlyData(MonthlyData toSet)`. During the creation of the new MonthlyData, the
Budget class will internally check if the budget amount is valid.

We will demonstrate what happens at the back-end whenever the user sets a budget:

Case 1. The user wishes to set their budget to $1500, non-recurring. They execute the command: **budget b/1500**.
The user's entry is checked by `BudgetCommandParser#parse()` and an attempt to parse each parameter occurs:

* `**Budget**` is parsed by `ParseUtil#parseBudget(ArgumentMultimap)`
* `rc/` prefix does not exist, so it is not recurring

NOTE: `**ArgumentMultimap**` is a class that stores all the parsed parameters taken from the user input.

Since the user input is valid, the `**Budget**` is successfully created and inserted into a newly created `**MonthlyData**`.

Case 2. The user made a typo when setting their budget. They execute the command **budget b/1500**.
The user's entry is checked by `BudgetCommandParser#parse()` and an attempt to parse each parameter occurs:

* `**Budget**` is parsed by `ParseUtil#parseBudget(ArgumentMultimap)`

`**Budget**` class then is attempted to be created with the parsed budget amount in the constructor. Internally
Budget will do a validity check using Regex and throw a `**ParseExection**` since amount is not valid.

Case 3. The user wishes to set their budget to $1500, recurring. They execute the command: **budget b/1500 rc/**.
The user's entry is checked by `BudgetCommandParser#Parse()` and an attempt to parse each parameter occurs:

* `**Budget**` is parsed by `ParseUtil#parseBudget(ArgumentMultimap)`
* `rc/` prefix exists, so it is recurring

Since the user input is valid, the `**Budget**` is successfully created and inserted into a newly created `**MonthlyData**`.
BudgetCommand will then modify `**GlobalData**` in `**Model**` by calling `**Logic#setGlobalData**`. `**RecurringBudget**`
value in `**GlobalData**` is now set to the new `**Budget**`

The sequence diagram below depicts what was just elaborated:

.Sequence diagram showing how a `**Budget**` is set
image::set-budget/SetBudgetSequenceDiagram.png[]

.Activity diagram showing how a `**Budget**` is set
image::set-budget/SetBudgetActivityDiagram.png[]

==== Design considerations
We have considered various ways as to how `**Budget**` should be stored in `**ExpenseLa**`. In this section, we will explain the
rationale on our course of actions.

===== Aspect: Make `**Budget**` a part of a bigger class called `**MonthlyData**`
* **Alternative 1 (current choice):** `**Budget**` is a part of `**MonthlyData**` and any `**Budget**` operations is through `**MonthlyData**`
** Pros: Easier to handle `**Budget**` together with other `**MonthlyData**` objects and all data inside is synchronised as it is
handled by a single object.
** Cons: Overhead when modifying `**Budget**` as to maintain immutability, a new `**MonthlyData**` object has to be created.
* Alternative 2: `**Budget**` should be an independent class with a direct reference in `**ExpenseLa**`.
** Pros: More freedom and efficiency in doing modifications on `**Budget**`
** Cons: Need to maintain more references for all different objects.

Again, we went with alternative 1 because it is easier to view `**Budget**` along with the other `**MonthlyData**` components
as a collective. And easier to just handle 1 reference in ExpenseLa.
// end::setbudget[]


// tag::commandHistoryNavigation[]
=== Command History navigation (Hubert Halim)
Users can navigate to previous commands by pressing the up or down button on the keyboard.
Only successful commands are stored in the CommandHistory list and only a maximum of 50 commands can
be stored at a time.

==== Implementation
Every time the user key in a command and press kbd:[Enter], `CommandBox#handleCommandEntered` method will be called.
The method will attempt to execute the command by calling `CommandExecutor#execute` method. That method throws an error
if command is invalid. So if the command is valid, the `CommandBox#handleCommandEntered` method will call
`Logic#deleteCommandFromHistory` to delete the command if it exists in the current command history.
It will then call `Logic#addToCommandhistory` to add the command to the command history as its latest entry.
Both commands for add and delete takes in an integer variable called `offset`. This variable is maintained by `CommandBox`
and determines which command the user is currently at in the command history.
Offset starts from -1 indicating `CommandBox` is empty and resets to -1 every time a successful command is entered

`Command History` is an array list that resides in `ModelManager` object. It can be accessed through `Logic` by calling

The diagrams below depicts what was just elaborated:

.Sequence diagram showing what happens when user enters a Command
image::command-history/CommandHistorySequenceDiagram.png[]

.Activity diagram showing what happens when user enters a Command
image::command-history/CommandHistoryActivityDiagram.png[]

.Sequence diagram showing what happens when presses Up/Down button
image::command-history/CommandHistoryNavigateSequenceDiagram.png[]

.Activity diagram showing what happens when presses Up/Down button
image::command-history/CommandHistoryNavigateActivityDiagram.png[]


==== Design considerations
We have considered various ways as to how to implement `**CommandHistory**` to support navigation to previous commands
Since we need to capture keyboard events when user press the keyboard, we decided to implement the event listener and handler
in `**CommandBox**` component as it is more convenient because when a keyboard event is captured, the app can straight away
modify the `**TextField**` in `**CommandBox**`. Since the event when user enter a command is also handled in `**CommandBox**`
and we only store successful commands in `**CommandHistory**`, we wait for execution of the Command by `**CommandExecutor**`,
if it is successful, the String for the command is added to, otherwise due to the error thrown and caught somewhere else, the
command is not stored.
// end::commandHistoryNavigation[]


=== Filtering Transactions (Pang Kim Jin)

The `Filter` command allows the user to bring up a list of `Transaction`, and filter it by either category, month,
or both at the same time. This is implemented by using a predicate for category and another predicate for month,
both of which inheriting from `Predicate<Transaction>` to filter the `Transaction`.

==== Implementation

`FilterCommand` is instantiated by `FilterCommandParser#parse(String args)` method, which parses the arguments supplied in the user
command to return a `FilterCommand` object.

The below sequence diagram depicts the interactions within the `Logic` component for the execute(""filter c/FOOD m/2020-04"") call:
image:FilterSequenceDiagram.png[]

The below scenario shows a typical usage of the filter feature:

Step 1: Upon application launch, the filter for all categories and the current month is automatically applied.
image:filter/Filter_SS_1.PNG[]

Step 2: User executes the command `filter c/food m/2020-02` to bring up transactions in the category ""FOOD"" for the month
of February 2020. (Note: The command in the command line disappears upon hitting Enter, the command in the command line
is purely for illustration purposes).
image:filter/Filter_SS_2.PNG[]

Step 3: The `FilterCommandParser#parse(String args)` parses the arguments.

Step 4: Since user input is correct and the arguments are parsed, a new `FilterCommand` object is created by the
`FilterCommandParser`.

Step 5: The `FilterCommand` object will use a `Predicate<Transaction>` based on the specified category, month, or both, to filter
the list of transactions.

Step 6: The list of filtered transactions is brought up. The filter category and month UI will also update accordingly
to show the category and month that the transactions are filtered by.

The below activity diagram gives an overview of the command execution:
image:filter/FilterActivityDiagram.png[]

==== Design Considerations

*Aspect: Using `Predicate` to improve extendability of the `Filter` feature in the future.*

* Alternative 1 (current choice): Create a new `Predicate<Transaction>` for each new filter type
** Pros: Greater flexibility can be provided for each filter type since different filter types have different requirements (e.g. Month vs Category)
** Cons: Tedious to implement a new class for each new type of filter
* Alternative 2: Use a single `Predicate<Transaction>` to filter for all filter types
** Pros: Easy to implement
** Cons: Prone to being inflexible for extensions

We decided to go with Alternative 1 since the current filter feature supports increasing the number of filter types
- on top of the current category and month filters. Despite having a different `Predicate` for each filter type, we use
a composed `Predicate` comprising of both `Predicate` s, making it much easier to support extensions to this feature.

==== Proposed Extension

We plan to enhance the filter feature to support other arguments in the command to filter by different types such as
price range or date range. This allows the user to have greater flexibility and have a better understanding of his/her
expenses.

The design consideration mentioned earlier hence facilitates this proposed extension, reducing the difficulty of such a
future implementation.

=== Chart Analytics (Choi Min Suk + Pang Kim Jin)

The *toggleview* command allows the user to switch between viewing the list of 'Transactions' and viewing an analysis of
his expenditure.

In the expenditure analysis view we have a bar chart to show expenditure breakdown by date as well as a pie chart to
show expenditure breakdown by category.


==== Implementation

`MainWindow` decides whether to show a list of transactions or chart analysis based on `ToggleView#isViewList`, by accessing
`Logic#getToggleView()`.

Here is a Class Diagram for the implementation of `ToggleView`:

image:chart-analytics/ToggleViewClassDiagram.png[]

The *ToggleView* mechanism utilizes `Logic` operations with the `ToggleViewCommand` class in place of `Command`. The following
methods are concrete implementations for the *toggle* operation:

* `ToggleViewCommand#execute()` - Modifies the `ToggleView` in `Model` to view list of transactions or view analytics, and
returns a `CommandResult` (<<Design-Logic, Step 4 of Logic>>).
* `ToggleView#switchIsViewList()` - Modifies the boolean value `isViewList` in `ToggleView` to the negation of it's
current value.
- This `ToggleView` is wrapped in `ExpenseLa` and its `switchIsViewList()` is called through
`ExpenseLa#switchToggleView()`.
- `ExpenseLa#switchToggleView()` is exposed in the `Model` interface as `Model#switchToggleView()`.

The following sequence diagram illustrates **toggleview** command execution:

.Sequence diagram showing execution of **toggleview**
image::chart-analytics/ToggleViewSequenceDiagram.png[]

===== Example of usage
Given next is an example and explanation of how the **ToggleView** mechanism behaves at each step:

Step 1. The user starts up the application with an initial list loaded from external storage file. The diagram here
depicts the example list used throughout this scenario.

:figure-caption!:
.Example list on startup
image::chart-analytics/ToggleViewStep1.png[,650]

Step 2. The user inputs **toggleview** to change the view from list of transactions to chart analysis.

.User input for toggle view
image::chart-analytics/ToggleViewStep2.png[]

Step 3. `ToggleViewCommand#execute()` switches `isViewList` of `ToggleView` from true to false.

.isViewList of ToggleView switched from ToggleViewCommand#execute()
image::chart-analytics/ToggleViewStep3.PNG[]

Step 4. `MainWindow#executeCommand()` checks the boolean value of isViewList in ToggleView, which is false,
and displays chart analysis.

.Switched from showing list of transactions to chart analysis
image::chart-analytics/ToggleViewStep4.png[,650]

Step 5. User inputs **toggleview** again to change view back to list of transactions.

image::chart-analytics/ToggleViewStep2.png[]
.Switched from showing list of transactions to chart analysis
image::chart-analytics/ToggleViewStep1.PNG[,650]

Step 6. User can set filter to a certain month to view a different kind of bar chart.

.Example of stacked bar chart of expenditure for a certain month
image::chart-analytics/ToggleViewStep6.PNG[,650]

The following code snippet from `MainWindow#executeCommand()` checking of the boolean value of isViewList in ToggleView,
and deciding whether to show a list of transactions of chart analysis, and what bar graph to show:

.MainWindow#executeCommand()
[source, java]
----
// The if else statement checks the value of isViewList from ToggleView
if (logic.getToggleView().getIsViewList()) {
    // Creates ui for list of transactions
    transactionListPanel = new TransactionListPanel(logic.getFilteredTransactionList());
    transactionListAndChartAnalyticsPanelPlaceholder.getChildren().add(transactionListPanel.getRoot());
} else {
    // Creates ui for chart analysis
    // Calls logic.getIsFilterMonth() to check if the filter is set to a specific month or not, to decide which bar graph to build
    chartAnalyticsPanel = new ChartAnalyticsPanel(logic.getFilteredTransactionList(), logic.getIsFilterMonth());
    transactionListAndChartAnalyticsPanelPlaceholder.getChildren().add(chartAnalyticsPanel.getRoot());
}
----

===== Execution shown to user
The following activity diagram gives an overview of what ExpenseLa shows the user when executing **toggleview** command:

:figure-caption: Figure
.Activity diagram for execution of toggleview command
image::chart-analytics/ToggleViewActivityDiagram.png[]

==== Design considerations
This section shows some of the design considerations taken when implementing the undo and redo features.

===== Aspect: Design used to implement toggelview feature

* Alternative 1 (current choice): Create a ToggleView Class to keep a boolean value of isViewList to keep track of
showing list of transactions or chart analysis.
** Pros: Easily extendable next time to accommodate more different kind of views by changing boolean to possibly enum.
** Pros: Easy to implement functions to change values in `ToggleView` object, which allows easy extendability next time also.
** Cons: Needs to implement many functions through `Logic` and `Model`.
* Alternative 2: Create a boolean value in `Model` to track whether to show list of transactions or chart analysis.
** Pros: Easy implementation and checking of boolean value by `MainWindow` to check which view to show.
** Cons: Not extendable next time when trying to accommodate different kind of views.

Alternative 1 was chosen because it is easily extendable, in case we want to improve or develop on the feature in the
future. It also follows better OOP principles, making the code much neater and understandable.

=== Export (Choi Min Suk)

The *export* command allows user to export currently filtered transactions to a csv file, in case he would like to use
the data for his own analysis.

==== Implementation

`ExportCommand` is instantiated by `ExpenseLaParser#parseCommand(String userInput)`, which attempts to split the userInput
into the command word and its parameters. Since `ExportCommand` does not require any arguments, it is instantiated directly.


`ExportCommand` obtains the filtered list of transaction to export using `Model#getFilteredTransactionList()`, which then
attempts to create a csv file in the current directory using the attributes of each transaction.

The sequence diagram below shows how the execution of *export* is like:

.Sequence diagram of how *export* command is applied at the back-end.
image::export/ExportSequenceDiagram.png[]

The following conditions will cause a `**CommandException**` to be thrown by the command:

. Empty filtered transaction list
. Failure in creating the file
. Failure in writing to the file (Possibly due to the directory changing while the command is being executed)

The image below shows how the csv file looks when user executes *export* command successfully:

.List of transactions in a csv file opened in Microsoft Excel
image::export/ExportCsv.PNG[,650]

==== Proposed extension
In the near future, we plan to enhance the export feature. We want to improve the export command to take in view as a
possible argument, thus allowing the user to choose between exporting list of transactions or the chart analysis. The
user can use the chart analysis generated for visual presentations, especially if the expense tracker is for a business.

The image below shows how a possible future implementation of this feature could look like:

.Expected command to export chart analytics
image::export/ExportChartCommand.PNG[]

image::export/ExportBarGraph.PNG[,550]
.Expected images to be exported when *export chartanalysis*
image::export/ExportPieChart.PNG[,550]

=== [Proposed] Data Encryption (Pang Kim Jin)

Given the sensitive nature of the information provided by users, we would like to safeguard the information provided by
our users through encryption. Naturally, the information would be encrypted and decrypted in the back-end without the user
requiring to do any of the encryption, decryption, or even any knowledge of how it works.

==== Proposed Implementation

We thus propose a `Keystore` module to contain authorisation certificates or public key certificates
interacting with the `Logic` and `Storage` modules. With this addition, the following architecture diagram
gives an overview of how it would fit in:

image::DataEncryptionClassDiagram.png[]

The `Keystore` module would have a `KeystoreManager` which implements the following methods:

* `KeystoreManager#setCipher(Cipher cipher)` - sets the `Cipher` for encryption usage.
* `KeystoreManager#encryptExpenseLa(ExpenseLa expenseLa)` - encrypts the given `ExpenseLa` object with the encryption cipher set with every
call to `LogicManager#execute()` method.
* `KeystoreManager#decryptExpenseLa(ExpenseLa expenseLa)` - Decrypts the encrypted json file upon application launch.

The following class diagram provides a depiction of the above:

image::DataEncryptionClassDiagram2.png[]

NOTE: `KeystoreManager#encryptExpenseLa(ExpenseLa expenseLa)` and `KeystoreManager#decryptExpenseLa(ExpenseLa expenseLa)`
will be using the Advanced Encryption Standard (AES 256) encryption algorithm.

==== Design Considerations
*Aspect: Encryption Algorithm*

* Alternative 1: Data Encryption Standard
** Pros: Simpler to implement encryption and decryption
** Cons: Weaker security, easy to brute force
* Alternative 2 (current choice) : Advanced Encryption Standard
** Pros: 256 bit key is exponentially more secure than DES' 56 bit key
** Cons: Harder to implement


=== [Proposed] ExpenseLa Monthly Statement (Pang Kim Jin)

Similar to how banks issue a statement of account, we believe that it would be helpful to provide
our users with an overview of their expenses. This statement would include the user's balance,
budget, expense, income, and transactions in a user specified time frame.The user can choose to include/exclude certain
transactions based on their categories or dates.

==== Proposed Implementation

To generate the statement, we propose a `StatementCommand` that extends `Command` and works with `ModelManager` just like
all other commands, as depicted in the following diagram:

image::StatementCommandClassDiagram.png[]

* The user uses the `FilterCommand` to  filter the list of transactions to show only the transactions with the
user's preferred category and transaction month
* Then `StatementCommand#execute()` will retrieve the `FilteredList` of transactions
and generate a Portable Document Format (PDF) file with Java's PDFWrite API.

Below is a truncated example of the PDF ExpenseLa statement:

image::statement/Statement.png[]

==== Design Considerations

*Aspect: Time and Nature of Transactions to Export*

* Alternative 1 (current choice): Users get to choose when to generate their statement and which month and categories of
transactions to include.
** Pros: Users get a statement tailored according to their needs.
** Cons: Users may forget to include certain types of transactions.
* Alternative 2: At the end of every month, a statement of all transactions and user information is exported
** Pros: Users get a comprehensive view of their expenses
** Cons: Users may be overloaded with information

Ultimately we chose Alternative 1 as we prioritise our user's freedom of choice and we understand that not all transactions
may be relevant for the purposes of exporting the statement.

=== Logging

We are using `java.util.logging` package for logging. The `LogsCenter` class is used to manage the logging levels and logging destinations.

* The logging level can be controlled using the `logLevel` setting in the configuration file (See <<Implementation-Configuration>>)
* The `Logger` for a class can be obtained using `LogsCenter.getLogger(Class)` which will log messages according to the specified logging level
* Currently log messages are output through: `Console` and to a `.log` file.

*Logging Levels*

* `SEVERE` : Critical problem detected which may possibly cause the termination of the application
* `WARNING` : Can continue, but with caution
* `INFO` : Information showing the noteworthy actions by the App
* `FINE` : Details that is not usually noteworthy but may be useful in debugging e.g. print the actual list instead of just its size

[[Implementation-Configuration]]
=== Configuration

Certain properties of the application can be controlled (e.g user prefs file location, logging level) through the configuration file (default: `config.json`).

== Documentation

Refer to the guide <<Documentation#, here>>.

== Testing

Refer to the guide <<Testing#, here>>.

== Dev Ops

Refer to the guide <<DevOps#, here>>.

[appendix]
== Product Scope

*Target user profile*:

* has a need to keep track of their expenses
* prefer desktop apps over other types
* can type fast
* prefers typing over mouse input
* is reasonably comfortable using CLI apps

*Value proposition*: efficient way to keep track of expenses and make decisions based on data and analytics provided

[appendix]
== User Stories

Priorities: High (must have) - `* * \\*`, Medium (nice to have) - `* \\*`, Low (unlikely to have) - `*`

[width=""59%"",cols=""22%,<23%,<25%,<30%"",options=""header"",]
|=======================================================================
|Priority |As a ... |I want to ... |So that I can...
|`* * *`
|new user
|see usage instructions
|refer to instructions when I forget how to use the App

|`* * *`
|general user
|add a new expense entry
|keep track of my expenses

|`* * *`
|someone who earns income
|add a new income entry
|keep track of my income

|`* * *`
|high-income user
|keep track of all the money I earn
|make decisions on where my most lucrative source of income is

|`* * *`
|low-income user
|set budget for current month
|limit my expenditure for the month

|`* * *`
|low-income user
|be notified by the application if i am spending too much money
|be wary of overshooting my budget

|`* * *`
|consistent thrifty user
|set budget for every month(recurrent budget) once
|have no need to constant;y set my unchanging budget

|`* * *`
|user with varying income
|be flexible with my budgets
|spend more or less on certain months depending on my financial situation

|`* * *`
|visual user
|be visually alerted when I spend a certain proportion of my budget
|adjust my spending habit for the rest of the month

|`* * *`
|careless user
|delete an expense or income entry
|remove entries that I added in by mistake

|`* * *`
|forgetful user
|find an entry by keyword
|check if I spent money on a particular thing

|`* * *`
|spendthrift user
|filter expense based on category
|know if I generally spend a lot of money or only on certain months

|`* * *`
|forward-looking user
|look at my spending trend by week or month
|keep track of my income

|`* * *`
|user trying to save money
|filter expense based on date or time period
|see how much money I have spent in that time period and make better decisions

|`* * *`
|user trying to save money
|view amount of budget left to spend
|adjust spending habit for the rest of the month

|`* * *`
|general user
|view total money I have
|be able to tell how much I can spend

|`* * *`
|user trying to save money
|view total expense for a particular month
|decide on my future expenditures

|`* * *`
|visually analytical user
|view pie chart of money spent based on category
|see where I spend the most money on

|`* * *`
|visually analytical user
|view bar chart of money spent based on time period
|see when I spend the most money

|`* * *`
|organized user
|organize my expenditure into different categories
|better able to track where I am spending my money

|`* * *`
|not one-off user
|all my expenditures and income to be saved
|continue on from previous whenever I exit and launch back the application

|`* *`
|smart analytical user
|export my expenditure and income
|use the data to make my own analysis

|`* *`
|secretive user
|set a password to login tp the application
|prevent unwanted users from viewing my expenses

|`* *`
|businessman
|have multiple accounts
|manage my expenses not only for myself but my business

|`* *`
|parent
|have multiple accounts
|help manage my children’s expenses |

|`* *`
|user with many friends
|add friends in the application
|help each other in their savings

|`* *`
|concerned friend
|look at my friend's spending habit
|keep a lookout for their expenditure

|`*`
|user who owes people money
|view the people who I owe money to
|keep track of who I owe

|`*`
|user who lends people money
|request payment from people who owe me money
|keep track of my loans

|`*`
|sociable user
|indicate when my expenditure is within the budget
|share the achievement with my friends

|`*`
|lazy user
|have the application make recommendations on my spending habits
|easily change my spending habit without thinking

|=======================================================================


[appendix]
== Use Cases (Hubert Halim)

(For all use cases below, the *System* is the `ExpenseLa` and the *Actor* is the `user`, unless specified otherwise)

[discrete]
=== Use case: Delete expense

*MSS*

1.  User requests to list all transactions
2.  System removes all filters and show all expenses
3.  User requests to delete a specific transaction in the list
4.  System deletes the transaction
+
Use case ends.

*Extensions*

[none]
* 2a. The list is empty.
+
Use case ends.

* 3a. The given index is invalid.
+
[none]
** 3a1. System shows an error message.
+
Use case resumes at step 2.

[discrete]
=== Use case: filter transactions by category

*MSS*

1.  User requests to list filtered transactions
2.  System queries list of transactions
3.  Apply filter predicate to update list of filtered  transactions
4.  System shows filtered list
+
Use case ends.

*Extensions*

[none]
* 2a. The list is empty.
+
Use case ends.

* 3a. The category given is not valid.
+
[none]
** 3a1. System shows an error message.
+
Use case resumes at step 2.

[discrete]
=== Use case: Set recurring monthly budget
1. User requests to set a recurring budget of a specified amount.
2. `**ExpenseLa**` processes the request and sets the specified amount as the budget for the current month.
3. `**ExpenseLa**` then update the value of recurringBudget variable in GlobalData to  the specified amount.
+
Use case ends.

*Extensions*

[none]
* 1a. The parameters specified by the user are not valid.
+
[none]
** 1a1. `**ExpenseLa**` displays an invalid parameter error to the user and the monthly budget is not updated.
+
Use case ends.

[discrete]
=== Use Case: Add an expense
*MSS*

1. User requests to add a new expense into their expensela.
2. The system processes the request and adds the expense transaction into the transactions list.
+
Use case ends.

*Extensions*

[none]
* 1a. The parameters specified by the user are not valid.
+
[none]
** 1a1. The system displays an invalid parameter error to the user and the transactions list is not updated.
+
Use case ends.

[discrete]
=== Use Case: Add a recurring income
*MSS*

1. User requests to add a new recurring income into their expensela.
2. The system processes the request and adds the income transaction into the transactions list.
3. The system then add the income transaction to RecurringTransactionList in GlobalData.
+
Use case ends.

*Extensions*

[none]
* 1a. The parameters specified by the user are not valid.
+
[none]
** 1a1. The system displays an invalid parameter error to the user and the transactions list is not updated.
+
Use case ends.

[discrete]
=== Use Case: Show chart analytics view
*MSS*

1. User requests to toggle to chart analytics view.
2. The system switches the view to charts view.
** 2a. The filter for month is set to all, bar chart displays data of the last 2 years by month.
** 2b. The filter for month is set to a specific month, bar chart displays data by day of the week.
+
Use case ends.

[discrete]
=== Use Case: Clear transaction list
MSS*

1. User requests to clear all transactions.
2. The system clears transaction list in ExpenseLa.
3. The system resets MonthlyData and GlobalData
+
Use case ends.

[discrete]
=== Use Case: Export to CSV file
*MSS*

1. User requests to export current list being viewed to a CSV file.
2. The system saves the transactions to that csv file named `transactions.csv` by the system.

Use case ends.

*Extensions*

[none]
* 1a. The file does not exists.
+
[none]
** 1a1. The system creates a file with the name `transactions.csv`.
+
Use case resumes at step 2.

[discrete]
=== Use Case: Import from CSV file
*MSS*

1. User requests to import transaction data from a CSV file.
2. Import the transactions data from the file specified by the user ignoring duplicate and invalid transactions
+
Use case ends.

[none]
* 1a. The file specified by user does not exists.
+
[none]
** 1a1. The system shows an error message prompting user to rectify their command.
+
Use case ends.

[discrete]
=== Use Case: Find transactions whose name contains certain words
*MSS*

1. User requests to list transactions whose name contains certain words.
2. The system queries all transactions
3. The system applies predicate to filter only transactions that contain the words specified by user
+
Use case ends.

[none]
* 2a. The list is empty.
+
Use case ends.
+
[none]
* 3a. The list is empty.
+
Use case ends.
+


[appendix]
== Non Functional Requirements

.  Should work on any <<mainstream-os,mainstream OS>> as long as it has Java `11` or above installed.
.  Should be able to hold up to 2000 transactions(expenses and incomes) without any apparent slowdown for normal usage.
.  A user with above average typing speed for regular English text (i.e. not code, not system admin commands) should be able to accomplish most of the tasks faster using commands than using the mouse.

_{More to be added}_

[appendix]
== Glossary

[horizontal]
[[expensela]] ExpenseLa::
Stands for the application that this developer guide is written for.

[[api]] API::
Stands for ""Application Programming Interface"" which simplifies programming by abstracting the underlying implementation and only exposing objects or actions the developer needs.

[[puml]] PlantUML::
Stands for a software tool that we use to render the diagrams used in this document.

[[mainstream-os]] Mainstream OS::
Stands for commonly used Operating Systems (OS) such as Windows, Linux, Unix, OS-X

[[system-administration]] System Administration::
Stands for the field of work in which someone manages one or more systems, be they software, hardware, servers or workstations
with the goal of ensuring the systems are running efficiently and effectively.

[[MSS]] MSS::
Stands for Main Success Scenario that describes the interaction for a given use case, which assumes that nothing goes wrong.

[[CLI-syntax]] CLI Syntax::
Stands for the Command Line Interface Syntax such as ""a/"" and ""c/"" that preceeds input values which act as indicators for the system to detect those values.

[[Ui]] UI::
Stands for the user interface which is the display which interacts with the user.

[appendix]

[appendix]
== Product Survey

*ExpenseLa*

Author: Team Halim

Pros:

* Very easy and quick tracking for people that prefer command line interfaces.
* Analytics serve as a quick bird's eye view on monthly spending.
* Analytics breakdown of spending per category helps me gain insights on the categories which I have spent too much money on.
* Well made prompts to warn me when I am going to exceed my monthly budget. Helps to better my budgeting practices.

Cons:

* Takes quite a bit of time to learn all the commands.
* It can get quite tedious to input every single transaction at any time. Could possibly automate some inputs.

[appendix]
== Instructions for Manual Testing

Given below are instructions to test the app manually.

[NOTE]
These instructions only provide a starting point for testers to work on; testers are expected to do more _exploratory_ testing.

=== Launch and Shutdown

. Initial launch

.. Download the jar file and copy into an empty folder
.. Double-click the jar file +
   Expected: Shows the GUI with a set of sample contacts. The window size may not be optimum.

. Saving window preferences

.. Resize the window to an optimum size. Move the window to a different location. Close the window.
.. Re-launch the app by double-clicking the jar file. +
   Expected: The most recent window size and location is retained.

_{ more test cases ... }_

=== Deleting a person

. Deleting a person while all persons are listed

.. Prerequisites: List all persons using the `list` command. Multiple persons in the list.
.. Test case: `delete 1` +
   Expected: First contact is deleted from the list. Details of the deleted contact shown in the status message. Timestamp in the status bar is updated.
.. Test case: `delete 0` +
   Expected: No person is deleted. Error details shown in the status message. Status bar remains the same.
.. Other incorrect delete commands to try: `delete`, `delete x` (where x is larger than the list size) _{give more}_ +
   Expected: Similar to previous.

_{ more test cases ... }_

=== Saving data

. Dealing with missing/corrupted data files

.. _{explain how to simulate a missing/corrupted file and the expected behavior}_

_{ more test cases ... }_

",12393,False,2094.003081569033,median
"/*
 * Copyright (C) 2017 BalazsJako
 * Copyright (C) 2018 Patrick Mours
 * SPDX-License-Identifier: BSD-3-Clause OR MIT
 *
 * Heavily modified version of https://github.com/BalazsJako/ImGuiColorTextEdit
 */

#include ""effect_lexer.hpp""
#include ""imgui_code_editor.hpp""
#include <imgui.h>
#include <imgui_internal.h> // GetCurrentWindowRead
#include <algorithm>

const char *reshade::imgui::code_editor::get_palette_color_name(unsigned int col)
{
	// Use similar naming convention as 'ImGui::GetStyleColorName'
	switch (col)
	{
	case color_default:
		return ""Default"";
	case color_keyword:
		return ""Keyword"";
	case color_number_literal:
		return ""NumberLiteral"";
	case color_string_literal:
		return ""StringLiteral"";
	case color_punctuation:
		return ""Punctuation"";
	case color_preprocessor:
		return ""Preprocessor"";
	case color_identifier:
		return ""Identifier"";
	case color_known_identifier:
		return ""KnownIdentifier"";
	case color_preprocessor_identifier:
		return ""PreprocessorIdentifier"";
	case color_comment:
		return ""Comment"";
	case color_multiline_comment:
		return ""MultilineComment"";
	case color_background:
		return ""Background"";
	case color_cursor:
		return ""Cursor"";
	case color_selection:
		return ""Selection"";
	case color_error_marker:
		return ""ErrorMarker"";
	case color_warning_marker:
		return ""WarningMarker"";
	case color_line_number:
		return ""LineNumber"";
	case color_current_line_fill:
		return ""LineNumberFill"";
	case color_current_line_fill_inactive:
		return ""LineNumberFillInactive"";
	case color_current_line_edge:
		return ""CurrentLineEdge"";
	}
	return nullptr;
}

reshade::imgui::code_editor::code_editor()
{
	_lines.emplace_back();
}

void reshade::imgui::code_editor::render(const char *title, const uint32_t palette[color_palette_max], bool border, ImFont *font)
{
	// There should always at least be a single line with a new line character
	assert(!_lines.empty());

	// Get all the style values here, before they are overwritten via 'ImGui::PushStyleVar'
	const float button_size = ImGui::GetFrameHeight();
	const float bottom_height = ImGui::GetFrameHeightWithSpacing() + ImGui::GetStyle().ItemSpacing.y;
	const float button_spacing = ImGui::GetStyle().ItemInnerSpacing.x;

	ImGui::PushFont(font);
	ImGui::PushStyleColor(ImGuiCol_ChildBg, ImGui::ColorConvertU32ToFloat4(palette[color_background]));
	ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0.0f, 0.0f));

	ImGui::BeginChild(title, ImVec2(0, _search_window_open * -bottom_height), border, ImGuiWindowFlags_HorizontalScrollbar | ImGuiWindowFlags_AlwaysHorizontalScrollbar | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoNavInputs);
	ImGui::PushAllowKeyboardFocus(true);
	const char *const editor_window_name = ImGui::GetCurrentWindowRead()->Name;

	char buf[128] = """", *buf_end = buf;

	// 'ImGui::CalcTextSize' cancels out character spacing at the end, but we do not want that, hence the custom function
	const auto calc_text_size = [](const char *text, const char *text_end = nullptr) {
		return ImGui::GetFont()->CalcTextSizeA(ImGui::GetFontSize(), FLT_MAX, -1.0f, text, text_end, nullptr);
	};

	// Deduce text start offset by evaluating maximum number of lines plus two spaces as text width
	snprintf(buf, 16, "" %zu "", _lines.size());
	const float text_start = ImGui::CalcTextSize(buf).x + _left_margin;
	// The following holds the approximate width and height of a default character for offset calculation
	const ImVec2 char_advance = ImVec2(calc_text_size("" "").x, ImGui::GetTextLineHeightWithSpacing() * _line_spacing);

	ImGuiIO &io = ImGui::GetIO();
	_cursor_anim += io.DeltaTime;

	const bool ctrl = io.KeyCtrl, shift = io.KeyShift, alt = io.KeyAlt;

	// Handle keyboard input
	if (ImGui::IsWindowFocused())
	{
		if (ImGui::IsWindowHovered())
			ImGui::SetMouseCursor(ImGuiMouseCursor_TextInput);

		io.WantTextInput = true;
		io.WantCaptureKeyboard = true;

		if (ImGui::IsKeyPressedMap(ImGuiKey_Escape))
			ImGui::SetWindowFocus(nullptr); // Reset window focus
		else if (ctrl && !shift && !alt && ImGui::IsKeyPressedMap(ImGuiKey_Z))
			undo();
		else if (ctrl && !shift && !alt && ImGui::IsKeyPressedMap(ImGuiKey_Y))
			redo();
		else if (!ctrl && ImGui::IsKeyPressedMap(ImGuiKey_UpArrow))
			if (alt && !shift) // Alt + Up moves the current line one up
				move_lines_up();
			else
				move_up(1, shift);
		else if (!ctrl && ImGui::IsKeyPressedMap(ImGuiKey_DownArrow))
			if (alt && !shift) // Alt + Down moves the current line one down
				move_lines_down();
			else
				move_down(1, shift);
		else if (!alt && ImGui::IsKeyPressedMap(ImGuiKey_LeftArrow))
			move_left(1, shift, ctrl);
		else if (!alt && ImGui::IsKeyPressedMap(ImGuiKey_RightArrow))
			move_right(1, shift, ctrl);
		else if (!alt && ImGui::IsKeyPressedMap(ImGuiKey_PageUp))
			move_up(static_cast<size_t>(floor((ImGui::GetWindowHeight() - 20.0f) / char_advance.y) - 4), shift);
		else if (!alt && ImGui::IsKeyPressedMap(ImGuiKey_PageDown))
			move_down(static_cast<size_t>(floor((ImGui::GetWindowHeight() - 20.0f) / char_advance.y) - 4), shift);
		else if (!alt && ImGui::IsKeyPressedMap(ImGuiKey_Home))
			if (ctrl)
				move_top(shift);
			else
				move_home(shift);
		else if (!alt && ImGui::IsKeyPressedMap(ImGuiKey_End))
			if (ctrl)
				move_bottom(shift);
			else
				move_end(shift);
		else if (!ctrl && !shift && !alt && ImGui::IsKeyPressedMap(ImGuiKey_Delete))
			delete_next();
		else if (!ctrl && !shift && !alt && ImGui::IsKeyPressedMap(ImGuiKey_Backspace))
			delete_previous();
		else if (!alt && ImGui::IsKeyPressedMap(ImGuiKey_Insert))
			if (ctrl)
				clipboard_copy();
			else if (shift)
				clipboard_paste();
			else
				_overwrite ^= true;
		else if (ctrl && !shift && !alt && ImGui::IsKeyPressedMap(ImGuiKey_C))
			clipboard_copy();
		else if (ctrl && !shift && !alt && ImGui::IsKeyPressedMap(ImGuiKey_V))
			clipboard_paste();
		else if (ctrl && !shift && !alt && ImGui::IsKeyPressedMap(ImGuiKey_X))
			clipboard_cut();
		else if (ctrl && !shift && !alt && ImGui::IsKeyPressedMap(ImGuiKey_A))
			select_all();
		else if (!ctrl && !shift && !alt && ImGui::IsKeyPressedMap(ImGuiKey_Enter))
			insert_character('\\n', true);
		else
			for (ImWchar c : io.InputQueueCharacters)
				if (c != 0 && (isprint(c) || isspace(c)))
					insert_character(static_cast<char>(c), true);
	}

	// Handle mouse input
	if (ImGui::IsWindowHovered() && !alt)
	{
		const auto mouse_to_text_pos = [this, text_start, &char_advance, &calc_text_size]() {
			const ImVec2 pos(ImGui::GetMousePos().x - ImGui::GetCursorScreenPos().x, ImGui::GetMousePos().y - ImGui::GetCursorScreenPos().y);

			text_pos res;
			res.line = std::max<size_t>(0, static_cast<size_t>(floor(pos.y / char_advance.y)));
			res.line = std::min<size_t>(res.line, _lines.size() - 1);

			float column_width = 0.0f;
			std::string cumulated_string = """";
			float cumulated_string_width[2] = { 0.0f, 0.0f }; // [0] is the latest, [1] is the previous. I use that trick to check where cursor is exactly (important for tabs).

			const auto &line = _lines[res.line];

			// First we find the hovered column
			while (text_start + cumulated_string_width[0] < pos.x && res.column < line.size())
			{
				cumulated_string_width[1] = cumulated_string_width[0];
				cumulated_string += line[res.column].c;
				cumulated_string_width[0] = calc_text_size(cumulated_string.c_str()).x;
				column_width = (cumulated_string_width[0] - cumulated_string_width[1]);
				res.column++;
			}

			// Then we reduce by 1 column if cursor is on the left side of the hovered column
			if (text_start + cumulated_string_width[0] - column_width / 2.0f > pos.x && res.column > 0)
				res.column--;

			return res;
		};

		const bool is_clicked = ImGui::IsMouseClicked(0);
		const bool is_double_click = !shift && ImGui::IsMouseDoubleClicked(0);
		const bool is_triple_click = !shift && is_clicked && !is_double_click && (ImGui::GetTime() - _last_click_time) < io.MouseDoubleClickTime;

		if (is_triple_click)
		{
			if (!ctrl)
			{
				_cursor_pos = mouse_to_text_pos();
				_interactive_beg = _cursor_pos;
				_interactive_end = _cursor_pos;

				select(_interactive_beg, _interactive_end, selection_mode::line);
			}

			_last_click_time = -1.0;
		}
		else if (is_double_click)
		{
			if (!ctrl)
			{
				_cursor_pos = mouse_to_text_pos();
				_interactive_beg = _cursor_pos;
				_interactive_end = _cursor_pos;

				select(_interactive_beg, _interactive_end, selection_mode::word);
			}

			_last_click_time = ImGui::GetTime();
		}
		else if (is_clicked)
		{
			const bool flip_selection = _cursor_pos > _select_beg;

			_cursor_pos = mouse_to_text_pos();
			_interactive_beg = _cursor_pos;
			_interactive_end = _cursor_pos;

			if (shift)
				if (flip_selection)
					_interactive_beg = _select_beg;
				else
					_interactive_end = _select_end;

			select(_interactive_beg, _interactive_end, ctrl ? selection_mode::word : selection_mode::normal);

			_last_click_time = ImGui::GetTime();
		}
		else if (ImGui::IsMouseDragging(0) && ImGui::IsMouseDown(0)) // Update selection while left mouse is dragging
		{
			io.WantCaptureMouse = true;

			_cursor_pos = mouse_to_text_pos();
			_interactive_end = _cursor_pos;

			select(_interactive_beg, _interactive_end, selection_mode::normal);
		}
	}

	// Update glyph colors
	colorize();

	const auto draw_list = ImGui::GetWindowDrawList();

	float longest_line = 0.0f;
	const float space_size = calc_text_size("" "").x;

	size_t line_no = static_cast<size_t>(floor(ImGui::GetScrollY() / char_advance.y));
	size_t line_max = std::max<size_t>(0, std::min(_lines.size() - 1, line_no + static_cast<size_t>(floor((ImGui::GetScrollY() + ImGui::GetWindowContentRegionMax().y) / char_advance.y))));

	const auto calc_text_distance_to_line_begin = [this, space_size, &calc_text_size](const text_pos &from) {
		float distance = 0.0f;
		const auto &line = _lines[from.line];
		for (size_t i = 0u; i < line.size() && i < from.column; ++i)
			if (line[i].c == '\\t')
				distance += _tab_size * space_size;
			else
				distance += calc_text_size(&line[i].c, &line[i].c + 1).x;
		return distance;
	};

	for (; line_no <= line_max; ++line_no, buf_end = buf)
	{
		const auto &line = _lines[line_no];

		// Position of the line number
		const ImVec2 line_screen_pos = ImVec2(ImGui::GetCursorScreenPos().x, ImGui::GetCursorScreenPos().y + line_no * char_advance.y);
		// Position of the text inside the editor
		const ImVec2 text_screen_pos = ImVec2(line_screen_pos.x + text_start, line_screen_pos.y);

		const text_pos line_beg_pos(line_no, 0);
		const text_pos line_end_pos(line_no, line.size());
		longest_line = std::max(calc_text_distance_to_line_begin(line_end_pos), longest_line);

		// Calculate selection rectangle
		float selection_beg = -1.0f;
		if (_select_beg <= line_end_pos)
			selection_beg = _select_beg > line_beg_pos ? calc_text_distance_to_line_begin(_select_beg) : 0.0f;
		float selection_end = -1.0f;
		if (_select_end >  line_beg_pos)
			selection_end = calc_text_distance_to_line_begin(_select_end < line_end_pos ? _select_end : line_end_pos);

		// Add small overhead rectangle at the end of selected lines
		if (_select_end.line > line_no)
			selection_end += char_advance.x;

		// Draw selected area
		if (selection_beg != -1 && selection_end != -1 && selection_beg < selection_end)
		{
			const ImVec2 beg = ImVec2(text_screen_pos.x + selection_beg, text_screen_pos.y);
			const ImVec2 end = ImVec2(text_screen_pos.x + selection_end, text_screen_pos.y + char_advance.y);

			draw_list->AddRectFilled(beg, end, palette[color_selection]);
		}

		// Find any highlighted words and draw a selection rectangle below them
		if (!_highlighted.empty())
		{
			size_t begin_column = 0;
			size_t highlight_index = 0;

			for (size_t i = 0; i < line.size(); ++i)
			{
				if (line[i].c == _highlighted[highlight_index] && line[i].col == color_identifier)
				{
					if (highlight_index == 0)
						begin_column = i;

					++highlight_index;

					if (highlight_index == _highlighted.size())
					{
						if ((begin_column == 0 || line[begin_column - 1].col != color_identifier) && (i + 1 == line.size() || line[i + 1].col != color_identifier)) // Make sure this is a whole word and not just part of one
						{
							// We found a matching text block
							const ImVec2 beg = ImVec2(text_screen_pos.x + calc_text_distance_to_line_begin(text_pos(line_no, begin_column)), text_screen_pos.y);
							const ImVec2 end = ImVec2(text_screen_pos.x + calc_text_distance_to_line_begin(text_pos(line_no, i + 1)), text_screen_pos.y + char_advance.y);

							draw_list->AddRectFilled(beg, end, palette[color_selection]);
						}
					}
					else
					{
						// Continue search
						continue;
					}
				}

				// Current text no longer matches, reset search
				highlight_index = 0;
			}
		}

		// Draw error markers
		if (auto it = _errors.find(line_no + 1); it != _errors.end())
		{
			const ImVec2 beg = ImVec2(line_screen_pos.x + ImGui::GetScrollX(), line_screen_pos.y);
			const ImVec2 end = ImVec2(line_screen_pos.x + ImGui::GetWindowContentRegionMax().x + 2.0f * ImGui::GetScrollX(), line_screen_pos.y + char_advance.y);

			draw_list->AddRectFilled(beg, end, palette[it->second.second ? color_warning_marker : color_error_marker]);

			if (ImGui::IsMouseHoveringRect(beg, end))
			{
				ImGui::BeginTooltip();
				ImGui::Text(""%s"", it->second.first.c_str());
				ImGui::EndTooltip();
			}
		}

		// Highlight the current line (where the cursor is)
		if (_cursor_pos.line == line_no)
		{
			const bool is_focused = ImGui::IsWindowFocused();

			if (!has_selection())
			{
				const ImVec2 beg = ImVec2(line_screen_pos.x + ImGui::GetScrollX(), line_screen_pos.y);
				const ImVec2 end = ImVec2(line_screen_pos.x + ImGui::GetWindowContentRegionMax().x + 2.0f * ImGui::GetScrollX(), line_screen_pos.y + char_advance.y);

				draw_list->AddRectFilled(beg, end, palette[is_focused ? color_current_line_fill : color_current_line_fill_inactive]);
				draw_list->AddRect(beg, end, palette[color_current_line_edge], 1.0f);
			}

			// Draw the cursor animation
			if (is_focused && io.ConfigInputTextCursorBlink && fmodf(_cursor_anim, 1.0f) <= 0.5f)
			{
				const float cx = calc_text_distance_to_line_begin(_cursor_pos);

				const ImVec2 beg = ImVec2(text_screen_pos.x + cx, line_screen_pos.y);
				const ImVec2 end = ImVec2(text_screen_pos.x + cx + (_overwrite ? char_advance.x : 1.0f), line_screen_pos.y + char_advance.y); // Larger cursor while overwriting

				draw_list->AddRectFilled(beg, end, palette[color_cursor]);
			}
		}

		// Draw line number (right aligned)
		snprintf(buf, 16, ""%zu  "", line_no + 1);

		draw_list->AddText(ImVec2(text_screen_pos.x - ImGui::CalcTextSize(buf).x, line_screen_pos.y), palette[color_line_number], buf);

		// Nothing to draw if the line is empty, so continue on
		if (line.empty())
			continue;

		// Draw colorized line text
		auto text_offset = 0.0f;
		auto current_color = line[0].col;

		// Fill temporary buffer with glyph characters and commit it every time the color changes or a tab character is encountered
		for (const glyph &glyph : line)
		{
			if (buf != buf_end && (glyph.col != current_color || glyph.c == '\\t' || buf_end - buf >= sizeof(buf)))
			{
				draw_list->AddText(ImVec2(text_screen_pos.x + text_offset, text_screen_pos.y), palette[current_color], buf, buf_end);

				text_offset += calc_text_size(buf, buf_end).x; buf_end = buf; // Reset temporary buffer
			}

			if (glyph.c != '\\t')
				*buf_end++ = glyph.c;
			else
				text_offset += _tab_size * space_size;

			current_color = glyph.col;
		}

		// Draw any text still in the temporary buffer that was not yet committed
		if (buf != buf_end)
			draw_list->AddText(ImVec2(text_screen_pos.x + text_offset, text_screen_pos.y), palette[current_color], buf, buf_end);
	}

	// Create dummy widget so a horizontal scrollbar appears
	ImGui::Dummy(ImVec2(text_start + longest_line, _lines.size() * char_advance.y));

	if (_scroll_to_cursor)
	{
		const float len = calc_text_distance_to_line_begin(_cursor_pos);
		const float extra_space = 8.0f;

		const float max_scroll_width = ImGui::GetWindowWidth() - 16.0f;
		const float max_scroll_height = ImGui::GetWindowHeight() - 32.0f;

		if (_cursor_pos.line < (ImGui::GetScrollY()) / char_advance.y) // No additional space when scrolling up
			ImGui::SetScrollY(std::max(0.0f, _cursor_pos.line * char_advance.y));
		if (_cursor_pos.line > (ImGui::GetScrollY() + max_scroll_height - extra_space) / char_advance.y)
			ImGui::SetScrollY(std::max(0.0f, _cursor_pos.line * char_advance.y + extra_space - max_scroll_height));

		if (len + text_start < (ImGui::GetScrollX() + extra_space))
			ImGui::SetScrollX(std::max(0.0f, len + text_start - extra_space));
		if (len + text_start > (ImGui::GetScrollX() + max_scroll_width - extra_space))
			ImGui::SetScrollX(std::max(0.0f, len + text_start + extra_space - max_scroll_width));

		if (!_search_window_open) // Focus on search text box instead of the editor window
			ImGui::SetWindowFocus();

		_scroll_to_cursor = false;
	}

	ImGui::PopAllowKeyboardFocus();
	ImGui::EndChild();

	ImGui::PopStyleVar();
	ImGui::PopStyleColor();
	ImGui::PopFont();

	if (ctrl && !shift && !alt && (ImGui::IsKeyPressed('F') || ImGui::IsKeyPressed('H')))
	{
		// Copy currently selected text into search box
		if (_select_beg != _select_end)
			_search_text[get_selected_text().copy(_search_text, sizeof(_search_text) - 1)] = '\\0';

		_search_window_open = ImGui::IsKeyPressed('H') ? 2 /* search + replace */ : 1 /* search */;
		_search_window_focus = 2; // Need to focus multiple frames (see https://github.com/ocornut/imgui/issues/343)
	}

	if (_search_window_open)
	{
		ImGui::Dummy(ImVec2(0, ImGui::GetStyle().ItemSpacing.y));
		ImGui::BeginChild(""##search"", ImVec2(0, 0));

		const float input_width = ImGui::GetContentRegionAvail().x - (4 * button_spacing) - (4 * button_size) - 5;
		ImGui::PushItemWidth(input_width);
		if (ImGui::InputText(""##search"", _search_text, sizeof(_search_text), ImGuiInputTextFlags_AutoSelectAll | ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_AllowTabInput))
		{
			_search_window_focus = 1; // Focus text box again after entering a value
			find_and_scroll_to_text(_search_text);
		}
		ImGui::PopItemWidth();

		if (_search_window_focus != 0 && _search_window_focus < 3)
		{
			_search_window_focus -= 1;
			ImGui::SetKeyboardFocusHere(-1);
		}

		ImGui::SameLine(0.0f, button_spacing);
		ImGui::PushStyleColor(ImGuiCol_Button, ImGui::GetStyle().Colors[_search_case_sensitive ? ImGuiCol_ButtonActive : ImGuiCol_Button]);
		if (ImGui::Button(""Aa"", ImVec2(button_size + 5, 0)) || (!ctrl && !shift && alt && ImGui::IsKeyPressed('C')))
			_search_case_sensitive = !_search_case_sensitive;
		ImGui::PopStyleColor();
		if (ImGui::IsItemHovered())
			ImGui::SetTooltip(""Match case (Alt + C)"");

		ImGui::SameLine(0.0f, button_spacing);
		if (ImGui::Button(""<"", ImVec2(button_size, 0)) || (shift && ImGui::IsKeyPressed(0x72))) // VK_F3
			find_and_scroll_to_text(_search_text, true);
		if (ImGui::IsItemHovered())
			ImGui::SetTooltip(""Find previous (Shift + F3)"");

		ImGui::SameLine(0.0f, button_spacing);
		if (ImGui::Button("">"", ImVec2(button_size, 0)) || (!shift && ImGui::IsKeyPressed(0x72)))
			find_and_scroll_to_text(_search_text, false);
		if (ImGui::IsItemHovered())
			ImGui::SetTooltip(""Find next (F3)"");

		ImGui::SameLine(0.0f, button_spacing);
		if (ImGui::Button(""X"", ImVec2(button_size, 0)) || ImGui::IsKeyPressedMap(ImGuiKey_Escape))
		{
			_search_window_open = _search_window_focus = 0;
			// Move focus back to text editor again next frame
			ImGui::SetWindowFocus(editor_window_name);
		}
		if (ImGui::IsItemHovered())
			ImGui::SetTooltip(""Close (Escape)"");

		if (_search_window_open != 1)
		{
			ImGui::PushItemWidth(input_width);
			if (ImGui::InputText(""##replace"", _replace_text, sizeof(_replace_text), ImGuiInputTextFlags_AutoSelectAll | ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_AllowTabInput))
			{
				_search_window_focus = 3; // Focus replace text box again after entering a value
				if (find_and_scroll_to_text(_search_text, false, true))
					insert_text(_replace_text);
			}
			ImGui::PopItemWidth();

			if (_search_window_focus == 3)
			{
				_search_window_focus  = 0;
				ImGui::SetKeyboardFocusHere(-1);
			}

			ImGui::SameLine(0.0f, button_spacing * 2 + button_size + 5);
			if (ImGui::Button(""Repl"", ImVec2(2 * button_size + button_spacing, 0)) || (!ctrl && !shift && alt && ImGui::IsKeyPressed('R')))
				if (find_and_scroll_to_text(_search_text, false, true))
					insert_text(_replace_text);
			if (ImGui::IsItemHovered())
				ImGui::SetTooltip(""Replace next (Alt + R)"");

			ImGui::SameLine(0.0f, button_spacing);
			if (ImGui::Button(""A"", ImVec2(button_size, 0)) || (!ctrl && !shift && alt && ImGui::IsKeyPressed('A')))
			{
				// Reset select position so that replace stats at document begin
				_select_beg = text_pos();
				while (find_and_scroll_to_text(_search_text, false, true))
					insert_text(_replace_text);
			}
			if (ImGui::IsItemHovered())
				ImGui::SetTooltip(""Replace all (Alt + A)"");
		}

		ImGui::EndChild();
	}
}

void reshade::imgui::code_editor::select(const text_pos &beg, const text_pos &end, selection_mode mode)
{
	assert(beg.line < _lines.size());
	assert(end.line < _lines.size());
	assert(beg.column <= _lines[beg.line].size()); // The last column is after the last character in the line
	assert(end.column <= _lines[end.line].size());

	if (end > beg)
		_select_beg = beg,
		_select_end = end;
	else
		_select_end = beg,
		_select_beg = end;

	const auto select_word = [this](text_pos &beg, text_pos &end) {
		const auto &beg_line = _lines[beg.line];
		const auto &end_line = _lines[end.line];
		// Empty lines cannot have any words, so abort
		if (beg_line.empty() || end_line.empty())
			return;
		// Whitespace has a special meaning in that if we select the space next to a word, then that word is precedence over the whitespace
		if (beg.column == beg_line.size() || (beg.column > 0 && beg_line[beg.column].col == color_default))
			beg.column--;
		if (end.column == end_line.size() || (end.column > 0 && end_line[end.column].col == color_default))
			end.column--;
		// Search from the first position backwards until a character with a different color is found
		for (auto word_color = beg_line[beg.column].col;
			beg.column > 0 && beg_line[beg.column - 1].col == word_color;
			--beg.column) continue;
		// Search from the selection end position forwards until a character with a different color is found
		for (auto word_color = end_line[end.column].col;
			end.column < end_line.size() && end_line[end.column].col == word_color;
			++end.column) continue;
	};

	// Reset cursor animation (so it is always visible when clicking something)
	_cursor_anim = 0;

	// Find the identifier under the cursor position
	text_pos highlight_beg = _select_beg;
	text_pos highlight_end = _select_end;
	select_word(highlight_beg, highlight_end);
	_highlighted = _lines[highlight_beg.line].size() > highlight_beg.column && _lines[highlight_beg.line][highlight_beg.column].col == color_identifier ?
		get_text(highlight_beg, highlight_end) : std::string();

	switch (mode)
	{
	case selection_mode::word:
		select_word(_select_beg, _select_end);
		break;
	case selection_mode::line:
		_select_beg.column = 0;
		_select_end.column = _lines[end.line].size();
		break;
	}
}
void reshade::imgui::code_editor::select_all()
{
	if (_lines.empty())
		return; // Cannot select anything if no text is set

	// Move cursor to end of text
	_cursor_pos = text_pos(_lines.size() - 1, _lines.back().size());

	// Update selection to contain everything
	_interactive_beg = text_pos(0, 0);
	_interactive_end = _cursor_pos;

	select(_interactive_beg, _interactive_end);
}

void reshade::imgui::code_editor::set_text(const std::string &text)
{
	_lines.clear();
	_lines.emplace_back();

	_undo.clear();
	_undo_index = 0;
	_undo_base_index = 0;
	_errors.clear();

	for (char c : text)
	{
		if (c == '\\r')
			continue; // Ignore the carriage return character
		else if (c == '\\n')
			_lines.emplace_back();
		else
			_lines.back().push_back({ c, color_default });
	}

	// Restrict cursor position to new text bounds
	_select_beg = _select_end = text_pos();
	_interactive_beg = _interactive_end = text_pos();
	_cursor_pos = std::min(_cursor_pos, text_pos(_lines.size() - 1, _lines.back().size()));

	_colorize_line_beg = 0;
	_colorize_line_end = _lines.size();
}
void reshade::imgui::code_editor::clear_text()
{
	set_text(std::string());
}
void reshade::imgui::code_editor::insert_text(const std::string &text)
{
	// Insert all characters of the text
	for (const char c : text)
		insert_character(c, false);

	// Move cursor to end of inserted text
	select(_cursor_pos, _cursor_pos);
}
void reshade::imgui::code_editor::insert_character(char c, bool auto_indent)
{
	if (_readonly)
		return;

	undo_record u;

	if (has_selection())
	{
		if (c == '\\t' && auto_indent) // Pressing tab with a selection indents the entire selection
		{
			auto &beg = _select_beg;
			auto &end = _select_end;

			_colorize_line_beg = std::min(_colorize_line_beg, beg.line - std::min<size_t>(beg.line, 10));
			_colorize_line_end = std::max(_colorize_line_end, end.line + 10 + 1);

			beg.column = 0;
			if (end.column == 0 && end.line > 0)
				end.column = _lines[--end.line].size();

			u.removed = get_text(beg, end);
			u.removed_beg = beg;
			u.removed_end = end;

			for (size_t i = beg.line; i <= end.line; i++)
			{
				auto &line = _lines[i];

				if (ImGui::GetIO().KeyShift)
				{
					if (line.empty())
						continue; // Line is already empty, so there is no indentation to remove

					if (line[0].c == '\\t')
					{
						line.erase(line.begin());
						if (i == end.line && end.column > 0)
							end.column--;
						if (i == _cursor_pos.line && _cursor_pos.column > 0)
							_cursor_pos.column--;
					}
					else for (size_t j = 0; j < _tab_size && !line.empty() && line[0].c == ' '; j++) // Do the same for spaces
					{
						line.erase(line.begin());
						if (i == end.line && end.column > 0)
							end.column--;
						if (i == _cursor_pos.line && _cursor_pos.column > 0)
							_cursor_pos.column--;
					}
				}
				else
				{
					line.insert(line.begin(), { '\\t', color_background });
					if (i == end.line)
						end.column++;
					if (i == _cursor_pos.line)
						_cursor_pos.column++;
				}
			}

			u.added = get_text(beg, end);
			u.added_beg = beg;
			u.added_end = end;
			record_undo(std::move(u));
			return;
		}

		// Otherwise overwrite the selection
		delete_selection();
	}
	else
	{
		if (c == '\\t' && auto_indent && ImGui::GetIO().KeyShift)
		{
			auto &line = _lines[_cursor_pos.line];

			if (line.empty())
				return; // Line is already empty, so there is no indentation to remove

			u.removed_beg = text_pos(_cursor_pos.line, 0);
			u.removed_end = u.removed_beg;

			if (line[0].c == '\\t')
			{
				u.removed += line[0].c;
				u.removed_end.column++;
				line.erase(line.begin());
				if (_cursor_pos.column > 0)
					_cursor_pos.column--;
			}
			else for (size_t j = 0; j < _tab_size && !line.empty() && line[0].c == ' '; j++) // Do the same for spaces
			{
				u.removed += line[0].c;
				u.removed_end.column++;
				line.erase(line.begin());
				if (_cursor_pos.column > 0)
					_cursor_pos.column--;
			}

			record_undo(std::move(u));
			return;
		}
	}

	assert(!_lines.empty());

	u.added = c;
	u.added_beg = _cursor_pos;

	// Colorize additional 10 lines above and below to better catch multi-line constructs
	_colorize_line_beg = std::min(_colorize_line_beg, _cursor_pos.line - std::min<size_t>(_cursor_pos.line, 10));

	// New line feed requires insertion of a new line
	if (c == '\\n')
	{
		// Move all error markers after the new line one up
		std::unordered_map<size_t, std::pair<std::string, bool>> errors;
		errors.reserve(_errors.size());
		for (auto &i : _errors)
			errors.insert({ i.first >= _cursor_pos.line + 1 ? i.first + 1 : i.first, i.second });
		_errors = std::move(errors);

		auto &new_line = *_lines.emplace(_lines.begin() + _cursor_pos.line + 1);
		auto &line = _lines[_cursor_pos.line];

		// Auto indentation
		if (auto_indent && _cursor_pos.column == line.size())
			for (size_t i = 0; i < line.size() && isblank(line[i].c); ++i)
				new_line.push_back(line[i]), u.added.push_back(line[i].c);
		const size_t indentation = new_line.size();

		new_line.insert(new_line.end(), line.begin() + _cursor_pos.column, line.end());
		line.erase(line.begin() + _cursor_pos.column, line.begin() + line.size());

		_cursor_pos.line++;
		_cursor_pos.column = indentation;
	}
	else if (c != '\\r') // Ignore carriage return
	{
		auto &line = _lines[_cursor_pos.line];

		if (_overwrite && _cursor_pos.column < line.size())
			line[_cursor_pos.column] = { c, color_default };
		else
			line.insert(line.begin() + _cursor_pos.column, { c, color_default });

		_cursor_pos.column++;
	}

	u.added_end = _cursor_pos;
	record_undo(std::move(u));

	// Reset cursor animation
	_cursor_anim = 0;

	_scroll_to_cursor = true;

	_colorize_line_end = std::max(_colorize_line_end, _cursor_pos.line + 10 + 1);
}

std::string reshade::imgui::code_editor::get_text() const
{
	return get_text(0, _lines.size());
}
std::string reshade::imgui::code_editor::get_text(const text_pos &beg, const text_pos &end) const
{
	// Calculate length of text to pre-allocate memory before building the string
	size_t length = 0;
	for (auto it = beg; it < end; it.line++)
		length += _lines[it.line].size() + 1;

	std::string result;
	result.reserve(length);

	for (auto it = beg; it < end;)
	{
		const auto &line = _lines[it.line];

		if (it.column < line.size())
		{
			result.push_back(line[it.column].c);

			it.column++;
		}
		else
		{
			it.line++;
			it.column = 0;

			if (it.line < _lines.size())
				// Reached end of line, so append a new line feed
				result.push_back('\\n');
		}
	}

	return result;
}
std::string reshade::imgui::code_editor::get_selected_text() const
{
	assert(has_selection());

	return get_text(_select_beg, _select_end);
}

void reshade::imgui::code_editor::undo(unsigned int steps)
{
	if (_readonly)
		return;

	// Reset selection
	_select_beg = _select_end = _cursor_pos;
	_interactive_beg = _interactive_end = _cursor_pos;

	_in_undo_operation = true;

	while (can_undo() && steps-- > 0)
	{
		const undo_record &record = _undo[--_undo_index];

		if (!record.added.empty())
		{
			_cursor_pos = record.added_beg;
			select(record.added_beg, record.added_end);
			delete_selection();
		}
		if (!record.removed.empty())
		{
			_cursor_pos = record.removed_beg;
			insert_text(record.removed);
		}
	}

	_scroll_to_cursor = true;
	_in_undo_operation = false;
}
void reshade::imgui::code_editor::redo(unsigned int steps)
{
	if (_readonly)
		return;

	// Reset selection
	_select_beg = _select_end = _cursor_pos;
	_interactive_beg = _interactive_end = _cursor_pos;

	_in_undo_operation = true;

	while (can_redo() && steps-- > 0)
	{
		const undo_record &record = _undo[_undo_index++];

		if (!record.removed.empty())
		{
			_cursor_pos = record.removed_beg;
			select(record.removed_beg, record.removed_end);
			delete_selection();
		}
		if (!record.added.empty())
		{
			_cursor_pos = record.added_beg;
			insert_text(record.added);
		}
	}

	_scroll_to_cursor = true;
	_in_undo_operation = false;
}

void reshade::imgui::code_editor::record_undo(undo_record &&record)
{
	if (_in_undo_operation)
		return;

	_undo.resize(_undo_index); // Remove all undo records after the current one
	_undo.push_back(std::move(record)); // Append new record to the list
	_undo_index++;
}

void reshade::imgui::code_editor::delete_next()
{
	if (_readonly)
		return;

	if (has_selection())
	{
		delete_selection();
		return;
	}

	assert(!_lines.empty());

	auto &line = _lines[_cursor_pos.line];

	undo_record u;
	u.removed_beg = _cursor_pos;
	u.removed_end = _cursor_pos;

	// If at end of line, move next line into the current one
	if (_cursor_pos.column == line.size())
	{
		if (_cursor_pos.line == _lines.size() - 1)
			return; // This already is the last line

		const auto &next_line = _lines[_cursor_pos.line + 1];

		u.removed = '\\n';
		u.removed_end.line++;
		u.removed_end.column = 0;

		// Copy next line into current line
		line.insert(line.end(), next_line.begin(), next_line.end());

		// Remove the line
		delete_lines(_cursor_pos.line + 1, _cursor_pos.line + 1);
	}
	else
	{
		u.removed = line[_cursor_pos.column].c;
		u.removed_end.column++;

		// Otherwise just remove the character at the cursor position
		line.erase(line.begin() + _cursor_pos.column);
	}

	record_undo(std::move(u));

	_colorize_line_beg = std::min(_colorize_line_beg, _cursor_pos.line - std::min<size_t>(_cursor_pos.line, 10));
	_colorize_line_end = std::max(_colorize_line_end, _cursor_pos.line + 10 + 1);
}
void reshade::imgui::code_editor::delete_previous()
{
	if (_readonly)
		return;

	if (has_selection())
	{
		delete_selection();
		return;
	}

	assert(!_lines.empty());

	auto &line = _lines[_cursor_pos.line];

	undo_record u;
	u.removed_end = _cursor_pos;

	// If at beginning of line, move previous line into the current one
	if (_cursor_pos.column == 0)
	{
		if (_cursor_pos.line == 0)
			return; // This already is the first line

		auto &prev_line = _lines[_cursor_pos.line - 1];
		_cursor_pos.line--;
		_cursor_pos.column = prev_line.size();

		u.removed = '\\n';

		// Copy current line into previous line
		prev_line.insert(prev_line.end(), line.begin(), line.end());

		// Remove the line
		delete_lines(_cursor_pos.line + 1, _cursor_pos.line + 1);
	}
	else
	{
		_cursor_pos.column--;

		u.removed = line[_cursor_pos.column].c;

		// Otherwise remove the character next to the cursor position
		line.erase(line.begin() + _cursor_pos.column);
	}

	u.removed_beg = _cursor_pos;
	record_undo(std::move(u));

	_scroll_to_cursor = true;

	_colorize_line_beg = std::min(_colorize_line_beg, _cursor_pos.line - std::min<size_t>(_cursor_pos.line, 10));
	_colorize_line_end = std::max(_colorize_line_end, _cursor_pos.line + 10 + 1);
}
void reshade::imgui::code_editor::delete_selection()
{
	if (_readonly)
		return;

	if (!has_selection())
		return;

	assert(!_lines.empty());

	undo_record u;
	u.removed = get_selected_text();
	u.removed_beg = _select_beg;
	u.removed_end = _select_end;
	record_undo(std::move(u));

	if (_select_beg.line == _select_end.line)
	{
		auto &line = _lines[_select_beg.line];

		if (_select_end.column >= line.size())
			line.erase(line.begin() + _select_beg.column, line.end());
		else
			line.erase(line.begin() + _select_beg.column, line.begin() + _select_end.column);
	}
	else
	{
		auto &beg_line = _lines[_select_beg.line];
		auto &end_line = _lines[_select_end.line];

		beg_line.erase(beg_line.begin() + _select_beg.column, beg_line.end());
		end_line.erase(end_line.begin(), end_line.begin() + _select_end.column);

		if (_select_beg.line < _select_end.line)
		{
			beg_line.insert(beg_line.end(), end_line.begin(), end_line.end());

			delete_lines(_select_beg.line + 1, _select_end.line);
		}

		assert(!_lines.empty());
	}

	_colorize_line_beg = std::min(_colorize_line_beg, _select_beg.line - std::min<size_t>(_cursor_pos.line, 10));
	_colorize_line_end = std::max(_colorize_line_end, _select_end.line + 10 + 1);

	// Reset selection
	_cursor_pos = _select_beg;
	select(_cursor_pos, _cursor_pos);
}
void reshade::imgui::code_editor::delete_lines(size_t first_line, size_t last_line)
{
	if (_readonly)
		return;

	// Move all error markers after the deleted lines down
	std::unordered_map<size_t, std::pair<std::string, bool>> errors;
	errors.reserve(_errors.size());
	for (auto &i : _errors)
		if (i.first < first_line && i.first > last_line)
			errors.insert({ i.first > last_line ? i.first - (last_line - first_line) : i.first, i.second });
	_errors = std::move(errors);

	_lines.erase(_lines.begin() + first_line, _lines.begin() + last_line + 1);
}

void reshade::imgui::code_editor::clipboard_copy()
{
	_last_copy_string.clear();
	_last_copy_from_empty_selection = false;

	if (has_selection())
	{
		ImGui::SetClipboardText(get_selected_text().c_str());
	}
	else if (!_lines.empty()) // Copy current line if there is no selection
	{
		std::string line_text;
		line_text.reserve(_lines[_cursor_pos.line].size());
		for (const glyph &glyph : _lines[_cursor_pos.line])
			line_text.push_back(glyph.c);
		// Include new line character
		line_text += '\\n';

		_last_copy_string = line_text;
		_last_copy_from_empty_selection = true;

		ImGui::SetClipboardText(line_text.c_str());
	}
}
void reshade::imgui::code_editor::clipboard_cut()
{
	if (!has_selection())
		return;

	clipboard_copy();
	delete_selection();
}
void reshade::imgui::code_editor::clipboard_paste()
{
	if (_readonly)
		return;

	const char *const text = ImGui::GetClipboardText();

	if (text == nullptr || *text == '\\0')
		return;

	undo_record u;

	_in_undo_operation = true;

	bool reset_cursor_pos = false;
	const size_t cursor_column = _cursor_pos.column;
	if (has_selection())
	{
		u.removed = get_selected_text();
		u.removed_beg = _select_beg;
		u.removed_end = _select_end;

		delete_selection();
	}
	else if (_last_copy_from_empty_selection && _last_copy_string == text)
	{
		reset_cursor_pos = true;
		// Paste line above current line if there is no selection and entire line was copied to clipboard without a selection too
		_cursor_pos.column = 0;
	}

	u.added = text;
	u.added_beg = _cursor_pos;

	insert_text(u.added);

	u.added_end = _cursor_pos;

	_in_undo_operation = false;

	record_undo(std::move(u));

	// Reset cursor position after pasting entire line above
	if (reset_cursor_pos)
		_cursor_pos.column = cursor_column;
}

void reshade::imgui::code_editor::move_up(size_t amount, bool selection)
{
	assert(!_lines.empty());

	const auto prev_pos = _cursor_pos;
	_cursor_pos.line = std::max<intptr_t>(0, _cursor_pos.line - amount);

	// The line before could be shorter, so adjust column
	_cursor_pos.column = std::min<intptr_t>(_cursor_pos.column, _lines[_cursor_pos.line].size());

	if (prev_pos == _cursor_pos)
		return;

	if (selection)
	{
		if (prev_pos == _interactive_beg)
			_interactive_beg = _cursor_pos;
		else if (prev_pos == _interactive_end)
			_interactive_end = _cursor_pos;
		else
			_interactive_beg = _cursor_pos,
			_interactive_end = prev_pos;
	}
	else
	{
		_interactive_beg = _cursor_pos;
		_interactive_end = _cursor_pos;
	}

	select(_interactive_beg, _interactive_end);
	_scroll_to_cursor = true;
}
void reshade::imgui::code_editor::move_down(size_t amount, bool selection)
{
	assert(!_lines.empty());

	const auto prev_pos = _cursor_pos;
	_cursor_pos.line = std::min<intptr_t>(_cursor_pos.line + amount, _lines.size() - 1);

	// The line after could be shorter, so adjust column
	_cursor_pos.column = std::min<intptr_t>(_cursor_pos.column, _lines[_cursor_pos.line].size());

	if (prev_pos == _cursor_pos)
		return;

	if (selection)
	{
		if (prev_pos == _interactive_beg)
			_interactive_beg = _cursor_pos;
		else if (prev_pos == _interactive_end)
			_interactive_end = _cursor_pos;
		else
			_interactive_beg = prev_pos,
			_interactive_end = _cursor_pos;
	}
	else
	{
		_interactive_beg = _cursor_pos;
		_interactive_end = _cursor_pos;
	}

	select(_interactive_beg, _interactive_end);
	_scroll_to_cursor = true;
}
void reshade::imgui::code_editor::move_left(size_t amount, bool selection, bool word_mode)
{
	assert(!_lines.empty());

	const auto prev_pos = _cursor_pos;

	// Move cursor to selection start when moving left and no longer selecting
	if (!selection && _interactive_beg != _interactive_end)
	{
		_cursor_pos = _interactive_beg;
		_interactive_end = _cursor_pos;
	}
	else
	{
		while (amount-- > 0)
		{
			if (_cursor_pos.column == 0) // At the beginning of the current line, so move on to previous
			{
				if (_cursor_pos.line == 0)
					break;

				_cursor_pos.line--;
				_cursor_pos.column = _lines[_cursor_pos.line].size();
			}
			else if (word_mode)
			{
				for (const auto word_color = _lines[_cursor_pos.line][_cursor_pos.column - 1].col; _cursor_pos.column > 0; --_cursor_pos.column)
					if (_lines[_cursor_pos.line][_cursor_pos.column - 1].col != word_color)
						break;
			}
			else
			{
				_cursor_pos.column--;
			}
		}

		if (selection)
		{
			if (prev_pos == _interactive_beg)
				_interactive_beg = _cursor_pos;
			else if (prev_pos == _interactive_end)
				_interactive_end = _cursor_pos;
			else
				_interactive_beg = _cursor_pos,
				_interactive_end = prev_pos;
		}
		else
		{
			_interactive_beg = _cursor_pos;
			_interactive_end = _cursor_pos;
		}
	}

	select(_interactive_beg, _interactive_end);
	_scroll_to_cursor = true;
}
void reshade::imgui::code_editor::move_right(size_t amount, bool selection, bool word_mode)
{
	assert(!_lines.empty());

	const auto prev_pos = _cursor_pos;

	while (amount-- > 0)
	{
		auto &line = _lines[_cursor_pos.line];

		if (_cursor_pos.column >= line.size()) // At the end of the current line, so move on to next
		{
			if (_cursor_pos.line >= _lines.size() - 1)
				break; // Reached end of input

			_cursor_pos.line++;
			_cursor_pos.column = 0;
		}
		else if (word_mode)
		{
			for (const auto word_color = _lines[_cursor_pos.line][_cursor_pos.column].col; _cursor_pos.column < _lines[_cursor_pos.line].size(); ++_cursor_pos.column)
				if (_lines[_cursor_pos.line][_cursor_pos.column].col != word_color)
					break;
		}
		else
		{
			_cursor_pos.column++;
		}
	}

	if (selection)
	{
		if (prev_pos == _interactive_end)
			_interactive_end = _cursor_pos;
		else if (prev_pos == _interactive_beg)
			_interactive_beg = _cursor_pos;
		else
			_interactive_beg = prev_pos,
			_interactive_end = _cursor_pos;
	}
	else
	{
		_interactive_beg = _interactive_end = _cursor_pos;
	}

	select(_interactive_beg, _interactive_end);
	_scroll_to_cursor = true;
}
void reshade::imgui::code_editor::move_top(bool selection)
{
	assert(!_lines.empty());

	const auto prev_pos = _cursor_pos;
	_cursor_pos = text_pos(0, 0);

	if (prev_pos == _cursor_pos)
		return;

	if (selection)
	{
		// This logic ensures the selection is updated depending on which direction it was created in (mimics behavior of popular text editors)
		if (_interactive_beg > _interactive_end)
			std::swap(_interactive_beg, _interactive_end);
		if (prev_pos != _interactive_beg)
			_interactive_end = _interactive_beg;

		_interactive_beg = _cursor_pos;
	}
	else
	{
		_interactive_beg = _cursor_pos;
		_interactive_end = _cursor_pos;
	}

	select(_interactive_beg, _interactive_end);
	_scroll_to_cursor = true;
}
void reshade::imgui::code_editor::move_bottom(bool selection)
{
	assert(!_lines.empty());

	const auto prev_pos = _cursor_pos;
	_cursor_pos = text_pos(_lines.size() - 1, 0);

	if (prev_pos == _cursor_pos)
		return;

	if (selection)
	{
		if (_interactive_beg > _interactive_end)
			std::swap(_interactive_beg, _interactive_end);
		if (prev_pos != _interactive_end)
			_interactive_beg = _interactive_end;

		_interactive_end = _cursor_pos;
	}
	else
	{
		_interactive_beg = _cursor_pos;
		_interactive_end = _cursor_pos;
	}

	select(_interactive_beg, _interactive_end);
	_scroll_to_cursor = true;
}
void reshade::imgui::code_editor::move_home(bool selection)
{
	assert(!_lines.empty());

	const auto prev_pos = _cursor_pos;
	_cursor_pos.column = 0;

	if (prev_pos == _cursor_pos &&
		_interactive_beg == _interactive_end) // This ensures that deselection works even when cursor is already at begin
		return;

	if (selection)
	{
		if (prev_pos == _interactive_beg)
			_interactive_beg = _cursor_pos;
		else if (prev_pos == _interactive_end)
			_interactive_end = _cursor_pos;
		else
			_interactive_beg = _cursor_pos,
			_interactive_end = prev_pos;
	}
	else
	{
		_interactive_beg = _interactive_end = _cursor_pos;
	}

	select(_interactive_beg, _interactive_end);
	_scroll_to_cursor = true;
}
void reshade::imgui::code_editor::move_end(bool selection)
{
	assert(!_lines.empty());

	const auto prev_pos = _cursor_pos;
	_cursor_pos.column = _lines[_cursor_pos.line].size();

	if (prev_pos == _cursor_pos &&
		_interactive_beg == _interactive_end) // This ensures that deselection works even when cursor is already at end
		return;

	if (selection)
	{
		if (prev_pos == _interactive_end)
			_interactive_end = _cursor_pos;
		else if (prev_pos == _interactive_beg)
			_interactive_beg = _cursor_pos;
		else
			_interactive_beg = prev_pos,
			_interactive_end = _cursor_pos;
	}
	else
	{
		_interactive_beg = _interactive_end = _cursor_pos;
	}

	select(_interactive_beg, _interactive_end);
	_scroll_to_cursor = true;
}
void reshade::imgui::code_editor::move_lines_up()
{
	if (_select_beg.line == 0 || _readonly)
		return;

	for (size_t line = _select_beg.line; line <= _select_end.line; ++line)
		std::swap(_lines[line], _lines[line - 1]);

	_select_beg.line--;
	_select_end.line--;
	_cursor_pos.line--;
}
void reshade::imgui::code_editor::move_lines_down()
{
	if (_select_end.line + 1 >= _lines.size() || _readonly)
		return;

	for (size_t line = _select_end.line; line >= _select_beg.line && line < _lines.size(); --line)
		std::swap(_lines[line], _lines[line + 1]);

	_select_beg.line++;
	_select_end.line++;
	_cursor_pos.line++;
}

bool reshade::imgui::code_editor::find_and_scroll_to_text(const std::string &text, bool backwards, bool with_selection)
{
	if (text.empty())
		return false; // Cannot search for empty text

	const auto compare_c = [this](char clhs, char crhs) {
		return _search_case_sensitive ? clhs == crhs : tolower(clhs) == tolower(crhs);
	};

	// Start search at the cursor position
	text_pos match_pos_beg, search_pos = backwards != with_selection ? _select_beg : _select_end;

	if (backwards)
	{
		// Start searching at the character before the current cursor position
		if (search_pos.column != 0)
		{
			search_pos.column -= 1;
		}
		else if (search_pos.line != 0)
		{
			search_pos.line -= 1;
			search_pos.column = _lines[search_pos.line].size();
		}

		const size_t match_last = text.size() - 1;
		size_t match_offset = match_last;

		while (true)
		{
			if (!_lines[search_pos.line].empty())
			{
				// Trim column index to the last character in the line (rather than the actual end)
				search_pos.column = std::min(search_pos.column, _lines[search_pos.line].size() - 1);

				while (true)
				{
					if (compare_c(_lines[search_pos.line][search_pos.column].c, text[match_offset]))
					{
						if (match_offset == match_last) // Keep track of end of the match
							match_pos_beg = search_pos;

						// All characters matching means the text was found, so select it and return
						if (match_offset == 0)
						{
							_select_beg = search_pos;
							_select_end = text_pos(match_pos_beg.line, match_pos_beg.column + 1);
							_cursor_pos = _select_beg;
							_scroll_to_cursor = true;
							return true;
						}
						else
						{
							match_offset--;
						}
					}
					else
					{
						// A character mismatched, so start from the end again
						match_offset = match_last;
					}

					if (search_pos.column == 0)
						break; // Reached the first column and cannot go further back, so break and go up the next line
					else
						search_pos.column -= 1;
				}
			}

			if (search_pos.line == 0)
				break; // Reached the first line and cannot go further back, so abort
			else
				search_pos.line -= 1;

			if (match_offset != match_last && text[match_offset--] != '\\n')
				match_offset  = match_last; // Check for line feed in search text between lines

			search_pos.column = _lines[search_pos.line].size(); // Continue at end of previous line
		}
	}
	else
	{
		size_t match_offset = 0;

		while (search_pos.line < _lines.size())
		{
			if (match_offset != 0 && text[match_offset++] != '\\n')
				match_offset  = 0; // Check for line feed in search text between lines

			while (search_pos.column < _lines[search_pos.line].size())
			{
				if (compare_c(_lines[search_pos.line][search_pos.column].c, text[match_offset]))
				{
					if (match_offset == 0) // Keep track of beginning of the match
						match_pos_beg = search_pos;

					match_offset++;

					// All characters matching means the text was found, so select it and return
					if (match_offset == text.size())
					{
						_select_beg = match_pos_beg;
						_select_end = text_pos(search_pos.line, search_pos.column + 1);
						_cursor_pos = _select_end;
						_scroll_to_cursor = true;
						return true;
					}
				}
				else
				{
					// A character mismatched, so start from the beginning again
					match_offset = 0;
				}

				search_pos.column += 1;
			}

			search_pos.line += 1;
			search_pos.column = 0;
		}
	}

	return false; // No match found
}

void reshade::imgui::code_editor::colorize()
{
	if (_colorize_line_beg >= _colorize_line_end)
		return;

	// Step through code incrementally rather than coloring everything at once
	const size_t from = _colorize_line_beg, to = std::min(from + 1000, _colorize_line_end);
	_colorize_line_beg = to;

	// Reset coloring range if we have finished coloring it after this iteration
	if (_colorize_line_end > _lines.size())
		_colorize_line_end = _lines.size();
	if (_colorize_line_beg == _colorize_line_end)
	{
		_colorize_line_beg = std::numeric_limits<size_t>::max();
		_colorize_line_end = 0;
	}

	// Copy lines into string for consumption by the lexer
	std::string input_string;
	for (size_t l = from; l < to && l < _lines.size(); ++l, input_string.push_back('\\n'))
		for (size_t k = 0; k < _lines[l].size(); ++k)
			input_string.push_back(_lines[l][k].c);

	reshadefx::lexer lexer(
		input_string,
		false /* ignore_comments */,
		true  /* ignore_whitespace */,
		false /* ignore_pp_directives */,
		true  /* ignore_line_directives */,
		false /* ignore_keywords */,
		false /* escape_string_literals */);

	for (reshadefx::token tok; (tok = lexer.lex()).id != reshadefx::tokenid::end_of_file;)
	{
		color col = color_default;

		switch (tok.id)
		{
		case reshadefx::tokenid::exclaim:
		case reshadefx::tokenid::percent:
		case reshadefx::tokenid::ampersand:
		case reshadefx::tokenid::parenthesis_open:
		case reshadefx::tokenid::parenthesis_close:
		case reshadefx::tokenid::star:
		case reshadefx::tokenid::plus:
		case reshadefx::tokenid::comma:
		case reshadefx::tokenid::minus:
		case reshadefx::tokenid::dot:
		case reshadefx::tokenid::slash:
		case reshadefx::tokenid::colon:
		case reshadefx::tokenid::semicolon:
		case reshadefx::tokenid::less:
		case reshadefx::tokenid::equal:
		case reshadefx::tokenid::greater:
		case reshadefx::tokenid::question:
		case reshadefx::tokenid::bracket_open:
		case reshadefx::tokenid::backslash:
		case reshadefx::tokenid::bracket_close:
		case reshadefx::tokenid::caret:
		case reshadefx::tokenid::brace_open:
		case reshadefx::tokenid::pipe:
		case reshadefx::tokenid::brace_close:
		case reshadefx::tokenid::tilde:
		case reshadefx::tokenid::exclaim_equal:
		case reshadefx::tokenid::percent_equal:
		case reshadefx::tokenid::ampersand_ampersand:
		case reshadefx::tokenid::ampersand_equal:
		case reshadefx::tokenid::star_equal:
		case reshadefx::tokenid::plus_plus:
		case reshadefx::tokenid::plus_equal:
		case reshadefx::tokenid::minus_minus:
		case reshadefx::tokenid::minus_equal:
		case reshadefx::tokenid::arrow:
		case reshadefx::tokenid::ellipsis:
		case reshadefx::tokenid::slash_equal:
		case reshadefx::tokenid::colon_colon:
		case reshadefx::tokenid::less_less_equal:
		case reshadefx::tokenid::less_less:
		case reshadefx::tokenid::less_equal:
		case reshadefx::tokenid::equal_equal:
		case reshadefx::tokenid::greater_greater_equal:
		case reshadefx::tokenid::greater_greater:
		case reshadefx::tokenid::greater_equal:
		case reshadefx::tokenid::caret_equal:
		case reshadefx::tokenid::pipe_equal:
		case reshadefx::tokenid::pipe_pipe:
			col = color_punctuation;
			break;
		case reshadefx::tokenid::identifier:
			col = color_identifier;
			break;
		case reshadefx::tokenid::int_literal:
		case reshadefx::tokenid::uint_literal:
		case reshadefx::tokenid::float_literal:
		case reshadefx::tokenid::double_literal:
			col = color_number_literal;
			break;
		case reshadefx::tokenid::string_literal:
			col = color_string_literal;
			break;
		case reshadefx::tokenid::true_literal:
		case reshadefx::tokenid::false_literal:
		case reshadefx::tokenid::namespace_:
		case reshadefx::tokenid::struct_:
		case reshadefx::tokenid::technique:
		case reshadefx::tokenid::pass:
		case reshadefx::tokenid::for_:
		case reshadefx::tokenid::while_:
		case reshadefx::tokenid::do_:
		case reshadefx::tokenid::if_:
		case reshadefx::tokenid::else_:
		case reshadefx::tokenid::switch_:
		case reshadefx::tokenid::case_:
		case reshadefx::tokenid::default_:
		case reshadefx::tokenid::break_:
		case reshadefx::tokenid::continue_:
		case reshadefx::tokenid::return_:
		case reshadefx::tokenid::discard_:
		case reshadefx::tokenid::extern_:
		case reshadefx::tokenid::static_:
		case reshadefx::tokenid::uniform_:
		case reshadefx::tokenid::volatile_:
		case reshadefx::tokenid::precise:
		case reshadefx::tokenid::groupshared:
		case reshadefx::tokenid::in:
		case reshadefx::tokenid::out:
		case reshadefx::tokenid::inout:
		case reshadefx::tokenid::const_:
		case reshadefx::tokenid::linear:
		case reshadefx::tokenid::noperspective:
		case reshadefx::tokenid::centroid:
		case reshadefx::tokenid::nointerpolation:
		case reshadefx::tokenid::void_:
		case reshadefx::tokenid::bool_:
		case reshadefx::tokenid::bool2:
		case reshadefx::tokenid::bool3:
		case reshadefx::tokenid::bool4:
		case reshadefx::tokenid::bool2x2:
		case reshadefx::tokenid::bool2x3:
		case reshadefx::tokenid::bool2x4:
		case reshadefx::tokenid::bool3x2:
		case reshadefx::tokenid::bool3x3:
		case reshadefx::tokenid::bool3x4:
		case reshadefx::tokenid::bool4x2:
		case reshadefx::tokenid::bool4x3:
		case reshadefx::tokenid::bool4x4:
		case reshadefx::tokenid::int_:
		case reshadefx::tokenid::int2:
		case reshadefx::tokenid::int3:
		case reshadefx::tokenid::int4:
		case reshadefx::tokenid::int2x2:
		case reshadefx::tokenid::int2x3:
		case reshadefx::tokenid::int2x4:
		case reshadefx::tokenid::int3x2:
		case reshadefx::tokenid::int3x3:
		case reshadefx::tokenid::int3x4:
		case reshadefx::tokenid::int4x2:
		case reshadefx::tokenid::int4x3:
		case reshadefx::tokenid::int4x4:
		case reshadefx::tokenid::min16int:
		case reshadefx::tokenid::min16int2:
		case reshadefx::tokenid::min16int3:
		case reshadefx::tokenid::min16int4:
		case reshadefx::tokenid::uint_:
		case reshadefx::tokenid::uint2:
		case reshadefx::tokenid::uint3:
		case reshadefx::tokenid::uint4:
		case reshadefx::tokenid::uint2x2:
		case reshadefx::tokenid::uint2x3:
		case reshadefx::tokenid::uint2x4:
		case reshadefx::tokenid::uint3x2:
		case reshadefx::tokenid::uint3x3:
		case reshadefx::tokenid::uint3x4:
		case reshadefx::tokenid::uint4x2:
		case reshadefx::tokenid::uint4x3:
		case reshadefx::tokenid::uint4x4:
		case reshadefx::tokenid::min16uint:
		case reshadefx::tokenid::min16uint2:
		case reshadefx::tokenid::min16uint3:
		case reshadefx::tokenid::min16uint4:
		case reshadefx::tokenid::float_:
		case reshadefx::tokenid::float2:
		case reshadefx::tokenid::float3:
		case reshadefx::tokenid::float4:
		case reshadefx::tokenid::float2x2:
		case reshadefx::tokenid::float2x3:
		case reshadefx::tokenid::float2x4:
		case reshadefx::tokenid::float3x2:
		case reshadefx::tokenid::float3x3:
		case reshadefx::tokenid::float3x4:
		case reshadefx::tokenid::float4x2:
		case reshadefx::tokenid::float4x3:
		case reshadefx::tokenid::float4x4:
		case reshadefx::tokenid::min16float:
		case reshadefx::tokenid::min16float2:
		case reshadefx::tokenid::min16float3:
		case reshadefx::tokenid::min16float4:
		case reshadefx::tokenid::vector:
		case reshadefx::tokenid::matrix:
		case reshadefx::tokenid::string_:
		case reshadefx::tokenid::texture:
		case reshadefx::tokenid::sampler:
		case reshadefx::tokenid::storage:
			col = color_keyword;
			break;
		case reshadefx::tokenid::hash_def:
		case reshadefx::tokenid::hash_undef:
		case reshadefx::tokenid::hash_if:
		case reshadefx::tokenid::hash_ifdef:
		case reshadefx::tokenid::hash_ifndef:
		case reshadefx::tokenid::hash_else:
		case reshadefx::tokenid::hash_elif:
		case reshadefx::tokenid::hash_endif:
		case reshadefx::tokenid::hash_error:
		case reshadefx::tokenid::hash_warning:
		case reshadefx::tokenid::hash_pragma:
		case reshadefx::tokenid::hash_include:
		case reshadefx::tokenid::hash_unknown:
			col = color_preprocessor;
			tok.offset--; // Add # to token
			tok.length++;
			break;
		case reshadefx::tokenid::single_line_comment:
			col = color_comment;
			break;
		case reshadefx::tokenid::multi_line_comment:
			col = color_multiline_comment;
			break;
		}

		// Update character range matching the current the token
		size_t line = from + tok.location.line - 1;
		size_t column = tok.location.column - 1;

		for (size_t k = 0; k < tok.length; ++k)
		{
			if (column >= _lines[line].size())
			{
				line++;
				column = 0;
				continue;
			}

			_lines[line][column++].col = col;
		}
	}
}
",16262,True,2737.429486391106,median
"[[verifying-dependencies]]
= Verifying dependencies

Working with external dependencies and plugins published on third-party repositories puts your build at risk.
In particular, you need to be aware of what binaries are brought in transitively and if they are legit.
To mitigate the security risks and avoid integrating compromised dependencies in your project, Gradle supports _dependency verification_.

[IMPORTANT]
====
Dependency verification is, by nature, an inconvenient feature to use.
It means that whenever you're going to update a dependency, builds are likely to fail.
It means that merging branches are going to be harder because each branch can have different dependencies.
It means that you will be tempted to switch it off.

So why should you bother?

Dependency verification is about **trust** in what you get and what you ship.

Without dependency verification it's easy for an attacker to compromise your supply chain.
There are many real world examples of tools compromised by adding a malicious dependency.
Dependency verification is meant to protect yourself from those attacks, by forcing you to ensure that the artifacts you include in your build are the ones that you expect.
It is not meant, however, to prevent you from including _vulnerable_ dependencies.

Finding the right balance between security and convenience is hard but Gradle will try to let you choose the ""right level"" for you.
====

Dependency verification consists of two different and complementary operations:

- _checksum verification_, which allows asserting the integrity of a dependency
- _signature verification_, which allows asserting the provenance of a dependency

Gradle supports both checksum and signature verification out of the box but performs no dependency verification by default.
This section will guide you into configuring dependency verification properly for your needs.

This feature can be used for:

- detecting compromised dependencies
- detecting compromised plugins
- detecting tampered dependencies in the local dependency caches

[[sub:enabling-verification]]
== Enabling dependency verification

[[sub:verification-metadata]]
=== The verification metadata file

[NOTE]
====
Currently the only source of dependency verification metadata is this XML configuration file.
Future versions of Gradle may include other sources (for example via external services).
====

Dependency verification is automatically enabled once the configuration file for dependency verification is discovered.
This configuration file is located at `$PROJECT_ROOT/gradle/verification-metadata.xml`.
This file minimally consists of the following:

[source,xml]
----
<?xml version=""1.0"" encoding=""UTF-8""?>
<verification-metadata>
   <configuration>
      <verify-metadata>true</verify-metadata>
      <verify-signatures>false</verify-signatures>
    </configuration>
</verification-metadata>
----

Doing so, Gradle will verify all artifacts using <<#sec:checksum-verification,checksums>>, but will not verify <<#sec:signature-verification,signatures>>.
Gradle will verify any artifact downloaded using its dependency management engine, which includes, but is not limited to:

- artifact files (e.g jar files, zips, ...) used during a build
- metadata artifacts (POM files, Ivy descriptors, Gradle Module Metadata)
- plugins (both project and settings plugins)
- artifacts resolved using the advanced dependency resolution APIs

Gradle will _not_ verify changing dependencies (in particular `SNAPSHOT` dependencies) nor locally produced artifacts (typically jars produced during the build itself) as by nature their checksums and signatures would always change.

With such a minimal configuration file, a project using _any_ external dependency or plugin would immediately start failing because it doesn't contain any checksum to verify.

[[sec:verification-scope]]
=== Scope of the dependency verification

A dependency verification configuration is _global_: a single file is used to configure verification of the whole build.
In particular, the same file is used for both the (sub)projects and `buildSrc`.

If an included build is used:

- the configuration file of the _current_ build is used for verification
- so if the included build itself uses verification, its configuration is ignored in favor of the current one
- which means that including a build works similarly to upgrading a dependency: it may require you to update your current verification metadata

An easy way to get started is therefore to generate the minimal configuration for an existing build.

[[sec:verification-console-output]]
=== Configuring the console output

By default, if dependency verification fails, Gradle will generate a small summary about the verification failure as well as an HTML report containing the full information about the failures.
If your environment prevents you from reading this HTML report file (for example if you run a build on CI and that it's not easy to fetch the remote artifacts), Gradle provides a way to opt-in a verbose console report.
For this, you need to add this Gradle property to your `gradle.properties` file:

----
org.gradle.dependency.verification.console=verbose
----

[[sec:bootstrapping-verification]]
=== Bootstrapping dependency verification

It's worth mentioning that while Gradle can generate a dependency verification file for you, you should always check whatever Gradle generated for you because your build may _already_ contain compromised dependencies without you knowing about it.
Please refer to the appropriate <<#sec:checksum-verification,checksum verification>> or <<#sec:signature-verification,signature verification>> section for more information.

If you plan on using <<#sec:signature-verification,signature verification>>, please also read the <<sec:bootstrapping-signature-verification,corresponding section>> of the docs.

Bootstrapping can either be used to create a file from the beginning, or also to _update_ an existing file with new information.
Therefore, it's recommended to always use the same parameters once you started bootstrapping.

The dependency verification file can be generated with the following CLI instructions:


----
gradle --write-verification-metadata sha256 help
----

The `write-verification-metadata` flag requires the list of <<#sec:checksum-verification,checksums>> that you want to generate or `pgp` for <<#sec:signature-verification,signatures>>.

Executing this command line will cause Gradle to:

* resolve all <<declaring_dependencies.adoc#sec:resolvable-consumable-configs,resolvable configurations>>, which includes:
** configurations from the root project
** configurations from all subprojects
** configurations from `buildSrc`
** included builds configurations
** configurations used by plugins
* download all artifacts discovered during resolution
* compute the requested checksums and possibly verify signatures depending on what you asked
* At the end of the build, generate the configuration file which will contain the inferred _verification metadata_

As a consequence, the `verification-metadata.xml` file will be used in subsequent builds to verify dependencies.

[WARNING]
====
There are dependencies that Gradle _cannot_ discover this way.
In particular, you will notice that the CLI above uses the `help` task.
If you don't specify any task, Gradle will automatically run the default task and generate a configuration file at the end of the build too.

The difference is that Gradle _may_ discover more dependencies and artifacts depending on the tasks you execute.
As a matter of fact, Gradle cannot automatically discover _detached configurations_, which are basically dependency graphs resolved as an internal implementation detail of the execution of a task: they are not, in particular, declared as an input of the task because they effectively depend on the configuration of the task at execution time.

A good way to start is just to use the simplest task, `help`, which will discover as much as possible, and if subsequent builds fail with a verification error, you can re-execute generation with the appropriate tasks to ""discover"" more dependencies.

Gradle won't verify either checksums or signatures of plugins which use their own HTTP clients.
Only plugins which use the infrastructure provided by Gradle for performing requests will see their requests verified.
====

[[sec:verification-update]]
=== Using generation for incremental updates

The verification file generated by Gradle has a strict ordering for all its content.
It also uses the information from the existing state to limit changes to the strict minimum.

This means that generation is actually a convenient tool for _updating_ a verification file:

* Checksum entries generated by Gradle will have a clear `origin` that starts with ""Generated by Gradle"", which is a good indicator that an entry needs to be reviewed,
* Entries added by hand will immediately be accounted for, and appear at the right location after writing the file,
* The header comments of the file will be preserved, i.e. comments before the root XML node.
This allows you to have a license header or instructions on which tasks and which parameters to use for generating that file.

With the above benefits, it is really easy to account for new dependencies or dependency versions by simply generating the file again and reviewing the changes.

[[sec:verification-dry-mode]]
=== Using dry mode

By default, bootstrapping is incremental, which means that if you run it multiple times, information is _added_ to the file and in particular you can rely on your VCS to check the diffs.
There are situations where you would just want to _see_ what the generated verification metadata file would look like without actually changing the existing one or overwriting it.

For this purpose, you can just add `--dry-run`:


----
gradle --write-verification-metadata sha256 help --dry-run
----

Then instead of generating the `verification-metadata.xml` file, a _new file_ will be generated, called `verification-metadata.dryrun.xml`.

[NOTE]
====
Because `--dry-run` doesn't execute tasks, this would be much faster, but it will miss any resolution happening at task execution time.
====

[[sec:disabling-metadata-verification]]
=== Disabling metadata verification

By default, Gradle will not only verify artifacts (jars, ...) but also the metadata associated with those artifacts (typically POM files).
Verifying this ensures the maximum level of security: metadata files typically tell what transitive dependencies will be included, so a compromised metadata file may cause the introduction of undesired dependencies in the graph.
However, because all artifacts are verified, such artifacts would in general easily be discovered by you, because they would cause a checksum verification failure (checksums would be _missing_ from verification metadata).
Because metadata verification can significantly increase the size of your configuration file, you may therefore want to disable verification of metadata.
If you understand the risks of doing so, set the `<verify-metadata>` flag to `false` in the configuration file:

[source,xml]
----
<?xml version=""1.0"" encoding=""UTF-8""?>
<verification-metadata>
   <configuration>
      <verify-metadata>false</verify-metadata>
      <verify-signatures>false</verify-signatures>
    </configuration>
    <!-- the rest of this file doesn't need to declare anything about metadata files -->
</verification-metadata>
----

[[sec:checksum-verification]]
== Verifying dependency checksums

Checksum verification allows you to ensure the integrity of an artifact.
This is the simplest thing that Gradle can do for you to make sure that the artifacts you use are un-tampered.

Gradle supports MD5, SHA1, SHA-256 and SHA-512 checksums.
However, only SHA-256 and SHA-512 checksums are considered secure nowadays.

=== Adding the checksum for an artifact

External components are identified by GAV coordinates, then each of the artifacts by their file names.
To declare the checksums of an artifact, you need to add the corresponding section in the verification metadata file.
For example, to declare the checksum for https://pdfbox.apache.org[Apache PDFBox].
The GAV coordinates are:

- group `org.apache.pdfbox`
- name `pdfbox`
- version `2.0.17`

Using this dependency will trigger the download of 2 different files:

- `pdfbox-2.0.17.jar` which is the main artifact
- `pdfbox-2.0.17.pom` which is the metadata file associated with this artifact

As as consequence, you need to declare the checksums for both of them (unless you <<sec:disabling-metadata-verification,disabled metadata verification>>):

[source,xml]
----
<?xml version=""1.0"" encoding=""UTF-8""?>
<verification-metadata>
   <configuration>
      <verify-metadata>true</verify-metadata>
      <verify-signatures>false</verify-signatures>
   </configuration>
   <components>
      <component group=""org.apache.pdfbox"" name=""pdfbox"" version=""2.0.17"">
         <artifact name=""pdfbox-2.0.17.jar"">
            <sha512 value=""7e11e54a21c395d461e59552e88b0de0ebaf1bf9d9bcacadf17b240d9bbc29bf6beb8e36896c186fe405d287f5d517b02c89381aa0fcc5e0aa5814e44f0ab331"" origin=""PDFBox Official site (https://pdfbox.apache.org/download.cgi)""/>
         </artifact>
         <artifact name=""pdfbox-2.0.17.pom"">
            <sha512 value=""82de436b38faf6121d8d2e71dda06e79296fc0f7bc7aba0766728c8d306fd1b0684b5379c18808ca724bf91707277eba81eb4fe19518e99e8f2a56459b79742f"" origin=""Generated by Gradle""/>
         </artifact>
      </component>
   </components>
</verification-metadata>
----

=== Where to get checksums from?

In general, checksums are published alongside artifacts on public repositories.
However, if a dependency is compromised in a repository, it's likely its checksum will be too, so it's a good practice to get the checksum from a different place, usually the website of the library itself.

In fact, it's a good security practice to publish the checksums of artifacts on a _different server_ than the server where the artifacts themselves are hosted: it's harder to compromise a library both on the repository __and__ the official website.

In the example above, the checksum was published on the website for the JAR, but not the POM file.
This is why it's usually easier to <<sec:bootstrapping-verification,let Gradle generate the checksums>> and verify by reviewing the generated file carefully.

// Be explicit about where origin info lives, it's not visible without scrolling right
In this example, not only could we check that the checksum was correct, but we could also find it on the official website, which is why we changed the value of the of `origin` attribute on the `sha512` element from `Generated by Gradle` to `PDFBox Official site`.
Changing the `origin` gives users a sense of how trustworthy your build it.

Interestingly, using `pdfbox` will require _much more_ than those 2 artifacts, because it will also bring in transitive dependencies.
If the dependency verification file only included the checksums for the main artifacts you used, the build would fail with an error like this one:


----
Execution failed for task ':compileJava'.
> Dependency verification failed for configuration ':compileClasspath':
    - On artifact commons-logging-1.2.jar (commons-logging:commons-logging:1.2) in repository 'MavenRepo': checksum is missing from verification metadata.
    - On artifact commons-logging-1.2.pom (commons-logging:commons-logging:1.2) in repository 'MavenRepo': checksum is missing from verification metadata.
----

What this indicates is that your build requires `commons-logging` when executing `compileJava`, however the verification file doesn't contain enough information for Gradle to verify the integrity of the dependencies, meaning you need to add the required information to the verification metadata file.

See <<sec:troubleshooting-verification,troubleshooting dependency verification>> for more insights on what to do in this situation.

=== What checksums are verified?

If a dependency verification metadata file declares more than one checksum for a dependency, Gradle will verify _all of them_ and fail if _any of them fails_.
For example, the following configuration would check both the `md5` and `sha1` checksums:

[source,xml]
----
<component group=""org.apache.pdfbox"" name=""pdfbox"" version=""2.0.17"">
   <artifact name=""pdfbox-2.0.17.jar"">
      <md5 value=""c713a8e252d0add65e9282b151adf6b4"" origin=""official site""/>
      <sha1 value=""b5c8dff799bd967c70ccae75e6972327ae640d35"" origin=""official site""/>
   </artifact>
</component>
----

There are multiple reasons why you'd like to do so:

1. an official site doesn't publish _secure_ checksums (SHA-256, SHA-512) but publishes multiple insecure ones (MD5, SHA1). While it's easy to fake a MD5 checksum and hard but possible to fake a SHA1 checksum, it's harder to fake both of them for the same artifact.
2. you might want to add generated checksums to the list above
3. when _updating_ dependency verification file with more secure checksums, you don't want to accidentally erase checksums

[[sec:signature-verification]]
== Verifying dependency signatures

In addition to <<sec:checksum-verification,checksums>>, Gradle supports verification of signatures.
Signatures are used to assess the _provenance_ of a dependency (it tells who signed the artifacts, which usually corresponds to who produced it).

As enabling signature verification usually means a higher level of security, you might want to replace checksum verification with signature verification.

[WARNING]
====
Signatures _can_ also be used to assess the integrity of a dependency similarly to checksums.
Signatures are signatures of the _hash_ of artifacts, not artifacts themselves.
This means that if the signature is done on an _unsafe hash_ (even SHA1), then you're not correctly assessing the _integrity_ of a file.
For this reason, if you care about both, you need to add both signatures _and_ checksums to your verification metadata.
====

However:

- Gradle only supports verification of signatures published on remote repositories as ASCII-armored PGP files
- Not all artifacts are published with signatures
- A good signature doesn't mean that the signatory was legit

As a consequence, signature verification will often be used alongside checksum verification.

[NOTE]
.About expired keys
====
It's very common to find artifacts which are signed with an expired key.
This is not a problem for _verification_: key expiry is mostly used to avoid signing with a stolen key.
If an artifact was signed before expiry, it's still valid.
====

=== Enabling signature verification

Because verifying signatures is more expensive (both I/O and CPU wise) and harder to check manually, it's not enabled by default.

Enabling it requires you to change the configuration option in the `verification-metadata.xml` file:

[source,xml]
----
<?xml version=""1.0"" encoding=""UTF-8""?>
<verification-metadata>
   <configuration>
      <verify-signatures>true</verify-signatures>
   </configuration>
</verification-metadata>
----

[[sec:understanding-signature-verification]]
== Understanding signature verification

Once signature verification is enabled, for each artifact, Gradle will:

* try to download the corresponding `.asc` file
* if it's present
** automatically download the keys required to perform verification of the signature
** verify the artifact using the downloaded public keys
** if signature verification passes, perform additional requested checksum verification
* if it's absent, fallback to checksum verification

That is to say that Gradle's verification mechanism is much stronger if signature verification is enabled than just with checksum verification.
In particular:

- if an artifact is signed with multiple keys, all of them must pass validation or the build will fail
- if an artifact passes verification, any additional checksum configured for the artifact _will also be checked_

However, it's not because an artifact passes signature verification that you can trust it: you need to _trust the keys_.

In practice, it means you need to list the keys that you trust for each artifact, which is done by adding a `pgp` entry instead of a `sha1` for example:

[source,xml]
----
<component group=""com.github.javaparser"" name=""javaparser-core"" version=""3.6.11"">
   <artifact name=""javaparser-core-3.6.11.jar"">
      <pgp value=""8756c4f765c9ac3cb6b85d62379ce192d401ab61""/>
   </artifact>
</component>
----

[TIP]
====
Gradle supports both full fingerprint ids or long (64-bit) key ids in `pgp`, `trusted-key` and `ignore-key` elements.
For maximum security, you should use full fingerprints as it's possible to have collisions for long key ids.
====

This effectively means that you trust `com.github.javaparser:javaparser-core:3.6.11` if it's signed with the key `8756c4f765c9ac3cb6b85d62379ce192d401ab61`.

Without this, the build would fail with this error:

----
> Dependency verification failed for configuration ':compileClasspath':
    - On artifact javaparser-core-3.6.11.jar (com.github.javaparser:javaparser-core:3.6.11) in repository 'MavenRepo': Artifact was signed with key '8756c4f765c9ac3cb6b85d62379ce192d401ab61' (Bintray (by JFrog) <****>) and passed verification but the key isn't in your trusted keys list.
----

[NOTE]
====
The key IDs that Gradle shows in error messages are the key IDs found in the signature file it tries to verify.
It doesn't mean that it's necessarily the keys that you should trust.
In particular, if the signature is correct but done by a malicious entity, Gradle wouldn't tell you.
====

[[sec:trusting-keys-globally]]
=== Trusting keys globally

Signature verification has the advantage that it can make the configuration of dependency verification easier by not having to explicitly list all artifacts like for checksum verification only.
In fact, it's common that the same key can be used to sign several artifacts.
If this is the case, you can move the trusted key from the artifact level to the global configuration block:

[source,xml]
----
<?xml version=""1.0"" encoding=""UTF-8""?>
<verification-metadata>
   <configuration>
      <verify-metadata>true</verify-metadata>
      <verify-signatures>true</verify-signatures>
      <trusted-keys>
         <trusted-key id=""379ce192d401ab61"" group=""com.github.javaparser""/>
      </trusted-keys>
   </configuration>
   <components/>
</verification-metadata>
----

The configuration above means that for any artifact belonging to the group `com.github.javaparser`, we trust it if it's signed with the `379ce192d401ab61`.

The `trusted-key` element works similarly to the <<sec:trusting-artifacts,trusted-artifact>> element:

- `group`, the group of the artifact to trust
- `name`, the name of the artifact to trust
- `version`, the version of the artifact to trust
- `file`, the name of the artifact _file_ to trust
- `regex`, a boolean saying if the `group`, `name`, `version` and `file` attributes need to be interpreted as regular expressions (defaults to `false`)

[WARNING]
====
You should be careful when trusting a key globally: try to limit it to the appropriate groups or artifacts:

- a valid key may have been used to sign artifact `A` which you trust
- later on, the key is stolen and used to sign artifact `B`

It means you can trust the key `A` for the first artifact, probably only up to the released version before the key was stolen, but not for `B`.

Remember that anybody can put an arbitrary name when generating a PGP key, so never trust the key solely based on the key name.
Verify if the key is listed at the official site.
For example, Apache projects typically provide a KEYS.txt file that you can trust.
====

[[sec:ignoring-keys]]
=== Specifying key servers and ignoring keys

Gradle will automatically download the public keys required to verify a signature.
For this it uses a list of well known and trusted key servers (the list may change between Gradle versions, please refer to the implementation to figure out what servers are used by default).

You can explicitly set the list of key servers that you want to use by adding them to the configuration:

[source,xml]
----
<?xml version=""1.0"" encoding=""UTF-8""?>
<verification-metadata>
   <configuration>
      <verify-metadata>true</verify-metadata>
      <verify-signatures>true</verify-signatures>
      <key-servers>
         <key-server uri=""hkp://my-key-server.org""/>
         <key-server uri=""https://my-other-key-server.org""/>
      </key-servers>
   </configuration>
</verification-metadata>
----

Despite this, it's possible that a key is not available:

- because it wasn't published to a public key server
- because it was lost

In this case, you can ignore a key in the configuration block:

[source,xml]
----
<?xml version=""1.0"" encoding=""UTF-8""?>
<verification-metadata>
   <configuration>
      <verify-metadata>true</verify-metadata>
      <verify-signatures>true</verify-signatures>
      <ignored-keys>
         <ignored-key id=""abcdef1234567890"" reason=""Key is not available in any key server""/>
      </ignored-keys>
   </configuration>
</verification-metadata>
----

As soon as a key is ignored, it will not be used for verification, even if the signature file mentions it.
However, if the signature cannot be verified with at least one other key, Gradle will mandate that you provide a checksum.

[[sec:local-keyring]]
=== Exporting keys for faster verification

Gradle automatically downloads the required keys but this operation can be quite slow and requires everyone to download the keys.
To avoid this, Gradle offers the ability to use a local keyring file containing the required public keys.

Gradle supports 2 different file formats for keyrings: a binary format (`.gpg` file) and a plain text format (`.keys`).

There are pros and cons for each of the formats: the binary format is more compact and can be updated directly via GPG commands, but is completely opaque (binary).
On the opposite, the plain text format is human readable, can be easily updated by hand and makes it easier to do code reviews thanks to readable diffs.

If the `gradle/verification-keyring.gpg` or `gradle/verification-keyring.keys` file is present, Gradle will search for keys there in priority.

Note that the plain text file will be ignored if there's already a `.gpg` file (the binary version takes precedence).

The keys are automatically deduplicated and sorted before exporting in order to cause minimal differences between exports.

You can generate the binary version using GPG, for example issuing the following commands (syntax may depend on the tool you use):

[source,bash]
----
$ gpg --no-default-keyring --keyring gradle/verification-keyring.gpg --recv-keys 379ce192d401ab61

gpg: keybox 'gradle/verification-keyring.gpg' created
gpg: key 379CE192D401AB61: public key ""Bintray (by JFrog) <****>"" imported
gpg: Total number processed: 1
gpg:               imported: 1

$ gpg --no-default-keyring --keyring gradle/verification-keyring.gpg --recv-keys 6a0975f8b1127b83

gpg: key 0729A0AFF8999A87: public key ""Kotlin Release <****>"" imported
gpg: Total number processed: 1
gpg:               imported: 1
----

The plain text version, on the other hand, can be updated manually.
The file must be formatted with the `US-ASCII` encoding and consists of a list of keys in ASCII armored format.

In the example above, you could amend an existing KEYS file by issuing the following commands:

[source,bash]
----
$ gpg --no-default-keyring --keyring /tmp/keyring.gpg --recv-keys 379ce192d401ab61

gpg: keybox '/tmp/keyring.gpg' created
gpg: key 379CE192D401AB61: public key ""Bintray (by JFrog) <****>"" imported
gpg: Total number processed: 1
gpg:               imported: 1

# First let's add a header so that we can recognize the added key
$ gpg --keyring /tmp/keyring.gpg --list-sigs 379CE192D401AB61 > gradle/verification-keyring.keys

# Then write its ASCII armored version
$ gpg --keyring /tmp/keyring.gpg --export --armor 379CE192D401AB61 > gradle/verification-keyring.keys
----

Or, alternatively, you can _ask Gradle to export all keys it used for verification of this build to the keyring_ during bootstrapping:

----
./gradlew --write-verification-metadata pgp,sha256 --export-keys
----

[NOTE]
====
This command will generate *both* the binary version and the ASCII armored file.
You should only pick one for your project.

It's a good idea to commit this file to VCS (as long as you trust your VCS).
If you use git and use the binary version, make sure to make it treat this file as binary, by adding this to your `.gitattributes` file:

----
*.gpg           binary
----
====

[[sec:bootstrapping-signature-verification]]
=== Bootstrapping and signature verification

[WARNING]
====
Signature verification bootstrapping takes an _optimistic point of view_ that signature verification is _enough_.
Therefore, if you also care about _integrity_, you **must** first bootstrap using checksum verification, _then_ with signature verification.
====

Similarly to bootstrapping for checksums, Gradle provides a convenience for bootstrapping a configuration file with signature verification enabled.
For this, just add the `pgp` option to the list of verifications to generate.
However, because there might be verification failures, missing keys or missing signature files, you **must** provide a fallback checksum verification algorithm:

----
./gradlew --write-verification-metadata pgp,sha256
----

this means that Gradle will verify the signatures and fallback to SHA-256 checksums when there's a problem.

When bootstrapping, Gradle performs _optimistic verification_ and therefore assumes a sane build environment.
It will therefore:

- automatically add the trusted keys as soon as verification passes
- automatically add ignored keys for keys which couldn't be downloaded from public key servers
- automatically generate checksums for artifacts without signatures or ignored keys

If, for some reason, verification fails during the generation, Gradle will automatically generate an ignored key entry but warn you that you must absolutely check what happens.

This situation is common as explained for <<sec:trusting-several-checksums,this section>>: a typical case is when the POM file for a dependency differs from one repository to the other (often in a non-meaningful way).

In addition, Gradle will try to group keys automatically and generate the `trusted-keys` block which reduced the configuration file size as much as possible.

[[sec:local-keyring-only]]
== Forcing use of local keyrings only

The local keyring files (`.gpg` or `.keys`) can be used to avoid reaching out to key servers whenever a key is required to verify an artifact.
However, it may be that the local keyring doesn't contain a key, in which case Gradle would use the key servers to fetch the missing key.
If the local keyring file isn't regularly updated, using <<sec:local-keyring,key export>>, then it may be that your CI builds, for example, would reach out to key servers too often (especially if you use disposable containers for builds).

To avoid this, Gradle offers the ability to disallow use of key servers altogether: only the local keyring file would be used, and if a key is missing from this file, the build will fail.

To enable this mode, you need to disable key servers in the configuration file:

[source,xml]
----
<?xml version=""1.0"" encoding=""UTF-8""?>
<verification-metadata>
   <configuration>
      <key-servers enabled=""false""/>
      ...
   </configuration>
   ...
</verification-metadata>
----

NOTE: If you are asking Gradle to <<sec:bootstrapping-verification,generate a verification metadata file>> and that an existing verification metadata file sets `enabled` to `false`, then this flag will be ignored, so that potentially missing keys are downloaded.

[[sec:troubleshooting-verification]]
== Troubleshooting dependency verification

[[sec:dealing-verification-failure]]
=== Dealing with a verification failure

Dependency verification can fail in different ways, this section explains how you should deal with the various cases.

==== Missing verification metadata

The simplest failure you can have is when verification metadata is missing from the dependency verification file.
This is the case for example if you use <<sec:checksum-verification,checksum verification>>, then you update a dependency and new versions of the dependency (and potentially its transitive dependencies) are brought in.

Gradle will tell you what metadata is missing:


----
Execution failed for task ':compileJava'.
> Dependency verification failed for configuration ':compileClasspath':
    - On artifact commons-logging-1.2.jar (commons-logging:commons-logging:1.2) in repository 'MavenRepo': checksum is missing from verification metadata.
----

- the missing module group is `commons-logging`, it's artifact name is `commons-logging` and its version is `1.2`. The corresponding artifact is `commons-logging-1.2.jar` so you need to add the following entry to the verification file:

[source,xml]
----
<component group=""commons-logging"" name=""commons-logging"" version=""1.2"">
   <artifact name=""commons-logging-1.2.jar"">
      <sha256 value=""daddea1ea0be0f56978ab3006b8ac92834afeefbd9b7e4e6316fca57df0fa636"" origin=""official distribution""/>
   </artifact>
</component>
----

Alternatively, you can ask Gradle to generate the missing information by using the <<#sec:bootstrapping-verification,bootstrapping mechanism>>: existing information in the metadata file will be preserved, Gradle will only add the missing verification metadata.

==== Incorrect checksums

A more problematic issue is when the actual checksum verification fails:


----
Execution failed for task ':compileJava'.
> Dependency verification failed for configuration ':compileClasspath':
    - On artifact commons-logging-1.2.jar (commons-logging:commons-logging:1.2) in repository 'MavenRepo': expected a 'sha256' checksum of '91f7a33096ea69bac2cbaf6d01feb934cac002c48d8c8cfa9c240b40f1ec21df' but was 'daddea1ea0be0f56978ab3006b8ac92834afeefbd9b7e4e6316fca57df0fa636'
----

This time, Gradle tells you what dependency is at fault, what was the expected checksum (the one you declared in the verification metadata file) and the one which was actually computed during verification.

Such a failure indicates that a **dependency may have been compromised**.
At this stage, you **must** perform manual verification and check what happens.
Several things can happen:

* a dependency was tampered in the local dependency cache of Gradle. This is usually harmless: erase the file from the cache and Gradle would redownload the dependency.
* a dependency is available in multiple sources with slightly different binaries (additional whitespace, ...)
** please inform the maintainers of the library that they have such an issue
** you can use <<#sec:trusting-several-checksums,`also-trust`>> to accept the additional checksums
* the dependency was compromised
** immediately inform the maintainers of the library
** notify the repository maintainers of the compromised library

Note that a variation of a compromised library is often _name squatting_, when a hacker would use GAV coordinates which _look legit_ but are actually different by one character, or _repository shadowing_, when a dependency with the official GAV coordinates is published in a malicious repository which comes first in your build.

==== Untrusted signatures

If you have signature verification enabled, Gradle will perform verification of the signatures but will not trust them automatically:


----
> Dependency verification failed for configuration ':compileClasspath':
    - On artifact javaparser-core-3.6.11.jar (com.github.javaparser:javaparser-core:3.6.11) in repository 'MavenRepo': Artifact was signed with key '379ce192d401ab61' (Bintray (by JFrog) <****>) and passed verification but the key isn't in your trusted keys list.
----

In this case it means you need to check yourself if the key that was used for verification (and therefore the signature) can be trusted, in which case refer to <<#sec:understanding-signature-verification,this section of the documentation>> to figure out how to declare trusted keys.

==== Failed signature verification

If Gradle fails to verify a signature, you will need to take action and verify artifacts manually because this **may indicate a compromised dependency**.

If such a thing happens, Gradle will fail with:

----
> Dependency verification failed for configuration ':compileClasspath':
    - On artifact javaparser-core-3.6.11.jar (com.github.javaparser:javaparser-core:3.6.11) in repository 'MavenRepo': Artifact was signed with key '379ce192d401ab61' (Bintray (by JFrog) <****>) but signature didn't match
----

There are several options:

1. signature was wrong in the first place, which happens frequently with <<#sec:trusting-several-checksums,dependencies published on different repositories>>.
2. the signature is correct but the artifact has been compromised (either in the local dependency cache or remotely)

The right approach here is to go to the official site of the dependency and see if they publish signatures for their artifacts.
If they do, verify that the signature that Gradle downloaded matches the one published.

If you have <<#sec:manual-checking-dependency,checked that the dependency is _not_ compromised>> and that it's ""only"" the signature which is wrong, you should declare an _artifact level key exclusion_:

[source,xml]
----
   <components>
       <component group=""com.github.javaparser"" name=""javaparser-core"" version=""3.6.11"">
          <artifact name=""javaparser-core-3.6.11.pom"">
             <ignored-keys>
                <ignored-key id=""379ce192d401ab61"" reason=""internal repo has corrupted POM""/>
             </ignored-keys>
          </artifact>
       </component>
   </components>
----

However, if you only do so, Gradle will still fail because all keys for this artifact will be ignored and you didn't provide a checksum:

[source,xml]
----
   <components>
       <component group=""com.github.javaparser"" name=""javaparser-core"" version=""3.6.11"">
          <artifact name=""javaparser-core-3.6.11.pom"">
             <ignored-keys>
                <ignored-key id=""379ce192d401ab61"" reason=""internal repo has corrupted POM""/>
             </ignored-keys>
             <sha256 value=""a2023504cfd611332177f96358b6f6db26e43d96e8ef4cff59b0f5a2bee3c1e1""/>
          </artifact>
       </component>
   </components>
----

[[sec:manual-checking-dependency]]
==== Manual verification of a dependency

You will likely face a dependency verification failure (either checksum verification or signature verification) and will need to figure out if the dependency has been compromised or not.

In this section we give _an example_ how you can manually check if a dependency was compromised.

For this we will take this example failure:

----
> Dependency verification failed for configuration ':compileClasspath':
- On artifact j2objc-annotations-1.1.jar (com.google.j2objc:j2objc-annotations:1.1) in repository 'MyCompany Mirror': Artifact was signed with key '29579f18fa8fd93b' but signature didn't match
----

This error message gives us the GAV coordinates of the problematic dependency, as well as an indication of where the dependency was fetched from.
Here, the dependency comes from `MyCompany Mirror`, which is a repository declared in our build.

The first thing to do is therefore to download the artifact and its signature manually from the mirror:

----
$ curl https://my-company-mirror.com/repo/com/google/j2objc/j2objc-annotations/1.1/j2objc-annotations-1.1.jar --output j2objc-annotations-1.1.jar
$ curl https://my-company-mirror.com/repo/com/google/j2objc/j2objc-annotations/1.1/j2objc-annotations-1.1.jar.asc --output j2objc-annotations-1.1.jar.asc
----

Then we can use the key information provided in the error message to import the key locally:

----
$ gpg --recv-keys 29579f18fa8fd93b
----

And perform verification:

----
$ gpg --verify j2objc-annotations-1.1.jar.asc
gpg: assuming signed data in 'j2objc-annotations-1.1.jar'
gpg: Signature made Thu 19 Jan 2017 12:06:51 AM CET
gpg:                using RSA key 29579F18FA8FD93B
gpg: BAD signature from ""Tom Ball <****>"" [unknown]
----

What this tells us is that the problem is _not_ on the local machine: the repository _already contains a bad signature_.

The next step is to do the same by downloading what is actually on Maven Central:

----
$ curl https://my-company-mirror.com/repo/com/google/j2objc/j2objc-annotations/1.1/j2objc-annotations-1.1.jar  --output central-j2objc-annotations-1.1.jar
$ curl https://my-company-mirror.com/repo/com/google/j2objc/j2objc-annotations/1/1/j2objc-annotations-1.1.jar.asc  --output central-j2objc-annotations-1.1.jar.asc
----

And we can now check the signature again:

----
$ gpg --verify central-j2objc-annotations-1.1.jar.asc

gpg: assuming signed data in 'central-j2objc-annotations-1.1.jar'
gpg: Signature made Thu 19 Jan 2017 12:06:51 AM CET
gpg:                using RSA key 29579F18FA8FD93B
gpg: Good signature from ""Tom Ball <****>"" [unknown]
gpg: WARNING: This key is not certified with a trusted signature!
gpg:          There is no indication that the signature belongs to the owner.
Primary key fingerprint: B801 E2F8 EF03 5068 EC11  39CC 2957 9F18 FA8F D93B
----

This indicates that the dependency is _valid_ on Maven Central.
At this stage, we already know that the problem lives in the mirror, it _may_ have been compromised, but we need to verify.

A good idea is to compare the 2 artifacts, which you can do with a tool like https://try.diffoscope.org/[diffoscope].

We then figure out that the intent wasn't malicious but that somehow a build has been overwritten with a newer version (the version in Central is newer than the one in our repository).

In this case, you can decide to:

- ignore the signature for this artifact and trust the different possible checksums (both for the old artifact and the new version)
- or cleanup your mirror so that it contains the same version as in Maven Central

It's worth noting that if you choose to delete the version from your repository, you will _also_ need to remove it from the local Gradle cache.

This is facilitated by the fact the error message tells you were the file is located:

----
> Dependency verification failed for configuration ':compileClasspath':
    - On artifact j2objc-annotations-1.1.jar (com.google.j2objc:j2objc-annotations:1.1) in repository 'MyCompany Mirror': Artifact was signed with key '29579f18fa8fd93b' but signature didn't match

  This can indicate that a dependency has been compromised. Please carefully verify the signatures and checksums.

  For your information here are the path to the files which failed verification:
    - GRADLE_USER_HOME/caches/modules-2/files-2.1/com.google.j2objc/j2objc-annotations/1.1/976d8d30bebc251db406f2bdb3eb01962b5685b3/j2objc-annotations-1.1.jar (signature: GRADLE_USER_HOME/caches/modules-2/files-2.1/com.google.j2objc/j2objc-annotations/1.1/82e922e14f57d522de465fd144ec26eb7da44501/j2objc-annotations-1.1.jar.asc)

  GRADLE_USER_HOME = /home/jiraya/.gradle
----

You can safely delete the artifact file as Gradle would automatically re-download it:

----
rm -rf ~/.gradle/caches/modules-2/files-2.1/com.google.j2objc/j2objc-annotations/1.1
----

[[sec:disabling-verification]]
=== Disabling verification or making it lenient

Dependency verification can be expensive, or sometimes verification could get in the way of day to day development (because of frequent dependency upgrades, for example).

Alternatively, you might want to enable verification on CI servers but not on local machines.

Gradle actually provides 3 different verification modes:

- `strict`, which is the default.
Verification fails _as early as possible_, in order to avoid the use of compromised dependencies during the build.
- `lenient`, which will run the build even if there are verification failures.
The verification errors will be displayed during the build without causing a build failure.
- `off` when verification is totally ignored.

All those modes can be activated on the CLI using the `--dependency-verification` flag, for example:


----
./gradlew --dependency-verification lenient build
----

Alternatively, you can set the `org.gradle.dependency.verification` system property, either on the CLI:


----
./gradlew -Dorg.gradle.dependency.verification=lenient build
----

or in a `gradle.properties` file:

----
org.gradle.dependency.verification=lenient
----

[[sec:trusting-artifacts]]
=== Trusting some particular artifacts

You might want to trust some artifacts more than others.
For example, it's legitimate to think that artifacts produced in your company and found in your internal repository only are safe, but you want to check every external component.

[NOTE]
====
This is a typical _company policy_.
In practice, **nothing** prevents your internal repository from being compromised, so it's a good idea to check your internal artifacts too!
====

For this purpose, Gradle offers a way to automatically trust some artifacts.
You can trust all artifacts in a group by adding this to your configuration:

[source,xml]
----
<?xml version=""1.0"" encoding=""UTF-8""?>
<verification-metadata>
   <configuration>
      <trusted-artifacts>
         <trust group=""com.mycompany""/>
      </trusted-artifacts>
   </configuration>
</verification-metadata>
----

This means that all components which group is `com.mycompany` will automatically be trusted.
Trusted means that Gradle will not perform any verification whatsoever.

The `trust` element accepts those attributes:

- `group`, the group of the artifact to trust
- `name`, the name of the artifact to trust
- `version`, the version of the artifact to trust
- `file`, the name of the artifact _file_ to trust
- `regex`, a boolean saying if the `group`, `name`, `version` and `file` attributes need to be interpreted as regular expressions (defaults to `false`)

In the example above it means that the trusted artifacts would be artifacts in `com.mycompany` but not `com.mycompany.other`.
To trust all artifacts in `com.mycompany` and all subgroups, you can use:

[source,xml]
----
<?xml version=""1.0"" encoding=""UTF-8""?>
<verification-metadata>
   <configuration>
      <trusted-artifacts>
         <trust group=""^com[.]mycompany($|([.].*))"" regex=""true""/>
      </trusted-artifacts>
   </configuration>
</verification-metadata>
----

[[sec:trusting-several-checksums]]
=== Trusting multiple checksums for an artifact

It's quite common to have _different checksums for the same artifact_ in the wild.
How is that possible?
Despite progress, it's often the case that developers publish, for example, to Maven Central and another repository separately, using different builds.
In general, this is not a problem but sometimes it means that the metadata files would be different (different timestamps, additional whitespaces, ...).
Add to this that your build may use several repositories or repository mirrors and it makes it quite likely that a single build can ""see"" different metadata files for the same component!
In general, it's not malicious (but you **must** verify that the artifact is actually correct), so Gradle lets you declare the additional artifact checksums.
For example:

[source,xml]
----
      <component group=""org.apache"" name=""apache"" version=""13"">
         <artifact name=""apache-13.pom"">
            <sha256 value=""2fafa38abefe1b40283016f506ba9e844bfcf18713497284264166a5dbf4b95e"">
               <also-trust value=""ff513db0361fd41237bef4784968bc15aae478d4ec0a9496f811072ccaf3841d""/>
            </sha256>
         </artifact>
      </component>
----

You can have as many `also-trust` entries as needed, but in general you shouldn't have more than 2.

[[sec:skipping-javadocs]]
=== Skipping Javadocs and sources

By default Gradle will verify _all_ downloaded artifacts, which includes Javadocs and sources.
In general this is not a problem but you might face an issue with IDEs which automatically try to download them during import: if you didn't set the checksums for those too, importing would fail.

To avoid this, you can configure Gradle to trust automatically all javadocs/sources:

[source,xml]
----
<trusted-artifacts>
   <trust file="".*-javadoc[.]jar"" regex=""true""/>
   <trust file="".*-sources[.]jar"" regex=""true""/>
</trusted-artifacts>
----

[[sec:verification-metadata-hygiene]]
=== Cleaning up the verification file

If you do nothing, the dependency verification metadata will grow over time as you add new dependencies or change versions: Gradle will not automatically remove _unused_ entries from this file.
The reason is that there's no way for Gradle to know upfront if a dependency will effectively be used during the build or not.

As a consequence, adding dependencies or changing dependency version can easily lead to more entries in the file, while leaving unnecessary entries out there.

One option to cleanup the file is to move the existing `verification-metadata.xml` file to a different location and call Gradle with the <<#sec:verification-dry-mode,`--dry-run` mode>>: while not perfect (it will not notice dependencies only resolved at configuration time), it generates _a new file_ that you can compare with the existing one.

We need to move the existing file because both the bootstrapping mode and the dry-run mode are incremental: they copy information from the existing metadata verification file (in particular, trusted keys).

[[sec:refreshing-missing-keys]]
=== Refreshing missing keys

Gradle caches missing keys for 24 hours, meaning it will not attempt to re-download the missing keys for 24 hours after failing.

If you want to retry immediately, you can run with the `--refresh-keys` CLI flag:


----
./gradlew build --refresh-keys
----

[[sub:disabling-specific-verification]]
== Disabling dependency verification for some configurations only

In order to provide the strongest security level possible, dependency verification is enabled globally.
This will ensure, for example, that you trust all the plugins you use.
However, the plugins themselves may need to resolve additional dependencies that it doesn't make sense to ask the user to accept.
For this purpose, Gradle provides an API which allows _disabling dependency verification on some specific configurations_.

[WARNING]
====
Disabling dependency verification, if you care about security, is not a good idea.
This API mostly exist for cases where it doesn't make sense to check dependencies.
However, in order to be on the safe side, Gradle will systematically print a warning whenever verification has been disabled for a specific configuration.
====

As an example, a plugin may want to check if there are _newer_ versions of a library available and list those versions.
It doesn't make sense, in this context, to ask the user to put the checksums of the POM files of the newer releases because by definition, they don't know about them.
So the plugin might need to run its code _independently of the dependency verification configuration_.

To do this, you need to call the `ResolutionStrategy#disableDependencyVerification` method:

.Disabling dependency verification
====
include::sample[dir=""snippets/dependencyManagement/dependencyVerification-disablingVerification/groovy"",files=""build.gradle[tags=disabling-one-configuration]""]
include::sample[dir=""snippets/dependencyManagement/dependencyVerification-disablingVerification/kotlin"",files=""build.gradle.kts[tags=disabling-one-configuration]""]
====

It's also possible to disable verification on detached configurations like in the following example:

.Disabling dependency verification
====
include::sample[dir=""snippets/dependencyManagement/dependencyVerification-disablingVerification/groovy"",files=""build.gradle[tags=disabling-detached-configuration]""]
include::sample[dir=""snippets/dependencyManagement/dependencyVerification-disablingVerification/kotlin"",files=""build.gradle.kts[tags=disabling-detached-configuration]""]
====
",12137,False,2389.321350632607,median
"[[git-plugin]]
= Git Plugin
:toc: macro
:toc-title:

[#introduction]
== Introduction

[.float-group]
--
[.text-center]
image:https://jenkins.io/images/logos/jenkins/jenkins.png[Jenkins logo,height=192,role=center,float=right]
image:images/signe-1923369_640.png[plus,height=64,float=right]
image:https://git-scm.com/images/logos/downloads/Git-Logo-2Color.png[Git logo,height=128,float=right]
--

The git plugin provides fundamental git operations for Jenkins projects.
It can poll, fetch, checkout, branch, list, merge, tag, and push repositories.

toc::[]

[#changelog]
== Changelog in https://github.com/jenkinsci/git-plugin/releases[GitHub Releases]

Release notes are recorded in https://github.com/jenkinsci/git-plugin/releases[GitHub Releases] since July 1, 2019 (git plugin 3.10.1 and later).
Prior release notes are recorded in the git plugin repository link:CHANGELOG.adoc#changelog-moved-to-github-releases[change log].

== Pipelines

The git plugin provides an SCM implementation to be used with the Pipeline SCM link:https://www.jenkins.io/doc/pipeline/steps/workflow-scm-step/[`checkout` step].
The link:https://www.jenkins.io/redirect/pipeline-snippet-generator[Pipeline Syntax Snippet Generator] guides the user to select checkout options.

The link:https://youtu.be/ai1kf4ihZUo[90 second video clip] below introduces the Pipeline Syntax Snippet Generator and shows how it is used to generate steps for the Jenkins Pipeline.

image:images/pipeline-syntax.png[link=https://youtu.be/ai1kf4ihZUo]

=== Multibranch Pipelines

The git plugin includes a multibranch provider for Jenkins link:https://www.jenkins.io/doc/book/pipeline/multibranch/[Multibranch Pipelines] and for Jenkins link:https://www.jenkins.io/doc/book/pipeline/multibranch/#organization-folders[Organization Folders].
The git plugin multibranch provider is a ""base implementation"" that uses command line git.
Users should prefer the multibranch implementation for their git provider when one is available.
Multibranch implementations for specific git providers can use REST API calls to improve the Jenkins experience and add additional capabilities.
Multibranch implementations are available for
link:https://docs.cloudbees.com/docs/cloudbees-ci/latest/cloud-admin-guide/github-branch-source-plugin[GitHub],
link:https://github.com/jenkinsci/bitbucket-branch-source-plugin/blob/master/docs/USER_GUIDE.adoc[Bitbucket],
link:https://plugins.jenkins.io/gitlab-branch-source/[GitLab],
link:https://plugins.jenkins.io/gitea/[Gitea], and
link:https://plugins.jenkins.io/tuleap-git-branch-source/[Tuleap].

The link:https://youtu.be/B_2FXWI6CWg[30 minute video clip] below introduces Multibranch Pipelines.

image:images/multibranch-pipeline.png[link=https://youtu.be/B_2FXWI6CWg]

[#configuration]
== [[GitPlugin-ProjectConfiguration]]Configuration

[#using-repositories]
=== Repositories

image:/images/git-repository-configuration.png[Repository Configuration]

The git plugin fetches commits from one or more remote repositories and performs a checkout in the agent workspace.
Repositories and their related information include:

Repository URL::

  The URL of the remote repository.
  The git plugin passes the remote repository URL to the git implementation (command line or JGit).
  Valid repository URL's include `https`, `ssh`, `scp`, `git`, `local file`, and other forms.
  Valid repository URL forms are described in the link:https://git-scm.com/book/en/v2/Git-on-the-Server-The-Protocols#_the_protocols[git documentation].

Credentials::

  Credentials are defined using the link:https://plugins.jenkins.io/credentials[Jenkins credentials plugin].
  They are selected from a drop-down list and their identifier is stored in the job definition.
  Refer to <<using-credentials,using credentials>> for more details on supported credential types.

Name::

  Git uses a shortname to simplify user references to the URL of the remote repository.
  The default shortname is `origin`.
  Other values may be assigned and then used throughout the job definition to refer to the remote repository.

Refspec::

  A refspec maps remote branches to local references.
  It defines the branches and tags which will be fetched from the remote repository into the agent workspace.
+
A refspec defines the remote references that will be retrieved and how they map to local references.
If left blank, it will default to the normal `git fetch` behavior and will retrieve all branches.
This default behavior is sufficient for most cases.
+
The default refspec is `+refs/heads/*:refs/remotes/REPOSITORYNAME/` where REPOSITORYNAME is the value you specify in the above repository ""Name"" field.
The default refspec retrieves all branches.
If a checkout only needs one branch, then a more restrictive refspec can reduce the data transfer from the remote repository to the agent workspace.
For example, `+refs/heads/master:refs/remotes/origin/master` will retrieve only the master branch and nothing else.
+
The refspec can be used with the <<honor-refspec-on-initial-clone,honor refspec on initial clone>> option in the <<advanced-clone-behaviours,advanced clone behaviors>> to limit the number of remote branches mapped to local references.
If ""honor refspec on initial clone"" is not enabled, then a default refspec for its initial fetch.
This maintains compatibility with previous behavior and allows the job definition to decide if the refspec should be honored on initial clone.
+
Multiple refspecs can be entered by separating them with a space character.
The refspec value `+refs/heads/master:refs/remotes/origin/master +refs/heads/develop:refs/remotes/origin/develop` retrieves the master branch and the develop branch and nothing else.
+
Refer to the link:https://git-scm.com/book/en/v2/Git-Internals-The-Refspec[git refspec documentation] for more refspec details.

[#using-credentials]
=== Using Credentials

The git plugin supports username / password credentials and private key credentials provided by the
https://plugins.jenkins.io/credentials[Jenkins credentials plugin].
It does not support other credential types like secret text, secret file, or certificates.
Select credentials from the job definition drop down menu or enter their identifiers in Pipeline job definitions.

When the remote repository is accessed with the **HTTP or HTTPS protocols**, the plugin requires a **username / password credential**.
Other credential types will not work with HTTP or HTTPS protocols.

When the remote repository is accessed with the **ssh protocol**, the plugin requires an **ssh private key credential**.
Other credential types will not work with the ssh protocol.

[#push-notification-from-repository]
=== [[GitPlugin-Pushnotificationfromrepository]]Push Notification From Repository

To minimize the delay between a push and a build, configure the remote repository to use a Webhook to notify Jenkins of changs to the repository.
Refer to webhook documentation for your repository:

* link:https://plugins.jenkins.io/github#GitHubPlugin-GitHubhooktriggerforGITScmpolling[GitHub]
* link:https://plugins.jenkins.io/bitbucket[Bitbucket]
* link:https://plugins.jenkins.io/gitlab-branch-source[GitLab]
* link:https://github.com/jenkinsci/gitea-plugin/blob/master/docs/README.md[Gitea]

Other git repositories can use a link:https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks[post-receive hook] in the remote repository to notify Jenkins of changes.
Add the following line in your `hooks/post-receive` file on the git server, replacing <URL of the Git repository> with the fully qualified URL you use when cloning the repository.

....
curl http://yourserver/git/notifyCommit?url=<URL of the Git repository>
....

This will scan all the jobs that:

* Have Build Triggers > Poll SCM enabled.  No polling schedule is required.
* Are configured to build the repository at the specified URL

For jobs that meet these conditions, polling will be triggered.
If polling finds a change worthy of a build, a build will be triggered.

This allows a notify script to remain the same for all Jenkins jobs.
Or if you have multiple repositories under a single repository host application (such as Gitosis), you can share a single post-receive hook script with all the repositories.
Finally, this URL doesn't require authentication even for secured Jenkins, because the server doesn't directly use anything that the client is sending.
It polls to verify that there is a change before it actually starts a build.

When notifyCommit is successful, the list of triggered projects is returned.

[#enabling-jgit]
=== Enabling JGit

See the link:https://plugins.jenkins.io/git-client/#enabling-jgit[git client plugin documentation] for instructions to enable JGit.
JGit becomes available throughout Jenkins once it has been enabled.

[#global-configuration]
=== [[GitPlugin-Configuration]]Global Configuration

image:/images/git-global-configuration.png[Global Configuration]

In the `Configure System` page, the Git Plugin provides the following options:

[[global-config-user-name]]
Global Config user.name Value::

  Defines the default git user name that will be assigned when git commits a change from Jenkins.
  For example, `Janice Examplesperson`.
  This can be overridden by individual projects with the <<custom-user-name-e-mail-address>> extension.

[[global-config-user-email]]
Global Config user.email Value::

  Defines the default git user e-mail that will be assigned when git commits a change from Jenkins.
  For example, `janice.examplesperson@example.com`.
  This can be overridden by individual projects with the <<custom-user-name-e-mail-address>> extension.

[[create-new-accounts-based-on-author-email]]
Create new accounts based on author/committer's email::

  New user accounts are created in Jenkins for committers and authors identified in changelogs.
  The new user accounts are added to the internal Jenkins database.
  The e-mail address is used as the id of the account.

[[show-the-entire-commit-summary-in-changes]]
Show the entire commit summary in changes::

  The `changes` page for each job would truncate the change summary prior to git plugin 4.0.
  With the release of git plugin 4.0, the default was changed to show the complete change summary.
  Administrators that want to restore the old behavior may disable this setting.

[[hide-credentials]]
Hide credential usage in job output::

  If checked, the console log will not show the credential identifier used to clone a repository.

[[disable-performance-enhancements]]
Disable performance enhancements::

  If JGit and command line git are both enabled on an agent, the git plugin uses a ""git tool chooser"" to choose a preferred git implementation.
  The preferred git implementation depends on the size of the repository and the git plugin features requested by the job.
  If the repository size is *less than* the JGit repository size threshold and the git features of the job are all implmented in JGit, then JGit is used.
  If the repository size is *greater than* the JGit repository size threshold or the job requires git features that are not implemented in JGit, then command line git is used.
+
If checked, the plugin will disable the feature that recommends a git implementation on the basis of the size of a repository.
This switch may be used in case of a bug in the performance improvement feature.
If you enable this setting, please report a git plugin issue that describes why you needed to enable it.

[[preserve-second-fetch-during-checkout]]
Preserve second fetch during initial checkout::

  If checked, the initial checkout step will not avoid the second fetch.
  Git plugin versions prior to git plugin 4.4 would perform two fetch operations during the initial repository checkout.
  Git plugin 4.4 removes the second fetch operation in most cases.
  Enabling this option will restore the second fetch operation.
  This setting is only needed if there is a bug in the redundant fetch removal logic.
  If you enable this setting, please report a git plugin issue that describes why you needed to enable it.

[[do-not-add-git-tag-action-to-jobs]]
Add git tag action to jobs::

  If checked, the git tag action will be added to any builds that happen *after* the box is checked.
  Prior to git plugin 4.5.0, the git tag action was always added.
  Git plugin 4.5.0 and later will not add the git tag action to new builds unless the administrator enables it.
+
The git tag action allows a user to apply a tag to the git repository in the workspace based on the git commit used in the build applying the tag.
The git plugin does *not* push the applied tag to any other location.
If the workspace is removed, the tag that was applied is lost.
Tagging a workspace made sense when using centralized repositories that automatically applied the tag to the centralized repository.
Applying a git tag in an agent workspace doesn't have many practical uses.

[#repository-browser]
=== Repository Browser

image:/images/git-repository-browser.png[Repository Browser]

A Repository Browser adds links in ""changes"" views within Jenkins to an external system for browsing the details of those changes.
The ""Auto"" selection attempts to infer the repository browser from the ""Repository URL"" and can detect cloud versions of GitHub, Bitbucket and GitLab.

Repository browsers include:

[#assemblaweb-repository-browser]
==== AssemblaWeb

image:/images/git-repository-browser-assemblaweb.png[Assembla Repository Browser]

Repository browser for git repositories hosted by link:https://www.assembla.com/home[Assembla].
Options include:

[[assembla-git-url]]
Assembla Git URL::

  Root URL serving this Assembla repository.
  For example, `\\https://app.assembla.com/spaces/git-plugin/git/source`

[#fisheye-repository-browser]
==== FishEye

image:/images/git-repository-browser-fisheye.png[FishEye Repository Browser]

Repository browser for git repositories hosted by link:https://www.atlassian.com/software/fisheye[Atlassian Fisheye].
Options include:

[[fisheye-url]]
URL::

  Root URL serving this FishEye repository.
  For example, `\\https://fisheye.example.com/browser/my-project`

[#kiln-repository-browser]
==== Kiln

image:/images/git-repository-browser-kiln.png[Kiln Repository Browser]

Repository browser for git repositories hosted by link:http://www.fogbugz.com/version-control[Kiln].
Options include:

[[kiln-url]]
URL::

  Root URL serving this Kiln repository.
  For example, `\\https://kiln.example.com/username/my-project`

[#visual-studio-team-services-repository-browser]
==== Microsoft Team Foundation Server/Visual Studio Team Services

image:/images/git-repository-browser-microsoft.png[Microsoft Repository Browser]

Repository browser for git repositories hosted by link:https://azure.microsoft.com/en-us/solutions/devops/[Azure DevOps].
Options include:

[[visual-studio-repository-url-or-name]]
URL or name::

  Root URL serving this Azure DevOps repository.
  For example, `\\https://example.visualstudio.com/_git/my-project.`

[bitbucketweb-repository-browser]
==== bitbucketweb

image:/images/git-repository-browser-bitbucket.png[Bitbucket Repository Browser]

Repository browser for git repositories hosted by link:https://bitbucket.org/[Bitbucket].
Options include:

[[bitbucketweb-url]]
URL::

  Root URL serving this Bitbucket repository.
  For example, `\\https://bitbucket.example.com/username/my-project`

[bitbucketserver-repository-browser]
==== bitbucketserver

image:/images/git-repository-browser-bitbucketserver.png[Bitbucket Server Repository Browser]

Repository browser for git repositories hosted by an on-premises Bitbucket Server installation.
Options include:

[[bitbucketserver-url]]
URL::

  Root URL serving this Bitbucket repository.
  For example, `\\https://bitbucket-server:7990/username/my-project`

[#cgit-repository-browser]
==== cgit

image:/images/git-repository-browser-cgit.png[CGit Repository Browser]

Repository browser for git repositories hosted by link:https://git.zx2c4.com/cgit/[cgit].
Options include:

[[cgit-url]]
URL::

  Root URL serving this cgit repository.
  For example, `\\https://git.zx2c4.com/cgit/`

[#gitblit-repository-browser]
==== gitblit

image:/images/git-repository-browser-gitblit.png[GitBlit Repository Browser]

[[gitblit-url]]
GitBlit root url::

  Root URL serving this GitBlit repository.
  For example, `\\https://gitblit.example.com/`

[[gitblit-project-name]]
Project name in GitBlit::

  Name of the GitBlit project.
  For example, `my-project`

[#githubweb-repository-browser]
==== githubweb

image:/images/git-repository-browser-github.png[GitHub Repository Browser]

Repository browser for git repositories hosted by link:https://github.com//[GitHub].
Options include:

[[githubweb-url]]
URL::

  Root URL serving this GitHub repository.
  For example, `\\https://github.example.com/username/my-project`

[#gitiles-repository-browser]
==== gitiles

image:/images/git-repository-browser-gitiles.png[Gitiles Repository Browser]

Repository browser for git repositories hosted by link:https://gerrit.googlesource.com/gitiles/[Gitiles].
Options include:

[[githubweb-url]]
gitiles root url::

  Root URL serving this Gitiles repository.
  For example, `\\https://gerrit.googlesource.com/gitiles/`

[#gitlab-self-hosted-repository-browser]
[#gitlab-com-repository-browser]
==== gitlab

image:/images/git-repository-browser-gitlab.png[GitLab Repository Browser]

Repository browser for git repositories hosted by link:https://gitlab.com/[GitLab].
Options include:

[[gitlab-url]]
URL::

  Root URL serving this GitLab repository.
  For example, `\\https://gitlab.example.com/username/my-project`

[[gitlab-version]]
Version::

  Major and minor version of GitLab you use, such as 12.6.
  If you don't specify a version, a modern version of GitLab (>= 8.0) is assumed.
  For example, `12.6`

[#gitlist-repository-browser]
==== gitlist

image:/images/git-repository-browser-gitlist.png[Gitlist Repository Browser]

Repository browser for git repositories hosted by link:https://gitlist.org/[GitList].
Options include:

[[gitlist-url]]
URL::

  Root URL serving this GitList repository.
  For example, `\\https://gitlist.example.com/username/my-project`

[#gitoriousweb-repository-browser]
==== gitoriousweb

Gitorious was acquired in 2015.
This browser is *deprecated*.

[[gitoriousweb-url]]
URL::

  Root URL serving this Gitorious repository.
  For example, `\\https://gitorious.org/username/my-project`

[#gitweb-repository-browser]
==== gitweb

image:/images/git-repository-browser-gitweb.png[Gitweb Repository Browser]

Repository browser for git repositories hosted by link:https://git-scm.com/docs/gitweb[GitWeb].
Options include:

[[gitweb-url]]
URL::

  Root URL serving this GitWeb repository.
  For example, `\\https://gitweb.example.com/username/my-project`

[#gogs-repository-browser]
==== gogs

image:/images/git-repository-browser-gogs.png[Gogs Repository Browser]

Repository browser for git repositories hosted by link:https://gogs.io/[Gogs].
Options include:

[[gogs-url]]
URL::

  Root URL serving this Gogs repository.
  For example, `\\https://gogs.example.com/username/my-project`

[#phabricator-repository-browser]
==== phabricator

image:/images/git-repository-browser-phabricator.png[Phabricator Repository Browser]

Repository browser for git repositories hosted by link:https://www.phacility.com/phabricator/[Phacility Phabricator].
Options include:

[[phabricator-url]]
URL::

  Root URL serving this Phabricator repository.
  For example, `\\https://phabricator.example.com/`

[[phabricator-repository-name]]
Repository name in Phab::

  Name of the Phabricator repository.
  For example, `my-project`

[#redmineweb-repository-browser]
==== redmineweb

image:/images/git-repository-browser-redmine.png[Redmine Repository Browser]

Repository browser for git repositories hosted by link:https://www.redmine.org/[Redmine].
Options include:

[[redmineweb-url]]
URL::

  Root URL serving this Redmine repository.
  For example, `\\https://redmine.example.com/username/projects/my-project/repository`

[#rhodecode-repository-browser]
==== rhodecode

image:/images/git-repository-browser-rhodecode.png[RhodeCode Repository Browser]

Repository browser for git repositories hosted by link:https://thodecode.com/[RhodeCode].
Options include:

[[rhodecode-url]]
URL::

  Root URL serving this RhodeCode repository.
  For example, `\\https://rhodecode.example.com/username/my-project`

[#stash-repository-browser]
==== stash

image:/images/git-repository-browser-stash.png[Stash Repository Browser]

Stash is now called *BitBucket Server*.
Repository browser for git repositories hosted by link:https://www.atlassian.com/software/bitbucket[BitBucket Server].
Options include:

[[stash-url]]
URL::

  Root URL serving this Stash repository.
  For example, `\\https://stash.example.com/username/my-project`

[#viewgit-repository-browser]
==== viewgit

image:/images/git-repository-browser-viewgit.png[Viewgit Repository Browser]

Repository browser for git repositories hosted by link:https://www.openhub.net/p/viewgit[viewgit].
Options include:

[[viewgit-root-url]]
ViewGit root url::

  Root URL serving this ViewGit repository.
  For example, `\\https://viewgit.example.com/`

[[viewgit-project-name]]
Project Name in ViewGit::

  ViewGit project name.
  For example, `my-project`

[#extensions]
== Extensions

Extensions add new behavior or modify existing plugin behavior for different uses.
Extensions help users more precisely tune the plugin to meet their needs.

Extensions include:

- <<clone-extensions>>
- <<checkout-extensions>>
- <<changelog-extensions>>
- <<tagging-extensions>>
- <<build-initiation-extensions>>
- <<merge-extensions>>
- <<deprecated-extensions>>

[#clone-extensions]
=== Clone Extensions

Clone extensions modify the git operations that retrieve remote changes into the agent workspace.
The extensions can adjust the amount of history retrieved, how long the retrieval is allowed to run, and other retrieval details.

[#advanced-clone-behaviours]
==== Advanced clone behaviours

image:/images/git-advanced-clone-behaviours.png[Advanced clone behaviours]

Advanced clone behaviors modify the `link:https://git-scm.com/docs/git-clone[git clone]` and `link:https://git-scm.com/docs/git-fetch[git fetch]` commands.
They control:

* breadth of history retrieval (refspecs)
* depth of history retrieval (shallow clone)
* disc space use (reference repositories)
* duration of the command (timeout)
* tag retrieval

Advanced clone behaviors include:

[[honor-refspec-on-initial-clone]]
Honor refspec on initial clone::

  Perform initial clone using the refspec defined for the repository.
  This can save time, data transfer and disk space when you only need to access the references specified by the refspec.
  If this is not enabled, then the plugin default refspec includes **all** remote branches.

Shallow clone::

  Perform a shallow clone by requesting a limited number of commits from the tip of the requested branch(es).
  Git will not download the complete history of the project.
  This can save time and disk space when you just want to access the latest version of a repository.

Shallow clone depth::

  Set shallow clone depth to the specified number of commits.
  Git will only download `depth` commits from the remote repository, saving time and disk space.

Path of the reference repo to use during clone::

  Specify a folder containing a repository that will be used by git as a reference during clone operations.
  This option will be ignored if the folder is not available on the agent.

Timeout (in minutes) for clone and fetch operations::

  Specify a timeout (in minutes) for clone and fetch operations.

Fetch tags::

  Deselect this to perform a clone without tags, saving time and disk space when you want to access only what is specified by the refspec, without considering any repository tags.

[#prune-stale-remote-tracking-branches]
==== Prune stale remote tracking branches

image:/images/git-prune-stale-remote-tracking-branches.png[Prune stale remote tracking branches]

Removes remote tracking branches from the local workspace if they no longer exist on the remote.
See `link:https://git-scm.com/docs/git-remote#Documentation/git-remote.txt-empruneem[git remote prune]` and `link:https://git-scm.com/docs/git-fetch#_pruning[git fetch --prune]` for more details.

[#prune-stale-tags]
==== Prune stale tags

image:/images/git-prune-stale-tags.png[Prune stale tags]

Removes tags from the local workspace before fetch if they no longer exist on the remote.
If stale tags are not pruned, deletion of a remote tag will not remove the local tag in the workspace.
If the local tag already exists in the workspace, git correctly refuses to create the tag again.
Pruning stale tags allows the local workspace to create a tag with the same name as a tag which was removed from the remote.

[#checkout-extensions]
=== Checkout Extensions

Checkout extensions modify the git operations that place files in the workspace from the git repository on the agent.
The extensions can adjust the maximum duration of the checkout operation, the use and behavior of git submodules, the location of the workspace on the disc, and more.

[#advanced-checkout-behaviors]
==== Advanced checkout behaviors

image:/images/git-advanced-checkout-behaviors.png[Advanced checkout behaviors]

Advanced checkout behaviors modify the `link:https://git-scm.com/docs/git-checkout[git checkout]` command.
Advanced checkout behaviors include

Timeout (in minutes) for checkout operation::

  Specify a timeout (in minutes) for checkout.
  The checkout is stopped if the timeout is exceeded.
  Checkout timeout is usually only required with slow file systems or large repositories.

[#advanced-sub-modules-behaviours]
==== Advanced sub-modules behaviours

image:/images/git-advanced-sub-modules-behaviours.png[Advanced sub-modules behaviours]

Advanced sub-modules behaviors modify the `link:https://git-scm.com/docs/git-submodule[git submodule]` commands.
They control:

* depth of history retrieval (shallow clone)
* disc space use (reference repositories)
* credential use
* duration of the command (timeout)
* concurrent threads used to fetch submodules

Advanced sub-modules include:

Disable submodules processing::

  Ignore submodules in the repository.

Recursively update submodules::

  Retrieve all submodules recursively. Without this option, submodules
  which contain other submodules will ignore the contained submodules.

Update tracking submodules to tip of branch::

  Retrieve the tip of the configured branch in .gitmodules.

Use credentials from default remote of parent repository::

  Use credentials from the default remote of the parent project.
  Submodule updates do not use credentials by default.
  Enabling this extension will provide the parent repository credentials to each of the submodule repositories.
  Submodule credentials require that the submodule repository must accept the same credentials as the parent project.
  If the parent project is cloned with https, then the authenticated submodule references must use https as well.
  If the parent project is cloned with ssh, then the authenticated submodule references must use ssh as well.

Path of the reference repo to use during submodule update::

  Folder containing a repository that will be used by git as a reference during submodule clone operations.
  This option will be ignored if the folder is not available on the agent running the build.
  A reference repository may contain multiple subprojects.
  See the combining repositories section for more details.

Timeout (in minutes) for submodule operations::

  Specify a timeout (in minutes) for submodules operations.
  This option overrides the default timeout.

Number of threads to use when updating submodules::

  Number of parallel processes to be used when updating submodules.
  Default is to use a single thread for submodule updates

Shallow clone::

  Perform shallow clone of submodules.
  Git will not download the complete history of the project, saving time and disk space.

Shallow clone depth::

  Set shallow clone depth for submodules.
  Git will only download recent history of the project, saving time and disk space.

[#checkout-to-a-sub-directory]
==== Checkout to a sub-directory

image:/images/git-checkout-to-a-sub-directory.png[Checkout to a sub-directory]

Checkout to a subdirectory of the workspace instead of using the workspace root.

This extension should **not** be used in Jenkins Pipeline (either declarative or scripted).
Jenkins Pipeline already provides standard techniques for checkout to a subdirectory.
Use `ws` and `dir` in Jenkins Pipeline rather than this extension.

Local subdirectory for repo::

  Name of the local directory (relative to the workspace root) for the git repository checkout.
  If left empty, the workspace root itself will be used.

[#checkout-to-specific-local-branch]
==== Checkout to specific local branch

image:/images/git-checkout-to-specific-local-branch.png[Checkout to specific local branch]

Branch name::

  If given, checkout the revision to build as HEAD on the named branch.
  If value is an empty string or ""**"", then the branch name is computed from the remote branch without the origin.
  In that case, a remote branch 'origin/master' will be checked out to a local branch named 'master', and a remote branch 'origin/develop/new-feature' will be checked out to a local branch named 'develop/new-feature'.
  If a specific revision and not branch HEAD is checked out, then 'detached' will be used as the local branch name.

[#wipe-out-repository-and-force-clone]
==== Wipe out repository and force clone

image:/images/git-wipe-out-repository-and-force-clone.png[Wipe out repository and force clone]

Delete the contents of the workspace before build and before checkout.
Deletes the git repository inside the workspace and will force a full clone.

[clean-after-checkout]
==== Clean after checkout

image:/images/git-clean-after-checkout.png[Clean after checkout]

Clean the workspace *after* every checkout by deleting all untracked files and directories, including those which are specified in `.gitignore`.
Resets all tracked files to their versioned state.
Ensures that the workspace is in the same state as if clone and checkout were performed in a new workspace.
Reduces the risk that current build will be affected by files generated by prior builds.
Does not remove files outside the workspace (like temporary files or cache files).
Does not remove files in the `.git` repository of the workspace.

Delete untracked nested repositories::

  Remove subdirectories which contain `.git` subdirectories if this option is enabled.
  This is implemented in command line git as `git clean -xffd`.
  Refer to the link:https://git-scm.com/docs/git-clean[git clean manual page] for more information.

[#clean-before-checkout]
==== Clean before checkout

image:/images/git-clean-before-checkout.png[Clean before checkout]

Clean the workspace *before* every checkout by deleting all untracked files and directories, including those which are specified in .gitignore.
Resets all tracked files to their versioned state.
Ensures that the workspace is in the same state as if cloned and checkout were performed in a new workspace.
Reduces the risk that current build will be affected by files generated by prior builds.
Does not remove files outside the workspace (like temporary files or cache files).
Does not remove files in the `.git` repository of the workspace.

Delete untracked nested repositories::

  Remove subdirectories which contain `.git` subdirectories if this option is enabled.
  This is implemented in command line git as `git clean -xffd`.
  Refer to the link:https://git-scm.com/docs/git-clean[git clean manual page] for more information.

[#sparse-checkout-paths]
==== Sparse checkout paths

image:/images/git-sparse-checkout-paths.png[Sparse checkout paths]

Specify the paths that you'd like to sparse checkout.
This may be used for saving space (Think about a reference repository).
Be sure to use a recent version of Git, at least above 1.7.10.

Multiple sparse checkout path values can be added to a single job.

Path::

  File or directory to be included in the checkout

[#git-lfs-pull-after-checkout]
==== Git LFS pull after checkout

image:/images/git-lfs-pull-after-checkout.png[Git LFS pull after checkout]

Enable https://git-lfs.github.com/[git large file support] for the workspace by pulling large files after the checkout completes.
Requires that the controller and each agent performing an LFS checkout have installed `git lfs`.

[#changelog-extensions]
=== Changelog Extensions

The plugin can calculate the source code differences between two builds.
Changelog extensions adapt the changelog calculations for different cases.

[#calculate-changelog-against-a-specific-branch]
==== Calculate changelog against a specific branch

image:/images/git-calculate-changelog-against-a-specific-branch.png[Calculate changelog against a specific branch]

'Calculate changelog against a specific branch' uses the specified branch to compute the changelog instead of computing it based on the previous build.
This extension can be useful for computing changes related to a known base branch, especially in environments which do not have the concept of a ""pull request"".

Name of repository::

  Name of the repository, such as 'origin', that contains the branch.

Name of branch::

  Name of the branch used for the changelog calculation within the named repository.

[#use-commit-author-in-changelog]
==== Use commit author in changelog

image:/images/git-use-commit-author-in-changelog.png[Use commit author in changelog]

The default behavior is to use the Git commit's ""Committer"" value in build changesets.
If this option is selected, the git commit's ""Author"" value is used instead.

[#tagging-extensions]
=== Tagging Extensions

Tagging extensions allow the plugin to apply tags in the current workspace.

[#create-a-tag-for-every-build]
==== Create a tag for every build

image:/images/git-create-a-tag-for-every-build.png[Create a tag for every build]

Create a tag in the workspace for every build to unambiguously mark the commit that was built.
You can combine this with Git publisher to push the tags to the remote repository.

[#build-initiation-extensions]
=== Build Initiation Extensions

The git plugin can start builds based on many different conditions.
The build inititation extensions control the conditions that start a build.
They can ignore notifications of a change or force a deeper evaluation of the commits when polling

[#dont-trigger-a-build-on-commit-notifications]
==== Don't trigger a build on commit notifications

image:/images/git-do-not-trigger-a-build-on-commit-notifications.png[Do not trigger a build on commit notifications]

If checked, this repository will be ignored when the notifyCommit URL is accessed whether the repository matches or not.

[#force-polling-using-workspace]
==== Force polling using workspace

image:/images/git-force-polling-using-workspace.png[Force polling using workspace]

The git plugin polls remotely using `ls-remote` when configured with a single branch (no wildcards!).
When this extension is enabled, the polling is performed from a cloned copy of the workspace instead of using `ls-remote`.

If this option is selected, polling will use a workspace instead of using `ls-remote`.

By default, the plugin polls by executing a polling process or thread on the Jenkins controller.
If the Jenkins controller does not have a git installation, the administrator may <<enabling-jgit,enable JGit>> to use a pure Java git implementation for polling.
In addition, the administrator may need to <<GitPlugin-WhyNotJGit,disable command line git>> to prevent use of command line git on the Jenkins controller.

[#polling-ignores-commits-from-certain-users]
==== Polling ignores commits from certain users

image:/images/git-polling-ignores-commits-from-certain-users.png[Polling ignores commits from certain users]

These options allow you to perform a merge to a particular branch before building.
For example, you could specify an integration branch to be built, and to merge to master.
In this scenario, on every change of integration, Jenkins will perform a merge with the master branch, and try to perform a build if the merge is successful.
It then may push the merge back to the remote repository if the Git Push post-build action is selected.

Excluded Users::

  If set and Jenkins is configured to poll for changes, Jenkins will ignore any revisions committed by users in this list when determining if a build should be triggered.
  This can be used to exclude commits done by the build itself from triggering another build, assuming the build server commits the change with a distinct SCM user.
  Using this behavior prevents the faster `git ls-remote` polling mechanism.
  It forces polling to require a workspace, as if you had selected the <<force-polling-using-workspace,Force polling using workspace>> extension.

  Each exclusion uses exact string comparison and must be separated by a new line.
  User names are only excluded if they exactly match one of the names in this list.

[#polling-ignores-commits-in-certain-paths]
==== Polling ignores commits in certain paths

image:/images/git-polling-ignores-commits-in-certain-paths.png[Polling ignores commits in certain paths]

If set and Jenkins is configured to poll for changes, Jenkins will pay attention to included and/or excluded files and/or folders when determining if a build needs to be triggered.

Using this behavior will preclude the faster remote polling mechanism, forcing polling to require a workspace thus sometimes triggering unwanted builds, as if you had selected the <<force-polling-using-workspace,Force polling using workspace>> extension as well.
This can be used to exclude commits done by the build itself from triggering another build, assuming the build server commits the change with a distinct SCM user.
Using this behavior will preclude the faster git ls-remote polling mechanism, forcing polling to require a workspace, as if you had selected the <<force-polling-using-workspace,Force polling using workspace>> extension as well.

Included Regions::

  Each inclusion uses java regular expression pattern matching, and must be separated by a new line.
  An empty list implies that everything is included.

Excluded Regions::

  Each exclusion uses java regular expression pattern matching, and must be separated by a new line.
  An empty list excludes nothing.

[#polling-ignores-commits-with-certain-messages]
==== Polling ignores commits with certain messages

image:/images/git-polling-ignores-commits-with-certain-messages.png[Polling ignores commits with certain messages]

Excluded Messages::

  If set and Jenkins is set to poll for changes, Jenkins will ignore any revisions committed with message matched to the regular expression pattern when determining if a build needs to be triggered.
  This can be used to exclude commits done by the build itself from triggering another build, assuming the build server commits the change with a distinct message.
  You can create more complex patterns using embedded flag expressions.

[#strategy-for-choosing-what-to-build]
==== Strategy for choosing what to build

image:/images/git-strategy-for-choosing-what-to-build.png[Strategy for choosing what to build]

When you are interested in using a job to build multiple branches, you can choose how Jenkins chooses the branches to build and the order they should be built.

This extension point in Jenkins is used by many other plugins to control the job as it builds specific commits.
When you activate those plugins, you may see them installing a custom build strategy.

Ancestry::

Maximum Age of Commit::

  The maximum age of a commit (in days) for it to be built.
  This uses the GIT_COMMITTER_DATE, not GIT_AUTHOR_DATE

Commit in Ancestry::

  If an ancestor commit (SHA-1) is provided, only branches with this commit in their history will be built.

Default::

  Build all the branches that match the branch name pattern.

Inverse::

  Build all branches except for those which match the branch specifiers configure above.
  This is useful, for example, when you have jobs building your master and various release branches and you want a second job which builds all new feature branches.
  For example, branches which do not match these patterns without redundantly building master and the release branches again each time they change.

[#merge-extensions]
=== Merge Extensions

The git plugin can optionally merge changes from other branches into the current branch of the agent workspace.
Merge extensions control the source branch for the merge and the options applied to the merge.

[#merge-before-build]
==== Merge before build

image:/images/git-merge-before-build.png[Merge before build]

These options allow you to perform a merge to a particular branch before building.
For example, you could specify an integration branch to be built, and to merge to master.
In this scenario, on every change of integration, Jenkins will perform a merge with the master branch, and try to perform a build if the merge is successful.
It then may push the merge back to the remote repository if the <<publisher-push-merge-results,Git Publisher post-build action>> is selected.

Name of repository::

  Name of the repository, such as origin, that contains the branch. If
  left blank, it'll default to the name of the first repository
  configured.

Branch to merge to::

  The name of the branch within the named repository to merge to, such as
  master.

Merge strategy::

  Merge strategy selection. Choices include:

* default
* resolve
* recursive
* octopus
* ours
* subtree
* recursive_theirs

Fast-forward mode::

* `--ff`: fast-forward which gracefully falls back to a merge commit when required
* `-ff-only`: fast-forward without any fallback
* `--no-ff`: merge commit always, even if a fast-forward would have been allowed

[#custom-user-name-e-mail-address]
==== Custom user name/e-mail address

image:/images/git-custom-user-name-e-mail-address.png[Custom user name/e-mail address]

user.name::

  Defines the user name value which git will assign to new commits made in the workspace.
  If given, the environment variables `GIT_COMMITTER_NAME` and `GIT_AUTHOR_NAME` are set for builds and override values from the global settings.

user.email::

  Defines the user email value which git will assign to new commits made in the workspace.
  If given, the environment variables `GIT_COMMITTER_EMAIL` and `GIT_AUTHOR_EMAIL` are set for builds and override values from the global settings.

[#deprecated-extensions]
=== Deprecated Extensions

[#custom-scm-name---deprecated]
==== Custom SCM name - *Deprecated*

Unique name for this SCM.
Was needed when using Git within the Multi SCM plugin.
Pipeline is the robust and feature-rich way to checkout from multiple repositories in a single job.

[#submodule-combinator---removed]
==== Submodule Combinator - *Removed*

An experiment was created many years ago that attempted to create combinations of submodules within the Jenkins job.
The experiment was never available to Freestyle projects or other legacy projects like multi-configuration projects.
It was visible in Pipeline, configuration as code, and JobDSL.

The implementation of the experiment has been removed.
Dependabot and other configuration tools are better suited to evaluate submodule combinations.

There are no known uses of the submodule combinator and no open Jira issues reported against the submodule combinator.
Those who were using submodule combinator should remain with git plugin versions prior to 4.6.0.

The submodule combinator ignores any user provided value of the following arguments to git's `checkout scm`:

doGenerateSubmoduleConfigurations::

  A boolean that is now always set to `false`.
  Submodule configurations are no longer evaluated by the git plugin.

submoduleCfg::

  A list of submodule names and branches that is now always empty.
  Submodule configurations are no longer evaluated by the git plugin.

Previous Pipeline syntax looked like this:

```groovy
checkout([$class: 'GitSCM',
          branches: [[name: 'master']],
          doGenerateSubmoduleConfigurations: false,
          extensions: [],
          submoduleCfg: [],
          userRemoteConfigs: [[url: 'https://github.com/jenkinsci/git-plugin']]])
```

Current Pipeline Syntax looks like this:

```groovy
checkout([$class: 'GitSCM',
          branches: [[name: 'master']],
          extensions: [],
          userRemoteConfigs: [[url: 'https://github.com/jenkinsci/git-plugin']]])
```

[#environment-variables]
== Environment Variables

The git plugin assigns values to environment variables in several contexts.
Environment variables are assigned in Freestyle, Pipeline, Multibranch Pipeline, and Organization Folder projects.

[#branch-variables]
=== Branch Variables

GIT_BRANCH:: Name of branch being built including remote name, as in `origin/master`
GIT_LOCAL_BRANCH:: Name of branch being built without remote name, as in `master`

[#commit-variables]
=== Commit Variables

GIT_COMMIT:: SHA-1 of the commit used in this build
GIT_PREVIOUS_COMMIT:: SHA-1 of the commit used in the preceding build of this project
GIT_PREVIOUS_SUCCESSFUL_COMMIT:: SHA-1 of the commit used in the most recent successful build of this project

[#system-configuration-variables]
=== System Configuration Variables

GIT_URL:: Remote URL of the first git repository in this workspace
GIT_URL_n:: Remote URL of the additional git repositories in this workspace (if any)
GIT_AUTHOR_EMAIL:: Author e-mail address that will be used for **new commits in this workspace**
GIT_AUTHOR_NAME:: Author name that will be used for **new commits in this workspace**
GIT_COMMITTER_EMAIL:: Committer e-mail address that will be used for **new commits in this workspace***
GIT_COMMITTER_NAME:: Committer name that will be used for **new commits in this workspace**

[#properties]
== Properties

Some git plugin settings can only be controlled from command line properties set at Jenkins startup.

[#default-timeout]
=== Default Timeout

The default git timeout value (in minutes) can be overridden by the `org.jenkinsci.plugins.gitclient.Git.timeOut` property (see https://issues.jenkins.io/browse/JENKINS-11286[JENKINS-11286]).
The property should be set on the controller and on all agents to have effect (see https://issues.jenkins.io/browse/JENKINS-22547[JENKINS-22547]).

[[GitPlugin-WhyNotJGit]]
Command line git is the reference git implementation in the git plugin and the git client plugin.
Command line git provides the most functionality and is the most stable implementation.
Some installations may not want to install command line git and may want to disable the command line git implementation.
Administrators may disable command line git with the property `org.jenkinsci.plugins.gitclient.Git.useCLI=false`.

[#git-publisher]
== Git Publisher

The Jenkins git plugin provides a ""git publisher"" as a post-build action.
The git publisher can push commits or tags from the workspace of a Freestyle project to the remote repository.

The git publisher is **only available** for Freestyle projects.
It is **not available** for Pipeline, Multibranch Pipeline, Organization Folder, or any other job type other than Freestyle.

[#git-publisher-options]
=== Git Publisher Options

The git publisher behaviors are controlled by options that can be configured as part of the Jenkins job.
Options include;

Push Only If Build Succeeds::

  Only push changes from the workspace to the remote repository if the build succeeds.
  If the build status is unstable, failed, or canceled, the changes from the workspace will not be pushed.

[[publisher-push-merge-results]]
Merge Results::

  If pre-build merging is configured through one of the <<merge-extensions,merge extensions>>, then enabling this checkbox will push the merge to the remote repository.

[[publisher-tag-force-push]]
Force Push::

  Git refuses to replace a remote commit with a different commit.
  This prevents accidental overwrite of new commits on the remote repository.
  However, there may be times when overwriting commits on the remote repository is acceptable and even desired.
  If the commits from the local workspace should overwrite commits on the remote repository, enable this option.
  It will request that the remote repository destroy history and replace it with history from the workspace.

[#git-publisher-tags-options]
==== Git publisher tags options

The git publisher can push tags from the workspace to the remote repository.
Options in this section will allow the plugin to create a new tag.
Options will also allow the plugin to update an existing tag, though the link:https://git-scm.com/docs/git-tag#_on_re_tagging[git documentation] **strongly advises** against updating tags.

Tag to push::

  Name of the tag to be pushed from the local workspace to the remote repository.
  The name may include link:https://jenkins.io/doc/book/pipeline/jenkinsfile/#using-environment-variables[Jenkins environment variables] or may be a fixed string.
  For example, the tag to push might be `$BUILD_TAG`, `my-tag-$BUILD_NUMBER`, `build-$BUILD_NUMBER-from-$NODE_NAME`, or `a-very-specific-string-that-will-be-used-once`.

Tag message::

  If the option is selected to create a tag or update a tag, then this message will be associated with the tag that is created.
  The message will expand references to link:https://jenkins.io/doc/book/pipeline/jenkinsfile/#using-environment-variables[Jenkins environment variables].
  For example, the message `Build $BUILD_NUMBER tagged on $NODE_NAME` will use the message `Build 1 tagged on special-agent` if build 1 of the job runs on an agent named 'special-agent'.

Create new tag::

  Create a new tag in the workspace.
  The git publisher will fail the job if the tag already exists.

Update new tag::

  Modify existing tag in the workspace so that it points to the most recent commit.
  Many git repository hosting services will reject attempts to push a tag which has been modified to point to a different commit than its original commit.
  Refer to <<publisher-tag-force-push,force push>> for an option which may force the remote repository to accept a modified tag.
  The link:https://git-scm.com/docs/git-tag#_on_re_tagging[git documentation] **strongly advises against updating tags**.

Tag remote name::

  Git uses the 'remote name' as a short string replacement for the full URL of the remote repository.
  This option defines which remote should receive the push.
  This is typically `origin`, though it could be any one of the remote names defined when the plugin performs the checkout.

[#git-publisher-branches-options]
==== Git publisher branches options

The git publisher can push branches from the workspace to the remote repository.
Options in this section will allow the plugin to push the contents of a local branch to the remote repository.

Branch to push::

  The name of the remote branch that will receive the latest commits from the agent workspace.
  This is usually the same branch that was used for the checkout

Target remote name::

  The shortname of the remote that will receive the latest commits from the agent workspace.
  Usually this is `origin`.
  It needs to be a shortname that is defined in the agent workspace, either through the initial checkout or through later configuration.

Rebase before push::

  Some Jenkins jobs may be blocked from pushing changes to the remote repository because the remote repository has received new commits since the start of the job.
  This may happen with projects that receive many commits or with projects that have long running jobs.
  The `Rebase before push` option fetches the most recent commits from the remote repository, applies local changes over the most recent commits, then pushes the result.
  The plugin uses `git rebase` to apply the local changes over the most recent remote changes.
+
Because `Rebase before push` is modifying the commits in the agent workspace **after the job has completed**, it is creating a configuration of commits that has **not been evaluated by any Jenkins job**.
The commits in the local workspace have been evaluated by the job.
The most recent commits from the remote repository have not been evaluated by the job.
Users may find that the risk of pushing an untested configuration is less than the risk of delaying the visibility of the changes which have been evaluated by the job.

[#combining-repositories]
== Combining repositories

A single reference repository may contain commits from multiple repositories.
For example, if a repository named `parent` includes references to submodules `child-1` and `child-2`, a reference repository could be created to cache commits from all three repositories using the commands:

....
$ mkdir multirepository-cache.git
$ cd  multirepository-cache.git
$ git init --bare
$ git remote add parent https://github.com/jenkinsci/git-plugin
$ git remote add child-1 https://github.com/jenkinsci/git-client-plugin
$ git remote add child-2 https://github.com/jenkinsci/platformlabeler-plugin
$ git fetch --all
....

Those commands create a single bare repository with the current commits from all three repositories.
If that reference repository is used in the advanced clone options link:#clone-reference-repository-path[clone reference repository], it will reduce data transfer and disc use for the parent repository.
If that reference repository is used in the submodule options link:#submodule-reference-repository-path[clone reference repository], it will reduce data transfer and disc use for the submodule repositories.

[#bug-reports]
== Bug Reports

Report issues and enhancements in the
https://issues.jenkins.io[Jenkins issue tracker].

[#contributing-to-the-plugin]
== Contributing to the Plugin

Refer to link:CONTRIBUTING.adoc#contributing-to-the-git-plugin[contributing to the plugin] for contribution guidelines.
Refer to link:Priorities.adoc#git-plugin-development-priorities[plugin development priorities] for the prioritized list of development topics.

== Remove Git Plugin BuildsByBranch BuildData Script

This script is used to remove the static list of BuildsByBranch that is stored for each build by the Git Plugin.

This is a workaround for link:https://issues.jenkins.io/browse/JENKINS-19022[JENKINS-19022]

[source,groovy]
----
import hudson.matrix.*
import hudson.model.*

hudsonInstance = hudson.model.Hudson.instance
jobNames = hudsonInstance.getJobNames()
allItems = []
for (name in jobNames) {
  allItems += hudsonInstance.getItemByFullName(name)
}

// Iterate over all jobs and find the ones that have a hudson.plugins.git.util.BuildData
// as an action.
//
// We then clean it by removing the useless array action.buildsByBranchName
//

for (job in allItems) {
  println(""job: "" + job.name);
  def counter = 0;
  for (build in job.getBuilds()) {
    // It is possible for a build to have multiple BuildData actions
    // since we can use the Mulitple SCM plugin.
    def gitActions = build.getActions(hudson.plugins.git.util.BuildData.class)
    if (gitActions != null) {
      for (action in gitActions) {
        action.buildsByBranchName = new HashMap<String, Build>();
        hudson.plugins.git.Revision r = action.getLastBuiltRevision();
        if (r != null) {
          for (branch in r.getBranches()) {
            action.buildsByBranchName.put(branch.getName(), action.lastBuild)
          }
        }
        build.actions.remove(action)
        build.actions.add(action)
        build.save();
        counter++;
      }
    }
    if (job instanceof MatrixProject) {
      def runcounter = 0;
      for (run in build.getRuns()) {
        gitActions = run.getActions(hudson.plugins.git.util.BuildData.class)
        if (gitActions != null) {
          for (action in gitActions) {
            action.buildsByBranchName = new HashMap<String, Build>();
            hudson.plugins.git.Revision r = action.getLastBuiltRevision();
            if (r != null) {
              for (branch in r.getBranches()) {
                action.buildsByBranchName.put(branch.getName(), action.lastBuild)
              }
            }
            run.actions.remove(action)
            run.actions.add(action)
            run.save();
            runcounter++;
          }
        }
      }
      if (runcounter > 0) {
        println("" -->> cleaned: "" + runcounter + "" runs"");
      }
    }
  }
  if (counter > 0) {
    println(""-- cleaned: "" + counter + "" builds"");
  }
}
----
",12149,False,2018.9335372852697,median
"= NUStudy Developer Guide
:site-section: DeveloperGuide
:toc:
:toc-title:
:toc-placement: preamble
:sectnums:
:imagesDir: images
:stylesDir: stylesheets
:xrefstyle: full
ifdef::env-github[]
:tip-caption: :bulb:
:note-caption: :information_source:
:warning-caption: :warning:
endif::[]
:repoURL: https://github.com/AY1920S1-CS2103T-F11-4/main/tree/master

By: `AY1920S1-CS2103T-F11-4`      Since: `September 2019`      Licence: `MIT`

NUStudy is an application for managing three kinds of informational material: lecture notes, quizzes and revision tasks.
It helps users to prepare for exams and tests in university by facilitating their learning.

As a developer of NUStudy, this guide can help you understand the basic software architecture and design considerations
for its implementation so that you can start contributing in no time.

For any queries, simply <<ContactUs#, contact us>>.

== Setting up

Refer to the guide <<SettingUp#, here>>.

== Design

[[Design-Architecture]]
=== Architecture

The architecture diagram below gives an overall view of NUStudy's structure. Each component
will be explained in more detail in the coming sections.

.Architecture Diagram
image::ArchitectureDiagram.png[]

`Main` has two classes called link:{repoURL}/src/main/java/seedu/address/Main.java[`Main`] and link:{repoURL}/src/main/java/seedu/address/MainApp.java[`MainApp`].
It is responsible for initializing and shutting down the application, linking and cleaning up where necessary.

The `commons` package contains classes used by multiple other components, of which `LogsCenter` is important
as it is used for logging. The rest of NUStudy consists of four primary components.

* <<Design-Ui,*`UI`*>>: The UI of NUStudy.
* <<Design-Logic,*`Logic`*>>: The command executor.
* <<Design-Model,*`Model`*>>: Holds application data in memory.
* <<Design-Storage,*`Storage`*>>: Reads and writes data to disk.

Each of the four components defines its _API_ in an `interface` with the same name as the component
and exposes the API using a `{Component Name}Manager` class. For example, the `Logic` component
(see the class diagram given below) defines its API in the `Logic.java` interface and exposes its functionality
using the `LogicManager.java` class.

.Class Diagram of the Logic Component
image::LogicClassDiagram.png[]

[discrete]
==== Inter-component interaction

The sequence diagram below shows how the components interact with each other for the scenario where the user
issues the command `deletenote 1`.

.Component interactions for `delete 1` command
image::ArchitectureSequenceDiagram.png[]

[[Design-Ui]]
=== `UI`

// tag::UIClassDiagram[]
.Class diagram of the `UI` component
image::UiClassDiagram.png[]

.Detailed class diagram for `Panels` package
image::PanelPackageClassDiagram.png[]
// end::UIClassDiagram[]

_API:_ link:{repoURL}/src/main/java/seedu/address/ui/Ui.java[`Ui.java`]

The UI consists of a `MainWindow` that is made up of parts e.g.`CommandBox`, `ResultDisplay`,
`NoteListPanel`, `StatusBarFooter`, etc. All these, including the `MainWindow`, inherit from the abstract
`UiPart` class.

The `UI` component uses JavaFX. The layout of these UI parts are defined in matching `.fxml` files that are in the `src/main/resources/view` folder. For example, the layout of the link:{repoURL}/src/main/java/seedu/address/ui/MainWindow.java[`MainWindow`] is specified in link:{repoURL}/src/main/resources/view/MainWindow.fxml[`MainWindow.fxml`]

This component

* executes user commands using the `Logic` component.
* listens for changes to `Model` data so that the UI can be updated with the modified data.

[[Design-Logic]]
=== `Logic`

[[fig-LogicClassDiagram]]
.Class diagram of the `Logic` component
image::LogicClassDiagram.png[]

_API:_ link:{repoURL}/src/main/java/seedu/address/logic/Logic.java[`Logic.java`]

.  `Logic` uses the `AppDataParser` class to parse the user command.
.  This results in a `Command` object which is executed by the `LogicManager`.
.  The command execution can affect the `Model` (e.g. adding a person).
.  The result of the command execution is encapsulated as a `CommandResult` object which is passed back to the `Ui`.
.  In addition, the `CommandResult` object can also instruct the `Ui` to perform certain actions, such as displaying help to the user.

Given below is the sequence diagram for interactions within the `Logic` component for the `execute(""delete 1"")` API call.
The lifeline for `DeleteCommandParser` should end at the destroy marker × but due to a limitation of PlantUML, the lifeline reaches the end of diagram.

[[DeleteSequenceDiagram]]
.Interactions inside the `Logic` component for the `deletenote 1` command
image::DeleteSequenceDiagram.png[]

[[Design-Model]]
=== `Model`
// tag::ModelClassDiagram[]
.Class diagram of the `Model` component
image::ModelClassDiagram.png[]
// end::ModelClassDiagram[]

_API:_ link:{repoURL}/src/main/java/seedu/address/model/Model.java[`Model.java`]

The `Model` component is independent of the other three primary components of NUStudy.
It stores application data – notes, questions and revision tasks – as well as a `UserPrefs` object
representing the user's preferences. It also exposes an unmodifiable `ObservableList<Note>` that is bound to the UI,
so any data changes are immediately user-visible.

[[Design-Storage]]
=== `Storage`

.Class diagram of the `Storage` component
image::StorageClassDiagram.png[]

_API:_ link:{repoURL}/src/main/java/seedu/address/storage/Storage.java[`Storage.java`]

The `Storage` component reads and writes `UserPrefs` objects and NUStudy data in JSON format.

== Implementation

This section describes some finer details on how certain features are implemented.

// tag::lecimage[]
=== Image support for lecture notes

Usually, we do not learn best from just text; we rely on images that our minds can process more easily.
As such, implementing images in lecture notes is a very important feature for NUStudy.

Although some lecture notes have multiple images, it is always possible to combine them using
basic image editing software like the GNU Image Manipulation Program (GIMP) and Paint, so the implementation is
limited to at most one image per note. Having a common format for notes facilitates their retrieval through
the `findnote` command and aids a human user in remembering what the notes say.

==== Implementation

Instead of a custom class to represent an image, JavaFX's `scene.image.Image` is used instead.
This is out of necessity, since an `ImageView` is needed to display an image in the GUI and it requires
an `Image` object, not just a `String` path to the image. No significant coupling is introduced
by this choice because `Image` objects can exist without a GUI to display them.

The static method `selectImage()` in `AppUtil` opens up a dialog allowing the user to choose the necessary image.
This is possible because `FileChooser#showOpenDialog()`, which shows the dialog, can be fed an argument of `null`
instead of having to rely on a `Window` object, which is the domain of the `UI` module.

The aforementioned dialog returns `null` if it is closed
without choosing a file (i.e. clicking the close button). We interpret this as ""no change""
rather than ""no image"", i.e. `addnote` and `editnote` proceed as if `i/` was not provided.
If the ""no image"" interpretation was used, the user who decides to edit a lecture note's image
but then decides not to would be surprised to see the image disappear without warning.
Therefore the value `i/none` has to be explicitly provided in `editnote` to remove the image; `EditNoteDescriptor`
has the field `isImageRemoved` to track this.

We also defer image selection until after the title has been checked against existing lecture notes,
which saves time that would otherwise be wasted in navigating to the desired image.
This is accomplished using three things:

* the `finalizeImage()` method of the `Note` class, calling `selectImage()`
* the `needsImage` field of `Note`, which allows a one-time execution of `finalizeImage()`
* the `isImageReplaced` field of `EditNoteDescriptor`

.Sequence diagram for the execution of `EditNoteCommandParser`
image::ImageSelectionSequenceDiagram.png[]

The diagram above shows how `EditNoteCommandParser` creates an `EditNoteCommand`. It first
creates an `EditNoteDescriptor` to hold details of what changes in the note, setting the new
title (provided by the `t/` argument) and content (`c/`) as necessary. If `i/none` is present,
the `EditNoteDescriptor` is set to remove the image. If `i/` is provided, it is set to replace
the image. An `EditNoteCommand` containing the `EditNoteDescriptor` is finally returned for execution.

Images are only referenced, not embedded, in the JSON file holding application data. These references are
Uniform Resource Identifiers (URIs) of system files, e.g. `file:data/picture.png`. Since NUStudy is meant to be portable,
we cannot use absolute paths, since they would break when the images are moved or deleted. Instead we copy images
into application data using `finalizeImage()`, which points references to these local copies.
// end::lecimage[]

// tag::lecimagedc[]
==== Design considerations: where to place the image?

* _Alternative 1 (current choice):_ We show the images associated to each and every lecture note
in the first column, together with the title and content.
** Pros: This is easier to implement, for the code interfacing with FXML does not have to be written in places other
than those directly pertaining to notes. It also makes the note ""card"" (object representing the note)
self-contained.
** Cons: Scrolling through lecture notes, all with images, takes time, but this downside is alleviated
by the `findnote` command.
* _Alternative 2:_ We place *one* full note in the second column and only show a preview (the title and first words
of the content) in the first column.
** Pros: This behaviour is closer to notepad applications on mobile devices which show a list of notes.
It saves space in the list and gives more prominence to a selected note, turning it into a flash card.
** Cons: The second column, normally housing revision tasks, requires extra code to handle the display
of full notes. This may include a separate `NotePreview` class, or `Note` may have a variable toggling
between preview and full modes.

==== Design considerations: when to copy images into the local folder
* _Alternative 1 (current choice):_ We copy images when the command is executed, i.e. in `Command#execute()`.
** Pros: This effects a better separation of concerns – image selection is not execution of the command, while
copying can be a side effect of command execution. Individual command effects can be fine-tuned.
** Cons: Each command that copies images needs to have its own code implementing the copy. To reduce code
duplication, that common code can be written as a method of the `Note` class requiring a `Path` object representing
the destination folder for the copy.
* _Alternative 2:_ We copy images when the image is selected, i.e. in `AppUtil#selectImage()`.
** Pros: Compared to alternative 1, this takes less time between image selection and writing into
application data, minimising the chance of exceptions due to changes in the file system (permissions,
existence of the file at the specified path, etc.) being raised.
** Cons: `selectImage()` has two only loosely related responsibilities in this alternative, which is
a worse separation of concerns. It is impossible to take into account user preferences at the point of image
selection, since it requires a `Model` object which is not available to `AppUtil#selectImage()`.
// end::lecimagedc[]

// tag::questiond[]
=== Question management feature
==== Current implementation

The question management feature is facilitated by `Model`.
The question-related commands extend `Command` with the question object if necessary.
The commands update the `Model` which is implemented by `ModelManager`.
This in turn updates `AppData` which stores all the questions internally as `UniqueQuestionList`.
Local data will be updated in the end by `LogicManager`.
The commands include:

* `AddQuestionCommand` -- Adds a new question to the app.
* `DeleteQuestionCommand` -- Deletes an existing question in the app.
* `ListQuestionCommand` -- Views the list of all questions available.
* `EditQuestionCommand` -- Edits an existing question in the app. (to be implemented)
* `FindQuestionCommand` -- Finds a question with a specified keyword. (to be implemented)

These operations are exposed in the `Model` interface as `Model#addQuestion(Question question)`,
`Model#deleteQuestion(Question question)`, `Model#getFilteredQuestionList()` and
`Model#setQuestion(Question target, Question editedQuestion)` respectively.

Given below is an example usage scenario and how the question mechanism behaves at each step.

Step 1. The user launches the application for the first time. The app will load all existing information from storage.

Step 2. The user executes `addq q/QUESTION a/ANSWER s/SUBJECT d/DIFFICULTY` command to add a new question to the app.
The `addq` command calls `Model#addQuestion(Question question)`, causing the `AppData` to be updated with the new question.

Step 3. The user executes `deleteq 5` command to delete the 5th question in the app. The `deleteq` command calls `Model#deleteQuestion(Question target)`
and `Model#updateFilteredQuestionList(Predicate<Question> predicate)`, causing the `AppData` to be updated with the
target question removed.

Step 4. The user executes `editq 2 a/NEW_ANSWER` command to edit the answer of the 2nd question in the app.
The `editq` command calls `Model#setQuestion(Question target, Question editedQuestion)` and
`Model#updateFilteredQuestionList(Predicate<Question> predicate)`, causing the `AppData` to be updated with the original
question being replaced by the edited question.

The following sequence diagram shows the interaction between classes when `EditQuestionCommand#execute(model)` is called:

.Sequence diagram for `execute(Model)` of `EditQuestionCommand`
image::EditQuestionCommandExecuteSequenceDiagram.png[width = ""600""]

The following activity diagram summarizes what happens when a user executes a new `addq` command:

.Activity diagram for `addq` command
image::AddQuestionActivityDiagram.png[width = ""300""]

Question is implemented as a concrete class with its relevant fields consist of `QuestionBody`, `Answer`,
`Subject`, and `Difficulty`.

The following class diagram illustrates how `Question` class is designed:

.Class diagram for `Question`
image::QuestionClassDiagram.png[width = ""500""]

===== Design considerations: How `addq`/`deleteq`/`editq` commands execute
* _Alternative 1 (current choice):_ Update the internal storage `UniqueQuestionList` in `AppData` first, then save the updated appData
in local storage when the command finishes executing.
** Pros: Easy to implement.
** Cons: Need the extra step to ensure that the internal list is correctly maintained.
* _Alternative 2:_ Update the local storage directly when the command is executing.
** Pros: No need to implement the internal list.
** Cons: Will access local memory more frequently. May have performance issues in terms of memory usage.

===== Design considerations: Data structure to support the question commands
* _Alternative 1 (current choice):_ Use a `UniqueQuestionList` to store questions in `AppData`.
** Pros: Cater to the question model specifically. Question list operations are encapsulated in one class.
** Cons: Logic is duplicated as other models also implement similar list structure.
* _Alternative 2:_ Use Java list to store the questions.
** Pros: Do not need to maintain a separate list class.
** Cons: Violates Single Responsibility Principle and Separation of Concerns as the model needs to maintain various
list operations.
// end::questiond[]

// tag::quiz[]
=== Quiz mode for revision
==== Implementation

The quiz mode feature is facilitated by `Model`.
The quiz-related commands extend `Command` with specific question object.
The commands update the `Model` which is implemented by `ModelManager`.
This in turn updates `AppData` which stores filtered specific questions internally as `QuizQuestionList`.
Local data will be updated in the end by `LogicManager`.
The commands include:

* `QuizModeCommand` -- Enters the quiz mode with questions selected by user.
* `QuizCheckAnswer` -- Checks the correctness of answer entered by user.
* `QuizShowAnswerCommand` -- Shows the answer for current question.
* `QuizSkipQuestion` -- Skips the current question.
* `QuitQuizModeCommand` -- Quits the quiz mode.

These operations are exposed in the `Model` interface as `Model#getQuizQuestions(int numOfQuestions, Subject subject
Difficulty difficulty)`, `Model#setQuizQuestionList(ObservableList<Question> quizQuestionList)`,
`Model#showQuizAnswer()`, `Model#getFilteredQuizQuestionList()`, `Model#checkQuizAnswer(Answer answer)`,
`Model#removeOneQuizQuestion()` and `Model#clearQuizQuestionList()` respectively.

Given below is an example usage scenario and how the question mechanism behaves at each step.

Step 1. The user launches the application for the first time. The app will load all existing information from storage.

Step 2. The user executes `quiz n/NUMBER OF QUESTIONS d/DIFFICULTY s/SUBJECT` command to enter quiz mode of the app.
The `quiz` command calls `Model#getQuizQuestions(int numOfQuestions, Subject subject Difficulty difficulty)` and
`Model#setQuizQuestionList(ObservableList<Question> quizQuestionList)`, causing the `AppData` to be updated with
a list of specific question selected by user for quiz.

Step 3. The user types answer to answer the question. It calls `Model#checkQuizAnswer(Answer answer)` and
`Model#addQuizResult(QuizResult quizResult)`, causing the `AppData` to be updated with the result of the answer.

The following graph explains how `QuizResult` class is designed:

.QuizResultClassDiagram
image::QuizResultClassDiagram.png[]

Step 4. The user executes `show` command to show the answer of current quiz question in the app. The `show` command calls
`Model#showQuizAnswer()`, causing the `AppData` to display the answer on the Ui.

Step 5. The user executes `skip` command to skip the current quiz question in the app. The `skip` command calls
`Model#removeOneQuizQuestion()`, causing the `AppData` to display the next quiz question on the Ui.

Step 6. The user executes `quit` command to exit from the quiz mode. The `quit` command calls
`Model#clearQuizQuestionList()`, causing the `AppData` to clear all quiz question list and return to normal mode.

The following sequence diagram shows how the `quiz` operation works:

.QuizModeSequenceDiagram
image::QuizModeSequenceDiagram.png[]

The following activity diagram summarizes what happens when a user executes a new command for quiz:

.QuizModeActivityDiagram
image::QuizModeActivityDiagram.png[400, 400]

==== Design Considerations

===== Aspect: How to store the quiz results
* **Alternative 1 (current choice):** Update the internal storage `QuizResultList` in `AppData` first, then save the
updated appData in local storage when the command finishes executing.
** Pros: It is easier to implement.
** Cons: It needs the extra step to ensure that the internal list is correctly maintained.
* **Alternative 2:** Update the local storage directly when the command is executing.
** Pros: There is no need to implement the internal list.
** Cons: The access to local memory is more frequent and it may have performance issues in terms of memory usage.

===== Aspect: What data structure is used to support the quiz commands
* **Alternative 1 (current choice):** Use `QuizQuestionList` and `QuizResultList` to store data in `AppData`.
** Pros: It is targeted to the quiz model specifically. Quiz question and result list operations are encapsulated in one class.
** Cons: Logic is duplicated as other models also implement similar list structure.
* **Alternative 2:** Use Java list to store the quiz questions and results.
** Pros: There is no need to maintain a separate list class.
** Cons: It violates Single Responsibility Principle and Separation of Concerns as the model needs to maintain various
list operations.
// end::quiz[]

// tag::stats[]
=== Statistics feature
==== Implementation

The statistics feature gathers data stored from quizzes done in NUStudy to analyse and return an output.
The different commands supported by the statistics feature are used to filter the type of statistics the user wants.
These commands include:

* `GetQnsCommand` -- Gets all questions answered correctly/incorrectly.
* `GetReportCommand` -- Returns a report of the specified question.
* `GetStatisticsCommand` -- Returns a pie chart containing a break down of the questions by its results.
* `GetOverviewCommand` -- Gets an overview of the types of questions that have been attempted overall.

Given below is an example usage scenario and how the statistics mechanism behaves at each step.

Step 1. The user launches the application.
The app will attempt to read past data from any quizzes done and store it internally to a `quizResults` list.

Step 2. The user enters `stats s/CS2103T` to get the statistics of all quiz questions done for CS2103T.
A `GetStatisticsCommand` will be created. When it is executed from the `MainWindow`,
it returns a new `CommandResult` with command type: `STATS`.

The following class diagram shows how the `GetStatisticsCommand` and `CommandResult` classes are related.

.Class diagram for `GetStatisticsCommand`
image::statistics/StatisticsClassDiagram.png[]

Step 3. After `CommandResult` is returned to `MainWindow`, it will call a `showStats` method to
create a pie chart. It will then show a statistics panel, hiding all notes, tasks and questions.

The following sequence diagram shows how the UI handles the `GetStatisticsCommand`:

.UI sequence diagram for `GetStatisticsCommand`
image::statistics/StatisticsSequenceDiagram.png[]

Step 4. The user now wants to stop viewing statistics and decides to view all notes, tasks and questions
again using the `listnote` command. The statistics panel will now be hidden.

The following activity diagram summarizes what happens when a user executes the statistics command:

.Statistics activity diagram
image::statistics/StatisticsActivityDiagram.png[]

==== Design Considerations

===== Aspect: Where statistics are shown
* **Alternative 1 (current choice):** Hide all other panels and only show statistics.
** Pros: Less scrolling will be needed and more information can be shown in one panel.
** Cons: More methods are needed to deal with hiding and showing the different panels leading to more room for errors.
* **Alternative 2:** Allocate a spot in the main window with the notes, tasks and questions for statistics to be displayed.
** Pros: It is easy to implement.
** Cons: The number of notes, tasks and questions that can be seen without scrolling will be decreased.
The charts will be small and condensed making it difficult to see the data at first glance.

===== Aspect: How statistics are represented
* **Alternative 1 (current choice):** Use a pie chart.
** Pros: It is easy to read at a glance.
** Cons: Pie chart slices may get too small to see if there are too little correct/incorrect questions done.
* **Alternative 2:** Use a grouped bar chart.
** Pros: The questions done are sorted by subjects, thus it is more informative.
** Cons: As the number of subjects increases, the bars get thinner making it more difficult to see the data.
This is also more difficult to implement.
// end::stats[]

// tag::task_1[]
=== Revision task management
Revision task management involves addition, deletion, editing, searching and many other operations on tasks. This section
explains how task management features are implemented.

==== Implementation

Revision task management is facilitated by `Model`.
Commands related to task manipulation extend `Command` class.
The commands update the `Model` interface which is implemented by `ModelManager` class.
The `ModelManager` then updates `AppData` which stores all the revision tasks in an internal data structure `TaskList`.
`TaskList` is essentially an `ObservableList` of `Task`.
Local data will be updated in the end by `LogicManager`.

//end::task_1[]

The revision task management commands include:

* `AddTaskForNoteCommand` -- Adds a new task for revising note to the app.
* `AddTaskForQuestionCommand` -- Adds a new task for revising question to the app.
* `ClearTaskCommand` -- Clears all tasks in the app.
* `DeleteTaskCommand` -- Deletes a task from the app.
* `DoneTaskCommand` -- Marks a task as done.
* `EditTaskCommand` -- Edits fields of a task.
* `FindTaskCommand` -- Searches for a task with given information.
* `ListAllTaskCommand` -- Displays all tasks to the user.
* `ListDoneTaskTaskCommand` -- Displays tasks that have been done to the user.
* `ListNotDoneTaskCommand` -- Displays tasks that have not been done to the user.
* `ListOverdueTaskCommand` -- Displays tasks that have passed the scheduled time to the user.

These operations are exposed in the `Model` interface as `Model#addTask(Task task)`, `Model#hasTask(Task task)`, `Model#clearTaskList()`,
`Model#deleteTask(Task target)`, `Model#markTaskAsDone(Task taskDone)`, `Model#setTask(Task target, Task editedTask)`,
`Model#updateFilteredTaskList(Predicate<Task> predicate)` and `Model#getFilteredTaskList()` respectively.

// tag::task_2[]

Taking `AddTaskForNoteCommand` as an example, the following process illustrates the mechanism of adding a revision task for note to the task list (adding a revision task
for question has a similar command but different parameters).

Step 1. The user enters command `rn t/UML diagram dt/01/01/2019 tm/1200` for adding a task for note. The command is parsed by `AddTaskForNoteCommandParser`.
`AddTaskForNoteParser` then creates an `AddTaskForNoteCommand`. The high-level logic of *parsing* and *creating the command*
is similar to the process of deleting a note from the note list as illustrated by the <<DeleteSequenceDiagram, *sequence diagram for deleting a note*>>.
However, the execution stage of `AddTaskForNoteCommand` differs from that of deleting a note.

Step 2. The `Logic Manager` calls `Command#execute(Model)` which essentially calls `AddTaskForNoteCommand#execute(Model)`
because of polymorphism.

Step 3. `AddTaskForNoteCommand` calls its own private method `hasValidNote(Model)` which checks if
the `Note` with `Title` ""UML diagram"" exists in `Model`. If not, a `CommandException` will be thrown and `execute(Model)` stops because non-existing note
title is not allowed to be the heading of any tasks.

Step 4. `AddTaskForNoteCommand` calls `Model#hasTask(Task)` to check whether the `Model` has a task identical to the one
the user is adding. If there is an existing identical task, a `CommandException` will be thrown and `execute(Model)` stops to avoid duplicate tasks.

Step 5. `AddTaskForNoteCommand` calls `Model#addTask(Task)` to add the new task to the `Model`. `Model` calls
`AppData#addTask(Task)` to add the task to `AppData` which keeps track of all data of the app. `AppData` then calls `TaskList#add(Task)`
to add the task to `TaskList`, which is the underlying data structure storing tasks.

Step 6. A `CommandResult` is created and returned to the `LogicManager` to inform the user of successful addition of a new
task to the revision plan.

The following sequence diagram illustrates the interaction between classes when calling `AddTaskForNoteCommand#execute(Model)`.

.Sequence diagram for `execute(Model)` of `AddTaskForNoteCommand`
image::task/AddTaskForNoteCommandExecuteSequenceDiagram.png[]

Zooming in to *Step 3*, when calling `hasValidNoteForTask(Model)`, `AddTaskForNoteCommand` creates a new `Note` with a `Title` ""UML diagram"" and a `Content` ""dummy entry"".
The entry of `Content` is not important because `AddTaskForNoteCommand` only records the `Title` of a `Note` and the existence
of a `Note` is checked against its `Title` only (if the title is in the note list, then the note exists in the list).
The detailed process is illustrated by the sequence diagram below.

.Sequence diagram for checking existence of a `Note` in the model when `AddTaskForNoteCommand` calls its own `hasValidNoteForTask(Model)`
image::task/HasValidNoteSequenceDiagram.png[]

The following activity diagram summarizes the whole process of adding a task for note.

.Activity diagram for adding a task for note
image::task/AddTaskForNoteActivityDiagram.png[]

==== Design considerations
===== Aspect: Design of `Task`
* **Alternative 1 (current implementation):** We implement `Task` as a concrete class with two subclasses to support task for
notes and questions respectively.
** Pros: It supports different behaviours of task for `Note` and task for `Question` by polymorphism. The concrete `Task`
class will also allow adding of general tasks in *v2.0*.
** Cons: We need to implement two different `AddTask` commands to support addition of the two different types of tasks.
Hence we need to write more pieces of code.

The class diagram below illustrates how `Task` class is designed:

.Design of `Task` class
image::task/TaskClassDiagram.png[]

* **Alternative 2:** We design `Task` as an interface to be implemented by two different classes.
** Pros: This approach is better in data hiding. The client classes know less information about internal properties of `Task`.
** Cons: We need to implement all methods in the interface and hence more code snippets are needed. Both implementing
classes have to include the field in common such as `isDone`, which results in duplicate code snippets.

* **Alternative 3:** We wrap everything in one concrete `Task` class to support both lecture notes and questions.
** Pros: We need to write less code.
** Cons: It violates the principle of Separation of Concern, making it hard to maintain or extend in the future if more types of
tasks are needed.

===== Aspect: Design of command for adding a task
* **Alternative 1 (current implementation):** We implement the command as two independent classes, namely `AddTaskForNoteCommand` and
`AddTaskForQuestionCommand` to support adding `TaskForNote` and `TaskForQuestion` respectively.
** Pros: The two types of commands, although similar in logic, receive different parameters and interact with different
classes (one interacting with `TaskForNote` while another one interacting with `TaskForQuestion`). Therefore, it is better to separate the
concerns by implementing the commands as two separate classes. If `TaskForNote` and `TaskForQuestion` classes deviate more
significantly in the future in terms of their behaviour, this approach makes it easier to maintain the adding commands.
** Cons: We need to write more code. There might be some duplicate code snippets involving the logic shared by both commands.
We also need to implement different parsers for the two commands, which involes some extra work.

* **Alternative 2:** We implement only one class of adding command to support both `TaskForNote` and `TaskForQuestion`.
** Pros: We can write less code as there would be fewer duplicate code snippets and we do not need to implement separate
command parsers.
** Cons: This approach leads to lower level of abstraction as all concerns of `Task`, regardless of `TaskForNote` or `TaskForQuestion`,
are wrapped into the same class. It could be difficult to maintain if the behaviors of `TaskForNote` and `TaskForQuestion`
get more complex and diverse.
// end::task_2[]

=== Logging

We use `java.util.logging` for logging. The `LogsCenter` class is used to manage the logging levels and destinations.

* The logging level can be controlled using the `logLevel` setting in the configuration file (see <<Implementation-Configuration>>).
* The `Logger` for a class can be obtained using `LogsCenter.getLogger(Class)`,
which will log messages according to the specified logging level.
* Log messages are written to the console and to a `.log` file.

*Logging levels*

* `SEVERE`: Indicates a critical (potentially fatal) problem with NUStudy.
* `WARNING`: After this incident NUStudy may continue, but with caution.
* `INFO`: Informational reports about actions taken by NUStudy.
* `FINE`: Strictly only useful for debugging purposes, records all data processed by NUStudy.

[[Implementation-Configuration]]
=== Configuration

The user preferences file location and logging level can be set through the configuration file,
by default `config.json`.

== Documentation

Refer to the guide <<Documentation#, here>>.

== Testing

Refer to the guide <<Testing#, here>>.

== DevOps

Refer to the guide <<DevOps#, here>>.

[appendix]
== Product Scope

*Target user profile*:

* has a need to manage a significant number of notes
* has a need to test contents of notes
* prefers desktop apps over other types
* can type fast
* prefers typing over mouse input
* is reasonably comfortable using CLI apps

*Value proposition*: Revise more efficiently with spaced repetition and active recall
compared to a typical note-taking app

[appendix]
== User Stories

Priorities:

* High (must have) – `* * *`
* Medium (nice to have) – `* *`
* Low (will be implemented in *v2.0*) – `*`

[width=""59%"",cols=""22%,<23%,<25%,<30%,<30%"",options=""header"",]
|=======================================================================
|Priority|As a/an...|I want to...|So that I can...|Author

|`* * *`|student|share and receive lecture content from others|my friends can share in the common knowledge, and my family can understand what I am studying|Jeremy

|`* * *`|student|annotate my lecture notes|I can go beyond the curriculum|Jeremy

|`*`|module coordinator|brief my subordinates about study materials|the tutors/lecturers under my charge are teaching what they are supposed to teach|Jeremy

|`*`|tutor|discuss the key points to remember from a tutorial|my students get as much out of their tutorials as possible|Jeremy

|`* *`|quizmaster|quiz contestants about their knowledge using the app|the contestants can have as much fun as possible|Jeremy

|`* * *`|student|set a revision plan and add tasks to my plan|I can be more organised in my revision and will not lose my focus|Shui Yao

|`* * *`|student|remove a revision task|I can remove accidentally added revision task or remove a revision task should there be a change of plan|Shui Yao

|`* * *`|student|edit the revision task|I can modify the details of a particular revision task in case I messed up some information|Shui Yao

|`* *`|student|mark a task as done|I can update the status of my revision plan and have greater motivation to move on|Shui Yao

|`* * *`|student|view my revision plan| be more clear on the big picture of my revision and check whatever is left to do when I forget|Shui Yao

|`* *`|student|view unfinished tasks|I can have a easy overview of what I need to to next|Shui Yao

|`* *`|student|view overdue tasks|I can re-schedule my revision and be more careful with the workload in my next planning|Shui Yao

|`*`|student|get notified when a revision task is about to start|I can finish up whatever stuff at hand and get ready for revision|Shui Yao

|`*`|student|disable notification|I will not be bothered in some important events|Shui Yao

|`* * *`|student|change the difficulty level of questions|I can customize the difficulty level of the questions as I progress along the time|Xueting

|`* * *`|student|find all the questions at a particular difficulty level|I can see how well I understand the subject content|Xueting

|`*`|student|set a mix of different difficulty levels at exam mode|I can better simulate the real-time exams conditions|Xueting

|`* *`|student|get a statistics of the number of questions I have attempted at a difficulty level|I can see how often I have practiced for this subject|Xueting

|`* *`|student|get statistics of the accuracy level of the specific difficulty|I can visualise how well I have practiced for this subject|Xueting

|`*`|student|get statistics of the change of difficulty levels I have made to a question|I can understand my improvement in understanding the content|Xueting

|`* * *`|student|see how well I am able to answer questions for different subjects|focus more on subjects that I need to improve on|Irene

|`* * *`|student|check my past responses to different questions|compare with my current response and improve on it if necessary/check if I am making the same mistakes twice|Irene

|`* *`|student|have a graphical report of my progress|get an overview of my progress with a glimpse|Irene

|`* *`|student|get an overview to see the number of questions I have done for the different subjects/difficulties|I can see which subjects/difficulties I need to attempt more questions of|Irene

|`*`|student|check the questions that I have attempted for a specific time period|I can skip questions that I have already done during that time period|Irene

|`*`|student|mark and store the questions I have made mistakes on|I can get a better understanding of which part I need to put more time to study|Dongjun

|`* * *`|student|take a series questions as a mock test before exam|I can refresh my memory on different modules before exam|Dongjun

|`* *`|student|find specific questions according to the keywords|I can filter the questions I want for different purposes|Dongjun

|`* * *`|student|change the difficulty of my test|I can be better prepared for actual exam|Dongjun

|`* *`|student|view all questions and answers stored|I can refer them as revision guide according to different subjects|Dongjun

|=======================================================================

[appendix]
== Use Cases

(For all use cases below, the system is `NUStudy` and the actor is the `student`)

// tag::usecase[]
[discrete]
=== Use case: Create lecture note (Jeremy)

*MSS*

1. Student gives the command to add a lecture note – `addnote t/TITLE c/CONTENT`
2. Application shows a lecture note with the given title and contents to the user
3. Application also updates the lecture note list with the new note

Use case ends

*Extensions*

[none]
* 1a. Student also gives `i/` in the command
[none]
** 1a1. Application brings up a file selection dialog
** 1a2. Student selects the image they wish to include in the lecture note
** 1a3. Application accepts the image
* Use case resumes from step 2

* 1a2a. The selected file is not an image (.png, .jpg, .gif)
[none]
** 1a2a1. Application displays message about the supported file formats
** 1a2a2. Student selects a file again
** Repeat 1a2a1, 1a2a2 until a supported file format is selected
* Use case resumes from step 1a3

[discrete]
=== Use case: Delete lecture note (Jeremy)

*MSS*

1. Student gives the command to delete a lecture note – `deletenote INDEX`
2. Application deletes the note from the note list

Use case ends

*Extensions*

[none]
* 1a. Student gives an out-of-range or non-numeric index
[none]
** 1a1. Application displays message showing in-range indices
** 1a2. Student re-enters the command
** Repeat 1a1 and 1a2 until a valid index is provided
* Use case resumes from step 2
// end::usecase[]

// tag::task_usecase[]

[discrete]
=== Use case: Add a revision task for note to revision plan (Shui Yao)

*Preconditions:* lecture note list is not empty

*MSS*

1. Student keys in revision task command and specifies the title of the note he/she wants to add to revision plan, with starting date and starting time
2. NUStudy adds the task to revision plan
3. NUStudy informs the Student about successful addition of the task

Use case ends

*Extensions*

[none]
* 1a. NUStudy detects missing entry for note title
[none]
** 1a1. NUStudy requests for input of note title
** 1a2. Student enters correct input
** Steps 1a1 - 1a2 are repeated until the input is valid
* Use case resumes from Step 2

[none]
* 1b. NUStudy detects a note title entry that is non-existent in the note list
[none]
** 1b1. NUStudy requests for a valid input of note title (a note that exists in the note list)
** 1b2. Student enters valid note title
** Steps 1b1 - 1b2 are repeated until the input is valid
* Use case resumes from Step 2

[none]
* 1c. NUStudy detects missing starting date or time
[none]
** 1c1. NUStudy requests for correct input with starting date and time
** 1c2. Student enters correct input following the format
** Steps 1c1 - 1c2 are repeated until getting a correct input with valid starting date and time
* Use case resumes from Step 2

[none]
* 1d. NUStudy detects invalid date or time
[none]
** 1d1. NUStudy requests for valid date and time
** 1d2. Student enters correct input with valid date and time
** Steps 1d1 - 1d2 are repeated until getting a correct input with valid date and time
* Use case resumes from Step 2

//end::task_usecase[]

[discrete]
=== Use case: Delete a task from revision plan (Shui Yao)

*MSS*

1. Student requests to list revision plan
2. NUStudy lists the revision plan
3. Student specifies the index of the task in the revision plan list
4. NUStudy removes the task from the revision plan
5. NUStudy informs the Student about the successful removal of the task

Use case ends

*Extensions*

[none]
* 1a. NUStudy detects that the revision plan has no tasks
[none]
** 1a1. NUStudy informs the Student that the revision plan is empty
* Use case ends

[none]
* 3a. NUStudy detects an index that is not in the revision plan
[none]
** 3a1. NUStudy requests for correct input with valid index
** 3a2. Student enters correct input with valid index
** Steps 3a1 - 3a2 are repeated until getting a valid index
* Use case resumes from Step 2

[discrete]
=== Use case: Clear the revision plan (Shui Yao)

*MSS*

1. Student clears the revision plan
2. NUStudy clears the revision plan
3. NUStudy informs the Student that the revision plan is successfully cleared

Use case ends.

// tag::statsUseCase[]
[discrete]
=== Use case: get statistics for subjects (Irene)

*MSS*

1. Student gives the command to get the statistics for a difficulty and some subjects `stats [d/DIFFICULTY] [s/SUBJECT1] [s/SUBJECT2]...`
2. Application returns a pie chart with number of questions answered correctly and incorrectly

Use case ends

*Extensions*
[none]
* 1a. Student provides an invalid difficulty or invalid subjects
[none]
** 1a1. Application will inform students that there are no statistics for that difficulty/subject
** 1a2. Student will re-enter the command with a valid difficulty/subject
* Use case resumes from step 2

[discrete]
=== Use case: get report of individual questions (Irene)

*MSS*

1. Student gives the command to get report of a question `report INDEX`
2. Application returns past attempts of the question and statistics of how well the question has been answered

Use case ends

*Extensions*
[none]
* 1a. Student gives an out-of-range index
[none]
** 1a1. Application displays a message indicating that the index is invalid
** 1a2. Student re-enters the command
** Repeat 1a1 and 1a2 until a valid index is provided
* Use case resumes from step 2

[none]
* 1b. Student does not provide an index
[none]
** 1b1. Application displays a message indicating that the command format is invalid
** 1b2. Student re-enters the command
* Use case resumes from step 2
// end::statsUseCase[]

// tag::usecasew[]
[discrete]
=== Use case: Add a question to question bank in NUStudy (Xueting)

*MSS*

1. Student keys in add question and specifies the relevant fields - `add q/QUESTION a/ANSWER s/SUBJECT d/DIFFICULTY`
2. Application adds the question with its fields.
3. Application informs the user about the success addition of question.

Use case ends

*Extensions*

[none]
* 1a. Student does not specify the difficulty level
[none]
** 1a1. Application shows an error message to require difficulty level input
** 1a2. Student inputs the difficulty level
** Repeat 1a1 and 1a2 until a difficulty level is provided
* Use case resumes from step 2

[discrete]
=== Use case: Delete a question (Xueting)

*MSS*

1. User requests to view a list of questions from another command (eg. `findq`, `difficulty`, `subject`).
2. Application shows the list of questions retrieved from this command.
3. User enters the delete command with the index of the question to be deleted.
4. Application removes the question from the question bank.
5. Application informs the user about the success of deletion.

Use case ends

*Extensions*

[none]
* 1a. There is no question listed from the previous command.
[none]
** 1a1. Application informs the user that the index is invalid since the question list is empty.
* Use case ends

[none]
* 1b. Student inputs invalid index for a question (either negative or out of range).
[none]
** 1b1. Application shows an error message to inform the user that the index is invalid.
** 1b2. Student re-enter the command by providing a valid index.
** Repeat 1b1 and 1b2 until valid index is provided
* Use case resumes at step 2
// end::usecasew[]

[discrete]
=== Use case: Edit difficulty level of a specific question (Xueting)

*MSS*

1. Student changes the difficulty level of a question - edit `-dif id/INDEX d/DIFFICULTY`
2. Application shows and stores the question with the updated difficulty level

Use case ends

*Extensions*

[none]
* 1a. Student does not provide the updated difficulty level
[none]
** 1a1. Application shows an error message to require difficulty level update
** 1a2. Student inputs the new difficulty level
** Repeat 1a1 and 1a2 until a difficulty level is provided
* Use case resumes at step 2

[none]
* 1b. Student provides the same difficulty level as the previous one
[none]
** 1b1. Application shows a warning message indicating that the difficulty level is not updated and ask whether the user would like to proceed
** 1b2. Student chooses either to proceed with the original difficulty level or re-edit the difficulty level
* Use case resumes at step 2

[none]
* 1c. Student inputs an invalid (out of range or non-numeric) questions index
[none]
** 1c1. Application displays the range of valid question indices
** 1c2. Student re-enters the question index
** Repeat 1c1 and 1c2 until a valid index is provided
* Use case resumes at step 1

// tag::quizUseCase[]
[discrete]
=== Use case: Take a quiz (Dongjun)

*MSS*

1. Student gives the command to enter the test mode `quiz [n/NUMBER_OF_QUESTIONS] [d/DIFFICULTY] [s/SUBJECT]`
2. Application shows a question with difficulty and subject indicated
3. Application waits for the student to key in the answer
4. Student enters the answer
5. Application displays whether the input answer is correct or wrong
6. Repeat 2 - 5 until all questions are answered

Use case ends

*Extensions*

[none]
* 1a. Student inputs the invalid quiz command
[none]
** 1a1. Application returns the correct format for quiz command
** 1a2. Students enter the correct quiz command
* Use case resumes from step 1

[none]
* 3a. Student chooses to skip current questions by giving `skip`
[none]
** Application skips this question and display the next question
* Use case resumes from step 2

[none]
* 3b. Student chooses to get the answer for current question by giving `show`
[none]
** 3b1. Application displays the answer
* Use case resumes from step 2

[none]
* a. At any time, Student chooses to exit from the quiz
[none]
** a1. Student gives the command `quit`
** a2. Application exits from the quiz mode
* Use case ends
// end::quizUseCase[]

// tag::nfrglossary[]
[appendix]
== Non-functional requirements

. Images must be copied into the application data, residing in a dedicated folder,
rather than merely linking to somewhere on the filesystem
. Export format of lecture notes and flash cards must be human-readable text
. Images must be referenced by pathnames with respect to the image folder

[appendix]
== Glossary

[[lecture-note]] Lecture note::
An object stored in the application model that includes a title, text content and optionally an image.
It is not quizzable.
// end::nfrglossary[]

[appendix]
== Manual testing
A few ways of manually testing NUStudy are listed below. Of course, any tester
should explore more than just these.

=== Opening and closing
. Initial launch
.. Download the JAR file and copy into an empty folder.
.. Open the jar file. _The GUI with some initial application data should be visible._
. Saving window preferences
.. Change the position and size of the window and close it.
.. Re-launch NUStudy. _It should look just like when it was closed._

=== Image support
. Adding a lecture note with an image
.. Type `addnote t/t c/c i/` in the command line. _An image dialog should be brought up._
.. Select any image. _It should appear in the lecture note panel, as a new lecture note with
title ""t"" and content ""c""._
. Modifying an image
.. After adding one lecture note with an image, type `editnote i i/` where `i` is its index.
.. _The same image dialog should be brought up_; select a different image.
_This image should appear in place of the old image, if any, even if the filename is the same._
. Local copy of images
.. Close the application and move the JAR file and its associated application data to another location.
.. Relaunch the application. _Images should display as before._
. Silent ignoring of broken images
.. Once lecture notes with images have been added, close NUStudy and delete all images
in its data folder.
.. Relaunch the application. _The app should not throw an exception, merely not display any images._
.. Add back the images to the lecture notes using `editnote`. _This operation should succeed._

== Question management
. Adding a question with all necessary fields
.. Type `addq q/MVC design pattern refers to (  ). a/Model View Controller s/CS2103T d/Medium` in the command line.
.. The application will show the success of adding the question if all fields are present and valid.
. Editing a question
.. Type `editq 1 d/Hard` to change the difficulty of the question at index 1 to hard.
.. The application will show the success of updating the question's difficulty and display all the fields.
The question at index 1 will have a new difficulty of Hard.
. Finding a question
.. Type `findq java python` in the command line.
.. The application will return a list of questions which contain the keyword ""java"" or ""python"" in either its
question body or answer. If no question contains these keywords, the application will return an empty list.
. Deleting a question
.. Type `listq` in the command line to view a list of all questions.
.. Type `deleteq 2` in the command line to delete the second question from the list.
.. The application will display the success of deletion of this question and its relevant fields.
The question will be removed from the list.

=== Quiz mode
NOTE: Ensure the application has at least one question to do the quiz.

. Entering the quiz mode
.. Type `quiz n/1 d/easy s/cs2040` in the command line. If the application has the questions which fit the requirement,
it will enter the quiz mode and display the quiz questions.
. Answering the question
.. Type your answer in the command line after entering the quiz mode. The result of your answer will be displayed under
the command box.
. Showing the answer of the question
.. Type `show` in the command line when the application is in the quiz mode. The correct answer of the current quiz question
will be displayed under the command box.
. Skipping current question
.. Type `skip` in the command line when the application is in the quiz mode. The current question will be skipped and
the next question will be displayed if there are still available questions.
. Quiting from the quiz mode
.. Type `quit` in the command line when the application is in the quiz mode. The application will exit from the quiz mode
and return to the original mode.
",12204,False,2021.808177566085,median
"//===- HWAddressSanitizer.cpp - detector of uninitialized reads -------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
/// \\file
/// This file is a part of HWAddressSanitizer, an address sanity checker
/// based on tagged addressing.
//===----------------------------------------------------------------------===//

#include ""llvm/Transforms/Instrumentation/HWAddressSanitizer.h""
#include ""llvm/ADT/MapVector.h""
#include ""llvm/ADT/SmallVector.h""
#include ""llvm/ADT/StringExtras.h""
#include ""llvm/ADT/StringRef.h""
#include ""llvm/ADT/Triple.h""
#include ""llvm/BinaryFormat/ELF.h""
#include ""llvm/IR/Attributes.h""
#include ""llvm/IR/BasicBlock.h""
#include ""llvm/IR/Constant.h""
#include ""llvm/IR/Constants.h""
#include ""llvm/IR/DataLayout.h""
#include ""llvm/IR/DebugInfoMetadata.h""
#include ""llvm/IR/DerivedTypes.h""
#include ""llvm/IR/Function.h""
#include ""llvm/IR/IRBuilder.h""
#include ""llvm/IR/InlineAsm.h""
#include ""llvm/IR/InstVisitor.h""
#include ""llvm/IR/Instruction.h""
#include ""llvm/IR/Instructions.h""
#include ""llvm/IR/IntrinsicInst.h""
#include ""llvm/IR/Intrinsics.h""
#include ""llvm/IR/LLVMContext.h""
#include ""llvm/IR/MDBuilder.h""
#include ""llvm/IR/Module.h""
#include ""llvm/IR/Type.h""
#include ""llvm/IR/Value.h""
#include ""llvm/InitializePasses.h""
#include ""llvm/Pass.h""
#include ""llvm/Support/Casting.h""
#include ""llvm/Support/CommandLine.h""
#include ""llvm/Support/Debug.h""
#include ""llvm/Support/raw_ostream.h""
#include ""llvm/Transforms/Instrumentation.h""
#include ""llvm/Transforms/Instrumentation/AddressSanitizerCommon.h""
#include ""llvm/Transforms/Utils/BasicBlockUtils.h""
#include ""llvm/Transforms/Utils/ModuleUtils.h""
#include ""llvm/Transforms/Utils/PromoteMemToReg.h""
#include <sstream>

using namespace llvm;

#define DEBUG_TYPE ""hwasan""

const char kHwasanModuleCtorName[] = ""hwasan.module_ctor"";
const char kHwasanNoteName[] = ""hwasan.note"";
const char kHwasanInitName[] = ""__hwasan_init"";
const char kHwasanPersonalityThunkName[] = ""__hwasan_personality_thunk"";

const char kHwasanShadowMemoryDynamicAddress[] =
    ""__hwasan_shadow_memory_dynamic_address"";

// Accesses sizes are powers of two: 1, 2, 4, 8, 16.
static const size_t kNumberOfAccessSizes = 5;

static const size_t kDefaultShadowScale = 4;
static const uint64_t kDynamicShadowSentinel =
    std::numeric_limits<uint64_t>::max();
static const unsigned kPointerTagShift = 56;

static const unsigned kShadowBaseAlignment = 32;

static cl::opt<std::string> ClMemoryAccessCallbackPrefix(
    ""hwasan-memory-access-callback-prefix"",
    cl::desc(""Prefix for memory access callbacks""), cl::Hidden,
    cl::init(""__hwasan_""));

static cl::opt<bool>
    ClInstrumentWithCalls(""hwasan-instrument-with-calls"",
                cl::desc(""instrument reads and writes with callbacks""),
                cl::Hidden, cl::init(false));

static cl::opt<bool> ClInstrumentReads(""hwasan-instrument-reads"",
                                       cl::desc(""instrument read instructions""),
                                       cl::Hidden, cl::init(true));

static cl::opt<bool> ClInstrumentWrites(
    ""hwasan-instrument-writes"", cl::desc(""instrument write instructions""),
    cl::Hidden, cl::init(true));

static cl::opt<bool> ClInstrumentAtomics(
    ""hwasan-instrument-atomics"",
    cl::desc(""instrument atomic instructions (rmw, cmpxchg)""), cl::Hidden,
    cl::init(true));

static cl::opt<bool> ClInstrumentByval(""hwasan-instrument-byval"",
                                       cl::desc(""instrument byval arguments""),
                                       cl::Hidden, cl::init(true));

static cl::opt<bool> ClRecover(
    ""hwasan-recover"",
    cl::desc(""Enable recovery mode (continue-after-error).""),
    cl::Hidden, cl::init(false));

static cl::opt<bool> ClInstrumentStack(""hwasan-instrument-stack"",
                                       cl::desc(""instrument stack (allocas)""),
                                       cl::Hidden, cl::init(true));

static cl::opt<bool> ClUARRetagToZero(
    ""hwasan-uar-retag-to-zero"",
    cl::desc(""Clear alloca tags before returning from the function to allow ""
             ""non-instrumented and instrumented function calls mix. When set ""
             ""to false, allocas are retagged before returning from the ""
             ""function to detect use after return.""),
    cl::Hidden, cl::init(true));

static cl::opt<bool> ClGenerateTagsWithCalls(
    ""hwasan-generate-tags-with-calls"",
    cl::desc(""generate new tags with runtime library calls""), cl::Hidden,
    cl::init(false));

static cl::opt<bool> ClGlobals(""hwasan-globals"", cl::desc(""Instrument globals""),
                               cl::Hidden, cl::init(false), cl::ZeroOrMore);

static cl::opt<int> ClMatchAllTag(
    ""hwasan-match-all-tag"",
    cl::desc(""don't report bad accesses via pointers with this tag""),
    cl::Hidden, cl::init(-1));

static cl::opt<bool> ClEnableKhwasan(
    ""hwasan-kernel"",
    cl::desc(""Enable KernelHWAddressSanitizer instrumentation""),
    cl::Hidden, cl::init(false));

// These flags allow to change the shadow mapping and control how shadow memory
// is accessed. The shadow mapping looks like:
//    Shadow = (Mem >> scale) + offset

static cl::opt<uint64_t>
    ClMappingOffset(""hwasan-mapping-offset"",
                    cl::desc(""HWASan shadow mapping offset [EXPERIMENTAL]""),
                    cl::Hidden, cl::init(0));

static cl::opt<bool>
    ClWithIfunc(""hwasan-with-ifunc"",
                cl::desc(""Access dynamic shadow through an ifunc global on ""
                         ""platforms that support this""),
                cl::Hidden, cl::init(false));

static cl::opt<bool> ClWithTls(
    ""hwasan-with-tls"",
    cl::desc(""Access dynamic shadow through an thread-local pointer on ""
             ""platforms that support this""),
    cl::Hidden, cl::init(true));

static cl::opt<bool>
    ClRecordStackHistory(""hwasan-record-stack-history"",
                         cl::desc(""Record stack frames with tagged allocations ""
                                  ""in a thread-local ring buffer""),
                         cl::Hidden, cl::init(true));
static cl::opt<bool>
    ClInstrumentMemIntrinsics(""hwasan-instrument-mem-intrinsics"",
                              cl::desc(""instrument memory intrinsics""),
                              cl::Hidden, cl::init(true));

static cl::opt<bool>
    ClInstrumentLandingPads(""hwasan-instrument-landing-pads"",
                            cl::desc(""instrument landing pads""), cl::Hidden,
                            cl::init(false), cl::ZeroOrMore);

static cl::opt<bool> ClUseShortGranules(
    ""hwasan-use-short-granules"",
    cl::desc(""use short granules in allocas and outlined checks""), cl::Hidden,
    cl::init(false), cl::ZeroOrMore);

static cl::opt<bool> ClInstrumentPersonalityFunctions(
    ""hwasan-instrument-personality-functions"",
    cl::desc(""instrument personality functions""), cl::Hidden, cl::init(false),
    cl::ZeroOrMore);

static cl::opt<bool> ClInlineAllChecks(""hwasan-inline-all-checks"",
                                       cl::desc(""inline all checks""),
                                       cl::Hidden, cl::init(false));

namespace {

/// An instrumentation pass implementing detection of addressability bugs
/// using tagged pointers.
class HWAddressSanitizer {
public:
  explicit HWAddressSanitizer(Module &M, bool CompileKernel = false,
                              bool Recover = false) : M(M) {
    this->Recover = ClRecover.getNumOccurrences() > 0 ? ClRecover : Recover;
    this->CompileKernel = ClEnableKhwasan.getNumOccurrences() > 0 ?
        ClEnableKhwasan : CompileKernel;

    initializeModule();
  }

  bool sanitizeFunction(Function &F);
  void initializeModule();
  void createHwasanCtorComdat();

  void initializeCallbacks(Module &M);

  Value *getOpaqueNoopCast(IRBuilder<> &IRB, Value *Val);

  Value *getDynamicShadowIfunc(IRBuilder<> &IRB);
  Value *getShadowNonTls(IRBuilder<> &IRB);

  void untagPointerOperand(Instruction *I, Value *Addr);
  Value *memToShadow(Value *Shadow, IRBuilder<> &IRB);
  void instrumentMemAccessInline(Value *Ptr, bool IsWrite,
                                 unsigned AccessSizeIndex,
                                 Instruction *InsertBefore);
  void instrumentMemIntrinsic(MemIntrinsic *MI);
  bool instrumentMemAccess(InterestingMemoryOperand &O);
  bool ignoreAccess(Value *Ptr);
  void getInterestingMemoryOperands(
      Instruction *I, SmallVectorImpl<InterestingMemoryOperand> &Interesting);

  bool isInterestingAlloca(const AllocaInst &AI);
  bool tagAlloca(IRBuilder<> &IRB, AllocaInst *AI, Value *Tag, size_t Size);
  Value *tagPointer(IRBuilder<> &IRB, Type *Ty, Value *PtrLong, Value *Tag);
  Value *untagPointer(IRBuilder<> &IRB, Value *PtrLong);
  bool instrumentStack(
      SmallVectorImpl<AllocaInst *> &Allocas,
      DenseMap<AllocaInst *, std::vector<DbgVariableIntrinsic *>> &AllocaDbgMap,
      SmallVectorImpl<Instruction *> &RetVec, Value *StackTag);
  Value *readRegister(IRBuilder<> &IRB, StringRef Name);
  bool instrumentLandingPads(SmallVectorImpl<Instruction *> &RetVec);
  Value *getNextTagWithCall(IRBuilder<> &IRB);
  Value *getStackBaseTag(IRBuilder<> &IRB);
  Value *getAllocaTag(IRBuilder<> &IRB, Value *StackTag, AllocaInst *AI,
                     unsigned AllocaNo);
  Value *getUARTag(IRBuilder<> &IRB, Value *StackTag);

  Value *getHwasanThreadSlotPtr(IRBuilder<> &IRB, Type *Ty);
  void emitPrologue(IRBuilder<> &IRB, bool WithFrameRecord);

  void instrumentGlobal(GlobalVariable *GV, uint8_t Tag);
  void instrumentGlobals();

  void instrumentPersonalityFunctions();

private:
  LLVMContext *C;
  Module &M;
  Triple TargetTriple;
  FunctionCallee HWAsanMemmove, HWAsanMemcpy, HWAsanMemset;
  FunctionCallee HWAsanHandleVfork;

  /// This struct defines the shadow mapping using the rule:
  ///   shadow = (mem >> Scale) + Offset.
  /// If InGlobal is true, then
  ///   extern char __hwasan_shadow[];
  ///   shadow = (mem >> Scale) + &__hwasan_shadow
  /// If InTls is true, then
  ///   extern char *__hwasan_tls;
  ///   shadow = (mem>>Scale) + align_up(__hwasan_shadow, kShadowBaseAlignment)
  struct ShadowMapping {
    int Scale;
    uint64_t Offset;
    bool InGlobal;
    bool InTls;

    void init(Triple &TargetTriple);
    unsigned getObjectAlignment() const { return 1U << Scale; }
  };
  ShadowMapping Mapping;

  Type *VoidTy = Type::getVoidTy(M.getContext());
  Type *IntptrTy;
  Type *Int8PtrTy;
  Type *Int8Ty;
  Type *Int32Ty;
  Type *Int64Ty = Type::getInt64Ty(M.getContext());

  bool CompileKernel;
  bool Recover;
  bool OutlinedChecks;
  bool UseShortGranules;
  bool InstrumentLandingPads;

  bool HasMatchAllTag = false;
  uint8_t MatchAllTag = 0;

  Function *HwasanCtorFunction;

  FunctionCallee HwasanMemoryAccessCallback[2][kNumberOfAccessSizes];
  FunctionCallee HwasanMemoryAccessCallbackSized[2];

  FunctionCallee HwasanTagMemoryFunc;
  FunctionCallee HwasanGenerateTagFunc;

  Constant *ShadowGlobal;

  Value *ShadowBase = nullptr;
  Value *StackBaseTag = nullptr;
  GlobalValue *ThreadPtrGlobal = nullptr;
};

class HWAddressSanitizerLegacyPass : public FunctionPass {
public:
  // Pass identification, replacement for typeid.
  static char ID;

  explicit HWAddressSanitizerLegacyPass(bool CompileKernel = false,
                                        bool Recover = false)
      : FunctionPass(ID), CompileKernel(CompileKernel), Recover(Recover) {
    initializeHWAddressSanitizerLegacyPassPass(
        *PassRegistry::getPassRegistry());
  }

  StringRef getPassName() const override { return ""HWAddressSanitizer""; }

  bool doInitialization(Module &M) override {
    HWASan = std::make_unique<HWAddressSanitizer>(M, CompileKernel, Recover);
    return true;
  }

  bool runOnFunction(Function &F) override {
    return HWASan->sanitizeFunction(F);
  }

  bool doFinalization(Module &M) override {
    HWASan.reset();
    return false;
  }

private:
  std::unique_ptr<HWAddressSanitizer> HWASan;
  bool CompileKernel;
  bool Recover;
};

} // end anonymous namespace

char HWAddressSanitizerLegacyPass::ID = 0;

INITIALIZE_PASS_BEGIN(
    HWAddressSanitizerLegacyPass, ""hwasan"",
    ""HWAddressSanitizer: detect memory bugs using tagged addressing."", false,
    false)
INITIALIZE_PASS_END(
    HWAddressSanitizerLegacyPass, ""hwasan"",
    ""HWAddressSanitizer: detect memory bugs using tagged addressing."", false,
    false)

FunctionPass *llvm::createHWAddressSanitizerLegacyPassPass(bool CompileKernel,
                                                           bool Recover) {
  assert(!CompileKernel || Recover);
  return new HWAddressSanitizerLegacyPass(CompileKernel, Recover);
}

HWAddressSanitizerPass::HWAddressSanitizerPass(bool CompileKernel, bool Recover)
    : CompileKernel(CompileKernel), Recover(Recover) {}

PreservedAnalyses HWAddressSanitizerPass::run(Module &M,
                                              ModuleAnalysisManager &MAM) {
  HWAddressSanitizer HWASan(M, CompileKernel, Recover);
  bool Modified = false;
  for (Function &F : M)
    Modified |= HWASan.sanitizeFunction(F);
  if (Modified)
    return PreservedAnalyses::none();
  return PreservedAnalyses::all();
}

void HWAddressSanitizer::createHwasanCtorComdat() {
  std::tie(HwasanCtorFunction, std::ignore) =
      getOrCreateSanitizerCtorAndInitFunctions(
          M, kHwasanModuleCtorName, kHwasanInitName,
          /*InitArgTypes=*/{},
          /*InitArgs=*/{},
          // This callback is invoked when the functions are created the first
          // time. Hook them into the global ctors list in that case:
          [&](Function *Ctor, FunctionCallee) {
            Comdat *CtorComdat = M.getOrInsertComdat(kHwasanModuleCtorName);
            Ctor->setComdat(CtorComdat);
            appendToGlobalCtors(M, Ctor, 0, Ctor);
          });

  // Create a note that contains pointers to the list of global
  // descriptors. Adding a note to the output file will cause the linker to
  // create a PT_NOTE program header pointing to the note that we can use to
  // find the descriptor list starting from the program headers. A function
  // provided by the runtime initializes the shadow memory for the globals by
  // accessing the descriptor list via the note. The dynamic loader needs to
  // call this function whenever a library is loaded.
  //
  // The reason why we use a note for this instead of a more conventional
  // approach of having a global constructor pass a descriptor list pointer to
  // the runtime is because of an order of initialization problem. With
  // constructors we can encounter the following problematic scenario:
  //
  // 1) library A depends on library B and also interposes one of B's symbols
  // 2) B's constructors are called before A's (as required for correctness)
  // 3) during construction, B accesses one of its ""own"" globals (actually
  //    interposed by A) and triggers a HWASAN failure due to the initialization
  //    for A not having happened yet
  //
  // Even without interposition it is possible to run into similar situations in
  // cases where two libraries mutually depend on each other.
  //
  // We only need one note per binary, so put everything for the note in a
  // comdat. This needs to be a comdat with an .init_array section to prevent
  // newer versions of lld from discarding the note.
  //
  // Create the note even if we aren't instrumenting globals. This ensures that
  // binaries linked from object files with both instrumented and
  // non-instrumented globals will end up with a note, even if a comdat from an
  // object file with non-instrumented globals is selected. The note is harmless
  // if the runtime doesn't support it, since it will just be ignored.
  Comdat *NoteComdat = M.getOrInsertComdat(kHwasanModuleCtorName);

  Type *Int8Arr0Ty = ArrayType::get(Int8Ty, 0);
  auto Start =
      new GlobalVariable(M, Int8Arr0Ty, true, GlobalVariable::ExternalLinkage,
                         nullptr, ""__start_hwasan_globals"");
  Start->setVisibility(GlobalValue::HiddenVisibility);
  Start->setDSOLocal(true);
  auto Stop =
      new GlobalVariable(M, Int8Arr0Ty, true, GlobalVariable::ExternalLinkage,
                         nullptr, ""__stop_hwasan_globals"");
  Stop->setVisibility(GlobalValue::HiddenVisibility);
  Stop->setDSOLocal(true);

  // Null-terminated so actually 8 bytes, which are required in order to align
  // the note properly.
  auto *Name = ConstantDataArray::get(*C, ""LLVM\\0\\0\\0"");

  auto *NoteTy = StructType::get(Int32Ty, Int32Ty, Int32Ty, Name->getType(),
                                 Int32Ty, Int32Ty);
  auto *Note =
      new GlobalVariable(M, NoteTy, /*isConstant=*/true,
                         GlobalValue::PrivateLinkage, nullptr, kHwasanNoteName);
  Note->setSection("".note.hwasan.globals"");
  Note->setComdat(NoteComdat);
  Note->setAlignment(Align(4));
  Note->setDSOLocal(true);

  // The pointers in the note need to be relative so that the note ends up being
  // placed in rodata, which is the standard location for notes.
  auto CreateRelPtr = [&](Constant *Ptr) {
    return ConstantExpr::getTrunc(
        ConstantExpr::getSub(ConstantExpr::getPtrToInt(Ptr, Int64Ty),
                             ConstantExpr::getPtrToInt(Note, Int64Ty)),
        Int32Ty);
  };
  Note->setInitializer(ConstantStruct::getAnon(
      {ConstantInt::get(Int32Ty, 8),                           // n_namesz
       ConstantInt::get(Int32Ty, 8),                           // n_descsz
       ConstantInt::get(Int32Ty, ELF::NT_LLVM_HWASAN_GLOBALS), // n_type
       Name, CreateRelPtr(Start), CreateRelPtr(Stop)}));
  appendToCompilerUsed(M, Note);

  // Create a zero-length global in hwasan_globals so that the linker will
  // always create start and stop symbols.
  auto Dummy = new GlobalVariable(
      M, Int8Arr0Ty, /*isConstantGlobal*/ true, GlobalVariable::PrivateLinkage,
      Constant::getNullValue(Int8Arr0Ty), ""hwasan.dummy.global"");
  Dummy->setSection(""hwasan_globals"");
  Dummy->setComdat(NoteComdat);
  Dummy->setMetadata(LLVMContext::MD_associated,
                     MDNode::get(*C, ValueAsMetadata::get(Note)));
  appendToCompilerUsed(M, Dummy);
}

/// Module-level initialization.
///
/// inserts a call to __hwasan_init to the module's constructor list.
void HWAddressSanitizer::initializeModule() {
  LLVM_DEBUG(dbgs() << ""Init "" << M.getName() << ""\\n"");
  auto &DL = M.getDataLayout();

  TargetTriple = Triple(M.getTargetTriple());

  Mapping.init(TargetTriple);

  C = &(M.getContext());
  IRBuilder<> IRB(*C);
  IntptrTy = IRB.getIntPtrTy(DL);
  Int8PtrTy = IRB.getInt8PtrTy();
  Int8Ty = IRB.getInt8Ty();
  Int32Ty = IRB.getInt32Ty();

  HwasanCtorFunction = nullptr;

  // Older versions of Android do not have the required runtime support for
  // short granules, global or personality function instrumentation. On other
  // platforms we currently require using the latest version of the runtime.
  bool NewRuntime =
      !TargetTriple.isAndroid() || !TargetTriple.isAndroidVersionLT(30);

  UseShortGranules =
      ClUseShortGranules.getNumOccurrences() ? ClUseShortGranules : NewRuntime;
  OutlinedChecks =
      TargetTriple.isAArch64() && TargetTriple.isOSBinFormatELF() &&
      (ClInlineAllChecks.getNumOccurrences() ? !ClInlineAllChecks : !Recover);

  if (ClMatchAllTag.getNumOccurrences()) {
    if (ClMatchAllTag != -1) {
      HasMatchAllTag = true;
      MatchAllTag = ClMatchAllTag & 0xFF;
    }
  } else if (CompileKernel) {
    HasMatchAllTag = true;
    MatchAllTag = 0xFF;
  }

  // If we don't have personality function support, fall back to landing pads.
  InstrumentLandingPads = ClInstrumentLandingPads.getNumOccurrences()
                              ? ClInstrumentLandingPads
                              : !NewRuntime;

  if (!CompileKernel) {
    createHwasanCtorComdat();
    bool InstrumentGlobals =
        ClGlobals.getNumOccurrences() ? ClGlobals : NewRuntime;
    if (InstrumentGlobals)
      instrumentGlobals();

    bool InstrumentPersonalityFunctions =
        ClInstrumentPersonalityFunctions.getNumOccurrences()
            ? ClInstrumentPersonalityFunctions
            : NewRuntime;
    if (InstrumentPersonalityFunctions)
      instrumentPersonalityFunctions();
  }

  if (!TargetTriple.isAndroid()) {
    Constant *C = M.getOrInsertGlobal(""__hwasan_tls"", IntptrTy, [&] {
      auto *GV = new GlobalVariable(M, IntptrTy, /*isConstant=*/false,
                                    GlobalValue::ExternalLinkage, nullptr,
                                    ""__hwasan_tls"", nullptr,
                                    GlobalVariable::InitialExecTLSModel);
      appendToCompilerUsed(M, GV);
      return GV;
    });
    ThreadPtrGlobal = cast<GlobalVariable>(C);
  }
}

void HWAddressSanitizer::initializeCallbacks(Module &M) {
  IRBuilder<> IRB(*C);
  for (size_t AccessIsWrite = 0; AccessIsWrite <= 1; AccessIsWrite++) {
    const std::string TypeStr = AccessIsWrite ? ""store"" : ""load"";
    const std::string EndingStr = Recover ? ""_noabort"" : """";

    HwasanMemoryAccessCallbackSized[AccessIsWrite] = M.getOrInsertFunction(
        ClMemoryAccessCallbackPrefix + TypeStr + ""N"" + EndingStr,
        FunctionType::get(IRB.getVoidTy(), {IntptrTy, IntptrTy}, false));

    for (size_t AccessSizeIndex = 0; AccessSizeIndex < kNumberOfAccessSizes;
         AccessSizeIndex++) {
      HwasanMemoryAccessCallback[AccessIsWrite][AccessSizeIndex] =
          M.getOrInsertFunction(
              ClMemoryAccessCallbackPrefix + TypeStr +
                  itostr(1ULL << AccessSizeIndex) + EndingStr,
              FunctionType::get(IRB.getVoidTy(), {IntptrTy}, false));
    }
  }

  HwasanTagMemoryFunc = M.getOrInsertFunction(
      ""__hwasan_tag_memory"", IRB.getVoidTy(), Int8PtrTy, Int8Ty, IntptrTy);
  HwasanGenerateTagFunc =
      M.getOrInsertFunction(""__hwasan_generate_tag"", Int8Ty);

  ShadowGlobal = M.getOrInsertGlobal(""__hwasan_shadow"",
                                     ArrayType::get(IRB.getInt8Ty(), 0));

  const std::string MemIntrinCallbackPrefix =
      CompileKernel ? std::string("""") : ClMemoryAccessCallbackPrefix;
  HWAsanMemmove = M.getOrInsertFunction(MemIntrinCallbackPrefix + ""memmove"",
                                        IRB.getInt8PtrTy(), IRB.getInt8PtrTy(),
                                        IRB.getInt8PtrTy(), IntptrTy);
  HWAsanMemcpy = M.getOrInsertFunction(MemIntrinCallbackPrefix + ""memcpy"",
                                       IRB.getInt8PtrTy(), IRB.getInt8PtrTy(),
                                       IRB.getInt8PtrTy(), IntptrTy);
  HWAsanMemset = M.getOrInsertFunction(MemIntrinCallbackPrefix + ""memset"",
                                       IRB.getInt8PtrTy(), IRB.getInt8PtrTy(),
                                       IRB.getInt32Ty(), IntptrTy);

  HWAsanHandleVfork =
      M.getOrInsertFunction(""__hwasan_handle_vfork"", IRB.getVoidTy(), IntptrTy);
}

Value *HWAddressSanitizer::getOpaqueNoopCast(IRBuilder<> &IRB, Value *Val) {
  // An empty inline asm with input reg == output reg.
  // An opaque no-op cast, basically.
  // This prevents code bloat as a result of rematerializing trivial definitions
  // such as constants or global addresses at every load and store.
  InlineAsm *Asm =
      InlineAsm::get(FunctionType::get(Int8PtrTy, {Val->getType()}, false),
                     StringRef(""""), StringRef(""=r,0""),
                     /*hasSideEffects=*/false);
  return IRB.CreateCall(Asm, {Val}, "".hwasan.shadow"");
}

Value *HWAddressSanitizer::getDynamicShadowIfunc(IRBuilder<> &IRB) {
  return getOpaqueNoopCast(IRB, ShadowGlobal);
}

Value *HWAddressSanitizer::getShadowNonTls(IRBuilder<> &IRB) {
  if (Mapping.Offset != kDynamicShadowSentinel)
    return getOpaqueNoopCast(
        IRB, ConstantExpr::getIntToPtr(
                 ConstantInt::get(IntptrTy, Mapping.Offset), Int8PtrTy));

  if (Mapping.InGlobal) {
    return getDynamicShadowIfunc(IRB);
  } else {
    Value *GlobalDynamicAddress =
        IRB.GetInsertBlock()->getParent()->getParent()->getOrInsertGlobal(
            kHwasanShadowMemoryDynamicAddress, Int8PtrTy);
    return IRB.CreateLoad(Int8PtrTy, GlobalDynamicAddress);
  }
}

bool HWAddressSanitizer::ignoreAccess(Value *Ptr) {
  // Do not instrument acesses from different address spaces; we cannot deal
  // with them.
  Type *PtrTy = cast<PointerType>(Ptr->getType()->getScalarType());
  if (PtrTy->getPointerAddressSpace() != 0)
    return true;

  // Ignore swifterror addresses.
  // swifterror memory addresses are mem2reg promoted by instruction
  // selection. As such they cannot have regular uses like an instrumentation
  // function and it makes no sense to track them as memory.
  if (Ptr->isSwiftError())
    return true;

  return false;
}

void HWAddressSanitizer::getInterestingMemoryOperands(
    Instruction *I, SmallVectorImpl<InterestingMemoryOperand> &Interesting) {
  // Skip memory accesses inserted by another instrumentation.
  if (I->hasMetadata(""nosanitize""))
    return;

  // Do not instrument the load fetching the dynamic shadow address.
  if (ShadowBase == I)
    return;

  if (LoadInst *LI = dyn_cast<LoadInst>(I)) {
    if (!ClInstrumentReads || ignoreAccess(LI->getPointerOperand()))
      return;
    Interesting.emplace_back(I, LI->getPointerOperandIndex(), false,
                             LI->getType(), LI->getAlign());
  } else if (StoreInst *SI = dyn_cast<StoreInst>(I)) {
    if (!ClInstrumentWrites || ignoreAccess(SI->getPointerOperand()))
      return;
    Interesting.emplace_back(I, SI->getPointerOperandIndex(), true,
                             SI->getValueOperand()->getType(), SI->getAlign());
  } else if (AtomicRMWInst *RMW = dyn_cast<AtomicRMWInst>(I)) {
    if (!ClInstrumentAtomics || ignoreAccess(RMW->getPointerOperand()))
      return;
    Interesting.emplace_back(I, RMW->getPointerOperandIndex(), true,
                             RMW->getValOperand()->getType(), None);
  } else if (AtomicCmpXchgInst *XCHG = dyn_cast<AtomicCmpXchgInst>(I)) {
    if (!ClInstrumentAtomics || ignoreAccess(XCHG->getPointerOperand()))
      return;
    Interesting.emplace_back(I, XCHG->getPointerOperandIndex(), true,
                             XCHG->getCompareOperand()->getType(), None);
  } else if (auto CI = dyn_cast<CallInst>(I)) {
    for (unsigned ArgNo = 0; ArgNo < CI->getNumArgOperands(); ArgNo++) {
      if (!ClInstrumentByval || !CI->isByValArgument(ArgNo) ||
          ignoreAccess(CI->getArgOperand(ArgNo)))
        continue;
      Type *Ty = CI->getParamByValType(ArgNo);
      Interesting.emplace_back(I, ArgNo, false, Ty, Align(1));
    }
  }
}

static unsigned getPointerOperandIndex(Instruction *I) {
  if (LoadInst *LI = dyn_cast<LoadInst>(I))
    return LI->getPointerOperandIndex();
  if (StoreInst *SI = dyn_cast<StoreInst>(I))
    return SI->getPointerOperandIndex();
  if (AtomicRMWInst *RMW = dyn_cast<AtomicRMWInst>(I))
    return RMW->getPointerOperandIndex();
  if (AtomicCmpXchgInst *XCHG = dyn_cast<AtomicCmpXchgInst>(I))
    return XCHG->getPointerOperandIndex();
  report_fatal_error(""Unexpected instruction"");
  return -1;
}

static size_t TypeSizeToSizeIndex(uint32_t TypeSize) {
  size_t Res = countTrailingZeros(TypeSize / 8);
  assert(Res < kNumberOfAccessSizes);
  return Res;
}

void HWAddressSanitizer::untagPointerOperand(Instruction *I, Value *Addr) {
  if (TargetTriple.isAArch64())
    return;

  IRBuilder<> IRB(I);
  Value *AddrLong = IRB.CreatePointerCast(Addr, IntptrTy);
  Value *UntaggedPtr =
      IRB.CreateIntToPtr(untagPointer(IRB, AddrLong), Addr->getType());
  I->setOperand(getPointerOperandIndex(I), UntaggedPtr);
}

Value *HWAddressSanitizer::memToShadow(Value *Mem, IRBuilder<> &IRB) {
  // Mem >> Scale
  Value *Shadow = IRB.CreateLShr(Mem, Mapping.Scale);
  if (Mapping.Offset == 0)
    return IRB.CreateIntToPtr(Shadow, Int8PtrTy);
  // (Mem >> Scale) + Offset
  return IRB.CreateGEP(Int8Ty, ShadowBase, Shadow);
}

void HWAddressSanitizer::instrumentMemAccessInline(Value *Ptr, bool IsWrite,
                                                   unsigned AccessSizeIndex,
                                                   Instruction *InsertBefore) {
  const int64_t AccessInfo =
      (CompileKernel << HWASanAccessInfo::CompileKernelShift) +
      (HasMatchAllTag << HWASanAccessInfo::HasMatchAllShift) +
      (MatchAllTag << HWASanAccessInfo::MatchAllShift) +
      (Recover << HWASanAccessInfo::RecoverShift) +
      (IsWrite << HWASanAccessInfo::IsWriteShift) +
      (AccessSizeIndex << HWASanAccessInfo::AccessSizeShift);
  IRBuilder<> IRB(InsertBefore);

  if (OutlinedChecks) {
    Module *M = IRB.GetInsertBlock()->getParent()->getParent();
    Ptr = IRB.CreateBitCast(Ptr, Int8PtrTy);
    IRB.CreateCall(Intrinsic::getDeclaration(
                       M, UseShortGranules
                              ? Intrinsic::hwasan_check_memaccess_shortgranules
                              : Intrinsic::hwasan_check_memaccess),
                   {ShadowBase, Ptr, ConstantInt::get(Int32Ty, AccessInfo)});
    return;
  }

  Value *PtrLong = IRB.CreatePointerCast(Ptr, IntptrTy);
  Value *PtrTag = IRB.CreateTrunc(IRB.CreateLShr(PtrLong, kPointerTagShift),
                                  IRB.getInt8Ty());
  Value *AddrLong = untagPointer(IRB, PtrLong);
  Value *Shadow = memToShadow(AddrLong, IRB);
  Value *MemTag = IRB.CreateLoad(Int8Ty, Shadow);
  Value *TagMismatch = IRB.CreateICmpNE(PtrTag, MemTag);

  if (HasMatchAllTag) {
    Value *TagNotIgnored = IRB.CreateICmpNE(
        PtrTag, ConstantInt::get(PtrTag->getType(), MatchAllTag));
    TagMismatch = IRB.CreateAnd(TagMismatch, TagNotIgnored);
  }

  Instruction *CheckTerm =
      SplitBlockAndInsertIfThen(TagMismatch, InsertBefore, false,
                                MDBuilder(*C).createBranchWeights(1, 100000));

  IRB.SetInsertPoint(CheckTerm);
  Value *OutOfShortGranuleTagRange =
      IRB.CreateICmpUGT(MemTag, ConstantInt::get(Int8Ty, 15));
  Instruction *CheckFailTerm =
      SplitBlockAndInsertIfThen(OutOfShortGranuleTagRange, CheckTerm, !Recover,
                                MDBuilder(*C).createBranchWeights(1, 100000));

  IRB.SetInsertPoint(CheckTerm);
  Value *PtrLowBits = IRB.CreateTrunc(IRB.CreateAnd(PtrLong, 15), Int8Ty);
  PtrLowBits = IRB.CreateAdd(
      PtrLowBits, ConstantInt::get(Int8Ty, (1 << AccessSizeIndex) - 1));
  Value *PtrLowBitsOOB = IRB.CreateICmpUGE(PtrLowBits, MemTag);
  SplitBlockAndInsertIfThen(PtrLowBitsOOB, CheckTerm, false,
                            MDBuilder(*C).createBranchWeights(1, 100000),
                            nullptr, nullptr, CheckFailTerm->getParent());

  IRB.SetInsertPoint(CheckTerm);
  Value *InlineTagAddr = IRB.CreateOr(AddrLong, 15);
  InlineTagAddr = IRB.CreateIntToPtr(InlineTagAddr, Int8PtrTy);
  Value *InlineTag = IRB.CreateLoad(Int8Ty, InlineTagAddr);
  Value *InlineTagMismatch = IRB.CreateICmpNE(PtrTag, InlineTag);
  SplitBlockAndInsertIfThen(InlineTagMismatch, CheckTerm, false,
                            MDBuilder(*C).createBranchWeights(1, 100000),
                            nullptr, nullptr, CheckFailTerm->getParent());

  IRB.SetInsertPoint(CheckFailTerm);
  InlineAsm *Asm;
  switch (TargetTriple.getArch()) {
    case Triple::x86_64:
      // The signal handler will find the data address in rdi.
      Asm = InlineAsm::get(
          FunctionType::get(IRB.getVoidTy(), {PtrLong->getType()}, false),
          ""int3\\nnopl "" +
              itostr(0x40 + (AccessInfo & HWASanAccessInfo::RuntimeMask)) +
              ""(%rax)"",
          ""{rdi}"",
          /*hasSideEffects=*/true);
      break;
    case Triple::aarch64:
    case Triple::aarch64_be:
      // The signal handler will find the data address in x0.
      Asm = InlineAsm::get(
          FunctionType::get(IRB.getVoidTy(), {PtrLong->getType()}, false),
          ""brk #"" +
              itostr(0x900 + (AccessInfo & HWASanAccessInfo::RuntimeMask)),
          ""{x0}"",
          /*hasSideEffects=*/true);
      break;
    default:
      report_fatal_error(""unsupported architecture"");
  }
  IRB.CreateCall(Asm, PtrLong);
  if (Recover)
    cast<BranchInst>(CheckFailTerm)->setSuccessor(0, CheckTerm->getParent());
}

void HWAddressSanitizer::instrumentMemIntrinsic(MemIntrinsic *MI) {
  IRBuilder<> IRB(MI);
  if (isa<MemTransferInst>(MI)) {
    IRB.CreateCall(
        isa<MemMoveInst>(MI) ? HWAsanMemmove : HWAsanMemcpy,
        {IRB.CreatePointerCast(MI->getOperand(0), IRB.getInt8PtrTy()),
         IRB.CreatePointerCast(MI->getOperand(1), IRB.getInt8PtrTy()),
         IRB.CreateIntCast(MI->getOperand(2), IntptrTy, false)});
  } else if (isa<MemSetInst>(MI)) {
    IRB.CreateCall(
        HWAsanMemset,
        {IRB.CreatePointerCast(MI->getOperand(0), IRB.getInt8PtrTy()),
         IRB.CreateIntCast(MI->getOperand(1), IRB.getInt32Ty(), false),
         IRB.CreateIntCast(MI->getOperand(2), IntptrTy, false)});
  }
  MI->eraseFromParent();
}

bool HWAddressSanitizer::instrumentMemAccess(InterestingMemoryOperand &O) {
  Value *Addr = O.getPtr();

  LLVM_DEBUG(dbgs() << ""Instrumenting: "" << O.getInsn() << ""\\n"");

  if (O.MaybeMask)
    return false; //FIXME

  IRBuilder<> IRB(O.getInsn());
  if (isPowerOf2_64(O.TypeSize) &&
      (O.TypeSize / 8 <= (1ULL << (kNumberOfAccessSizes - 1))) &&
      (!O.Alignment || *O.Alignment >= (1ULL << Mapping.Scale) ||
       *O.Alignment >= O.TypeSize / 8)) {
    size_t AccessSizeIndex = TypeSizeToSizeIndex(O.TypeSize);
    if (ClInstrumentWithCalls) {
      IRB.CreateCall(HwasanMemoryAccessCallback[O.IsWrite][AccessSizeIndex],
                     IRB.CreatePointerCast(Addr, IntptrTy));
    } else {
      instrumentMemAccessInline(Addr, O.IsWrite, AccessSizeIndex, O.getInsn());
    }
  } else {
    IRB.CreateCall(HwasanMemoryAccessCallbackSized[O.IsWrite],
                   {IRB.CreatePointerCast(Addr, IntptrTy),
                    ConstantInt::get(IntptrTy, O.TypeSize / 8)});
  }
  untagPointerOperand(O.getInsn(), Addr);

  return true;
}

static uint64_t getAllocaSizeInBytes(const AllocaInst &AI) {
  uint64_t ArraySize = 1;
  if (AI.isArrayAllocation()) {
    const ConstantInt *CI = dyn_cast<ConstantInt>(AI.getArraySize());
    assert(CI && ""non-constant array size"");
    ArraySize = CI->getZExtValue();
  }
  Type *Ty = AI.getAllocatedType();
  uint64_t SizeInBytes = AI.getModule()->getDataLayout().getTypeAllocSize(Ty);
  return SizeInBytes * ArraySize;
}

bool HWAddressSanitizer::tagAlloca(IRBuilder<> &IRB, AllocaInst *AI,
                                   Value *Tag, size_t Size) {
  size_t AlignedSize = alignTo(Size, Mapping.getObjectAlignment());
  if (!UseShortGranules)
    Size = AlignedSize;

  Value *JustTag = IRB.CreateTrunc(Tag, IRB.getInt8Ty());
  if (ClInstrumentWithCalls) {
    IRB.CreateCall(HwasanTagMemoryFunc,
                   {IRB.CreatePointerCast(AI, Int8PtrTy), JustTag,
                    ConstantInt::get(IntptrTy, AlignedSize)});
  } else {
    size_t ShadowSize = Size >> Mapping.Scale;
    Value *ShadowPtr = memToShadow(IRB.CreatePointerCast(AI, IntptrTy), IRB);
    // If this memset is not inlined, it will be intercepted in the hwasan
    // runtime library. That's OK, because the interceptor skips the checks if
    // the address is in the shadow region.
    // FIXME: the interceptor is not as fast as real memset. Consider lowering
    // llvm.memset right here into either a sequence of stores, or a call to
    // hwasan_tag_memory.
    if (ShadowSize)
      IRB.CreateMemSet(ShadowPtr, JustTag, ShadowSize, Align(1));
    if (Size != AlignedSize) {
      IRB.CreateStore(
          ConstantInt::get(Int8Ty, Size % Mapping.getObjectAlignment()),
          IRB.CreateConstGEP1_32(Int8Ty, ShadowPtr, ShadowSize));
      IRB.CreateStore(JustTag, IRB.CreateConstGEP1_32(
                                   Int8Ty, IRB.CreateBitCast(AI, Int8PtrTy),
                                   AlignedSize - 1));
    }
  }
  return true;
}

static unsigned RetagMask(unsigned AllocaNo) {
  // A list of 8-bit numbers that have at most one run of non-zero bits.
  // x = x ^ (mask << 56) can be encoded as a single armv8 instruction for these
  // masks.
  // The list does not include the value 255, which is used for UAR.
  //
  // Because we are more likely to use earlier elements of this list than later
  // ones, it is sorted in increasing order of probability of collision with a
  // mask allocated (temporally) nearby. The program that generated this list
  // can be found at:
  // https://github.com/google/sanitizers/blob/master/hwaddress-sanitizer/sort_masks.py
  static unsigned FastMasks[] = {0,  128, 64,  192, 32,  96,  224, 112, 240,
                                 48, 16,  120, 248, 56,  24,  8,   124, 252,
                                 60, 28,  12,  4,   126, 254, 62,  30,  14,
                                 6,  2,   127, 63,  31,  15,  7,   3,   1};
  return FastMasks[AllocaNo % (sizeof(FastMasks) / sizeof(FastMasks[0]))];
}

Value *HWAddressSanitizer::getNextTagWithCall(IRBuilder<> &IRB) {
  return IRB.CreateZExt(IRB.CreateCall(HwasanGenerateTagFunc), IntptrTy);
}

Value *HWAddressSanitizer::getStackBaseTag(IRBuilder<> &IRB) {
  if (ClGenerateTagsWithCalls)
    return getNextTagWithCall(IRB);
  if (StackBaseTag)
    return StackBaseTag;
  // FIXME: use addressofreturnaddress (but implement it in aarch64 backend
  // first).
  Module *M = IRB.GetInsertBlock()->getParent()->getParent();
  auto GetStackPointerFn = Intrinsic::getDeclaration(
      M, Intrinsic::frameaddress,
      IRB.getInt8PtrTy(M->getDataLayout().getAllocaAddrSpace()));
  Value *StackPointer = IRB.CreateCall(
      GetStackPointerFn, {Constant::getNullValue(IRB.getInt32Ty())});

  // Extract some entropy from the stack pointer for the tags.
  // Take bits 20..28 (ASLR entropy) and xor with bits 0..8 (these differ
  // between functions).
  Value *StackPointerLong = IRB.CreatePointerCast(StackPointer, IntptrTy);
  Value *StackTag =
      IRB.CreateXor(StackPointerLong, IRB.CreateLShr(StackPointerLong, 20),
                    ""hwasan.stack.base.tag"");
  return StackTag;
}

Value *HWAddressSanitizer::getAllocaTag(IRBuilder<> &IRB, Value *StackTag,
                                        AllocaInst *AI, unsigned AllocaNo) {
  if (ClGenerateTagsWithCalls)
    return getNextTagWithCall(IRB);
  return IRB.CreateXor(StackTag,
                       ConstantInt::get(IntptrTy, RetagMask(AllocaNo)));
}

Value *HWAddressSanitizer::getUARTag(IRBuilder<> &IRB, Value *StackTag) {
  if (ClUARRetagToZero)
    return ConstantInt::get(IntptrTy, 0);
  if (ClGenerateTagsWithCalls)
    return getNextTagWithCall(IRB);
  return IRB.CreateXor(StackTag, ConstantInt::get(IntptrTy, 0xFFU));
}

// Add a tag to an address.
Value *HWAddressSanitizer::tagPointer(IRBuilder<> &IRB, Type *Ty,
                                      Value *PtrLong, Value *Tag) {
  Value *TaggedPtrLong;
  if (CompileKernel) {
    // Kernel addresses have 0xFF in the most significant byte.
    Value *ShiftedTag = IRB.CreateOr(
        IRB.CreateShl(Tag, kPointerTagShift),
        ConstantInt::get(IntptrTy, (1ULL << kPointerTagShift) - 1));
    TaggedPtrLong = IRB.CreateAnd(PtrLong, ShiftedTag);
  } else {
    // Userspace can simply do OR (tag << 56);
    Value *ShiftedTag = IRB.CreateShl(Tag, kPointerTagShift);
    TaggedPtrLong = IRB.CreateOr(PtrLong, ShiftedTag);
  }
  return IRB.CreateIntToPtr(TaggedPtrLong, Ty);
}

// Remove tag from an address.
Value *HWAddressSanitizer::untagPointer(IRBuilder<> &IRB, Value *PtrLong) {
  Value *UntaggedPtrLong;
  if (CompileKernel) {
    // Kernel addresses have 0xFF in the most significant byte.
    UntaggedPtrLong = IRB.CreateOr(PtrLong,
        ConstantInt::get(PtrLong->getType(), 0xFFULL << kPointerTagShift));
  } else {
    // Userspace addresses have 0x00.
    UntaggedPtrLong = IRB.CreateAnd(PtrLong,
        ConstantInt::get(PtrLong->getType(), ~(0xFFULL << kPointerTagShift)));
  }
  return UntaggedPtrLong;
}

Value *HWAddressSanitizer::getHwasanThreadSlotPtr(IRBuilder<> &IRB, Type *Ty) {
  Module *M = IRB.GetInsertBlock()->getParent()->getParent();
  if (TargetTriple.isAArch64() && TargetTriple.isAndroid()) {
    // Android provides a fixed TLS slot for sanitizers. See TLS_SLOT_SANITIZER
    // in Bionic's libc/private/bionic_tls.h.
    Function *ThreadPointerFunc =
        Intrinsic::getDeclaration(M, Intrinsic::thread_pointer);
    Value *SlotPtr = IRB.CreatePointerCast(
        IRB.CreateConstGEP1_32(IRB.getInt8Ty(),
                               IRB.CreateCall(ThreadPointerFunc), 0x30),
        Ty->getPointerTo(0));
    return SlotPtr;
  }
  if (ThreadPtrGlobal)
    return ThreadPtrGlobal;


  return nullptr;
}

void HWAddressSanitizer::emitPrologue(IRBuilder<> &IRB, bool WithFrameRecord) {
  if (!Mapping.InTls) {
    ShadowBase = getShadowNonTls(IRB);
    return;
  }

  if (!WithFrameRecord && TargetTriple.isAndroid()) {
    ShadowBase = getDynamicShadowIfunc(IRB);
    return;
  }

  Value *SlotPtr = getHwasanThreadSlotPtr(IRB, IntptrTy);
  assert(SlotPtr);

  Value *ThreadLong = IRB.CreateLoad(IntptrTy, SlotPtr);
  // Extract the address field from ThreadLong. Unnecessary on AArch64 with TBI.
  Value *ThreadLongMaybeUntagged =
      TargetTriple.isAArch64() ? ThreadLong : untagPointer(IRB, ThreadLong);

  if (WithFrameRecord) {
    Function *F = IRB.GetInsertBlock()->getParent();
    StackBaseTag = IRB.CreateAShr(ThreadLong, 3);

    // Prepare ring buffer data.
    Value *PC;
    if (TargetTriple.getArch() == Triple::aarch64)
      PC = readRegister(IRB, ""pc"");
    else
      PC = IRB.CreatePtrToInt(F, IntptrTy);
    Module *M = F->getParent();
    auto GetStackPointerFn = Intrinsic::getDeclaration(
        M, Intrinsic::frameaddress,
        IRB.getInt8PtrTy(M->getDataLayout().getAllocaAddrSpace()));
    Value *SP = IRB.CreatePtrToInt(
        IRB.CreateCall(GetStackPointerFn,
                       {Constant::getNullValue(IRB.getInt32Ty())}),
        IntptrTy);
    // Mix SP and PC.
    // Assumptions:
    // PC is 0x0000PPPPPPPPPPPP  (48 bits are meaningful, others are zero)
    // SP is 0xsssssssssssSSSS0  (4 lower bits are zero)
    // We only really need ~20 lower non-zero bits (SSSS), so we mix like this:
    //       0xSSSSPPPPPPPPPPPP
    SP = IRB.CreateShl(SP, 44);

    // Store data to ring buffer.
    Value *RecordPtr =
        IRB.CreateIntToPtr(ThreadLongMaybeUntagged, IntptrTy->getPointerTo(0));
    IRB.CreateStore(IRB.CreateOr(PC, SP), RecordPtr);

    // Update the ring buffer. Top byte of ThreadLong defines the size of the
    // buffer in pages, it must be a power of two, and the start of the buffer
    // must be aligned by twice that much. Therefore wrap around of the ring
    // buffer is simply Addr &= ~((ThreadLong >> 56) << 12).
    // The use of AShr instead of LShr is due to
    //   https://bugs.llvm.org/show_bug.cgi?id=39030
    // Runtime library makes sure not to use the highest bit.
    Value *WrapMask = IRB.CreateXor(
        IRB.CreateShl(IRB.CreateAShr(ThreadLong, 56), 12, """", true, true),
        ConstantInt::get(IntptrTy, (uint64_t)-1));
    Value *ThreadLongNew = IRB.CreateAnd(
        IRB.CreateAdd(ThreadLong, ConstantInt::get(IntptrTy, 8)), WrapMask);
    IRB.CreateStore(ThreadLongNew, SlotPtr);
  }

  // Get shadow base address by aligning RecordPtr up.
  // Note: this is not correct if the pointer is already aligned.
  // Runtime library will make sure this never happens.
  ShadowBase = IRB.CreateAdd(
      IRB.CreateOr(
          ThreadLongMaybeUntagged,
          ConstantInt::get(IntptrTy, (1ULL << kShadowBaseAlignment) - 1)),
      ConstantInt::get(IntptrTy, 1), ""hwasan.shadow"");
  ShadowBase = IRB.CreateIntToPtr(ShadowBase, Int8PtrTy);
}

Value *HWAddressSanitizer::readRegister(IRBuilder<> &IRB, StringRef Name) {
  Module *M = IRB.GetInsertBlock()->getParent()->getParent();
  Function *ReadRegister =
      Intrinsic::getDeclaration(M, Intrinsic::read_register, IntptrTy);
  MDNode *MD = MDNode::get(*C, {MDString::get(*C, Name)});
  Value *Args[] = {MetadataAsValue::get(*C, MD)};
  return IRB.CreateCall(ReadRegister, Args);
}

bool HWAddressSanitizer::instrumentLandingPads(
    SmallVectorImpl<Instruction *> &LandingPadVec) {
  for (auto *LP : LandingPadVec) {
    IRBuilder<> IRB(LP->getNextNode());
    IRB.CreateCall(
        HWAsanHandleVfork,
        {readRegister(IRB, (TargetTriple.getArch() == Triple::x86_64) ? ""rsp""
                                                                      : ""sp"")});
  }
  return true;
}

bool HWAddressSanitizer::instrumentStack(
    SmallVectorImpl<AllocaInst *> &Allocas,
    DenseMap<AllocaInst *, std::vector<DbgVariableIntrinsic *>> &AllocaDbgMap,
    SmallVectorImpl<Instruction *> &RetVec, Value *StackTag) {
  // Ideally, we want to calculate tagged stack base pointer, and rewrite all
  // alloca addresses using that. Unfortunately, offsets are not known yet
  // (unless we use ASan-style mega-alloca). Instead we keep the base tag in a
  // temp, shift-OR it into each alloca address and xor with the retag mask.
  // This generates one extra instruction per alloca use.
  for (unsigned N = 0; N < Allocas.size(); ++N) {
    auto *AI = Allocas[N];
    IRBuilder<> IRB(AI->getNextNode());

    // Replace uses of the alloca with tagged address.
    Value *Tag = getAllocaTag(IRB, StackTag, AI, N);
    Value *AILong = IRB.CreatePointerCast(AI, IntptrTy);
    Value *Replacement = tagPointer(IRB, AI->getType(), AILong, Tag);
    std::string Name =
        AI->hasName() ? AI->getName().str() : ""alloca."" + itostr(N);
    Replacement->setName(Name + "".hwasan"");

    AI->replaceUsesWithIf(Replacement,
                          [AILong](Use &U) { return U.getUser() != AILong; });

    for (auto *DDI : AllocaDbgMap.lookup(AI)) {
      // Prepend ""tag_offset, N"" to the dwarf expression.
      // Tag offset logically applies to the alloca pointer, and it makes sense
      // to put it at the beginning of the expression.
      SmallVector<uint64_t, 8> NewOps = {dwarf::DW_OP_LLVM_tag_offset,
                                         RetagMask(N)};
      DDI->setArgOperand(
          2, MetadataAsValue::get(*C, DIExpression::prependOpcodes(
                                          DDI->getExpression(), NewOps)));
    }

    size_t Size = getAllocaSizeInBytes(*AI);
    tagAlloca(IRB, AI, Tag, Size);

    for (auto RI : RetVec) {
      IRB.SetInsertPoint(RI);

      // Re-tag alloca memory with the special UAR tag.
      Value *Tag = getUARTag(IRB, StackTag);
      tagAlloca(IRB, AI, Tag, alignTo(Size, Mapping.getObjectAlignment()));
    }
  }

  return true;
}

bool HWAddressSanitizer::isInterestingAlloca(const AllocaInst &AI) {
  return (AI.getAllocatedType()->isSized() &&
          // FIXME: instrument dynamic allocas, too
          AI.isStaticAlloca() &&
          // alloca() may be called with 0 size, ignore it.
          getAllocaSizeInBytes(AI) > 0 &&
          // We are only interested in allocas not promotable to registers.
          // Promotable allocas are common under -O0.
          !isAllocaPromotable(&AI) &&
          // inalloca allocas are not treated as static, and we don't want
          // dynamic alloca instrumentation for them as well.
          !AI.isUsedWithInAlloca() &&
          // swifterror allocas are register promoted by ISel
          !AI.isSwiftError());
}

bool HWAddressSanitizer::sanitizeFunction(Function &F) {
  if (&F == HwasanCtorFunction)
    return false;

  if (!F.hasFnAttribute(Attribute::SanitizeHWAddress))
    return false;

  LLVM_DEBUG(dbgs() << ""Function: "" << F.getName() << ""\\n"");

  SmallVector<InterestingMemoryOperand, 16> OperandsToInstrument;
  SmallVector<MemIntrinsic *, 16> IntrinToInstrument;
  SmallVector<AllocaInst*, 8> AllocasToInstrument;
  SmallVector<Instruction*, 8> RetVec;
  SmallVector<Instruction*, 8> LandingPadVec;
  DenseMap<AllocaInst *, std::vector<DbgVariableIntrinsic *>> AllocaDbgMap;
  for (auto &BB : F) {
    for (auto &Inst : BB) {
      if (ClInstrumentStack)
        if (AllocaInst *AI = dyn_cast<AllocaInst>(&Inst)) {
          if (isInterestingAlloca(*AI))
            AllocasToInstrument.push_back(AI);
          continue;
        }

      if (isa<ReturnInst>(Inst) || isa<ResumeInst>(Inst) ||
          isa<CleanupReturnInst>(Inst))
        RetVec.push_back(&Inst);

      if (auto *DDI = dyn_cast<DbgVariableIntrinsic>(&Inst))
        if (auto *Alloca =
                dyn_cast_or_null<AllocaInst>(DDI->getVariableLocation()))
          AllocaDbgMap[Alloca].push_back(DDI);

      if (InstrumentLandingPads && isa<LandingPadInst>(Inst))
        LandingPadVec.push_back(&Inst);

      getInterestingMemoryOperands(&Inst, OperandsToInstrument);

      if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(&Inst))
        IntrinToInstrument.push_back(MI);
    }
  }

  initializeCallbacks(*F.getParent());

  bool Changed = false;

  if (!LandingPadVec.empty())
    Changed |= instrumentLandingPads(LandingPadVec);

  if (AllocasToInstrument.empty() && F.hasPersonalityFn() &&
      F.getPersonalityFn()->getName() == kHwasanPersonalityThunkName) {
    // __hwasan_personality_thunk is a no-op for functions without an
    // instrumented stack, so we can drop it.
    F.setPersonalityFn(nullptr);
    Changed = true;
  }

  if (AllocasToInstrument.empty() && OperandsToInstrument.empty() &&
      IntrinToInstrument.empty())
    return Changed;

  assert(!ShadowBase);

  Instruction *InsertPt = &*F.getEntryBlock().begin();
  IRBuilder<> EntryIRB(InsertPt);
  emitPrologue(EntryIRB,
               /*WithFrameRecord*/ ClRecordStackHistory &&
                   !AllocasToInstrument.empty());

  if (!AllocasToInstrument.empty()) {
    Value *StackTag =
        ClGenerateTagsWithCalls ? nullptr : getStackBaseTag(EntryIRB);
    instrumentStack(AllocasToInstrument, AllocaDbgMap, RetVec, StackTag);
  }
  // Pad and align each of the allocas that we instrumented to stop small
  // uninteresting allocas from hiding in instrumented alloca's padding and so
  // that we have enough space to store real tags for short granules.
  DenseMap<AllocaInst *, AllocaInst *> AllocaToPaddedAllocaMap;
  for (AllocaInst *AI : AllocasToInstrument) {
    uint64_t Size = getAllocaSizeInBytes(*AI);
    uint64_t AlignedSize = alignTo(Size, Mapping.getObjectAlignment());
    AI->setAlignment(
        Align(std::max(AI->getAlignment(), Mapping.getObjectAlignment())));
    if (Size != AlignedSize) {
      Type *AllocatedType = AI->getAllocatedType();
      if (AI->isArrayAllocation()) {
        uint64_t ArraySize =
            cast<ConstantInt>(AI->getArraySize())->getZExtValue();
        AllocatedType = ArrayType::get(AllocatedType, ArraySize);
      }
      Type *TypeWithPadding = StructType::get(
          AllocatedType, ArrayType::get(Int8Ty, AlignedSize - Size));
      auto *NewAI = new AllocaInst(
          TypeWithPadding, AI->getType()->getAddressSpace(), nullptr, """", AI);
      NewAI->takeName(AI);
      NewAI->setAlignment(AI->getAlign());
      NewAI->setUsedWithInAlloca(AI->isUsedWithInAlloca());
      NewAI->setSwiftError(AI->isSwiftError());
      NewAI->copyMetadata(*AI);
      auto *Bitcast = new BitCastInst(NewAI, AI->getType(), """", AI);
      AI->replaceAllUsesWith(Bitcast);
      AllocaToPaddedAllocaMap[AI] = NewAI;
    }
  }

  if (!AllocaToPaddedAllocaMap.empty()) {
    for (auto &BB : F)
      for (auto &Inst : BB)
        if (auto *DVI = dyn_cast<DbgVariableIntrinsic>(&Inst))
          if (auto *AI =
                  dyn_cast_or_null<AllocaInst>(DVI->getVariableLocation()))
            if (auto *NewAI = AllocaToPaddedAllocaMap.lookup(AI))
              DVI->setArgOperand(
                  0, MetadataAsValue::get(*C, LocalAsMetadata::get(NewAI)));
    for (auto &P : AllocaToPaddedAllocaMap)
      P.first->eraseFromParent();
  }

  // If we split the entry block, move any allocas that were originally in the
  // entry block back into the entry block so that they aren't treated as
  // dynamic allocas.
  if (EntryIRB.GetInsertBlock() != &F.getEntryBlock()) {
    InsertPt = &*F.getEntryBlock().begin();
    for (auto II = EntryIRB.GetInsertBlock()->begin(),
              IE = EntryIRB.GetInsertBlock()->end();
         II != IE;) {
      Instruction *I = &*II++;
      if (auto *AI = dyn_cast<AllocaInst>(I))
        if (isa<ConstantInt>(AI->getArraySize()))
          I->moveBefore(InsertPt);
    }
  }

  for (auto &Operand : OperandsToInstrument)
    instrumentMemAccess(Operand);

  if (ClInstrumentMemIntrinsics && !IntrinToInstrument.empty()) {
    for (auto Inst : IntrinToInstrument)
      instrumentMemIntrinsic(cast<MemIntrinsic>(Inst));
  }

  ShadowBase = nullptr;
  StackBaseTag = nullptr;

  return true;
}

void HWAddressSanitizer::instrumentGlobal(GlobalVariable *GV, uint8_t Tag) {
  Constant *Initializer = GV->getInitializer();
  uint64_t SizeInBytes =
      M.getDataLayout().getTypeAllocSize(Initializer->getType());
  uint64_t NewSize = alignTo(SizeInBytes, Mapping.getObjectAlignment());
  if (SizeInBytes != NewSize) {
    // Pad the initializer out to the next multiple of 16 bytes and add the
    // required short granule tag.
    std::vector<uint8_t> Init(NewSize - SizeInBytes, 0);
    Init.back() = Tag;
    Constant *Padding = ConstantDataArray::get(*C, Init);
    Initializer = ConstantStruct::getAnon({Initializer, Padding});
  }

  auto *NewGV = new GlobalVariable(M, Initializer->getType(), GV->isConstant(),
                                   GlobalValue::ExternalLinkage, Initializer,
                                   GV->getName() + "".hwasan"");
  NewGV->copyAttributesFrom(GV);
  NewGV->setLinkage(GlobalValue::PrivateLinkage);
  NewGV->copyMetadata(GV, 0);
  NewGV->setAlignment(
      MaybeAlign(std::max(GV->getAlignment(), Mapping.getObjectAlignment())));

  // It is invalid to ICF two globals that have different tags. In the case
  // where the size of the global is a multiple of the tag granularity the
  // contents of the globals may be the same but the tags (i.e. symbol values)
  // may be different, and the symbols are not considered during ICF. In the
  // case where the size is not a multiple of the granularity, the short granule
  // tags would discriminate two globals with different tags, but there would
  // otherwise be nothing stopping such a global from being incorrectly ICF'd
  // with an uninstrumented (i.e. tag 0) global that happened to have the short
  // granule tag in the last byte.
  NewGV->setUnnamedAddr(GlobalValue::UnnamedAddr::None);

  // Descriptor format (assuming little-endian):
  // bytes 0-3: relative address of global
  // bytes 4-6: size of global (16MB ought to be enough for anyone, but in case
  // it isn't, we create multiple descriptors)
  // byte 7: tag
  auto *DescriptorTy = StructType::get(Int32Ty, Int32Ty);
  const uint64_t MaxDescriptorSize = 0xfffff0;
  for (uint64_t DescriptorPos = 0; DescriptorPos < SizeInBytes;
       DescriptorPos += MaxDescriptorSize) {
    auto *Descriptor =
        new GlobalVariable(M, DescriptorTy, true, GlobalValue::PrivateLinkage,
                           nullptr, GV->getName() + "".hwasan.descriptor"");
    auto *GVRelPtr = ConstantExpr::getTrunc(
        ConstantExpr::getAdd(
            ConstantExpr::getSub(
                ConstantExpr::getPtrToInt(NewGV, Int64Ty),
                ConstantExpr::getPtrToInt(Descriptor, Int64Ty)),
            ConstantInt::get(Int64Ty, DescriptorPos)),
        Int32Ty);
    uint32_t Size = std::min(SizeInBytes - DescriptorPos, MaxDescriptorSize);
    auto *SizeAndTag = ConstantInt::get(Int32Ty, Size | (uint32_t(Tag) << 24));
    Descriptor->setComdat(NewGV->getComdat());
    Descriptor->setInitializer(ConstantStruct::getAnon({GVRelPtr, SizeAndTag}));
    Descriptor->setSection(""hwasan_globals"");
    Descriptor->setMetadata(LLVMContext::MD_associated,
                            MDNode::get(*C, ValueAsMetadata::get(NewGV)));
    appendToCompilerUsed(M, Descriptor);
  }

  Constant *Aliasee = ConstantExpr::getIntToPtr(
      ConstantExpr::getAdd(
          ConstantExpr::getPtrToInt(NewGV, Int64Ty),
          ConstantInt::get(Int64Ty, uint64_t(Tag) << kPointerTagShift)),
      GV->getType());
  auto *Alias = GlobalAlias::create(GV->getValueType(), GV->getAddressSpace(),
                                    GV->getLinkage(), """", Aliasee, &M);
  Alias->setVisibility(GV->getVisibility());
  Alias->takeName(GV);
  GV->replaceAllUsesWith(Alias);
  GV->eraseFromParent();
}

void HWAddressSanitizer::instrumentGlobals() {
  std::vector<GlobalVariable *> Globals;
  for (GlobalVariable &GV : M.globals()) {
    if (GV.isDeclarationForLinker() || GV.getName().startswith(""llvm."") ||
        GV.isThreadLocal())
      continue;

    // Common symbols can't have aliases point to them, so they can't be tagged.
    if (GV.hasCommonLinkage())
      continue;

    // Globals with custom sections may be used in __start_/__stop_ enumeration,
    // which would be broken both by adding tags and potentially by the extra
    // padding/alignment that we insert.
    if (GV.hasSection())
      continue;

    Globals.push_back(&GV);
  }

  MD5 Hasher;
  Hasher.update(M.getSourceFileName());
  MD5::MD5Result Hash;
  Hasher.final(Hash);
  uint8_t Tag = Hash[0];

  for (GlobalVariable *GV : Globals) {
    // Skip tag 0 in order to avoid collisions with untagged memory.
    if (Tag == 0)
      Tag = 1;
    instrumentGlobal(GV, Tag++);
  }
}

void HWAddressSanitizer::instrumentPersonalityFunctions() {
  // We need to untag stack frames as we unwind past them. That is the job of
  // the personality function wrapper, which either wraps an existing
  // personality function or acts as a personality function on its own. Each
  // function that has a personality function or that can be unwound past has
  // its personality function changed to a thunk that calls the personality
  // function wrapper in the runtime.
  MapVector<Constant *, std::vector<Function *>> PersonalityFns;
  for (Function &F : M) {
    if (F.isDeclaration() || !F.hasFnAttribute(Attribute::SanitizeHWAddress))
      continue;

    if (F.hasPersonalityFn()) {
      PersonalityFns[F.getPersonalityFn()->stripPointerCasts()].push_back(&F);
    } else if (!F.hasFnAttribute(Attribute::NoUnwind)) {
      PersonalityFns[nullptr].push_back(&F);
    }
  }

  if (PersonalityFns.empty())
    return;

  FunctionCallee HwasanPersonalityWrapper = M.getOrInsertFunction(
      ""__hwasan_personality_wrapper"", Int32Ty, Int32Ty, Int32Ty, Int64Ty,
      Int8PtrTy, Int8PtrTy, Int8PtrTy, Int8PtrTy, Int8PtrTy);
  FunctionCallee UnwindGetGR = M.getOrInsertFunction(""_Unwind_GetGR"", VoidTy);
  FunctionCallee UnwindGetCFA = M.getOrInsertFunction(""_Unwind_GetCFA"", VoidTy);

  for (auto &P : PersonalityFns) {
    std::string ThunkName = kHwasanPersonalityThunkName;
    if (P.first)
      ThunkName += (""."" + P.first->getName()).str();
    FunctionType *ThunkFnTy = FunctionType::get(
        Int32Ty, {Int32Ty, Int32Ty, Int64Ty, Int8PtrTy, Int8PtrTy}, false);
    bool IsLocal = P.first && (!isa<GlobalValue>(P.first) ||
                               cast<GlobalValue>(P.first)->hasLocalLinkage());
    auto *ThunkFn = Function::Create(ThunkFnTy,
                                     IsLocal ? GlobalValue::InternalLinkage
                                             : GlobalValue::LinkOnceODRLinkage,
                                     ThunkName, &M);
    if (!IsLocal) {
      ThunkFn->setVisibility(GlobalValue::HiddenVisibility);
      ThunkFn->setComdat(M.getOrInsertComdat(ThunkName));
    }

    auto *BB = BasicBlock::Create(*C, ""entry"", ThunkFn);
    IRBuilder<> IRB(BB);
    CallInst *WrapperCall = IRB.CreateCall(
        HwasanPersonalityWrapper,
        {ThunkFn->getArg(0), ThunkFn->getArg(1), ThunkFn->getArg(2),
         ThunkFn->getArg(3), ThunkFn->getArg(4),
         P.first ? IRB.CreateBitCast(P.first, Int8PtrTy)
                 : Constant::getNullValue(Int8PtrTy),
         IRB.CreateBitCast(UnwindGetGR.getCallee(), Int8PtrTy),
         IRB.CreateBitCast(UnwindGetCFA.getCallee(), Int8PtrTy)});
    WrapperCall->setTailCall();
    IRB.CreateRet(WrapperCall);

    for (Function *F : P.second)
      F->setPersonalityFn(ThunkFn);
  }
}

void HWAddressSanitizer::ShadowMapping::init(Triple &TargetTriple) {
  Scale = kDefaultShadowScale;
  if (ClMappingOffset.getNumOccurrences() > 0) {
    InGlobal = false;
    InTls = false;
    Offset = ClMappingOffset;
  } else if (ClEnableKhwasan || ClInstrumentWithCalls) {
    InGlobal = false;
    InTls = false;
    Offset = 0;
  } else if (ClWithIfunc) {
    InGlobal = true;
    InTls = false;
    Offset = kDynamicShadowSentinel;
  } else if (ClWithTls) {
    InGlobal = false;
    InTls = true;
    Offset = kDynamicShadowSentinel;
  } else {
    InGlobal = false;
    InTls = false;
    Offset = kDynamicShadowSentinel;
  }
}
",16171,True,2948.048171392477,median
"[[debezium-mysql-component]]
= Debezium MySQL Connector Component
:docTitle: Debezium MySQL Connector
:artifactId: camel-debezium-mysql
:description: Capture changes from a MySQL database.
:since: 3.0
:supportLevel: Stable
:component-header: Only consumer is supported
include::{cq-version}@camel-quarkus:ROOT:partial$reference/components/debezium-mysql.adoc[opts=optional]

*Since Camel {since}*

*{component-header}*

The Debezium MySQL component is wrapper around https://debezium.io/[Debezium] using https://debezium.io/documentation/reference/0.9/operations/embedded.html[Debezium Embedded], which enables Change Data Capture from MySQL database using Debezium without the need for Kafka or Kafka Connect.

*Note on handling failures:* Per https://debezium.io/documentation/reference/0.9/operations/embedded.html#_handling_failures[Debezium Embedded Engine] documentation, the engines is actively recording source offsets and periodically flushes these offsets to a persistent storage, so when the application is restarted or crashed, the engine will resume from the last recorded offset.
Thus, at normal operation, your downstream routes will receive each event exactly once, however in case of an application crash (not having a graceful shutdown), the application will resume from the last recorded offset,
which may result in receiving duplicate events immediately after the restart. Therefore, your downstream routes should be tolerant enough of such case and deduplicate events if needed.

*Note:* The Debezium MySQL component is currently not supported in OSGi

Maven users will need to add the following dependency to their `pom.xml`
for this component.

[source,xml]
----
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-debezium-mysql</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>
----

== URI format

[source,text]
---------------------------
debezium-mysql:name[?options]
---------------------------

*Note:* Due to licensing issues, you will need to add the dependency for `mysql-conenctor-java` if you are using MySQL connector, just add the following to your POM file:
[source,xml]
----
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.15</version>
</dependency>
----

== Options


// component options: START
The Debezium MySQL Connector component supports 80 options, which are listed below.



[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *additionalProperties* (common) | Additional properties for debezium components in case they can't be set directly on the camel configurations (e.g: setting Kafka Connect properties needed by Debezium engine, for example setting KafkaOffsetBackingStore), the properties have to be prefixed with additionalProperties.. E.g: additionalProperties.transactional.id=12345&additionalProperties.schema.registry.url=\\http://localhost:8811/avro |  | Map
| *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | boolean
| *configuration* (consumer) | Allow pre-configured Configurations to be set. |  | MySqlConnectorEmbeddedDebeziumConfiguration
| *internalKeyConverter* (consumer) | The Converter class that should be used to serialize and deserialize key data for offsets. The default is JSON converter. | org.apache.kafka.connect.json.JsonConverter | String
| *internalValueConverter* (consumer) | The Converter class that should be used to serialize and deserialize value data for offsets. The default is JSON converter. | org.apache.kafka.connect.json.JsonConverter | String
| *offsetCommitPolicy* (consumer) | The name of the Java class of the commit policy. It defines when offsets commit has to be triggered based on the number of events processed and the time elapsed since the last commit. This class must implement the interface 'OffsetCommitPolicy'. The default is a periodic commit policy based upon time intervals. | io.debezium.embedded.spi.OffsetCommitPolicy.PeriodicCommitOffsetPolicy | String
| *offsetCommitTimeoutMs* (consumer) | Maximum number of milliseconds to wait for records to flush and partition offset data to be committed to offset storage before cancelling the process and restoring the offset data to be committed in a future attempt. The default is 5 seconds. | 5s | long
| *offsetFlushIntervalMs* (consumer) | Interval at which to try committing offsets. The default is 1 minute. | 60s | long
| *offsetStorage* (consumer) | The name of the Java class that is responsible for persistence of connector offsets. | org.apache.kafka.connect.storage.FileOffsetBackingStore | String
| *offsetStorageFileName* (consumer) | Path to file where offsets are to be stored. Required when offset.storage is set to the FileOffsetBackingStore. |  | String
| *offsetStoragePartitions* (consumer) | The number of partitions used when creating the offset storage topic. Required when offset.storage is set to the 'KafkaOffsetBackingStore'. |  | int
| *offsetStorageReplicationFactor* (consumer) | Replication factor used when creating the offset storage topic. Required when offset.storage is set to the KafkaOffsetBackingStore |  | int
| *offsetStorageTopic* (consumer) | The name of the Kafka topic where offsets are to be stored. Required when offset.storage is set to the KafkaOffsetBackingStore. |  | String
| *autowiredEnabled* (advanced) | Whether autowiring is enabled. This is used for automatic autowiring options (the option must be marked as autowired) by looking up in the registry to find if there is a single instance of matching type, which then gets configured on the component. This can be used for automatic configuring JDBC data sources, JMS connection factories, AWS Clients, etc. | true | boolean
| *bigintUnsignedHandlingMode* (mysql) | Specify how BIGINT UNSIGNED columns should be represented in change events, including:'precise' uses java.math.BigDecimal to represent values, which are encoded in the change events using a binary representation and Kafka Connect's 'org.apache.kafka.connect.data.Decimal' type; 'long' (the default) represents values using Java's 'long', which may not offer the precision but will be far easier to use in consumers. | long | String
| *binaryHandlingMode* (mysql) | Specify how binary (blob, binary, etc.) columns should be represented in change events, including:'bytes' represents binary data as byte array (default)'base64' represents binary data as base64-encoded string'hex' represents binary data as hex-encoded (base16) string | bytes | String
| *binlogBufferSize* (mysql) | The size of a look-ahead buffer used by the binlog reader to decide whether the transaction in progress is going to be committed or rolled back. Use 0 to disable look-ahead buffering. Defaults to 0 (i.e. buffering is disabled). | 0 | int
| *columnBlacklist* (mysql) | Regular expressions matching columns to exclude from change events (deprecated, use column.exclude.list instead) |  | String
| *columnExcludeList* (mysql) | Regular expressions matching columns to exclude from change events |  | String
| *columnIncludeList* (mysql) | Regular expressions matching columns to include in change events |  | String
| *connectKeepAlive* (mysql) | Whether a separate thread should be used to ensure the connection is kept alive. | true | boolean
| *connectKeepAliveIntervalMs* (mysql) | Interval in milliseconds to wait for connection checking if keep alive thread is used. | 1m | long
| *connectTimeoutMs* (mysql) | Maximum time in milliseconds to wait after trying to connect to the database before timing out. | 30s | int
| *databaseExcludeList* (mysql) | A comma-separated list of regular expressions that match database names to be excluded from monitoring |  | String
| *databaseHistory* (mysql) | The name of the DatabaseHistory class that should be used to store and recover database schema changes. The configuration properties for the history are prefixed with the 'database.history.' string. | io.debezium.relational.history.FileDatabaseHistory | String
| *databaseHistoryFileFilename* (mysql) | The path to the file that will be used to record the database history |  | String
| *databaseHistoryKafkaBootstrap{zwsp}Servers* (mysql) | A list of host/port pairs that the connector will use for establishing the initial connection to the Kafka cluster for retrieving database schema history previously stored by the connector. This should point to the same Kafka cluster used by the Kafka Connect process. |  | String
| *databaseHistoryKafkaRecovery{zwsp}Attempts* (mysql) | The number of attempts in a row that no data are returned from Kafka before recover completes. The maximum amount of time to wait after receiving no data is (recovery.attempts) x (recovery.poll.interval.ms). | 100 | int
| *databaseHistoryKafkaRecovery{zwsp}PollIntervalMs* (mysql) | The number of milliseconds to wait while polling for persisted data during recovery. | 100ms | int
| *databaseHistoryKafkaTopic* (mysql) | The name of the topic for the database schema history |  | String
| *databaseHistorySkipUnparseable{zwsp}Ddl* (mysql) | Controls the action Debezium will take when it meets a DDL statement in binlog, that it cannot parse.By default the connector will stop operating but by changing the setting it can ignore the statements which it cannot parse. If skipping is enabled then Debezium can miss metadata changes. | false | boolean
| *databaseHistoryStoreOnly{zwsp}MonitoredTablesDdl* (mysql) | Controls what DDL will Debezium store in database history.By default (false) Debezium will store all incoming DDL statements. If set to truethen only DDL that manipulates a monitored table will be stored. | false | boolean
| *databaseHostname* (mysql) | Resolvable hostname or IP address of the MySQL database server. |  | String
| *databaseIncludeList* (mysql) | The databases for which changes are to be captured |  | String
| *databaseInitialStatements* (mysql) | A semicolon separated list of SQL statements to be executed when a JDBC connection (not binlog reading connection) to the database is established. Note that the connector may establish JDBC connections at its own discretion, so this should typically be used for configuration of session parameters only,but not for executing DML statements. Use doubled semicolon (';;') to use a semicolon as a character and not as a delimiter. |  | String
| *databaseJdbcDriver* (mysql) | JDBC Driver class name used to connect to the MySQL database server. | class com.mysql.cj.jdbc.Driver | String
| *databasePassword* (mysql) | *Required* Password of the MySQL database user to be used when connecting to the database. |  | String
| *databasePort* (mysql) | Port of the MySQL database server. | 3306 | int
| *databaseServerId* (mysql) | A numeric ID of this database client, which must be unique across all currently-running database processes in the cluster. This connector joins the MySQL database cluster as another server (with this unique ID) so it can read the binlog. By default, a random number is generated between 5400 and 6400. |  | long
| *databaseServerIdOffset* (mysql) | Only relevant if parallel snapshotting is configured. During parallel snapshotting, multiple (4) connections open to the database client, and they each need their own unique connection ID. This offset is used to generate those IDs from the base configured cluster ID. | 10000 | long
| *databaseServerName* (mysql) | *Required* Unique name that identifies the database server and all recorded offsets, and that is used as a prefix for all schemas and topics. Each distinct installation should have a separate namespace and be monitored by at most one Debezium connector. |  | String
| *databaseSslKeystore* (mysql) | Location of the Java keystore file containing an application process's own certificate and private key. |  | String
| *databaseSslKeystorePassword* (mysql) | Password to access the private key from the keystore file specified by 'ssl.keystore' configuration property or the 'javax.net.ssl.keyStore' system or JVM property. This password is used to unlock the keystore file (store password), and to decrypt the private key stored in the keystore (key password). |  | String
| *databaseSslMode* (mysql) | Whether to use an encrypted connection to MySQL. Options include'disabled' (the default) to use an unencrypted connection; 'preferred' to establish a secure (encrypted) connection if the server supports secure connections, but fall back to an unencrypted connection otherwise; 'required' to use a secure (encrypted) connection, and fail if one cannot be established; 'verify_ca' like 'required' but additionally verify the server TLS certificate against the configured Certificate Authority (CA) certificates, or fail if no valid matching CA certificates are found; or'verify_identity' like 'verify_ca' but additionally verify that the server certificate matches the host to which the connection is attempted. | disabled | String
| *databaseSslTruststore* (mysql) | Location of the Java truststore file containing the collection of CA certificates trusted by this application process (trust store). |  | String
| *databaseSslTruststorePassword* (mysql) | Password to unlock the keystore file (store password) specified by 'ssl.trustore' configuration property or the 'javax.net.ssl.trustStore' system or JVM property. |  | String
| *databaseUser* (mysql) | Name of the MySQL database user to be used when connecting to the database. |  | String
| *decimalHandlingMode* (mysql) | Specify how DECIMAL and NUMERIC columns should be represented in change events, including:'precise' (the default) uses java.math.BigDecimal to represent values, which are encoded in the change events using a binary representation and Kafka Connect's 'org.apache.kafka.connect.data.Decimal' type; 'string' uses string to represent values; 'double' represents values using Java's 'double', which may not offer the precision but will be far easier to use in consumers. | precise | String
| *enableTimeAdjuster* (mysql) | MySQL allows user to insert year value as either 2-digit or 4-digit. In case of two digit the value is automatically mapped into 1970 - 2069.false - delegates the implicit conversion to the databasetrue - (the default) Debezium makes the conversion | true | boolean
| *eventDeserializationFailure{zwsp}HandlingMode* (mysql) | Specify how failures during deserialization of binlog events (i.e. when encountering a corrupted event) should be handled, including:'fail' (the default) an exception indicating the problematic event and its binlog position is raised, causing the connector to be stopped; 'warn' the problematic event and its binlog position will be logged and the event will be skipped;'ignore' the problematic event will be skipped. | fail | String
| *eventProcessingFailureHandling{zwsp}Mode* (mysql) | Specify how failures during processing of events (i.e. when encountering a corrupted event) should be handled, including:'fail' (the default) an exception indicating the problematic event and its position is raised, causing the connector to be stopped; 'warn' the problematic event and its position will be logged and the event will be skipped;'ignore' the problematic event will be skipped. | fail | String
| *gtidNewChannelPosition* (mysql) | If set to 'latest', when connector sees new GTID, it will start consuming gtid channel from the server latest executed gtid position. If 'earliest' (the default) connector starts reading channel from first available (not purged) gtid position on the server. | earliest | String
| *gtidSourceExcludes* (mysql) | The source UUIDs used to exclude GTID ranges when determine the starting position in the MySQL server's binlog. |  | String
| *gtidSourceFilterDmlEvents* (mysql) | If set to true, we will only produce DML events into Kafka for transactions that were written on mysql servers with UUIDs matching the filters defined by the gtid.source.includes or gtid.source.excludes configuration options, if they are specified. | true | boolean
| *gtidSourceIncludes* (mysql) | The source UUIDs used to include GTID ranges when determine the starting position in the MySQL server's binlog. |  | String
| *heartbeatIntervalMs* (mysql) | Length of an interval in milli-seconds in in which the connector periodically sends heartbeat messages to a heartbeat topic. Use 0 to disable heartbeat messages. Disabled by default. | 0ms | int
| *heartbeatTopicsPrefix* (mysql) | The prefix that is used to name heartbeat topics.Defaults to __debezium-heartbeat. | __debezium-heartbeat | String
| *includeQuery* (mysql) | Whether the connector should include the original SQL query that generated the change event. Note: This option requires MySQL be configured with the binlog_rows_query_log_events option set to ON. Query will not be present for events generated from snapshot. WARNING: Enabling this option may expose tables or fields explicitly blacklisted or masked by including the original SQL statement in the change event. For this reason the default value is 'false'. | false | boolean
| *includeSchemaChanges* (mysql) | Whether the connector should publish changes in the database schema to a Kafka topic with the same name as the database server ID. Each schema change will be recorded using a key that contains the database name and whose value include logical description of the new schema and optionally the DDL statement(s).The default is 'true'. This is independent of how the connector internally records database history. | true | boolean
| *inconsistentSchemaHandlingMode* (mysql) | Specify how binlog events that belong to a table missing from internal schema representation (i.e. internal representation is not consistent with database) should be handled, including:'fail' (the default) an exception indicating the problematic event and its binlog position is raised, causing the connector to be stopped; 'warn' the problematic event and its binlog position will be logged and the event will be skipped;'skip' the problematic event will be skipped. | fail | String
| *maxBatchSize* (mysql) | Maximum size of each batch of source records. Defaults to 2048. | 2048 | int
| *maxQueueSize* (mysql) | Maximum size of the queue for change events read from the database log but not yet recorded or forwarded. Defaults to 8192, and should always be larger than the maximum batch size. | 8192 | int
| *messageKeyColumns* (mysql) | A semicolon-separated list of expressions that match fully-qualified tables and column(s) to be used as message key. Each expression must match the pattern ':',where the table names could be defined as (DB_NAME.TABLE_NAME) or (SCHEMA_NAME.TABLE_NAME), depending on the specific connector,and the key columns are a comma-separated list of columns representing the custom key. For any table without an explicit key configuration the table's primary key column(s) will be used as message key.Example: dbserver1.inventory.orderlines:orderId,orderLineId;dbserver1.inventory.orders:id |  | String
| *pollIntervalMs* (mysql) | Frequency in milliseconds to wait for new change events to appear after receiving no events. Defaults to 500ms. | 500ms | long
| *skippedOperations* (mysql) | The comma-separated list of operations to skip during streaming, defined as: 'i' for inserts; 'u' for updates; 'd' for deletes. By default, no operations will be skipped. |  | String
| *snapshotDelayMs* (mysql) | The number of milliseconds to delay before a snapshot will begin. | 0ms | long
| *snapshotEventsAsInserts* (mysql) | Whether or not to mark snapshot events as normal inserts (op 'c'). If disabled, the standard functionality of emitting these records as reads (op 'r') will be used. | true | boolean
| *snapshotFetchSize* (mysql) | The maximum number of records that should be loaded into memory while performing a snapshot |  | int
| *snapshotLockingMode* (mysql) | Controls how long the connector holds onto the global read lock while it is performing a snapshot. The default is 'minimal', which means the connector holds the global read lock (and thus prevents any updates) for just the initial portion of the snapshot while the database schemas and other metadata are being read. The remaining work in a snapshot involves selecting all rows from each table, and this can be done using the snapshot process' REPEATABLE READ transaction even when the lock is no longer held and other operations are updating the database. However, in some cases it may be desirable to block all writes for the entire duration of the snapshot; in such cases set this property to 'extended'. Using a value of 'none' will prevent the connector from acquiring any table locks during the snapshot process. This mode can only be used in combination with snapshot.mode values of 'schema_only' or 'schema_only_recovery' and is only safe to use if no schema changes are happening while the snapshot is taken. | minimal | String
| *snapshotMode* (mysql) | The criteria for running a snapshot upon startup of the connector. Options include: 'when_needed' to specify that the connector run a snapshot upon startup whenever it deems it necessary; 'schema_only' to only take a snapshot of the schema (table structures) but no actual data; 'initial' (the default) to specify the connector can run a snapshot only when no offsets are available for the logical server name; 'initial_only' same as 'initial' except the connector should stop after completing the snapshot and before it would normally read the binlog; and'never' to specify the connector should never run a snapshot and that upon first startup the connector should read from the beginning of the binlog. The 'never' mode should be used with care, and only when the binlog is known to contain all history. | initial | String
| *snapshotNewTables* (mysql) | BETA FEATURE: On connector restart, the connector will check if there have been any new tables added to the configuration, and snapshot them. There is presently only two options:'off': Default behavior. Do not snapshot new tables.'parallel': The snapshot of the new tables will occur in parallel to the continued binlog reading of the old tables. When the snapshot completes, an independent binlog reader will begin reading the events for the new tables until it catches up to present time. At this point, both old and new binlog readers will be momentarily halted and new binlog reader will start that will read the binlog for all configured tables. The parallel binlog reader will have a configured server id of 10000 the primary binlog reader's server id. | off | String
| *snapshotSelectStatement{zwsp}Overrides* (mysql) | This property contains a comma-separated list of fully-qualified tables (DB_NAME.TABLE_NAME) or (SCHEMA_NAME.TABLE_NAME), depending on thespecific connectors . Select statements for the individual tables are specified in further configuration properties, one for each table, identified by the id 'snapshot.select.statement.overrides.DB_NAME.TABLE_NAME' or 'snapshot.select.statement.overrides.SCHEMA_NAME.TABLE_NAME', respectively. The value of those properties is the select statement to use when retrieving data from the specific table during snapshotting. A possible use case for large append-only tables is setting a specific point where to start (resume) snapshotting, in case a previous snapshotting was interrupted. |  | String
| *sourceStructVersion* (mysql) | A version of the format of the publicly visible source part in the message | v2 | String
| *tableBlacklist* (mysql) | A comma-separated list of regular expressions that match the fully-qualified names of tables to be excluded from monitoring (deprecated, use table.exclude.list instead) |  | String
| *tableExcludeList* (mysql) | A comma-separated list of regular expressions that match the fully-qualified names of tables to be excluded from monitoring |  | String
| *tableIgnoreBuiltin* (mysql) | Flag specifying whether built-in tables should be ignored. | true | boolean
| *tableIncludeList* (mysql) | The tables for which changes are to be captured |  | String
| *tableWhitelist* (mysql) | The tables for which changes are to be captured (deprecated, use table.include.list instead) |  | String
| *timePrecisionMode* (mysql) | Time, date and timestamps can be represented with different kinds of precisions, including:'adaptive_time_microseconds': the precision of date and timestamp values is based the database column's precision; but time fields always use microseconds precision;'connect': always represents time, date and timestamp values using Kafka Connect's built-in representations for Time, Date, and Timestamp, which uses millisecond precision regardless of the database columns' precision. | adaptive_time_microseconds | String
| *tombstonesOnDelete* (mysql) | Whether delete operations should be represented by a delete event and a subsquenttombstone event (true) or only by a delete event (false). Emitting the tombstone event (the default behavior) allows Kafka to completely delete all events pertaining to the given key once the source record got deleted. | false | boolean
|===
// component options: END


// endpoint options: START
The Debezium MySQL Connector endpoint is configured using URI syntax:

----
debezium-mysql:name
----

with the following path and query parameters:

=== Path Parameters (1 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *name* | *Required* Unique name for the connector. Attempting to register again with the same name will fail. |  | String
|===


=== Query Parameters (81 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *additionalProperties* (common) | Additional properties for debezium components in case they can't be set directly on the camel configurations (e.g: setting Kafka Connect properties needed by Debezium engine, for example setting KafkaOffsetBackingStore), the properties have to be prefixed with additionalProperties.. E.g: additionalProperties.transactional.id=12345&additionalProperties.schema.registry.url=\\http://localhost:8811/avro |  | Map
| *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | boolean
| *internalKeyConverter* (consumer) | The Converter class that should be used to serialize and deserialize key data for offsets. The default is JSON converter. | org.apache.kafka.connect.json.JsonConverter | String
| *internalValueConverter* (consumer) | The Converter class that should be used to serialize and deserialize value data for offsets. The default is JSON converter. | org.apache.kafka.connect.json.JsonConverter | String
| *offsetCommitPolicy* (consumer) | The name of the Java class of the commit policy. It defines when offsets commit has to be triggered based on the number of events processed and the time elapsed since the last commit. This class must implement the interface 'OffsetCommitPolicy'. The default is a periodic commit policy based upon time intervals. | io.debezium.embedded.spi.OffsetCommitPolicy.PeriodicCommitOffsetPolicy | String
| *offsetCommitTimeoutMs* (consumer) | Maximum number of milliseconds to wait for records to flush and partition offset data to be committed to offset storage before cancelling the process and restoring the offset data to be committed in a future attempt. The default is 5 seconds. | 5s | long
| *offsetFlushIntervalMs* (consumer) | Interval at which to try committing offsets. The default is 1 minute. | 60s | long
| *offsetStorage* (consumer) | The name of the Java class that is responsible for persistence of connector offsets. | org.apache.kafka.connect.storage.FileOffsetBackingStore | String
| *offsetStorageFileName* (consumer) | Path to file where offsets are to be stored. Required when offset.storage is set to the FileOffsetBackingStore. |  | String
| *offsetStoragePartitions* (consumer) | The number of partitions used when creating the offset storage topic. Required when offset.storage is set to the 'KafkaOffsetBackingStore'. |  | int
| *offsetStorageReplicationFactor* (consumer) | Replication factor used when creating the offset storage topic. Required when offset.storage is set to the KafkaOffsetBackingStore |  | int
| *offsetStorageTopic* (consumer) | The name of the Kafka topic where offsets are to be stored. Required when offset.storage is set to the KafkaOffsetBackingStore. |  | String
| *exceptionHandler* (consumer) | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this option is not in use. By default the consumer will deal with exceptions, that will be logged at WARN or ERROR level and ignored. |  | ExceptionHandler
| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut |  | ExchangePattern
| *synchronous* (advanced) | Sets whether synchronous processing should be strictly used, or Camel is allowed to use asynchronous processing (if supported). | false | boolean
| *bigintUnsignedHandlingMode* (mysql) | Specify how BIGINT UNSIGNED columns should be represented in change events, including:'precise' uses java.math.BigDecimal to represent values, which are encoded in the change events using a binary representation and Kafka Connect's 'org.apache.kafka.connect.data.Decimal' type; 'long' (the default) represents values using Java's 'long', which may not offer the precision but will be far easier to use in consumers. | long | String
| *binaryHandlingMode* (mysql) | Specify how binary (blob, binary, etc.) columns should be represented in change events, including:'bytes' represents binary data as byte array (default)'base64' represents binary data as base64-encoded string'hex' represents binary data as hex-encoded (base16) string | bytes | String
| *binlogBufferSize* (mysql) | The size of a look-ahead buffer used by the binlog reader to decide whether the transaction in progress is going to be committed or rolled back. Use 0 to disable look-ahead buffering. Defaults to 0 (i.e. buffering is disabled). | 0 | int
| *columnBlacklist* (mysql) | Regular expressions matching columns to exclude from change events (deprecated, use column.exclude.list instead) |  | String
| *columnExcludeList* (mysql) | Regular expressions matching columns to exclude from change events |  | String
| *columnIncludeList* (mysql) | Regular expressions matching columns to include in change events |  | String
| *connectKeepAlive* (mysql) | Whether a separate thread should be used to ensure the connection is kept alive. | true | boolean
| *connectKeepAliveIntervalMs* (mysql) | Interval in milliseconds to wait for connection checking if keep alive thread is used. | 1m | long
| *connectTimeoutMs* (mysql) | Maximum time in milliseconds to wait after trying to connect to the database before timing out. | 30s | int
| *databaseExcludeList* (mysql) | A comma-separated list of regular expressions that match database names to be excluded from monitoring |  | String
| *databaseHistory* (mysql) | The name of the DatabaseHistory class that should be used to store and recover database schema changes. The configuration properties for the history are prefixed with the 'database.history.' string. | io.debezium.relational.history.FileDatabaseHistory | String
| *databaseHistoryFileFilename* (mysql) | The path to the file that will be used to record the database history |  | String
| *databaseHistoryKafkaBootstrap{zwsp}Servers* (mysql) | A list of host/port pairs that the connector will use for establishing the initial connection to the Kafka cluster for retrieving database schema history previously stored by the connector. This should point to the same Kafka cluster used by the Kafka Connect process. |  | String
| *databaseHistoryKafkaRecovery{zwsp}Attempts* (mysql) | The number of attempts in a row that no data are returned from Kafka before recover completes. The maximum amount of time to wait after receiving no data is (recovery.attempts) x (recovery.poll.interval.ms). | 100 | int
| *databaseHistoryKafkaRecovery{zwsp}PollIntervalMs* (mysql) | The number of milliseconds to wait while polling for persisted data during recovery. | 100ms | int
| *databaseHistoryKafkaTopic* (mysql) | The name of the topic for the database schema history |  | String
| *databaseHistorySkipUnparseable{zwsp}Ddl* (mysql) | Controls the action Debezium will take when it meets a DDL statement in binlog, that it cannot parse.By default the connector will stop operating but by changing the setting it can ignore the statements which it cannot parse. If skipping is enabled then Debezium can miss metadata changes. | false | boolean
| *databaseHistoryStoreOnly{zwsp}MonitoredTablesDdl* (mysql) | Controls what DDL will Debezium store in database history.By default (false) Debezium will store all incoming DDL statements. If set to truethen only DDL that manipulates a monitored table will be stored. | false | boolean
| *databaseHostname* (mysql) | Resolvable hostname or IP address of the MySQL database server. |  | String
| *databaseIncludeList* (mysql) | The databases for which changes are to be captured |  | String
| *databaseInitialStatements* (mysql) | A semicolon separated list of SQL statements to be executed when a JDBC connection (not binlog reading connection) to the database is established. Note that the connector may establish JDBC connections at its own discretion, so this should typically be used for configuration of session parameters only,but not for executing DML statements. Use doubled semicolon (';;') to use a semicolon as a character and not as a delimiter. |  | String
| *databaseJdbcDriver* (mysql) | JDBC Driver class name used to connect to the MySQL database server. | class com.mysql.cj.jdbc.Driver | String
| *databasePassword* (mysql) | *Required* Password of the MySQL database user to be used when connecting to the database. |  | String
| *databasePort* (mysql) | Port of the MySQL database server. | 3306 | int
| *databaseServerId* (mysql) | A numeric ID of this database client, which must be unique across all currently-running database processes in the cluster. This connector joins the MySQL database cluster as another server (with this unique ID) so it can read the binlog. By default, a random number is generated between 5400 and 6400. |  | long
| *databaseServerIdOffset* (mysql) | Only relevant if parallel snapshotting is configured. During parallel snapshotting, multiple (4) connections open to the database client, and they each need their own unique connection ID. This offset is used to generate those IDs from the base configured cluster ID. | 10000 | long
| *databaseServerName* (mysql) | *Required* Unique name that identifies the database server and all recorded offsets, and that is used as a prefix for all schemas and topics. Each distinct installation should have a separate namespace and be monitored by at most one Debezium connector. |  | String
| *databaseSslKeystore* (mysql) | Location of the Java keystore file containing an application process's own certificate and private key. |  | String
| *databaseSslKeystorePassword* (mysql) | Password to access the private key from the keystore file specified by 'ssl.keystore' configuration property or the 'javax.net.ssl.keyStore' system or JVM property. This password is used to unlock the keystore file (store password), and to decrypt the private key stored in the keystore (key password). |  | String
| *databaseSslMode* (mysql) | Whether to use an encrypted connection to MySQL. Options include'disabled' (the default) to use an unencrypted connection; 'preferred' to establish a secure (encrypted) connection if the server supports secure connections, but fall back to an unencrypted connection otherwise; 'required' to use a secure (encrypted) connection, and fail if one cannot be established; 'verify_ca' like 'required' but additionally verify the server TLS certificate against the configured Certificate Authority (CA) certificates, or fail if no valid matching CA certificates are found; or'verify_identity' like 'verify_ca' but additionally verify that the server certificate matches the host to which the connection is attempted. | disabled | String
| *databaseSslTruststore* (mysql) | Location of the Java truststore file containing the collection of CA certificates trusted by this application process (trust store). |  | String
| *databaseSslTruststorePassword* (mysql) | Password to unlock the keystore file (store password) specified by 'ssl.trustore' configuration property or the 'javax.net.ssl.trustStore' system or JVM property. |  | String
| *databaseUser* (mysql) | Name of the MySQL database user to be used when connecting to the database. |  | String
| *decimalHandlingMode* (mysql) | Specify how DECIMAL and NUMERIC columns should be represented in change events, including:'precise' (the default) uses java.math.BigDecimal to represent values, which are encoded in the change events using a binary representation and Kafka Connect's 'org.apache.kafka.connect.data.Decimal' type; 'string' uses string to represent values; 'double' represents values using Java's 'double', which may not offer the precision but will be far easier to use in consumers. | precise | String
| *enableTimeAdjuster* (mysql) | MySQL allows user to insert year value as either 2-digit or 4-digit. In case of two digit the value is automatically mapped into 1970 - 2069.false - delegates the implicit conversion to the databasetrue - (the default) Debezium makes the conversion | true | boolean
| *eventDeserializationFailure{zwsp}HandlingMode* (mysql) | Specify how failures during deserialization of binlog events (i.e. when encountering a corrupted event) should be handled, including:'fail' (the default) an exception indicating the problematic event and its binlog position is raised, causing the connector to be stopped; 'warn' the problematic event and its binlog position will be logged and the event will be skipped;'ignore' the problematic event will be skipped. | fail | String
| *eventProcessingFailureHandling{zwsp}Mode* (mysql) | Specify how failures during processing of events (i.e. when encountering a corrupted event) should be handled, including:'fail' (the default) an exception indicating the problematic event and its position is raised, causing the connector to be stopped; 'warn' the problematic event and its position will be logged and the event will be skipped;'ignore' the problematic event will be skipped. | fail | String
| *gtidNewChannelPosition* (mysql) | If set to 'latest', when connector sees new GTID, it will start consuming gtid channel from the server latest executed gtid position. If 'earliest' (the default) connector starts reading channel from first available (not purged) gtid position on the server. | earliest | String
| *gtidSourceExcludes* (mysql) | The source UUIDs used to exclude GTID ranges when determine the starting position in the MySQL server's binlog. |  | String
| *gtidSourceFilterDmlEvents* (mysql) | If set to true, we will only produce DML events into Kafka for transactions that were written on mysql servers with UUIDs matching the filters defined by the gtid.source.includes or gtid.source.excludes configuration options, if they are specified. | true | boolean
| *gtidSourceIncludes* (mysql) | The source UUIDs used to include GTID ranges when determine the starting position in the MySQL server's binlog. |  | String
| *heartbeatIntervalMs* (mysql) | Length of an interval in milli-seconds in in which the connector periodically sends heartbeat messages to a heartbeat topic. Use 0 to disable heartbeat messages. Disabled by default. | 0ms | int
| *heartbeatTopicsPrefix* (mysql) | The prefix that is used to name heartbeat topics.Defaults to __debezium-heartbeat. | __debezium-heartbeat | String
| *includeQuery* (mysql) | Whether the connector should include the original SQL query that generated the change event. Note: This option requires MySQL be configured with the binlog_rows_query_log_events option set to ON. Query will not be present for events generated from snapshot. WARNING: Enabling this option may expose tables or fields explicitly blacklisted or masked by including the original SQL statement in the change event. For this reason the default value is 'false'. | false | boolean
| *includeSchemaChanges* (mysql) | Whether the connector should publish changes in the database schema to a Kafka topic with the same name as the database server ID. Each schema change will be recorded using a key that contains the database name and whose value include logical description of the new schema and optionally the DDL statement(s).The default is 'true'. This is independent of how the connector internally records database history. | true | boolean
| *inconsistentSchemaHandlingMode* (mysql) | Specify how binlog events that belong to a table missing from internal schema representation (i.e. internal representation is not consistent with database) should be handled, including:'fail' (the default) an exception indicating the problematic event and its binlog position is raised, causing the connector to be stopped; 'warn' the problematic event and its binlog position will be logged and the event will be skipped;'skip' the problematic event will be skipped. | fail | String
| *maxBatchSize* (mysql) | Maximum size of each batch of source records. Defaults to 2048. | 2048 | int
| *maxQueueSize* (mysql) | Maximum size of the queue for change events read from the database log but not yet recorded or forwarded. Defaults to 8192, and should always be larger than the maximum batch size. | 8192 | int
| *messageKeyColumns* (mysql) | A semicolon-separated list of expressions that match fully-qualified tables and column(s) to be used as message key. Each expression must match the pattern ':',where the table names could be defined as (DB_NAME.TABLE_NAME) or (SCHEMA_NAME.TABLE_NAME), depending on the specific connector,and the key columns are a comma-separated list of columns representing the custom key. For any table without an explicit key configuration the table's primary key column(s) will be used as message key.Example: dbserver1.inventory.orderlines:orderId,orderLineId;dbserver1.inventory.orders:id |  | String
| *pollIntervalMs* (mysql) | Frequency in milliseconds to wait for new change events to appear after receiving no events. Defaults to 500ms. | 500ms | long
| *skippedOperations* (mysql) | The comma-separated list of operations to skip during streaming, defined as: 'i' for inserts; 'u' for updates; 'd' for deletes. By default, no operations will be skipped. |  | String
| *snapshotDelayMs* (mysql) | The number of milliseconds to delay before a snapshot will begin. | 0ms | long
| *snapshotEventsAsInserts* (mysql) | Whether or not to mark snapshot events as normal inserts (op 'c'). If disabled, the standard functionality of emitting these records as reads (op 'r') will be used. | true | boolean
| *snapshotFetchSize* (mysql) | The maximum number of records that should be loaded into memory while performing a snapshot |  | int
| *snapshotLockingMode* (mysql) | Controls how long the connector holds onto the global read lock while it is performing a snapshot. The default is 'minimal', which means the connector holds the global read lock (and thus prevents any updates) for just the initial portion of the snapshot while the database schemas and other metadata are being read. The remaining work in a snapshot involves selecting all rows from each table, and this can be done using the snapshot process' REPEATABLE READ transaction even when the lock is no longer held and other operations are updating the database. However, in some cases it may be desirable to block all writes for the entire duration of the snapshot; in such cases set this property to 'extended'. Using a value of 'none' will prevent the connector from acquiring any table locks during the snapshot process. This mode can only be used in combination with snapshot.mode values of 'schema_only' or 'schema_only_recovery' and is only safe to use if no schema changes are happening while the snapshot is taken. | minimal | String
| *snapshotMode* (mysql) | The criteria for running a snapshot upon startup of the connector. Options include: 'when_needed' to specify that the connector run a snapshot upon startup whenever it deems it necessary; 'schema_only' to only take a snapshot of the schema (table structures) but no actual data; 'initial' (the default) to specify the connector can run a snapshot only when no offsets are available for the logical server name; 'initial_only' same as 'initial' except the connector should stop after completing the snapshot and before it would normally read the binlog; and'never' to specify the connector should never run a snapshot and that upon first startup the connector should read from the beginning of the binlog. The 'never' mode should be used with care, and only when the binlog is known to contain all history. | initial | String
| *snapshotNewTables* (mysql) | BETA FEATURE: On connector restart, the connector will check if there have been any new tables added to the configuration, and snapshot them. There is presently only two options:'off': Default behavior. Do not snapshot new tables.'parallel': The snapshot of the new tables will occur in parallel to the continued binlog reading of the old tables. When the snapshot completes, an independent binlog reader will begin reading the events for the new tables until it catches up to present time. At this point, both old and new binlog readers will be momentarily halted and new binlog reader will start that will read the binlog for all configured tables. The parallel binlog reader will have a configured server id of 10000 the primary binlog reader's server id. | off | String
| *snapshotSelectStatement{zwsp}Overrides* (mysql) | This property contains a comma-separated list of fully-qualified tables (DB_NAME.TABLE_NAME) or (SCHEMA_NAME.TABLE_NAME), depending on thespecific connectors . Select statements for the individual tables are specified in further configuration properties, one for each table, identified by the id 'snapshot.select.statement.overrides.DB_NAME.TABLE_NAME' or 'snapshot.select.statement.overrides.SCHEMA_NAME.TABLE_NAME', respectively. The value of those properties is the select statement to use when retrieving data from the specific table during snapshotting. A possible use case for large append-only tables is setting a specific point where to start (resume) snapshotting, in case a previous snapshotting was interrupted. |  | String
| *sourceStructVersion* (mysql) | A version of the format of the publicly visible source part in the message | v2 | String
| *tableBlacklist* (mysql) | A comma-separated list of regular expressions that match the fully-qualified names of tables to be excluded from monitoring (deprecated, use table.exclude.list instead) |  | String
| *tableExcludeList* (mysql) | A comma-separated list of regular expressions that match the fully-qualified names of tables to be excluded from monitoring |  | String
| *tableIgnoreBuiltin* (mysql) | Flag specifying whether built-in tables should be ignored. | true | boolean
| *tableIncludeList* (mysql) | The tables for which changes are to be captured |  | String
| *tableWhitelist* (mysql) | The tables for which changes are to be captured (deprecated, use table.include.list instead) |  | String
| *timePrecisionMode* (mysql) | Time, date and timestamps can be represented with different kinds of precisions, including:'adaptive_time_microseconds': the precision of date and timestamp values is based the database column's precision; but time fields always use microseconds precision;'connect': always represents time, date and timestamp values using Kafka Connect's built-in representations for Time, Date, and Timestamp, which uses millisecond precision regardless of the database columns' precision. | adaptive_time_microseconds | String
| *tombstonesOnDelete* (mysql) | Whether delete operations should be represented by a delete event and a subsquenttombstone event (true) or only by a delete event (false). Emitting the tombstone event (the default behavior) allows Kafka to completely delete all events pertaining to the given key once the source record got deleted. | false | boolean
|===
// endpoint options: END

For more information about configuration:
https://debezium.io/documentation/reference/0.10/operations/embedded.html#engine-properties[https://debezium.io/documentation/reference/0.10/operations/embedded.html#engine-properties]
https://debezium.io/documentation/reference/0.10/connectors/mysql.html#connector-properties[https://debezium.io/documentation/reference/0.10/connectors/mysql.html#connector-properties]

== Message headers

=== Consumer headers

The following headers are available when consuming change events from Debezium.
[width=""100%"",cols=""2m,2m,1m,5"",options=""header""]
|===
| Header constant                           | Header value                                   | Type        | Description
| DebeziumConstants.HEADER_IDENTIFIER       | ""CamelDebeziumIdentifier""                      | String      | The identifier of the connector, normally is this format ""+++{server-name}.{database-name}.{table-name}+++"".
| DebeziumConstants.HEADER_KEY              | ""CamelDebeziumKey""                             | Struct      | The key of the event, normally is the table Primary Key.
| DebeziumConstants.HEADER_SOURCE_METADATA  | ""CamelDebeziumSourceMetadata""                  | Map         | The metadata about the source event, for example `table` name, database `name`, log position, etc, please refer to the Debezium documentation for more info.
| DebeziumConstants.HEADER_OPERATION        | ""CamelDebeziumOperation""                       | String      | If presents, the type of event operation. Values for the connector are `c` for create (or insert), `u` for update, `d` for delete or `r` in case of a snapshot event.
| DebeziumConstants.HEADER_TIMESTAMP        | ""CamelDebeziumTimestamp""                       | Long        | If presents, the time (using the system clock in the JVM) at which the connector processed the event.
| DebeziumConstants.HEADER_BEFORE           | ""CamelDebeziumBefore""                          | Struct     | If presents, contains the state of the row before the event occurred.
|===

== Message body
The message body if is not `null` (in case of tombstones), it contains the state of the row after the event occurred as `Struct` format or `Map` format if you use the included Type Converter from `Struct` to `Map` (please look below for more explanation).

== Samples

=== Consuming events

Here is a very simple route that you can use in order to listen to Debezium events from MySQL connector.
[source,java]
----
from(""debezium-mysql:dbz-test-1?offsetStorageFileName=/usr/offset-file-1.dat&databaseHostName=localhost&databaseUser=debezium&databasePassword=dbz&databaseServerName=my-app-connector&databaseHistoryFileName=/usr/history-file-1.dat"")
    .log(""Event received from Debezium : ${body}"")
    .log(""    with this identifier ${headers.CamelDebeziumIdentifier}"")
    .log(""    with these source metadata ${headers.CamelDebeziumSourceMetadata}"")
    .log(""    the event occured upon this operation '${headers.CamelDebeziumSourceOperation}'"")
    .log(""    on this database '${headers.CamelDebeziumSourceMetadata[db]}' and this table '${headers.CamelDebeziumSourceMetadata[table]}'"")
    .log(""    with the key ${headers.CamelDebeziumKey}"")
    .log(""    the previous value is ${headers.CamelDebeziumBefore}"")
----

By default, the component will emit the events in the body and `CamelDebeziumBefore` header as https://kafka.apache.org/22/javadoc/org/apache/kafka/connect/data/Struct.html[`Struct`] data type, the reasoning behind this, is to perceive the schema information in case is needed.
However, the component as well contains a xref:manual::type-converter.adoc[Type Converter] that converts
from default output type of https://kafka.apache.org/22/javadoc/org/apache/kafka/connect/data/Struct.html[`Struct`] to `Map` in order to leverage Camel's rich xref:manual::data-format.adoc[Data Format] types which many of them work out of box with `Map` data type.
To use it, you can either add `Map.class` type when you access the message e.g: `exchange.getIn().getBody(Map.class)`, or you can convert the body always to `Map` from the route builder by adding `.convertBodyTo(Map.class)` to your Camel Route DSL after `from` statement.

We mentioned above about the schema, which can be used in case you need to perform advance data transformation and the schema is needed for that. If you choose not to convert your body to `Map`,
you can obtain the schema information as https://kafka.apache.org/22/javadoc/org/apache/kafka/connect/data/Schema.html[`Schema`] type from `Struct` like this:
[source,java]
----
from(""debezium-mysql:[name]?[options]])
    .process(exchange -> {
        final Struct bodyValue = exchange.getIn().getBody(Struct.class);
        final Schema schemaValue = bodyValue.schema();

        log.info(""Body value is :"" + bodyValue);
        log.info(""With Schema : "" + schemaValue);
        log.info(""And fields of :"" + schemaValue.fields());
        log.info(""Field name has `"" + schemaValue.field(""name"").schema() + ""` type"");
    });
----

*Important Note:* This component is a thin wrapper around Debezium Engine as mentioned, therefore before using this component in production, you need to understand how Debezium works and how configurations can reflect the expected behavior, especially in regards to https://debezium.io/documentation/reference/0.9/operations/embedded.html#_handling_failures[handling failures].

include::camel-spring-boot::page$debezium-mysql-starter.adoc[]
",12141,True,3024.627874635853,median
"/*------------------------------------------------------------------------
 * Vulkan Conformance Tests
 * ------------------------
 *
 * Copyright (c) 2017-2019 The Khronos Group Inc.
 * Copyright (c) 2018-2019 NVIDIA Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the ""License"");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *	  http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *//*!
 * \\file
 * \\brief Tests for VK_EXT_buffer_device_address.
 *//*--------------------------------------------------------------------*/

#include ""vktBindingBufferDeviceAddressTests.hpp""

#include ""vkBufferWithMemory.hpp""
#include ""vkImageWithMemory.hpp""
#include ""vkQueryUtil.hpp""
#include ""vkBuilderUtil.hpp""
#include ""vkCmdUtil.hpp""
#include ""vkTypeUtil.hpp""
#include ""vkObjUtil.hpp""

#include ""vktTestGroupUtil.hpp""
#include ""vktTestCase.hpp""

#include ""deDefs.h""
#include ""deMath.h""
#include ""deRandom.h""
#include ""deSharedPtr.hpp""
#include ""deString.h""

#include ""tcuTestCase.hpp""
#include ""tcuTestLog.hpp""

#include <string>
#include <sstream>

namespace vkt
{
namespace BindingModel
{
namespace
{
using namespace vk;
using namespace std;

typedef de::MovePtr<Unique<VkBuffer> >	VkBufferSp;
typedef de::MovePtr<Allocation>			AllocationSp;

static const deUint32 DIM = 8;

typedef enum
{
	BASE_UBO = 0,
	BASE_SSBO,
} Base;

#define ENABLE_RAYTRACING 0

typedef enum
{
	STAGE_COMPUTE = 0,
	STAGE_VERTEX,
	STAGE_FRAGMENT,
	STAGE_RAYGEN,
} Stage;

typedef enum
{
	BT_SINGLE = 0,
	BT_MULTI,
	BT_REPLAY,
} BufType;

typedef enum
{
	LAYOUT_STD140 = 0,
	LAYOUT_SCALAR,
} Layout;

typedef enum
{
	CONVERT_NONE = 0,
	CONVERT_UINT64,
	CONVERT_UVEC2,
	CONVERT_U64CMP,
	CONVERT_UVEC2CMP,
	CONVERT_UVEC2TOU64,
	CONVERT_U64TOUVEC2,
} Convert;

struct CaseDef
{
	deUint32 set;
	deUint32 depth;
	Base base;
	Stage stage;
	Convert convertUToPtr;
	bool storeInLocal;
	BufType bufType;
	Layout layout;
};

class BufferAddressTestInstance : public TestInstance
{
public:
						BufferAddressTestInstance	(Context& context, const CaseDef& data);
						~BufferAddressTestInstance	(void);
	tcu::TestStatus		iterate						(void);
	virtual	void		fillBuffer					(const std::vector<deUint8 *>& cpuAddrs,
													 const std::vector<deUint64>& gpuAddrs,
													 deUint32 bufNum, deUint32 curDepth) const;
private:
	CaseDef				m_data;

	enum
	{
		WIDTH = 256,
		HEIGHT = 256
	};
};

BufferAddressTestInstance::BufferAddressTestInstance (Context& context, const CaseDef& data)
	: vkt::TestInstance		(context)
	, m_data				(data)
{
}

BufferAddressTestInstance::~BufferAddressTestInstance (void)
{
}

class BufferAddressTestCase : public TestCase
{
	public:
							BufferAddressTestCase	(tcu::TestContext& context, const char* name, const char* desc, const CaseDef data);
							~BufferAddressTestCase	(void);
	virtual	void			initPrograms			(SourceCollections& programCollection) const;
	virtual TestInstance*	createInstance			(Context& context) const;
	virtual void			checkSupport			(Context& context) const;
	virtual	void			checkBuffer				(std::stringstream& checks, deUint32 bufNum, deUint32 curDepth, const std::string &prefix) const;

private:
	CaseDef					m_data;
};

BufferAddressTestCase::BufferAddressTestCase (tcu::TestContext& context, const char* name, const char* desc, const CaseDef data)
	: vkt::TestCase	(context, name, desc)
	, m_data		(data)
{
}

BufferAddressTestCase::~BufferAddressTestCase	(void)
{
}

void BufferAddressTestCase::checkSupport (Context& context) const
{
	if (!context.isBufferDeviceAddressSupported())
		TCU_THROW(NotSupportedError, ""Physical storage buffer pointers not supported"");

	if (m_data.stage == STAGE_VERTEX && !context.getDeviceFeatures().vertexPipelineStoresAndAtomics)
		TCU_THROW(NotSupportedError, ""Vertex pipeline stores and atomics not supported"");

	if (m_data.set >= context.getDeviceProperties().limits.maxBoundDescriptorSets)
		TCU_THROW(NotSupportedError, ""descriptor set number not supported"");

	bool isBufferDeviceAddressWithCaptureReplaySupported =
			(context.isDeviceFunctionalitySupported(""VK_KHR_buffer_device_address"") && context.getBufferDeviceAddressFeatures().bufferDeviceAddressCaptureReplay) ||
			(context.isDeviceFunctionalitySupported(""VK_EXT_buffer_device_address"") && context.getBufferDeviceAddressFeaturesEXT().bufferDeviceAddressCaptureReplay);
	if (m_data.bufType == BT_REPLAY && !isBufferDeviceAddressWithCaptureReplaySupported)
		TCU_THROW(NotSupportedError, ""Capture/replay of physical storage buffer pointers not supported"");

	if (m_data.layout == LAYOUT_SCALAR && !context.getScalarBlockLayoutFeatures().scalarBlockLayout)
		TCU_THROW(NotSupportedError, ""Scalar block layout not supported"");

#if ENABLE_RAYTRACING
	if (m_data.stage == STAGE_RAYGEN &&
		!context.isDeviceFunctionalitySupported(""VK_NV_ray_tracing""))
	{
		TCU_THROW(NotSupportedError, ""Ray tracing not supported"");
	}
#endif

	const bool needsInt64	= (	m_data.convertUToPtr == CONVERT_UINT64		||
								m_data.convertUToPtr == CONVERT_U64CMP		||
								m_data.convertUToPtr == CONVERT_U64TOUVEC2	||
								m_data.convertUToPtr == CONVERT_UVEC2TOU64	);

	const bool needsKHR		= (	m_data.convertUToPtr == CONVERT_UVEC2		||
								m_data.convertUToPtr == CONVERT_UVEC2CMP	||
								m_data.convertUToPtr == CONVERT_U64TOUVEC2	||
								m_data.convertUToPtr == CONVERT_UVEC2TOU64	);

	if (needsInt64 && !context.getDeviceFeatures().shaderInt64)
		TCU_THROW(NotSupportedError, ""Int64 not supported"");
	if (needsKHR && !context.isDeviceFunctionalitySupported(""VK_KHR_buffer_device_address""))
		TCU_THROW(NotSupportedError, ""VK_KHR_buffer_device_address not supported"");
}

void BufferAddressTestCase::checkBuffer (std::stringstream& checks, deUint32 bufNum, deUint32 curDepth, const std::string &prefix) const
{
	string newPrefix = prefix;
	if (curDepth > 0)
	{
		if (m_data.convertUToPtr == CONVERT_UINT64 || m_data.convertUToPtr == CONVERT_UVEC2TOU64)
			newPrefix = ""T1(uint64_t(T1("" + newPrefix + "")))"";
		else if (m_data.convertUToPtr == CONVERT_UVEC2 || m_data.convertUToPtr == CONVERT_U64TOUVEC2)
			newPrefix = ""T1(uvec2(T1("" + newPrefix + "")))"";
	}

	if (m_data.storeInLocal && curDepth != 0)
	{
		std::string localName = ""l"" + de::toString(bufNum);
		checks << ""   "" << ((bufNum & 1) ? ""restrict "" : """") << ""T1 "" << localName << "" = "" << newPrefix << "";\\n"";
		newPrefix = localName;
	}

	checks << ""   accum |= "" << newPrefix << "".a[0] - "" << bufNum*3+0 << "";\\n"";
	checks << ""   accum |= "" << newPrefix << "".a[pc.identity[1]] - "" << bufNum*3+1 << "";\\n"";
	checks << ""   accum |= "" << newPrefix << "".b - "" << bufNum*3+2 << "";\\n"";
	checks << ""   accum |= int("" << newPrefix << "".e[0][0] - "" << bufNum*3+3 << "");\\n"";
	checks << ""   accum |= int("" << newPrefix << "".e[0][1] - "" << bufNum*3+5 << "");\\n"";
	checks << ""   accum |= int("" << newPrefix << "".e[1][0] - "" << bufNum*3+4 << "");\\n"";
	checks << ""   accum |= int("" << newPrefix << "".e[1][1] - "" << bufNum*3+6 << "");\\n"";

	if (m_data.layout == LAYOUT_SCALAR)
	{
		checks << ""   f = "" << newPrefix << "".f;\\n"";
		checks << ""   accum |= f.x - "" << bufNum*3+7 << "";\\n"";
		checks << ""   accum |= f.y - "" << bufNum*3+8 << "";\\n"";
		checks << ""   accum |= f.z - "" << bufNum*3+9 << "";\\n"";
	}

	const std::string localPrefix = ""l"" + de::toString(bufNum);

	if (m_data.convertUToPtr == CONVERT_U64CMP || m_data.convertUToPtr == CONVERT_UVEC2CMP)
	{
		const std::string type = ((m_data.convertUToPtr == CONVERT_U64CMP) ? ""uint64_t"" : ""uvec2"");

		checks << ""   "" << type << "" "" << localPrefix << ""c0 = "" << type << ""("" << newPrefix << "".c[0]);\\n"";
		checks << ""   "" << type << "" "" << localPrefix << ""c1 = "" << type << ""("" << newPrefix << "".c[pc.identity[1]]);\\n"";
		checks << ""   "" << type << "" "" << localPrefix << ""d  = "" << type << ""("" << newPrefix << "".d);\\n"";
	}

	if (curDepth != m_data.depth)
	{
		// Check non-null pointers and inequality among them.
		if (m_data.convertUToPtr == CONVERT_U64CMP)
		{
			checks << ""   if ("" << localPrefix << ""c0 == zero ||\\n""
				   << ""       "" << localPrefix << ""c1 == zero ||\\n""
				   << ""       "" << localPrefix << ""d  == zero ||\\n""
				   << ""       "" << localPrefix << ""c0 == "" << localPrefix << ""c1 ||\\n""
				   << ""       "" << localPrefix << ""c1 == "" << localPrefix << ""d  ||\\n""
				   << ""       "" << localPrefix << ""c0 == "" << localPrefix << ""d  ) {\\n""
				   << ""     accum |= 1;\\n""
				   << ""   }\\n"";
		}
		else if (m_data.convertUToPtr == CONVERT_UVEC2CMP)
		{
			checks << ""   if (all(equal("" << localPrefix << ""c0, zero)) ||\\n""
				   << ""       all(equal("" << localPrefix << ""c1, zero)) ||\\n""
				   << ""       all(equal("" << localPrefix << ""d , zero)) ||\\n""
				   << ""       all(equal("" << localPrefix << ""c0, "" << localPrefix << ""c1)) ||\\n""
				   << ""       all(equal("" << localPrefix << ""c1, "" << localPrefix << ""d )) ||\\n""
				   << ""       all(equal("" << localPrefix << ""c0, "" << localPrefix << ""d )) ) {\\n""
				   << ""     accum |= 1;\\n""
				   << ""   }\\n"";
		}

		checkBuffer(checks, bufNum*3+1, curDepth+1, newPrefix + "".c[0]"");
		checkBuffer(checks, bufNum*3+2, curDepth+1, newPrefix + "".c[pc.identity[1]]"");
		checkBuffer(checks, bufNum*3+3, curDepth+1, newPrefix + "".d"");
	}
	else
	{
		// Check null pointers nonexplicitly.
		if (m_data.convertUToPtr == CONVERT_U64CMP)
		{
			checks << ""   if (!("" << localPrefix << ""c0 == "" << localPrefix << ""c1 &&\\n""
				   << ""         "" << localPrefix << ""c1 == "" << localPrefix << ""d  &&\\n""
				   << ""         "" << localPrefix << ""c0 == "" << localPrefix << ""d  )) {\\n""
				   << ""     accum |= 1;\\n""
				   << ""   }\\n"";
		}
		else if (m_data.convertUToPtr == CONVERT_UVEC2CMP)
		{
			checks << ""   if (!(all(equal("" << localPrefix << ""c0, "" << localPrefix << ""c1)) &&\\n""
				   << ""         all(equal("" << localPrefix << ""c1, "" << localPrefix << ""d )) &&\\n""
				   << ""         all(equal("" << localPrefix << ""c0, "" << localPrefix << ""d )) )) {\\n""
				   << ""     accum |= 1;\\n""
				   << ""   }\\n"";
		}
	}
}

void BufferAddressTestInstance::fillBuffer (const std::vector<deUint8 *>& cpuAddrs,
											const std::vector<deUint64>& gpuAddrs,
											deUint32 bufNum, deUint32 curDepth) const
{
	deUint8 *buf = cpuAddrs[bufNum];

	deUint32 aStride = m_data.layout == LAYOUT_SCALAR ? 1 : 4; // (in deUint32s)
	deUint32 cStride = m_data.layout == LAYOUT_SCALAR ? 1 : 2; // (in deUint64s)
	deUint32 matStride = m_data.layout == LAYOUT_SCALAR ? 2 : 4; // (in floats)

	// a
	((deUint32 *)(buf+0))[0] = bufNum*3+0;
	((deUint32 *)(buf+0))[aStride] = bufNum*3+1;
	// b
	((deUint32 *)(buf+32))[0] = bufNum*3+2;
	if (m_data.layout == LAYOUT_SCALAR)
	{
		// f
		((deUint32 *)(buf+36))[0] = bufNum*3+7;
		((deUint32 *)(buf+36))[1] = bufNum*3+8;
		((deUint32 *)(buf+36))[2] = bufNum*3+9;
	}
	// e
	((float *)(buf+96))[0] = (float)(bufNum*3+3);
	((float *)(buf+96))[1] = (float)(bufNum*3+4);
	((float *)(buf+96))[matStride] = (float)(bufNum*3+5);
	((float *)(buf+96))[matStride+1] = (float)(bufNum*3+6);

	if (curDepth != m_data.depth)
	{
		// c
		((deUint64 *)(buf+48))[0] = gpuAddrs[bufNum*3+1];
		((deUint64 *)(buf+48))[cStride] = gpuAddrs[bufNum*3+2];
		// d
		((deUint64 *)(buf+80))[0] = gpuAddrs[bufNum*3+3];

		fillBuffer(cpuAddrs, gpuAddrs, bufNum*3+1, curDepth+1);
		fillBuffer(cpuAddrs, gpuAddrs, bufNum*3+2, curDepth+1);
		fillBuffer(cpuAddrs, gpuAddrs, bufNum*3+3, curDepth+1);
	}
	else
	{
		// c
		((deUint64 *)(buf+48))[0] = 0ull;
		((deUint64 *)(buf+48))[cStride] = 0ull;
		// d
		((deUint64 *)(buf+80))[0] = 0ull;
	}
}


void BufferAddressTestCase::initPrograms (SourceCollections& programCollection) const
{
	std::stringstream decls, checks, localDecls;

	std::string baseStorage = m_data.base == BASE_UBO ? ""uniform"" : ""buffer"";
	std::string memberStorage = ""buffer"";

	decls << ""layout(r32ui, set = "" << m_data.set << "", binding = 0) uniform uimage2D image0_0;\\n"";
	decls << ""layout(buffer_reference) "" << memberStorage << "" T1;\\n"";

	std::string refType;
	switch (m_data.convertUToPtr)
	{
	case CONVERT_UINT64:
	case CONVERT_U64TOUVEC2:
		refType = ""uint64_t"";
		break;

	case CONVERT_UVEC2:
	case CONVERT_UVEC2TOU64:
		refType = ""uvec2"";
		break;

	default:
		refType = ""T1"";
		break;
	}

	std::string layout = m_data.layout == LAYOUT_SCALAR ? ""scalar"" : ""std140"";
	decls <<
			""layout(set = "" << m_data.set << "", binding = 1, "" << layout << "") "" << baseStorage << "" T2 {\\n""
			""   layout(offset = 0) int a[2]; // stride = 4 for scalar, 16 for std140\\n""
			""   layout(offset = 32) int b;\\n""
			<< ((m_data.layout == LAYOUT_SCALAR) ? ""   layout(offset = 36) ivec3 f;\\n"" : """") <<
			""   layout(offset = 48) "" << refType << "" c[2]; // stride = 8 for scalar, 16 for std140\\n""
			""   layout(offset = 80) "" << refType << "" d;\\n""
			""   layout(offset = 96, row_major) mat2 e; // tightly packed for scalar, 16 byte matrix stride for std140\\n""
			""} x;\\n"";
	decls <<
			""layout(buffer_reference, "" << layout << "") "" << memberStorage << "" T1 {\\n""
			""   layout(offset = 0) int a[2]; // stride = 4 for scalar, 16 for std140\\n""
			""   layout(offset = 32) int b;\\n""
			<< ((m_data.layout == LAYOUT_SCALAR) ? ""   layout(offset = 36) ivec3 f;\\n"" : """") <<
			""   layout(offset = 48) "" << refType << "" c[2]; // stride = 8 for scalar, 16 for std140\\n""
			""   layout(offset = 80) "" << refType << "" d;\\n""
			""   layout(offset = 96, row_major) mat2 e; // tightly packed for scalar, 16 byte matrix stride for std140\\n""
			""};\\n"";

	if (m_data.convertUToPtr == CONVERT_U64CMP)
		localDecls << ""  uint64_t zero = uint64_t(0);\\n"";
	else if (m_data.convertUToPtr == CONVERT_UVEC2CMP)
		localDecls << ""  uvec2 zero = uvec2(0, 0);\\n"";

	checkBuffer(checks, 0, 0, ""x"");

	std::stringstream pushdecl;
	pushdecl << ""layout (push_constant, std430) uniform Block { int identity[32]; } pc;\\n"";

	vk::ShaderBuildOptions::Flags flags = vk::ShaderBuildOptions::Flags(0);
	if (m_data.layout == LAYOUT_SCALAR)
		flags = vk::ShaderBuildOptions::FLAG_ALLOW_SCALAR_OFFSETS;

	// The conversion and comparison in uvec2 form test needs SPIR-V 1.5 for OpBitcast.
	const vk::SpirvVersion spirvVersion = ((m_data.convertUToPtr == CONVERT_UVEC2CMP) ? vk::SPIRV_VERSION_1_5 : vk::SPIRV_VERSION_1_0);

	switch (m_data.stage)
	{
	default: DE_ASSERT(0); // Fallthrough
	case STAGE_COMPUTE:
		{
			std::stringstream css;
			css <<
				""#version 450 core\\n""
				""#extension GL_EXT_shader_explicit_arithmetic_types_int64 : enable\\n""
				""#extension GL_EXT_buffer_reference : enable\\n""
				""#extension GL_EXT_scalar_block_layout : enable\\n""
				""#extension GL_EXT_buffer_reference_uvec2 : enable\\n""
				<< pushdecl.str()
				<< decls.str() <<
				""layout(local_size_x = 1, local_size_y = 1) in;\\n""
				""void main()\\n""
				""{\\n""
				""  int accum = 0, temp;\\n""
				""  ivec3 f;\\n""
				<< localDecls.str()
				<< checks.str() <<
				""  uvec4 color = (accum != 0) ? uvec4(0,0,0,0) : uvec4(1,0,0,1);\\n""
				""  imageStore(image0_0, ivec2(gl_GlobalInvocationID.xy), color);\\n""
				""}\\n"";

			programCollection.glslSources.add(""test"") << glu::ComputeSource(css.str())
				<< vk::ShaderBuildOptions(programCollection.usedVulkanVersion, spirvVersion, flags);
			break;
		}
#if ENABLE_RAYTRACING
	case STAGE_RAYGEN:
		{
			std::stringstream css;
			css <<
				""#version 460 core\\n""
				""#extension GL_EXT_shader_explicit_arithmetic_types_int64 : enable\\n""
				""#extension GL_EXT_buffer_reference : enable\\n""
				""#extension GL_EXT_scalar_block_layout : enable\\n""
				""#extension GL_EXT_buffer_reference_uvec2 : enable\\n""
				""#extension GL_NV_ray_tracing : require\\n""
				<< pushdecl.str()
				<< decls.str() <<
				""void main()\\n""
				""{\\n""
				""  int accum = 0, temp;\\n""
				""  ivec3 f;\\n""
				<< localDecls.str()
				<< checks.str() <<
				""  uvec4 color = (accum != 0) ? uvec4(0,0,0,0) : uvec4(1,0,0,1);\\n""
				""  imageStore(image0_0, ivec2(gl_LaunchIDNV.xy), color);\\n""
				""}\\n"";

			programCollection.glslSources.add(""test"") << glu::RaygenSource(css.str())
				<< vk::ShaderBuildOptions(programCollection.usedVulkanVersion, spirvVersion, flags);
			break;
		}
#endif
	case STAGE_VERTEX:
		{
			std::stringstream vss;
			vss <<
				""#version 450 core\\n""
				""#extension GL_EXT_shader_explicit_arithmetic_types_int64 : enable\\n""
				""#extension GL_EXT_buffer_reference : enable\\n""
				""#extension GL_EXT_scalar_block_layout : enable\\n""
				""#extension GL_EXT_buffer_reference_uvec2 : enable\\n""
				<< pushdecl.str()
				<< decls.str()  <<
				""void main()\\n""
				""{\\n""
				""  int accum = 0, temp;\\n""
				""  ivec3 f;\\n""
				<< localDecls.str()
				<< checks.str() <<
				""  uvec4 color = (accum != 0) ? uvec4(0,0,0,0) : uvec4(1,0,0,1);\\n""
				""  imageStore(image0_0, ivec2(gl_VertexIndex % "" << DIM << "", gl_VertexIndex / "" << DIM << ""), color);\\n""
				""  gl_PointSize = 1.0f;\\n""
				""}\\n"";

			programCollection.glslSources.add(""test"") << glu::VertexSource(vss.str())
				<< vk::ShaderBuildOptions(programCollection.usedVulkanVersion, spirvVersion, flags);
			break;
		}
	case STAGE_FRAGMENT:
		{
			std::stringstream vss;
			vss <<
				""#version 450 core\\n""
				""void main()\\n""
				""{\\n""
				// full-viewport quad
				""  gl_Position = vec4( 2.0*float(gl_VertexIndex&2) - 1.0, 4.0*(gl_VertexIndex&1)-1.0, 1.0 - 2.0 * float(gl_VertexIndex&1), 1);\\n""
				""}\\n"";

			programCollection.glslSources.add(""vert"") << glu::VertexSource(vss.str());

			std::stringstream fss;
			fss <<
				""#version 450 core\\n""
				""#extension GL_EXT_shader_explicit_arithmetic_types_int64 : enable\\n""
				""#extension GL_EXT_buffer_reference : enable\\n""
				""#extension GL_EXT_scalar_block_layout : enable\\n""
				""#extension GL_EXT_buffer_reference_uvec2 : enable\\n""
				<< pushdecl.str()
				<< decls.str() <<
				""void main()\\n""
				""{\\n""
				""  int accum = 0, temp;\\n""
				""  ivec3 f;\\n""
				<< localDecls.str()
				<< checks.str() <<
				""  uvec4 color = (accum != 0) ? uvec4(0,0,0,0) : uvec4(1,0,0,1);\\n""
				""  imageStore(image0_0, ivec2(gl_FragCoord.x, gl_FragCoord.y), color);\\n""
				""}\\n"";

			programCollection.glslSources.add(""test"") << glu::FragmentSource(fss.str())
				<< vk::ShaderBuildOptions(programCollection.usedVulkanVersion, spirvVersion, flags);
			break;
		}
	}

}

TestInstance* BufferAddressTestCase::createInstance (Context& context) const
{
	return new BufferAddressTestInstance(context, m_data);
}

VkBufferCreateInfo makeBufferCreateInfo (const void*				pNext,
										 const VkDeviceSize			bufferSize,
										 const VkBufferUsageFlags	usage,
										 const VkBufferCreateFlags  flags)
{
	const VkBufferCreateInfo bufferCreateInfo =
	{
		VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,	// VkStructureType		sType;
		pNext,									// const void*			pNext;
		flags,									// VkBufferCreateFlags	flags;
		bufferSize,								// VkDeviceSize			size;
		usage,									// VkBufferUsageFlags	usage;
		VK_SHARING_MODE_EXCLUSIVE,				// VkSharingMode		sharingMode;
		0u,										// deUint32				queueFamilyIndexCount;
		DE_NULL,								// const deUint32*		pQueueFamilyIndices;
	};
	return bufferCreateInfo;
}

tcu::TestStatus BufferAddressTestInstance::iterate (void)
{
	const InstanceInterface&vki						= m_context.getInstanceInterface();
	const DeviceInterface&	vk						= m_context.getDeviceInterface();
	const VkPhysicalDevice&	physDevice				= m_context.getPhysicalDevice();
	const VkDevice			device					= m_context.getDevice();
	Allocator&				allocator				= m_context.getDefaultAllocator();
	const bool				useKHR					= m_context.isDeviceFunctionalitySupported(""VK_KHR_buffer_device_address"");


	VkFlags allShaderStages = VK_SHADER_STAGE_COMPUTE_BIT | VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT;
	VkFlags allPipelineStages = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT | VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;

#if ENABLE_RAYTRACING
	if (m_data.stage == STAGE_RAYGEN)
	{
		allShaderStages = VK_SHADER_STAGE_RAYGEN_BIT_NV;
		allPipelineStages = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV;
	}
#endif

	VkPhysicalDeviceProperties2 properties;
	deMemset(&properties, 0, sizeof(properties));
	properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;

#if ENABLE_RAYTRACING
	VkPhysicalDeviceRayTracingPropertiesNV rayTracingProperties;
	deMemset(&rayTracingProperties, 0, sizeof(rayTracingProperties));
	rayTracingProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV;

	if (m_context.isDeviceFunctionalitySupported(""VK_NV_ray_tracing""))
	{
		properties.pNext = &rayTracingProperties;
	}
#endif

	m_context.getInstanceInterface().getPhysicalDeviceProperties2(m_context.getPhysicalDevice(), &properties);

	VkPipelineBindPoint bindPoint;

	switch (m_data.stage)
	{
	case STAGE_COMPUTE:
		bindPoint = VK_PIPELINE_BIND_POINT_COMPUTE;
		break;
#if ENABLE_RAYTRACING
	case STAGE_RAYGEN:
		bindPoint = VK_PIPELINE_BIND_POINT_RAY_TRACING_NV;
		break;
#endif
	default:
		bindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
		break;
	}

	Move<vk::VkDescriptorPool>	descriptorPool;
	Move<vk::VkDescriptorSet>	descriptorSet;

	VkDescriptorPoolCreateFlags poolCreateFlags = VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT;

	VkDescriptorSetLayoutBinding bindings[2];
	bindings[0].binding = 0;
	bindings[0].stageFlags = allShaderStages;
	bindings[0].descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE;
	bindings[0].descriptorCount = 1;
	bindings[1].binding = 1;
	bindings[1].stageFlags = allShaderStages;
	bindings[1].descriptorType = m_data.base == BASE_UBO ? VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER : VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
	bindings[1].descriptorCount = 1;

	// Create a layout and allocate a descriptor set for it.
	VkDescriptorSetLayoutCreateInfo setLayoutCreateInfo =
	{
		vk::VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
		DE_NULL,

		0,
		(deUint32)2,
		&bindings[0]
	};

	Move<vk::VkDescriptorSetLayout>	descriptorSetLayout = vk::createDescriptorSetLayout(vk, device, &setLayoutCreateInfo);

	setLayoutCreateInfo.bindingCount = 0;
	Move<vk::VkDescriptorSetLayout>	emptyDescriptorSetLayout = vk::createDescriptorSetLayout(vk, device, &setLayoutCreateInfo);

	vk::DescriptorPoolBuilder poolBuilder;
	poolBuilder.addType(bindings[1].descriptorType, 1);
	poolBuilder.addType(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1);

	descriptorPool = poolBuilder.build(vk, device, poolCreateFlags, 1u);
	descriptorSet = makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout);

	VkDeviceSize	align = de::max(de::max(properties.properties.limits.minUniformBufferOffsetAlignment,
											properties.properties.limits.minStorageBufferOffsetAlignment),
											(VkDeviceSize)128 /*sizeof(T1)*/);

	deUint32 numBindings = 1;
	for (deUint32 d = 0; d < m_data.depth; ++d)
	{
		numBindings = numBindings*3+1;
	}

	VkBufferDeviceAddressCreateInfoEXT addressCreateInfoEXT =
	{
		VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT,	// VkStructureType	 sType;
		DE_NULL,													// const void*		 pNext;
		0x000000000ULL,												// VkDeviceSize		 deviceAddress
	};

	VkBufferOpaqueCaptureAddressCreateInfo bufferOpaqueCaptureAddressCreateInfo =
	{
		VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO,	// VkStructureType	 sType;
		DE_NULL,														// const void*		 pNext;
		0x000000000ULL,													// VkDeviceSize		 opaqueCaptureAddress
	};

	std::vector<deUint8 *> cpuAddrs(numBindings);
	std::vector<VkDeviceAddress> gpuAddrs(numBindings);
	std::vector<deUint64> opaqueBufferAddrs(numBindings);
	std::vector<deUint64> opaqueMemoryAddrs(numBindings);

	VkBufferDeviceAddressInfo bufferDeviceAddressInfo =
	{
		VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,	// VkStructureType	 sType;
		DE_NULL,										// const void*		 pNext;
		0,												// VkBuffer			 buffer
	};

	VkDeviceMemoryOpaqueCaptureAddressInfo deviceMemoryOpaqueCaptureAddressInfo =
	{
		VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO,	// VkStructureType	 sType;
		DE_NULL,														// const void*		 pNext;
		0,																// VkDeviceMemory	 memory;
	};

	bool multiBuffer = m_data.bufType != BT_SINGLE;
	deUint32 numBuffers = multiBuffer ? numBindings : 1;
	VkDeviceSize bufferSize = multiBuffer ? align : (align*numBindings);

	vector<VkBufferSp>			buffers(numBuffers);
	vector<AllocationSp>		allocations(numBuffers);

	VkBufferCreateInfo			bufferCreateInfo = makeBufferCreateInfo(DE_NULL, bufferSize,
														VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
														VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT |
														VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,
														m_data.bufType == BT_REPLAY ? VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT : 0);

	// VkMemoryAllocateFlags to be filled out later
	VkMemoryAllocateFlagsInfo	allocFlagsInfo =
	{
		VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO,	//	VkStructureType	sType
		DE_NULL,										//	const void*		pNext
		0,												//	VkMemoryAllocateFlags    flags
		0,												//	uint32_t                 deviceMask
	};

	VkMemoryOpaqueCaptureAddressAllocateInfo memoryOpaqueCaptureAddressAllocateInfo =
	{
		VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO,	// VkStructureType    sType;
		DE_NULL,														// const void*        pNext;
		0,																// uint64_t           opaqueCaptureAddress;
	};

	if (useKHR)
		allocFlagsInfo.flags |= VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT;

	if (useKHR && m_data.bufType == BT_REPLAY)
	{
		allocFlagsInfo.flags |= VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT;
		allocFlagsInfo.pNext = &memoryOpaqueCaptureAddressAllocateInfo;
	}

	for (deUint32 i = 0; i < numBuffers; ++i)
	{
		buffers[i] = VkBufferSp(new Unique<VkBuffer>(createBuffer(vk, device, &bufferCreateInfo)));

		// query opaque capture address before binding memory
		if (useKHR) {
			bufferDeviceAddressInfo.buffer = **buffers[i];
			opaqueBufferAddrs[i] = vk.getBufferOpaqueCaptureAddress(device, &bufferDeviceAddressInfo);
		}

		allocations[i] = AllocationSp(allocateExtended(vki, vk, physDevice, device, getBufferMemoryRequirements(vk, device, **buffers[i]), MemoryRequirement::HostVisible, &allocFlagsInfo));

		if (useKHR) {
			deviceMemoryOpaqueCaptureAddressInfo.memory = allocations[i]->getMemory();
			opaqueMemoryAddrs[i] = vk.getDeviceMemoryOpaqueCaptureAddress(device, &deviceMemoryOpaqueCaptureAddressInfo);
		}

		VK_CHECK(vk.bindBufferMemory(device, **buffers[i], allocations[i]->getMemory(), 0));
	}

	if (m_data.bufType == BT_REPLAY)
	{
		for (deUint32 i = 0; i < numBuffers; ++i)
		{
			bufferDeviceAddressInfo.buffer = **buffers[i];
			if (useKHR)
				gpuAddrs[i] = vk.getBufferDeviceAddress(device, &bufferDeviceAddressInfo);
			else
				gpuAddrs[i] = vk.getBufferDeviceAddressEXT(device, &bufferDeviceAddressInfo);
		}
		buffers.clear();
		buffers.resize(numBuffers);
		allocations.clear();
		allocations.resize(numBuffers);

		bufferCreateInfo.pNext = useKHR ? (void *)&bufferOpaqueCaptureAddressCreateInfo : (void *)&addressCreateInfoEXT;

		for (deInt32 i = numBuffers-1; i >= 0; --i)
		{
			addressCreateInfoEXT.deviceAddress = gpuAddrs[i];
			bufferOpaqueCaptureAddressCreateInfo.opaqueCaptureAddress = opaqueBufferAddrs[i];
			memoryOpaqueCaptureAddressAllocateInfo.opaqueCaptureAddress = opaqueMemoryAddrs[i];

			buffers[i] = VkBufferSp(new Unique<VkBuffer>(createBuffer(vk, device, &bufferCreateInfo)));
			allocations[i] = AllocationSp(allocateExtended(vki, vk, physDevice, device, getBufferMemoryRequirements(vk, device, **buffers[i]), MemoryRequirement::HostVisible, &allocFlagsInfo));
			VK_CHECK(vk.bindBufferMemory(device, **buffers[i], allocations[i]->getMemory(), 0));

			bufferDeviceAddressInfo.buffer = **buffers[i];
			VkDeviceSize newAddr;
			if (useKHR)
				newAddr = vk.getBufferDeviceAddress(device, &bufferDeviceAddressInfo);
			else
				newAddr = vk.getBufferDeviceAddressEXT(device, &bufferDeviceAddressInfo);
			if (newAddr != gpuAddrs[i])
				return tcu::TestStatus(QP_TEST_RESULT_FAIL, ""address mismatch"");
		}
	}

	// Create a buffer and compute the address for each ""align"" bytes.
	for (deUint32 i = 0; i < numBindings; ++i)
	{
		bufferDeviceAddressInfo.buffer = **buffers[multiBuffer ? i : 0];

		if (useKHR)
			gpuAddrs[i] = vk.getBufferDeviceAddress(device, &bufferDeviceAddressInfo);
		else
			gpuAddrs[i] = vk.getBufferDeviceAddressEXT(device, &bufferDeviceAddressInfo);
		cpuAddrs[i] = (deUint8 *)allocations[multiBuffer ? i : 0]->getHostPtr();
		if (!multiBuffer)
		{
			cpuAddrs[i] = cpuAddrs[i] + align*i;
			gpuAddrs[i] = gpuAddrs[i] + align*i;
		}
		//printf(""addr 0x%08x`%08x\\n"", (unsigned)(gpuAddrs[i]>>32), (unsigned)(gpuAddrs[i]));
	}

	fillBuffer(cpuAddrs, gpuAddrs, 0, 0);

	for (deUint32 i = 0; i < numBuffers; ++i)
		flushAlloc(vk, device, *allocations[i]);

	const VkQueue					queue					= m_context.getUniversalQueue();
	Move<VkCommandPool>				cmdPool					= createCommandPool(vk, device, 0, m_context.getUniversalQueueFamilyIndex());
	Move<VkCommandBuffer>			cmdBuffer				= allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);

	beginCommandBuffer(vk, *cmdBuffer, 0u);

	// Push constants are used for dynamic indexing. PushConstant[i] = i.

	const VkPushConstantRange pushConstRange =
	{
		allShaderStages,		// VkShaderStageFlags	stageFlags
		0,						// deUint32				offset
		128						// deUint32				size
	};

	deUint32 nonEmptySetLimit = m_data.base == BASE_UBO ? properties.properties.limits.maxPerStageDescriptorUniformBuffers :
														  properties.properties.limits.maxPerStageDescriptorStorageBuffers;
	nonEmptySetLimit = de::min(nonEmptySetLimit, properties.properties.limits.maxPerStageDescriptorStorageImages);

	vector<vk::VkDescriptorSetLayout>	descriptorSetLayoutsRaw(m_data.set+1);
	for (size_t i = 0; i < m_data.set+1; ++i)
	{
		// use nonempty descriptor sets to consume resources until we run out of descriptors
		if (i < nonEmptySetLimit - 1 || i == m_data.set)
			descriptorSetLayoutsRaw[i] = descriptorSetLayout.get();
		else
			descriptorSetLayoutsRaw[i] = emptyDescriptorSetLayout.get();
	}

	const VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo =
	{
		VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,				// sType
		DE_NULL,													// pNext
		(VkPipelineLayoutCreateFlags)0,
		m_data.set+1,												// setLayoutCount
		&descriptorSetLayoutsRaw[0],								// pSetLayouts
		1u,															// pushConstantRangeCount
		&pushConstRange,											// pPushConstantRanges
	};

	Move<VkPipelineLayout> pipelineLayout = createPipelineLayout(vk, device, &pipelineLayoutCreateInfo, NULL);

	// PushConstant[i] = i
	for (deUint32 i = 0; i < (deUint32)(128 / sizeof(deUint32)); ++i)
	{
		vk.cmdPushConstants(*cmdBuffer, *pipelineLayout, allShaderStages,
							(deUint32)(i * sizeof(deUint32)), (deUint32)sizeof(deUint32), &i);
	}

	de::MovePtr<BufferWithMemory> copyBuffer;
	copyBuffer = de::MovePtr<BufferWithMemory>(new BufferWithMemory(
		vk, device, allocator, makeBufferCreateInfo(DE_NULL, DIM*DIM*sizeof(deUint32), VK_BUFFER_USAGE_TRANSFER_DST_BIT, 0), MemoryRequirement::HostVisible));

	const VkImageCreateInfo			imageCreateInfo			=
	{
		VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,	// VkStructureType			sType;
		DE_NULL,								// const void*				pNext;
		(VkImageCreateFlags)0u,					// VkImageCreateFlags		flags;
		VK_IMAGE_TYPE_2D,						// VkImageType				imageType;
		VK_FORMAT_R32_UINT,						// VkFormat					format;
		{
			DIM,								// deUint32	width;
			DIM,								// deUint32	height;
			1u									// deUint32	depth;
		},										// VkExtent3D				extent;
		1u,										// deUint32					mipLevels;
		1u,										// deUint32					arrayLayers;
		VK_SAMPLE_COUNT_1_BIT,					// VkSampleCountFlagBits	samples;
		VK_IMAGE_TILING_OPTIMAL,				// VkImageTiling			tiling;
		VK_IMAGE_USAGE_STORAGE_BIT
		| VK_IMAGE_USAGE_TRANSFER_SRC_BIT
		| VK_IMAGE_USAGE_TRANSFER_DST_BIT,		// VkImageUsageFlags		usage;
		VK_SHARING_MODE_EXCLUSIVE,				// VkSharingMode			sharingMode;
		0u,										// deUint32					queueFamilyIndexCount;
		DE_NULL,								// const deUint32*			pQueueFamilyIndices;
		VK_IMAGE_LAYOUT_UNDEFINED				// VkImageLayout			initialLayout;
	};

	VkImageViewCreateInfo		imageViewCreateInfo		=
	{
		VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,	// VkStructureType			sType;
		DE_NULL,									// const void*				pNext;
		(VkImageViewCreateFlags)0u,					// VkImageViewCreateFlags	flags;
		DE_NULL,									// VkImage					image;
		VK_IMAGE_VIEW_TYPE_2D,						// VkImageViewType			viewType;
		VK_FORMAT_R32_UINT,							// VkFormat					format;
		{
			VK_COMPONENT_SWIZZLE_R,					// VkComponentSwizzle	r;
			VK_COMPONENT_SWIZZLE_G,					// VkComponentSwizzle	g;
			VK_COMPONENT_SWIZZLE_B,					// VkComponentSwizzle	b;
			VK_COMPONENT_SWIZZLE_A					// VkComponentSwizzle	a;
		},											// VkComponentMapping		 components;
		{
			VK_IMAGE_ASPECT_COLOR_BIT,				// VkImageAspectFlags	aspectMask;
			0u,										// deUint32				baseMipLevel;
			1u,										// deUint32				levelCount;
			0u,										// deUint32				baseArrayLayer;
			1u										// deUint32				layerCount;
		}											// VkImageSubresourceRange	subresourceRange;
	};

	de::MovePtr<ImageWithMemory> image;
	Move<VkImageView> imageView;

	image = de::MovePtr<ImageWithMemory>(new ImageWithMemory(
		vk, device, allocator, imageCreateInfo, MemoryRequirement::Any));
	imageViewCreateInfo.image = **image;
	imageView = createImageView(vk, device, &imageViewCreateInfo, NULL);

	VkDescriptorImageInfo imageInfo = makeDescriptorImageInfo(DE_NULL, *imageView, VK_IMAGE_LAYOUT_GENERAL);
	VkDescriptorBufferInfo bufferInfo = makeDescriptorBufferInfo(**buffers[0], 0, align);

	VkWriteDescriptorSet w =
	{
		VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,							// sType
		DE_NULL,														// pNext
		*descriptorSet,													// dstSet
		(deUint32)0,													// dstBinding
		0,																// dstArrayElement
		1u,																// descriptorCount
		bindings[0].descriptorType,										// descriptorType
		&imageInfo,														// pImageInfo
		&bufferInfo,													// pBufferInfo
		DE_NULL,														// pTexelBufferView
	};
	vk.updateDescriptorSets(device, 1, &w, 0, NULL);

	w.dstBinding = 1;
	w.descriptorType = bindings[1].descriptorType;
	vk.updateDescriptorSets(device, 1, &w, 0, NULL);

	vk.cmdBindDescriptorSets(*cmdBuffer, bindPoint, *pipelineLayout, m_data.set, 1, &descriptorSet.get(), 0, DE_NULL);

	Move<VkPipeline> pipeline;
	Move<VkRenderPass> renderPass;
	Move<VkFramebuffer> framebuffer;
	de::MovePtr<BufferWithMemory> sbtBuffer;

	m_context.getTestContext().touchWatchdogAndDisableIntervalTimeLimit();

	if (m_data.stage == STAGE_COMPUTE)
	{
		const Unique<VkShaderModule>	shader(createShaderModule(vk, device, m_context.getBinaryCollection().get(""test""), 0));

		const VkPipelineShaderStageCreateInfo	shaderCreateInfo =
		{
			VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
			DE_NULL,
			(VkPipelineShaderStageCreateFlags)0,
			VK_SHADER_STAGE_COMPUTE_BIT,								// stage
			*shader,													// shader
			""main"",
			DE_NULL,													// pSpecializationInfo
		};

		const VkComputePipelineCreateInfo		pipelineCreateInfo =
		{
			VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
			DE_NULL,
			0u,															// flags
			shaderCreateInfo,											// cs
			*pipelineLayout,											// layout
			(vk::VkPipeline)0,											// basePipelineHandle
			0u,															// basePipelineIndex
		};
		pipeline = createComputePipeline(vk, device, DE_NULL, &pipelineCreateInfo, NULL);
	}
#if ENABLE_RAYTRACING
	else if (m_data.stage == STAGE_RAYGEN)
	{
		const Unique<VkShaderModule>	shader(createShaderModule(vk, device, m_context.getBinaryCollection().get(""test""), 0));

		const VkPipelineShaderStageCreateInfo	shaderCreateInfo =
		{
			VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
			DE_NULL,
			(VkPipelineShaderStageCreateFlags)0,
			VK_SHADER_STAGE_RAYGEN_BIT_NV,								// stage
			*shader,													// shader
			""main"",
			DE_NULL,													// pSpecializationInfo
		};

		VkRayTracingShaderGroupCreateInfoNV group =
		{
			VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV,
			DE_NULL,
			VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV,			// type
			0,														// generalShader
			VK_SHADER_UNUSED_NV,									// closestHitShader
			VK_SHADER_UNUSED_NV,									// anyHitShader
			VK_SHADER_UNUSED_NV,									// intersectionShader
		};

		VkRayTracingPipelineCreateInfoNV pipelineCreateInfo = {
			VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV,	// sType
			DE_NULL,												// pNext
			0,														// flags
			1,														// stageCount
			&shaderCreateInfo,										// pStages
			1,														// groupCount
			&group,													// pGroups
			0,														// maxRecursionDepth
			*pipelineLayout,										// layout
			(vk::VkPipeline)0,										// basePipelineHandle
			0u,														// basePipelineIndex
		};

		pipeline = createRayTracingPipelineNV(vk, device, DE_NULL, &pipelineCreateInfo, NULL);

		sbtBuffer = de::MovePtr<BufferWithMemory>(new BufferWithMemory(
			vk, device, allocator, makeBufferCreateInfo(DE_NULL, rayTracingProperties.shaderGroupHandleSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_RAY_TRACING_BIT_NV, 0), MemoryRequirement::HostVisible));
		deUint32 *ptr = (deUint32 *)sbtBuffer->getAllocation().getHostPtr();
		invalidateMappedMemoryRange(vk, device, sbtBuffer->getAllocation().getMemory(), sbtBuffer->getAllocation().getOffset(), rayTracingProperties.shaderGroupHandleSize);

		vk.getRayTracingShaderGroupHandlesNV(device, *pipeline, 0, 1, rayTracingProperties.shaderGroupHandleSize, ptr);
	}
#endif
	else
	{

		const vk::VkSubpassDescription		subpassDesc			=
		{
			(vk::VkSubpassDescriptionFlags)0,
			vk::VK_PIPELINE_BIND_POINT_GRAPHICS,					// pipelineBindPoint
			0u,														// inputCount
			DE_NULL,												// pInputAttachments
			0u,														// colorCount
			DE_NULL,												// pColorAttachments
			DE_NULL,												// pResolveAttachments
			DE_NULL,												// depthStencilAttachment
			0u,														// preserveCount
			DE_NULL,												// pPreserveAttachments
		};
		const vk::VkRenderPassCreateInfo	renderPassParams	=
		{
			vk::VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,			// sType
			DE_NULL,												// pNext
			(vk::VkRenderPassCreateFlags)0,
			0u,														// attachmentCount
			DE_NULL,												// pAttachments
			1u,														// subpassCount
			&subpassDesc,											// pSubpasses
			0u,														// dependencyCount
			DE_NULL,												// pDependencies
		};

		renderPass = createRenderPass(vk, device, &renderPassParams);

		const vk::VkFramebufferCreateInfo	framebufferParams	=
		{
			vk::VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,	// sType
			DE_NULL,										// pNext
			(vk::VkFramebufferCreateFlags)0,
			*renderPass,									// renderPass
			0u,												// attachmentCount
			DE_NULL,										// pAttachments
			DIM,											// width
			DIM,											// height
			1u,												// layers
		};

		framebuffer = createFramebuffer(vk, device, &framebufferParams);

		const VkPipelineVertexInputStateCreateInfo		vertexInputStateCreateInfo		=
		{
			VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,	// VkStructureType							sType;
			DE_NULL,													// const void*								pNext;
			(VkPipelineVertexInputStateCreateFlags)0,					// VkPipelineVertexInputStateCreateFlags	flags;
			0u,															// deUint32									vertexBindingDescriptionCount;
			DE_NULL,													// const VkVertexInputBindingDescription*	pVertexBindingDescriptions;
			0u,															// deUint32									vertexAttributeDescriptionCount;
			DE_NULL														// const VkVertexInputAttributeDescription*	pVertexAttributeDescriptions;
		};

		const VkPipelineInputAssemblyStateCreateInfo	inputAssemblyStateCreateInfo	=
		{
			VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,	// VkStructureType							sType;
			DE_NULL,														// const void*								pNext;
			(VkPipelineInputAssemblyStateCreateFlags)0,						// VkPipelineInputAssemblyStateCreateFlags	flags;
			(m_data.stage == STAGE_VERTEX) ? VK_PRIMITIVE_TOPOLOGY_POINT_LIST : VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, // VkPrimitiveTopology						topology;
			VK_FALSE														// VkBool32									primitiveRestartEnable;
		};

		const VkPipelineRasterizationStateCreateInfo	rasterizationStateCreateInfo	=
		{
			VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,		// VkStructureType							sType;
			DE_NULL,														// const void*								pNext;
			(VkPipelineRasterizationStateCreateFlags)0,						// VkPipelineRasterizationStateCreateFlags	flags;
			VK_FALSE,														// VkBool32									depthClampEnable;
			(m_data.stage == STAGE_VERTEX) ? VK_TRUE : VK_FALSE,			// VkBool32									rasterizerDiscardEnable;
			VK_POLYGON_MODE_FILL,											// VkPolygonMode							polygonMode;
			VK_CULL_MODE_NONE,												// VkCullModeFlags							cullMode;
			VK_FRONT_FACE_CLOCKWISE,										// VkFrontFace								frontFace;
			VK_FALSE,														// VkBool32									depthBiasEnable;
			0.0f,															// float									depthBiasConstantFactor;
			0.0f,															// float									depthBiasClamp;
			0.0f,															// float									depthBiasSlopeFactor;
			1.0f															// float									lineWidth;
		};

		const VkPipelineMultisampleStateCreateInfo		multisampleStateCreateInfo =
		{
			VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,	// VkStructureType							sType
			DE_NULL,													// const void*								pNext
			0u,															// VkPipelineMultisampleStateCreateFlags	flags
			VK_SAMPLE_COUNT_1_BIT,										// VkSampleCountFlagBits					rasterizationSamples
			VK_FALSE,													// VkBool32									sampleShadingEnable
			1.0f,														// float									minSampleShading
			DE_NULL,													// const VkSampleMask*						pSampleMask
			VK_FALSE,													// VkBool32									alphaToCoverageEnable
			VK_FALSE													// VkBool32									alphaToOneEnable
		};

		VkViewport viewport = makeViewport(DIM, DIM);
		VkRect2D scissor = makeRect2D(DIM, DIM);

		const VkPipelineViewportStateCreateInfo			viewportStateCreateInfo				=
		{
			VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,	// VkStructureType							sType
			DE_NULL,												// const void*								pNext
			(VkPipelineViewportStateCreateFlags)0,					// VkPipelineViewportStateCreateFlags		flags
			1u,														// deUint32									viewportCount
			&viewport,												// const VkViewport*						pViewports
			1u,														// deUint32									scissorCount
			&scissor												// const VkRect2D*							pScissors
		};

		Move<VkShaderModule> fs;
		Move<VkShaderModule> vs;

		deUint32 numStages;
		if (m_data.stage == STAGE_VERTEX)
		{
			vs = createShaderModule(vk, device, m_context.getBinaryCollection().get(""test""), 0);
			fs = createShaderModule(vk, device, m_context.getBinaryCollection().get(""test""), 0); // bogus
			numStages = 1u;
		}
		else
		{
			vs = createShaderModule(vk, device, m_context.getBinaryCollection().get(""vert""), 0);
			fs = createShaderModule(vk, device, m_context.getBinaryCollection().get(""test""), 0);
			numStages = 2u;
		}

		const VkPipelineShaderStageCreateInfo	shaderCreateInfo[2] =
		{
			{
				VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
				DE_NULL,
				(VkPipelineShaderStageCreateFlags)0,
				VK_SHADER_STAGE_VERTEX_BIT,									// stage
				*vs,														// shader
				""main"",
				DE_NULL,													// pSpecializationInfo
			},
			{
				VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
				DE_NULL,
				(VkPipelineShaderStageCreateFlags)0,
				VK_SHADER_STAGE_FRAGMENT_BIT,								// stage
				*fs,														// shader
				""main"",
				DE_NULL,													// pSpecializationInfo
			}
		};

		const VkGraphicsPipelineCreateInfo				graphicsPipelineCreateInfo		=
		{
			VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,	// VkStructureType									sType;
			DE_NULL,											// const void*										pNext;
			(VkPipelineCreateFlags)0,							// VkPipelineCreateFlags							flags;
			numStages,											// deUint32											stageCount;
			&shaderCreateInfo[0],								// const VkPipelineShaderStageCreateInfo*			pStages;
			&vertexInputStateCreateInfo,						// const VkPipelineVertexInputStateCreateInfo*		pVertexInputState;
			&inputAssemblyStateCreateInfo,						// const VkPipelineInputAssemblyStateCreateInfo*	pInputAssemblyState;
			DE_NULL,											// const VkPipelineTessellationStateCreateInfo*		pTessellationState;
			&viewportStateCreateInfo,							// const VkPipelineViewportStateCreateInfo*			pViewportState;
			&rasterizationStateCreateInfo,						// const VkPipelineRasterizationStateCreateInfo*	pRasterizationState;
			&multisampleStateCreateInfo,						// const VkPipelineMultisampleStateCreateInfo*		pMultisampleState;
			DE_NULL,											// const VkPipelineDepthStencilStateCreateInfo*		pDepthStencilState;
			DE_NULL,											// const VkPipelineColorBlendStateCreateInfo*		pColorBlendState;
			DE_NULL,											// const VkPipelineDynamicStateCreateInfo*			pDynamicState;
			pipelineLayout.get(),								// VkPipelineLayout									layout;
			renderPass.get(),									// VkRenderPass										renderPass;
			0u,													// deUint32											subpass;
			DE_NULL,											// VkPipeline										basePipelineHandle;
			0													// int												basePipelineIndex;
		};

		pipeline = createGraphicsPipeline(vk, device, DE_NULL, &graphicsPipelineCreateInfo);
	}

	m_context.getTestContext().touchWatchdogAndEnableIntervalTimeLimit();

	const VkImageMemoryBarrier imageBarrier =
	{
		VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,				// VkStructureType		sType
		DE_NULL,											// const void*			pNext
		0u,													// VkAccessFlags		srcAccessMask
		VK_ACCESS_TRANSFER_WRITE_BIT,						// VkAccessFlags		dstAccessMask
		VK_IMAGE_LAYOUT_UNDEFINED,							// VkImageLayout		oldLayout
		VK_IMAGE_LAYOUT_GENERAL,							// VkImageLayout		newLayout
		VK_QUEUE_FAMILY_IGNORED,							// uint32_t				srcQueueFamilyIndex
		VK_QUEUE_FAMILY_IGNORED,							// uint32_t				dstQueueFamilyIndex
		**image,											// VkImage				image
		{
			VK_IMAGE_ASPECT_COLOR_BIT,				// VkImageAspectFlags	aspectMask
			0u,										// uint32_t				baseMipLevel
			1u,										// uint32_t				mipLevels,
			0u,										// uint32_t				baseArray
			1u,										// uint32_t				arraySize
		}
	};

	vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
							(VkDependencyFlags)0,
							0, (const VkMemoryBarrier*)DE_NULL,
							0, (const VkBufferMemoryBarrier*)DE_NULL,
							1, &imageBarrier);

	vk.cmdBindPipeline(*cmdBuffer, bindPoint, *pipeline);

	VkImageSubresourceRange range = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1u, 0u, 1u);
	VkClearValue clearColor = makeClearValueColorU32(0,0,0,0);

	VkMemoryBarrier					memBarrier =
	{
		VK_STRUCTURE_TYPE_MEMORY_BARRIER,	// sType
		DE_NULL,							// pNext
		0u,									// srcAccessMask
		0u,									// dstAccessMask
	};

	vk.cmdClearColorImage(*cmdBuffer, **image, VK_IMAGE_LAYOUT_GENERAL, &clearColor.color, 1, &range);

	memBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
	memBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;
	vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, allPipelineStages,
		0, 1, &memBarrier, 0, DE_NULL, 0, DE_NULL);

	if (m_data.stage == STAGE_COMPUTE)
	{
		vk.cmdDispatch(*cmdBuffer, DIM, DIM, 1);
	}
#if ENABLE_RAYTRACING
	else if (m_data.stage == STAGE_RAYGEN)
	{
		vk.cmdTraceRaysNV(*cmdBuffer,
			**sbtBuffer, 0,
			DE_NULL, 0, 0,
			DE_NULL, 0, 0,
			DE_NULL, 0, 0,
			DIM, DIM, 1);
	}
#endif
	else
	{
		beginRenderPass(vk, *cmdBuffer, *renderPass, *framebuffer,
						makeRect2D(DIM, DIM),
						0, DE_NULL, VK_SUBPASS_CONTENTS_INLINE);
		// Draw a point cloud for vertex shader testing, and a single quad for fragment shader testing
		if (m_data.stage == STAGE_VERTEX)
		{
			vk.cmdDraw(*cmdBuffer, DIM*DIM, 1u, 0u, 0u);
		}
		else
		{
			vk.cmdDraw(*cmdBuffer, 4u, 1u, 0u, 0u);
		}
		endRenderPass(vk, *cmdBuffer);
	}

	memBarrier.srcAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;
	memBarrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT;
	vk.cmdPipelineBarrier(*cmdBuffer, allPipelineStages, VK_PIPELINE_STAGE_TRANSFER_BIT,
		0, 1, &memBarrier, 0, DE_NULL, 0, DE_NULL);

	const VkBufferImageCopy copyRegion = makeBufferImageCopy(makeExtent3D(DIM, DIM, 1u),
															 makeImageSubresourceLayers(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 0u, 1u));
	vk.cmdCopyImageToBuffer(*cmdBuffer, **image, VK_IMAGE_LAYOUT_GENERAL, **copyBuffer, 1u, &copyRegion);

	endCommandBuffer(vk, *cmdBuffer);

	submitCommandsAndWait(vk, device, queue, cmdBuffer.get());

	deUint32 *ptr = (deUint32 *)copyBuffer->getAllocation().getHostPtr();
	invalidateMappedMemoryRange(vk, device, copyBuffer->getAllocation().getMemory(), copyBuffer->getAllocation().getOffset(), DIM*DIM*sizeof(deUint32));

	qpTestResult res = QP_TEST_RESULT_PASS;

	for (deUint32 i = 0; i < DIM*DIM; ++i)
	{
		if (ptr[i] != 1)
		{
			res = QP_TEST_RESULT_FAIL;
		}
	}

	return tcu::TestStatus(res, qpGetTestResultName(res));
}

}	// anonymous

tcu::TestCaseGroup*	createBufferDeviceAddressTests (tcu::TestContext& testCtx)
{
	de::MovePtr<tcu::TestCaseGroup> group(new tcu::TestCaseGroup(testCtx, ""buffer_device_address"", ""Test VK_EXT_buffer_device_address""));

	typedef struct
	{
		deUint32				count;
		const char*				name;
		const char*				description;
	} TestGroupCase;

	TestGroupCase setCases[] =
	{
		{ 0,	""set0"",		""set 0""		},
		{ 3,	""set3"",		""set 3""		},
		{ 7,	""set7"",		""set 7""		},
		{ 15,	""set15"",	""set 15""	},
		{ 31,	""set31"",	""set 31""	},
	};

	TestGroupCase depthCases[] =
	{
		{ 1,	""depth1"",	""1 nested struct""		},
		{ 2,	""depth2"",	""2 nested structs""		},
		{ 3,	""depth3"",	""3 nested structs""		},
	};

	TestGroupCase baseCases[] =
	{
		{ BASE_UBO,	""baseubo"",	""base ubo""		},
		{ BASE_SSBO,""basessbo"",	""base ssbo""		},
	};

	TestGroupCase cvtCases[] =
	{
		{ CONVERT_NONE,			""load"",				""load reference""										},
		{ CONVERT_UINT64,		""convert"",			""load and convert reference""							},
		{ CONVERT_UVEC2,		""convertuvec2"",		""load and convert reference to uvec2""					},
		{ CONVERT_U64CMP,		""convertchecku64"",	""load, convert and compare references as uint64_t""		},
		{ CONVERT_UVEC2CMP,		""convertcheckuv2"",	""load, convert and compare references as uvec2""			},
		{ CONVERT_UVEC2TOU64,	""crossconvertu2p"",	""load reference as uint64_t and convert it to uvec2""	},
		{ CONVERT_U64TOUVEC2,	""crossconvertp2u"",	""load reference as uvec2 and convert it to uint64_t""	},
	};

	TestGroupCase storeCases[] =
	{
		{ 0,	""nostore"",		""don't store intermediate reference""		},
		{ 1,	""store"",		""store intermediate reference""				},
	};

	TestGroupCase btCases[] =
	{
		{ BT_SINGLE,	""single"",		""single buffer""	},
		{ BT_MULTI,		""multi"",		""multiple buffers""	},
		{ BT_REPLAY,	""replay"",		""multiple buffers and VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT""	},
	};

	TestGroupCase layoutCases[] =
	{
		{ LAYOUT_STD140,	""std140"",		""std140""	},
		{ LAYOUT_SCALAR,	""scalar"",		""scalar""	},
	};

	TestGroupCase stageCases[] =
	{
		{ STAGE_COMPUTE,	""comp"",		""compute""	},
		{ STAGE_FRAGMENT,	""frag"",		""fragment""	},
		{ STAGE_VERTEX,		""vert"",		""vertex""	},
#if ENABLE_RAYTRACING
		{ STAGE_RAYGEN,		""rgen"",		""raygen""	},
#endif
	};

	for (int setNdx = 0; setNdx < DE_LENGTH_OF_ARRAY(setCases); setNdx++)
	{
		de::MovePtr<tcu::TestCaseGroup> setGroup(new tcu::TestCaseGroup(testCtx, setCases[setNdx].name, setCases[setNdx].description));
		for (int depthNdx = 0; depthNdx < DE_LENGTH_OF_ARRAY(depthCases); depthNdx++)
		{
			de::MovePtr<tcu::TestCaseGroup> depthGroup(new tcu::TestCaseGroup(testCtx, depthCases[depthNdx].name, depthCases[depthNdx].description));
			for (int baseNdx = 0; baseNdx < DE_LENGTH_OF_ARRAY(baseCases); baseNdx++)
			{
				de::MovePtr<tcu::TestCaseGroup> baseGroup(new tcu::TestCaseGroup(testCtx, baseCases[baseNdx].name, baseCases[baseNdx].description));
				for (int cvtNdx = 0; cvtNdx < DE_LENGTH_OF_ARRAY(cvtCases); cvtNdx++)
				{
					de::MovePtr<tcu::TestCaseGroup> cvtGroup(new tcu::TestCaseGroup(testCtx, cvtCases[cvtNdx].name, cvtCases[cvtNdx].description));
					for (int storeNdx = 0; storeNdx < DE_LENGTH_OF_ARRAY(storeCases); storeNdx++)
					{
						de::MovePtr<tcu::TestCaseGroup> storeGroup(new tcu::TestCaseGroup(testCtx, storeCases[storeNdx].name, storeCases[storeNdx].description));
						for (int btNdx = 0; btNdx < DE_LENGTH_OF_ARRAY(btCases); btNdx++)
						{
							de::MovePtr<tcu::TestCaseGroup> btGroup(new tcu::TestCaseGroup(testCtx, btCases[btNdx].name, btCases[btNdx].description));
							for (int layoutNdx = 0; layoutNdx < DE_LENGTH_OF_ARRAY(layoutCases); layoutNdx++)
							{
								de::MovePtr<tcu::TestCaseGroup> layoutGroup(new tcu::TestCaseGroup(testCtx, layoutCases[layoutNdx].name, layoutCases[layoutNdx].description));
								for (int stageNdx = 0; stageNdx < DE_LENGTH_OF_ARRAY(stageCases); stageNdx++)
								{
									CaseDef c =
									{
										setCases[setNdx].count,						// deUint32 set;
										depthCases[depthNdx].count,					// deUint32 depth;
										(Base)baseCases[baseNdx].count,				// Base base;
										(Stage)stageCases[stageNdx].count,			// Stage stage;
										(Convert)cvtCases[cvtNdx].count,			// Convert convertUToPtr;
										!!storeCases[storeNdx].count,				// bool storeInLocal;
										(BufType)btCases[btNdx].count,				// BufType bufType;
										(Layout)layoutCases[layoutNdx].count,		// Layout layout;
									};

									// Skip more complex test cases for most descriptor sets, to reduce runtime.
									if (c.set != 3 && (c.depth == 3 || c.layout != LAYOUT_STD140))
										continue;

									layoutGroup->addChild(new BufferAddressTestCase(testCtx, stageCases[stageNdx].name, stageCases[stageNdx].description, c));
								}
								btGroup->addChild(layoutGroup.release());
							}
							storeGroup->addChild(btGroup.release());
						}
						cvtGroup->addChild(storeGroup.release());
					}
					baseGroup->addChild(cvtGroup.release());
				}
				depthGroup->addChild(baseGroup.release());
			}
			setGroup->addChild(depthGroup.release());
		}
		group->addChild(setGroup.release());
	}
	return group.release();
}

}	// BindingModel
}	// vkt
",16366,True,2863.530418362379,median
"= Contact+ Pro - Developer Guide
:toc:
:toc-title:
:toc-placement: preamble
:sectnums:
:imagesDir: images
:stylesDir: stylesheets
ifdef::env-github[]
:tip-caption: :bulb:
:note-caption: :information_source:
endif::[]
ifdef::env-github,env-browser[:outfilesuffix: .adoc]
:repoURL: https://github.com/CS2103AUG2017-T14-B4/main

By: `Team T14-B4`

The App is developer based on address-book level 4 by team `See-du`

== Setting up

=== Prerequisites

. *JDK `1.8.0_60`* or later
+
[NOTE]
Having any Java 8 version is not enough. +
This app will not work with earlier versions of Java 8.
+

. *IntelliJ* IDE
+
[NOTE]
IntelliJ by default has Gradle and JavaFx plugins installed. +
Do not disable them. If you have disabled them, go to `File` > `Settings` > `Plugins` to re-enable them.


=== Setting up the project in your computer

. Fork this repo, and clone the fork to your computer
. Open IntelliJ (if you are not in the welcome screen, click `File` > `Close Project` to close the existing project dialog first)
. Set up the correct JDK version for Gradle
.. Click `Configure` > `Project Defaults` > `Project Structure`
.. Click `New...` and find the directory of the JDK
. Click `Import Project`
. Locate the `build.gradle` file and select it. Click `OK`
. Click `Open as Project`
. Click `OK` to accept the default settings
. Open a console and run the command `gradlew processResources` (Mac/Linux: `./gradlew processResources`). It should finish with the `BUILD SUCCESSFUL` message. +
This will generate all resources required by the application and tests.

=== Verifying the setup

. Run the `seedu.address.MainApp` and try a few commands
. link:#testing[Run the tests] to ensure they all pass.

=== Configurations to do before writing code

==== Configuring the coding style

This project follows https://github.com/oss-generic/process/blob/master/docs/CodingStandards.md[oss-generic coding standards]. IntelliJ's default style is mostly compliant with ours but it uses a different import order from ours. To rectify,

. Go to `File` > `Settings...` (Windows/Linux), or `IntelliJ IDEA` > `Preferences...` (macOS)
. Select `Editor` > `Code Style` > `Java`
. Click on the `Imports` tab to set the order

* For `Class count to use import with '\\*'` and `Names count to use static import with '*'`: Set to `999` to prevent IntelliJ from contracting the import statements
* For `Import Layout`: The order is `import static all other imports`, `import java.\\*`, `import javax.*`, `import org.\\*`, `import com.*`, `import all other imports`. Add a `<blank line>` between each `import`

Optionally, you can follow the <<UsingCheckstyle#, UsingCheckstyle.adoc>> document to configure Intellij to check style-compliance as you write code.

==== Updating documentation to match your fork

After forking the repo, links in the documentation will still point to the `se-edu/addressbook-level4` repo. If you plan to develop this as a separate product (i.e. instead of contributing to the `se-edu/addressbook-level4`) , you should replace the URL in the variable `repoURL` in `DeveloperGuide.adoc` and `UserGuide.adoc` with the URL of your fork.

==== Setting up CI

Set up Travis to perform Continuous Integration (CI) for your fork. See <<UsingTravis#, UsingTravis.adoc>> to learn how to set it up.

Optionally, you can set up AppVeyor as a second CI (see <<UsingAppVeyor#, UsingAppVeyor.adoc>>).

[NOTE]
Having both Travis and AppVeyor ensures your App works on both Unix-based platforms and Windows-based platforms (Travis is Unix-based and AppVeyor is Windows-based)

==== Getting started with coding

When you are ready to start coding,

1. Get some sense of the overall design by reading the link:#architecture[Architecture] section.
2. Take a look at the section link:#suggested-programming-tasks-to-get-started[Suggested Programming Tasks to Get Started].

== Design

=== Architecture

image::Architecture.png[width=""600""]
_Figure 2.1.1 : Architecture Diagram_

The *_Architecture Diagram_* given above explains the high-level design of the App. Given below is a quick overview of each component.

[TIP]
The `.pptx` files used to create diagrams in this document can be found in the link:{repoURL}/docs/diagrams/[diagrams] folder. To update a diagram, modify the diagram in the pptx file, select the objects of the diagram, and choose `Save as picture`.

`Main` has only one class called link:{repoURL}/src/main/java/seedu/address/MainApp.java[`MainApp`]. It is responsible for,

* At app launch: Initializes the components in the correct sequence, and connects them up with each other.
* At shut down: Shuts down the components and invokes cleanup method where necessary.

link:#common-classes[*`Commons`*] represents a collection of classes used by multiple other components. Two of those classes play important roles at the architecture level.

* `EventsCenter` : This class (written using https://github.com/google/guava/wiki/EventBusExplained[Google's Event Bus library]) is used by components to communicate with other components using events (i.e. a form of _Event Driven_ design)
* `LogsCenter` : Used by many classes to write log messages to the App's log file.

The rest of the App consists of four components.

* link:#ui-component[*`UI`*] : The UI of the App.
* link:#logic-component[*`Logic`*] : The command executor.
* link:#model-component[*`Model`*] : Holds the data of the App in-memory.
* link:#storage-component[*`Storage`*] : Reads data from, and writes data to, the hard disk.

Each of the four components

* Defines its _API_ in an `interface` with the same name as the Component.
* Exposes its functionality using a `{Component Name}Manager` class.

For example, the `Logic` component (see the class diagram given below) defines it's API in the `Logic.java` interface and exposes its functionality using the `LogicManager.java` class.

image::LogicClassDiagram.png[width=""800""]
_Figure 2.1.2 : Class Diagram of the Logic Component_

[discrete]
==== Events-Driven nature of the design

The _Sequence Diagram_ below shows how the components interact for the scenario where the user issues the command `delete 1`.

image::SDforDeletePerson.png[width=""800""]
_Figure 2.1.3a : Component interactions for `delete 1` command (part 1)_

[NOTE]
Note how the `Model` simply raises a `AddressBookChangedEvent` when the Address Book data are changed, instead of asking the `Storage` to save the updates to the hard disk.

The diagram below shows how the `EventsCenter` reacts to that event, which eventually results in the updates being saved to the hard disk and the status bar of the UI being updated to reflect the 'Last Updated' time.

image::SDforDeletePersonEventHandling.png[width=""800""]
_Figure 2.1.3b : Component interactions for `delete 1` command (part 2)_

[NOTE]
Note how the event is propagated through the `EventsCenter` to the `Storage` and `UI` without `Model` having to be coupled to either of them. This is an example of how this Event Driven approach helps us reduce direct coupling between components.

The sections below give more details of each component.

=== UI component

image::UiClassDiagram.png[width=""800""]
_Figure 2.2.1 : Structure of the UI Component_

*API* : link:{repoURL}/src/main/java/seedu/address/ui/Ui.java[`Ui.java`]

The UI consists of a `MainWindow` that is made up of parts e.g.`CommandBox`, `ResultDisplay`, `PersonListPanel`, `StatusBarFooter`, `BrowserPanel` etc. All these, including the `MainWindow`, inherit from the abstract `UiPart` class.

The `UI` component uses JavaFx UI framework. The layout of these UI parts are defined in matching `.fxml` files that are in the `src/main/resources/view` folder. For example, the layout of the link:{repoURL}/src/main/java/seedu/address/ui/MainWindow.java[`MainWindow`] is specified in link:{repoURL}/src/main/resources/view/MainWindow.fxml[`MainWindow.fxml`]

The `UI` component,

* Executes user commands using the `Logic` component.
* Binds itself to some data in the `Model` so that the UI can auto-update when data in the `Model` change.
* Responds to events raised from various parts of the App and updates the UI accordingly.

=== Logic component

image::LogicClassDiagram.png[width=""800""]
_Figure 2.3.1 : Structure of the Logic Component_

image::LogicCommandClassDiagram.png[width=""800""]
_Figure 2.3.2 : Structure of Commands in the Logic Component. This diagram shows finer details concerning `XYZCommand` and `Command` in Figure 2.3.1_

*API* :
link:{repoURL}/src/main/java/seedu/address/logic/Logic.java[`Logic.java`]

.  `Logic` uses the `AddressBookParser` class to parse the user command.
.  This results in a `Command` object which is executed by the `LogicManager`.
.  The command execution can affect the `Model` (e.g. adding a person) and/or raise events.
.  The result of the command execution is encapsulated as a `CommandResult` object which is passed back to the `Ui`.

Given below is the Sequence Diagram for interactions within the `Logic` component for the `execute(""delete 1"")` API call.

image::DeletePersonSdForLogic.png[width=""800""]
_Figure 2.3.1 : Interactions Inside the Logic Component for the `delete 1` Command_

=== Model component

image::ModelClassDiagram.png[width=""800""]
_Figure 2.4.1 : Structure of the Model Component_

*API* : link:{repoURL}/src/main/java/seedu/address/model/Model.java[`Model.java`]

The `Model`,

* stores a `UserPref` object that represents the user's preferences.
* stores the Address Book data.
* exposes an unmodifiable `ObservableList<ReadOnlyPerson>` that can be 'observed' e.g. the UI can be bound to this list so that the UI automatically updates when the data in the list change.
* does not depend on any of the other three components.

=== Storage component

image::StorageClassDiagram.png[width=""800""]
_Figure 2.5.1 : Structure of the Storage Component_

*API* : link:{repoURL}/src/main/java/seedu/address/storage/Storage.java[`Storage.java`]

The `Storage` component,

* can save `UserPref` objects in json format and read it back.
* can save the Address Book data in xml format and read it back.

=== Common classes

Classes used by multiple components are in the `seedu.addressbook.commons` package.

== Implementation

This section describes some noteworthy details on how certain features are implemented.

// tag::undoredo[]
=== Undo/Redo mechanism

The undo/redo mechanism is facilitated by an `UndoRedoStack`, which resides inside `LogicManager`. It supports undoing and redoing of commands that modifies the state of the address book (e.g. `add`, `edit`). Such commands will inherit from `UndoableCommand`.

`UndoRedoStack` only deals with `UndoableCommands`. Commands that cannot be undone will inherit from `Command` instead. The following diagram shows the inheritance diagram for commands:

image::LogicCommandClassDiagram.png[width=""800""]

As you can see from the diagram, `UndoableCommand` adds an extra layer between the abstract `Command` class and concrete commands that can be undone, such as the `DeleteCommand`. Note that extra tasks need to be done when executing a command in an _undoable_ way, such as saving the state of the address book before execution. `UndoableCommand` contains the high-level algorithm for those extra tasks while the child classes implements the details of how to execute the specific command. Note that this technique of putting the high-level algorithm in the parent class and lower-level steps of the algorithm in child classes is also known as the https://www.tutorialspoint.com/design_pattern/template_pattern.htm[template pattern].

Commands that are not undoable are implemented this way:
[source,java]
----
public class ListCommand extends Command {
    @Override
    public CommandResult execute() {
        // ... list logic ...
    }
}
----

With the extra layer, the commands that are undoable are implemented this way:
[source,java]
----
public abstract class UndoableCommand extends Command {
    @Override
    public CommandResult execute() {
        // ... undo logic ...

        executeUndoableCommand();
    }
}

public class DeleteCommand extends UndoableCommand {
    @Override
    public CommandResult executeUndoableCommand() {
        // ... delete logic ...
    }
}
----

Suppose that the user has just launched the application. The `UndoRedoStack` will be empty at the beginning.

The user executes a new `UndoableCommand`, `delete 5`, to delete the 5th person in the address book. The current state of the address book is saved before the `delete 5` command executes. The `delete 5` command will then be pushed onto the `undoStack` (the current state is saved together with the command).

image::UndoRedoStartingStackDiagram.png[width=""800""]

As the user continues to use the program, more commands are added into the `undoStack`. For example, the user may execute `add n/David ...` to add a new person.

image::UndoRedoNewCommand1StackDiagram.png[width=""800""]

[NOTE]
If a command fails its execution, it will not be pushed to the `UndoRedoStack` at all.

The user now decides that adding the person was a mistake, and decides to undo that action using `undo`.

We will pop the most recent command out of the `undoStack` and push it back to the `redoStack`. We will restore the address book to the state before the `add` command executed.

image::UndoRedoExecuteUndoStackDiagram.png[width=""800""]

[NOTE]
If the `undoStack` is empty, then there are no other commands left to be undone, and an `Exception` will be thrown when popping the `undoStack`.

The following sequence diagram shows how the undo operation works:

image::UndoRedoSequenceDiagram.png[width=""800""]

The redo does the exact opposite (pops from `redoStack`, push to `undoStack`, and restores the address book to the state after the command is executed).

[NOTE]
If the `redoStack` is empty, then there are no other commands left to be redone, and an `Exception` will be thrown when popping the `redoStack`.

The user now decides to execute a new command, `clear`. As before, `clear` will be pushed into the `undoStack`. This time the `redoStack` is no longer empty. It will be purged as it no longer make sense to redo the `add n/David` command (this is the behavior that most modern desktop applications follow).

image::UndoRedoNewCommand2StackDiagram.png[width=""800""]

Commands that are not undoable are not added into the `undoStack`. For example, `list`, which inherits from `Command` rather than `UndoableCommand`, will not be added after execution:

image::UndoRedoNewCommand3StackDiagram.png[width=""800""]

The following activity diagram summarize what happens inside the `UndoRedoStack` when a user executes a new command:

image::UndoRedoActivityDiagram.png[width=""200""]

==== Design Considerations

**Aspect:** Implementation of `UndoableCommand` +
**Alternative 1 (current choice):** Add a new abstract method `executeUndoableCommand()` +
**Pros:** We will not lose any undone/redone functionality as it is now part of the default behaviour. Classes that deal with `Command` do not have to know that `executeUndoableCommand()` exist. +
**Cons:** Hard for new developers to understand the template pattern. +
**Alternative 2:** Just override `execute()` +
**Pros:** Does not involve the template pattern, easier for new developers to understand. +
**Cons:** Classes that inherit from `UndoableCommand` must remember to call `super.execute()`, or lose the ability to undo/redo.

---

**Aspect:** How undo & redo executes +
**Alternative 1 (current choice):** Saves the entire address book. +
**Pros:** Easy to implement. +
**Cons:** May have performance issues in terms of memory usage. +
**Alternative 2:** Individual command knows how to undo/redo by itself. +
**Pros:** Will use less memory (e.g. for `delete`, just save the person being deleted). +
**Cons:** We must ensure that the implementation of each individual command are correct.

---

**Aspect:** Type of commands that can be undone/redone +
**Alternative 1 (current choice):** Only include commands that modifies the address book (`add`, `clear`, `edit`). +
**Pros:** We only revert changes that are hard to change back (the view can easily be re-modified as no data are lost). +
**Cons:** User might think that undo also applies when the list is modified (undoing filtering for example), only to realize that it does not do that, after executing `undo`. +
**Alternative 2:** Include all commands. +
**Pros:** Might be more intuitive for the user. +
**Cons:** User have no way of skipping such commands if he or she just want to reset the state of the address book and not the view. +
**Additional Info:** See our discussion  https://github.com/se-edu/addressbook-level4/issues/390#issuecomment-298936672[here].

---

**Aspect:** Data structure to support the undo/redo commands +
**Alternative 1 (current choice):** Use separate stack for undo and redo +
**Pros:** Easy to understand for new Computer Science student undergraduates to understand, who are likely to be the new incoming developers of our project. +
**Cons:** Logic is duplicated twice. For example, when a new command is executed, we must remember to update both `HistoryManager` and `UndoRedoStack`. +
**Alternative 2:** Use `HistoryManager` for undo/redo +
**Pros:** We do not need to maintain a separate stack, and just reuse what is already in the codebase. +
**Cons:** Requires dealing with commands that have already been undone: We must remember to skip these commands. Violates Single Responsibility Principle and Separation of Concerns as `HistoryManager` now needs to do two different things. +
// end::undoredo[]

// tag::listalp[]
=== List Persons whose names start with certain alphabet

List alphabet function is designated for frequent users who have a large number of contacts saved in the addressbook and could not recall the full name of the person he wants to find.

List alphabet function is implemented in ListAlphabetCommand under logic component. When parsing the ListAlphaCommand in ListAlphaCommandParser, instead of passing the input argument to the ListAlphabetCommand, the parser invokes a method called NameStartsWithAlphabetPredicate.

NameStartsWithAlphabetPredicate is a class created under model component, which checks for any persons whose name starts with the character same as the input argument, and returns a predicate to be passed into ListAlphabetCommand.

ListAlphabetCommand reads the predicate and update filtered person list according to the predicate. After updating person list, Command result is returned with size of the updated filtered person list.

==== Design Consideration
**Aspect:** Way of comparing input argument and name +
**Alternative 1 (current choice):** Comparing the first character of input argument and first character of a person's full name. +
**Pros:** Easy to implement. +
**Cons:** Only the first input alphabet is effective, and unable to search for multiple alphabets. +
**Alternative 2:** Use regex to restrict input argument format, compare each single input character to get a full list of persons. +
**Pros:** Allows user to search for multiple alphabets at once. +
**Cons:** User might need to repeatedly type the same command if the input format is different from preset regex.
// end::listalp[]

=== Logging

We are using `java.util.logging` package for logging. The `LogsCenter` class is used to manage the logging levels and logging destinations.

* The logging level can be controlled using the `logLevel` setting in the configuration file (See link:#configuration[Configuration])
* The `Logger` for a class can be obtained using `LogsCenter.getLogger(Class)` which will log messages according to the specified logging level
* Currently log messages are output through: `Console` and to a `.log` file.

*Logging Levels*

* `SEVERE` : Critical problem detected which may possibly cause the termination of the application
* `WARNING` : Can continue, but with caution
* `INFO` : Information showing the noteworthy actions by the App
* `FINE` : Details that is not usually noteworthy but may be useful in debugging e.g. print the actual list instead of just its size

=== Configuration

Certain properties of the application can be controlled (e.g App name, logging level) through the configuration file (default: `config.json`).

=== Storage with back up

Upon the first-time run of this application, user is provided with a sample list of people, provided by link:{repoURL}/src/main/java/seedu/address/storage/model/util/SampleDataUtil.java[`SampleDataUtil.java`]. This is to give the user an idea of how the working application should look like.

If this is not a first-time run, under normal operation, addressbook.xml storage file in application directory/main/data is used to instantiate model for current session.

However if user's main storage file addressbook.xml is non-existant, of incorrect format or unreadable, we make a best effort retrieval of back up data in addressbook.xml-backup.xml.

Pseudo code for initiation of model:
[source,java]
----
private Model initModelManager(Storage storage, UserPrefs userPrefs) {
    ...
    try {
        read addressbook using storage
        if storage file is not present:
            initModelWithBackup
    } catch (addressbook has incorrect format) {
        initModelWithBackup
    } catch (unreadable addressbook) {
        initModelWithBackup
    }
    ...
}

private Model initModelWithBackup(Storage storage, UserPrefs userPrefs) {
    ...
    try {
        read backup addressbook using storage
        if backup storage file is present:
            retrieve back up addressbook
            save back up addressbook content to addressbook
        else:
            retrieve sample addressbook
    } catch (addressbook has incorrect format) {
        create empty addressbook
    } catch (unreadable addressbook) {
        create empty addressbook
    }
}
----

Back up file is kept up-to-date by updating itself when an AddressBookChangedEvent is raised.

=== Grouping

The grouping function is created to allow user to better organise his contacts.
This is achieved by introducing `UniqueGroupList` into the `addressbook`, which is a list of `Group` objects.

`Group` objects are extensions of `UniquePersonList`, and contain all information of `Person` objects seperately
from `UniquePersonList` in `addressbook` as a result of current implementation of `UniquePersonList`, which does
not return direct reference to `Person` objects of interest.

As `Person` in a `Group` and the corresponding `Person` in the `addressbook` are seperately kept, synchronization
is done to all operations that cause a change in existing `Person` to propagate the changes down to `Group`.

Code snippet demonstrating propagation of change using EditCommand as an example:
[source,java]
----
public CommandResult executeUndoableCommand() throws CommandException {
    ...
    try {
        model.updatePerson(personToEdit, editedPerson);
        model.propagateToGroup(personToEdit, editedPerson);
    } catch (DuplicatePersonException dpe) {
        throw new CommandException(MESSAGE_DUPLICATE_PERSON);
    } catch (PersonNotFoundException pnfe) {
        throw new AssertionError(""The target person cannot be missing"");
    }
    ....
}
----

=== Favorite

The Favorite function is created for frequent users who have have certain ""close contacts"" and
want the contacts on top of their list for the ease of access.
In order to implement such feature, two things need to be implemented:

* Favorite class +
* Sorting

==== Favorite class
A favorite class is implemented and used by Person class. A person object does not construct with a favorite object but it is
able to setFavorite a new favorite object.
A favorite object is different from other attribute object is that it just contains a simple boolean property.

To favorite a person in the list, a favorite command is implemented. The favorite command follows the same parser logic
as `delete` command, which is to parse the index of the person to favorite. Hence, the favoriteCommand also extends
UndoableCommand and overrides the methods in UndoableCommand.

Model and UI components also have to be updated. For model, a method toggle favorite is implemented to favorite or ""defavorite""
a person at specified index:

[source,java]
----
public void favorite(ReadOnlyPerson toFavorite)
    throws PersonNotFoundException {
        requireNonNull(toFavorite);
        int index = internalList.indexOf(toFavorite);

        if (index == -1) {
            throw new PersonNotFoundException();
        }

        Person newPerson = new Person(toFavorite);
        newPerson.setFavorite(new Favorite(!toFavorite.getFavorite().favorite));

        internalList.set(index, newPerson);
        sort();
}
----

And for UI, a simple label is created and `setVisible` to `true` for any index that is
favorited. The labels are `setGraphic` to followed image:

image::heart.png[width=""40""]

==== Sorting

A sorting algorithm needs to be implemented for the `UniquePersonList` of the `Model` Component.
Fortunately, it can be easily done with `List.sort()` and  `Java predicate`. The priority of sorting is such that
the persons favorited always appear on the top of the list, then all persons w/out favorited are
sorted by alphabetical order:

[source,java]
----
private void sort() {
        internalList.sort((ReadOnlyPerson p1, ReadOnlyPerson p2) -> {
            if (!p1.getFavorite().equals(p2.getFavorite())) {
                return p2.getFavorite().getValue() - p1.getFavorite().getValue();
            } else {
                return p1.getName().fullName.compareTo(p2.getName().fullName);
            }
        });
}
----

Finally, this method needs to be called whenever an event that causes changes to the model is called, eg
Edit a person, Add a person or Favorite a person.


==== Design Considerations

**Aspect:** Where sorting should occurs +
**Alternative 1 (current choice):** On the lowest layer of `Model`, which is `UniquePersonList` +
**Pros:** No need to have sorting in upper layer. +
**Cons:** Permanently mutate the data list. +
**Alternative 2:** Only sorting on the surface of `UI` component +
**Pros:** No mutation of data list. +
**Cons:** Difficult to implement system tests. +
// end::favorite[]


== Birthday Detail

A birthday detail is implemented under the Person class as Birthday. Users will add the birthday in along with the add command.

=== Description

Format: b/[dd/mm/yyyy]

=== Full solution

See this http://github.com/NgSuli/main[PR] for the full solution.


== Documentation

We use asciidoc for writing documentation.

[NOTE]
We chose asciidoc over Markdown because asciidoc, although a bit more complex than Markdown, provides more flexibility in formatting.

=== Editing Documentation

See <<UsingGradle#rendering-asciidoc-files, UsingGradle.adoc>> to learn how to render `.adoc` files locally to preview the end result of your edits.
Alternatively, you can download the AsciiDoc plugin for IntelliJ, which allows you to preview the changes you have made to your `.adoc` files in real-time.

=== Publishing Documentation

See <<UsingTravis#deploying-github-pages, UsingTravis.adoc>> to learn how to deploy GitHub Pages using Travis.

=== Converting Documentation to PDF format

We use https://www.google.com/chrome/browser/desktop/[Google Chrome] for converting documentation to PDF format, as Chrome's PDF engine preserves hyperlinks used in webpages.

Here are the steps to convert the project documentation files to PDF format.

.  Follow the instructions in <<UsingGradle#rendering-asciidoc-files, UsingGradle.adoc>> to convert the AsciiDoc files in the `docs/` directory to HTML format.
.  Go to your generated HTML files in the `build/docs` folder, right click on them and select `Open with` -> `Google Chrome`.
.  Within Chrome, click on the `Print` option in Chrome's menu.
.  Set the destination to `Save as PDF`, then click `Save` to save a copy of the file in PDF format. For best results, use the settings indicated in the screenshot below.

image::chrome_save_as_pdf.png[width=""300""]
_Figure 5.6.1 : Saving documentation as PDF files in Chrome_

== Testing

=== Running Tests

There are three ways to run tests.

[TIP]
The most reliable way to run tests is the 3rd one. The first two methods might fail some GUI tests due to platform/resolution-specific idiosyncrasies.

*Method 1: Using IntelliJ JUnit test runner*

* To run all tests, right-click on the `src/test/java` folder and choose `Run 'All Tests'`
* To run a subset of tests, you can right-click on a test package, test class, or a test and choose `Run 'ABC'`

*Method 2: Using Gradle*

* Open a console and run the command `gradlew clean allTests` (Mac/Linux: `./gradlew clean allTests`)

[NOTE]
See <<UsingGradle#, UsingGradle.adoc>> for more info on how to run tests using Gradle.

*Method 3: Using Gradle (headless)*

Thanks to the https://github.com/TestFX/TestFX[TestFX] library we use, our GUI tests can be run in the _headless_ mode. In the headless mode, GUI tests do not show up on the screen. That means the developer can do other things on the Computer while the tests are running.

To run tests in headless mode, open a console and run the command `gradlew clean headless allTests` (Mac/Linux: `./gradlew clean headless allTests`)

=== Types of tests

We have two types of tests:

.  *GUI Tests* - These are tests involving the GUI. They include,
.. _System Tests_ that test the entire App by simulating user actions on the GUI. These are in the `systemtests` package.
.. _Unit tests_ that test the individual components. These are in `seedu.address.ui` package.
.  *Non-GUI Tests* - These are tests not involving the GUI. They include,
..  _Unit tests_ targeting the lowest level methods/classes. +
e.g. `seedu.address.commons.StringUtilTest`
..  _Integration tests_ that are checking the integration of multiple code units (those code units are assumed to be working). +
e.g. `seedu.address.storage.StorageManagerTest`
..  Hybrids of unit and integration tests. These test are checking multiple code units as well as how the are connected together. +
e.g. `seedu.address.logic.LogicManagerTest`


=== Troubleshooting Testing
**Problem: `HelpWindowTest` fails with a `NullPointerException`.**

* Reason: One of its dependencies, `UserGuide.html` in `src/main/resources/docs` is missing.
* Solution: Execute Gradle task `processResources`.

== Dev Ops

=== Build Automation

See <<UsingGradle#, UsingGradle.adoc>> to learn how to use Gradle for build automation.

=== Continuous Integration

We use https://travis-ci.org/[Travis CI] and https://www.appveyor.com/[AppVeyor] to perform _Continuous Integration_ on our projects. See <<UsingTravis#, UsingTravis.adoc>> and <<UsingAppVeyor#, UsingAppVeyor.adoc>> for more details.

=== Making a Release

Here are the steps to create a new release.

.  Update the version number in link:{repoURL}/src/main/java/seedu/address/MainApp.java[`MainApp.java`].
.  Generate a JAR file <<UsingGradle#creating-the-jar-file, using Gradle>>.
.  Tag the repo with the version number. e.g. `v0.1`
.  https://help.github.com/articles/creating-releases/[Create a new release using GitHub] and upload the JAR file you created.

=== Managing Dependencies

A project often depends on third-party libraries. For example, Address Book depends on the http://wiki.fasterxml.com/JacksonHome[Jackson library] for XML parsing. Managing these _dependencies_ can be automated using Gradle. For example, Gradle can download the dependencies automatically, which is better than these alternatives. +
a. Include those libraries in the repo (this bloats the repo size) +
b. Require developers to download those libraries manually (this creates extra work for developers)

[appendix]
== Suggested Programming Tasks to Get Started

Suggested path for new programmers:

1. First, add small local-impact (i.e. the impact of the change does not go beyond the component) enhancements to one component at a time. Some suggestions are given in this section link:#improving-each-component[Improving a Component].

2. Next, add a feature that touches multiple components to learn how to implement an end-to-end feature across all components. The section link:#creating-a-new-command-code-remark-code[Creating a new command: `remark`] explains how to go about adding such a feature.

=== Improving each component

Each individual exercise in this section is component-based (i.e. you would not need to modify the other components to get it to work).

[discrete]
==== `Logic` component

[TIP]
Do take a look at the link:#logic-component[Design: Logic Component] section before attempting to modify the `Logic` component.

. Add a shorthand equivalent alias for each of the individual commands. For example, besides typing `clear`, the user can also type `c` to remove all persons in the list.
+
****
* Hints
** Just like we store each individual command word constant `COMMAND_WORD` inside `*Command.java` (e.g.  link:{repoURL}/src/main/java/seedu/address/logic/commands/FindCommand.java[`FindCommand#COMMAND_WORD`], link:{repoURL}/src/main/java/seedu/address/logic/commands/DeleteCommand.java[`DeleteCommand#COMMAND_WORD`]), you need a new constant for aliases as well (e.g. `FindCommand#COMMAND_ALIAS`).
** link:{repoURL}/src/main/java/seedu/address/logic/parser/AddressBookParser.java[`AddressBookParser`] is responsible for analyzing command words.
* Solution
** Modify the switch statement in link:{repoURL}/src/main/java/seedu/address/logic/parser/AddressBookParser.java[`AddressBookParser#parseCommand(String)`] such that both the proper command word and alias can be used to execute the same intended command.
** See this https://github.com/se-edu/addressbook-level4/pull/590/files[PR] for the full solution.
****

[discrete]
==== `Model` component

[TIP]
Do take a look at the link:#model-component[Design: Model Component] section before attempting to modify the `Model` component.

. Add a `removeTag(Tag)` method. The specified tag will be removed from everyone in the address book.
+
****
* Hints
** The link:{repoURL}/src/main/java/seedu/address/model/Model.java[`Model`] API needs to be updated.
**  Find out which of the existing API methods in  link:{repoURL}/src/main/java/seedu/address/model/AddressBook.java[`AddressBook`] and link:{repoURL}/src/main/java/seedu/address/model/person/Person.java[`Person`] classes can be used to implement the tag removal logic. link:{repoURL}/src/main/java/seedu/address/model/AddressBook.java[`AddressBook`] allows you to update a person, and link:{repoURL}/src/main/java/seedu/address/model/person/Person.java[`Person`] allows you to update the tags.
* Solution
** Add the implementation of `deleteTag(Tag)` method in link:{repoURL}/src/main/java/seedu/address/model/ModelManager.java[`ModelManager`]. Loop through each person, and remove the `tag` from each person.
** See this https://github.com/se-edu/addressbook-level4/pull/591/files[PR] for the full solution.
****

[discrete]
==== `Ui` component

[TIP]
Do take a look at the link:#ui-component[Design: UI Component] section before attempting to modify the `UI` component.

. Use different colors for different tags inside person cards. For example, `friends` tags can be all in grey, and `colleagues` tags can be all in red.
+
**Before**
+
image::getting-started-ui-tag-before.png[width=""300""]
+
**After**
+
image::getting-started-ui-tag-after.png[width=""300""]
+
****
* Hints
** The tag labels are created inside link:{repoURL}/src/main/java/seedu/address/ui/PersonCard.java[`PersonCard#initTags(ReadOnlyPerson)`] (`new Label(tag.tagName)`). https://docs.oracle.com/javase/8/javafx/api/javafx/scene/control/Label.html[JavaFX's `Label` class] allows you to modify the style of each Label, such as changing its color.
** Use the .css attribute `-fx-background-color` to add a color.
* Solution
** See this https://github.com/se-edu/addressbook-level4/pull/592/files[PR] for the full solution.
****

. Modify link:{repoURL}/src/main/java/seedu/address/commons/events/ui/NewResultAvailableEvent.java[`NewResultAvailableEvent`] such that link:{repoURL}/src/main/java/seedu/address/ui/ResultDisplay.java[`ResultDisplay`] can show a different style on error (currently it shows the same regardless of errors).
+
**Before**
+
image::getting-started-ui-result-before.png[width=""200""]
+
**After**
+
image::getting-started-ui-result-after.png[width=""200""]
+
****
* Hints
** link:{repoURL}/src/main/java/seedu/address/commons/events/ui/NewResultAvailableEvent.java[`NewResultAvailableEvent`] is raised by link:{repoURL}/src/main/java/seedu/address/ui/CommandBox.java[`CommandBox`] which also knows whether the result is a success or failure, and is caught by link:{repoURL}/src/main/java/seedu/address/ui/ResultDisplay.java[`ResultDisplay`] which is where we want to change the style to.
** Refer to link:{repoURL}/src/main/java/seedu/address/ui/CommandBox.java[`CommandBox`] for an example on how to display an error.
* Solution
** Modify link:{repoURL}/src/main/java/seedu/address/commons/events/ui/NewResultAvailableEvent.java[`NewResultAvailableEvent`] 's constructor so that users of the event can indicate whether an error has occurred.
** Modify link:{repoURL}/src/main/java/seedu/address/ui/ResultDisplay.java[`ResultDisplay#handleNewResultAvailableEvent(event)`] to react to this event appropriately.
** See this https://github.com/se-edu/addressbook-level4/pull/593/files[PR] for the full solution.
****

. Modify the link:{repoURL}/src/main/java/seedu/address/ui/StatusBarFooter.java[`StatusBarFooter`] to show the total number of people in the address book.
+
**Before**
+
image::getting-started-ui-status-before.png[width=""500""]
+
**After**
+
image::getting-started-ui-status-after.png[width=""500""]
+
****
* Hints
** link:{repoURL}/src/main/resources/view/StatusBarFooter.fxml[`StatusBarFooter.fxml`] will need a new `StatusBar`. Be sure to set the `GridPane.columnIndex` properly for each `StatusBar` to avoid misalignment!
** link:{repoURL}/src/main/java/seedu/address/ui/StatusBarFooter.java[`StatusBarFooter`] needs to initialize the status bar on application start, and to update it accordingly whenever the address book is updated.
* Solution
** Modify the constructor of link:{repoURL}/src/main/java/seedu/address/ui/StatusBarFooter.java[`StatusBarFooter`] to take in the number of persons when the application just started.
** Use link:{repoURL}/src/main/java/seedu/address/ui/StatusBarFooter.java[`StatusBarFooter#handleAddressBookChangedEvent(AddressBookChangedEvent)`] to update the number of persons whenever there are new changes to the addressbook.
** See this https://github.com/se-edu/addressbook-level4/pull/596/files[PR] for the full solution.
****

[discrete]
==== `Storage` component

[TIP]
Do take a look at the link:#storage-component[Design: Storage Component] section before attempting to modify the `Storage` component.

. Add a new method `backupAddressBook(ReadOnlyAddressBook)`, so that the address book can be saved in a fixed temporary location.
+
****
* Hint
** Add the API method in link:{repoURL}/src/main/java/seedu/address/storage/AddressBookStorage.java[`AddressBookStorage`] interface.
** Implement the logic in link:{repoURL}/src/main/java/seedu/address/storage/StorageManager.java[`StorageManager`] class.
* Solution
** See this https://github.com/se-edu/addressbook-level4/pull/594/files[PR] for the full solution.
****

=== Creating a new command: `remark`

By creating this command, you will get a chance to learn how to implement a feature end-to-end, touching all major components of the app.

==== Description
Edits the remark for a person specified in the `INDEX`. +
Format: `remark INDEX r/[REMARK]`

Examples:

* `remark 1 r/Likes to drink coffee.` +
Edits the remark for the first person to `Likes to drink coffee.`
* `remark 1 r/` +
Removes the remark for the first person.

==== Step-by-step Instructions

===== [Step 1] Logic: Teach the app to accept 'remark' which does nothing
Let's start by teaching the application how to parse a `remark` command. We will add the logic of `remark` later.

**Main:**

. Add a `RemarkCommand` that extends link:{repoURL}/src/main/java/seedu/address/logic/commands/UndoableCommand.java[`UndoableCommand`]. Upon execution, it should just throw an `Exception`.
. Modify link:{repoURL}/src/main/java/seedu/address/logic/parser/AddressBookParser.java[`AddressBookParser`] to accept a `RemarkCommand`.

**Tests:**

. Add `RemarkCommandTest` that tests that `executeUndoableCommand()` throws an Exception.
. Add new test method to link:{repoURL}/src/test/java/seedu/address/logic/parser/AddressBookParserTest.java[`AddressBookParserTest`], which tests that typing ""remark"" returns an instance of `RemarkCommand`.

===== [Step 2] Logic: Teach the app to accept 'remark' arguments
Let's teach the application to parse arguments that our `remark` command will accept. E.g. `1 r/Likes to drink coffee.`

**Main:**

. Modify `RemarkCommand` to take in an `Index` and `String` and print those two parameters as the error message.
. Add `RemarkCommandParser` that knows how to parse two arguments, one index and one with prefix 'r/'.
. Modify link:{repoURL}/src/main/java/seedu/address/logic/parser/AddressBookParser.java[`AddressBookParser`] to use the newly implemented `RemarkCommandParser`.

**Tests:**

. Modify `RemarkCommandTest` to test the `RemarkCommand#equals()` method.
. Add `RemarkCommandParserTest` that tests different boundary values
for `RemarkCommandParser`.
. Modify link:{repoURL}/src/test/java/seedu/address/logic/parser/AddressBookParserTest.java[`AddressBookParserTest`] to test that the correct command is generated according to the user input.

===== [Step 3] Ui: Add a placeholder for remark in `PersonCard`
Let's add a placeholder on all our link:{repoURL}/src/main/java/seedu/address/ui/PersonCard.java[`PersonCard`] s to display a remark for each person later.

**Main:**

. Add a `Label` with any random text inside link:{repoURL}/src/main/resources/view/PersonListCard.fxml[`PersonListCard.fxml`].
. Add FXML annotation in link:{repoURL}/src/main/java/seedu/address/ui/PersonCard.java[`PersonCard`] to tie the variable to the actual label.

**Tests:**

. Modify link:{repoURL}/src/test/java/guitests/guihandles/PersonCardHandle.java[`PersonCardHandle`] so that future tests can read the contents of the remark label.

===== [Step 4] Model: Add `Remark` class
We have to properly encapsulate the remark in our link:{repoURL}/src/main/java/seedu/address/model/person/ReadOnlyPerson.java[`ReadOnlyPerson`] class. Instead of just using a `String`, let's follow the conventional class structure that the codebase already uses by adding a `Remark` class.

**Main:**

. Add `Remark` to model component (you can copy from link:{repoURL}/src/main/java/seedu/address/model/person/Address.java[`Address`], remove the regex and change the names accordingly).
. Modify `RemarkCommand` to now take in a `Remark` instead of a `String`.

**Tests:**

. Add test for `Remark`, to test the `Remark#equals()` method.

===== [Step 5] Model: Modify `ReadOnlyPerson` to support a `Remark` field
Now we have the `Remark` class, we need to actually use it inside link:{repoURL}/src/main/java/seedu/address/model/person/ReadOnlyPerson.java[`ReadOnlyPerson`].

**Main:**

. Add three methods `setRemark(Remark)`, `getRemark()` and `remarkProperty()`. Be sure to implement these newly created methods in link:{repoURL}/src/main/java/seedu/address/model/person/ReadOnlyPerson.java[`Person`], which implements the link:{repoURL}/src/main/java/seedu/address/model/person/ReadOnlyPerson.java[`ReadOnlyPerson`] interface.
. You may assume that the user will not be able to use the `add` and `edit` commands to modify the remarks field (i.e. the person will be created without a remark).
. Modify link:{repoURL}/src/main/java/seedu/address/model/util/SampleDataUtil.java/[`SampleDataUtil`] to add remarks for the sample data (delete your `addressBook.xml` so that the application will load the sample data when you launch it.)

===== [Step 6] Storage: Add `Remark` field to `XmlAdaptedPerson` class
We now have `Remark` s for `Person` s, but they will be gone when we exit the application. Let's modify link:{repoURL}/src/main/java/seedu/address/storage/XmlAdaptedPerson.java[`XmlAdaptedPerson`] to include a `Remark` field so that it will be saved.

**Main:**

. Add a new Xml field for `Remark`.
. Be sure to modify the logic of the constructor and `toModelType()`, which handles the conversion to/from  link:{repoURL}/src/main/java/seedu/address/model/person/ReadOnlyPerson.java[`ReadOnlyPerson`].

**Tests:**

. Fix `validAddressBook.xml` such that the XML tests will not fail due to a missing `<remark>` element.

===== [Step 7] Ui: Connect `Remark` field to `PersonCard`
Our remark label in link:{repoURL}/src/main/java/seedu/address/ui/PersonCard.java[`PersonCard`] is still a placeholder. Let's bring it to life by binding it with the actual `remark` field.

**Main:**

. Modify link:{repoURL}/src/main/java/seedu/address/ui/PersonCard.java[`PersonCard#bindListeners()`] to add the binding for `remark`.

**Tests:**

. Modify link:{repoURL}/src/test/java/seedu/address/ui/testutil/GuiTestAssert.java[`GuiTestAssert#assertCardDisplaysPerson(...)`] so that it will compare the remark label.
. In link:{repoURL}/src/test/java/seedu/address/ui/PersonCardTest.java[`PersonCardTest`], call `personWithTags.setRemark(ALICE.getRemark())` to test that changes in the link:{repoURL}/src/main/java/seedu/address/model/person/ReadOnlyPerson.java[`Person`] 's remark correctly updates the corresponding link:{repoURL}/src/main/java/seedu/address/ui/PersonCard.java[`PersonCard`].

===== [Step 8] Logic: Implement `RemarkCommand#execute()` logic
We now have everything set up... but we still can't modify the remarks. Let's finish it up by adding in actual logic for our `remark` command.

**Main:**

. Replace the logic in `RemarkCommand#execute()` (that currently just throws an `Exception`), with the actual logic to modify the remarks of a person.

**Tests:**

. Update `RemarkCommandTest` to test that the `execute()` logic works.

==== Full Solution

See this https://github.com/se-edu/addressbook-level4/pull/599[PR] for the step-by-step solution.

[appendix]
== User Stories

Priorities: High (must have) - `* * \\*`, Medium (nice to have) - `* \\*`, Low (unlikely to have) - `*`

[width=""59%"",cols=""22%,<23%,<25%,<30%"",options=""header"",]
|=======================================================================
|Priority |As a ... |I want to ... |So that I can...
|`* * *` |new user |see usage instructions |refer to instructions when I forget how to use the App

|`* * *` |user |add a new person |

|`* * *` |user |delete a person |remove entries that I no longer need

|`* * *` |user |find a person by name |locate details of persons without having to go through the entire list

|`* *` |user |hide link:#private-contact-detail[private contact details] by default |minimize chance of someone else seeing them by accident

|`*` |user with many persons in the address book |sort persons by name |locate a person easily

|`* * *` |user |undo/redo changes up to a reasonable number of steps in one go |So that multiple mistakes can be rectified easily.

|`* * *` |new user |I can input the details of one contact in any order |so that I do not need memorize and follow the exact order

|`* * *` |user |I can choose to find a contact with any details recorded in the AddressBook |so there are more ways to utilize the address book.

|`* * *` |frequent user |I can sort people according to the frequency of interaction |so that I can find close friends easily

|`* *` |power user |I can add tags to multiple people at the same time |so that creating a new grouping is much less time consuming

|`*` |power user |I can customize abbreviation for people's names |so that searching for them is faster

|`*` |power user |I can change my addressbook theme/color scheme |so that I can enjoy using the address book more.

|`* *` |frequent user |I can 'favourite' a contact |so that these contacts will be on the top of my list on my UI

|`* *` |user |I can click on an email and it opens up an email box |so i can directly send an email directly to the person

|`* *` |user |I can choose to list contacts starting with a certain alphabet |
|=======================================================================

{More to be added}

[appendix]
== Use Cases

(For all use cases below, the *System* is the `AddressBook` and the *Actor* is the `user`, unless specified otherwise)

[discrete]
=== Use case: Delete person

*MSS*

1.  User requests to list persons
2.  AddressBook shows a list of persons
3.  User requests to delete a specific person in the list
4.  AddressBook deletes the person
+
Use case ends.

*Extensions*

[none]
* 2a. The list is empty.
+
Use case ends.

* 3a. The given index is invalid.
+
[none]
** 3a1. AddressBook shows an error message.
+
Use case resumes at step 2.


== Use case: Search history

*MSS*

1. User request to search history by keying in 'history'
2. Addressbook shows a list of commands used in the past.

[discrete]
=== Use case: Find person

*MSS*

1. User requests to find person by name, address, phone, email or tag
2. AddressBook searches for person with the specified name and displays to user


+
Use case ends.

*Extensions*

[none]

* 2a. The list is empty.
+
Use case ends.



* 1a. The input name format is invalid.
+
[none]
** 1a1. AddressBook shows an error message.
+
Use case ends.

* 2a. No person with the specified name found.
+
Use case ends.

* 2b. Multiple persons whose names contain the same keyword are found.
+
[none]
** 2b1. AddressBook displays an indexed list of all persons found with the keyword in their names.
+
Use case ends.

[discrete]
=== Use case: Add tag to an existing person

*MSS*

1. User request to find person
2. User request to add a tag to the specified person
3. AddressBook updates the tagList of the person
+
Use case ends.

*Extensions*

[none]
* 1a. Multiple persons are found.
+
[none]
** 1a1. AddressBook displays an indexed list of persons.
** 1a2. User specifies index.
** 1a3. AddressBook checks if the index is valid, if not AddressBook shows an error message and returns to step 1a2.
** Use case resumes from step 2.

* 2a. Format of tag provided by user is invalid.
+
[none]
** 2a1. AddressBook shows an error message.
** Use case resumes from step 2.

* 3a. The new tag is the same as an existing tag.
+
Use cse ends.



{More to be added}

[appendix]
== Non Functional Requirements

.  Should work on any link:#mainstream-os[mainstream OS] as long as it has Java `1.8.0_60` or higher installed.
.  Should be able to hold up to 1000 persons without a noticeable sluggishness in performance for typical usage.
.  A user with above average typing speed for regular English text (i.e. not code, not system admin commands) should be able to accomplish most of the tasks faster using commands than using the mouse.
.  The addressbook will only work with english text.

{More to be added}

[appendix]
== Glossary

[[mainstream-os]]
Mainstream OS

....
Windows, Linux, Unix, OS-X
....

[[private-contact-detail]]
Private contact detail

....
A contact detail that is not meant to be shared with others
....

[appendix]
== Product Survey

*Product Name*

Author: ...

Pros:

* ...
* ...

Cons:

* ...
* ...
",12254,False,1966.0659835025751,median
"// Automatically generated by 'openshift-apidocs-gen'. Do not edit.
:_content-type: ASSEMBLY
[id=""cronjob-batch-v1""]
= CronJob [batch/v1]
ifdef::product-title[]
include::modules/common-attributes.adoc[]
endif::[]

toc::[]


Description::
+
--
CronJob represents the configuration of a single cron job.
--

Type::
  `object`



== Specification

[cols=""1,1,1"",options=""header""]
|===
| Property | Type | Description

| `apiVersion`
| `string`
| APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources

| `kind`
| `string`
| Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds

| `metadata`
| xref:../objects/index.adoc#io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta[`ObjectMeta`]
| Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata

| `spec`
| `object`
| CronJobSpec describes how the job execution will look like and when it will actually run.

| `status`
| `object`
| CronJobStatus represents the current state of a cron job.

|===
=== .spec
Description::
+
--
CronJobSpec describes how the job execution will look like and when it will actually run.
--

Type::
  `object`

Required::
  - `schedule`
  - `jobTemplate`



[cols=""1,1,1"",options=""header""]
|===
| Property | Type | Description

| `concurrencyPolicy`
| `string`
| Specifies how to treat concurrent executions of a Job. Valid values are: - ""Allow"" (default): allows CronJobs to run concurrently; - ""Forbid"": forbids concurrent runs, skipping next run if previous run hasn't finished yet; - ""Replace"": cancels currently running job and replaces it with a new one

| `failedJobsHistoryLimit`
| `integer`
| The number of failed finished jobs to retain. Value must be non-negative integer. Defaults to 1.

| `jobTemplate`
| `object`
| JobTemplateSpec describes the data a Job should have when created from a template

| `schedule`
| `string`
| The schedule in Cron format, see https://en.wikipedia.org/wiki/Cron.

| `startingDeadlineSeconds`
| `integer`
| Optional deadline in seconds for starting the job if it misses scheduled time for any reason.  Missed jobs executions will be counted as failed ones.

| `successfulJobsHistoryLimit`
| `integer`
| The number of successful finished jobs to retain. Value must be non-negative integer. Defaults to 3.

| `suspend`
| `boolean`
| This flag tells the controller to suspend subsequent executions, it does not apply to already started executions.  Defaults to false.

|===
=== .spec.jobTemplate
Description::
+
--
JobTemplateSpec describes the data a Job should have when created from a template
--

Type::
  `object`




[cols=""1,1,1"",options=""header""]
|===
| Property | Type | Description

| `metadata`
| xref:../objects/index.adoc#io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta[`ObjectMeta`]
| Standard object's metadata of the jobs created from this template. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata

| `spec`
| `object`
| JobSpec describes how the job execution will look like.

|===
=== .spec.jobTemplate.spec
Description::
+
--
JobSpec describes how the job execution will look like.
--

Type::
  `object`

Required::
  - `template`



[cols=""1,1,1"",options=""header""]
|===
| Property | Type | Description

| `activeDeadlineSeconds`
| `integer`
| Specifies the duration in seconds relative to the startTime that the job may be continuously active before the system tries to terminate it; value must be positive integer. If a Job is suspended (at creation or through an update), this timer will effectively be stopped and reset when the Job is resumed again.

| `backoffLimit`
| `integer`
| Specifies the number of retries before marking this job failed. Defaults to 6

| `completionMode`
| `string`
| CompletionMode specifies how Pod completions are tracked. It can be `NonIndexed` (default) or `Indexed`.

`NonIndexed` means that the Job is considered complete when there have been .spec.completions successfully completed Pods. Each Pod completion is homologous to each other.

`Indexed` means that the Pods of a Job get an associated completion index from 0 to (.spec.completions - 1), available in the annotation batch.kubernetes.io/job-completion-index. The Job is considered complete when there is one successfully completed Pod for each index. When value is `Indexed`, .spec.completions must be specified and `.spec.parallelism` must be less than or equal to 10^5. In addition, The Pod name takes the form `$(job-name)-$(index)-$(random-string)`, the Pod hostname takes the form `$(job-name)-$(index)`.

This field is beta-level. More completion modes can be added in the future. If the Job controller observes a mode that it doesn't recognize, the controller skips updates for the Job.

| `completions`
| `integer`
| Specifies the desired number of successfully finished pods the job should be run with.  Setting to nil means that the success of any pod signals the success of all pods, and allows parallelism to have any positive value.  Setting to 1 means that parallelism is limited to 1 and the success of that pod signals the success of the job. More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/

| `manualSelector`
| `boolean`
| manualSelector controls generation of pod labels and pod selectors. Leave `manualSelector` unset unless you are certain what you are doing. When false or unset, the system pick labels unique to this job and appends those labels to the pod template.  When true, the user is responsible for picking unique labels and specifying the selector.  Failure to pick a unique label may cause this and other jobs to not function correctly.  However, You may see `manualSelector=true` in jobs that were created with the old `extensions/v1beta1` API. More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/#specifying-your-own-pod-selector

| `parallelism`
| `integer`
| Specifies the maximum desired number of pods the job should run at any given time. The actual number of pods running in steady state will be less than this number when ((.spec.completions - .status.successful) < .spec.parallelism), i.e. when the work left to do is less than max parallelism. More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/

| `selector`
| xref:../objects/index.adoc#io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector[`LabelSelector`]
| A label query over pods that should match the pod count. Normally, the system sets this field for you. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors

| `suspend`
| `boolean`
| Suspend specifies whether the Job controller should create Pods or not. If a Job is created with suspend set to true, no Pods are created by the Job controller. If a Job is suspended after creation (i.e. the flag goes from false to true), the Job controller will delete all active Pods associated with this Job. Users must design their workload to gracefully handle this. Suspending a Job will reset the StartTime field of the Job, effectively resetting the ActiveDeadlineSeconds timer too. Defaults to false.

This field is beta-level, gated by SuspendJob feature flag (enabled by default).

| `template`
| xref:../objects/index.adoc#io.k8s.api.core.v1.PodTemplateSpec[`PodTemplateSpec`]
| Describes the pod that will be created when executing a job. More info: https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/

| `ttlSecondsAfterFinished`
| `integer`
| ttlSecondsAfterFinished limits the lifetime of a Job that has finished execution (either Complete or Failed). If this field is set, ttlSecondsAfterFinished after the Job finishes, it is eligible to be automatically deleted. When the Job is being deleted, its lifecycle guarantees (e.g. finalizers) will be honored. If this field is unset, the Job won't be automatically deleted. If this field is set to zero, the Job becomes eligible to be deleted immediately after it finishes. This field is alpha-level and is only honored by servers that enable the TTLAfterFinished feature.

|===
=== .status
Description::
+
--
CronJobStatus represents the current state of a cron job.
--

Type::
  `object`




[cols=""1,1,1"",options=""header""]
|===
| Property | Type | Description

| `active`
| xref:../objects/index.adoc#io.k8s.api.core.v1.ObjectReference[`array (ObjectReference)`]
| A list of pointers to currently running jobs.

| `lastScheduleTime`
| xref:../objects/index.adoc#io.k8s.apimachinery.pkg.apis.meta.v1.Time[`Time`]
| Information when was the last time the job was successfully scheduled.

| `lastSuccessfulTime`
| xref:../objects/index.adoc#io.k8s.apimachinery.pkg.apis.meta.v1.Time[`Time`]
| Information when was the last time the job successfully completed.

|===

== API endpoints

The following API endpoints are available:

* `/apis/batch/v1/cronjobs`
- `GET`: list or watch objects of kind CronJob
* `/apis/batch/v1/watch/cronjobs`
- `GET`: watch individual changes to a list of CronJob. deprecated: use the &#x27;watch&#x27; parameter with a list operation instead.
* `/apis/batch/v1/namespaces/{namespace}/cronjobs`
- `DELETE`: delete collection of CronJob
- `GET`: list or watch objects of kind CronJob
- `POST`: create a CronJob
* `/apis/batch/v1/watch/namespaces/{namespace}/cronjobs`
- `GET`: watch individual changes to a list of CronJob. deprecated: use the &#x27;watch&#x27; parameter with a list operation instead.
* `/apis/batch/v1/namespaces/{namespace}/cronjobs/{name}`
- `DELETE`: delete a CronJob
- `GET`: read the specified CronJob
- `PATCH`: partially update the specified CronJob
- `PUT`: replace the specified CronJob
* `/apis/batch/v1/watch/namespaces/{namespace}/cronjobs/{name}`
- `GET`: watch changes to an object of kind CronJob. deprecated: use the &#x27;watch&#x27; parameter with a list operation instead, filtered to a single item with the &#x27;fieldSelector&#x27; parameter.
* `/apis/batch/v1/namespaces/{namespace}/cronjobs/{name}/status`
- `GET`: read status of the specified CronJob
- `PATCH`: partially update status of the specified CronJob
- `PUT`: replace status of the specified CronJob


=== /apis/batch/v1/cronjobs


.Global query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `allowWatchBookmarks`
| `boolean`
| allowWatchBookmarks requests watch events with type &quot;BOOKMARK&quot;. Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server&#x27;s discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.
| `continue`
| `string`
| The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the &quot;next key&quot;.

This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
| `fieldSelector`
| `string`
| A selector to restrict the list of returned objects by their fields. Defaults to everything.
| `labelSelector`
| `string`
| A selector to restrict the list of returned objects by their labels. Defaults to everything.
| `limit`
| `integer`
| limit is a maximum number of responses to return for a list call. If more items exist, the server will set the &#x60;continue&#x60; field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
| `pretty`
| `string`
| If &#x27;true&#x27;, then the output is pretty printed.
| `resourceVersion`
| `string`
| resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.

Defaults to unset
| `resourceVersionMatch`
| `string`
| resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.

Defaults to unset
| `timeoutSeconds`
| `integer`
| Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
| `watch`
| `boolean`
| Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

HTTP method::
  `GET`

Description::
  list or watch objects of kind CronJob


.HTTP responses
[cols=""1,1"",options=""header""]
|===
| HTTP code | Reponse body
| 200 - OK
| xref:../objects/index.adoc#io.k8s.api.batch.v1.CronJobList[`CronJobList`] schema
| 401 - Unauthorized
| Empty
|===


=== /apis/batch/v1/watch/cronjobs


.Global query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `allowWatchBookmarks`
| `boolean`
| allowWatchBookmarks requests watch events with type &quot;BOOKMARK&quot;. Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server&#x27;s discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.
| `continue`
| `string`
| The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the &quot;next key&quot;.

This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
| `fieldSelector`
| `string`
| A selector to restrict the list of returned objects by their fields. Defaults to everything.
| `labelSelector`
| `string`
| A selector to restrict the list of returned objects by their labels. Defaults to everything.
| `limit`
| `integer`
| limit is a maximum number of responses to return for a list call. If more items exist, the server will set the &#x60;continue&#x60; field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
| `pretty`
| `string`
| If &#x27;true&#x27;, then the output is pretty printed.
| `resourceVersion`
| `string`
| resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.

Defaults to unset
| `resourceVersionMatch`
| `string`
| resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.

Defaults to unset
| `timeoutSeconds`
| `integer`
| Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
| `watch`
| `boolean`
| Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

HTTP method::
  `GET`

Description::
  watch individual changes to a list of CronJob. deprecated: use the &#x27;watch&#x27; parameter with a list operation instead.


.HTTP responses
[cols=""1,1"",options=""header""]
|===
| HTTP code | Reponse body
| 200 - OK
| xref:../objects/index.adoc#io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent[`WatchEvent`] schema
| 401 - Unauthorized
| Empty
|===


=== /apis/batch/v1/namespaces/{namespace}/cronjobs

.Global path parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `namespace`
| `string`
| object name and auth scope, such as for teams and projects
|===

.Global query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `pretty`
| `string`
| If &#x27;true&#x27;, then the output is pretty printed.
|===

HTTP method::
  `DELETE`

Description::
  delete collection of CronJob


.Query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `continue`
| `string`
| The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the &quot;next key&quot;.

This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
| `dryRun`
| `string`
| When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
| `fieldSelector`
| `string`
| A selector to restrict the list of returned objects by their fields. Defaults to everything.
| `gracePeriodSeconds`
| `integer`
| The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.
| `labelSelector`
| `string`
| A selector to restrict the list of returned objects by their labels. Defaults to everything.
| `limit`
| `integer`
| limit is a maximum number of responses to return for a list call. If more items exist, the server will set the &#x60;continue&#x60; field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
| `orphanDependents`
| `boolean`
| Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the &quot;orphan&quot; finalizer will be added to/removed from the object&#x27;s finalizers list. Either this field or PropagationPolicy may be set, but not both.
| `propagationPolicy`
| `string`
| Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: &#x27;Orphan&#x27; - orphan the dependents; &#x27;Background&#x27; - allow the garbage collector to delete the dependents in the background; &#x27;Foreground&#x27; - a cascading policy that deletes all dependents in the foreground.
| `resourceVersion`
| `string`
| resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.

Defaults to unset
| `resourceVersionMatch`
| `string`
| resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.

Defaults to unset
| `timeoutSeconds`
| `integer`
| Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
|===

.Body parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `body`
| xref:../objects/index.adoc#io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions[`DeleteOptions`] schema
| 
|===

.HTTP responses
[cols=""1,1"",options=""header""]
|===
| HTTP code | Reponse body
| 200 - OK
| xref:../objects/index.adoc#io.k8s.apimachinery.pkg.apis.meta.v1.Status[`Status`] schema
| 401 - Unauthorized
| Empty
|===

HTTP method::
  `GET`

Description::
  list or watch objects of kind CronJob


.Query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `allowWatchBookmarks`
| `boolean`
| allowWatchBookmarks requests watch events with type &quot;BOOKMARK&quot;. Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server&#x27;s discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.
| `continue`
| `string`
| The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the &quot;next key&quot;.

This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
| `fieldSelector`
| `string`
| A selector to restrict the list of returned objects by their fields. Defaults to everything.
| `labelSelector`
| `string`
| A selector to restrict the list of returned objects by their labels. Defaults to everything.
| `limit`
| `integer`
| limit is a maximum number of responses to return for a list call. If more items exist, the server will set the &#x60;continue&#x60; field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
| `resourceVersion`
| `string`
| resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.

Defaults to unset
| `resourceVersionMatch`
| `string`
| resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.

Defaults to unset
| `timeoutSeconds`
| `integer`
| Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
| `watch`
| `boolean`
| Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===


.HTTP responses
[cols=""1,1"",options=""header""]
|===
| HTTP code | Reponse body
| 200 - OK
| xref:../objects/index.adoc#io.k8s.api.batch.v1.CronJobList[`CronJobList`] schema
| 401 - Unauthorized
| Empty
|===

HTTP method::
  `POST`

Description::
  create a CronJob


.Query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `dryRun`
| `string`
| When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
| `fieldManager`
| `string`
| fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
|===

.Body parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `body`
| xref:../workloads_apis/cronjob-batch-v1.adoc#cronjob-batch-v1[`CronJob`] schema
| 
|===

.HTTP responses
[cols=""1,1"",options=""header""]
|===
| HTTP code | Reponse body
| 200 - OK
| xref:../workloads_apis/cronjob-batch-v1.adoc#cronjob-batch-v1[`CronJob`] schema
| 201 - Created
| xref:../workloads_apis/cronjob-batch-v1.adoc#cronjob-batch-v1[`CronJob`] schema
| 202 - Accepted
| xref:../workloads_apis/cronjob-batch-v1.adoc#cronjob-batch-v1[`CronJob`] schema
| 401 - Unauthorized
| Empty
|===


=== /apis/batch/v1/watch/namespaces/{namespace}/cronjobs

.Global path parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `namespace`
| `string`
| object name and auth scope, such as for teams and projects
|===

.Global query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `allowWatchBookmarks`
| `boolean`
| allowWatchBookmarks requests watch events with type &quot;BOOKMARK&quot;. Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server&#x27;s discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.
| `continue`
| `string`
| The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the &quot;next key&quot;.

This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
| `fieldSelector`
| `string`
| A selector to restrict the list of returned objects by their fields. Defaults to everything.
| `labelSelector`
| `string`
| A selector to restrict the list of returned objects by their labels. Defaults to everything.
| `limit`
| `integer`
| limit is a maximum number of responses to return for a list call. If more items exist, the server will set the &#x60;continue&#x60; field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
| `pretty`
| `string`
| If &#x27;true&#x27;, then the output is pretty printed.
| `resourceVersion`
| `string`
| resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.

Defaults to unset
| `resourceVersionMatch`
| `string`
| resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.

Defaults to unset
| `timeoutSeconds`
| `integer`
| Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
| `watch`
| `boolean`
| Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

HTTP method::
  `GET`

Description::
  watch individual changes to a list of CronJob. deprecated: use the &#x27;watch&#x27; parameter with a list operation instead.


.HTTP responses
[cols=""1,1"",options=""header""]
|===
| HTTP code | Reponse body
| 200 - OK
| xref:../objects/index.adoc#io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent[`WatchEvent`] schema
| 401 - Unauthorized
| Empty
|===


=== /apis/batch/v1/namespaces/{namespace}/cronjobs/{name}

.Global path parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `name`
| `string`
| name of the CronJob
| `namespace`
| `string`
| object name and auth scope, such as for teams and projects
|===

.Global query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `pretty`
| `string`
| If &#x27;true&#x27;, then the output is pretty printed.
|===

HTTP method::
  `DELETE`

Description::
  delete a CronJob


.Query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `dryRun`
| `string`
| When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
| `gracePeriodSeconds`
| `integer`
| The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.
| `orphanDependents`
| `boolean`
| Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the &quot;orphan&quot; finalizer will be added to/removed from the object&#x27;s finalizers list. Either this field or PropagationPolicy may be set, but not both.
| `propagationPolicy`
| `string`
| Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: &#x27;Orphan&#x27; - orphan the dependents; &#x27;Background&#x27; - allow the garbage collector to delete the dependents in the background; &#x27;Foreground&#x27; - a cascading policy that deletes all dependents in the foreground.
|===

.Body parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `body`
| xref:../objects/index.adoc#io.k8s.apimachinery.pkg.apis.meta.v1.DeleteOptions[`DeleteOptions`] schema
| 
|===

.HTTP responses
[cols=""1,1"",options=""header""]
|===
| HTTP code | Reponse body
| 200 - OK
| xref:../objects/index.adoc#io.k8s.apimachinery.pkg.apis.meta.v1.Status[`Status`] schema
| 202 - Accepted
| xref:../objects/index.adoc#io.k8s.apimachinery.pkg.apis.meta.v1.Status[`Status`] schema
| 401 - Unauthorized
| Empty
|===

HTTP method::
  `GET`

Description::
  read the specified CronJob


.HTTP responses
[cols=""1,1"",options=""header""]
|===
| HTTP code | Reponse body
| 200 - OK
| xref:../workloads_apis/cronjob-batch-v1.adoc#cronjob-batch-v1[`CronJob`] schema
| 401 - Unauthorized
| Empty
|===

HTTP method::
  `PATCH`

Description::
  partially update the specified CronJob


.Query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `dryRun`
| `string`
| When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
| `fieldManager`
| `string`
| fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).
| `force`
| `boolean`
| Force is going to &quot;force&quot; Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.
|===

.Body parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `body`
| xref:../objects/index.adoc#io.k8s.apimachinery.pkg.apis.meta.v1.Patch[`Patch`] schema
| 
|===

.HTTP responses
[cols=""1,1"",options=""header""]
|===
| HTTP code | Reponse body
| 200 - OK
| xref:../workloads_apis/cronjob-batch-v1.adoc#cronjob-batch-v1[`CronJob`] schema
| 201 - Created
| xref:../workloads_apis/cronjob-batch-v1.adoc#cronjob-batch-v1[`CronJob`] schema
| 401 - Unauthorized
| Empty
|===

HTTP method::
  `PUT`

Description::
  replace the specified CronJob


.Query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `dryRun`
| `string`
| When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
| `fieldManager`
| `string`
| fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
|===

.Body parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `body`
| xref:../workloads_apis/cronjob-batch-v1.adoc#cronjob-batch-v1[`CronJob`] schema
| 
|===

.HTTP responses
[cols=""1,1"",options=""header""]
|===
| HTTP code | Reponse body
| 200 - OK
| xref:../workloads_apis/cronjob-batch-v1.adoc#cronjob-batch-v1[`CronJob`] schema
| 201 - Created
| xref:../workloads_apis/cronjob-batch-v1.adoc#cronjob-batch-v1[`CronJob`] schema
| 401 - Unauthorized
| Empty
|===


=== /apis/batch/v1/watch/namespaces/{namespace}/cronjobs/{name}

.Global path parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `name`
| `string`
| name of the CronJob
| `namespace`
| `string`
| object name and auth scope, such as for teams and projects
|===

.Global query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `allowWatchBookmarks`
| `boolean`
| allowWatchBookmarks requests watch events with type &quot;BOOKMARK&quot;. Servers that do not implement bookmarks may ignore this flag and bookmarks are sent at the server&#x27;s discretion. Clients should not assume bookmarks are returned at any specific interval, nor may they assume the server will send any BOOKMARK event during a session. If this is not a watch, this field is ignored.
| `continue`
| `string`
| The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server, the server will respond with a 410 ResourceExpired error together with a continue token. If the client needs a consistent list, it must restart their list without the continue field. Otherwise, the client may send another list request with the token received with the 410 error, the server will respond with a list starting from the next key, but from the latest snapshot, which is inconsistent from the previous list results - objects that are created, modified, or deleted after the first list request will be included in the response, as long as their keys are after the &quot;next key&quot;.

This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
| `fieldSelector`
| `string`
| A selector to restrict the list of returned objects by their fields. Defaults to everything.
| `labelSelector`
| `string`
| A selector to restrict the list of returned objects by their labels. Defaults to everything.
| `limit`
| `integer`
| limit is a maximum number of responses to return for a list call. If more items exist, the server will set the &#x60;continue&#x60; field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
| `pretty`
| `string`
| If &#x27;true&#x27;, then the output is pretty printed.
| `resourceVersion`
| `string`
| resourceVersion sets a constraint on what resource versions a request may be served from. See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.

Defaults to unset
| `resourceVersionMatch`
| `string`
| resourceVersionMatch determines how resourceVersion is applied to list calls. It is highly recommended that resourceVersionMatch be set for list calls where resourceVersion is set See https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-versions for details.

Defaults to unset
| `timeoutSeconds`
| `integer`
| Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
| `watch`
| `boolean`
| Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

HTTP method::
  `GET`

Description::
  watch changes to an object of kind CronJob. deprecated: use the &#x27;watch&#x27; parameter with a list operation instead, filtered to a single item with the &#x27;fieldSelector&#x27; parameter.


.HTTP responses
[cols=""1,1"",options=""header""]
|===
| HTTP code | Reponse body
| 200 - OK
| xref:../objects/index.adoc#io.k8s.apimachinery.pkg.apis.meta.v1.WatchEvent[`WatchEvent`] schema
| 401 - Unauthorized
| Empty
|===


=== /apis/batch/v1/namespaces/{namespace}/cronjobs/{name}/status

.Global path parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `name`
| `string`
| name of the CronJob
| `namespace`
| `string`
| object name and auth scope, such as for teams and projects
|===

.Global query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `pretty`
| `string`
| If &#x27;true&#x27;, then the output is pretty printed.
|===

HTTP method::
  `GET`

Description::
  read status of the specified CronJob


.HTTP responses
[cols=""1,1"",options=""header""]
|===
| HTTP code | Reponse body
| 200 - OK
| xref:../workloads_apis/cronjob-batch-v1.adoc#cronjob-batch-v1[`CronJob`] schema
| 401 - Unauthorized
| Empty
|===

HTTP method::
  `PATCH`

Description::
  partially update status of the specified CronJob


.Query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `dryRun`
| `string`
| When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
| `fieldManager`
| `string`
| fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. This field is required for apply requests (application/apply-patch) but optional for non-apply patch types (JsonPatch, MergePatch, StrategicMergePatch).
| `force`
| `boolean`
| Force is going to &quot;force&quot; Apply requests. It means user will re-acquire conflicting fields owned by other people. Force flag must be unset for non-apply patch requests.
|===

.Body parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `body`
| xref:../objects/index.adoc#io.k8s.apimachinery.pkg.apis.meta.v1.Patch[`Patch`] schema
| 
|===

.HTTP responses
[cols=""1,1"",options=""header""]
|===
| HTTP code | Reponse body
| 200 - OK
| xref:../workloads_apis/cronjob-batch-v1.adoc#cronjob-batch-v1[`CronJob`] schema
| 201 - Created
| xref:../workloads_apis/cronjob-batch-v1.adoc#cronjob-batch-v1[`CronJob`] schema
| 401 - Unauthorized
| Empty
|===

HTTP method::
  `PUT`

Description::
  replace status of the specified CronJob


.Query parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `dryRun`
| `string`
| When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed
| `fieldManager`
| `string`
| fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint.
|===

.Body parameters
[cols=""1,1,2"",options=""header""]
|===
| Parameter | Type | Description
| `body`
| xref:../workloads_apis/cronjob-batch-v1.adoc#cronjob-batch-v1[`CronJob`] schema
| 
|===

.HTTP responses
[cols=""1,1"",options=""header""]
|===
| HTTP code | Reponse body
| 200 - OK
| xref:../workloads_apis/cronjob-batch-v1.adoc#cronjob-batch-v1[`CronJob`] schema
| 201 - Created
| xref:../workloads_apis/cronjob-batch-v1.adoc#cronjob-batch-v1[`CronJob`] schema
| 401 - Unauthorized
| Empty
|===


",12224,True,3015.4151937127262,median
"// Copyright (c) 2010 Satoshi Nakamoto
// Copyright (c) 2009-2017 The Bitcoin Core developers 
// Copyright (c) 2015-2017 The Dash developers 
// Copyright (c) 2015-2017 The Urals developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include ""amount.h""
#include ""chain.h""
#include ""chainparams.h""
#include ""checkpoints.h""
#include ""coins.h""
#include ""consensus/validation.h""
#include ""validation.h""
#include ""policy/policy.h""
#include ""primitives/transaction.h""
#include ""rpc/server.h""
#include ""streams.h""
#include ""sync.h""
#include ""txmempool.h""
#include ""util.h""
#include ""utilstrencodings.h""
#include ""hash.h""

#include <stdint.h>

#include <univalue.h>

#include <boost/thread/thread.hpp> // boost::thread::interrupt

//#include <mutex>
//#include <condition_variable>
using namespace std;

struct CUpdatedBlock
{
    uint256 hash;
    int height;
};

static boost::mutex cs_blockchange;
static boost::condition_variable cond_blockchange;
static CUpdatedBlock latestblock;

extern void TxToJSON(const CTransaction& tx, const uint256 hashBlock, UniValue& entry);
void ScriptPubKeyToJSON(const CScript& scriptPubKey, UniValue& out, bool fIncludeHex);

double GetDifficulty(const CBlockIndex* blockindex)
{
    // Floating point number that is a multiple of the minimum difficulty,
    // minimum difficulty = 1.0.
    if (blockindex == NULL)
    {
        if (chainActive.Tip() == NULL)
            return 1.0;
        else
            blockindex = chainActive.Tip();
    }

    int nShift = (blockindex->nBits >> 24) & 0xff;

    double dDiff =
        (double)0x0000ffff / (double)(blockindex->nBits & 0x00ffffff);

    while (nShift < 29)
    {
        dDiff *= 256.0;
        nShift++;
    }
    while (nShift > 29)
    {
        dDiff /= 256.0;
        nShift--;
    }

    return dDiff;
}

UniValue blockheaderToJSON(const CBlockIndex* blockindex)
{
    UniValue result(UniValue::VOBJ);
    result.push_back(Pair(""hash"", blockindex->GetBlockHash().GetHex()));
    int confirmations = -1;
    // Only report confirmations if the block is on the main chain
    if (chainActive.Contains(blockindex))
        confirmations = chainActive.Height() - blockindex->nHeight + 1;
    result.push_back(Pair(""confirmations"", confirmations));
    result.push_back(Pair(""height"", blockindex->nHeight));
    result.push_back(Pair(""version"", blockindex->nVersion));
    result.push_back(Pair(""versionHex"", strprintf(""%08x"", blockindex->nVersion)));
    result.push_back(Pair(""merkleroot"", blockindex->hashMerkleRoot.GetHex()));
    result.push_back(Pair(""time"", (int64_t)blockindex->nTime));
    result.push_back(Pair(""mediantime"", (int64_t)blockindex->GetMedianTimePast()));
    result.push_back(Pair(""nonce"", (uint64_t)blockindex->nNonce));
    result.push_back(Pair(""bits"", strprintf(""%08x"", blockindex->nBits)));
    result.push_back(Pair(""difficulty"", GetDifficulty(blockindex)));
    result.push_back(Pair(""chainwork"", blockindex->nChainWork.GetHex()));

    if (blockindex->pprev)
        result.push_back(Pair(""previousblockhash"", blockindex->pprev->GetBlockHash().GetHex()));
    CBlockIndex *pnext = chainActive.Next(blockindex);
    if (pnext)
        result.push_back(Pair(""nextblockhash"", pnext->GetBlockHash().GetHex()));
    return result;
}

UniValue blockToJSON(const CBlock& block, const CBlockIndex* blockindex, bool txDetails = false)
{
    UniValue result(UniValue::VOBJ);
    result.push_back(Pair(""hash"", blockindex->GetBlockHash().GetHex()));
    int confirmations = -1;
    // Only report confirmations if the block is on the main chain
    if (chainActive.Contains(blockindex))
        confirmations = chainActive.Height() - blockindex->nHeight + 1;
    result.push_back(Pair(""confirmations"", confirmations));
    result.push_back(Pair(""strippedsize"", (int)::GetSerializeSize(block, SER_NETWORK, PROTOCOL_VERSION | SERIALIZE_TRANSACTION_NO_WITNESS)));
    result.push_back(Pair(""size"", (int)::GetSerializeSize(block, SER_NETWORK, PROTOCOL_VERSION)));
    result.push_back(Pair(""weight"", (int)::GetBlockWeight(block)));
    result.push_back(Pair(""height"", blockindex->nHeight));
    result.push_back(Pair(""version"", block.nVersion));
    result.push_back(Pair(""versionHex"", strprintf(""%08x"", block.nVersion)));
    result.push_back(Pair(""merkleroot"", block.hashMerkleRoot.GetHex()));
    UniValue txs(UniValue::VARR);
    for(const auto& tx : block.vtx)
    {
        if(txDetails)
        {
            UniValue objTx(UniValue::VOBJ);
            TxToJSON(*tx, uint256(), objTx);
            txs.push_back(objTx);
        }
        else
            txs.push_back(tx->GetHash().GetHex());
    }
    result.push_back(Pair(""tx"", txs));
    result.push_back(Pair(""time"", block.GetBlockTime()));
    result.push_back(Pair(""mediantime"", (int64_t)blockindex->GetMedianTimePast()));
    result.push_back(Pair(""nonce"", (uint64_t)block.nNonce));
    result.push_back(Pair(""bits"", strprintf(""%08x"", block.nBits)));
    result.push_back(Pair(""difficulty"", GetDifficulty(blockindex)));
    result.push_back(Pair(""chainwork"", blockindex->nChainWork.GetHex()));

    if (blockindex->pprev)
        result.push_back(Pair(""previousblockhash"", blockindex->pprev->GetBlockHash().GetHex()));
    CBlockIndex *pnext = chainActive.Next(blockindex);
    if (pnext)
        result.push_back(Pair(""nextblockhash"", pnext->GetBlockHash().GetHex()));
    return result;
}

UniValue getblockcount(const JSONRPCRequest& request)
{
    if (request.fHelp || request.params.size() != 0)
        throw runtime_error(
            ""getblockcount\\n""
            ""\\nReturns the number of blocks in the longest blockchain.\\n""
            ""\\nResult:\\n""
            ""n    (numeric) The current block count\\n""
            ""\\nExamples:\\n""
            + HelpExampleCli(""getblockcount"", """")
            + HelpExampleRpc(""getblockcount"", """")
        );

    LOCK(cs_main);
    return chainActive.Height();
}

UniValue getbestblockhash(const JSONRPCRequest& request)
{
    if (request.fHelp || request.params.size() != 0)
        throw runtime_error(
            ""getbestblockhash\\n""
            ""\\nReturns the hash of the best (tip) block in the longest blockchain.\\n""
            ""\\nResult:\\n""
            ""\\""hex\\""      (string) the block hash hex encoded\\n""
            ""\\nExamples:\\n""
            + HelpExampleCli(""getbestblockhash"", """")
            + HelpExampleRpc(""getbestblockhash"", """")
        );

    LOCK(cs_main);
    return chainActive.Tip()->GetBlockHash().GetHex();
}

void RPCNotifyBlockChange(bool ibd, const CBlockIndex * pindex)
{
    if(pindex) {
        boost::lock_guard<boost::mutex> lock(cs_blockchange);
        latestblock.hash = pindex->GetBlockHash();
        latestblock.height = pindex->nHeight;
    }
	cond_blockchange.notify_all();
}

UniValue waitfornewblock(const JSONRPCRequest& request)
{
    if (request.fHelp || request.params.size() > 1)
        throw runtime_error(
            ""waitfornewblock (timeout)\\n""
            ""\\nWaits for a specific new block and returns useful info about it.\\n""
            ""\\nReturns the current block on timeout or exit.\\n""
            ""\\nArguments:\\n""
            ""1. timeout (int, optional, default=0) Time in milliseconds to wait for a response. 0 indicates no timeout.\\n""
            ""\\nResult:\\n""
            ""{                           (json object)\\n""
            ""  \\""hash\\"" : {       (string) The blockhash\\n""
            ""  \\""height\\"" : {     (int) Block height\\n""
            ""}\\n""
            ""\\nExamples:\\n""
            + HelpExampleCli(""waitfornewblock"", ""1000"")
            + HelpExampleRpc(""waitfornewblock"", ""1000"")
        );
    int timeout = 0;
    if (request.params.size() > 0)
        timeout = request.params[0].get_int();

    CUpdatedBlock block;
    {
        boost::unique_lock<boost::mutex> lock(cs_blockchange);
        block = latestblock;
        if(timeout)
            cond_blockchange.wait_for(lock, boost::chrono::milliseconds(timeout), [&block]{return latestblock.height != block.height || latestblock.hash != block.hash || !IsRPCRunning(); });
        else
            cond_blockchange.wait(lock, [&block]{return latestblock.height != block.height || latestblock.hash != block.hash || !IsRPCRunning(); });
        block = latestblock;
    }
    UniValue ret(UniValue::VOBJ);
    ret.push_back(Pair(""hash"", block.hash.GetHex()));
    ret.push_back(Pair(""height"", block.height));
    return ret;
}

UniValue waitforblock(const JSONRPCRequest& request)
{
    if (request.fHelp || request.params.size() < 1 || request.params.size() > 2)
        throw runtime_error(
            ""waitforblock <blockhash> (timeout)\\n""
            ""\\nWaits for a specific new block and returns useful info about it.\\n""
            ""\\nReturns the current block on timeout or exit.\\n""
            ""\\nArguments:\\n""
            ""1. \\""blockhash\\"" (required, string) Block hash to wait for.\\n""
            ""2. timeout       (int, optional, default=0) Time in milliseconds to wait for a response. 0 indicates no timeout.\\n""
            ""\\nResult:\\n""
            ""{                           (json object)\\n""
            ""  \\""hash\\"" : {       (string) The blockhash\\n""
            ""  \\""height\\"" : {     (int) Block height\\n""
            ""}\\n""
            ""\\nExamples:\\n""
            + HelpExampleCli(""waitforblock"", ""\\""0000000000079f8ef3d2c688c244eb7a4570b24c9ed7b4a8c619eb02596f8862\\"", 1000"")
            + HelpExampleRpc(""waitforblock"", ""\\""0000000000079f8ef3d2c688c244eb7a4570b24c9ed7b4a8c619eb02596f8862\\"", 1000"")
        );
    int timeout = 0;

    uint256 hash = uint256S(request.params[0].get_str());

    if (request.params.size() > 1)
        timeout = request.params[1].get_int();

    CUpdatedBlock block;
    {
        boost::unique_lock<boost::mutex> lock(cs_blockchange);
        if(timeout)
            cond_blockchange.wait_for(lock, boost::chrono::milliseconds(timeout), [&hash]{return latestblock.hash == hash || !IsRPCRunning();});
        else
            cond_blockchange.wait(lock, [&hash]{return latestblock.hash == hash || !IsRPCRunning(); });
        block = latestblock;
    }

    UniValue ret(UniValue::VOBJ);
    ret.push_back(Pair(""hash"", block.hash.GetHex()));
    ret.push_back(Pair(""height"", block.height));
    return ret;
}

UniValue waitforblockheight(const JSONRPCRequest& request)
{
    if (request.fHelp || request.params.size() < 1 || request.params.size() > 2)
        throw runtime_error(
            ""waitforblockheight <height> (timeout)\\n""
            ""\\nWaits for (at least) block height and returns the height and hash\\n""
            ""of the current tip.\\n""
            ""\\nReturns the current block on timeout or exit.\\n""
            ""\\nArguments:\\n""
            ""1. height  (required, int) Block height to wait for (int)\\n""
            ""2. timeout (int, optional, default=0) Time in milliseconds to wait for a response. 0 indicates no timeout.\\n""
            ""\\nResult:\\n""
            ""{                           (json object)\\n""
            ""  \\""hash\\"" : {       (string) The blockhash\\n""
            ""  \\""height\\"" : {     (int) Block height\\n""
            ""}\\n""
            ""\\nExamples:\\n""
            + HelpExampleCli(""waitforblockheight"", ""\\""100\\"", 1000"")
            + HelpExampleRpc(""waitforblockheight"", ""\\""100\\"", 1000"")
        );
    int timeout = 0;

    int height = request.params[0].get_int();

    if (request.params.size() > 1)
        timeout = request.params[1].get_int();

    CUpdatedBlock block;
    {
        boost::unique_lock<boost::mutex> lock(cs_blockchange);
        if(timeout)
            cond_blockchange.wait_for(lock, boost::chrono::milliseconds(timeout), [&height]{return latestblock.height >= height || !IsRPCRunning();});
        else
            cond_blockchange.wait(lock, [&height]{return latestblock.height >= height || !IsRPCRunning(); });
        block = latestblock;
    }
    UniValue ret(UniValue::VOBJ);
    ret.push_back(Pair(""hash"", block.hash.GetHex()));
    ret.push_back(Pair(""height"", block.height));
    return ret;
}

UniValue getdifficulty(const JSONRPCRequest& request)
{
    if (request.fHelp || request.params.size() != 0)
        throw runtime_error(
            ""getdifficulty\\n""
            ""\\nReturns the proof-of-work difficulty as a multiple of the minimum difficulty.\\n""
            ""\\nResult:\\n""
            ""n.nnn       (numeric) the proof-of-work difficulty as a multiple of the minimum difficulty.\\n""
            ""\\nExamples:\\n""
            + HelpExampleCli(""getdifficulty"", """")
            + HelpExampleRpc(""getdifficulty"", """")
        );

    LOCK(cs_main);
    return GetDifficulty();
}

std::string EntryDescriptionString()
{
    return ""    \\""size\\"" : n,             (numeric) virtual transaction size as defined in BIP 141. This is different from actual serialized size for witness transactions as witness data is discounted.\\n""
           ""    \\""fee\\"" : n,              (numeric) transaction fee in "" + CURRENCY_UNIT + ""\\n""
           ""    \\""modifiedfee\\"" : n,      (numeric) transaction fee with fee deltas used for mining priority\\n""
           ""    \\""time\\"" : n,             (numeric) local time transaction entered pool in seconds since 1 Jan 1970 GMT\\n""
           ""    \\""height\\"" : n,           (numeric) block height when transaction entered pool\\n""
           ""    \\""startingpriority\\"" : n, (numeric) DEPRECATED. Priority when transaction entered pool\\n""
           ""    \\""currentpriority\\"" : n,  (numeric) DEPRECATED. Transaction priority now\\n""
           ""    \\""descendantcount\\"" : n,  (numeric) number of in-mempool descendant transactions (including this one)\\n""
           ""    \\""descendantsize\\"" : n,   (numeric) virtual transaction size of in-mempool descendants (including this one)\\n""
           ""    \\""descendantfees\\"" : n,   (numeric) modified fees (see above) of in-mempool descendants (including this one)\\n""
           ""    \\""ancestorcount\\"" : n,    (numeric) number of in-mempool ancestor transactions (including this one)\\n""
           ""    \\""ancestorsize\\"" : n,     (numeric) virtual transaction size of in-mempool ancestors (including this one)\\n""
           ""    \\""ancestorfees\\"" : n,     (numeric) modified fees (see above) of in-mempool ancestors (including this one)\\n""
           ""    \\""depends\\"" : [           (array) unconfirmed transactions used as inputs for this transaction\\n""
           ""        \\""transactionid\\"",    (string) parent transaction id\\n""
           ""       ... ]\\n"";
}

void entryToJSON(UniValue &info, const CTxMemPoolEntry &e)
{
    AssertLockHeld(mempool.cs);

    info.push_back(Pair(""size"", (int)e.GetTxSize()));
    info.push_back(Pair(""fee"", ValueFromAmount(e.GetFee())));
    info.push_back(Pair(""modifiedfee"", ValueFromAmount(e.GetModifiedFee())));
    info.push_back(Pair(""time"", e.GetTime()));
    info.push_back(Pair(""height"", (int)e.GetHeight()));
    info.push_back(Pair(""startingpriority"", e.GetPriority(e.GetHeight())));
    info.push_back(Pair(""currentpriority"", e.GetPriority(chainActive.Height())));
    info.push_back(Pair(""descendantcount"", e.GetCountWithDescendants()));
    info.push_back(Pair(""descendantsize"", e.GetSizeWithDescendants()));
    info.push_back(Pair(""descendantfees"", e.GetModFeesWithDescendants()));
    info.push_back(Pair(""ancestorcount"", e.GetCountWithAncestors()));
    info.push_back(Pair(""ancestorsize"", e.GetSizeWithAncestors()));
    info.push_back(Pair(""ancestorfees"", e.GetModFeesWithAncestors()));
    const CTransaction& tx = e.GetTx();
    set<string> setDepends;
    BOOST_FOREACH(const CTxIn& txin, tx.vin)
    {
        if (mempool.exists(txin.prevout.hash))
            setDepends.insert(txin.prevout.hash.ToString());
    }

    UniValue depends(UniValue::VARR);
    BOOST_FOREACH(const string& dep, setDepends)
    {
        depends.push_back(dep);
    }

    info.push_back(Pair(""depends"", depends));
}

UniValue mempoolToJSON(bool fVerbose = false)
{
    if (fVerbose)
    {
        LOCK(mempool.cs);
        UniValue o(UniValue::VOBJ);
        BOOST_FOREACH(const CTxMemPoolEntry& e, mempool.mapTx)
        {
            const uint256& hash = e.GetTx().GetHash();
            UniValue info(UniValue::VOBJ);
            entryToJSON(info, e);
            o.push_back(Pair(hash.ToString(), info));
        }
        return o;
    }
    else
    {
        vector<uint256> vtxid;
        mempool.queryHashes(vtxid);

        UniValue a(UniValue::VARR);
        BOOST_FOREACH(const uint256& hash, vtxid)
            a.push_back(hash.ToString());

        return a;
    }
}

UniValue getrawmempool(const JSONRPCRequest& request)
{
    if (request.fHelp || request.params.size() > 1)
        throw runtime_error(
            ""getrawmempool ( verbose )\\n""
            ""\\nReturns all transaction ids in memory pool as a json array of string transaction ids.\\n""
            ""\\nArguments:\\n""
            ""1. verbose (boolean, optional, default=false) True for a json object, false for array of transaction ids\\n""
            ""\\nResult: (for verbose = false):\\n""
            ""[                     (json array of string)\\n""
            ""  \\""transactionid\\""     (string) The transaction id\\n""
            ""  ,...\\n""
            ""]\\n""
            ""\\nResult: (for verbose = true):\\n""
            ""{                           (json object)\\n""
            ""  \\""transactionid\\"" : {       (json object)\\n""
            + EntryDescriptionString()
            + ""  }, ...\\n""
            ""}\\n""
            ""\\nExamples:\\n""
            + HelpExampleCli(""getrawmempool"", ""true"")
            + HelpExampleRpc(""getrawmempool"", ""true"")
        );

    bool fVerbose = false;
    if (request.params.size() > 0)
        fVerbose = request.params[0].get_bool();

    return mempoolToJSON(fVerbose);
}

UniValue getmempoolancestors(const JSONRPCRequest& request)
{
    if (request.fHelp || request.params.size() < 1 || request.params.size() > 2) {
        throw runtime_error(
            ""getmempoolancestors txid (verbose)\\n""
            ""\\nIf txid is in the mempool, returns all in-mempool ancestors.\\n""
            ""\\nArguments:\\n""
            ""1. \\""txid\\""                 (string, required) The transaction id (must be in mempool)\\n""
            ""2. verbose                  (boolean, optional, default=false) True for a json object, false for array of transaction ids\\n""
            ""\\nResult (for verbose=false):\\n""
            ""[                       (json array of strings)\\n""
            ""  \\""transactionid\\""           (string) The transaction id of an in-mempool ancestor transaction\\n""
            ""  ,...\\n""
            ""]\\n""
            ""\\nResult (for verbose=true):\\n""
            ""{                           (json object)\\n""
            ""  \\""transactionid\\"" : {       (json object)\\n""
            + EntryDescriptionString()
            + ""  }, ...\\n""
            ""}\\n""
            ""\\nExamples:\\n""
            + HelpExampleCli(""getmempoolancestors"", ""\\""mytxid\\"""")
            + HelpExampleRpc(""getmempoolancestors"", ""\\""mytxid\\"""")
            );
    }

    bool fVerbose = false;
    if (request.params.size() > 1)
        fVerbose = request.params[1].get_bool();

    uint256 hash = ParseHashV(request.params[0], ""parameter 1"");

    LOCK(mempool.cs);

    CTxMemPool::txiter it = mempool.mapTx.find(hash);
    if (it == mempool.mapTx.end()) {
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Transaction not in mempool"");
    }

    CTxMemPool::setEntries setAncestors;
    uint64_t noLimit = std::numeric_limits<uint64_t>::max();
    std::string dummy;
    mempool.CalculateMemPoolAncestors(*it, setAncestors, noLimit, noLimit, noLimit, noLimit, dummy, false);

    if (!fVerbose) {
        UniValue o(UniValue::VARR);
        BOOST_FOREACH(CTxMemPool::txiter ancestorIt, setAncestors) {
            o.push_back(ancestorIt->GetTx().GetHash().ToString());
        }

        return o;
    } else {
        UniValue o(UniValue::VOBJ);
        BOOST_FOREACH(CTxMemPool::txiter ancestorIt, setAncestors) {
            const CTxMemPoolEntry &e = *ancestorIt;
            const uint256& _hash = e.GetTx().GetHash();
            UniValue info(UniValue::VOBJ);
            entryToJSON(info, e);
            o.push_back(Pair(_hash.ToString(), info));
        }
        return o;
    }
}

UniValue getmempooldescendants(const JSONRPCRequest& request)
{
    if (request.fHelp || request.params.size() < 1 || request.params.size() > 2) {
        throw runtime_error(
            ""getmempooldescendants txid (verbose)\\n""
            ""\\nIf txid is in the mempool, returns all in-mempool descendants.\\n""
            ""\\nArguments:\\n""
            ""1. \\""txid\\""                 (string, required) The transaction id (must be in mempool)\\n""
            ""2. verbose                  (boolean, optional, default=false) True for a json object, false for array of transaction ids\\n""
            ""\\nResult (for verbose=false):\\n""
            ""[                       (json array of strings)\\n""
            ""  \\""transactionid\\""           (string) The transaction id of an in-mempool descendant transaction\\n""
            ""  ,...\\n""
            ""]\\n""
            ""\\nResult (for verbose=true):\\n""
            ""{                           (json object)\\n""
            ""  \\""transactionid\\"" : {       (json object)\\n""
            + EntryDescriptionString()
            + ""  }, ...\\n""
            ""}\\n""
            ""\\nExamples:\\n""
            + HelpExampleCli(""getmempooldescendants"", ""\\""mytxid\\"""")
            + HelpExampleRpc(""getmempooldescendants"", ""\\""mytxid\\"""")
            );
    }

    bool fVerbose = false;
    if (request.params.size() > 1)
        fVerbose = request.params[1].get_bool();

    uint256 hash = ParseHashV(request.params[0], ""parameter 1"");

    LOCK(mempool.cs);

    CTxMemPool::txiter it = mempool.mapTx.find(hash);
    if (it == mempool.mapTx.end()) {
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Transaction not in mempool"");
    }

    CTxMemPool::setEntries setDescendants;
    mempool.CalculateDescendants(it, setDescendants);
    // CTxMemPool::CalculateDescendants will include the given tx
    setDescendants.erase(it);

    if (!fVerbose) {
        UniValue o(UniValue::VARR);
        BOOST_FOREACH(CTxMemPool::txiter descendantIt, setDescendants) {
            o.push_back(descendantIt->GetTx().GetHash().ToString());
        }

        return o;
    } else {
        UniValue o(UniValue::VOBJ);
        BOOST_FOREACH(CTxMemPool::txiter descendantIt, setDescendants) {
            const CTxMemPoolEntry &e = *descendantIt;
            const uint256& _hash = e.GetTx().GetHash();
            UniValue info(UniValue::VOBJ);
            entryToJSON(info, e);
            o.push_back(Pair(_hash.ToString(), info));
        }
        return o;
    }
}

UniValue getmempoolentry(const JSONRPCRequest& request)
{
    if (request.fHelp || request.params.size() != 1) {
        throw runtime_error(
            ""getmempoolentry txid\\n""
            ""\\nReturns mempool data for given transaction\\n""
            ""\\nArguments:\\n""
            ""1. \\""txid\\""                   (string, required) The transaction id (must be in mempool)\\n""
            ""\\nResult:\\n""
            ""{                           (json object)\\n""
            + EntryDescriptionString()
            + ""}\\n""
            ""\\nExamples:\\n""
            + HelpExampleCli(""getmempoolentry"", ""\\""mytxid\\"""")
            + HelpExampleRpc(""getmempoolentry"", ""\\""mytxid\\"""")
        );
    }

    uint256 hash = ParseHashV(request.params[0], ""parameter 1"");

    LOCK(mempool.cs);

    CTxMemPool::txiter it = mempool.mapTx.find(hash);
    if (it == mempool.mapTx.end()) {
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Transaction not in mempool"");
    }

    const CTxMemPoolEntry &e = *it;
    UniValue info(UniValue::VOBJ);
    entryToJSON(info, e);
    return info;
}

UniValue getblockhash(const JSONRPCRequest& request)
{
    if (request.fHelp || request.params.size() != 1)
        throw runtime_error(
            ""getblockhash height\\n""
            ""\\nReturns hash of block in best-block-chain at height provided.\\n""
            ""\\nArguments:\\n""
            ""1. height         (numeric, required) The height index\\n""
            ""\\nResult:\\n""
            ""\\""hash\\""         (string) The block hash\\n""
            ""\\nExamples:\\n""
            + HelpExampleCli(""getblockhash"", ""1000"")
            + HelpExampleRpc(""getblockhash"", ""1000"")
        );

    LOCK(cs_main);

    int nHeight = request.params[0].get_int();
    if (nHeight < 0 || nHeight > chainActive.Height())
        throw JSONRPCError(RPC_INVALID_PARAMETER, ""Block height out of range"");

    CBlockIndex* pblockindex = chainActive[nHeight];
    return pblockindex->GetBlockHash().GetHex();
}

UniValue getblockheader(const JSONRPCRequest& request)
{
    if (request.fHelp || request.params.size() < 1 || request.params.size() > 2)
        throw runtime_error(
            ""getblockheader \\""hash\\"" ( verbose )\\n""
            ""\\nIf verbose is false, returns a string that is serialized, hex-encoded data for blockheader 'hash'.\\n""
            ""If verbose is true, returns an Object with information about blockheader <hash>.\\n""
            ""\\nArguments:\\n""
            ""1. \\""hash\\""          (string, required) The block hash\\n""
            ""2. verbose           (boolean, optional, default=true) true for a json object, false for the hex encoded data\\n""
            ""\\nResult (for verbose = true):\\n""
            ""{\\n""
            ""  \\""hash\\"" : \\""hash\\"",     (string) the block hash (same as provided)\\n""
            ""  \\""confirmations\\"" : n,   (numeric) The number of confirmations, or -1 if the block is not on the main chain\\n""
            ""  \\""height\\"" : n,          (numeric) The block height or index\\n""
            ""  \\""version\\"" : n,         (numeric) The block version\\n""
            ""  \\""versionHex\\"" : \\""00000000\\"", (string) The block version formatted in hexadecimal\\n""
            ""  \\""merkleroot\\"" : \\""xxxx\\"", (string) The merkle root\\n""
            ""  \\""time\\"" : ttt,          (numeric) The block time in seconds since epoch (Jan 1 1970 GMT)\\n""
            ""  \\""mediantime\\"" : ttt,    (numeric) The median block time in seconds since epoch (Jan 1 1970 GMT)\\n""
            ""  \\""nonce\\"" : n,           (numeric) The nonce\\n""
            ""  \\""bits\\"" : \\""1d00ffff\\"", (string) The bits\\n""
            ""  \\""difficulty\\"" : x.xxx,  (numeric) The difficulty\\n""
            ""  \\""chainwork\\"" : \\""0000...1f3\\""     (string) Expected number of hashes required to produce the current chain (in hex)\\n""
            ""  \\""previousblockhash\\"" : \\""hash\\"",  (string) The hash of the previous block\\n""
            ""  \\""nextblockhash\\"" : \\""hash\\"",      (string) The hash of the next block\\n""
            ""}\\n""
            ""\\nResult (for verbose=false):\\n""
            ""\\""data\\""             (string) A string that is serialized, hex-encoded data for block 'hash'.\\n""
            ""\\nExamples:\\n""
            + HelpExampleCli(""getblockheader"", ""\\""00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\\"""")
            + HelpExampleRpc(""getblockheader"", ""\\""00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\\"""")
        );

    LOCK(cs_main);

    std::string strHash = request.params[0].get_str();
    uint256 hash(uint256S(strHash));

    bool fVerbose = true;
    if (request.params.size() > 1)
        fVerbose = request.params[1].get_bool();

    if (mapBlockIndex.count(hash) == 0)
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Block not found"");

    CBlockIndex* pblockindex = mapBlockIndex[hash];

    if (!fVerbose)
    {
        CDataStream ssBlock(SER_NETWORK, PROTOCOL_VERSION);
        ssBlock << pblockindex->GetBlockHeader();
        std::string strHex = HexStr(ssBlock.begin(), ssBlock.end());
        return strHex;
    }

    return blockheaderToJSON(pblockindex);
}

UniValue getblock(const JSONRPCRequest& request)
{
    if (request.fHelp || request.params.size() < 1 || request.params.size() > 2)
        throw runtime_error(
            ""getblock \\""blockhash\\"" ( verbose )\\n""
            ""\\nIf verbose is false, returns a string that is serialized, hex-encoded data for block 'hash'.\\n""
            ""If verbose is true, returns an Object with information about block <hash>.\\n""
            ""\\nArguments:\\n""
            ""1. \\""blockhash\\""          (string, required) The block hash\\n""
            ""2. verbose                (boolean, optional, default=true) true for a json object, false for the hex encoded data\\n""
            ""\\nResult (for verbose = true):\\n""
            ""{\\n""
            ""  \\""hash\\"" : \\""hash\\"",     (string) the block hash (same as provided)\\n""
            ""  \\""confirmations\\"" : n,   (numeric) The number of confirmations, or -1 if the block is not on the main chain\\n""
            ""  \\""size\\"" : n,            (numeric) The block size\\n""
            ""  \\""strippedsize\\"" : n,    (numeric) The block size excluding witness data\\n""
            ""  \\""weight\\"" : n           (numeric) The block weight as defined in BIP 141\\n""
            ""  \\""height\\"" : n,          (numeric) The block height or index\\n""
            ""  \\""version\\"" : n,         (numeric) The block version\\n""
            ""  \\""versionHex\\"" : \\""00000000\\"", (string) The block version formatted in hexadecimal\\n""
            ""  \\""merkleroot\\"" : \\""xxxx\\"", (string) The merkle root\\n""
            ""  \\""tx\\"" : [               (array of string) The transaction ids\\n""
            ""     \\""transactionid\\""     (string) The transaction id\\n""
            ""     ,...\\n""
            ""  ],\\n""
            ""  \\""time\\"" : ttt,          (numeric) The block time in seconds since epoch (Jan 1 1970 GMT)\\n""
            ""  \\""mediantime\\"" : ttt,    (numeric) The median block time in seconds since epoch (Jan 1 1970 GMT)\\n""
            ""  \\""nonce\\"" : n,           (numeric) The nonce\\n""
            ""  \\""bits\\"" : \\""1d00ffff\\"", (string) The bits\\n""
            ""  \\""difficulty\\"" : x.xxx,  (numeric) The difficulty\\n""
            ""  \\""chainwork\\"" : \\""xxxx\\"",  (string) Expected number of hashes required to produce the chain up to this block (in hex)\\n""
            ""  \\""previousblockhash\\"" : \\""hash\\"",  (string) The hash of the previous block\\n""
            ""  \\""nextblockhash\\"" : \\""hash\\""       (string) The hash of the next block\\n""
            ""}\\n""
            ""\\nResult (for verbose=false):\\n""
            ""\\""data\\""             (string) A string that is serialized, hex-encoded data for block 'hash'.\\n""
            ""\\nExamples:\\n""
            + HelpExampleCli(""getblock"", ""\\""00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\\"""")
            + HelpExampleRpc(""getblock"", ""\\""00000000c937983704a73af28acdec37b049d214adbda81d7e2a3dd146f6ed09\\"""")
        );

    LOCK(cs_main);

    std::string strHash = request.params[0].get_str();
    uint256 hash(uint256S(strHash));

    bool fVerbose = true;
    if (request.params.size() > 1)
        fVerbose = request.params[1].get_bool();

    if (mapBlockIndex.count(hash) == 0)
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Block not found"");

    CBlock block;
    CBlockIndex* pblockindex = mapBlockIndex[hash];

    if (fHavePruned && !(pblockindex->nStatus & BLOCK_HAVE_DATA) && pblockindex->nTx > 0)
        throw JSONRPCError(RPC_INTERNAL_ERROR, ""Block not available (pruned data)"");

    if(!ReadBlockFromDisk(block, pblockindex, Params().GetConsensus()))
        throw JSONRPCError(RPC_INTERNAL_ERROR, ""Can't read block from disk"");

    if (!fVerbose)
    {
        CDataStream ssBlock(SER_NETWORK, PROTOCOL_VERSION | RPCSerializationFlags());
        ssBlock << block;
        std::string strHex = HexStr(ssBlock.begin(), ssBlock.end());
        return strHex;
    }

    return blockToJSON(block, pblockindex);
}

struct CCoinsStats
{
    int nHeight;
    uint256 hashBlock;
    uint64_t nTransactions;
    uint64_t nTransactionOutputs;
    uint64_t nSerializedSize;
    uint256 hashSerialized;
    CAmount nTotalAmount;

    CCoinsStats() : nHeight(0), nTransactions(0), nTransactionOutputs(0), nSerializedSize(0), nTotalAmount(0) {}
};

//! Calculate statistics about the unspent transaction output set
static bool GetUTXOStats(CCoinsView *view, CCoinsStats &stats)
{
    std::unique_ptr<CCoinsViewCursor> pcursor(view->Cursor());

    CHashWriter ss(SER_GETHASH, PROTOCOL_VERSION);
    stats.hashBlock = pcursor->GetBestBlock();
    {
        LOCK(cs_main);
        stats.nHeight = mapBlockIndex.find(stats.hashBlock)->second->nHeight;
    }
    ss << stats.hashBlock;
    CAmount nTotalAmount = 0;
    while (pcursor->Valid()) {
        boost::this_thread::interruption_point();
        uint256 key;
        CCoins coins;
        if (pcursor->GetKey(key) && pcursor->GetValue(coins)) {
            stats.nTransactions++;
            ss << key;
            for (unsigned int i=0; i<coins.vout.size(); i++) {
                const CTxOut &out = coins.vout[i];
                if (!out.IsNull()) {
                    stats.nTransactionOutputs++;
                    ss << VARINT(i+1);
                    ss << out;
                    nTotalAmount += out.nValue;
                }
            }
            stats.nSerializedSize += 32 + pcursor->GetValueSize();
            ss << VARINT(0);
        } else {
            return error(""%s: unable to read value"", __func__);
        }
        pcursor->Next();
    }
    stats.hashSerialized = ss.GetHash();
    stats.nTotalAmount = nTotalAmount;
    return true;
}

UniValue pruneblockchain(const JSONRPCRequest& request)
{
    if (request.fHelp || request.params.size() != 1)
        throw runtime_error(
            ""pruneblockchain\\n""
            ""\\nArguments:\\n""
            ""1. \\""height\\""       (numeric, required) The block height to prune up to. May be set to a discrete height, or a unix timestamp\\n""
            ""                  to prune blocks whose block time is at least 2 hours older than the provided timestamp.\\n""
            ""\\nResult:\\n""
            ""n    (numeric) Height of the last block pruned.\\n""
            ""\\nExamples:\\n""
            + HelpExampleCli(""pruneblockchain"", ""1000"")
            + HelpExampleRpc(""pruneblockchain"", ""1000""));

    if (!fPruneMode)
        throw JSONRPCError(RPC_METHOD_NOT_FOUND, ""Cannot prune blocks because node is not in prune mode."");

    LOCK(cs_main);

    int heightParam = request.params[0].get_int();
    if (heightParam < 0)
        throw JSONRPCError(RPC_INVALID_PARAMETER, ""Negative block height."");

    // Height value more than a billion is too high to be a block height, and
    // too low to be a block time (corresponds to timestamp from Sep 2001).
    if (heightParam > 1000000000) {
        // Add a 2 hour buffer to include blocks which might have had old timestamps
        CBlockIndex* pindex = chainActive.FindEarliestAtLeast(heightParam - 7200);
        if (!pindex) {
            throw JSONRPCError(RPC_INTERNAL_ERROR, ""Could not find block with at least the specified timestamp."");
        }
        heightParam = pindex->nHeight;
    }

    unsigned int height = (unsigned int) heightParam;
    unsigned int chainHeight = (unsigned int) chainActive.Height();
    if (chainHeight < Params().PruneAfterHeight())
        throw JSONRPCError(RPC_INTERNAL_ERROR, ""Blockchain is too short for pruning."");
    else if (height > chainHeight)
        throw JSONRPCError(RPC_INVALID_PARAMETER, ""Blockchain is shorter than the attempted prune height."");
    else if (height > chainHeight - MIN_BLOCKS_TO_KEEP) {
        LogPrint(""rpc"", ""Attempt to prune blocks close to the tip.  Retaining the minimum number of blocks."");
        height = chainHeight - MIN_BLOCKS_TO_KEEP;
    }

    PruneBlockFilesManual(height);
    return uint64_t(height);
}

UniValue gettxoutsetinfo(const JSONRPCRequest& request)
{
    if (request.fHelp || request.params.size() != 0)
        throw runtime_error(
            ""gettxoutsetinfo\\n""
            ""\\nReturns statistics about the unspent transaction output set.\\n""
            ""Note this call may take some time.\\n""
            ""\\nResult:\\n""
            ""{\\n""
            ""  \\""height\\"":n,     (numeric) The current block height (index)\\n""
            ""  \\""bestblock\\"": \\""hex\\"",   (string) the best block hash hex\\n""
            ""  \\""transactions\\"": n,      (numeric) The number of transactions\\n""
            ""  \\""txouts\\"": n,            (numeric) The number of output transactions\\n""
            ""  \\""bytes_serialized\\"": n,  (numeric) The serialized size\\n""
            ""  \\""hash_serialized\\"": \\""hash\\"",   (string) The serialized hash\\n""
            ""  \\""total_amount\\"": x.xxx          (numeric) The total amount\\n""
            ""}\\n""
            ""\\nExamples:\\n""
            + HelpExampleCli(""gettxoutsetinfo"", """")
            + HelpExampleRpc(""gettxoutsetinfo"", """")
        );

    UniValue ret(UniValue::VOBJ);

    CCoinsStats stats;
    FlushStateToDisk();
    if (GetUTXOStats(pcoinsTip, stats)) {
        ret.push_back(Pair(""height"", (int64_t)stats.nHeight));
        ret.push_back(Pair(""bestblock"", stats.hashBlock.GetHex()));
        ret.push_back(Pair(""transactions"", (int64_t)stats.nTransactions));
        ret.push_back(Pair(""txouts"", (int64_t)stats.nTransactionOutputs));
        ret.push_back(Pair(""bytes_serialized"", (int64_t)stats.nSerializedSize));
        ret.push_back(Pair(""hash_serialized"", stats.hashSerialized.GetHex()));
        ret.push_back(Pair(""total_amount"", ValueFromAmount(stats.nTotalAmount)));
    } else {
        throw JSONRPCError(RPC_INTERNAL_ERROR, ""Unable to read UTXO set"");
    }
    return ret;
}

UniValue gettxout(const JSONRPCRequest& request)
{
    if (request.fHelp || request.params.size() < 2 || request.params.size() > 3)
        throw runtime_error(
            ""gettxout \\""txid\\"" n ( include_mempool )\\n""
            ""\\nReturns details about an unspent transaction output.\\n""
            ""\\nArguments:\\n""
            ""1. \\""txid\\""       (string, required) The transaction id\\n""
            ""2. n              (numeric, required) vout number\\n""
            ""3. include_mempool  (boolean, optional) Whether to include the mempool\\n""
            ""\\nResult:\\n""
            ""{\\n""
            ""  \\""bestblock\\"" : \\""hash\\"",    (string) the block hash\\n""
            ""  \\""confirmations\\"" : n,       (numeric) The number of confirmations\\n""
            ""  \\""value\\"" : x.xxx,           (numeric) The transaction value in "" + CURRENCY_UNIT + ""\\n""
            ""  \\""scriptPubKey\\"" : {         (json object)\\n""
            ""     \\""asm\\"" : \\""code\\"",       (string) \\n""
            ""     \\""hex\\"" : \\""hex\\"",        (string) \\n""
            ""     \\""reqSigs\\"" : n,          (numeric) Number of required signatures\\n""
            ""     \\""type\\"" : \\""pubkeyhash\\"", (string) The type, eg pubkeyhash\\n""
            ""     \\""addresses\\"" : [          (array of string) array of urals addresses\\n""
            ""        \\""address\\""     (string) urals address\\n""
            ""        ,...\\n""
            ""     ]\\n""
            ""  },\\n""
            ""  \\""version\\"" : n,            (numeric) The version\\n""
            ""  \\""coinbase\\"" : true|false   (boolean) Coinbase or not\\n""
            ""}\\n""

            ""\\nExamples:\\n""
            ""\\nGet unspent transactions\\n""
            + HelpExampleCli(""listunspent"", """") +
            ""\\nView the details\\n""
            + HelpExampleCli(""gettxout"", ""\\""txid\\"" 1"") +
            ""\\nAs a json rpc call\\n""
            + HelpExampleRpc(""gettxout"", ""\\""txid\\"", 1"")
        );

    LOCK(cs_main);

    UniValue ret(UniValue::VOBJ);

    std::string strHash = request.params[0].get_str();
    uint256 hash(uint256S(strHash));
    int n = request.params[1].get_int();
    bool fMempool = true;
    if (request.params.size() > 2)
        fMempool = request.params[2].get_bool();

    CCoins coins;
    if (fMempool) {
        LOCK(mempool.cs);
        CCoinsViewMemPool view(pcoinsTip, mempool);
        if (!view.GetCoins(hash, coins))
            return NullUniValue;
        mempool.pruneSpent(hash, coins); // TODO: this should be done by the CCoinsViewMemPool
    } else {
        if (!pcoinsTip->GetCoins(hash, coins))
            return NullUniValue;
    }
    if (n<0 || (unsigned int)n>=coins.vout.size() || coins.vout[n].IsNull())
        return NullUniValue;

    BlockMap::iterator it = mapBlockIndex.find(pcoinsTip->GetBestBlock());
    CBlockIndex *pindex = it->second;
    ret.push_back(Pair(""bestblock"", pindex->GetBlockHash().GetHex()));
    if ((unsigned int)coins.nHeight == MEMPOOL_HEIGHT)
        ret.push_back(Pair(""confirmations"", 0));
    else
        ret.push_back(Pair(""confirmations"", pindex->nHeight - coins.nHeight + 1));
    ret.push_back(Pair(""value"", ValueFromAmount(coins.vout[n].nValue)));
    UniValue o(UniValue::VOBJ);
    ScriptPubKeyToJSON(coins.vout[n].scriptPubKey, o, true);
    ret.push_back(Pair(""scriptPubKey"", o));
    ret.push_back(Pair(""version"", coins.nVersion));
    ret.push_back(Pair(""coinbase"", coins.fCoinBase));

    return ret;
}

UniValue verifychain(const JSONRPCRequest& request)
{
    int nCheckLevel = GetArg(""-checklevel"", DEFAULT_CHECKLEVEL);
    int nCheckDepth = GetArg(""-checkblocks"", DEFAULT_CHECKBLOCKS);
    if (request.fHelp || request.params.size() > 2)
        throw runtime_error(
            ""verifychain ( checklevel nblocks )\\n""
            ""\\nVerifies blockchain database.\\n""
            ""\\nArguments:\\n""
            ""1. checklevel   (numeric, optional, 0-4, default="" + strprintf(""%d"", nCheckLevel) + "") How thorough the block verification is.\\n""
            ""2. nblocks      (numeric, optional, default="" + strprintf(""%d"", nCheckDepth) + "", 0=all) The number of blocks to check.\\n""
            ""\\nResult:\\n""
            ""true|false       (boolean) Verified or not\\n""
            ""\\nExamples:\\n""
            + HelpExampleCli(""verifychain"", """")
            + HelpExampleRpc(""verifychain"", """")
        );

    LOCK(cs_main);

    if (request.params.size() > 0)
        nCheckLevel = request.params[0].get_int();
    if (request.params.size() > 1)
        nCheckDepth = request.params[1].get_int();

    return CVerifyDB().VerifyDB(Params(), pcoinsTip, nCheckLevel, nCheckDepth);
}

/** Implementation of IsSuperMajority with better feedback */
static UniValue SoftForkMajorityDesc(int version, CBlockIndex* pindex, const Consensus::Params& consensusParams)
{
    UniValue rv(UniValue::VOBJ);
    bool activated = false;
    switch(version)
    {
        case 2:
            activated = pindex->nHeight >= consensusParams.BIP34Height;
            break;
        case 3:
            activated = pindex->nHeight >= consensusParams.BIP66Height;
            break;
        case 4:
            activated = pindex->nHeight >= consensusParams.BIP65Height;
            break;
    }
    rv.push_back(Pair(""status"", activated));
    return rv;
}

static UniValue SoftForkDesc(const std::string &name, int version, CBlockIndex* pindex, const Consensus::Params& consensusParams)
{
    UniValue rv(UniValue::VOBJ);
    rv.push_back(Pair(""id"", name));
    rv.push_back(Pair(""version"", version));
    rv.push_back(Pair(""reject"", SoftForkMajorityDesc(version, pindex, consensusParams)));
    return rv;
}

static UniValue BIP9SoftForkDesc(const Consensus::Params& consensusParams, Consensus::DeploymentPos id)
{
    UniValue rv(UniValue::VOBJ);
    const ThresholdState thresholdState = VersionBitsTipState(consensusParams, id);
    switch (thresholdState) {
    case THRESHOLD_DEFINED: rv.push_back(Pair(""status"", ""defined"")); break;
    case THRESHOLD_STARTED: rv.push_back(Pair(""status"", ""started"")); break;
    case THRESHOLD_LOCKED_IN: rv.push_back(Pair(""status"", ""locked_in"")); break;
    case THRESHOLD_ACTIVE: rv.push_back(Pair(""status"", ""active"")); break;
    case THRESHOLD_FAILED: rv.push_back(Pair(""status"", ""failed"")); break;
    }
    if (THRESHOLD_STARTED == thresholdState)
    {
        rv.push_back(Pair(""bit"", consensusParams.vDeployments[id].bit));
    }
    rv.push_back(Pair(""startTime"", consensusParams.vDeployments[id].nStartTime));
    rv.push_back(Pair(""timeout"", consensusParams.vDeployments[id].nTimeout));
    rv.push_back(Pair(""since"", VersionBitsTipStateSinceHeight(consensusParams, id)));
    return rv;
}

void BIP9SoftForkDescPushBack(UniValue& bip9_softforks, const std::string &name, const Consensus::Params& consensusParams, Consensus::DeploymentPos id)
{
    // Deployments with timeout value of 0 are hidden.
    // A timeout value of 0 guarantees a softfork will never be activated.
    // This is used when softfork codes are merged without specifying the deployment schedule.
    if (consensusParams.vDeployments[id].nTimeout > 0)
        bip9_softforks.push_back(Pair(name, BIP9SoftForkDesc(consensusParams, id)));
}

UniValue getblockchaininfo(const JSONRPCRequest& request)
{
    if (request.fHelp || request.params.size() != 0)
        throw runtime_error(
            ""getblockchaininfo\\n""
            ""Returns an object containing various state info regarding blockchain processing.\\n""
            ""\\nResult:\\n""
            ""{\\n""
            ""  \\""chain\\"": \\""xxxx\\"",        (string) current network name as defined in BIP70 (main, test, regtest)\\n""
            ""  \\""blocks\\"": xxxxxx,         (numeric) the current number of blocks processed in the server\\n""
            ""  \\""headers\\"": xxxxxx,        (numeric) the current number of headers we have validated\\n""
            ""  \\""bestblockhash\\"": \\""...\\"", (string) the hash of the currently best block\\n""
            ""  \\""difficulty\\"": xxxxxx,     (numeric) the current difficulty\\n""
            ""  \\""mediantime\\"": xxxxxx,     (numeric) median time for the current best block\\n""
            ""  \\""verificationprogress\\"": xxxx, (numeric) estimate of verification progress [0..1]\\n""
            ""  \\""chainwork\\"": \\""xxxx\\""     (string) total amount of work in active chain, in hexadecimal\\n""
            ""  \\""pruned\\"": xx,             (boolean) if the blocks are subject to pruning\\n""
            ""  \\""pruneheight\\"": xxxxxx,    (numeric) lowest-height complete block stored\\n""
            ""  \\""softforks\\"": [            (array) status of softforks in progress\\n""
            ""     {\\n""
            ""        \\""id\\"": \\""xxxx\\"",        (string) name of softfork\\n""
            ""        \\""version\\"": xx,         (numeric) block version\\n""
            ""        \\""reject\\"": {            (object) progress toward rejecting pre-softfork blocks\\n""
            ""           \\""status\\"": xx,       (boolean) true if threshold reached\\n""
            ""        },\\n""
            ""     }, ...\\n""
            ""  ],\\n""
            ""  \\""bip9_softforks\\"": {          (object) status of BIP9 softforks in progress\\n""
            ""     \\""xxxx\\"" : {                (string) name of the softfork\\n""
            ""        \\""status\\"": \\""xxxx\\"",    (string) one of \\""defined\\"", \\""started\\"", \\""locked_in\\"", \\""active\\"", \\""failed\\""\\n""
            ""        \\""bit\\"": xx,             (numeric) the bit (0-28) in the block version field used to signal this softfork (only for \\""started\\"" status)\\n""
            ""        \\""startTime\\"": xx,       (numeric) the minimum median time past of a block at which the bit gains its meaning\\n""
            ""        \\""timeout\\"": xx,         (numeric) the median time past of a block at which the deployment is considered failed if not yet locked in\\n""
            ""        \\""since\\"": xx            (numeric) height of the first block to which the status applies\\n""
            ""     }\\n""
            ""  }\\n""
            ""}\\n""
            ""\\nExamples:\\n""
            + HelpExampleCli(""getblockchaininfo"", """")
            + HelpExampleRpc(""getblockchaininfo"", """")
        );

    LOCK(cs_main);

    UniValue obj(UniValue::VOBJ);
    obj.push_back(Pair(""chain"",                 Params().NetworkIDString()));
    obj.push_back(Pair(""blocks"",                (int)chainActive.Height()));
    obj.push_back(Pair(""headers"",               pindexBestHeader ? pindexBestHeader->nHeight : -1));
    obj.push_back(Pair(""bestblockhash"",         chainActive.Tip()->GetBlockHash().GetHex()));
    obj.push_back(Pair(""difficulty"",            (double)GetDifficulty()));
    obj.push_back(Pair(""mediantime"",            (int64_t)chainActive.Tip()->GetMedianTimePast()));
    obj.push_back(Pair(""verificationprogress"",  GuessVerificationProgress(Params().TxData(), chainActive.Tip())));
    obj.push_back(Pair(""chainwork"",             chainActive.Tip()->nChainWork.GetHex()));
    obj.push_back(Pair(""pruned"",                fPruneMode));

    const Consensus::Params& consensusParams = Params().GetConsensus();
    CBlockIndex* tip = chainActive.Tip();
    UniValue softforks(UniValue::VARR);
    UniValue bip9_softforks(UniValue::VOBJ);
    softforks.push_back(SoftForkDesc(""bip34"", 2, tip, consensusParams));
    softforks.push_back(SoftForkDesc(""bip66"", 3, tip, consensusParams));
    softforks.push_back(SoftForkDesc(""bip65"", 4, tip, consensusParams));
    BIP9SoftForkDescPushBack(bip9_softforks, ""csv"", consensusParams, Consensus::DEPLOYMENT_CSV);
    BIP9SoftForkDescPushBack(bip9_softforks, ""segwit"", consensusParams, Consensus::DEPLOYMENT_SEGWIT);
    obj.push_back(Pair(""softforks"",             softforks));
    obj.push_back(Pair(""bip9_softforks"", bip9_softforks));

    if (fPruneMode)
    {
        CBlockIndex *block = chainActive.Tip();
        while (block && block->pprev && (block->pprev->nStatus & BLOCK_HAVE_DATA))
            block = block->pprev;

        obj.push_back(Pair(""pruneheight"",        block->nHeight));
    }
    return obj;
}

/** Comparison function for sorting the getchaintips heads.  */
struct CompareBlocksByHeight
{
    bool operator()(const CBlockIndex* a, const CBlockIndex* b) const
    {
        /* Make sure that unequal blocks with the same height do not compare
           equal. Use the pointers themselves to make a distinction. */

        if (a->nHeight != b->nHeight)
          return (a->nHeight > b->nHeight);

        return a < b;
    }
};

UniValue getchaintips(const JSONRPCRequest& request)
{
    if (request.fHelp || request.params.size() != 0)
        throw runtime_error(
            ""getchaintips\\n""
            ""Return information about all known tips in the block tree,""
            "" including the main chain as well as orphaned branches.\\n""
            ""\\nResult:\\n""
            ""[\\n""
            ""  {\\n""
            ""    \\""height\\"": xxxx,         (numeric) height of the chain tip\\n""
            ""    \\""hash\\"": \\""xxxx\\"",         (string) block hash of the tip\\n""
            ""    \\""branchlen\\"": 0          (numeric) zero for main chain\\n""
            ""    \\""status\\"": \\""active\\""      (string) \\""active\\"" for the main chain\\n""
            ""  },\\n""
            ""  {\\n""
            ""    \\""height\\"": xxxx,\\n""
            ""    \\""hash\\"": \\""xxxx\\"",\\n""
            ""    \\""branchlen\\"": 1          (numeric) length of branch connecting the tip to the main chain\\n""
            ""    \\""status\\"": \\""xxxx\\""        (string) status of the chain (active, valid-fork, valid-headers, headers-only, invalid)\\n""
            ""  }\\n""
            ""]\\n""
            ""Possible values for status:\\n""
            ""1.  \\""invalid\\""               This branch contains at least one invalid block\\n""
            ""2.  \\""headers-only\\""          Not all blocks for this branch are available, but the headers are valid\\n""
            ""3.  \\""valid-headers\\""         All blocks are available for this branch, but they were never fully validated\\n""
            ""4.  \\""valid-fork\\""            This branch is not part of the active chain, but is fully validated\\n""
            ""5.  \\""active\\""                This is the tip of the active main chain, which is certainly valid\\n""
            ""\\nExamples:\\n""
            + HelpExampleCli(""getchaintips"", """")
            + HelpExampleRpc(""getchaintips"", """")
        );

    LOCK(cs_main);

    /*
     * Idea:  the set of chain tips is chainActive.tip, plus orphan blocks which do not have another orphan building off of them. 
     * Algorithm:
     *  - Make one pass through mapBlockIndex, picking out the orphan blocks, and also storing a set of the orphan block's pprev pointers.
     *  - Iterate through the orphan blocks. If the block isn't pointed to by another orphan, it is a chain tip.
     *  - add chainActive.Tip()
     */
    std::set<const CBlockIndex*, CompareBlocksByHeight> setTips;
    std::set<const CBlockIndex*> setOrphans;
    std::set<const CBlockIndex*> setPrevs;

    BOOST_FOREACH(const PAIRTYPE(const uint256, CBlockIndex*)& item, mapBlockIndex)
    {
        if (!chainActive.Contains(item.second)) {
            setOrphans.insert(item.second);
            setPrevs.insert(item.second->pprev);
        }
    }

    for (std::set<const CBlockIndex*>::iterator it = setOrphans.begin(); it != setOrphans.end(); ++it)
    {
        if (setPrevs.erase(*it) == 0) {
            setTips.insert(*it);
        }
    }

    // Always report the currently active tip.
    setTips.insert(chainActive.Tip());

    /* Construct the output array.  */
    UniValue res(UniValue::VARR);
    BOOST_FOREACH(const CBlockIndex* block, setTips)
    {
        UniValue obj(UniValue::VOBJ);
        obj.push_back(Pair(""height"", block->nHeight));
        obj.push_back(Pair(""hash"", block->phashBlock->GetHex()));

        const int branchLen = block->nHeight - chainActive.FindFork(block)->nHeight;
        obj.push_back(Pair(""branchlen"", branchLen));

        string status;
        if (chainActive.Contains(block)) {
            // This block is part of the currently active chain.
            status = ""active"";
        } else if (block->nStatus & BLOCK_FAILED_MASK) {
            // This block or one of its ancestors is invalid.
            status = ""invalid"";
        } else if (block->nChainTx == 0) {
            // This block cannot be connected because full block data for it or one of its parents is missing.
            status = ""headers-only"";
        } else if (block->IsValid(BLOCK_VALID_SCRIPTS)) {
            // This block is fully validated, but no longer part of the active chain. It was probably the active block once, but was reorganized.
            status = ""valid-fork"";
        } else if (block->IsValid(BLOCK_VALID_TREE)) {
            // The headers for this block are valid, but it has not been validated. It was probably never part of the most-work chain.
            status = ""valid-headers"";
        } else {
            // No clue.
            status = ""unknown"";
        }
        obj.push_back(Pair(""status"", status));

        res.push_back(obj);
    }

    return res;
}

UniValue mempoolInfoToJSON()
{
    UniValue ret(UniValue::VOBJ);
    ret.push_back(Pair(""size"", (int64_t) mempool.size()));
    ret.push_back(Pair(""bytes"", (int64_t) mempool.GetTotalTxSize()));
    ret.push_back(Pair(""usage"", (int64_t) mempool.DynamicMemoryUsage()));
    size_t maxmempool = GetArg(""-maxmempool"", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000;
    ret.push_back(Pair(""maxmempool"", (int64_t) maxmempool));
    ret.push_back(Pair(""mempoolminfee"", ValueFromAmount(mempool.GetMinFee(maxmempool).GetFeePerK())));

    return ret;
}

UniValue getmempoolinfo(const JSONRPCRequest& request)
{
    if (request.fHelp || request.params.size() != 0)
        throw runtime_error(
            ""getmempoolinfo\\n""
            ""\\nReturns details on the active state of the TX memory pool.\\n""
            ""\\nResult:\\n""
            ""{\\n""
            ""  \\""size\\"": xxxxx,               (numeric) Current tx count\\n""
            ""  \\""bytes\\"": xxxxx,              (numeric) Sum of all virtual transaction sizes as defined in BIP 141. Differs from actual serialized size because witness data is discounted\\n""
            ""  \\""usage\\"": xxxxx,              (numeric) Total memory usage for the mempool\\n""
            ""  \\""maxmempool\\"": xxxxx,         (numeric) Maximum memory usage for the mempool\\n""
            ""  \\""mempoolminfee\\"": xxxxx       (numeric) Minimum fee for tx to be accepted\\n""
            ""}\\n""
            ""\\nExamples:\\n""
            + HelpExampleCli(""getmempoolinfo"", """")
            + HelpExampleRpc(""getmempoolinfo"", """")
        );

    return mempoolInfoToJSON();
}

UniValue preciousblock(const JSONRPCRequest& request)
{
    if (request.fHelp || request.params.size() != 1)
        throw runtime_error(
            ""preciousblock \\""blockhash\\""\\n""
            ""\\nTreats a block as if it were received before others with the same work.\\n""
            ""\\nA later preciousblock call can override the effect of an earlier one.\\n""
            ""\\nThe effects of preciousblock are not retained across restarts.\\n""
            ""\\nArguments:\\n""
            ""1. \\""blockhash\\""   (string, required) the hash of the block to mark as precious\\n""
            ""\\nResult:\\n""
            ""\\nExamples:\\n""
            + HelpExampleCli(""preciousblock"", ""\\""blockhash\\"""")
            + HelpExampleRpc(""preciousblock"", ""\\""blockhash\\"""")
        );

    std::string strHash = request.params[0].get_str();
    uint256 hash(uint256S(strHash));
    CBlockIndex* pblockindex;

    {
        LOCK(cs_main);
        if (mapBlockIndex.count(hash) == 0)
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Block not found"");

        pblockindex = mapBlockIndex[hash];
    }

    CValidationState state;
    PreciousBlock(state, Params(), pblockindex);

    if (!state.IsValid()) {
        throw JSONRPCError(RPC_DATABASE_ERROR, state.GetRejectReason());
    }

    return NullUniValue;
}

UniValue invalidateblock(const JSONRPCRequest& request)
{
    if (request.fHelp || request.params.size() != 1)
        throw runtime_error(
            ""invalidateblock \\""blockhash\\""\\n""
            ""\\nPermanently marks a block as invalid, as if it violated a consensus rule.\\n""
            ""\\nArguments:\\n""
            ""1. \\""blockhash\\""   (string, required) the hash of the block to mark as invalid\\n""
            ""\\nResult:\\n""
            ""\\nExamples:\\n""
            + HelpExampleCli(""invalidateblock"", ""\\""blockhash\\"""")
            + HelpExampleRpc(""invalidateblock"", ""\\""blockhash\\"""")
        );

    std::string strHash = request.params[0].get_str();
    uint256 hash(uint256S(strHash));
    CValidationState state;

    {
        LOCK(cs_main);
        if (mapBlockIndex.count(hash) == 0)
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Block not found"");

        CBlockIndex* pblockindex = mapBlockIndex[hash];
        InvalidateBlock(state, Params(), pblockindex);
    }

    if (state.IsValid()) {
        ActivateBestChain(state, Params());
    }

    if (!state.IsValid()) {
        throw JSONRPCError(RPC_DATABASE_ERROR, state.GetRejectReason());
    }

    return NullUniValue;
}

UniValue reconsiderblock(const JSONRPCRequest& request)
{
    if (request.fHelp || request.params.size() != 1)
        throw runtime_error(
            ""reconsiderblock \\""blockhash\\""\\n""
            ""\\nRemoves invalidity status of a block and its descendants, reconsider them for activation.\\n""
            ""This can be used to undo the effects of invalidateblock.\\n""
            ""\\nArguments:\\n""
            ""1. \\""blockhash\\""   (string, required) the hash of the block to reconsider\\n""
            ""\\nResult:\\n""
            ""\\nExamples:\\n""
            + HelpExampleCli(""reconsiderblock"", ""\\""blockhash\\"""")
            + HelpExampleRpc(""reconsiderblock"", ""\\""blockhash\\"""")
        );

    std::string strHash = request.params[0].get_str();
    uint256 hash(uint256S(strHash));

    {
        LOCK(cs_main);
        if (mapBlockIndex.count(hash) == 0)
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Block not found"");

        CBlockIndex* pblockindex = mapBlockIndex[hash];
        ResetBlockFailureFlags(pblockindex);
    }

    CValidationState state;
    ActivateBestChain(state, Params());

    if (!state.IsValid()) {
        throw JSONRPCError(RPC_DATABASE_ERROR, state.GetRejectReason());
    }

    return NullUniValue;
}

static const CRPCCommand commands[] =
{ //  category              name                      actor (function)         okSafe argNames
  //  --------------------- ------------------------  -----------------------  ------ ----------
    { ""blockchain"",         ""getblockchaininfo"",      &getblockchaininfo,      true,  {} },
    { ""blockchain"",         ""getbestblockhash"",       &getbestblockhash,       true,  {} },
    { ""blockchain"",         ""getblockcount"",          &getblockcount,          true,  {} },
	{ ""blockchain"",         ""invalidateblock"",        &invalidateblock,        true,  {} },//TODO--
    { ""blockchain"",         ""reconsiderblock"",        &reconsiderblock,        true,  {} },//TODO--
    { ""blockchain"",         ""getblock"",               &getblock,               true,  {""blockhash"",""verbose""} },
    { ""blockchain"",         ""getblockhash"",           &getblockhash,           true,  {""height""} },
    { ""blockchain"",         ""getblockheader"",         &getblockheader,         true,  {""blockhash"",""verbose""} },
    { ""blockchain"",         ""getchaintips"",           &getchaintips,           true,  {} },
    { ""blockchain"",         ""getdifficulty"",          &getdifficulty,          true,  {} },
    { ""blockchain"",         ""getmempoolancestors"",    &getmempoolancestors,    true,  {""txid"",""verbose""} },
    { ""blockchain"",         ""getmempooldescendants"",  &getmempooldescendants,  true,  {""txid"",""verbose""} },
    { ""blockchain"",         ""getmempoolentry"",        &getmempoolentry,        true,  {""txid""} },
    { ""blockchain"",         ""getmempoolinfo"",         &getmempoolinfo,         true,  {} },
    { ""blockchain"",         ""getrawmempool"",          &getrawmempool,          true,  {""verbose""} },
    { ""blockchain"",         ""gettxout"",               &gettxout,               true,  {""txid"",""n"",""include_mempool""} },
    { ""blockchain"",         ""gettxoutsetinfo"",        &gettxoutsetinfo,        true,  {} },
    { ""blockchain"",         ""pruneblockchain"",        &pruneblockchain,        true,  {""height""} },
    { ""blockchain"",         ""verifychain"",            &verifychain,            true,  {""checklevel"",""nblocks""} },

    { ""blockchain"",         ""preciousblock"",          &preciousblock,          true,  {""blockhash""} },

    /* Not shown in help */
    { ""hidden"",             ""invalidateblock"",        &invalidateblock,        true,  {""blockhash""} },
    { ""hidden"",             ""reconsiderblock"",        &reconsiderblock,        true,  {""blockhash""} },
    { ""hidden"",             ""waitfornewblock"",        &waitfornewblock,        true,  {""timeout""} },
    { ""hidden"",             ""waitforblock"",           &waitforblock,           true,  {""blockhash"",""timeout""} },
    { ""hidden"",             ""waitforblockheight"",     &waitforblockheight,     true,  {""height"",""timeout""} },
};

void RegisterBlockchainRPCCommands(CRPCTable &t)
{
    for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++)
        t.appendCommand(commands[vcidx].name, &commands[vcidx]);
}
",16146,True,2777.555904251501,median
"/*
 * Copyright (c) Contributors to the Open 3D Engine Project.
 * For complete copyright and license terms please see the LICENSE at the root of this distribution.
 *
 * SPDX-License-Identifier: Apache-2.0 OR MIT
 *
 */
#include ""UserTypes.h""

#include <AzCore/std/containers/set.h>
#include <AzCore/std/containers/map.h>

#include <AzCore/std/containers/intrusive_set.h>

#include <AzCore/std/containers/array.h>
#include <AzCore/std/containers/fixed_vector.h>

using namespace AZStd;
using namespace UnitTestInternal;

#define AZ_TEST_VALIDATE_EMPTY_TREE(_Tree_) \\
    EXPECT_EQ(0, _Tree_.size());     \\
    EXPECT_TRUE(_Tree_.empty());         \\
    EXPECT_TRUE(_Tree_.begin() == _Tree_.end());

#define AZ_TEST_VALIDATE_TREE(_Tree_, _NumElements)                                                    \\
    EXPECT_EQ(_NumElements, _Tree_.size());                                                     \\
    EXPECT_TRUE((_Tree_.size() > 0) ? !_Tree_.empty() : _Tree_.empty());                              \\
    EXPECT_TRUE((_NumElements > 0) ? _Tree_.begin() != _Tree_.end() : _Tree_.begin() == _Tree_.end()); \\
    EXPECT_FALSE(_Tree_.empty());

namespace UnitTest
{
    /**
     * Setup the red-black tree. To achieve fixed_rbtree all you need is to use \\ref AZStd::static_pool_allocator with
     * the node (Internal::rb_tree_node<T>).
     */
    template<class T, class KeyEq = AZStd::less<T>, class Allocator = AZStd::allocator >
    struct RedBlackTree_SetTestTraits
    {
        typedef T                   key_type;
        typedef KeyEq               key_eq;
        typedef T                   value_type;
        typedef Allocator           allocator_type;
        static AZ_FORCE_INLINE const key_type& key_from_value(const value_type& value)  { return value; }
    };

    class Tree_RedBlack
        : public AllocatorsFixture
    {
    };
    
    TEST_F(Tree_RedBlack, Test)
    {
        array<int, 5> elements = {
            {1, 5, 8, 8, 4}
        };
        AZStd::size_t num;

        typedef rbtree<RedBlackTree_SetTestTraits<int> > rbtree_set_type;

        rbtree_set_type tree;
        AZ_TEST_VALIDATE_EMPTY_TREE(tree);

        rbtree_set_type copy_tree = tree;
        AZ_TEST_VALIDATE_EMPTY_TREE(copy_tree);

        // insert unique element
        bool isInsert = tree.insert_unique(10).second;
        AZ_TEST_VALIDATE_TREE(tree, 1);
        AZ_TEST_ASSERT(isInsert == true);

        // insert unique element, which we already have.
        isInsert = tree.insert_unique(10).second;
        AZ_TEST_VALIDATE_TREE(tree, 1);
        AZ_TEST_ASSERT(isInsert == false);

        // insert equal element.
        tree.insert_equal(11);
        AZ_TEST_VALIDATE_TREE(tree, 2);

        // insert equal element, which we already have.
        tree.insert_equal(11);
        AZ_TEST_VALIDATE_TREE(tree, 3);

        tree.insert_unique(elements.begin(), elements.end());
        AZ_TEST_VALIDATE_TREE(tree, 7);  /// there are 4 unique elements in the list.

        tree.insert_equal(elements.begin(), elements.end());
        AZ_TEST_VALIDATE_TREE(tree, 12);

        AZ_TEST_ASSERT(*tree.begin() == 1);
        rbtree_set_type::iterator iterNext = tree.erase(tree.begin());  // we have 2 elements with value (1)
        AZ_TEST_ASSERT(*iterNext == 1);
        tree.erase(tree.begin());
        AZ_TEST_VALIDATE_TREE(tree, 10);
        AZ_TEST_ASSERT(*tree.begin() == 4);

        AZ_TEST_ASSERT(*prev(tree.end()) == 11);
        iterNext = tree.erase(prev(tree.end()));
        AZ_TEST_ASSERT(iterNext == tree.end());
        AZ_TEST_VALIDATE_TREE(tree, 9);
        AZ_TEST_ASSERT(*prev(tree.end()) == 11);  // we have 2 elements with value(11) at the end

        num = tree.erase(8);
        AZ_TEST_VALIDATE_TREE(tree, 6);
        AZ_TEST_ASSERT(num == 3);

        tree.clear();
        AZ_TEST_VALIDATE_EMPTY_TREE(tree);

        tree.insert_equal(elements.begin(), elements.end());

        tree.erase(elements.begin(), elements.end());
        AZ_TEST_ASSERT(iterNext == tree.end());
        AZ_TEST_VALIDATE_EMPTY_TREE(tree);

        tree.insert_equal(elements.begin(), elements.end());
        tree.insert_equal(elements.begin(), elements.end());
        AZ_TEST_VALIDATE_TREE(tree, 10);

        rbtree_set_type::iterator iter, iter1;

        iter = tree.find(8);
        AZ_TEST_ASSERT(iter != tree.end());

        iter1 = tree.lower_bound(8);
        AZ_TEST_ASSERT(iter == iter1);

        iter1 = tree.upper_bound(8);
        AZ_TEST_ASSERT(iter1 == tree.end());
        AZ_TEST_ASSERT(iter1 != iter);

        num = tree.count(8);
        AZ_TEST_ASSERT(num == 4);

        AZStd::pair<rbtree_set_type::iterator, rbtree_set_type::iterator> range;
        range = tree.equal_range(8);
        AZ_TEST_ASSERT(range.first != tree.end());
        AZ_TEST_ASSERT(range.second == tree.end());
        AZ_TEST_ASSERT(AZStd::distance(range.first, range.second) == 4);

        // check the order
        int prevValue = *tree.begin();
        for (iter = next(tree.begin()); iter != tree.end(); ++iter)
        {
            AZ_TEST_ASSERT(prevValue <= *iter);
            prevValue = *iter;
        }

        // rbtree with different key equal function
        typedef rbtree<RedBlackTree_SetTestTraits<int, AZStd::greater<int> > > rbtree_set_type1;
        rbtree_set_type1 tree1;

        tree1.insert_equal(elements.begin(), elements.end());
        tree1.insert_equal(elements.begin(), elements.end());
        AZ_TEST_VALIDATE_TREE(tree1, 10);

        // check the order
        prevValue = *tree1.begin();
        for (rbtree_set_type1::iterator it = next(tree1.begin()); it != tree1.end(); ++it)
        {
            AZ_TEST_ASSERT(prevValue >= *it);
            prevValue = *it;
        }
    }

    class Tree_IntrusiveMultiSet
        : public AllocatorsFixture
    {
    public:
        struct Node
            : public AZStd::intrusive_multiset_node<Node>
        {
            Node(int order)
                : m_order(order) {}

            operator int() {
                return m_order;
            }

            int m_order;
        };

        typedef AZStd::intrusive_multiset<Node, AZStd::intrusive_multiset_base_hook<Node>, AZStd::less<> > IntrusiveSetIntKeyType;
    };

    TEST_F(Tree_IntrusiveMultiSet, Test)
    {
        IntrusiveSetIntKeyType  tree;

        // make sure the tree is empty
        AZ_TEST_VALIDATE_EMPTY_TREE(tree);

        // insert node
        Node n1(1);
        tree.insert(&n1);
        AZ_TEST_ASSERT(!tree.empty());
        AZ_TEST_ASSERT(tree.size() == 1);
        AZ_TEST_ASSERT(tree.begin() != tree.end());
        AZ_TEST_ASSERT(tree.begin()->m_order == 1);

        // insert node and sort
        Node n2(0);
        tree.insert(&n2);
        AZ_TEST_ASSERT(!tree.empty());
        AZ_TEST_ASSERT(tree.size() == 2);
        AZ_TEST_ASSERT(tree.begin() != tree.end());
        AZ_TEST_ASSERT(tree.begin()->m_order == 0);
        AZ_TEST_ASSERT((++tree.begin())->m_order == 1);

        // erase the first node
        IntrusiveSetIntKeyType::iterator it = tree.erase(tree.begin());
        AZ_TEST_ASSERT(it != tree.end());
        AZ_TEST_ASSERT(tree.size() == 1);
        AZ_TEST_ASSERT(it->m_order == 1);

        // insert via reference (a pointer to it will be taken)
        it = tree.insert(n2);
        AZ_TEST_ASSERT(it->m_order == n2.m_order);
        AZ_TEST_ASSERT(tree.size() == 2);

        AZStd::fixed_vector<Node, 5> elements;
        elements.push_back(Node(2));
        elements.push_back(Node(5));
        elements.push_back(Node(8));
        elements.push_back(Node(8));
        elements.push_back(Node(4));

        // insert from input iterator
        tree.insert(elements.begin(), elements.end());
        AZ_TEST_ASSERT(!tree.empty());
        AZ_TEST_ASSERT(tree.size() == 7);
        AZ_TEST_ASSERT(tree.begin() != tree.end());
        it = tree.begin();
        AZ_TEST_ASSERT((it++)->m_order == 0);
        AZ_TEST_ASSERT((it++)->m_order == 1);
        AZ_TEST_ASSERT((it++)->m_order == 2);
        AZ_TEST_ASSERT((it++)->m_order == 4);
        AZ_TEST_ASSERT((it++)->m_order == 5);
        AZ_TEST_ASSERT((it++)->m_order == 8);
        AZ_TEST_ASSERT((it++)->m_order == 8);

        // lower bound
        it = tree.lower_bound(8);
        AZ_TEST_ASSERT(it != tree.end());
        AZ_TEST_ASSERT(it->m_order == 8);
        AZ_TEST_ASSERT((++it)->m_order == 8);

        // upper bound
        it = tree.upper_bound(8);
        AZ_TEST_ASSERT(it == tree.end());
        AZ_TEST_ASSERT((--it)->m_order == 8);
        AZ_TEST_ASSERT((--it)->m_order == 8);

        // minimum
        it = tree.minimum();
        AZ_TEST_ASSERT(it != tree.end());
        AZ_TEST_ASSERT(it->m_order == 0);

        // maximum
        it = tree.maximum();
        AZ_TEST_ASSERT(it != tree.end());
        AZ_TEST_ASSERT(it->m_order == 8);

        // erase elements with iterator
        tree.erase(elements.begin(), elements.end());
        it = tree.begin();
        AZ_TEST_ASSERT(tree.size() == 2);
        AZ_TEST_ASSERT((it++)->m_order == 0);
        AZ_TEST_ASSERT((it++)->m_order == 1);

        // clear the entire container
        tree.clear();
        AZ_TEST_VALIDATE_EMPTY_TREE(tree);
    }

    // SetContainerTest-Begin
    class Tree_Set
        : public AllocatorsFixture
    {
    };

    TEST_F(Tree_Set, Test)
    {
        array<int, 5> elements = {
            {2, 6, 9, 3, 9}
        };
        array<int, 5> elements2 = {
            {11, 4, 13, 6, 1}
        };
        AZStd::size_t num;

        typedef set<int> int_set_type;

        int_set_type set;
        AZ_TEST_VALIDATE_EMPTY_TREE(set);

        int_set_type set1(elements.begin(), elements.end());
        AZ_TEST_ASSERT(set1 > set);
        AZ_TEST_VALIDATE_TREE(set1, 4);
        AZ_TEST_ASSERT(*set1.begin() == 2);
        AZ_TEST_ASSERT(*prev(set1.end()) == 9);

        int_set_type set2(set1);
        AZ_TEST_ASSERT(set1 == set2);
        AZ_TEST_VALIDATE_TREE(set2, 4);
        AZ_TEST_ASSERT(*set2.begin() == 2);
        AZ_TEST_ASSERT(*prev(set2.end()) == 9);

        set = set2;
        AZ_TEST_VALIDATE_TREE(set, 4);
        AZ_TEST_ASSERT(*set.begin() == 2);
        AZ_TEST_ASSERT(*prev(set.end()) == 9);

        set.clear();
        AZ_TEST_VALIDATE_EMPTY_TREE(set);

        set.swap(set2);
        AZ_TEST_VALIDATE_TREE(set, 4);
        AZ_TEST_ASSERT(*set.begin() == 2);
        AZ_TEST_ASSERT(*prev(set.end()) == 9);
        AZ_TEST_VALIDATE_EMPTY_TREE(set2);

        bool isInsert = set.insert(6).second;
        AZ_TEST_VALIDATE_TREE(set, 4);
        AZ_TEST_ASSERT(isInsert == false);

        isInsert = set.insert(10).second;
        AZ_TEST_VALIDATE_TREE(set, 5);
        AZ_TEST_ASSERT(isInsert == true);
        AZ_TEST_ASSERT(*prev(set.end()) == 10);

        set.insert(elements2.begin(), elements2.end());
        AZ_TEST_VALIDATE_TREE(set, 9);
        AZ_TEST_ASSERT(*set.begin() == 1);
        AZ_TEST_ASSERT(*prev(set.end()) == 13);

        set.erase(set.begin());
        AZ_TEST_VALIDATE_TREE(set, 8);
        AZ_TEST_ASSERT(*set.begin() == 2);

        set.erase(prev(set.end()));
        AZ_TEST_VALIDATE_TREE(set, 7);
        AZ_TEST_ASSERT(*prev(set.end()) == 11);

        num = set.erase(6);
        AZ_TEST_VALIDATE_TREE(set, 6);
        AZ_TEST_ASSERT(num == 1);

        num = set.erase(100);
        AZ_TEST_VALIDATE_TREE(set, 6);
        AZ_TEST_ASSERT(num == 0);

        int_set_type::iterator iter = set.find(9);
        AZ_TEST_ASSERT(iter != set.end());

        iter = set.find(99);
        AZ_TEST_ASSERT(iter == set.end());

        num = set.count(9);
        AZ_TEST_ASSERT(num == 1);

        num = set.count(88);
        AZ_TEST_ASSERT(num == 0);

        iter = set.lower_bound(11);
        AZ_TEST_ASSERT(iter != set.end());
        AZ_TEST_ASSERT(*iter == 11);

        iter = set.lower_bound(111);
        AZ_TEST_ASSERT(iter == set.end());

        iter = set.upper_bound(11);
        AZ_TEST_ASSERT(iter == set.end()); // this is the last element

        iter = set.upper_bound(4);
        AZ_TEST_ASSERT(iter != set.end()); // this is NOT the last element

        iter = set.upper_bound(44);
        AZ_TEST_ASSERT(iter == set.end());

        AZStd::pair<int_set_type::iterator, int_set_type::iterator> range = set.equal_range(11);
        num = distance(range.first, range.second);
        AZ_TEST_ASSERT(num == 1);
        AZ_TEST_ASSERT(range.first != set.end());
        AZ_TEST_ASSERT(*range.first == 11);
        AZ_TEST_ASSERT(range.second == set.end()); // this is the last element

        range = set.equal_range(91);
        num = distance(range.first, range.second);
        AZ_TEST_ASSERT(num == 0);
        AZ_TEST_ASSERT(range.first == set.end());
        AZ_TEST_ASSERT(range.second == set.end());
    }

    TEST_F(Tree_Set, ExplicitAllocatorSucceeds)
    {
        AZ::OSAllocator customAllocator;
        AZStd::set<int, AZStd::less<int>, AZ::AZStdIAllocator> setWithCustomAllocator{ AZ::AZStdIAllocator(&customAllocator) };
        auto insertIter = setWithCustomAllocator.emplace(1);
        EXPECT_TRUE(insertIter.second);
        insertIter = setWithCustomAllocator.emplace(1);
        EXPECT_FALSE(insertIter.second);
        EXPECT_EQ(1, setWithCustomAllocator.size());
    }

    class Tree_MultiSet
        : public AllocatorsFixture
    {
    };

    TEST_F(Tree_MultiSet, Test)
    {
        array<int, 5> elements = {
            {2, 6, 9, 3, 9}
        };
        array<int, 5> elements2 = {
            {11, 4, 13, 6, 1}
        };
        AZStd::size_t num;

        typedef multiset<int> int_multiset_type;

        int_multiset_type set;
        AZ_TEST_VALIDATE_EMPTY_TREE(set);

        int_multiset_type set1(elements.begin(), elements.end());
        AZ_TEST_ASSERT(set1 > set);
        AZ_TEST_VALIDATE_TREE(set1, 5);
        AZ_TEST_ASSERT(*set1.begin() == 2);
        AZ_TEST_ASSERT(*prev(set1.end()) == 9);

        int_multiset_type set2(set1);
        AZ_TEST_ASSERT(set1 == set2);
        AZ_TEST_VALIDATE_TREE(set2, 5);
        AZ_TEST_ASSERT(*set2.begin() == 2);
        AZ_TEST_ASSERT(*prev(set2.end()) == 9);

        set = set2;
        AZ_TEST_VALIDATE_TREE(set, 5);
        AZ_TEST_ASSERT(*set.begin() == 2);
        AZ_TEST_ASSERT(*prev(set.end()) == 9);

        set.clear();
        AZ_TEST_VALIDATE_EMPTY_TREE(set);

        set.swap(set2);
        AZ_TEST_VALIDATE_TREE(set, 5);
        AZ_TEST_ASSERT(*set.begin() == 2);
        AZ_TEST_ASSERT(*prev(set.end()) == 9);
        AZ_TEST_VALIDATE_EMPTY_TREE(set2);

        set.insert(10);
        AZ_TEST_VALIDATE_TREE(set, 6);
        AZ_TEST_ASSERT(*prev(set.end()) == 10);

        set.insert(elements2.begin(), elements2.end());
        AZ_TEST_VALIDATE_TREE(set, 11);
        AZ_TEST_ASSERT(*set.begin() == 1);
        AZ_TEST_ASSERT(*prev(set.end()) == 13);

        set.erase(set.begin());
        AZ_TEST_VALIDATE_TREE(set, 10);
        AZ_TEST_ASSERT(*set.begin() == 2);

        set.erase(prev(set.end()));
        AZ_TEST_VALIDATE_TREE(set, 9);
        AZ_TEST_ASSERT(*prev(set.end()) == 11);

        num = set.erase(6);
        AZ_TEST_VALIDATE_TREE(set, 7);
        AZ_TEST_ASSERT(num == 2);

        num = set.erase(100);
        AZ_TEST_VALIDATE_TREE(set, 7);
        AZ_TEST_ASSERT(num == 0);

        int_multiset_type::iterator iter = set.find(9);
        AZ_TEST_ASSERT(iter != set.end());

        iter = set.find(99);
        AZ_TEST_ASSERT(iter == set.end());

        num = set.count(9);
        AZ_TEST_ASSERT(num == 2);

        num = set.count(88);
        AZ_TEST_ASSERT(num == 0);

        iter = set.lower_bound(11);
        AZ_TEST_ASSERT(iter != set.end());
        AZ_TEST_ASSERT(*iter == 11);

        iter = set.lower_bound(111);
        AZ_TEST_ASSERT(iter == set.end());

        iter = set.upper_bound(11);
        AZ_TEST_ASSERT(iter == set.end()); // this is the last element

        iter = set.upper_bound(4);
        AZ_TEST_ASSERT(iter != set.end()); // this is NOT the last element

        iter = set.upper_bound(44);
        AZ_TEST_ASSERT(iter == set.end());

        AZStd::pair<int_multiset_type::iterator, int_multiset_type::iterator> range = set.equal_range(9);
        num = distance(range.first, range.second);
        AZ_TEST_ASSERT(num == 2);
        AZ_TEST_ASSERT(range.first != set.end());
        AZ_TEST_ASSERT(*range.first == 9);
        AZ_TEST_ASSERT(range.second != set.end());

        range = set.equal_range(91);
        num = distance(range.first, range.second);
        AZ_TEST_ASSERT(num == 0);
        AZ_TEST_ASSERT(range.first == set.end());
        AZ_TEST_ASSERT(range.second == set.end());
    }

    TEST_F(Tree_MultiSet, ExplicitAllocatorSucceeds)
    {
        AZ::OSAllocator customAllocator;
        AZStd::multiset<int, AZStd::less<int>, AZ::AZStdIAllocator> setWithCustomAllocator{ AZ::AZStdIAllocator(&customAllocator) };
        setWithCustomAllocator.emplace(1);
        setWithCustomAllocator.emplace(1);
        EXPECT_EQ(2, setWithCustomAllocator.size());
    }

    class Tree_Map
        : public AllocatorsFixture
    {
    };

    TEST_F(Tree_Map, Test)
    {
        fixed_vector<AZStd::pair<int, int>, 5> elements;
        elements.push_back(AZStd::make_pair(2, 100));
        elements.push_back(AZStd::make_pair(6, 101));
        elements.push_back(AZStd::make_pair(9, 102));
        elements.push_back(AZStd::make_pair(3, 103));
        elements.push_back(AZStd::make_pair(9, 104));
        fixed_vector<AZStd::pair<int, int>, 5> elements2;
        elements2.push_back(AZStd::make_pair(11, 200));
        elements2.push_back(AZStd::make_pair(4, 201));
        elements2.push_back(AZStd::make_pair(13, 202));
        elements2.push_back(AZStd::make_pair(6, 203));
        elements2.push_back(AZStd::make_pair(1, 204));
        AZStd::size_t num;

        typedef map<int, int> int_map_type;

        int_map_type map;
        AZ_TEST_VALIDATE_EMPTY_TREE(map);

        int_map_type map1(elements.begin(), elements.end());
        AZ_TEST_ASSERT(map1 > map);
        AZ_TEST_VALIDATE_TREE(map1, 4);
        AZ_TEST_ASSERT((*map1.begin()).first == 2);
        AZ_TEST_ASSERT((*prev(map1.end())).first == 9);

        int_map_type map2(map1);
        AZ_TEST_ASSERT(map1 == map2);
        AZ_TEST_VALIDATE_TREE(map2, 4);
        AZ_TEST_ASSERT((*map2.begin()).first == 2);
        AZ_TEST_ASSERT((*prev(map2.end())).first == 9);

        map = map2;
        AZ_TEST_VALIDATE_TREE(map, 4);
        AZ_TEST_ASSERT((*map.begin()).first == 2);
        AZ_TEST_ASSERT((*prev(map.end())).first == 9);

        map.clear();
        AZ_TEST_VALIDATE_EMPTY_TREE(map);

        map.swap(map2);
        AZ_TEST_VALIDATE_TREE(map, 4);
        AZ_TEST_ASSERT((*map.begin()).first == 2);
        AZ_TEST_ASSERT((*prev(map.end())).first == 9);
        AZ_TEST_VALIDATE_EMPTY_TREE(map2);

        bool isInsert = map.insert(6).second;
        AZ_TEST_VALIDATE_TREE(map, 4);
        AZ_TEST_ASSERT(isInsert == false);

        isInsert = map.insert(10).second;
        AZ_TEST_VALIDATE_TREE(map, 5);
        AZ_TEST_ASSERT(isInsert == true);
        AZ_TEST_ASSERT((*prev(map.end())).first == 10);

        map.insert(elements2.begin(), elements2.end());
        AZ_TEST_VALIDATE_TREE(map, 9);
        AZ_TEST_ASSERT((*map.begin()).first == 1);
        AZ_TEST_ASSERT((*prev(map.end())).first == 13);

        map.erase(map.begin());
        AZ_TEST_VALIDATE_TREE(map, 8);
        AZ_TEST_ASSERT(map.begin()->first == 2);

        map.erase(prev(map.end()));
        AZ_TEST_VALIDATE_TREE(map, 7);
        AZ_TEST_ASSERT(prev(map.end())->first == 11);

        num = map.erase(6);
        AZ_TEST_VALIDATE_TREE(map, 6);
        AZ_TEST_ASSERT(num == 1);

        num = map.erase(100);
        AZ_TEST_VALIDATE_TREE(map, 6);
        AZ_TEST_ASSERT(num == 0);

        int_map_type::iterator iter = map.find(9);
        AZ_TEST_ASSERT(iter != map.end());

        iter = map.find(99);
        AZ_TEST_ASSERT(iter == map.end());

        num = map.count(9);
        AZ_TEST_ASSERT(num == 1);

        num = map.count(88);
        AZ_TEST_ASSERT(num == 0);

        iter = map.lower_bound(11);
        AZ_TEST_ASSERT(iter != map.end());
        AZ_TEST_ASSERT(iter->first == 11);

        iter = map.lower_bound(111);
        AZ_TEST_ASSERT(iter == map.end());

        iter = map.upper_bound(11);
        AZ_TEST_ASSERT(iter == map.end()); // this is the last element

        iter = map.upper_bound(4);
        AZ_TEST_ASSERT(iter != map.end()); // this is NOT the last element

        iter = map.upper_bound(44);
        AZ_TEST_ASSERT(iter == map.end());

        AZStd::pair<int_map_type::iterator, int_map_type::iterator> range = map.equal_range(11);
        num = distance(range.first, range.second);
        AZ_TEST_ASSERT(num == 1);
        AZ_TEST_ASSERT(range.first != map.end());
        AZ_TEST_ASSERT(range.first->first == 11);
        AZ_TEST_ASSERT(range.second == map.end()); // this is the last element

        range = map.equal_range(91);
        num = distance(range.first, range.second);
        AZ_TEST_ASSERT(num == 0);
        AZ_TEST_ASSERT(range.first == map.end());
        AZ_TEST_ASSERT(range.second == map.end());

        AZStd::map<int, MyNoCopyClass> nocopy_map;
        MyNoCopyClass& inserted = nocopy_map.insert(3).first->second;
        inserted.m_bool = true;
        AZ_TEST_ASSERT(nocopy_map.begin()->second.m_bool == true);

        int_map_type map3({
                {1, 2}, {3, 4}, {5, 6}
            });
        AZ_TEST_VALIDATE_TREE(map3, 3);
        AZ_TEST_ASSERT((*map3.begin()).first == 1);
        AZ_TEST_ASSERT((*map3.begin()).second == 2);
        AZ_TEST_ASSERT((*prev(map3.end())).first == 5);
        AZ_TEST_ASSERT((*prev(map3.end())).second == 6);
    }

    TEST_F(Tree_Map, ExplicitAllocatorSucceeds)
    {
        AZ::OSAllocator customAllocator;
        AZStd::map<int, int, AZStd::less<int>, AZ::AZStdIAllocator> mapWithCustomAllocator{ AZ::AZStdIAllocator(&customAllocator) };
        auto insertIter = mapWithCustomAllocator.emplace(1, 1);
        EXPECT_TRUE(insertIter.second);
        insertIter = mapWithCustomAllocator.emplace(1, 2);
        EXPECT_FALSE(insertIter.second);
        EXPECT_EQ(1, mapWithCustomAllocator.size());
    }

    TEST_F(Tree_Map, IndexOperatorCompilesWithMoveOnlyType)
    {
        AZStd::map<int, AZStd::unique_ptr<int>> uniquePtrIntMap;
        uniquePtrIntMap[4] = AZStd::make_unique<int>(74);
        auto findIter = uniquePtrIntMap.find(4);
        EXPECT_NE(uniquePtrIntMap.end(), findIter);
        EXPECT_EQ(74, *findIter->second);
    }

    class Tree_MultiMap
        : public AllocatorsFixture
    {
    };

    TEST_F(Tree_MultiMap, Test)
    {
        fixed_vector<AZStd::pair<int, int>, 5> elements;
        elements.push_back(AZStd::make_pair(2, 100));
        elements.push_back(AZStd::make_pair(6, 101));
        elements.push_back(AZStd::make_pair(9, 102));
        elements.push_back(AZStd::make_pair(3, 103));
        elements.push_back(AZStd::make_pair(9, 104));
        fixed_vector<AZStd::pair<int, int>, 5> elements2;
        elements2.push_back(AZStd::make_pair(11, 200));
        elements2.push_back(AZStd::make_pair(4, 201));
        elements2.push_back(AZStd::make_pair(13, 202));
        elements2.push_back(AZStd::make_pair(6, 203));
        elements2.push_back(AZStd::make_pair(1, 204));
        AZStd::size_t num;

        typedef multimap<int, int> int_multimap_type;

        int_multimap_type map;
        AZ_TEST_VALIDATE_EMPTY_TREE(map);

        int_multimap_type map1(elements.begin(), elements.end());
        AZ_TEST_ASSERT(map1 > map);
        AZ_TEST_VALIDATE_TREE(map1, 5);
        AZ_TEST_ASSERT(map1.begin()->first == 2);
        AZ_TEST_ASSERT(prev(map1.end())->first == 9);

        int_multimap_type map2(map1);
        AZ_TEST_ASSERT(map1 == map2);
        AZ_TEST_VALIDATE_TREE(map2, 5);
        AZ_TEST_ASSERT(map2.begin()->first == 2);
        AZ_TEST_ASSERT(prev(map2.end())->first == 9);

        map = map2;
        AZ_TEST_VALIDATE_TREE(map, 5);
        AZ_TEST_ASSERT(map.begin()->first == 2);
        AZ_TEST_ASSERT(prev(map.end())->first == 9);

        map.clear();
        AZ_TEST_VALIDATE_EMPTY_TREE(map);

        map.swap(map2);
        AZ_TEST_VALIDATE_TREE(map, 5);
        AZ_TEST_ASSERT(map.begin()->first == 2);
        AZ_TEST_ASSERT(prev(map.end())->first == 9);
        AZ_TEST_VALIDATE_EMPTY_TREE(map2);

        map.insert(10);
        AZ_TEST_VALIDATE_TREE(map, 6);
        AZ_TEST_ASSERT(prev(map.end())->first == 10);

        map.insert(elements2.begin(), elements2.end());
        AZ_TEST_VALIDATE_TREE(map, 11);
        AZ_TEST_ASSERT(map.begin()->first == 1);
        AZ_TEST_ASSERT(prev(map.end())->first == 13);

        map.erase(map.begin());
        AZ_TEST_VALIDATE_TREE(map, 10);
        AZ_TEST_ASSERT(map.begin()->first == 2);

        map.erase(prev(map.end()));
        AZ_TEST_VALIDATE_TREE(map, 9);
        AZ_TEST_ASSERT(prev(map.end())->first == 11);

        num = map.erase(6);
        AZ_TEST_VALIDATE_TREE(map, 7);
        AZ_TEST_ASSERT(num == 2);

        num = map.erase(100);
        AZ_TEST_VALIDATE_TREE(map, 7);
        AZ_TEST_ASSERT(num == 0);

        int_multimap_type::iterator iter = map.find(9);
        AZ_TEST_ASSERT(iter != map.end());

        iter = map.find(99);
        AZ_TEST_ASSERT(iter == map.end());

        num = map.count(9);
        AZ_TEST_ASSERT(num == 2);

        num = map.count(88);
        AZ_TEST_ASSERT(num == 0);

        iter = map.lower_bound(11);
        AZ_TEST_ASSERT(iter != map.end());
        AZ_TEST_ASSERT(iter->first == 11);

        iter = map.lower_bound(111);
        AZ_TEST_ASSERT(iter == map.end());

        iter = map.upper_bound(11);
        AZ_TEST_ASSERT(iter == map.end()); // this is the last element

        iter = map.upper_bound(4);
        AZ_TEST_ASSERT(iter != map.end()); // this is NOT the last element

        iter = map.upper_bound(44);
        AZ_TEST_ASSERT(iter == map.end());

        AZStd::pair<int_multimap_type::iterator, int_multimap_type::iterator> range = map.equal_range(9);
        num = distance(range.first, range.second);
        AZ_TEST_ASSERT(num == 2);
        AZ_TEST_ASSERT(range.first != map.end());
        AZ_TEST_ASSERT(range.first->first == 9);
        AZ_TEST_ASSERT(range.second != map.end());

        range = map.equal_range(91);
        num = distance(range.first, range.second);
        AZ_TEST_ASSERT(num == 0);
        AZ_TEST_ASSERT(range.first == map.end());
        AZ_TEST_ASSERT(range.second == map.end());

        int_multimap_type intint_map3({
                {1, 10}, {2, 200}, {3, 3000}, {4, 40000}, {4, 40001}, {5, 500000}
            });
        AZ_TEST_ASSERT(intint_map3.size() == 6);
        AZ_TEST_ASSERT(intint_map3.count(1) == 1);
        AZ_TEST_ASSERT(intint_map3.count(2) == 1);
        AZ_TEST_ASSERT(intint_map3.count(3) == 1);
        AZ_TEST_ASSERT(intint_map3.count(4) == 2);
        AZ_TEST_ASSERT(intint_map3.count(5) == 1);
        AZ_TEST_ASSERT(intint_map3.lower_bound(1)->second == 10);
        AZ_TEST_ASSERT(intint_map3.lower_bound(2)->second == 200);
        AZ_TEST_ASSERT(intint_map3.lower_bound(3)->second == 3000);
        AZ_TEST_ASSERT(intint_map3.lower_bound(4)->second == 40000 || intint_map3.lower_bound(4)->second == 40001);
        AZ_TEST_ASSERT((++intint_map3.lower_bound(4))->second == 40000 || (++intint_map3.lower_bound(4))->second == 40001);
        AZ_TEST_ASSERT(intint_map3.lower_bound(5)->second == 500000);
    }

    TEST_F(Tree_MultiMap, ExplicitAllocatorSucceeds)
    {
        AZ::OSAllocator customAllocator;
        AZStd::multimap<int, int, AZStd::less<int>, AZ::AZStdIAllocator> mapWithCustomAllocator{ AZ::AZStdIAllocator(&customAllocator) };
        mapWithCustomAllocator.emplace(1, 1);
        mapWithCustomAllocator.emplace(1, 2);
        EXPECT_EQ(2, mapWithCustomAllocator.size());
    }

    template<typename ContainerType>
    class TreeSetContainers
        : public AllocatorsFixture
    {
    protected:
        void SetUp() override
        {
            AllocatorsFixture::SetUp();
        }

        void TearDown() override
        {
            AllocatorsFixture::TearDown();
        }
    };


    struct MoveOnlyIntType
    {
        MoveOnlyIntType() = default;
        MoveOnlyIntType(int32_t value)
            : m_value(value)
        {}
        MoveOnlyIntType(const MoveOnlyIntType&) = delete;
        MoveOnlyIntType& operator=(const MoveOnlyIntType&) = delete;
        MoveOnlyIntType(MoveOnlyIntType&& other)
            : m_value(other.m_value)
        {
        }

        MoveOnlyIntType& operator=(MoveOnlyIntType&& other)
        {
            m_value = other.m_value;
            other.m_value = {};
            return *this;
        }

        explicit operator int32_t()
        {
            return m_value;
        }

        bool operator==(const MoveOnlyIntType& other) const
        {
            return m_value == other.m_value;
        }

        int32_t m_value;
    };

    struct MoveOnlyIntTypeCompare
    {
        bool operator()(const MoveOnlyIntType& lhs, const MoveOnlyIntType& rhs) const
        {
            return lhs.m_value < rhs.m_value;
        }
    };

    template<typename ContainerType>
    struct TreeSetConfig
    {
        using SetType = ContainerType;
        static SetType Create()
        {
            SetType testSet;

            testSet.emplace(1);
            testSet.emplace(2);
            testSet.emplace(84075);
            testSet.emplace(-73);
            testSet.emplace(534);
            testSet.emplace(-845920);
            testSet.emplace(-42);
            testSet.emplace(0b1111'0000);
            return testSet;
        }
    };

    using SetContainerConfigs = ::testing::Types<
        TreeSetConfig<AZStd::set<int32_t>>
        , TreeSetConfig<AZStd::multiset<int32_t>>
        , TreeSetConfig<AZStd::set<MoveOnlyIntType, MoveOnlyIntTypeCompare>>
        , TreeSetConfig<AZStd::multiset<MoveOnlyIntType, MoveOnlyIntTypeCompare>>
    >;
    TYPED_TEST_CASE(TreeSetContainers, SetContainerConfigs);

    TYPED_TEST(TreeSetContainers, ExtractNodeHandleByKeySucceeds)
    {
        using SetType = typename TypeParam::SetType;
        using node_type = typename SetType::node_type;

        SetType testContainer = TypeParam::Create();
        node_type extractedNode = testContainer.extract(84075);

        EXPECT_EQ(7, testContainer.size());
        EXPECT_FALSE(extractedNode.empty());
        EXPECT_EQ(84075, static_cast<int32_t>(extractedNode.value()));
    }

    TYPED_TEST(TreeSetContainers, ExtractNodeHandleByKeyFails)
    {
        using SetType = typename TypeParam::SetType;
        using node_type = typename SetType::node_type;

        SetType testContainer = TypeParam::Create();
        node_type extractedNode = testContainer.extract(10000001);

        EXPECT_EQ(8, testContainer.size());
        EXPECT_TRUE(extractedNode.empty());
    }

    TYPED_TEST(TreeSetContainers, ExtractNodeHandleByIteratorSucceeds)
    {
        using SetType = typename TypeParam::SetType;
        using node_type = typename SetType::node_type;

        SetType testContainer = TypeParam::Create();
        auto foundIter = testContainer.find(-73);
        node_type extractedNode = testContainer.extract(foundIter);

        EXPECT_EQ(7, testContainer.size());
        EXPECT_FALSE(extractedNode.empty());
        EXPECT_EQ(-73, static_cast<int32_t>(extractedNode.value()));
    }

    TYPED_TEST(TreeSetContainers, InsertNodeHandleSucceeds)
    {
        using SetType = AZStd::set<int32_t>;
        using node_type = typename SetType::node_type;
        using insert_return_type = typename SetType::insert_return_type;

        SetType testContainer = TreeSetConfig<SetType>::Create();
        node_type extractedNode = testContainer.extract(84075);
        EXPECT_EQ(7, testContainer.size());
        EXPECT_FALSE(extractedNode.empty());
        EXPECT_EQ(84075, static_cast<int32_t>(extractedNode.value()));

        extractedNode.value() = -60;
        insert_return_type insertResult = testContainer.insert(AZStd::move(extractedNode));
        EXPECT_NE(testContainer.end(), insertResult.position);
        EXPECT_TRUE(insertResult.inserted);
        EXPECT_TRUE(insertResult.node.empty());

        EXPECT_NE(0, testContainer.count(-60));
        EXPECT_EQ(8, testContainer.size());
    }

    TEST_F(Tree_Set, SetInsertNodeHandleSucceeds)
    {
        using SetType = AZStd::set<int32_t>;
        using node_type = typename SetType::node_type;
        using insert_return_type = typename SetType::insert_return_type;

        SetType testContainer = TreeSetConfig<SetType>::Create();

        node_type extractedNode;
        EXPECT_TRUE(extractedNode.empty());

        insert_return_type insertResult = testContainer.insert(AZStd::move(extractedNode));
        EXPECT_EQ(testContainer.end(), insertResult.position);
        EXPECT_FALSE(insertResult.inserted);
        EXPECT_TRUE(insertResult.node.empty());
        EXPECT_EQ(8, testContainer.size());
    }

    TEST_F(Tree_Set, SetInsertNodeHandleWithEmptyNodeHandleFails)
    {
        using SetType = AZStd::set<int32_t>;
        using node_type = typename SetType::node_type;
        using insert_return_type = typename SetType::insert_return_type;

        SetType testContainer = TreeSetConfig<SetType>::Create();

        node_type extractedNode;
        EXPECT_TRUE(extractedNode.empty());

        insert_return_type insertResult = testContainer.insert(AZStd::move(extractedNode));
        EXPECT_EQ(testContainer.end(), insertResult.position);
        EXPECT_FALSE(insertResult.inserted);
        EXPECT_TRUE(insertResult.node.empty());
        EXPECT_EQ(8, testContainer.size());
    }

    TEST_F(Tree_Set, SetInsertNodeHandleWithDuplicateValueInNodeHandleFails)
    {
        using SetType = AZStd::set<int32_t>;
        using node_type = typename SetType::node_type;
        using insert_return_type = typename SetType::insert_return_type;

        SetType testContainer = TreeSetConfig<SetType>::Create();
        node_type extractedNode = testContainer.extract(2);

        EXPECT_EQ(7, testContainer.size());
        EXPECT_FALSE(extractedNode.empty());
        EXPECT_EQ(2, static_cast<int32_t>(extractedNode.value()));

        // Set node handle value to a key that is currently within the container
        extractedNode.value() = 534;
        insert_return_type insertResult = testContainer.insert(AZStd::move(extractedNode));
        EXPECT_NE(testContainer.end(), insertResult.position);
        EXPECT_FALSE(insertResult.inserted);
        EXPECT_FALSE(insertResult.node.empty());

        EXPECT_EQ(7, testContainer.size());
    }

    TEST_F(Tree_Set, SetExtractedNodeCanBeInsertedIntoMultiset)
    {
        using SetType = AZStd::set<int32_t>;
        using MultisetType = AZStd::multiset<int32_t>;

        SetType uniqueSet{ 1, 2, 3 };
        MultisetType multiSet{ 1, 4, 1 };

        auto extractedNode = uniqueSet.extract(1);
        EXPECT_EQ(2, uniqueSet.size());
        EXPECT_FALSE(extractedNode.empty());

        auto insertIt = multiSet.insert(AZStd::move(extractedNode));
        EXPECT_NE(multiSet.end(), insertIt);
        EXPECT_EQ(4, multiSet.size());
        EXPECT_EQ(3, multiSet.count(1));
    }

    TEST_F(Tree_Set, MultisetExtractedNodeCanBeInsertedIntoSet)
    {
        using SetType = AZStd::set<int32_t>;
        using MultisetType = AZStd::multiset<int32_t>;

        SetType uniqueSet{ 1, 2, 3 };
        MultisetType multiSet{ 1, 4, 1 };

        auto extractedNode = multiSet.extract(4);
        EXPECT_EQ(2, multiSet.size());
        EXPECT_FALSE(extractedNode.empty());

        auto insertResult = uniqueSet.insert(AZStd::move(extractedNode));
        EXPECT_TRUE(insertResult.inserted);
        EXPECT_EQ(4, uniqueSet.size());
        EXPECT_EQ(1, uniqueSet.count(4));
    }

    template <typename ContainerType>
    class TreeSetDifferentAllocatorFixture
        : public AllocatorsFixture
    {
    };

    template<template <typename, typename, typename> class ContainerTemplate>
    struct TreeSetWithCustomAllocatorConfig
    {
        using ContainerType = ContainerTemplate<int32_t, AZStd::less<int32_t>, AZ::AZStdIAllocator>;

        static ContainerType Create(std::initializer_list<typename ContainerType::value_type> intList, AZ::IAllocatorAllocate* allocatorInstance)
        {
            ContainerType allocatorSet(intList, AZStd::less<int32_t>{}, AZ::AZStdIAllocator{ allocatorInstance });
            return allocatorSet;
        }
    };

    using SetTemplateConfigs = ::testing::Types<
        TreeSetWithCustomAllocatorConfig<AZStd::set>
        , TreeSetWithCustomAllocatorConfig<AZStd::multiset>
    >;
    TYPED_TEST_CASE(TreeSetDifferentAllocatorFixture, SetTemplateConfigs);

#if GTEST_OS_SUPPORTS_DEATH_TEST
    TYPED_TEST(TreeSetDifferentAllocatorFixture, InsertNodeHandleWithDifferentAllocatorsLogsTraceMessages)
    {
        using ContainerType = typename TypeParam::ContainerType;

        ContainerType systemAllocatorSet = TypeParam::Create({ {1}, {2}, {3} }, &AZ::AllocatorInstance<AZ::SystemAllocator>::Get());
        auto extractedNode = systemAllocatorSet.extract(1);

        ContainerType osAllocatorSet = TypeParam::Create({ {2} }, &AZ::AllocatorInstance<AZ::OSAllocator>::Get());
        // Attempt to insert an extracted node from a container using the AZ::SystemAllocator into a container using the AZ::OSAllocator
        EXPECT_DEATH(
            {
                UnitTest::TestRunner::Instance().StartAssertTests();
                osAllocatorSet.insert(AZStd::move(extractedNode));
                if (UnitTest::TestRunner::Instance().StopAssertTests() > 0)
                {
                    // AZ_Assert does not cause the application to exit in profile_test configuration
                    // Therefore an exit with a non-zero error code is invoked to trigger the death condition
                    abort();
                }
            }, "".*"");
    }
#endif // GTEST_OS_SUPPORTS_DEATH_TEST

    TYPED_TEST(TreeSetDifferentAllocatorFixture, SwapMovesElementsWhenAllocatorsDiffer)
    {
        using ContainerType = typename TypeParam::ContainerType;

        ContainerType systemAllocatorMap = TypeParam::Create({ {1}, {2}, {3} }, &AZ::AllocatorInstance<AZ::SystemAllocator>::Get());
        ContainerType osAllocatorMap = TypeParam::Create({ {2} }, &AZ::AllocatorInstance<AZ::OSAllocator>::Get());
        // Swap the container elements around while leave the allocators the same.
        systemAllocatorMap.swap(osAllocatorMap);

        EXPECT_EQ(1, systemAllocatorMap.size());
        EXPECT_EQ(1, systemAllocatorMap.count(2));
        EXPECT_EQ(AZ::AZStdIAllocator(&AZ::AllocatorInstance<AZ::SystemAllocator>::Get()), systemAllocatorMap.get_allocator());

        EXPECT_EQ(3, osAllocatorMap.size());
        EXPECT_EQ(1, osAllocatorMap.count(1));
        EXPECT_EQ(1, osAllocatorMap.count(2));
        EXPECT_EQ(1, osAllocatorMap.count(3));
        EXPECT_EQ(AZ::AZStdIAllocator(&AZ::AllocatorInstance<AZ::OSAllocator>::Get()), osAllocatorMap.get_allocator());
    }

    template<typename ContainerType>
    class TreeMapContainers
        : public AllocatorsFixture
    {
    protected:
        void SetUp() override
        {
            AllocatorsFixture::SetUp();
        }

        void TearDown() override
        {
            AllocatorsFixture::TearDown();
        }
    };

    template<typename ContainerType>
    struct TreeMapConfig
    {
        using MapType = ContainerType;
        static MapType Create()
        {
            MapType testMap;

            testMap.emplace(8001, 1337);
            testMap.emplace(-200, 31337);
            testMap.emplace(-932, 0xbaddf00d);
            testMap.emplace(73, 0xfee1badd);
            testMap.emplace(1872, 0xCDCDCDCD);
            testMap.emplace(0xFF, 7000000);
            testMap.emplace(0777, 0b00110000010);
            testMap.emplace(0b11010110110000101, 0xDDDDDDDD);
            return testMap;
        }
    };
    using MapContainerConfigs = ::testing::Types<
        TreeMapConfig<AZStd::map<int32_t, int32_t>>
        , TreeMapConfig<AZStd::multimap<int32_t, int32_t>>
        , TreeMapConfig<AZStd::map<MoveOnlyIntType, int32_t, MoveOnlyIntTypeCompare>>
        , TreeMapConfig<AZStd::multimap<MoveOnlyIntType, int32_t, MoveOnlyIntTypeCompare>>
    >;
    TYPED_TEST_CASE(TreeMapContainers, MapContainerConfigs);

    TYPED_TEST(TreeMapContainers, ExtractNodeHandleByKeySucceeds)
    {
        using MapType = typename TypeParam::MapType;
        using node_type = typename MapType::node_type;

        MapType testContainer = TypeParam::Create();
        node_type extractedNode = testContainer.extract(0777);

        EXPECT_EQ(7, testContainer.size());
        EXPECT_FALSE(extractedNode.empty());
        EXPECT_EQ(0777, static_cast<int32_t>(extractedNode.key()));
        EXPECT_EQ(0b00110000010, extractedNode.mapped());
    }

    TYPED_TEST(TreeMapContainers, ExtractNodeHandleByKeyFails)
    {
        using MapType = typename TypeParam::MapType;
        using node_type = typename MapType::node_type;

        MapType testContainer = TypeParam::Create();
        node_type extractedNode = testContainer.extract(3);

        EXPECT_EQ(8, testContainer.size());
        EXPECT_TRUE(extractedNode.empty());
    }

    TYPED_TEST(TreeMapContainers, ExtractNodeHandleByIteratorSucceeds)
    {
        using MapType = typename TypeParam::MapType;
        using node_type = typename MapType::node_type;

        MapType testContainer = TypeParam::Create();
        auto foundIter = testContainer.find(73);
        node_type extractedNode = testContainer.extract(foundIter);

        EXPECT_EQ(7, testContainer.size());
        EXPECT_FALSE(extractedNode.empty());
        EXPECT_EQ(73, static_cast<int32_t>(extractedNode.key()));
        EXPECT_EQ(0xfee1badd, extractedNode.mapped());
    }

    TYPED_TEST(TreeMapContainers, InsertNodeHandleSucceeds)
    {
        using MapType = typename TypeParam::MapType;
        using node_type = typename MapType::node_type;

        MapType testContainer = TypeParam::Create();
        node_type extractedNode = testContainer.extract(0777);

        EXPECT_EQ(7, testContainer.size());
        EXPECT_FALSE(extractedNode.empty());
        EXPECT_EQ(0777, static_cast<int32_t>(extractedNode.key()));
        extractedNode.key() = 0644;
        extractedNode.mapped() = 1'212;

        testContainer.insert(AZStd::move(extractedNode));
        auto foundIt = testContainer.find(0644);
        EXPECT_NE(testContainer.end(), foundIt);
        EXPECT_EQ(0644, static_cast<int32_t>(foundIt->first));
        EXPECT_EQ(1'212, foundIt->second);
        EXPECT_EQ(8, testContainer.size());
    }

    TEST_F(Tree_Map, MapInsertNodeHandleSucceeds)
    {
        using MapType = AZStd::map<int32_t, int32_t>;
        using node_type = typename MapType::node_type;
        using insert_return_type = typename MapType::insert_return_type;

        MapType testContainer = TreeMapConfig<MapType>::Create();
        node_type extractedNode = testContainer.extract(0b11010110110000101);

        EXPECT_EQ(7, testContainer.size());
        EXPECT_FALSE(extractedNode.empty());
        EXPECT_EQ(0b11010110110000101, extractedNode.key());

        extractedNode.key() = -60;
        extractedNode.mapped() = -1;

        insert_return_type insertResult = testContainer.insert(AZStd::move(extractedNode));
        EXPECT_NE(testContainer.end(), insertResult.position);
        EXPECT_TRUE(insertResult.inserted);
        EXPECT_TRUE(insertResult.node.empty());

        auto foundIt = testContainer.find(-60);
        EXPECT_NE(testContainer.end(), foundIt);
        EXPECT_EQ(-60, foundIt->first);
        EXPECT_EQ(-1, foundIt->second);
        EXPECT_EQ(8, testContainer.size());
    }

    TEST_F(Tree_Map, MapInsertNodeHandleWithEmptyNodeHandleFails)
    {
        using MapType = AZStd::map<int32_t, int32_t>;
        using node_type = typename MapType::node_type;
        using insert_return_type = typename MapType::insert_return_type;

        MapType testContainer = TreeMapConfig<MapType>::Create();

        node_type extractedNode;
        EXPECT_TRUE(extractedNode.empty());

        EXPECT_EQ(8, testContainer.size());
        insert_return_type insertResult = testContainer.insert(AZStd::move(extractedNode));
        EXPECT_EQ(testContainer.end(), insertResult.position);
        EXPECT_FALSE(insertResult.inserted);
        EXPECT_TRUE(insertResult.node.empty());
        EXPECT_EQ(8, testContainer.size());
    }

    TEST_F(Tree_Map, MapInsertNodeHandleWithDuplicateValueInNodeHandleFails)
    {
        using MapType = AZStd::map<int32_t, int32_t>;
        using node_type = typename MapType::node_type;
        using insert_return_type = typename MapType::insert_return_type;
        MapType testContainer = TreeMapConfig<MapType>::Create();

        node_type extractedNode = testContainer.extract(0xFF);
        EXPECT_EQ(7, testContainer.size());
        EXPECT_FALSE(extractedNode.empty());
        EXPECT_EQ(0xFF, static_cast<int32_t>(extractedNode.key()));
        // Update the extracted node to have the same key as one of the elements currently within the container
        extractedNode.key() = -200;

        insert_return_type insertResult = testContainer.insert(AZStd::move(extractedNode));
        EXPECT_NE(testContainer.end(), insertResult.position);
        EXPECT_FALSE(insertResult.inserted);
        EXPECT_FALSE(insertResult.node.empty());
        EXPECT_EQ(7, testContainer.size());
    }

    TEST_F(Tree_Map, MapExtractedNodeCanBeInsertedIntoMultimap)
    {
        using MapType = AZStd::map<int32_t, int32_t>;
        using MultimapType = AZStd::multimap<int32_t, int32_t>;

        MapType uniqueMap{ {1, 2}, {2, 4}, {3, 6} };
        MultimapType multiMap{ {1, 2}, { 4, 8}, {1, 3} };

        auto extractedNode = uniqueMap.extract(1);
        EXPECT_EQ(2, uniqueMap.size());
        EXPECT_FALSE(extractedNode.empty());

        auto insertIt = multiMap.insert(AZStd::move(extractedNode));
        EXPECT_NE(multiMap.end(), insertIt);
        EXPECT_EQ(4, multiMap.size());
        EXPECT_EQ(3, multiMap.count(1));
    }

    TEST_F(Tree_Map, MultimapExtractedNodeCanBeInsertedIntoMap)
    {
        using MapType = AZStd::map<int32_t, int32_t>;
        using MultimapType = AZStd::multimap<int32_t, int32_t>;

        MapType uniqueMap{ {1, 2}, {2, 4}, {3, 6} };
        MultimapType multiMap{ {1, 2}, { 4, 8}, {1, 3} };

        auto extractedNode = multiMap.extract(4);
        EXPECT_EQ(2, multiMap.size());
        EXPECT_FALSE(extractedNode.empty());

        auto insertResult = uniqueMap.insert(AZStd::move(extractedNode));
        EXPECT_TRUE(insertResult.inserted);
        EXPECT_EQ(4, uniqueMap.size());
        EXPECT_EQ(1, uniqueMap.count(4));
    }

    TEST_F(Tree_Map, MapTryEmplace_DoesNotConstruct_OnExistingKey)
    {
        static int s_tryEmplaceConstructorCallCount;
        s_tryEmplaceConstructorCallCount = 0;
        struct TryEmplaceConstructorCalls
        {
            TryEmplaceConstructorCalls()
            {
                ++s_tryEmplaceConstructorCallCount;
            }
            TryEmplaceConstructorCalls(int value)
                : m_value{ value }
            {
                ++s_tryEmplaceConstructorCallCount;
            }
            TryEmplaceConstructorCalls(const TryEmplaceConstructorCalls& other)
                : m_value{ other.m_value }
            {
                ++s_tryEmplaceConstructorCallCount;
            }

            int m_value{};
        };
        using TryEmplaceTestMap = AZStd::map<int, TryEmplaceConstructorCalls>;
        TryEmplaceTestMap testContainer;

        // try_emplace move key
        AZStd::pair<TryEmplaceTestMap::iterator, bool> emplacePairIter = testContainer.try_emplace(1, 5);
        EXPECT_EQ(1, s_tryEmplaceConstructorCallCount);
        EXPECT_TRUE(emplacePairIter.second);
        EXPECT_EQ(5, emplacePairIter.first->second.m_value);

        // try_emplace copy key
        int testKey = 3;
        emplacePairIter = testContainer.try_emplace(testKey, 72);
        EXPECT_EQ(2, s_tryEmplaceConstructorCallCount);
        EXPECT_TRUE(emplacePairIter.second);
        EXPECT_EQ(72, emplacePairIter.first->second.m_value);

        // invoke try_emplace with hint and move key
        TryEmplaceTestMap::iterator emplaceIter = testContainer.try_emplace(testContainer.end(), 5, 4092);
        EXPECT_EQ(3, s_tryEmplaceConstructorCallCount);
        EXPECT_EQ(4092, emplaceIter->second.m_value);

        // invoke try_emplace with hint and copy key
        testKey = 48;
        emplaceIter = testContainer.try_emplace(testContainer.end(), testKey, 824);
        EXPECT_EQ(4, s_tryEmplaceConstructorCallCount);
        EXPECT_EQ(824, emplaceIter->second.m_value);

        // Since the key of '1' exist, nothing should be constructed
        emplacePairIter = testContainer.try_emplace(1, -6354);
        EXPECT_EQ(4, s_tryEmplaceConstructorCallCount);
        EXPECT_FALSE(emplacePairIter.second);
        EXPECT_EQ(5, emplacePairIter.first->second.m_value);
    }

    TEST_F(Tree_Map, MapTryEmplace_DoesNotMoveValue_OnExistingKey)
    {
        AZStd::unordered_map<int, AZStd::unique_ptr<int>> testMap;
        auto testPtr = AZStd::make_unique<int>(5);
        auto [emplaceIter, inserted] = testMap.try_emplace(1, AZStd::move(testPtr));
        EXPECT_TRUE(inserted);
        EXPECT_EQ(nullptr, testPtr);

        testPtr = AZStd::make_unique<int>(7000);
        auto [emplaceIter2, inserted2] = testMap.try_emplace(1, AZStd::move(testPtr));
        EXPECT_FALSE(inserted2);
        ASSERT_NE(nullptr, testPtr);
        EXPECT_EQ(7000, *testPtr);
    }

    TEST_F(Tree_Map, MapInsertOrAssign_PerformsAssignment_OnExistingKey)
    {
        static int s_tryInsertOrAssignConstructorCalls;
        static int s_tryInsertOrAssignAssignmentCalls;
        s_tryInsertOrAssignConstructorCalls = 0;
        s_tryInsertOrAssignAssignmentCalls = 0;
        struct InsertOrAssignInitCalls
        {
            InsertOrAssignInitCalls()
            {
                ++s_tryInsertOrAssignConstructorCalls;
            }
            InsertOrAssignInitCalls(int value)
                : m_value{ value }
            {
                ++s_tryInsertOrAssignConstructorCalls;
            }
            InsertOrAssignInitCalls(const InsertOrAssignInitCalls& other)
                : m_value{ other.m_value }
            {
                ++s_tryInsertOrAssignConstructorCalls;
            }

            InsertOrAssignInitCalls& operator=(int value)
            {
                m_value = value;
                ++s_tryInsertOrAssignAssignmentCalls;
                return *this;
            }

            int m_value{};
        };
        using InsertOrAssignTestMap = AZStd::map<int, InsertOrAssignInitCalls>;
        InsertOrAssignTestMap testContainer;

        // insert_or_assign move key
        AZStd::pair<InsertOrAssignTestMap::iterator, bool> insertOrAssignPairIter = testContainer.insert_or_assign(1, 5);
        EXPECT_EQ(1, s_tryInsertOrAssignConstructorCalls);
        EXPECT_EQ(0, s_tryInsertOrAssignAssignmentCalls);
        EXPECT_TRUE(insertOrAssignPairIter.second);
        EXPECT_EQ(5, insertOrAssignPairIter.first->second.m_value);

        // insert_or_assign copy key
        int testKey = 3;
        insertOrAssignPairIter = testContainer.insert_or_assign(testKey, 72);
        EXPECT_EQ(2, s_tryInsertOrAssignConstructorCalls);
        EXPECT_EQ(0, s_tryInsertOrAssignAssignmentCalls);
        EXPECT_TRUE(insertOrAssignPairIter.second);
        EXPECT_EQ(72, insertOrAssignPairIter.first->second.m_value);

        // invoke insert_or_assign with hint and move key
        InsertOrAssignTestMap::iterator insertOrAssignIter = testContainer.insert_or_assign(testContainer.end(), 5, 4092);
        EXPECT_EQ(3, s_tryInsertOrAssignConstructorCalls);
        EXPECT_EQ(0, s_tryInsertOrAssignAssignmentCalls);
        EXPECT_EQ(4092, insertOrAssignIter->second.m_value);

        // invoke insert_or_assign with hint and copy key
        testKey = 48;
        insertOrAssignIter = testContainer.insert_or_assign(testContainer.end(), testKey, 824);
        EXPECT_EQ(4, s_tryInsertOrAssignConstructorCalls);
        EXPECT_EQ(0, s_tryInsertOrAssignAssignmentCalls);
        EXPECT_EQ(824, insertOrAssignIter->second.m_value);

        // Since the key of '1' exist, only an assignment should take place
        insertOrAssignPairIter = testContainer.insert_or_assign(1, -6354);
        EXPECT_EQ(4, s_tryInsertOrAssignConstructorCalls);
        EXPECT_EQ(1, s_tryInsertOrAssignAssignmentCalls);
        EXPECT_FALSE(insertOrAssignPairIter.second);
        EXPECT_EQ(-6354, insertOrAssignPairIter.first->second.m_value);
    }

    template <typename ContainerType>
    class TreeMapDifferentAllocatorFixture
        : public AllocatorsFixture
    {
    };

    template<template <typename, typename, typename, typename> class ContainerTemplate>
    struct TreeMapWithCustomAllocatorConfig
    {
        using ContainerType = ContainerTemplate<int32_t, int32_t, AZStd::less<int32_t>, AZ::AZStdIAllocator>;

        static ContainerType Create(std::initializer_list<typename ContainerType::value_type> intList, AZ::IAllocatorAllocate* allocatorInstance)
        {
            ContainerType allocatorMap(intList, AZStd::less<int32_t>{}, AZ::AZStdIAllocator{ allocatorInstance });
            return allocatorMap;
        }
    };

    using MapTemplateConfigs = ::testing::Types<
        TreeMapWithCustomAllocatorConfig<AZStd::map>
        , TreeMapWithCustomAllocatorConfig<AZStd::multimap>
    >;
    TYPED_TEST_CASE(TreeMapDifferentAllocatorFixture, MapTemplateConfigs);

#if GTEST_OS_SUPPORTS_DEATH_TEST
    TYPED_TEST(TreeMapDifferentAllocatorFixture, InsertNodeHandleWithDifferentAllocatorsLogsTraceMessages)
    {
        using ContainerType = typename TypeParam::ContainerType;

        ContainerType systemAllocatorMap = TypeParam::Create({ {1, 2}, {2, 4}, {3, 6} }, &AZ::AllocatorInstance<AZ::SystemAllocator>::Get());
        auto extractedNode = systemAllocatorMap.extract(1);

        ContainerType osAllocatorMap = TypeParam::Create({ {2, 4} }, &AZ::AllocatorInstance<AZ::OSAllocator>::Get());
        // Attempt to insert an extracted node from a container using the AZ::SystemAllocator into a container using the AZ::OSAllocator
        EXPECT_DEATH(
            {
                UnitTest::TestRunner::Instance().StartAssertTests();
                osAllocatorMap.insert(AZStd::move(extractedNode));
                if (UnitTest::TestRunner::Instance().StopAssertTests() > 0)
                {
                    // AZ_Assert does not cause the application to exit in profile_test configuration
                    // Therefore an exit with a non-zero error code is invoked to trigger the death condition
                    abort();
                }
            }, "".*"");
    }
#endif // GTEST_OS_SUPPORTS_DEATH_TEST

    TYPED_TEST(TreeMapDifferentAllocatorFixture, SwapMovesElementsWhenAllocatorsDiffer)
    {
        using ContainerType = typename TypeParam::ContainerType;

        ContainerType systemAllocatorMap = TypeParam::Create({ {1, 2}, {2, 4}, {3, 6} }, &AZ::AllocatorInstance<AZ::SystemAllocator>::Get());
        ContainerType osAllocatorMap = TypeParam::Create({ {2, 4} }, &AZ::AllocatorInstance<AZ::OSAllocator>::Get());
        // Swap the container elements around while leaving the allocators the same.
        systemAllocatorMap.swap(osAllocatorMap);

        EXPECT_EQ(1, systemAllocatorMap.size());
        EXPECT_EQ(1, systemAllocatorMap.count(2));
        EXPECT_EQ(AZ::AZStdIAllocator(&AZ::AllocatorInstance<AZ::SystemAllocator>::Get()), systemAllocatorMap.get_allocator());

        EXPECT_EQ(3, osAllocatorMap.size());
        EXPECT_EQ(1, osAllocatorMap.count(1));
        EXPECT_EQ(1, osAllocatorMap.count(2));
        EXPECT_EQ(1, osAllocatorMap.count(3));
        EXPECT_EQ(AZ::AZStdIAllocator(&AZ::AllocatorInstance<AZ::OSAllocator>::Get()), osAllocatorMap.get_allocator());
    }

    namespace TreeContainerTransparentTestInternal
    {
        static int s_allConstructorCount;
        static int s_allAssignmentCount;

        struct TrackConstructorCalls
        {
            TrackConstructorCalls()
            {
                ++s_allConstructorCount;
            }
            TrackConstructorCalls(int value)
                : m_value(value)
            {
                ++s_allConstructorCount;
            }
            TrackConstructorCalls(const TrackConstructorCalls& other)
                : m_value(other.m_value)
            {
                ++s_allConstructorCount;
            };
            TrackConstructorCalls& operator=(const TrackConstructorCalls& other)
            {
                ++s_allAssignmentCount;
                m_value = other.m_value;
                return *this;
            }

            operator int() const
            {
                return m_value;
            }

            int m_value{}; // Used for comparison
        };

        bool operator<(const TrackConstructorCalls& lhs, const TrackConstructorCalls& rhs)
        {
            return lhs.m_value < rhs.m_value;
        }
        bool operator<(int lhs, const TrackConstructorCalls& rhs)
        {
            return lhs < rhs.m_value;
        }
        bool operator<(const TrackConstructorCalls& lhs, int rhs)
        {
            return lhs.m_value < rhs;
        }
    }

    template<typename Container>
    struct TreeContainerTransparentConfig
    {
        using ContainerType = Container;
    };

    template <typename ContainerType>
    class TreeContainerTransparentFixture
        : public ScopedAllocatorSetupFixture
    {
    protected:
        void SetUp() override
        {
            TreeContainerTransparentTestInternal::s_allConstructorCount = 0;
            TreeContainerTransparentTestInternal::s_allAssignmentCount = 0;
        }
        void TearDown() override
        {
            TreeContainerTransparentTestInternal::s_allConstructorCount = 0;
            TreeContainerTransparentTestInternal::s_allAssignmentCount = 0;
        }
    };

    using TreeContainerConfigs = ::testing::Types <
        TreeContainerTransparentConfig<AZStd::set<TreeContainerTransparentTestInternal::TrackConstructorCalls,  AZStd::less<>>>
        , TreeContainerTransparentConfig<AZStd::multiset<TreeContainerTransparentTestInternal::TrackConstructorCalls, AZStd::less<>>>
        , TreeContainerTransparentConfig<AZStd::map<TreeContainerTransparentTestInternal::TrackConstructorCalls, int, AZStd::less<>>>
        , TreeContainerTransparentConfig<AZStd::multimap<TreeContainerTransparentTestInternal::TrackConstructorCalls, int, AZStd::less<>>>
    >;

    TYPED_TEST_CASE(TreeContainerTransparentFixture, TreeContainerConfigs);

    TYPED_TEST(TreeContainerTransparentFixture, FindDoesNotConstructKeyForTransparentHashEqual_NoKeyConstructed_Succeeds)
    {
        typename TypeParam::ContainerType container;
        container.emplace(1);
        container.emplace(2);
        container.emplace(3);
        container.emplace(4);
        container.emplace(5);
        container.emplace(1);

        // Reset constructor count to zero
        TreeContainerTransparentTestInternal::s_allConstructorCount = 0;

        // The following call will construct a TrackConstructorCalls element
        auto foundIt = container.find(TreeContainerTransparentTestInternal::TrackConstructorCalls{ 2 });
        EXPECT_EQ(1, TreeContainerTransparentTestInternal::s_allConstructorCount);
        EXPECT_NE(container.end(), foundIt);

        // The transparent find function should be invoked and no constructor of TrackConstructorCallsElement should be invoked
        foundIt = container.find(1);
        // The ConstructorCount should still be the same
        EXPECT_EQ(1, TreeContainerTransparentTestInternal::s_allConstructorCount);
        EXPECT_NE(container.end(), foundIt);

        // When find fails to locate an element, TrackConstructorCallsElement shouldn't be construction
        foundIt = container.find(-1);
        EXPECT_EQ(1, TreeContainerTransparentTestInternal::s_allConstructorCount);
        EXPECT_EQ(container.end(), foundIt);

        // No assignments should have taken place from any of the container operations
        EXPECT_EQ(0, TreeContainerTransparentTestInternal::s_allAssignmentCount);
    }

    TYPED_TEST(TreeContainerTransparentFixture, ContainsDoesNotConstructKeyForTransparentHashEqual_NoKeyConstructed_Succeeds)
    {
        typename TypeParam::ContainerType container;
        container.emplace(1);
        container.emplace(2);
        container.emplace(3);
        container.emplace(4);
        container.emplace(5);
        container.emplace(1);

        // Reset constructor count to zero
        TreeContainerTransparentTestInternal::s_allConstructorCount = 0;

        // The following call will construct a TrackConstructorCalls element
        EXPECT_TRUE(container.contains(TreeContainerTransparentTestInternal::TrackConstructorCalls{ 2 }));
        EXPECT_EQ(1, TreeContainerTransparentTestInternal::s_allConstructorCount);


        // The transparent contain function should be invoked and no constructor of TrackConstructorCallsElement should be invoked
        EXPECT_TRUE(container.contains(2));
        // The ConstructorCount should still be the same
        EXPECT_EQ(1, TreeContainerTransparentTestInternal::s_allConstructorCount);

        // In the case when the element isn't found, no constructor shouldn't be invoked as well
        EXPECT_FALSE(container.contains(27));
        EXPECT_EQ(1, TreeContainerTransparentTestInternal::s_allConstructorCount);
        // No assignments should have taken place from any of the container operations
        EXPECT_EQ(0, TreeContainerTransparentTestInternal::s_allAssignmentCount);
    }

    TYPED_TEST(TreeContainerTransparentFixture, CountDoesNotConstructKeyForTransparentHashEqual_NoKeyConstructed_Succeeds)
    {
        typename TypeParam::ContainerType container;
        container.emplace(1);
        container.emplace(2);
        container.emplace(3);
        container.emplace(4);
        container.emplace(5);
        container.emplace(1);

        // Reset constructor count to zero
        TreeContainerTransparentTestInternal::s_allConstructorCount = 0;

        // The following call will construct a TrackConstructorCalls element
        EXPECT_EQ(1, container.count(TreeContainerTransparentTestInternal::TrackConstructorCalls{ 2 }));
        EXPECT_EQ(1, TreeContainerTransparentTestInternal::s_allConstructorCount);

        // The transparent count function should be invoked and no constructor of TrackConstructorCallsElement should be invoked
        EXPECT_EQ(1, container.count(2));
        // The ConstructorCount should still be the same
        EXPECT_EQ(1, TreeContainerTransparentTestInternal::s_allConstructorCount);

        // In the case when the element isn't found, no constructor shouldn't be invoked as well
        EXPECT_EQ(0, container.count(27));
        EXPECT_EQ(1, TreeContainerTransparentTestInternal::s_allConstructorCount);
        // No assignments should have taken place from any of the container operations
        EXPECT_EQ(0, TreeContainerTransparentTestInternal::s_allAssignmentCount);
    }

    TYPED_TEST(TreeContainerTransparentFixture, LowerBoundDoesNotConstructKeyForTransparentHashEqual_NoKeyConstructed_Succeeds)
    {
        typename TypeParam::ContainerType container;
        container.emplace(21);
        container.emplace(4);
        container.emplace(3);
        container.emplace(7);
        container.emplace(15);
        container.emplace(42);

        // Reset constructor count to zero
        TreeContainerTransparentTestInternal::s_allConstructorCount = 0;

        // The following call will construct a TrackConstructorCalls element
        auto foundIt = container.lower_bound(TreeContainerTransparentTestInternal::TrackConstructorCalls{ 2 });
        EXPECT_EQ(1, TreeContainerTransparentTestInternal::s_allConstructorCount);
        EXPECT_NE(container.end(), foundIt);

        // The transparent lower_bound function should be invoked and no constructor of TrackConstructorCallsElement should be invoked
        foundIt = container.lower_bound(26);
        // The ConstructorCount should still be the same
        EXPECT_EQ(1, TreeContainerTransparentTestInternal::s_allConstructorCount);
        EXPECT_NE(container.end(), foundIt);

        // In the case when the element isn't found, no constructor shouldn't be invoked as well
        foundIt = container.lower_bound(562);
        EXPECT_EQ(1, TreeContainerTransparentTestInternal::s_allConstructorCount);
        EXPECT_EQ(container.end(), foundIt);

        // No assignments should have taken place from any of the container operations
        EXPECT_EQ(0, TreeContainerTransparentTestInternal::s_allAssignmentCount);
    }

    TYPED_TEST(TreeContainerTransparentFixture, UpperBoundDoesNotConstructKeyForTransparentHashEqual_NoKeyConstructed_Succeeds)
    {
        typename TypeParam::ContainerType container;
        container.emplace(2);
        container.emplace(4);
        container.emplace(15);
        container.emplace(332);
        container.emplace(5);
        container.emplace(1);

        // Reset constructor count to zero
        TreeContainerTransparentTestInternal::s_allConstructorCount = 0;

        // The following call will construct a TrackConstructorCalls element
        auto foundIt = container.upper_bound(TreeContainerTransparentTestInternal::TrackConstructorCalls{ 3 });
        EXPECT_EQ(1, TreeContainerTransparentTestInternal::s_allConstructorCount);
        EXPECT_NE(container.end(), foundIt);

        // The transparent upper_bound function should be invoked and no constructor of TrackConstructorCallsElement should be invoked
        foundIt = container.upper_bound(278);
        // The ConstructorCount should still be the same
        EXPECT_EQ(1, TreeContainerTransparentTestInternal::s_allConstructorCount);
        EXPECT_NE(container.end(), foundIt);

        // In the case when the element isn't found, no constructor shouldn't be invoked as well
        foundIt = container.upper_bound(1000);
        EXPECT_EQ(1, TreeContainerTransparentTestInternal::s_allConstructorCount);
        EXPECT_EQ(container.end(), foundIt);

        // No assignments should have taken place from any of the container operations
        EXPECT_EQ(0, TreeContainerTransparentTestInternal::s_allAssignmentCount);
    }

    TYPED_TEST(TreeContainerTransparentFixture, EqualRangeDoesNotConstructKeyForTransparentHashEqual_NoKeyConstructed_Succeeds)
    {
        typename TypeParam::ContainerType container;
        container.emplace(-2352);
        container.emplace(3534);
        container.emplace(1535408957);
        container.emplace(3310556522);
        container.emplace(55546193);
        container.emplace(1582);

        // Reset constructor count to zero
        TreeContainerTransparentTestInternal::s_allConstructorCount = 0;

        // The following call will construct a TrackConstructorCalls element
        auto foundRange = container.equal_range(TreeContainerTransparentTestInternal::TrackConstructorCalls{ -2352 });
        EXPECT_EQ(1, TreeContainerTransparentTestInternal::s_allConstructorCount);
        EXPECT_NE(foundRange.first, foundRange.second);

        // The transparent upper_bound function should be invoked and no constructor of TrackConstructorCallsElement should be invoked
        foundRange = container.equal_range(55546193);
        // The ConstructorCount should still be the same
        EXPECT_EQ(1, TreeContainerTransparentTestInternal::s_allConstructorCount);
        EXPECT_NE(foundRange.first, foundRange.second);

        // In the case when the element isn't found, no constructor shouldn't be invoked as well
        foundRange = container.equal_range(0x9034);
        EXPECT_EQ(1, TreeContainerTransparentTestInternal::s_allConstructorCount);
        EXPECT_EQ(foundRange.first, foundRange.second);

        // No assignments should have taken place from any of the container operations
        EXPECT_EQ(0, TreeContainerTransparentTestInternal::s_allAssignmentCount);
    }
}
",16233,True,2877.5925910792307,median
"[[jpa.repositories]]
= JPA Repositories

This chapter points out the specialties for repository support for JPA. This builds on the core repository support explained in ""`<<repositories>>`"". Make sure you have a sound understanding of the basic concepts explained there.

[[jpa.introduction]]
== Introduction

This section describes the basics of configuring Spring Data JPA through either:

* ""`<<jpa.namespace>>`"" (XML configuration)
* ""`<<jpa.java-config>>`"" (Java configuration)

[[jpa.namespace]]
=== Spring Namespace

The JPA module of Spring Data contains a custom namespace that allows defining repository beans. It also contains certain features and element attributes that are special to JPA. Generally, the JPA repositories can be set up by   using the `repositories` element, as shown in the following example:

.Setting up JPA repositories by using the namespace
====
[source, xml]
----
<?xml version=""1.0"" encoding=""UTF-8""?>
<beans xmlns=""http://www.springframework.org/schema/beans""
  xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance""
  xmlns:jpa=""http://www.springframework.org/schema/data/jpa""
  xsi:schemaLocation=""http://www.springframework.org/schema/beans
    https://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/data/jpa
    https://www.springframework.org/schema/data/jpa/spring-jpa.xsd"">

  <jpa:repositories base-package=""com.acme.repositories"" />

</beans>
----
====

Using the `repositories` element looks up Spring Data repositories as described in ""`<<repositories.create-instances>>`"". Beyond that, it activates persistence exception translation for all beans annotated with `@Repository`, to let exceptions being thrown by the JPA persistence providers be converted into Spring's `DataAccessException` hierarchy.

[[jpa.namespace.custom-namespace-attributes]]
==== Custom Namespace Attributes
Beyond the default attributes of the `repositories` element, the JPA namespace offers additional attributes to let you gain more detailed control over the setup of the repositories:

.Custom JPA-specific attributes of the `repositories` element
[options = ""autowidth""]
|===============
|`entity-manager-factory-ref`|Explicitly wire the `EntityManagerFactory` to be used with the repositories being detected by the `repositories` element. Usually used if multiple `EntityManagerFactory` beans are used within the application. If not configured, Spring Data automatically looks up the `EntityManagerFactory` bean with the name `entityManagerFactory` in the `ApplicationContext`.
|`transaction-manager-ref`|Explicitly wire the `PlatformTransactionManager` to be used with the repositories being detected by the `repositories` element. Usually only necessary if multiple transaction managers or `EntityManagerFactory` beans have been configured. Default to a single defined `PlatformTransactionManager` inside the current `ApplicationContext`.
|===============

NOTE: Spring Data JPA requires a `PlatformTransactionManager` bean named `transactionManager` to be present if no explicit `transaction-manager-ref` is defined.

[[jpa.java-config]]
=== Annotation-based Configuration
The Spring Data JPA repositories support can be activated not only through an XML namespace but also by using an annotation through JavaConfig, as shown in the following example:

.Spring Data JPA repositories using JavaConfig
====
[source, java]
----
@Configuration
@EnableJpaRepositories
@EnableTransactionManagement
class ApplicationConfig {

  @Bean
  public DataSource dataSource() {

    EmbeddedDatabaseBuilder builder = new EmbeddedDatabaseBuilder();
    return builder.setType(EmbeddedDatabaseType.HSQL).build();
  }

  @Bean
  public LocalContainerEntityManagerFactoryBean entityManagerFactory() {

    HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
    vendorAdapter.setGenerateDdl(true);

    LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
    factory.setJpaVendorAdapter(vendorAdapter);
    factory.setPackagesToScan(""com.acme.domain"");
    factory.setDataSource(dataSource());
    return factory;
  }

  @Bean
  public PlatformTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) {

    JpaTransactionManager txManager = new JpaTransactionManager();
    txManager.setEntityManagerFactory(entityManagerFactory);
    return txManager;
  }
}
----
====
NOTE: You must create `LocalContainerEntityManagerFactoryBean` and not `EntityManagerFactory` directly, since the former also participates in exception translation mechanisms in addition to creating `EntityManagerFactory`.

The preceding configuration class sets up an embedded HSQL database by using the `EmbeddedDatabaseBuilder` API of `spring-jdbc`. Spring Data then sets up an `EntityManagerFactory` and uses Hibernate as the sample persistence provider. The last infrastructure component declared here is the `JpaTransactionManager`. Finally, the example activates Spring Data JPA repositories by using the `@EnableJpaRepositories` annotation, which essentially carries the same attributes as the XML namespace. If no base package is configured, it uses the one in which the configuration class resides.

[[jpa.bootstrap-mode]]
=== Bootstrap Mode

By default, Spring Data JPA repositories are default Spring beans.
They are singleton scoped and eagerly initialized.
During startup, they already interact with the JPA `EntityManager` for verification and metadata analysis purposes.
Spring Framework supports the initialization of the JPA `EntityManagerFactory` in a background thread because that process usually takes up a significant amount of startup time in a Spring application.
To make use of that background initialization effectively, we need to make sure that JPA repositories are initialized as late as possible.

As of Spring Data JPA 2.1 you can now configure a `BootstrapMode` (either via the `@EnableJpaRepositories` annotation or the XML namespace) that takes the following values:

* `DEFAULT` (default) -- Repositories are instantiated eagerly unless explicitly annotated with `@Lazy`.
The lazification only has effect if no client bean needs an instance of the repository as that will require the initialization of the repository bean.
* `LAZY` -- Implicitly declares all repository beans lazy and also causes lazy initialization proxies to be created to be injected into client beans.
That means, that repositories will not get instantiated if the client bean is simply storing the instance in a field and not making use of the repository during initialization.
Repository instances will be initialized and verified upon first interaction with the repository.
* `DEFERRED` -- Fundamentally the same mode of operation as `LAZY`, but triggering repository initialization in response to an `ContextRefreshedEvent` so that repositories are verified before the application has completely started.

[[jpa.bootstrap-mode.recommendations]]
==== Recommendations

If you're not using asynchronous JPA bootstrap stick with the default bootstrap mode.

In case you bootstrap JPA asynchronously, `DEFERRED` is a reasonable default as it will make sure the Spring Data JPA bootstrap only waits for the `EntityManagerFactory` setup if that itself takes longer than initializing all other application components.
Still, it makes sure that repositories are properly initialized and validated before the application signals it's up.

`LAZY` is a decent choice for testing scenarios and local development.
Once you are pretty sure that repositories can properly bootstrap, or in cases where you are testing other parts of the application, running verification for all repositories might unnecessarily increase the startup time.
The same applies to local development in which you only access parts of the application that might need to have a single repository initialized.

[[jpa.entity-persistence]]
== Persisting Entities

This section describes how to persist (save) entities with Spring Data JPA.

[[jpa.entity-persistence.saving-entites]]
=== Saving Entities

Saving an entity can be performed with the `CrudRepository.save(…)` method. It persists or merges the given entity by using the underlying JPA `EntityManager`. If the entity has not yet been persisted, Spring Data JPA saves the entity with a call to the `entityManager.persist(…)` method. Otherwise, it calls the `entityManager.merge(…)` method.

[[jpa.entity-persistence.saving-entites.strategies]]
==== Entity State-detection Strategies
Spring Data JPA offers the following strategies to detect whether an entity is new or not:

1. Version-Property and Id-Property inspection (*default*):
   By default Spring Data JPA inspects first if there is a Version-property of non-primitive type.
   If there is, the entity is considered new if the value of that property is `null`.
   Without such a Version-property Spring Data JPA inspects the identifier property of the given entity.
   If the identifier property is `null`, then the entity is assumed to be new.
   Otherwise, it is assumed to be not new.
2. Implementing `Persistable`: If an entity implements `Persistable`, Spring Data JPA delegates the new detection to the `isNew(…)` method of the entity. See the link:$$https://docs.spring.io/spring-data/data-commons/docs/current/api/index.html?org/springframework/data/domain/Persistable.html$$[JavaDoc] for details.
3. Implementing `EntityInformation`: You can customize the `EntityInformation` abstraction used in the `SimpleJpaRepository` implementation by creating a subclass of `JpaRepositoryFactory` and overriding the `getEntityInformation(…)` method accordingly. You then have to register the custom implementation of `JpaRepositoryFactory` as a Spring bean. Note that this should be rarely necessary. See the link:$$https://docs.spring.io/spring-data/data-jpa/docs/current/api/index.html?org/springframework/data/jpa/repository/support/JpaRepositoryFactory.html$$[JavaDoc] for details.

Option 1 is not an option for entities that use manually assigned identifiers and no version attribute as with those the identifier will always be non-`null`.
A common pattern in that scenario is to use a common base class with a transient flag defaulting to indicate a new instance and using JPA lifecycle callbacks to flip that flag on persistence operations:

.A base class for entities with manually assigned identifiers
====
[source, java]
----
@MappedSuperclass
public abstract class AbstractEntity<ID> implements Persistable<ID> {

  @Transient
  private boolean isNew = true; <1>

  @Override
  public boolean isNew() {
    return isNew; <2>
  }

  @PrePersist <3>
  @PostLoad
  void markNotNew() {
    this.isNew = false;
  }

  // More code…
}
----
<1> Declare a flag to hold the new state. Transient so that it's not persisted to the database.
<2> Return the flag in the implementation of `Persistable.isNew()` so that Spring Data repositories know whether to call `EntityManager.persist()` or `….merge()`.
<3> Declare a method using JPA entity callbacks so that the flag is switched to indicate an existing entity after a repository call to `save(…)` or an instance creation by the persistence provider.
====

[[jpa.query-methods]]
== Query Methods

This section describes the various ways to create a query with Spring Data JPA.

[[jpa.sample-app.finders.strategies]]
=== Query Lookup Strategies

The JPA module supports defining a query manually as a String or having it being derived from the method name.

Derived queries with the predicates `IsStartingWith`, `StartingWith`, `StartsWith`, `IsEndingWith`, `EndingWith`, `EndsWith`,
`IsNotContaining`, `NotContaining`, `NotContains`, `IsContaining`, `Containing`, `Contains` the respective arguments for these queries will get sanitized.
This means if the arguments actually contain characters recognized by `LIKE` as wildcards these will get escaped so they match only as literals.
The escape character used can be configured by setting the `escapeCharacter` of the `@EnableJpaRepositories` annotation.
Compare with <<jpa.query.spel-expressions>>.

[[jpa.query-methods.declared-queries]]
==== Declared Queries
Although getting a query derived from the method name is quite convenient, one might face the situation in which either the method name parser does not support the keyword one wants to use or the method name would get unnecessarily ugly. So you can either use JPA named queries through a naming convention (see <<jpa.query-methods.named-queries>> for more information) or rather annotate your query method with `@Query` (see <<jpa.query-methods.at-query>> for details).

[[jpa.query-methods.query-creation]]
=== Query Creation

Generally, the query creation mechanism for JPA works as described in ""`<<repositories.query-methods>>`"". The following example shows what a JPA query method translates into:

.Query creation from method names
====
----
public interface UserRepository extends Repository<User, Long> {

  List<User> findByEmailAddressAndLastname(String emailAddress, String lastname);
}
----
We create a query using the JPA criteria API from this, but, essentially, this translates into the following query: `select u from User u where u.emailAddress = ?1 and u.lastname = ?2`. Spring Data JPA does a property check and traverses nested properties, as described in ""`<<repositories.query-methods.query-property-expressions>>`"".
====

The following table describes the keywords supported for JPA and what a method containing that keyword translates to:

.Supported keywords inside method names
[options = ""header, autowidth""]
|===============
|Keyword|Sample|JPQL snippet
|`Distinct`|`findDistinctByLastnameAndFirstname`|`select distinct ... where x.lastname = ?1 and x.firstname = ?2`
|`And`|`findByLastnameAndFirstname`|`… where x.lastname = ?1 and x.firstname = ?2`
|`Or`|`findByLastnameOrFirstname`|`… where x.lastname = ?1 or x.firstname = ?2`
|`Is`, `Equals`|`findByFirstname`,`findByFirstnameIs`,`findByFirstnameEquals`|`… where x.firstname = ?1`
|`Between`|`findByStartDateBetween`|`… where x.startDate between ?1 and ?2`
|`LessThan`|`findByAgeLessThan`|`… where x.age < ?1`
|`LessThanEqual`|`findByAgeLessThanEqual`|`… where x.age \\<= ?1`
|`GreaterThan`|`findByAgeGreaterThan`|`… where x.age > ?1`
|`GreaterThanEqual`|`findByAgeGreaterThanEqual`|`… where x.age >= ?1`
|`After`|`findByStartDateAfter`|`… where x.startDate > ?1`
|`Before`|`findByStartDateBefore`|`… where x.startDate < ?1`
|`IsNull`, `Null`|`findByAge(Is)Null`|`… where x.age is null`
|`IsNotNull`, `NotNull`|`findByAge(Is)NotNull`|`… where x.age not null`
|`Like`|`findByFirstnameLike`|`… where x.firstname like ?1`
|`NotLike`|`findByFirstnameNotLike`|`… where x.firstname not like ?1`
|`StartingWith`|`findByFirstnameStartingWith`|`… where x.firstname like ?1` (parameter bound with appended `%`)
|`EndingWith`|`findByFirstnameEndingWith`|`… where x.firstname like ?1` (parameter bound with prepended `%`)
|`Containing`|`findByFirstnameContaining`|`… where x.firstname like ?1` (parameter bound wrapped in `%`)
|`OrderBy`|`findByAgeOrderByLastnameDesc`|`… where x.age = ?1 order by x.lastname desc`
|`Not`|`findByLastnameNot`|`… where x.lastname <> ?1`
|`In`|`findByAgeIn(Collection<Age> ages)`|`… where x.age in ?1`
|`NotIn`|`findByAgeNotIn(Collection<Age> ages)`|`… where x.age not in ?1`
|`True`|`findByActiveTrue()`|`… where x.active = true`
|`False`|`findByActiveFalse()`|`… where x.active = false`
|`IgnoreCase`|`findByFirstnameIgnoreCase`|`… where UPPER(x.firstname) = UPPER(?1)`
|===============

NOTE: `In` and `NotIn` also take any subclass of `Collection` as a parameter as well as arrays or varargs. For other syntactical versions of the same logical operator, check ""`<<repository-query-keywords>>`"".

[[jpa.query-methods.named-queries]]
=== Using JPA Named Queries

NOTE: The examples use the `<named-query />` element and `@NamedQuery` annotation. The queries for these configuration elements have to be defined in the JPA query language. Of course, you can use `<named-native-query />` or `@NamedNativeQuery` too. These elements let you define the query in native SQL by losing the database platform independence.

[[jpa.query-methods.named-queries.xml-named-query-definition]]
==== XML Named Query Definition
To use XML configuration, add the necessary `<named-query />` element to the `orm.xml` JPA configuration file located in the `META-INF` folder of your classpath. Automatic invocation of named queries is enabled by using some defined naming convention. For more details, see below.

.XML named query configuration
====
[source, xml]
----
<named-query name=""User.findByLastname"">
  <query>select u from User u where u.lastname = ?1</query>
</named-query>
----
====

The query has a special name that is used to resolve it at runtime.

[[jpa.query-methods.named-queries.annotation-based-configuration]]
==== Annotation-based Configuration
Annotation-based configuration has the advantage of not needing another configuration file to be edited, lowering maintenance effort. You pay for that benefit by the need to recompile your domain class for every new query declaration.

.Annotation-based named query configuration
====
[source, java]
----
@Entity
@NamedQuery(name = ""User.findByEmailAddress"",
  query = ""select u from User u where u.emailAddress = ?1"")
public class User {

}
----
====

[[jpa.query-methods.named-queries.declaring-interfaces]]
==== Declaring Interfaces
To allow these named queries, specify the `UserRepository` as follows:

.Query method declaration in UserRepository
====
[source, java]
----
public interface UserRepository extends JpaRepository<User, Long> {

  List<User> findByLastname(String lastname);

  User findByEmailAddress(String emailAddress);
}
----
====

Spring Data tries to resolve a call to these methods to a named query, starting with the simple name of the configured domain class, followed by the method name separated by a dot.
So the preceding example would use the named queries defined earlier instead of trying to create a query from the method name.

[[jpa.query-methods.at-query]]
=== Using `@Query`

Using named queries to declare queries for entities is a valid approach and works fine for a small number of queries. As the queries themselves are tied to the Java method that runs them, you can actually bind them directly by using the Spring Data JPA `@Query` annotation rather than annotating them to the domain class. This frees the domain class from persistence specific information and co-locates the query to the repository interface.

Queries annotated to the query method take precedence over queries defined using `@NamedQuery` or named queries declared in `orm.xml`.

The following example shows a query created with the `@Query` annotation:

.Declare query at the query method using `@Query`
====
[source, java]
----
public interface UserRepository extends JpaRepository<User, Long> {

  @Query(""select u from User u where u.emailAddress = ?1"")
  User findByEmailAddress(String emailAddress);
}
----
====

[[jpa.query-methods.at-query.advanced-like]]
==== Using Advanced `LIKE` Expressions

The query running mechanism for manually defined queries created with `@Query` allows the definition of advanced `LIKE` expressions inside the query definition, as shown in the following example:

.Advanced `like` expressions in @Query
====
[source, java]
----
public interface UserRepository extends JpaRepository<User, Long> {

  @Query(""select u from User u where u.firstname like %?1"")
  List<User> findByFirstnameEndsWith(String firstname);
}
----
====

In the preceding example, the `LIKE` delimiter character (`%`) is recognized, and the query is transformed into a valid JPQL query (removing the `%`). Upon running the query, the parameter passed to the method call gets augmented with the previously recognized `LIKE` pattern.

[[jpa.query-methods.at-query.native]]
==== Native Queries

The `@Query` annotation allows for running native queries by setting the `nativeQuery` flag to true, as shown in the following example:

.Declare a native query at the query method using @Query
====
[source, java]
----
public interface UserRepository extends JpaRepository<User, Long> {

  @Query(value = ""SELECT * FROM USERS WHERE EMAIL_ADDRESS = ?1"", nativeQuery = true)
  User findByEmailAddress(String emailAddress);
}
----

====

NOTE: Spring Data JPA does not currently support dynamic sorting for native queries, because it would have to manipulate the actual query declared, which it cannot do reliably for native SQL. You can, however, use native queries for pagination by specifying the count query yourself, as shown in the following example:

.Declare native count queries for pagination at the query method by using `@Query`
====
[source, java]
----
public interface UserRepository extends JpaRepository<User, Long> {

  @Query(value = ""SELECT * FROM USERS WHERE LASTNAME = ?1"",
    countQuery = ""SELECT count(*) FROM USERS WHERE LASTNAME = ?1"",
    nativeQuery = true)
  Page<User> findByLastname(String lastname, Pageable pageable);
}
----

====

A similar approach also works with named native queries, by adding the `.count` suffix to a copy of your query. You probably need to register a result set mapping for your count query, though.

[[jpa.query-methods.sorting]]
=== Using Sort

Sorting can be done by either providing a `PageRequest` or by using `Sort` directly. The properties actually used within the `Order` instances of `Sort` need to match your domain model, which means they need to resolve to either a property or an alias used within the query. The JPQL defines this as a state field path expression.

NOTE: Using any non-referenceable path expression leads to an `Exception`.

However, using `Sort` together with <<jpa.query-methods.at-query, `@Query`>> lets you sneak in non-path-checked `Order` instances containing functions within the `ORDER BY` clause. This is possible because the `Order` is appended to the given query string. By default, Spring Data JPA rejects any `Order` instance containing function calls, but you can use `JpaSort.unsafe` to add potentially unsafe ordering.

The following example uses `Sort` and `JpaSort`, including an unsafe option on `JpaSort`:

.Using `Sort` and `JpaSort`
====
[source, java]
----
public interface UserRepository extends JpaRepository<User, Long> {

  @Query(""select u from User u where u.lastname like ?1%"")
  List<User> findByAndSort(String lastname, Sort sort);

  @Query(""select u.id, LENGTH(u.firstname) as fn_len from User u where u.lastname like ?1%"")
  List<Object[]> findByAsArrayAndSort(String lastname, Sort sort);
}

repo.findByAndSort(""lannister"", Sort.by(""firstname""));                <1>
repo.findByAndSort(""stark"", Sort.by(""LENGTH(firstname)""));            <2>
repo.findByAndSort(""targaryen"", JpaSort.unsafe(""LENGTH(firstname)"")); <3>
repo.findByAsArrayAndSort(""bolton"", Sort.by(""fn_len""));               <4>
----
<1> Valid `Sort` expression pointing to property in domain model.
<2> Invalid `Sort` containing function call. Throws Exception.
<3> Valid `Sort` containing explicitly _unsafe_ `Order`.
<4> Valid `Sort` expression pointing to aliased function.
====

[[jpa.named-parameters]]
=== Using Named Parameters

By default, Spring Data JPA uses position-based parameter binding, as described in all the preceding examples. This makes query methods a little error-prone when refactoring regarding the parameter position. To solve this issue, you can use `@Param` annotation to give a method parameter a concrete name and bind the name in the query, as shown in the following example:

.Using named parameters
====
[source, java]
----
public interface UserRepository extends JpaRepository<User, Long> {

  @Query(""select u from User u where u.firstname = :firstname or u.lastname = :lastname"")
  User findByLastnameOrFirstname(@Param(""lastname"") String lastname,
                                 @Param(""firstname"") String firstname);
}
----
====

NOTE: The method parameters are switched according to their order in the defined query.

NOTE: As of version 4, Spring fully supports Java 8’s parameter name discovery based on the `-parameters` compiler flag. By using this flag in your build as an alternative to debug information, you can omit the `@Param` annotation for named parameters.

[[jpa.query.spel-expressions]]
=== Using SpEL Expressions

As of Spring Data JPA release 1.4, we support the usage of restricted SpEL template expressions in manually defined queries that are defined with `@Query`. Upon the query being run, these expressions are evaluated against a predefined set of variables. Spring Data JPA supports a variable called `entityName`. Its usage is `select x from #{#entityName} x`. It inserts the `entityName` of the domain type associated with the given repository. The `entityName` is resolved as follows: If the domain type has set the name property on the `@Entity` annotation, it is used. Otherwise, the simple class-name of the domain type is used.

The following example demonstrates one use case for the `+#{#entityName}+` expression in a query string where you want to define a repository interface with a query method and a manually defined query:

.Using SpEL expressions in repository query methods - entityName
====
[source, java]
----
@Entity
public class User {

  @Id
  @GeneratedValue
  Long id;

  String lastname;
}

public interface UserRepository extends JpaRepository<User,Long> {

  @Query(""select u from #{#entityName} u where u.lastname = ?1"")
  List<User> findByLastname(String lastname);
}
----
====

To avoid stating the actual entity name in the query string of a `@Query` annotation, you can use the `+#{#entityName}+` variable.

NOTE: The `entityName` can be customized by using the `@Entity` annotation. Customizations in `orm.xml` are not supported for the SpEL expressions.

Of course, you could have just used `User` in the query declaration directly, but that would require you to change the query as well. The reference to `#entityName` picks up potential future remappings of the `User` class to a different entity name (for example, by using `@Entity(name = ""MyUser"")`.

Another use case for the `#{#entityName}` expression in a query string is if you want to define a generic repository interface with specialized repository interfaces for a concrete domain type. To not repeat the definition of custom query methods on the concrete interfaces, you can use the entity name expression in the query string of the `@Query` annotation in the generic repository interface, as shown in the following example:

.Using SpEL expressions in repository query methods - entityName with inheritance
====
[source, java]
----
@MappedSuperclass
public abstract class AbstractMappedType {
  …
  String attribute
}

@Entity
public class ConcreteType extends AbstractMappedType { … }

@NoRepositoryBean
public interface MappedTypeRepository<T extends AbstractMappedType>
  extends Repository<T, Long> {

  @Query(""select t from #{#entityName} t where t.attribute = ?1"")
  List<T> findAllByAttribute(String attribute);
}

public interface ConcreteRepository
  extends MappedTypeRepository<ConcreteType> { … }
----
====

In the preceding example, the `MappedTypeRepository` interface is the common parent interface for a few domain types extending `AbstractMappedType`. It also defines the generic `findAllByAttribute(…)` method, which can be used on instances of the specialized repository interfaces. If you now invoke `findByAllAttribute(…)` on `ConcreteRepository`, the query becomes `select t from ConcreteType t where t.attribute = ?1`.

SpEL expressions to manipulate arguments may also be used to manipulate method arguments.
In these SpEL expressions the entity name is not available, but the arguments are.
They can be accessed by name or index as demonstrated in the following example.

.Using SpEL expressions in repository query methods - accessing arguments.
====
[source, java]
----
@Query(""select u from User u where u.firstname = ?1 and u.firstname=?#{[0]} and u.emailAddress = ?#{principal.emailAddress}"")
List<User> findByFirstnameAndCurrentUserWithCustomQuery(String firstname);
----
====

For `like`-conditions one often wants to append `%` to the beginning or the end of a String valued parameter.
This can be done by appending or prefixing a bind parameter marker or a SpEL expression with `%`.
Again the following example demonstrates this.

.Using SpEL expressions in repository query methods - wildcard shortcut.
====
[source, java]
----
@Query(""select u from User u where u.lastname like %:#{[0]}% and u.lastname like %:lastname%"")
List<User> findByLastnameWithSpelExpression(@Param(""lastname"") String lastname);
----
====

When using `like`-conditions with values that are coming from a not secure source the values should be sanitized so they can't contain any wildcards and thereby allow attackers to select more data than they should be able to.
For this purpose the `escape(String)` method is made available in the SpEL context.
It prefixes all instances of `_` and `%` in the first argument with the single character from the second argument.
In combination with the `escape` clause of the `like` expression available in JPQL and standard SQL this allows easy cleaning of bind parameters.


.Using SpEL expressions in repository query methods - sanitizing input values.
====
[source, java]
----
@Query(""select u from User u where u.firstname like %?#{escape([0])}% escape ?#{escapeCharacter()}"")
List<User> findContainingEscaped(String namePart);
----
====

Given this method declaration in a repository interface `findContainingEscaped(""Peter_"")` will find `Peter_Parker` but not `Peter Parker`.
The escape character used can be configured by setting the `escapeCharacter` of the `@EnableJpaRepositories` annotation.
Note that the method `escape(String)` available in the SpEL context will only escape the SQL and JPQL standard wildcards `_` and `%`.
If the underlying database or the JPA implementation supports additional wildcards these will not get escaped.

[[jpa.modifying-queries]]
=== Modifying Queries

All the previous sections describe how to declare queries to access a given entity or collection of entities.
You can add custom modifying behavior by using the custom method facilities described in ""`<<repositories.custom-implementations>>`"".
As this approach is feasible for comprehensive custom functionality, you can modify queries that only need parameter binding by annotating the query method with `@Modifying`, as shown in the following example:

.Declaring manipulating queries
====
[source, java]
----
@Modifying
@Query(""update User u set u.firstname = ?1 where u.lastname = ?2"")
int setFixedFirstnameFor(String firstname, String lastname);
----
====

Doing so triggers the query annotated to the method as an updating query instead of a selecting one. As the `EntityManager` might contain outdated entities after the execution of the modifying query, we do not automatically clear it (see the https://docs.oracle.com/javaee/7/api/javax/persistence/EntityManager.html[JavaDoc] of `EntityManager.clear()` for details), since this effectively drops all non-flushed changes still pending in the `EntityManager`.
If you wish the `EntityManager` to be cleared automatically, you can set the `@Modifying` annotation's `clearAutomatically` attribute to `true`.

The `@Modifying` annotation is only relevant in combination with the `@Query` annotation.
Derived query methods or custom methods do not require this annotation.

[[jpa.modifying-queries.derived-delete]]
==== Derived Delete Queries
Spring Data JPA also supports derived delete queries that let you avoid having to declare the JPQL query explicitly, as shown in the following example:

.Using a derived delete query
====
[source, java]
----
interface UserRepository extends Repository<User, Long> {

  void deleteByRoleId(long roleId);

  @Modifying
  @Query(""delete from User u where u.role.id = ?1"")
  void deleteInBulkByRoleId(long roleId);
}
----
====

Although the `deleteByRoleId(…)` method looks like it basically produces the same result as the `deleteInBulkByRoleId(…)`, there is an important difference between the two method declarations in terms of the way they are run.
As the name suggests, the latter method issues a single JPQL query (the one defined in the annotation) against the database.
This means even currently loaded instances of `User` do not see lifecycle callbacks invoked.

To make sure lifecycle queries are actually invoked, an invocation of `deleteByRoleId(…)` runs a query and then deletes the returned instances one by one, so that the persistence provider can actually invoke `@PreRemove` callbacks on those entities.

In fact, a derived delete query is a shortcut for running the query and then calling `CrudRepository.delete(Iterable<User> users)` on the result and keeping behavior in sync with the implementations of other `delete(…)` methods in `CrudRepository`.

[[jpa.query-hints]]
=== Applying Query Hints
To apply JPA query hints to the queries declared in your repository interface, you can use the `@QueryHints` annotation. It takes an array of JPA `@QueryHint` annotations plus a boolean flag to potentially disable the hints applied to the additional count query triggered when applying pagination, as shown in the following example:

.Using QueryHints with a repository method
====
[source, java]
----
public interface UserRepository extends Repository<User, Long> {

  @QueryHints(value = { @QueryHint(name = ""name"", value = ""value"")},
              forCounting = false)
  Page<User> findByLastname(String lastname, Pageable pageable);
}
----
====
The preceding declaration would apply the configured `@QueryHint` for that actually query but omit applying it to the count query triggered to calculate the total number of pages.

[[jpa.entity-graph]]
=== Configuring Fetch- and LoadGraphs

The JPA 2.1 specification introduced support for specifying Fetch- and LoadGraphs that we also support with the `@EntityGraph` annotation, which lets you reference a `@NamedEntityGraph` definition. You can use that annotation on an entity to configure the fetch plan of the resulting query. The type (`Fetch` or `Load`) of the fetching can be configured by using the `type` attribute on the `@EntityGraph` annotation. See the JPA 2.1 Spec 3.7.4 for further reference.

The following example shows how to define a named entity graph on an entity:

.Defining a named entity graph on an entity.
====
[source, java]
----
@Entity
@NamedEntityGraph(name = ""GroupInfo.detail"",
  attributeNodes = @NamedAttributeNode(""members""))
public class GroupInfo {

  // default fetch mode is lazy.
  @ManyToMany
  List<GroupMember> members = new ArrayList<GroupMember>();

  …
}
----
====

The following example shows how to reference a named entity graph on a repository query method:

.Referencing a named entity graph definition on a repository query method.
====
[source, java]
----
public interface GroupRepository extends CrudRepository<GroupInfo, String> {

  @EntityGraph(value = ""GroupInfo.detail"", type = EntityGraphType.LOAD)
  GroupInfo getByGroupName(String name);

}
----
====

It is also possible to define ad hoc entity graphs by using `@EntityGraph`. The provided `attributePaths` are translated into the according `EntityGraph` without needing to explicitly add `@NamedEntityGraph` to your domain types, as shown in the following example:

.Using AD-HOC entity graph definition on an repository query method.
====
[source, java]
----
public interface GroupRepository extends CrudRepository<GroupInfo, String> {

  @EntityGraph(attributePaths = { ""members"" })
  GroupInfo getByGroupName(String name);

}
----
====

:repository-projections-trailing-dto-fragment: ../../../../spring-data-jpa/src/main/asciidoc/repository-projections-dto-limitations.adoc

include::{spring-data-commons-docs}/repository-projections.adoc[leveloffset=+2]

[[jpa.stored-procedures]]
== Stored Procedures
The JPA 2.1 specification introduced support for calling stored procedures by using the JPA criteria query API.
We Introduced the `@Procedure` annotation for declaring stored procedure metadata on a repository method.

The examples to follow use the following stored procedure:

.The definition of the `plus1inout` procedure in HSQL DB.
====
[source, sql]
----
/;
DROP procedure IF EXISTS plus1inout
/;
CREATE procedure plus1inout (IN arg int, OUT res int)
BEGIN ATOMIC
 set res = arg + 1;
END
/;
----
====

Metadata for stored procedures can be configured by using the `NamedStoredProcedureQuery` annotation on an entity type.

[[jpa.stored-procedure-entity-metadata]]
.StoredProcedure metadata definitions on an entity.
====
[source, java]
----
@Entity
@NamedStoredProcedureQuery(name = ""User.plus1"", procedureName = ""plus1inout"", parameters = {
  @StoredProcedureParameter(mode = ParameterMode.IN, name = ""arg"", type = Integer.class),
  @StoredProcedureParameter(mode = ParameterMode.OUT, name = ""res"", type = Integer.class) })
public class User {}
----
====

Note that `@NamedStoredProcedureQuery` has two different names for the stored procedure.
`name` is the name JPA uses. `procedureName` is the name the stored procedure has in the database.

You can reference stored procedures from a repository method in multiple ways.
The stored procedure to be called can either be defined directly by using the `value` or `procedureName` attribute of the `@Procedure` annotation.
This refers directly to the stored procedure in the database and ignores any configuration via `@NamedStoredProcedureQuery`.

Alternatively you may specify the `@NamedStoredProcedureQuery.name` attribute as the `@Procedure.name` attribute.
If neither `value`, `procedureName` nor `name` is configured, the name of the repository method is used as the `name` attribute.

The following example shows how to reference an explicitly mapped procedure:

[[jpa.stored-procedure-reference]]
.Referencing explicitly mapped procedure with name ""plus1inout"" in database.
====
[source, java]
----
@Procedure(""plus1inout"")
Integer explicitlyNamedPlus1inout(Integer arg);
----
====

The following example is equivalent to the previous one but uses the `procedureName` alias:

.Referencing implicitly mapped procedure with name ""plus1inout"" in database via `procedureName` alias.
====
[source, java]
----
@Procedure(procedureName = ""plus1inout"")
Integer callPlus1InOut(Integer arg);
----
====

The following is again equivalent to the previous two but using the method name instead of an explicite annotation attribute.

.Referencing implicitly mapped named stored procedure ""User.plus1"" in `EntityManager` by using the method name.
====
[source, java]
----
@Procedure
Integer plus1inout(@Param(""arg"") Integer arg);
----
====

The following example shows how to reference a stored procedure by referencing the `@NamedStoredProcedureQuery.name` attribute.

.Referencing explicitly mapped named stored procedure ""User.plus1IO"" in `EntityManager`.
====
[source, java]
----
@Procedure(name = ""User.plus1IO"")
Integer entityAnnotatedCustomNamedProcedurePlus1IO(@Param(""arg"") Integer arg);
----
====

If the stored procedure getting called has a single out parameter that parameter may be returned as the return value of the method.
If there are multiple out parameters specified in a `@NamedStoredProcedureQuery` annotation those can be returned as a `Map` with the key being the parameter name given in the `@NamedStoredProcedureQuery` annotation.


[[specifications]]
== Specifications

JPA 2 introduces a criteria API that you can use to build queries programmatically. By writing a `criteria`, you define the where clause of a query for a domain class. Taking another step back, these criteria can be regarded as a predicate over the entity that is described by the JPA criteria API constraints.

Spring Data JPA takes the concept of a specification from Eric Evans' book, ""`Domain Driven Design`"", following the same semantics and providing an API to define such specifications with the JPA criteria API. To support specifications, you can extend your repository interface with the `JpaSpecificationExecutor` interface, as follows:

[source, java]
----
public interface CustomerRepository extends CrudRepository<Customer, Long>, JpaSpecificationExecutor<Customer> {
 …
}
----

The additional interface has methods that let you run specifications in a variety of ways. For example, the `findAll` method returns all entities that match the specification, as shown in the following example:

[source, java]
----
List<T> findAll(Specification<T> spec);
----

The `Specification` interface is defined as follows:

[source, java]
----
public interface Specification<T> {
  Predicate toPredicate(Root<T> root, CriteriaQuery<?> query,
            CriteriaBuilder builder);
}
----

Specifications can easily be used to build an extensible set of predicates on top of an entity that then can be combined and used with `JpaRepository` without the need to declare a query (method) for every needed combination, as shown in the following example:

.Specifications for a Customer
====
[source, java]
----
public class CustomerSpecs {


  public static Specification<Customer> isLongTermCustomer() {
    return (root, query, builder) -> {
      LocalDate date = LocalDate.now().minusYears(2);
      return builder.lessThan(root.get(Customer_.createdAt), date);
    };
  }

  public static Specification<Customer> hasSalesOfMoreThan(MonetaryAmount value) {
    return (root, query, builder) -> {
      // build query here
    };
  }
}
----
====

The `Customer_` type is a metamodel type generated using the JPA Metamodel generator (see the link:$$https://docs.jboss.org/hibernate/jpamodelgen/1.0/reference/en-US/html_single/#whatisit$$[Hibernate implementation's documentation for an example]).
So the expression, `Customer_.createdAt`, assumes the `Customer` has a `createdAt` attribute of type `Date`.
Besides that, we have expressed some criteria on a business requirement abstraction level and created executable `Specifications`.
So a client might use a `Specification` as follows:

.Using a simple Specification
====
[source, java]
----
List<Customer> customers = customerRepository.findAll(isLongTermCustomer());
----
====

Why not create a query for this kind of data access? Using a single `Specification` does not gain a lot of benefit over a plain query declaration. The power of specifications really shines when you combine them to create new `Specification` objects. You can achieve this through the default methods of `Specification` we provide to build expressions similar to the following:

.Combined Specifications
====
[source, java]
----
MonetaryAmount amount = new MonetaryAmount(200.0, Currencies.DOLLAR);
List<Customer> customers = customerRepository.findAll(
  isLongTermCustomer().or(hasSalesOfMoreThan(amount)));
----

`Specification` offers some ""`glue-code`"" default methods to chain and combine `Specification` instances. These methods let you extend your data access layer by creating new `Specification` implementations and combining them with already existing implementations.
====

include::{spring-data-commons-docs}/query-by-example.adoc[leveloffset=+1]
include::query-by-example.adoc[leveloffset=+1]

[[transactions]]
== Transactionality

By default, CRUD methods on repository instances inherited from link:$$https://docs.spring.io/spring-data/data-jpa/docs/current/api/org/springframework/data/jpa/repository/support/SimpleJpaRepository.html$$[`SimpleJpaRepository`] are transactional.
For read operations, the transaction configuration `readOnly` flag is set to `true`.
All others are configured with a plain `@Transactional` so that default transaction configuration applies.
Repository methods that are backed by transactional repository fragments inherit the transactional attributes from the actual fragment method.

If you need to tweak transaction configuration for one of the methods declared in a repository, redeclare the method in your repository interface, as follows:

.Custom transaction configuration for CRUD
====
[source, java]
----
public interface UserRepository extends CrudRepository<User, Long> {

  @Override
  @Transactional(timeout = 10)
  public List<User> findAll();

  // Further query method declarations
}
----
Doing so causes the `findAll()` method to run with a timeout of 10 seconds and without the `readOnly` flag.
====

Another way to alter transactional behaviour is to use a facade or service implementation that (typically) covers more than one repository. Its purpose is to define transactional boundaries for non-CRUD operations. The following example shows how to use such a facade for more than one repository:

.Using a facade to define transactions for multiple repository calls
====
[source, java]
----
@Service
public class UserManagementImpl implements UserManagement {

  private final UserRepository userRepository;
  private final RoleRepository roleRepository;

  public UserManagementImpl(UserRepository userRepository,
    RoleRepository roleRepository) {
    this.userRepository = userRepository;
    this.roleRepository = roleRepository;
  }

  @Transactional
  public void addRoleToAllUsers(String roleName) {

    Role role = roleRepository.findByName(roleName);

    for (User user : userRepository.findAll()) {
      user.addRole(role);
      userRepository.save(user);
    }
  }
}
----
This example causes call to `addRoleToAllUsers(…)` to run inside a transaction (participating in an existing one or creating a new one if none are already running). The transaction configuration at the repositories is then neglected, as the outer transaction configuration determines the actual one used. Note that you must activate `<tx:annotation-driven />` or use `@EnableTransactionManagement` explicitly to get annotation-based configuration of facades to work.
This example assumes you use component scanning.

Note that the call to `save` is not strictly necessary from a JPA point of view, but should still be there in order to stay consistent to the repository abstraction offered by Spring Data.
====

[[transactional-query-methods]]
=== Transactional query methods

To let your query methods be transactional, use `@Transactional` at the repository interface you define, as shown in the following example:

.Using @Transactional at query methods
====
[source, java]
----
@Transactional(readOnly = true)
interface UserRepository extends JpaRepository<User, Long> {

  List<User> findByLastname(String lastname);

  @Modifying
  @Transactional
  @Query(""delete from User u where u.active = false"")
  void deleteInactiveUsers();
}
----
Typically, you want the `readOnly` flag to be set to `true`, as most of the query methods only read data. In contrast to that, `deleteInactiveUsers()` makes use of the `@Modifying` annotation and overrides the transaction configuration. Thus, the method runs with the `readOnly` flag set to `false`.
====

[NOTE]
====
You can use transactions for read-only queries and mark them as such by setting the `readOnly` flag. Doing so does not, however, act as a check that you do not trigger a manipulating query (although some databases reject `INSERT` and `UPDATE` statements inside a read-only transaction). The `readOnly` flag is instead propagated as a hint to the underlying JDBC driver for performance optimizations. Furthermore, Spring performs some optimizations on the underlying JPA provider. For example, when used with Hibernate, the flush mode is set to `NEVER` when you configure a transaction as `readOnly`, which causes Hibernate to skip dirty checks (a noticeable improvement on large object trees).
====

[[locking]]
== Locking
To specify the lock mode to be used, you can use the `@Lock` annotation on query methods, as shown in the following example:

.Defining lock metadata on query methods
====
[source, java]
----
interface UserRepository extends Repository<User, Long> {

  // Plain query method
  @Lock(LockModeType.READ)
  List<User> findByLastname(String lastname);
}
----
====

This method declaration causes the query being triggered to be equipped with a `LockModeType` of `READ`. You can also define locking for CRUD methods by redeclaring them in your repository interface and adding the `@Lock` annotation, as shown in the following example:

.Defining lock metadata on CRUD methods
====
[source, java]
----
interface UserRepository extends Repository<User, Long> {

  // Redeclaration of a CRUD method
  @Lock(LockModeType.READ)
  List<User> findAll();
}
----
====

:leveloffset: +1
include::{spring-data-commons-docs}/auditing.adoc[]
:leveloffset: -1

[[jpa.auditing]]
== JPA Auditing

[[jpa.auditing.configuration]]
=== General Auditing Configuration

Spring Data JPA ships with an entity listener that can be used to trigger the capturing of auditing information. First, you must register the `AuditingEntityListener` to be used for all entities in your persistence contexts inside your `orm.xml` file, as shown in the following example:

.Auditing configuration orm.xml
====
[source, xml]
----
<persistence-unit-metadata>
  <persistence-unit-defaults>
    <entity-listeners>
      <entity-listener class=""….data.jpa.domain.support.AuditingEntityListener"" />
    </entity-listeners>
  </persistence-unit-defaults>
</persistence-unit-metadata>
----
====

You can also enable the `AuditingEntityListener` on a per-entity basis by using the `@EntityListeners` annotation, as follows:

====
[source, java]
----
@Entity
@EntityListeners(AuditingEntityListener.class)
public class MyEntity {

}
----
====

NOTE: The auditing feature requires `spring-aspects.jar` to be on the classpath.

With `orm.xml` suitably modified and `spring-aspects.jar` on the classpath, activating auditing functionality is a matter of adding the Spring Data JPA `auditing` namespace element to your configuration, as follows:

.Activating auditing using XML configuration
====
[source, xml]
----
<jpa:auditing auditor-aware-ref=""yourAuditorAwareBean"" />
----
====

As of Spring Data JPA 1.5, you can enable auditing by annotating a configuration class with the `@EnableJpaAuditing` annotation. You must still modify the `orm.xml` file and have `spring-aspects.jar` on the classpath. The following example shows how to use the `@EnableJpaAuditing` annotation:

.Activating auditing with Java configuration
====
[source, java]
----
@Configuration
@EnableJpaAuditing
class Config {

  @Bean
  public AuditorAware<AuditableUser> auditorProvider() {
    return new AuditorAwareImpl();
  }
}
----
====

If you expose a bean of type `AuditorAware` to the `ApplicationContext`, the auditing infrastructure automatically picks it up and uses it to determine the current user to be set on domain types. If you have multiple implementations registered in the `ApplicationContext`, you can select the one to be used by explicitly setting the `auditorAwareRef` attribute of `@EnableJpaAuditing`.

[[jpa.misc]]
= Miscellaneous Considerations

[[jpa.misc.jpa-context]]
== Using `JpaContext` in Custom Implementations

When working with multiple `EntityManager` instances and <<repositories.custom-implementations,custom repository implementations>>, you need to wire the correct `EntityManager` into the repository implementation class. You can do so by explicitly naming the `EntityManager` in the `@PersistenceContext` annotation or, if the `EntityManager` is `@Autowired`, by using `@Qualifier`.

As of Spring Data JPA 1.9, Spring Data JPA includes a class called `JpaContext` that lets you obtain the `EntityManager` by managed domain class, assuming it is managed by only one of the `EntityManager` instances in the application. The following example shows how to use `JpaContext` in a custom repository:

.Using `JpaContext` in a custom repository implementation
====
[source, java]
----
class UserRepositoryImpl implements UserRepositoryCustom {

  private final EntityManager em;

  @Autowired
  public UserRepositoryImpl(JpaContext context) {
    this.em = context.getEntityManagerByManagedType(User.class);
  }

  …
}
----
====

The advantage of this approach is that, if the domain type gets assigned to a different persistence unit, the repository does not have to be touched to alter the reference to the persistence unit.

[[jpa.misc.merging-persistence-units]]
== Merging persistence units

Spring supports having multiple persistence units. Sometimes, however, you might want to modularize your application but still make sure that all these modules run inside a single persistence unit. To enable that behavior, Spring Data JPA offers a `PersistenceUnitManager` implementation that automatically merges persistence units based on their name, as shown in the following example:

.Using MergingPersistenceUnitmanager
====
[source, xml]
----
<bean class=""….LocalContainerEntityManagerFactoryBean"">
  <property name=""persistenceUnitManager"">
    <bean class=""….MergingPersistenceUnitManager"" />
  </property>
</bean>
----
====

[[jpa.misc.entity-scanning]]
=== Classpath Scanning for @Entity Classes and JPA Mapping Files

A plain JPA setup requires all annotation-mapped entity classes to be listed in `orm.xml`. The same applies to XML mapping files. Spring Data JPA provides a `ClasspathScanningPersistenceUnitPostProcessor` that gets a base package configured and optionally takes a mapping filename pattern. It then scans the given package for classes annotated with `@Entity` or `@MappedSuperclass`, loads the configuration files that match the filename pattern, and hands them to the JPA configuration. The post-processor must be configured as follows:

.Using ClasspathScanningPersistenceUnitPostProcessor
====
[source, xml]
----
<bean class=""….LocalContainerEntityManagerFactoryBean"">
  <property name=""persistenceUnitPostProcessors"">
    <list>
      <bean class=""org.springframework.data.jpa.support.ClasspathScanningPersistenceUnitPostProcessor"">
        <constructor-arg value=""com.acme.domain"" />
        <property name=""mappingFileNamePattern"" value=""**/*Mapping.xml"" />
      </bean>
    </list>
  </property>
</bean>
----
====

NOTE: As of Spring 3.1, a package to scan can be configured on the `LocalContainerEntityManagerFactoryBean` directly to enable classpath scanning for entity classes. See the link:$$https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/orm/jpa/LocalContainerEntityManagerFactoryBean.html#setPackagesToScan(java.lang.String...)$$[JavaDoc] for details.

[[jpd.misc.cdi-integration]]
== CDI Integration

Instances of the repository interfaces are usually created by a container, for which Spring is the most natural choice when working with Spring Data. Spring offers sophisticated support for creating bean instances, as documented in <<repositories.create-instances>>. As of version 1.1.0, Spring Data JPA ships with a custom CDI extension that allows using the repository abstraction in CDI environments. The extension is part of the JAR. To activate it, include the Spring Data JPA JAR on your classpath.

You can now set up the infrastructure by implementing a CDI Producer for the `EntityManagerFactory` and `EntityManager`, as shown in the following example:

[source, java]
----
class EntityManagerFactoryProducer {

  @Produces
  @ApplicationScoped
  public EntityManagerFactory createEntityManagerFactory() {
    return Persistence.createEntityManagerFactory(""my-persistence-unit"");
  }

  public void close(@Disposes EntityManagerFactory entityManagerFactory) {
    entityManagerFactory.close();
  }

  @Produces
  @RequestScoped
  public EntityManager createEntityManager(EntityManagerFactory entityManagerFactory) {
    return entityManagerFactory.createEntityManager();
  }

  public void close(@Disposes EntityManager entityManager) {
    entityManager.close();
  }
}
----

The necessary setup can vary depending on the JavaEE environment. You may need to do nothing more than redeclare a `EntityManager` as a CDI bean, as follows:

[source, java]
----
class CdiConfig {

  @Produces
  @RequestScoped
  @PersistenceContext
  public EntityManager entityManager;
}
----

In the preceding example, the container has to be capable of creating JPA `EntityManagers` itself. All the configuration does is re-export the JPA `EntityManager` as a CDI bean.

The Spring Data JPA CDI extension picks up all available `EntityManager` instances as CDI beans and creates a proxy for a Spring Data repository whenever a bean of a repository type is requested by the container. Thus, obtaining an instance of a Spring Data repository is a matter of declaring an `@Injected` property, as shown in the following example:

[source, java]
----
class RepositoryClient {

  @Inject
  PersonRepository repository;

  public void businessMethod() {
    List<Person> people = repository.findAll();
  }
}
----
",12117,False,2012.5130537854072,median
"//===- LoopInterchange.cpp - Loop interchange pass-------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This Pass handles loop interchange transform.
// This pass interchanges loops to provide a more cache-friendly memory access
// patterns.
//
//===----------------------------------------------------------------------===//

#include ""llvm/Transforms/Scalar/LoopInterchange.h""
#include ""llvm/ADT/STLExtras.h""
#include ""llvm/ADT/SmallVector.h""
#include ""llvm/ADT/Statistic.h""
#include ""llvm/ADT/StringRef.h""
#include ""llvm/Analysis/DependenceAnalysis.h""
#include ""llvm/Analysis/LoopInfo.h""
#include ""llvm/Analysis/LoopNestAnalysis.h""
#include ""llvm/Analysis/LoopPass.h""
#include ""llvm/Analysis/OptimizationRemarkEmitter.h""
#include ""llvm/Analysis/ScalarEvolution.h""
#include ""llvm/Analysis/ScalarEvolutionExpressions.h""
#include ""llvm/IR/BasicBlock.h""
#include ""llvm/IR/Constants.h""
#include ""llvm/IR/DiagnosticInfo.h""
#include ""llvm/IR/Dominators.h""
#include ""llvm/IR/Function.h""
#include ""llvm/IR/IRBuilder.h""
#include ""llvm/IR/InstrTypes.h""
#include ""llvm/IR/Instruction.h""
#include ""llvm/IR/Instructions.h""
#include ""llvm/IR/Type.h""
#include ""llvm/IR/User.h""
#include ""llvm/IR/Value.h""
#include ""llvm/InitializePasses.h""
#include ""llvm/Pass.h""
#include ""llvm/Support/Casting.h""
#include ""llvm/Support/CommandLine.h""
#include ""llvm/Support/Debug.h""
#include ""llvm/Support/ErrorHandling.h""
#include ""llvm/Support/raw_ostream.h""
#include ""llvm/Transforms/Scalar.h""
#include ""llvm/Transforms/Utils.h""
#include ""llvm/Transforms/Utils/BasicBlockUtils.h""
#include ""llvm/Transforms/Utils/LoopUtils.h""
#include <cassert>
#include <utility>
#include <vector>

using namespace llvm;

#define DEBUG_TYPE ""loop-interchange""

STATISTIC(LoopsInterchanged, ""Number of loops interchanged"");

static cl::opt<int> LoopInterchangeCostThreshold(
    ""loop-interchange-threshold"", cl::init(0), cl::Hidden,
    cl::desc(""Interchange if you gain more than this number""));

namespace {

using LoopVector = SmallVector<Loop *, 8>;

// TODO: Check if we can use a sparse matrix here.
using CharMatrix = std::vector<std::vector<char>>;

} // end anonymous namespace

// Maximum number of dependencies that can be handled in the dependency matrix.
static const unsigned MaxMemInstrCount = 100;

// Maximum loop depth supported.
static const unsigned MaxLoopNestDepth = 10;

#ifdef DUMP_DEP_MATRICIES
static void printDepMatrix(CharMatrix &DepMatrix) {
  for (auto &Row : DepMatrix) {
    for (auto D : Row)
      LLVM_DEBUG(dbgs() << D << "" "");
    LLVM_DEBUG(dbgs() << ""\\n"");
  }
}
#endif

static bool populateDependencyMatrix(CharMatrix &DepMatrix, unsigned Level,
                                     Loop *L, DependenceInfo *DI) {
  using ValueVector = SmallVector<Value *, 16>;

  ValueVector MemInstr;

  // For each block.
  for (BasicBlock *BB : L->blocks()) {
    // Scan the BB and collect legal loads and stores.
    for (Instruction &I : *BB) {
      if (!isa<Instruction>(I))
        return false;
      if (auto *Ld = dyn_cast<LoadInst>(&I)) {
        if (!Ld->isSimple())
          return false;
        MemInstr.push_back(&I);
      } else if (auto *St = dyn_cast<StoreInst>(&I)) {
        if (!St->isSimple())
          return false;
        MemInstr.push_back(&I);
      }
    }
  }

  LLVM_DEBUG(dbgs() << ""Found "" << MemInstr.size()
                    << "" Loads and Stores to analyze\\n"");

  ValueVector::iterator I, IE, J, JE;

  for (I = MemInstr.begin(), IE = MemInstr.end(); I != IE; ++I) {
    for (J = I, JE = MemInstr.end(); J != JE; ++J) {
      std::vector<char> Dep;
      Instruction *Src = cast<Instruction>(*I);
      Instruction *Dst = cast<Instruction>(*J);
      if (Src == Dst)
        continue;
      // Ignore Input dependencies.
      if (isa<LoadInst>(Src) && isa<LoadInst>(Dst))
        continue;
      // Track Output, Flow, and Anti dependencies.
      if (auto D = DI->depends(Src, Dst, true)) {
        assert(D->isOrdered() && ""Expected an output, flow or anti dep."");
        LLVM_DEBUG(StringRef DepType =
                       D->isFlow() ? ""flow"" : D->isAnti() ? ""anti"" : ""output"";
                   dbgs() << ""Found "" << DepType
                          << "" dependency between Src and Dst\\n""
                          << "" Src:"" << *Src << ""\\n Dst:"" << *Dst << '\\n');
        unsigned Levels = D->getLevels();
        char Direction;
        for (unsigned II = 1; II <= Levels; ++II) {
          const SCEV *Distance = D->getDistance(II);
          const SCEVConstant *SCEVConst =
              dyn_cast_or_null<SCEVConstant>(Distance);
          if (SCEVConst) {
            const ConstantInt *CI = SCEVConst->getValue();
            if (CI->isNegative())
              Direction = '<';
            else if (CI->isZero())
              Direction = '=';
            else
              Direction = '>';
            Dep.push_back(Direction);
          } else if (D->isScalar(II)) {
            Direction = 'S';
            Dep.push_back(Direction);
          } else {
            unsigned Dir = D->getDirection(II);
            if (Dir == Dependence::DVEntry::LT ||
                Dir == Dependence::DVEntry::LE)
              Direction = '<';
            else if (Dir == Dependence::DVEntry::GT ||
                     Dir == Dependence::DVEntry::GE)
              Direction = '>';
            else if (Dir == Dependence::DVEntry::EQ)
              Direction = '=';
            else
              Direction = '*';
            Dep.push_back(Direction);
          }
        }
        while (Dep.size() != Level) {
          Dep.push_back('I');
        }

        DepMatrix.push_back(Dep);
        if (DepMatrix.size() > MaxMemInstrCount) {
          LLVM_DEBUG(dbgs() << ""Cannot handle more than "" << MaxMemInstrCount
                            << "" dependencies inside loop\\n"");
          return false;
        }
      }
    }
  }

  return true;
}

// A loop is moved from index 'from' to an index 'to'. Update the Dependence
// matrix by exchanging the two columns.
static void interChangeDependencies(CharMatrix &DepMatrix, unsigned FromIndx,
                                    unsigned ToIndx) {
  for (unsigned I = 0, E = DepMatrix.size(); I < E; ++I)
    std::swap(DepMatrix[I][ToIndx], DepMatrix[I][FromIndx]);
}

// Checks if outermost non '=','S'or'I' dependence in the dependence matrix is
// '>'
static bool isOuterMostDepPositive(CharMatrix &DepMatrix, unsigned Row,
                                   unsigned Column) {
  for (unsigned i = 0; i <= Column; ++i) {
    if (DepMatrix[Row][i] == '<')
      return false;
    if (DepMatrix[Row][i] == '>')
      return true;
  }
  // All dependencies were '=','S' or 'I'
  return false;
}

// Checks if no dependence exist in the dependency matrix in Row before Column.
static bool containsNoDependence(CharMatrix &DepMatrix, unsigned Row,
                                 unsigned Column) {
  for (unsigned i = 0; i < Column; ++i) {
    if (DepMatrix[Row][i] != '=' && DepMatrix[Row][i] != 'S' &&
        DepMatrix[Row][i] != 'I')
      return false;
  }
  return true;
}

static bool validDepInterchange(CharMatrix &DepMatrix, unsigned Row,
                                unsigned OuterLoopId, char InnerDep,
                                char OuterDep) {
  if (isOuterMostDepPositive(DepMatrix, Row, OuterLoopId))
    return false;

  if (InnerDep == OuterDep)
    return true;

  // It is legal to interchange if and only if after interchange no row has a
  // '>' direction as the leftmost non-'='.

  if (InnerDep == '=' || InnerDep == 'S' || InnerDep == 'I')
    return true;

  if (InnerDep == '<')
    return true;

  if (InnerDep == '>') {
    // If OuterLoopId represents outermost loop then interchanging will make the
    // 1st dependency as '>'
    if (OuterLoopId == 0)
      return false;

    // If all dependencies before OuterloopId are '=','S'or 'I'. Then
    // interchanging will result in this row having an outermost non '='
    // dependency of '>'
    if (!containsNoDependence(DepMatrix, Row, OuterLoopId))
      return true;
  }

  return false;
}

// Checks if it is legal to interchange 2 loops.
// [Theorem] A permutation of the loops in a perfect nest is legal if and only
// if the direction matrix, after the same permutation is applied to its
// columns, has no "">"" direction as the leftmost non-""="" direction in any row.
static bool isLegalToInterChangeLoops(CharMatrix &DepMatrix,
                                      unsigned InnerLoopId,
                                      unsigned OuterLoopId) {
  unsigned NumRows = DepMatrix.size();
  // For each row check if it is valid to interchange.
  for (unsigned Row = 0; Row < NumRows; ++Row) {
    char InnerDep = DepMatrix[Row][InnerLoopId];
    char OuterDep = DepMatrix[Row][OuterLoopId];
    if (InnerDep == '*' || OuterDep == '*')
      return false;
    if (!validDepInterchange(DepMatrix, Row, OuterLoopId, InnerDep, OuterDep))
      return false;
  }
  return true;
}

static LoopVector populateWorklist(Loop &L) {
  LLVM_DEBUG(dbgs() << ""Calling populateWorklist on Func: ""
                    << L.getHeader()->getParent()->getName() << "" Loop: %""
                    << L.getHeader()->getName() << '\\n');
  LoopVector LoopList;
  Loop *CurrentLoop = &L;
  const std::vector<Loop *> *Vec = &CurrentLoop->getSubLoops();
  while (!Vec->empty()) {
    // The current loop has multiple subloops in it hence it is not tightly
    // nested.
    // Discard all loops above it added into Worklist.
    if (Vec->size() != 1)
      return {};

    LoopList.push_back(CurrentLoop);
    CurrentLoop = Vec->front();
    Vec = &CurrentLoop->getSubLoops();
  }
  LoopList.push_back(CurrentLoop);
  return LoopList;
}

namespace {

/// LoopInterchangeLegality checks if it is legal to interchange the loop.
class LoopInterchangeLegality {
public:
  LoopInterchangeLegality(Loop *Outer, Loop *Inner, ScalarEvolution *SE,
                          OptimizationRemarkEmitter *ORE)
      : OuterLoop(Outer), InnerLoop(Inner), SE(SE), ORE(ORE) {}

  /// Check if the loops can be interchanged.
  bool canInterchangeLoops(unsigned InnerLoopId, unsigned OuterLoopId,
                           CharMatrix &DepMatrix);

  /// Discover induction PHIs in the header of \\p L. Induction
  /// PHIs are added to \\p Inductions.
  bool findInductions(Loop *L, SmallVectorImpl<PHINode *> &Inductions);

  /// Check if the loop structure is understood. We do not handle triangular
  /// loops for now.
  bool isLoopStructureUnderstood();

  bool currentLimitations();

  const SmallPtrSetImpl<PHINode *> &getOuterInnerReductions() const {
    return OuterInnerReductions;
  }

  const SmallVectorImpl<PHINode *> &getInnerLoopInductions() const {
    return InnerLoopInductions;
  }

private:
  bool tightlyNested(Loop *Outer, Loop *Inner);
  bool containsUnsafeInstructions(BasicBlock *BB);

  /// Discover induction and reduction PHIs in the header of \\p L. Induction
  /// PHIs are added to \\p Inductions, reductions are added to
  /// OuterInnerReductions. When the outer loop is passed, the inner loop needs
  /// to be passed as \\p InnerLoop.
  bool findInductionAndReductions(Loop *L,
                                  SmallVector<PHINode *, 8> &Inductions,
                                  Loop *InnerLoop);

  Loop *OuterLoop;
  Loop *InnerLoop;

  ScalarEvolution *SE;

  /// Interface to emit optimization remarks.
  OptimizationRemarkEmitter *ORE;

  /// Set of reduction PHIs taking part of a reduction across the inner and
  /// outer loop.
  SmallPtrSet<PHINode *, 4> OuterInnerReductions;

  /// Set of inner loop induction PHIs
  SmallVector<PHINode *, 8> InnerLoopInductions;
};

/// LoopInterchangeProfitability checks if it is profitable to interchange the
/// loop.
class LoopInterchangeProfitability {
public:
  LoopInterchangeProfitability(Loop *Outer, Loop *Inner, ScalarEvolution *SE,
                               OptimizationRemarkEmitter *ORE)
      : OuterLoop(Outer), InnerLoop(Inner), SE(SE), ORE(ORE) {}

  /// Check if the loop interchange is profitable.
  bool isProfitable(unsigned InnerLoopId, unsigned OuterLoopId,
                    CharMatrix &DepMatrix);

private:
  int getInstrOrderCost();

  Loop *OuterLoop;
  Loop *InnerLoop;

  /// Scev analysis.
  ScalarEvolution *SE;

  /// Interface to emit optimization remarks.
  OptimizationRemarkEmitter *ORE;
};

/// LoopInterchangeTransform interchanges the loop.
class LoopInterchangeTransform {
public:
  LoopInterchangeTransform(Loop *Outer, Loop *Inner, ScalarEvolution *SE,
                           LoopInfo *LI, DominatorTree *DT,
                           const LoopInterchangeLegality &LIL)
      : OuterLoop(Outer), InnerLoop(Inner), SE(SE), LI(LI), DT(DT), LIL(LIL) {}

  /// Interchange OuterLoop and InnerLoop.
  bool transform();
  void restructureLoops(Loop *NewInner, Loop *NewOuter,
                        BasicBlock *OrigInnerPreHeader,
                        BasicBlock *OrigOuterPreHeader);
  void removeChildLoop(Loop *OuterLoop, Loop *InnerLoop);

private:
  bool adjustLoopLinks();
  bool adjustLoopBranches();

  Loop *OuterLoop;
  Loop *InnerLoop;

  /// Scev analysis.
  ScalarEvolution *SE;

  LoopInfo *LI;
  DominatorTree *DT;

  const LoopInterchangeLegality &LIL;
};

struct LoopInterchange {
  ScalarEvolution *SE = nullptr;
  LoopInfo *LI = nullptr;
  DependenceInfo *DI = nullptr;
  DominatorTree *DT = nullptr;

  /// Interface to emit optimization remarks.
  OptimizationRemarkEmitter *ORE;

  LoopInterchange(ScalarEvolution *SE, LoopInfo *LI, DependenceInfo *DI,
                  DominatorTree *DT, OptimizationRemarkEmitter *ORE)
      : SE(SE), LI(LI), DI(DI), DT(DT), ORE(ORE) {}

  bool run(Loop *L) {
    if (L->getParentLoop())
      return false;

    return processLoopList(populateWorklist(*L));
  }

  bool run(LoopNest &LN) {
    const auto &LoopList = LN.getLoops();
    for (unsigned I = 1; I < LoopList.size(); ++I)
      if (LoopList[I]->getParentLoop() != LoopList[I - 1])
        return false;
    return processLoopList(LoopList);
  }

  bool isComputableLoopNest(ArrayRef<Loop *> LoopList) {
    for (Loop *L : LoopList) {
      const SCEV *ExitCountOuter = SE->getBackedgeTakenCount(L);
      if (isa<SCEVCouldNotCompute>(ExitCountOuter)) {
        LLVM_DEBUG(dbgs() << ""Couldn't compute backedge count\\n"");
        return false;
      }
      if (L->getNumBackEdges() != 1) {
        LLVM_DEBUG(dbgs() << ""NumBackEdges is not equal to 1\\n"");
        return false;
      }
      if (!L->getExitingBlock()) {
        LLVM_DEBUG(dbgs() << ""Loop doesn't have unique exit block\\n"");
        return false;
      }
    }
    return true;
  }

  unsigned selectLoopForInterchange(ArrayRef<Loop *> LoopList) {
    // TODO: Add a better heuristic to select the loop to be interchanged based
    // on the dependence matrix. Currently we select the innermost loop.
    return LoopList.size() - 1;
  }

  bool processLoopList(ArrayRef<Loop *> LoopList) {
    bool Changed = false;
    unsigned LoopNestDepth = LoopList.size();
    if (LoopNestDepth < 2) {
      LLVM_DEBUG(dbgs() << ""Loop doesn't contain minimum nesting level.\\n"");
      return false;
    }
    if (LoopNestDepth > MaxLoopNestDepth) {
      LLVM_DEBUG(dbgs() << ""Cannot handle loops of depth greater than ""
                        << MaxLoopNestDepth << ""\\n"");
      return false;
    }
    if (!isComputableLoopNest(LoopList)) {
      LLVM_DEBUG(dbgs() << ""Not valid loop candidate for interchange\\n"");
      return false;
    }

    LLVM_DEBUG(dbgs() << ""Processing LoopList of size = "" << LoopNestDepth
                      << ""\\n"");

    CharMatrix DependencyMatrix;
    Loop *OuterMostLoop = *(LoopList.begin());
    if (!populateDependencyMatrix(DependencyMatrix, LoopNestDepth,
                                  OuterMostLoop, DI)) {
      LLVM_DEBUG(dbgs() << ""Populating dependency matrix failed\\n"");
      return false;
    }
#ifdef DUMP_DEP_MATRICIES
    LLVM_DEBUG(dbgs() << ""Dependence before interchange\\n"");
    printDepMatrix(DependencyMatrix);
#endif

    // Get the Outermost loop exit.
    BasicBlock *LoopNestExit = OuterMostLoop->getExitBlock();
    if (!LoopNestExit) {
      LLVM_DEBUG(dbgs() << ""OuterMostLoop needs an unique exit block"");
      return false;
    }

    unsigned SelecLoopId = selectLoopForInterchange(LoopList);
    // Move the selected loop outwards to the best possible position.
    Loop *LoopToBeInterchanged = LoopList[SelecLoopId];
    for (unsigned i = SelecLoopId; i > 0; i--) {
      bool Interchanged = processLoop(LoopToBeInterchanged, LoopList[i - 1], i,
                                      i - 1, DependencyMatrix);
      if (!Interchanged)
        return Changed;
      // Update the DependencyMatrix
      interChangeDependencies(DependencyMatrix, i, i - 1);
#ifdef DUMP_DEP_MATRICIES
      LLVM_DEBUG(dbgs() << ""Dependence after interchange\\n"");
      printDepMatrix(DependencyMatrix);
#endif
      Changed |= Interchanged;
    }
    return Changed;
  }

  bool processLoop(Loop *InnerLoop, Loop *OuterLoop, unsigned InnerLoopId,
                   unsigned OuterLoopId,
                   std::vector<std::vector<char>> &DependencyMatrix) {
    LLVM_DEBUG(dbgs() << ""Processing InnerLoopId = "" << InnerLoopId
                      << "" and OuterLoopId = "" << OuterLoopId << ""\\n"");
    LoopInterchangeLegality LIL(OuterLoop, InnerLoop, SE, ORE);
    if (!LIL.canInterchangeLoops(InnerLoopId, OuterLoopId, DependencyMatrix)) {
      LLVM_DEBUG(dbgs() << ""Not interchanging loops. Cannot prove legality.\\n"");
      return false;
    }
    LLVM_DEBUG(dbgs() << ""Loops are legal to interchange\\n"");
    LoopInterchangeProfitability LIP(OuterLoop, InnerLoop, SE, ORE);
    if (!LIP.isProfitable(InnerLoopId, OuterLoopId, DependencyMatrix)) {
      LLVM_DEBUG(dbgs() << ""Interchanging loops not profitable.\\n"");
      return false;
    }

    ORE->emit([&]() {
      return OptimizationRemark(DEBUG_TYPE, ""Interchanged"",
                                InnerLoop->getStartLoc(),
                                InnerLoop->getHeader())
             << ""Loop interchanged with enclosing loop."";
    });

    LoopInterchangeTransform LIT(OuterLoop, InnerLoop, SE, LI, DT, LIL);
    LIT.transform();
    LLVM_DEBUG(dbgs() << ""Loops interchanged.\\n"");
    LoopsInterchanged++;

    assert(InnerLoop->isLCSSAForm(*DT) &&
           ""Inner loop not left in LCSSA form after loop interchange!"");
    assert(OuterLoop->isLCSSAForm(*DT) &&
           ""Outer loop not left in LCSSA form after loop interchange!"");

    return true;
  }
};

} // end anonymous namespace

bool LoopInterchangeLegality::containsUnsafeInstructions(BasicBlock *BB) {
  return any_of(*BB, [](const Instruction &I) {
    return I.mayHaveSideEffects() || I.mayReadFromMemory();
  });
}

bool LoopInterchangeLegality::tightlyNested(Loop *OuterLoop, Loop *InnerLoop) {
  BasicBlock *OuterLoopHeader = OuterLoop->getHeader();
  BasicBlock *InnerLoopPreHeader = InnerLoop->getLoopPreheader();
  BasicBlock *OuterLoopLatch = OuterLoop->getLoopLatch();

  LLVM_DEBUG(dbgs() << ""Checking if loops are tightly nested\\n"");

  // A perfectly nested loop will not have any branch in between the outer and
  // inner block i.e. outer header will branch to either inner preheader and
  // outerloop latch.
  BranchInst *OuterLoopHeaderBI =
      dyn_cast<BranchInst>(OuterLoopHeader->getTerminator());
  if (!OuterLoopHeaderBI)
    return false;

  for (BasicBlock *Succ : successors(OuterLoopHeaderBI))
    if (Succ != InnerLoopPreHeader && Succ != InnerLoop->getHeader() &&
        Succ != OuterLoopLatch)
      return false;

  LLVM_DEBUG(dbgs() << ""Checking instructions in Loop header and Loop latch\\n"");
  // We do not have any basic block in between now make sure the outer header
  // and outer loop latch doesn't contain any unsafe instructions.
  if (containsUnsafeInstructions(OuterLoopHeader) ||
      containsUnsafeInstructions(OuterLoopLatch))
    return false;

  // Also make sure the inner loop preheader does not contain any unsafe
  // instructions. Note that all instructions in the preheader will be moved to
  // the outer loop header when interchanging.
  if (InnerLoopPreHeader != OuterLoopHeader &&
      containsUnsafeInstructions(InnerLoopPreHeader))
    return false;

  BasicBlock *InnerLoopExit = InnerLoop->getExitBlock();
  // Ensure the inner loop exit block flows to the outer loop latch possibly
  // through empty blocks.
  const BasicBlock &SuccInner =
      LoopNest::skipEmptyBlockUntil(InnerLoopExit, OuterLoopLatch);
  if (&SuccInner != OuterLoopLatch) {
    LLVM_DEBUG(dbgs() << ""Inner loop exit block "" << *InnerLoopExit
                      << "" does not lead to the outer loop latch.\\n"";);
    return false;
  }
  // The inner loop exit block does flow to the outer loop latch and not some
  // other BBs, now make sure it contains safe instructions, since it will be
  // moved into the (new) inner loop after interchange.
  if (containsUnsafeInstructions(InnerLoopExit))
    return false;

  LLVM_DEBUG(dbgs() << ""Loops are perfectly nested\\n"");
  // We have a perfect loop nest.
  return true;
}

bool LoopInterchangeLegality::isLoopStructureUnderstood() {
  BasicBlock *InnerLoopPreheader = InnerLoop->getLoopPreheader();
  for (PHINode *InnerInduction : InnerLoopInductions) {
    unsigned Num = InnerInduction->getNumOperands();
    for (unsigned i = 0; i < Num; ++i) {
      Value *Val = InnerInduction->getOperand(i);
      if (isa<Constant>(Val))
        continue;
      Instruction *I = dyn_cast<Instruction>(Val);
      if (!I)
        return false;
      // TODO: Handle triangular loops.
      // e.g. for(int i=0;i<N;i++)
      //        for(int j=i;j<N;j++)
      unsigned IncomBlockIndx = PHINode::getIncomingValueNumForOperand(i);
      if (InnerInduction->getIncomingBlock(IncomBlockIndx) ==
              InnerLoopPreheader &&
          !OuterLoop->isLoopInvariant(I)) {
        return false;
      }
    }
  }

  // TODO: Handle triangular loops of another form.
  // e.g. for(int i=0;i<N;i++)
  //        for(int j=0;j<i;j++)
  // or,
  //      for(int i=0;i<N;i++)
  //        for(int j=0;j*i<N;j++)
  BasicBlock *InnerLoopLatch = InnerLoop->getLoopLatch();
  BranchInst *InnerLoopLatchBI =
      dyn_cast<BranchInst>(InnerLoopLatch->getTerminator());
  if (!InnerLoopLatchBI->isConditional())
    return false;
  if (CmpInst *InnerLoopCmp =
          dyn_cast<CmpInst>(InnerLoopLatchBI->getCondition())) {
    Value *Op0 = InnerLoopCmp->getOperand(0);
    Value *Op1 = InnerLoopCmp->getOperand(1);

    // LHS and RHS of the inner loop exit condition, e.g.,
    // in ""for(int j=0;j<i;j++)"", LHS is j and RHS is i.
    Value *Left = nullptr;
    Value *Right = nullptr;

    // Check if V only involves inner loop induction variable.
    // Return true if V is InnerInduction, or a cast from
    // InnerInduction, or a binary operator that involves
    // InnerInduction and a constant.
    std::function<bool(Value *)> IsPathToInnerIndVar;
    IsPathToInnerIndVar = [this, &IsPathToInnerIndVar](const Value *V) -> bool {
      if (llvm::is_contained(InnerLoopInductions, V))
        return true;
      if (isa<Constant>(V))
        return true;
      const Instruction *I = dyn_cast<Instruction>(V);
      if (!I)
        return false;
      if (isa<CastInst>(I))
        return IsPathToInnerIndVar(I->getOperand(0));
      if (isa<BinaryOperator>(I))
        return IsPathToInnerIndVar(I->getOperand(0)) &&
               IsPathToInnerIndVar(I->getOperand(1));
      return false;
    };

    // In case of multiple inner loop indvars, it is okay if LHS and RHS
    // are both inner indvar related variables.
    if (IsPathToInnerIndVar(Op0) && IsPathToInnerIndVar(Op1))
      return true;

    // Otherwise we check if the cmp instruction compares an inner indvar
    // related variable (Left) with a outer loop invariant (Right).
    if (IsPathToInnerIndVar(Op0) && !isa<Constant>(Op0)) {
      Left = Op0;
      Right = Op1;
    } else if (IsPathToInnerIndVar(Op1) && !isa<Constant>(Op1)) {
      Left = Op1;
      Right = Op0;
    }

    if (Left == nullptr)
      return false;

    const SCEV *S = SE->getSCEV(Right);
    if (!SE->isLoopInvariant(S, OuterLoop))
      return false;
  }

  return true;
}

// If SV is a LCSSA PHI node with a single incoming value, return the incoming
// value.
static Value *followLCSSA(Value *SV) {
  PHINode *PHI = dyn_cast<PHINode>(SV);
  if (!PHI)
    return SV;

  if (PHI->getNumIncomingValues() != 1)
    return SV;
  return followLCSSA(PHI->getIncomingValue(0));
}

// Check V's users to see if it is involved in a reduction in L.
static PHINode *findInnerReductionPhi(Loop *L, Value *V) {
  // Reduction variables cannot be constants.
  if (isa<Constant>(V))
    return nullptr;

  for (Value *User : V->users()) {
    if (PHINode *PHI = dyn_cast<PHINode>(User)) {
      if (PHI->getNumIncomingValues() == 1)
        continue;
      RecurrenceDescriptor RD;
      if (RecurrenceDescriptor::isReductionPHI(PHI, L, RD)) {
        // Detect floating point reduction only when it can be reordered.
        if (RD.getExactFPMathInst() != nullptr)
          return nullptr;
        return PHI;
      }
      return nullptr;
    }
  }

  return nullptr;
}

bool LoopInterchangeLegality::findInductionAndReductions(
    Loop *L, SmallVector<PHINode *, 8> &Inductions, Loop *InnerLoop) {
  if (!L->getLoopLatch() || !L->getLoopPredecessor())
    return false;
  for (PHINode &PHI : L->getHeader()->phis()) {
    RecurrenceDescriptor RD;
    InductionDescriptor ID;
    if (InductionDescriptor::isInductionPHI(&PHI, L, SE, ID))
      Inductions.push_back(&PHI);
    else {
      // PHIs in inner loops need to be part of a reduction in the outer loop,
      // discovered when checking the PHIs of the outer loop earlier.
      if (!InnerLoop) {
        if (!OuterInnerReductions.count(&PHI)) {
          LLVM_DEBUG(dbgs() << ""Inner loop PHI is not part of reductions ""
                               ""across the outer loop.\\n"");
          return false;
        }
      } else {
        assert(PHI.getNumIncomingValues() == 2 &&
               ""Phis in loop header should have exactly 2 incoming values"");
        // Check if we have a PHI node in the outer loop that has a reduction
        // result from the inner loop as an incoming value.
        Value *V = followLCSSA(PHI.getIncomingValueForBlock(L->getLoopLatch()));
        PHINode *InnerRedPhi = findInnerReductionPhi(InnerLoop, V);
        if (!InnerRedPhi ||
            !llvm::is_contained(InnerRedPhi->incoming_values(), &PHI)) {
          LLVM_DEBUG(
              dbgs()
              << ""Failed to recognize PHI as an induction or reduction.\\n"");
          return false;
        }
        OuterInnerReductions.insert(&PHI);
        OuterInnerReductions.insert(InnerRedPhi);
      }
    }
  }
  return true;
}

// This function indicates the current limitations in the transform as a result
// of which we do not proceed.
bool LoopInterchangeLegality::currentLimitations() {
  BasicBlock *InnerLoopLatch = InnerLoop->getLoopLatch();

  // transform currently expects the loop latches to also be the exiting
  // blocks.
  if (InnerLoop->getExitingBlock() != InnerLoopLatch ||
      OuterLoop->getExitingBlock() != OuterLoop->getLoopLatch() ||
      !isa<BranchInst>(InnerLoopLatch->getTerminator()) ||
      !isa<BranchInst>(OuterLoop->getLoopLatch()->getTerminator())) {
    LLVM_DEBUG(
        dbgs() << ""Loops where the latch is not the exiting block are not""
               << "" supported currently.\\n"");
    ORE->emit([&]() {
      return OptimizationRemarkMissed(DEBUG_TYPE, ""ExitingNotLatch"",
                                      OuterLoop->getStartLoc(),
                                      OuterLoop->getHeader())
             << ""Loops where the latch is not the exiting block cannot be""
                "" interchange currently."";
    });
    return true;
  }

  SmallVector<PHINode *, 8> Inductions;
  if (!findInductionAndReductions(OuterLoop, Inductions, InnerLoop)) {
    LLVM_DEBUG(
        dbgs() << ""Only outer loops with induction or reduction PHI nodes ""
               << ""are supported currently.\\n"");
    ORE->emit([&]() {
      return OptimizationRemarkMissed(DEBUG_TYPE, ""UnsupportedPHIOuter"",
                                      OuterLoop->getStartLoc(),
                                      OuterLoop->getHeader())
             << ""Only outer loops with induction or reduction PHI nodes can be""
                "" interchanged currently."";
    });
    return true;
  }

  Inductions.clear();
  if (!findInductionAndReductions(InnerLoop, Inductions, nullptr)) {
    LLVM_DEBUG(
        dbgs() << ""Only inner loops with induction or reduction PHI nodes ""
               << ""are supported currently.\\n"");
    ORE->emit([&]() {
      return OptimizationRemarkMissed(DEBUG_TYPE, ""UnsupportedPHIInner"",
                                      InnerLoop->getStartLoc(),
                                      InnerLoop->getHeader())
             << ""Only inner loops with induction or reduction PHI nodes can be""
                "" interchange currently."";
    });
    return true;
  }

  // TODO: Triangular loops are not handled for now.
  if (!isLoopStructureUnderstood()) {
    LLVM_DEBUG(dbgs() << ""Loop structure not understood by pass\\n"");
    ORE->emit([&]() {
      return OptimizationRemarkMissed(DEBUG_TYPE, ""UnsupportedStructureInner"",
                                      InnerLoop->getStartLoc(),
                                      InnerLoop->getHeader())
             << ""Inner loop structure not understood currently."";
    });
    return true;
  }

  return false;
}

bool LoopInterchangeLegality::findInductions(
    Loop *L, SmallVectorImpl<PHINode *> &Inductions) {
  for (PHINode &PHI : L->getHeader()->phis()) {
    InductionDescriptor ID;
    if (InductionDescriptor::isInductionPHI(&PHI, L, SE, ID))
      Inductions.push_back(&PHI);
  }
  return !Inductions.empty();
}

// We currently only support LCSSA PHI nodes in the inner loop exit, if their
// users are either reduction PHIs or PHIs outside the outer loop (which means
// the we are only interested in the final value after the loop).
static bool
areInnerLoopExitPHIsSupported(Loop *InnerL, Loop *OuterL,
                              SmallPtrSetImpl<PHINode *> &Reductions) {
  BasicBlock *InnerExit = OuterL->getUniqueExitBlock();
  for (PHINode &PHI : InnerExit->phis()) {
    // Reduction lcssa phi will have only 1 incoming block that from loop latch.
    if (PHI.getNumIncomingValues() > 1)
      return false;
    if (any_of(PHI.users(), [&Reductions, OuterL](User *U) {
          PHINode *PN = dyn_cast<PHINode>(U);
          return !PN ||
                 (!Reductions.count(PN) && OuterL->contains(PN->getParent()));
        })) {
      return false;
    }
  }
  return true;
}

// We currently support LCSSA PHI nodes in the outer loop exit, if their
// incoming values do not come from the outer loop latch or if the
// outer loop latch has a single predecessor. In that case, the value will
// be available if both the inner and outer loop conditions are true, which
// will still be true after interchanging. If we have multiple predecessor,
// that may not be the case, e.g. because the outer loop latch may be executed
// if the inner loop is not executed.
static bool areOuterLoopExitPHIsSupported(Loop *OuterLoop, Loop *InnerLoop) {
  BasicBlock *LoopNestExit = OuterLoop->getUniqueExitBlock();
  for (PHINode &PHI : LoopNestExit->phis()) {
    for (unsigned i = 0; i < PHI.getNumIncomingValues(); i++) {
      Instruction *IncomingI = dyn_cast<Instruction>(PHI.getIncomingValue(i));
      if (!IncomingI || IncomingI->getParent() != OuterLoop->getLoopLatch())
        continue;

      // The incoming value is defined in the outer loop latch. Currently we
      // only support that in case the outer loop latch has a single predecessor.
      // This guarantees that the outer loop latch is executed if and only if
      // the inner loop is executed (because tightlyNested() guarantees that the
      // outer loop header only branches to the inner loop or the outer loop
      // latch).
      // FIXME: We could weaken this logic and allow multiple predecessors,
      //        if the values are produced outside the loop latch. We would need
      //        additional logic to update the PHI nodes in the exit block as
      //        well.
      if (OuterLoop->getLoopLatch()->getUniquePredecessor() == nullptr)
        return false;
    }
  }
  return true;
}

// In case of multi-level nested loops, it may occur that lcssa phis exist in
// the latch of InnerLoop, i.e., when defs of the incoming values are further
// inside the loopnest. Sometimes those incoming values are not available
// after interchange, since the original inner latch will become the new outer
// latch which may have predecessor paths that do not include those incoming
// values.
// TODO: Handle transformation of lcssa phis in the InnerLoop latch in case of
// multi-level loop nests.
static bool areInnerLoopLatchPHIsSupported(Loop *OuterLoop, Loop *InnerLoop) {
  if (InnerLoop->getSubLoops().empty())
    return true;
  // If the original outer latch has only one predecessor, then values defined
  // further inside the looploop, e.g., in the innermost loop, will be available
  // at the new outer latch after interchange.
  if (OuterLoop->getLoopLatch()->getUniquePredecessor() != nullptr)
    return true;

  // The outer latch has more than one predecessors, i.e., the inner
  // exit and the inner header.
  // PHI nodes in the inner latch are lcssa phis where the incoming values
  // are defined further inside the loopnest. Check if those phis are used
  // in the original inner latch. If that is the case then bail out since
  // those incoming values may not be available at the new outer latch.
  BasicBlock *InnerLoopLatch = InnerLoop->getLoopLatch();
  for (PHINode &PHI : InnerLoopLatch->phis()) {
    for (auto *U : PHI.users()) {
      Instruction *UI = cast<Instruction>(U);
      if (InnerLoopLatch == UI->getParent())
        return false;
    }
  }
  return true;
}

bool LoopInterchangeLegality::canInterchangeLoops(unsigned InnerLoopId,
                                                  unsigned OuterLoopId,
                                                  CharMatrix &DepMatrix) {
  if (!isLegalToInterChangeLoops(DepMatrix, InnerLoopId, OuterLoopId)) {
    LLVM_DEBUG(dbgs() << ""Failed interchange InnerLoopId = "" << InnerLoopId
                      << "" and OuterLoopId = "" << OuterLoopId
                      << "" due to dependence\\n"");
    ORE->emit([&]() {
      return OptimizationRemarkMissed(DEBUG_TYPE, ""Dependence"",
                                      InnerLoop->getStartLoc(),
                                      InnerLoop->getHeader())
             << ""Cannot interchange loops due to dependences."";
    });
    return false;
  }
  // Check if outer and inner loop contain legal instructions only.
  for (auto *BB : OuterLoop->blocks())
    for (Instruction &I : BB->instructionsWithoutDebug())
      if (CallInst *CI = dyn_cast<CallInst>(&I)) {
        // readnone functions do not prevent interchanging.
        if (CI->onlyWritesMemory())
          continue;
        LLVM_DEBUG(
            dbgs() << ""Loops with call instructions cannot be interchanged ""
                   << ""safely."");
        ORE->emit([&]() {
          return OptimizationRemarkMissed(DEBUG_TYPE, ""CallInst"",
                                          CI->getDebugLoc(),
                                          CI->getParent())
                 << ""Cannot interchange loops due to call instruction."";
        });

        return false;
      }

  if (!findInductions(InnerLoop, InnerLoopInductions)) {
    LLVM_DEBUG(dbgs() << ""Cound not find inner loop induction variables.\\n"");
    return false;
  }

  if (!areInnerLoopLatchPHIsSupported(OuterLoop, InnerLoop)) {
    LLVM_DEBUG(dbgs() << ""Found unsupported PHI nodes in inner loop latch.\\n"");
    ORE->emit([&]() {
      return OptimizationRemarkMissed(DEBUG_TYPE, ""UnsupportedInnerLatchPHI"",
                                      InnerLoop->getStartLoc(),
                                      InnerLoop->getHeader())
             << ""Cannot interchange loops because unsupported PHI nodes found ""
                ""in inner loop latch."";
    });
    return false;
  }

  // TODO: The loops could not be interchanged due to current limitations in the
  // transform module.
  if (currentLimitations()) {
    LLVM_DEBUG(dbgs() << ""Not legal because of current transform limitation\\n"");
    return false;
  }

  // Check if the loops are tightly nested.
  if (!tightlyNested(OuterLoop, InnerLoop)) {
    LLVM_DEBUG(dbgs() << ""Loops not tightly nested\\n"");
    ORE->emit([&]() {
      return OptimizationRemarkMissed(DEBUG_TYPE, ""NotTightlyNested"",
                                      InnerLoop->getStartLoc(),
                                      InnerLoop->getHeader())
             << ""Cannot interchange loops because they are not tightly ""
                ""nested."";
    });
    return false;
  }

  if (!areInnerLoopExitPHIsSupported(OuterLoop, InnerLoop,
                                     OuterInnerReductions)) {
    LLVM_DEBUG(dbgs() << ""Found unsupported PHI nodes in inner loop exit.\\n"");
    ORE->emit([&]() {
      return OptimizationRemarkMissed(DEBUG_TYPE, ""UnsupportedExitPHI"",
                                      InnerLoop->getStartLoc(),
                                      InnerLoop->getHeader())
             << ""Found unsupported PHI node in loop exit."";
    });
    return false;
  }

  if (!areOuterLoopExitPHIsSupported(OuterLoop, InnerLoop)) {
    LLVM_DEBUG(dbgs() << ""Found unsupported PHI nodes in outer loop exit.\\n"");
    ORE->emit([&]() {
      return OptimizationRemarkMissed(DEBUG_TYPE, ""UnsupportedExitPHI"",
                                      OuterLoop->getStartLoc(),
                                      OuterLoop->getHeader())
             << ""Found unsupported PHI node in loop exit."";
    });
    return false;
  }

  return true;
}

int LoopInterchangeProfitability::getInstrOrderCost() {
  unsigned GoodOrder, BadOrder;
  BadOrder = GoodOrder = 0;
  for (BasicBlock *BB : InnerLoop->blocks()) {
    for (Instruction &Ins : *BB) {
      if (const GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(&Ins)) {
        unsigned NumOp = GEP->getNumOperands();
        bool FoundInnerInduction = false;
        bool FoundOuterInduction = false;
        for (unsigned i = 0; i < NumOp; ++i) {
          // Skip operands that are not SCEV-able.
          if (!SE->isSCEVable(GEP->getOperand(i)->getType()))
            continue;

          const SCEV *OperandVal = SE->getSCEV(GEP->getOperand(i));
          const SCEVAddRecExpr *AR = dyn_cast<SCEVAddRecExpr>(OperandVal);
          if (!AR)
            continue;

          // If we find the inner induction after an outer induction e.g.
          // for(int i=0;i<N;i++)
          //   for(int j=0;j<N;j++)
          //     A[i][j] = A[i-1][j-1]+k;
          // then it is a good order.
          if (AR->getLoop() == InnerLoop) {
            // We found an InnerLoop induction after OuterLoop induction. It is
            // a good order.
            FoundInnerInduction = true;
            if (FoundOuterInduction) {
              GoodOrder++;
              break;
            }
          }
          // If we find the outer induction after an inner induction e.g.
          // for(int i=0;i<N;i++)
          //   for(int j=0;j<N;j++)
          //     A[j][i] = A[j-1][i-1]+k;
          // then it is a bad order.
          if (AR->getLoop() == OuterLoop) {
            // We found an OuterLoop induction after InnerLoop induction. It is
            // a bad order.
            FoundOuterInduction = true;
            if (FoundInnerInduction) {
              BadOrder++;
              break;
            }
          }
        }
      }
    }
  }
  return GoodOrder - BadOrder;
}

static bool isProfitableForVectorization(unsigned InnerLoopId,
                                         unsigned OuterLoopId,
                                         CharMatrix &DepMatrix) {
  // TODO: Improve this heuristic to catch more cases.
  // If the inner loop is loop independent or doesn't carry any dependency it is
  // profitable to move this to outer position.
  for (auto &Row : DepMatrix) {
    if (Row[InnerLoopId] != 'S' && Row[InnerLoopId] != 'I')
      return false;
    // TODO: We need to improve this heuristic.
    if (Row[OuterLoopId] != '=')
      return false;
  }
  // If outer loop has dependence and inner loop is loop independent then it is
  // profitable to interchange to enable parallelism.
  // If there are no dependences, interchanging will not improve anything.
  return !DepMatrix.empty();
}

bool LoopInterchangeProfitability::isProfitable(unsigned InnerLoopId,
                                                unsigned OuterLoopId,
                                                CharMatrix &DepMatrix) {
  // TODO: Add better profitability checks.
  // e.g
  // 1) Construct dependency matrix and move the one with no loop carried dep
  //    inside to enable vectorization.

  // This is rough cost estimation algorithm. It counts the good and bad order
  // of induction variables in the instruction and allows reordering if number
  // of bad orders is more than good.
  int Cost = getInstrOrderCost();
  LLVM_DEBUG(dbgs() << ""Cost = "" << Cost << ""\\n"");
  if (Cost < -LoopInterchangeCostThreshold)
    return true;

  // It is not profitable as per current cache profitability model. But check if
  // we can move this loop outside to improve parallelism.
  if (isProfitableForVectorization(InnerLoopId, OuterLoopId, DepMatrix))
    return true;

  ORE->emit([&]() {
    return OptimizationRemarkMissed(DEBUG_TYPE, ""InterchangeNotProfitable"",
                                    InnerLoop->getStartLoc(),
                                    InnerLoop->getHeader())
           << ""Interchanging loops is too costly (cost=""
           << ore::NV(""Cost"", Cost) << "", threshold=""
           << ore::NV(""Threshold"", LoopInterchangeCostThreshold)
           << "") and it does not improve parallelism."";
  });
  return false;
}

void LoopInterchangeTransform::removeChildLoop(Loop *OuterLoop,
                                               Loop *InnerLoop) {
  for (Loop *L : *OuterLoop)
    if (L == InnerLoop) {
      OuterLoop->removeChildLoop(L);
      return;
    }
  llvm_unreachable(""Couldn't find loop"");
}

/// Update LoopInfo, after interchanging. NewInner and NewOuter refer to the
/// new inner and outer loop after interchanging: NewInner is the original
/// outer loop and NewOuter is the original inner loop.
///
/// Before interchanging, we have the following structure
/// Outer preheader
//  Outer header
//    Inner preheader
//    Inner header
//      Inner body
//      Inner latch
//   outer bbs
//   Outer latch
//
// After interchanging:
// Inner preheader
// Inner header
//   Outer preheader
//   Outer header
//     Inner body
//     outer bbs
//     Outer latch
//   Inner latch
void LoopInterchangeTransform::restructureLoops(
    Loop *NewInner, Loop *NewOuter, BasicBlock *OrigInnerPreHeader,
    BasicBlock *OrigOuterPreHeader) {
  Loop *OuterLoopParent = OuterLoop->getParentLoop();
  // The original inner loop preheader moves from the new inner loop to
  // the parent loop, if there is one.
  NewInner->removeBlockFromLoop(OrigInnerPreHeader);
  LI->changeLoopFor(OrigInnerPreHeader, OuterLoopParent);

  // Switch the loop levels.
  if (OuterLoopParent) {
    // Remove the loop from its parent loop.
    removeChildLoop(OuterLoopParent, NewInner);
    removeChildLoop(NewInner, NewOuter);
    OuterLoopParent->addChildLoop(NewOuter);
  } else {
    removeChildLoop(NewInner, NewOuter);
    LI->changeTopLevelLoop(NewInner, NewOuter);
  }
  while (!NewOuter->isInnermost())
    NewInner->addChildLoop(NewOuter->removeChildLoop(NewOuter->begin()));
  NewOuter->addChildLoop(NewInner);

  // BBs from the original inner loop.
  SmallVector<BasicBlock *, 8> OrigInnerBBs(NewOuter->blocks());

  // Add BBs from the original outer loop to the original inner loop (excluding
  // BBs already in inner loop)
  for (BasicBlock *BB : NewInner->blocks())
    if (LI->getLoopFor(BB) == NewInner)
      NewOuter->addBlockEntry(BB);

  // Now remove inner loop header and latch from the new inner loop and move
  // other BBs (the loop body) to the new inner loop.
  BasicBlock *OuterHeader = NewOuter->getHeader();
  BasicBlock *OuterLatch = NewOuter->getLoopLatch();
  for (BasicBlock *BB : OrigInnerBBs) {
    // Nothing will change for BBs in child loops.
    if (LI->getLoopFor(BB) != NewOuter)
      continue;
    // Remove the new outer loop header and latch from the new inner loop.
    if (BB == OuterHeader || BB == OuterLatch)
      NewInner->removeBlockFromLoop(BB);
    else
      LI->changeLoopFor(BB, NewInner);
  }

  // The preheader of the original outer loop becomes part of the new
  // outer loop.
  NewOuter->addBlockEntry(OrigOuterPreHeader);
  LI->changeLoopFor(OrigOuterPreHeader, NewOuter);

  // Tell SE that we move the loops around.
  SE->forgetLoop(NewOuter);
  SE->forgetLoop(NewInner);
}

bool LoopInterchangeTransform::transform() {
  bool Transformed = false;

  if (InnerLoop->getSubLoops().empty()) {
    BasicBlock *InnerLoopPreHeader = InnerLoop->getLoopPreheader();
    LLVM_DEBUG(dbgs() << ""Splitting the inner loop latch\\n"");
    auto &InductionPHIs = LIL.getInnerLoopInductions();
    if (InductionPHIs.empty()) {
      LLVM_DEBUG(dbgs() << ""Failed to find the point to split loop latch \\n"");
      return false;
    }

    SmallVector<Instruction *, 8> InnerIndexVarList;
    for (PHINode *CurInductionPHI : InductionPHIs) {
      if (CurInductionPHI->getIncomingBlock(0) == InnerLoopPreHeader)
        InnerIndexVarList.push_back(
            dyn_cast<Instruction>(CurInductionPHI->getIncomingValue(1)));
      else
        InnerIndexVarList.push_back(
            dyn_cast<Instruction>(CurInductionPHI->getIncomingValue(0)));
    }

    // Create a new latch block for the inner loop. We split at the
    // current latch's terminator and then move the condition and all
    // operands that are not either loop-invariant or the induction PHI into the
    // new latch block.
    BasicBlock *NewLatch =
        SplitBlock(InnerLoop->getLoopLatch(),
                   InnerLoop->getLoopLatch()->getTerminator(), DT, LI);

    SmallSetVector<Instruction *, 4> WorkList;
    unsigned i = 0;
    auto MoveInstructions = [&i, &WorkList, this, &InductionPHIs, NewLatch]() {
      for (; i < WorkList.size(); i++) {
        // Duplicate instruction and move it the new latch. Update uses that
        // have been moved.
        Instruction *NewI = WorkList[i]->clone();
        NewI->insertBefore(NewLatch->getFirstNonPHI());
        assert(!NewI->mayHaveSideEffects() &&
               ""Moving instructions with side-effects may change behavior of ""
               ""the loop nest!"");
        for (Use &U : llvm::make_early_inc_range(WorkList[i]->uses())) {
          Instruction *UserI = cast<Instruction>(U.getUser());
          if (!InnerLoop->contains(UserI->getParent()) ||
              UserI->getParent() == NewLatch ||
              llvm::is_contained(InductionPHIs, UserI))
            U.set(NewI);
        }
        // Add operands of moved instruction to the worklist, except if they are
        // outside the inner loop or are the induction PHI.
        for (Value *Op : WorkList[i]->operands()) {
          Instruction *OpI = dyn_cast<Instruction>(Op);
          if (!OpI ||
              this->LI->getLoopFor(OpI->getParent()) != this->InnerLoop ||
              llvm::is_contained(InductionPHIs, OpI))
            continue;
          WorkList.insert(OpI);
        }
      }
    };

    // FIXME: Should we interchange when we have a constant condition?
    Instruction *CondI = dyn_cast<Instruction>(
        cast<BranchInst>(InnerLoop->getLoopLatch()->getTerminator())
            ->getCondition());
    if (CondI)
      WorkList.insert(CondI);
    MoveInstructions();
    for (Instruction *InnerIndexVar : InnerIndexVarList)
      WorkList.insert(cast<Instruction>(InnerIndexVar));
    MoveInstructions();

    // Splits the inner loops phi nodes out into a separate basic block.
    BasicBlock *InnerLoopHeader = InnerLoop->getHeader();
    SplitBlock(InnerLoopHeader, InnerLoopHeader->getFirstNonPHI(), DT, LI);
    LLVM_DEBUG(dbgs() << ""splitting InnerLoopHeader done\\n"");
  }

  // Instructions in the original inner loop preheader may depend on values
  // defined in the outer loop header. Move them there, because the original
  // inner loop preheader will become the entry into the interchanged loop nest.
  // Currently we move all instructions and rely on LICM to move invariant
  // instructions outside the loop nest.
  BasicBlock *InnerLoopPreHeader = InnerLoop->getLoopPreheader();
  BasicBlock *OuterLoopHeader = OuterLoop->getHeader();
  if (InnerLoopPreHeader != OuterLoopHeader) {
    SmallPtrSet<Instruction *, 4> NeedsMoving;
    for (Instruction &I :
         make_early_inc_range(make_range(InnerLoopPreHeader->begin(),
                                         std::prev(InnerLoopPreHeader->end()))))
      I.moveBefore(OuterLoopHeader->getTerminator());
  }

  Transformed |= adjustLoopLinks();
  if (!Transformed) {
    LLVM_DEBUG(dbgs() << ""adjustLoopLinks failed\\n"");
    return false;
  }

  return true;
}

/// \\brief Move all instructions except the terminator from FromBB right before
/// InsertBefore
static void moveBBContents(BasicBlock *FromBB, Instruction *InsertBefore) {
  auto &ToList = InsertBefore->getParent()->getInstList();
  auto &FromList = FromBB->getInstList();

  ToList.splice(InsertBefore->getIterator(), FromList, FromList.begin(),
                FromBB->getTerminator()->getIterator());
}

/// Swap instructions between \\p BB1 and \\p BB2 but keep terminators intact.
static void swapBBContents(BasicBlock *BB1, BasicBlock *BB2) {
  // Save all non-terminator instructions of BB1 into TempInstrs and unlink them
  // from BB1 afterwards.
  auto Iter = map_range(*BB1, [](Instruction &I) { return &I; });
  SmallVector<Instruction *, 4> TempInstrs(Iter.begin(), std::prev(Iter.end()));
  for (Instruction *I : TempInstrs)
    I->removeFromParent();

  // Move instructions from BB2 to BB1.
  moveBBContents(BB2, BB1->getTerminator());

  // Move instructions from TempInstrs to BB2.
  for (Instruction *I : TempInstrs)
    I->insertBefore(BB2->getTerminator());
}

// Update BI to jump to NewBB instead of OldBB. Records updates to the
// dominator tree in DTUpdates. If \\p MustUpdateOnce is true, assert that
// \\p OldBB  is exactly once in BI's successor list.
static void updateSuccessor(BranchInst *BI, BasicBlock *OldBB,
                            BasicBlock *NewBB,
                            std::vector<DominatorTree::UpdateType> &DTUpdates,
                            bool MustUpdateOnce = true) {
  assert((!MustUpdateOnce ||
          llvm::count_if(successors(BI),
                         [OldBB](BasicBlock *BB) {
                           return BB == OldBB;
                         }) == 1) && ""BI must jump to OldBB exactly once."");
  bool Changed = false;
  for (Use &Op : BI->operands())
    if (Op == OldBB) {
      Op.set(NewBB);
      Changed = true;
    }

  if (Changed) {
    DTUpdates.push_back(
        {DominatorTree::UpdateKind::Insert, BI->getParent(), NewBB});
    DTUpdates.push_back(
        {DominatorTree::UpdateKind::Delete, BI->getParent(), OldBB});
  }
  assert(Changed && ""Expected a successor to be updated"");
}

// Move Lcssa PHIs to the right place.
static void moveLCSSAPhis(BasicBlock *InnerExit, BasicBlock *InnerHeader,
                          BasicBlock *InnerLatch, BasicBlock *OuterHeader,
                          BasicBlock *OuterLatch, BasicBlock *OuterExit,
                          Loop *InnerLoop, LoopInfo *LI) {

  // Deal with LCSSA PHI nodes in the exit block of the inner loop, that are
  // defined either in the header or latch. Those blocks will become header and
  // latch of the new outer loop, and the only possible users can PHI nodes
  // in the exit block of the loop nest or the outer loop header (reduction
  // PHIs, in that case, the incoming value must be defined in the inner loop
  // header). We can just substitute the user with the incoming value and remove
  // the PHI.
  for (PHINode &P : make_early_inc_range(InnerExit->phis())) {
    assert(P.getNumIncomingValues() == 1 &&
           ""Only loops with a single exit are supported!"");

    // Incoming values are guaranteed be instructions currently.
    auto IncI = cast<Instruction>(P.getIncomingValueForBlock(InnerLatch));
    // Skip phis with incoming values from the inner loop body, excluding the
    // header and latch.
    if (IncI->getParent() != InnerLatch && IncI->getParent() != InnerHeader)
      continue;

    assert(all_of(P.users(),
                  [OuterHeader, OuterExit, IncI, InnerHeader](User *U) {
                    return (cast<PHINode>(U)->getParent() == OuterHeader &&
                            IncI->getParent() == InnerHeader) ||
                           cast<PHINode>(U)->getParent() == OuterExit;
                  }) &&
           ""Can only replace phis iff the uses are in the loop nest exit or ""
           ""the incoming value is defined in the inner header (it will ""
           ""dominate all loop blocks after interchanging)"");
    P.replaceAllUsesWith(IncI);
    P.eraseFromParent();
  }

  SmallVector<PHINode *, 8> LcssaInnerExit;
  for (PHINode &P : InnerExit->phis())
    LcssaInnerExit.push_back(&P);

  SmallVector<PHINode *, 8> LcssaInnerLatch;
  for (PHINode &P : InnerLatch->phis())
    LcssaInnerLatch.push_back(&P);

  // Lcssa PHIs for values used outside the inner loop are in InnerExit.
  // If a PHI node has users outside of InnerExit, it has a use outside the
  // interchanged loop and we have to preserve it. We move these to
  // InnerLatch, which will become the new exit block for the innermost
  // loop after interchanging.
  for (PHINode *P : LcssaInnerExit)
    P->moveBefore(InnerLatch->getFirstNonPHI());

  // If the inner loop latch contains LCSSA PHIs, those come from a child loop
  // and we have to move them to the new inner latch.
  for (PHINode *P : LcssaInnerLatch)
    P->moveBefore(InnerExit->getFirstNonPHI());

  // Deal with LCSSA PHI nodes in the loop nest exit block. For PHIs that have
  // incoming values defined in the outer loop, we have to add a new PHI
  // in the inner loop latch, which became the exit block of the outer loop,
  // after interchanging.
  if (OuterExit) {
    for (PHINode &P : OuterExit->phis()) {
      if (P.getNumIncomingValues() != 1)
        continue;
      // Skip Phis with incoming values defined in the inner loop. Those should
      // already have been updated.
      auto I = dyn_cast<Instruction>(P.getIncomingValue(0));
      if (!I || LI->getLoopFor(I->getParent()) == InnerLoop)
        continue;

      PHINode *NewPhi = dyn_cast<PHINode>(P.clone());
      NewPhi->setIncomingValue(0, P.getIncomingValue(0));
      NewPhi->setIncomingBlock(0, OuterLatch);
      // We might have incoming edges from other BBs, i.e., the original outer
      // header.
      for (auto *Pred : predecessors(InnerLatch)) {
        if (Pred == OuterLatch)
          continue;
        NewPhi->addIncoming(P.getIncomingValue(0), Pred);
      }
      NewPhi->insertBefore(InnerLatch->getFirstNonPHI());
      P.setIncomingValue(0, NewPhi);
    }
  }

  // Now adjust the incoming blocks for the LCSSA PHIs.
  // For PHIs moved from Inner's exit block, we need to replace Inner's latch
  // with the new latch.
  InnerLatch->replacePhiUsesWith(InnerLatch, OuterLatch);
}

bool LoopInterchangeTransform::adjustLoopBranches() {
  LLVM_DEBUG(dbgs() << ""adjustLoopBranches called\\n"");
  std::vector<DominatorTree::UpdateType> DTUpdates;

  BasicBlock *OuterLoopPreHeader = OuterLoop->getLoopPreheader();
  BasicBlock *InnerLoopPreHeader = InnerLoop->getLoopPreheader();

  assert(OuterLoopPreHeader != OuterLoop->getHeader() &&
         InnerLoopPreHeader != InnerLoop->getHeader() && OuterLoopPreHeader &&
         InnerLoopPreHeader && ""Guaranteed by loop-simplify form"");
  // Ensure that both preheaders do not contain PHI nodes and have single
  // predecessors. This allows us to move them easily. We use
  // InsertPreHeaderForLoop to create an 'extra' preheader, if the existing
  // preheaders do not satisfy those conditions.
  if (isa<PHINode>(OuterLoopPreHeader->begin()) ||
      !OuterLoopPreHeader->getUniquePredecessor())
    OuterLoopPreHeader =
        InsertPreheaderForLoop(OuterLoop, DT, LI, nullptr, true);
  if (InnerLoopPreHeader == OuterLoop->getHeader())
    InnerLoopPreHeader =
        InsertPreheaderForLoop(InnerLoop, DT, LI, nullptr, true);

  // Adjust the loop preheader
  BasicBlock *InnerLoopHeader = InnerLoop->getHeader();
  BasicBlock *OuterLoopHeader = OuterLoop->getHeader();
  BasicBlock *InnerLoopLatch = InnerLoop->getLoopLatch();
  BasicBlock *OuterLoopLatch = OuterLoop->getLoopLatch();
  BasicBlock *OuterLoopPredecessor = OuterLoopPreHeader->getUniquePredecessor();
  BasicBlock *InnerLoopLatchPredecessor =
      InnerLoopLatch->getUniquePredecessor();
  BasicBlock *InnerLoopLatchSuccessor;
  BasicBlock *OuterLoopLatchSuccessor;

  BranchInst *OuterLoopLatchBI =
      dyn_cast<BranchInst>(OuterLoopLatch->getTerminator());
  BranchInst *InnerLoopLatchBI =
      dyn_cast<BranchInst>(InnerLoopLatch->getTerminator());
  BranchInst *OuterLoopHeaderBI =
      dyn_cast<BranchInst>(OuterLoopHeader->getTerminator());
  BranchInst *InnerLoopHeaderBI =
      dyn_cast<BranchInst>(InnerLoopHeader->getTerminator());

  if (!OuterLoopPredecessor || !InnerLoopLatchPredecessor ||
      !OuterLoopLatchBI || !InnerLoopLatchBI || !OuterLoopHeaderBI ||
      !InnerLoopHeaderBI)
    return false;

  BranchInst *InnerLoopLatchPredecessorBI =
      dyn_cast<BranchInst>(InnerLoopLatchPredecessor->getTerminator());
  BranchInst *OuterLoopPredecessorBI =
      dyn_cast<BranchInst>(OuterLoopPredecessor->getTerminator());

  if (!OuterLoopPredecessorBI || !InnerLoopLatchPredecessorBI)
    return false;
  BasicBlock *InnerLoopHeaderSuccessor = InnerLoopHeader->getUniqueSuccessor();
  if (!InnerLoopHeaderSuccessor)
    return false;

  // Adjust Loop Preheader and headers.
  // The branches in the outer loop predecessor and the outer loop header can
  // be unconditional branches or conditional branches with duplicates. Consider
  // this when updating the successors.
  updateSuccessor(OuterLoopPredecessorBI, OuterLoopPreHeader,
                  InnerLoopPreHeader, DTUpdates, /*MustUpdateOnce=*/false);
  // The outer loop header might or might not branch to the outer latch.
  // We are guaranteed to branch to the inner loop preheader.
  if (llvm::is_contained(OuterLoopHeaderBI->successors(), OuterLoopLatch)) {
    // In this case the outerLoopHeader should branch to the InnerLoopLatch.
    updateSuccessor(OuterLoopHeaderBI, OuterLoopLatch, InnerLoopLatch,
                    DTUpdates,
                    /*MustUpdateOnce=*/false);
  }
  updateSuccessor(OuterLoopHeaderBI, InnerLoopPreHeader,
                  InnerLoopHeaderSuccessor, DTUpdates,
                  /*MustUpdateOnce=*/false);

  // Adjust reduction PHI's now that the incoming block has changed.
  InnerLoopHeaderSuccessor->replacePhiUsesWith(InnerLoopHeader,
                                               OuterLoopHeader);

  updateSuccessor(InnerLoopHeaderBI, InnerLoopHeaderSuccessor,
                  OuterLoopPreHeader, DTUpdates);

  // -------------Adjust loop latches-----------
  if (InnerLoopLatchBI->getSuccessor(0) == InnerLoopHeader)
    InnerLoopLatchSuccessor = InnerLoopLatchBI->getSuccessor(1);
  else
    InnerLoopLatchSuccessor = InnerLoopLatchBI->getSuccessor(0);

  updateSuccessor(InnerLoopLatchPredecessorBI, InnerLoopLatch,
                  InnerLoopLatchSuccessor, DTUpdates);

  if (OuterLoopLatchBI->getSuccessor(0) == OuterLoopHeader)
    OuterLoopLatchSuccessor = OuterLoopLatchBI->getSuccessor(1);
  else
    OuterLoopLatchSuccessor = OuterLoopLatchBI->getSuccessor(0);

  updateSuccessor(InnerLoopLatchBI, InnerLoopLatchSuccessor,
                  OuterLoopLatchSuccessor, DTUpdates);
  updateSuccessor(OuterLoopLatchBI, OuterLoopLatchSuccessor, InnerLoopLatch,
                  DTUpdates);

  DT->applyUpdates(DTUpdates);
  restructureLoops(OuterLoop, InnerLoop, InnerLoopPreHeader,
                   OuterLoopPreHeader);

  moveLCSSAPhis(InnerLoopLatchSuccessor, InnerLoopHeader, InnerLoopLatch,
                OuterLoopHeader, OuterLoopLatch, InnerLoop->getExitBlock(),
                InnerLoop, LI);
  // For PHIs in the exit block of the outer loop, outer's latch has been
  // replaced by Inners'.
  OuterLoopLatchSuccessor->replacePhiUsesWith(OuterLoopLatch, InnerLoopLatch);

  auto &OuterInnerReductions = LIL.getOuterInnerReductions();
  // Now update the reduction PHIs in the inner and outer loop headers.
  SmallVector<PHINode *, 4> InnerLoopPHIs, OuterLoopPHIs;
  for (PHINode &PHI : InnerLoopHeader->phis())
    if (OuterInnerReductions.contains(&PHI))
      InnerLoopPHIs.push_back(&PHI);

  for (PHINode &PHI : OuterLoopHeader->phis())
    if (OuterInnerReductions.contains(&PHI))
      OuterLoopPHIs.push_back(&PHI);

  // Now move the remaining reduction PHIs from outer to inner loop header and
  // vice versa. The PHI nodes must be part of a reduction across the inner and
  // outer loop and all the remains to do is and updating the incoming blocks.
  for (PHINode *PHI : OuterLoopPHIs) {
    LLVM_DEBUG(dbgs() << ""Outer loop reduction PHIs:\\n""; PHI->dump(););
    PHI->moveBefore(InnerLoopHeader->getFirstNonPHI());
    assert(OuterInnerReductions.count(PHI) && ""Expected a reduction PHI node"");
  }
  for (PHINode *PHI : InnerLoopPHIs) {
    LLVM_DEBUG(dbgs() << ""Inner loop reduction PHIs:\\n""; PHI->dump(););
    PHI->moveBefore(OuterLoopHeader->getFirstNonPHI());
    assert(OuterInnerReductions.count(PHI) && ""Expected a reduction PHI node"");
  }

  // Update the incoming blocks for moved PHI nodes.
  OuterLoopHeader->replacePhiUsesWith(InnerLoopPreHeader, OuterLoopPreHeader);
  OuterLoopHeader->replacePhiUsesWith(InnerLoopLatch, OuterLoopLatch);
  InnerLoopHeader->replacePhiUsesWith(OuterLoopPreHeader, InnerLoopPreHeader);
  InnerLoopHeader->replacePhiUsesWith(OuterLoopLatch, InnerLoopLatch);

  // Values defined in the outer loop header could be used in the inner loop
  // latch. In that case, we need to create LCSSA phis for them, because after
  // interchanging they will be defined in the new inner loop and used in the
  // new outer loop.
  IRBuilder<> Builder(OuterLoopHeader->getContext());
  SmallVector<Instruction *, 4> MayNeedLCSSAPhis;
  for (Instruction &I :
       make_range(OuterLoopHeader->begin(), std::prev(OuterLoopHeader->end())))
    MayNeedLCSSAPhis.push_back(&I);
  formLCSSAForInstructions(MayNeedLCSSAPhis, *DT, *LI, SE, Builder);

  return true;
}

bool LoopInterchangeTransform::adjustLoopLinks() {
  // Adjust all branches in the inner and outer loop.
  bool Changed = adjustLoopBranches();
  if (Changed) {
    // We have interchanged the preheaders so we need to interchange the data in
    // the preheaders as well. This is because the content of the inner
    // preheader was previously executed inside the outer loop.
    BasicBlock *OuterLoopPreHeader = OuterLoop->getLoopPreheader();
    BasicBlock *InnerLoopPreHeader = InnerLoop->getLoopPreheader();
    swapBBContents(OuterLoopPreHeader, InnerLoopPreHeader);
  }
  return Changed;
}

namespace {
/// Main LoopInterchange Pass.
struct LoopInterchangeLegacyPass : public LoopPass {
  static char ID;

  LoopInterchangeLegacyPass() : LoopPass(ID) {
    initializeLoopInterchangeLegacyPassPass(*PassRegistry::getPassRegistry());
  }

  void getAnalysisUsage(AnalysisUsage &AU) const override {
    AU.addRequired<DependenceAnalysisWrapperPass>();
    AU.addRequired<OptimizationRemarkEmitterWrapperPass>();

    getLoopAnalysisUsage(AU);
  }

  bool runOnLoop(Loop *L, LPPassManager &LPM) override {
    if (skipLoop(L))
      return false;

    auto *SE = &getAnalysis<ScalarEvolutionWrapperPass>().getSE();
    auto *LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
    auto *DI = &getAnalysis<DependenceAnalysisWrapperPass>().getDI();
    auto *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
    auto *ORE = &getAnalysis<OptimizationRemarkEmitterWrapperPass>().getORE();

    return LoopInterchange(SE, LI, DI, DT, ORE).run(L);
  }
};
} // namespace

char LoopInterchangeLegacyPass::ID = 0;

INITIALIZE_PASS_BEGIN(LoopInterchangeLegacyPass, ""loop-interchange"",
                      ""Interchanges loops for cache reuse"", false, false)
INITIALIZE_PASS_DEPENDENCY(LoopPass)
INITIALIZE_PASS_DEPENDENCY(DependenceAnalysisWrapperPass)
INITIALIZE_PASS_DEPENDENCY(OptimizationRemarkEmitterWrapperPass)

INITIALIZE_PASS_END(LoopInterchangeLegacyPass, ""loop-interchange"",
                    ""Interchanges loops for cache reuse"", false, false)

Pass *llvm::createLoopInterchangePass() {
  return new LoopInterchangeLegacyPass();
}

PreservedAnalyses LoopInterchangePass::run(LoopNest &LN,
                                           LoopAnalysisManager &AM,
                                           LoopStandardAnalysisResults &AR,
                                           LPMUpdater &U) {
  Function &F = *LN.getParent();

  DependenceInfo DI(&F, &AR.AA, &AR.SE, &AR.LI);
  OptimizationRemarkEmitter ORE(&F);
  if (!LoopInterchange(&AR.SE, &AR.LI, &DI, &AR.DT, &ORE).run(LN))
    return PreservedAnalyses::all();
  return getLoopPassPreservedAnalyses();
}
",16253,True,2982.8778666213434,median
"

[[Elasticsearch_Client]]
=== Elasticsearch\\Client



Class Client

*Description*


NOTE: this file is autogenerated using util/GenerateEndpoints.php
and Elasticsearch 7.12.1 (3186837139b9c6b6d23c3200870651f10d3343b7)


*Methods*

The class defines the following methods:

* <<Elasticsearch_Clientbulk_bulk,`bulk()`>>
* <<Elasticsearch_ClientclearScroll_clearScroll,`clearScroll()`>>
* <<Elasticsearch_ClientclosePointInTime_closePointInTime,`closePointInTime()`>>
* <<Elasticsearch_Clientcount_count,`count()`>>
* <<Elasticsearch_Clientcreate_create,`create()`>>
* <<Elasticsearch_Clientdelete_delete,`delete()`>>
* <<Elasticsearch_ClientdeleteByQuery_deleteByQuery,`deleteByQuery()`>>
* <<Elasticsearch_ClientdeleteByQueryRethrottle_deleteByQueryRethrottle,`deleteByQueryRethrottle()`>>
* <<Elasticsearch_ClientdeleteScript_deleteScript,`deleteScript()`>>
* <<Elasticsearch_Clientexists_exists,`exists()`>>
* <<Elasticsearch_ClientexistsSource_existsSource,`existsSource()`>>
* <<Elasticsearch_Clientexplain_explain,`explain()`>>
* <<Elasticsearch_ClientfieldCaps_fieldCaps,`fieldCaps()`>>
* <<Elasticsearch_Clientget_get,`get()`>>
* <<Elasticsearch_ClientgetScript_getScript,`getScript()`>>
* <<Elasticsearch_ClientgetScriptContext_getScriptContext,`getScriptContext()`>>
* <<Elasticsearch_ClientgetScriptLanguages_getScriptLanguages,`getScriptLanguages()`>>
* <<Elasticsearch_ClientgetSource_getSource,`getSource()`>>
* <<Elasticsearch_Clientindex_index,`index()`>>
* <<Elasticsearch_Clientinfo_info,`info()`>>
* <<Elasticsearch_Clientmget_mget,`mget()`>>
* <<Elasticsearch_Clientmsearch_msearch,`msearch()`>>
* <<Elasticsearch_ClientmsearchTemplate_msearchTemplate,`msearchTemplate()`>>
* <<Elasticsearch_Clientmtermvectors_mtermvectors,`mtermvectors()`>>
* <<Elasticsearch_ClientopenPointInTime_openPointInTime,`openPointInTime()`>>
* <<Elasticsearch_Clientping_ping,`ping()`>>
* <<Elasticsearch_ClientputScript_putScript,`putScript()`>>
* <<Elasticsearch_ClientrankEval_rankEval,`rankEval()`>>
* <<Elasticsearch_Clientreindex_reindex,`reindex()`>>
* <<Elasticsearch_ClientreindexRethrottle_reindexRethrottle,`reindexRethrottle()`>>
* <<Elasticsearch_ClientrenderSearchTemplate_renderSearchTemplate,`renderSearchTemplate()`>>
* <<Elasticsearch_ClientscriptsPainlessExecute_scriptsPainlessExecute,`scriptsPainlessExecute()`>>
* <<Elasticsearch_Clientscroll_scroll,`scroll()`>>
* <<Elasticsearch_Clientsearch_search,`search()`>>
* <<Elasticsearch_ClientsearchShards_searchShards,`searchShards()`>>
* <<Elasticsearch_ClientsearchTemplate_searchTemplate,`searchTemplate()`>>
* <<Elasticsearch_Clienttermvectors_termvectors,`termvectors()`>>
* <<Elasticsearch_Clientupdate_update,`update()`>>
* <<Elasticsearch_ClientupdateByQuery_updateByQuery,`updateByQuery()`>>
* <<Elasticsearch_ClientupdateByQueryRethrottle_updateByQueryRethrottle,`updateByQueryRethrottle()`>>
* <<Elasticsearch_ClientasyncSearch_asyncSearch,`asyncSearch()`>>
* <<Elasticsearch_Clientautoscaling_autoscaling,`autoscaling()`>>
* <<Elasticsearch_Clientcat_cat,`cat()`>>
* <<Elasticsearch_Clientccr_ccr,`ccr()`>>
* <<Elasticsearch_Clientcluster_cluster,`cluster()`>>
* <<Elasticsearch_ClientdanglingIndices_danglingIndices,`danglingIndices()`>>
* <<Elasticsearch_ClientdataFrameTransformDeprecated_dataFrameTransformDeprecated,`dataFrameTransformDeprecated()`>>
* <<Elasticsearch_Clientenrich_enrich,`enrich()`>>
* <<Elasticsearch_Clienteql_eql,`eql()`>>
* <<Elasticsearch_Clientfeatures_features,`features()`>>
* <<Elasticsearch_Clientgraph_graph,`graph()`>>
* <<Elasticsearch_Clientilm_ilm,`ilm()`>>
* <<Elasticsearch_Clientindices_indices,`indices()`>>
* <<Elasticsearch_Clientingest_ingest,`ingest()`>>
* <<Elasticsearch_Clientlicense_license,`license()`>>
* <<Elasticsearch_Clientlogstash_logstash,`logstash()`>>
* <<Elasticsearch_Clientmigration_migration,`migration()`>>
* <<Elasticsearch_Clientml_ml,`ml()`>>
* <<Elasticsearch_Clientmonitoring_monitoring,`monitoring()`>>
* <<Elasticsearch_Clientnodes_nodes,`nodes()`>>
* <<Elasticsearch_Clientrollup_rollup,`rollup()`>>
* <<Elasticsearch_ClientsearchableSnapshots_searchableSnapshots,`searchableSnapshots()`>>
* <<Elasticsearch_Clientsecurity_security,`security()`>>
* <<Elasticsearch_Clientslm_slm,`slm()`>>
* <<Elasticsearch_Clientsnapshot_snapshot,`snapshot()`>>
* <<Elasticsearch_Clientsql_sql,`sql()`>>
* <<Elasticsearch_Clientssl_ssl,`ssl()`>>
* <<Elasticsearch_Clienttasks_tasks,`tasks()`>>
* <<Elasticsearch_ClienttextStructure_textStructure,`textStructure()`>>
* <<Elasticsearch_Clienttransform_transform,`transform()`>>
* <<Elasticsearch_Clientwatcher_watcher,`watcher()`>>
* <<Elasticsearch_Clientxpack_xpack,`xpack()`>>
* <<Elasticsearch_Client-call-_call,`__call()`>>
* <<Elasticsearch_ClientextractArgument_extractArgument,`extractArgument()`>>




[[Elasticsearch_Clientbulk_bulk]]
.`bulk(array $params = [])`
****
[source,php]
----
/*
$params['index']                  = (string) Default index for items which don't provide one
$params['type']                   = DEPRECATED (string) Default document type for items which don't provide one
$params['wait_for_active_shards'] = (string) Sets the number of shard copies that must be active before proceeding with the bulk operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
$params['refresh']                = (enum) If `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes. (Options = true,false,wait_for)
$params['routing']                = (string) Specific routing value
$params['timeout']                = (time) Explicit operation timeout
$params['_source']                = (list) True or false to return the _source field or not, or default list of fields to return, can be overridden on each sub-request
$params['_source_excludes']       = (list) Default list of fields to exclude from the returned _source field, can be overridden on each sub-request
$params['_source_includes']       = (list) Default list of fields to extract and return from the _source field, can be overridden on each sub-request
$params['pipeline']               = (string) The pipeline id to preprocess incoming documents with
$params['require_alias']          = (boolean) Sets require_alias for all incoming documents. Defaults to unset (false)
$params['body']                   = (array) The operation definition and data (action-data pairs), separated by newlines (Required)
*/
----
****



[[Elasticsearch_ClientclearScroll_clearScroll]]
.`clearScroll(array $params = [])`
****
[source,php]
----
/*
$params['scroll_id'] = DEPRECATED (list) A comma-separated list of scroll IDs to clear
$params['body']      = (array) A comma-separated list of scroll IDs to clear if none was specified via the scroll_id parameter
*/
----
****



[[Elasticsearch_ClientclosePointInTime_closePointInTime]]
.`closePointInTime(array $params = [])`
****
[source,php]
----
/*
$params['body'] = (array) a point-in-time id to close
*/
----
****



[[Elasticsearch_Clientcount_count]]
.`count(array $params = [])`
****
[source,php]
----
/*
$params['index']              = (list) A comma-separated list of indices to restrict the results
$params['type']               = DEPRECATED (list) A comma-separated list of types to restrict the results
$params['ignore_unavailable'] = (boolean) Whether specified concrete indices should be ignored when unavailable (missing or closed)
$params['ignore_throttled']   = (boolean) Whether specified concrete, expanded or aliased indices should be ignored when throttled
$params['allow_no_indices']   = (boolean) Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
$params['expand_wildcards']   = (enum) Whether to expand wildcard expression to concrete indices that are open, closed or both. (Options = open,closed,hidden,none,all) (Default = open)
$params['min_score']          = (number) Include only documents with a specific `_score` value in the result
$params['preference']         = (string) Specify the node or shard the operation should be performed on (default: random)
$params['routing']            = (list) A comma-separated list of specific routing values
$params['q']                  = (string) Query in the Lucene query string syntax
$params['analyzer']           = (string) The analyzer to use for the query string
$params['analyze_wildcard']   = (boolean) Specify whether wildcard and prefix queries should be analyzed (default: false)
$params['default_operator']   = (enum) The default operator for query string query (AND or OR) (Options = AND,OR) (Default = OR)
$params['df']                 = (string) The field to use as default where no field prefix is given in the query string
$params['lenient']            = (boolean) Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
$params['terminate_after']    = (number) The maximum count for each shard, upon reaching which the query execution will terminate early
$params['body']               = (array) A query to restrict the results specified with the Query DSL (optional)
*/
----
****



[[Elasticsearch_Clientcreate_create]]
.`create(array $params = [])`
****
[source,php]
----
/*
$params['id']                     = (string) Document ID (Required)
$params['index']                  = (string) The name of the index (Required)
$params['type']                   = DEPRECATED (string) The type of the document
$params['wait_for_active_shards'] = (string) Sets the number of shard copies that must be active before proceeding with the index operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
$params['refresh']                = (enum) If `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes. (Options = true,false,wait_for)
$params['routing']                = (string) Specific routing value
$params['timeout']                = (time) Explicit operation timeout
$params['version']                = (number) Explicit version number for concurrency control
$params['version_type']           = (enum) Specific version type (Options = internal,external,external_gte)
$params['pipeline']               = (string) The pipeline id to preprocess incoming documents with
$params['body']                   = (array) The document (Required)
*/
----
****



[[Elasticsearch_Clientdelete_delete]]
.`delete(array $params = [])`
****
[source,php]
----
/*
$params['id']                     = (string) The document ID (Required)
$params['index']                  = (string) The name of the index (Required)
$params['type']                   = DEPRECATED (string) The type of the document
$params['wait_for_active_shards'] = (string) Sets the number of shard copies that must be active before proceeding with the delete operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
$params['refresh']                = (enum) If `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes. (Options = true,false,wait_for)
$params['routing']                = (string) Specific routing value
$params['timeout']                = (time) Explicit operation timeout
$params['if_seq_no']              = (number) only perform the delete operation if the last operation that has changed the document has the specified sequence number
$params['if_primary_term']        = (number) only perform the delete operation if the last operation that has changed the document has the specified primary term
$params['version']                = (number) Explicit version number for concurrency control
$params['version_type']           = (enum) Specific version type (Options = internal,external,external_gte,force)
*/
----
****



[[Elasticsearch_ClientdeleteByQuery_deleteByQuery]]
.`deleteByQuery(array $params = [])`
****
[source,php]
----
/*
$params['index']                  = (list) A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices (Required)
$params['type']                   = DEPRECATED (list) A comma-separated list of document types to search; leave empty to perform the operation on all types
$params['analyzer']               = (string) The analyzer to use for the query string
$params['analyze_wildcard']       = (boolean) Specify whether wildcard and prefix queries should be analyzed (default: false)
$params['default_operator']       = (enum) The default operator for query string query (AND or OR) (Options = AND,OR) (Default = OR)
$params['df']                     = (string) The field to use as default where no field prefix is given in the query string
$params['from']                   = (number) Starting offset (default: 0)
$params['ignore_unavailable']     = (boolean) Whether specified concrete indices should be ignored when unavailable (missing or closed)
$params['allow_no_indices']       = (boolean) Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
$params['conflicts']              = (enum) What to do when the delete by query hits version conflicts? (Options = abort,proceed) (Default = abort)
$params['expand_wildcards']       = (enum) Whether to expand wildcard expression to concrete indices that are open, closed or both. (Options = open,closed,hidden,none,all) (Default = open)
$params['lenient']                = (boolean) Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
$params['preference']             = (string) Specify the node or shard the operation should be performed on (default: random)
$params['q']                      = (string) Query in the Lucene query string syntax
$params['routing']                = (list) A comma-separated list of specific routing values
$params['scroll']                 = (time) Specify how long a consistent view of the index should be maintained for scrolled search
$params['search_type']            = (enum) Search operation type (Options = query_then_fetch,dfs_query_then_fetch)
$params['search_timeout']         = (time) Explicit timeout for each search request. Defaults to no timeout.
*/
----
****



[[Elasticsearch_ClientdeleteByQueryRethrottle_deleteByQueryRethrottle]]
.`deleteByQueryRethrottle(array $params = [])`
****
[source,php]
----
/*
$params['task_id']             = (string) The task id to rethrottle
$params['requests_per_second'] = (number) The throttle to set on this request in floating sub-requests per second. -1 means set no throttle. (Required)
*/
----
****



[[Elasticsearch_ClientdeleteScript_deleteScript]]
.`deleteScript(array $params = [])`
****
[source,php]
----
/*
$params['id']             = (string) Script ID
$params['timeout']        = (time) Explicit operation timeout
$params['master_timeout'] = (time) Specify timeout for connection to master
*/
----
****



[[Elasticsearch_Clientexists_exists]]
.`exists(array $params = [])`
****
[source,php]
----
/*
$params['id']               = (string) The document ID (Required)
$params['index']            = (string) The name of the index (Required)
$params['type']             = DEPRECATED (string) The type of the document (use `_all` to fetch the first document matching the ID across all types)
$params['stored_fields']    = (list) A comma-separated list of stored fields to return in the response
$params['preference']       = (string) Specify the node or shard the operation should be performed on (default: random)
$params['realtime']         = (boolean) Specify whether to perform the operation in realtime or search mode
$params['refresh']          = (boolean) Refresh the shard containing the document before performing the operation
$params['routing']          = (string) Specific routing value
$params['_source']          = (list) True or false to return the _source field or not, or a list of fields to return
$params['_source_excludes'] = (list) A list of fields to exclude from the returned _source field
$params['_source_includes'] = (list) A list of fields to extract and return from the _source field
$params['version']          = (number) Explicit version number for concurrency control
$params['version_type']     = (enum) Specific version type (Options = internal,external,external_gte,force)
*/
----
****



[[Elasticsearch_ClientexistsSource_existsSource]]
.`existsSource(array $params = [])`
****
[source,php]
----
/*
$params['id']               = (string) The document ID (Required)
$params['index']            = (string) The name of the index (Required)
$params['type']             = DEPRECATED (string) The type of the document; deprecated and optional starting with 7.0
$params['preference']       = (string) Specify the node or shard the operation should be performed on (default: random)
$params['realtime']         = (boolean) Specify whether to perform the operation in realtime or search mode
$params['refresh']          = (boolean) Refresh the shard containing the document before performing the operation
$params['routing']          = (string) Specific routing value
$params['_source']          = (list) True or false to return the _source field or not, or a list of fields to return
$params['_source_excludes'] = (list) A list of fields to exclude from the returned _source field
$params['_source_includes'] = (list) A list of fields to extract and return from the _source field
$params['version']          = (number) Explicit version number for concurrency control
$params['version_type']     = (enum) Specific version type (Options = internal,external,external_gte,force)
*/
----
****



[[Elasticsearch_Clientexplain_explain]]
.`explain(array $params = [])`
****
[source,php]
----
/*
$params['id']               = (string) The document ID (Required)
$params['index']            = (string) The name of the index (Required)
$params['type']             = DEPRECATED (string) The type of the document
$params['analyze_wildcard'] = (boolean) Specify whether wildcards and prefix queries in the query string query should be analyzed (default: false)
$params['analyzer']         = (string) The analyzer for the query string query
$params['default_operator'] = (enum) The default operator for query string query (AND or OR) (Options = AND,OR) (Default = OR)
$params['df']               = (string) The default field for query string query (default: _all)
$params['stored_fields']    = (list) A comma-separated list of stored fields to return in the response
$params['lenient']          = (boolean) Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
$params['preference']       = (string) Specify the node or shard the operation should be performed on (default: random)
$params['q']                = (string) Query in the Lucene query string syntax
$params['routing']          = (string) Specific routing value
$params['_source']          = (list) True or false to return the _source field or not, or a list of fields to return
$params['_source_excludes'] = (list) A list of fields to exclude from the returned _source field
$params['_source_includes'] = (list) A list of fields to extract and return from the _source field
$params['body']             = (array) The query definition using the Query DSL
*/
----
****



[[Elasticsearch_ClientfieldCaps_fieldCaps]]
.`fieldCaps(array $params = [])`
****
[source,php]
----
/*
$params['index']              = (list) A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices
$params['fields']             = (list) A comma-separated list of field names
$params['ignore_unavailable'] = (boolean) Whether specified concrete indices should be ignored when unavailable (missing or closed)
$params['allow_no_indices']   = (boolean) Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
$params['expand_wildcards']   = (enum) Whether to expand wildcard expression to concrete indices that are open, closed or both. (Options = open,closed,hidden,none,all) (Default = open)
$params['include_unmapped']   = (boolean) Indicates whether unmapped fields should be included in the response. (Default = false)
$params['body']               = (array) An index filter specified with the Query DSL
*/
----
****



[[Elasticsearch_Clientget_get]]
.`get(array $params = [])`
****
[source,php]
----
/*
$params['id']               = (string) The document ID (Required)
$params['index']            = (string) The name of the index (Required)
$params['type']             = DEPRECATED (string) The type of the document (use `_all` to fetch the first document matching the ID across all types)
$params['stored_fields']    = (list) A comma-separated list of stored fields to return in the response
$params['preference']       = (string) Specify the node or shard the operation should be performed on (default: random)
$params['realtime']         = (boolean) Specify whether to perform the operation in realtime or search mode
$params['refresh']          = (boolean) Refresh the shard containing the document before performing the operation
$params['routing']          = (string) Specific routing value
$params['_source']          = (list) True or false to return the _source field or not, or a list of fields to return
$params['_source_excludes'] = (list) A list of fields to exclude from the returned _source field
$params['_source_includes'] = (list) A list of fields to extract and return from the _source field
$params['version']          = (number) Explicit version number for concurrency control
$params['version_type']     = (enum) Specific version type (Options = internal,external,external_gte,force)
*/
----
****



[[Elasticsearch_ClientgetScript_getScript]]
.`getScript(array $params = [])`
****
[source,php]
----
/*
$params['id']             = (string) Script ID
$params['master_timeout'] = (time) Specify timeout for connection to master
*/
----
****



[[Elasticsearch_ClientgetScriptContext_getScriptContext]]
.`getScriptContext(array $params = [])`
*NOTE:* This API is EXPERIMENTAL and may be changed or removed completely in a future release
****
[source,php]
----
/*
*/
----
****



[[Elasticsearch_ClientgetScriptLanguages_getScriptLanguages]]
.`getScriptLanguages(array $params = [])`
*NOTE:* This API is EXPERIMENTAL and may be changed or removed completely in a future release
****
[source,php]
----
/*
*/
----
****



[[Elasticsearch_ClientgetSource_getSource]]
.`getSource(array $params = [])`
****
[source,php]
----
/*
$params['id']               = (string) The document ID (Required)
$params['index']            = (string) The name of the index (Required)
$params['type']             = DEPRECATED (string) The type of the document; deprecated and optional starting with 7.0
$params['preference']       = (string) Specify the node or shard the operation should be performed on (default: random)
$params['realtime']         = (boolean) Specify whether to perform the operation in realtime or search mode
$params['refresh']          = (boolean) Refresh the shard containing the document before performing the operation
$params['routing']          = (string) Specific routing value
$params['_source']          = (list) True or false to return the _source field or not, or a list of fields to return
$params['_source_excludes'] = (list) A list of fields to exclude from the returned _source field
$params['_source_includes'] = (list) A list of fields to extract and return from the _source field
$params['version']          = (number) Explicit version number for concurrency control
$params['version_type']     = (enum) Specific version type (Options = internal,external,external_gte,force)
*/
----
****



[[Elasticsearch_Clientindex_index]]
.`index(array $params = [])`
****
[source,php]
----
/*
$params['id']                     = (string) Document ID
$params['index']                  = (string) The name of the index (Required)
$params['type']                   = DEPRECATED (string) The type of the document
$params['wait_for_active_shards'] = (string) Sets the number of shard copies that must be active before proceeding with the index operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
$params['op_type']                = (enum) Explicit operation type. Defaults to `index` for requests with an explicit document ID, and to `create`for requests without an explicit document ID (Options = index,create)
$params['refresh']                = (enum) If `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes. (Options = true,false,wait_for)
$params['routing']                = (string) Specific routing value
$params['timeout']                = (time) Explicit operation timeout
$params['version']                = (number) Explicit version number for concurrency control
$params['version_type']           = (enum) Specific version type (Options = internal,external,external_gte)
$params['if_seq_no']              = (number) only perform the index operation if the last operation that has changed the document has the specified sequence number
$params['if_primary_term']        = (number) only perform the index operation if the last operation that has changed the document has the specified primary term
$params['pipeline']               = (string) The pipeline id to preprocess incoming documents with
$params['require_alias']          = (boolean) When true, requires destination to be an alias. Default is false
$params['body']                   = (array) The document (Required)
*/
----
****



[[Elasticsearch_Clientinfo_info]]
.`info(array $params = [])`
****
[source,php]
----
/*
*/
----
****



[[Elasticsearch_Clientmget_mget]]
.`mget(array $params = [])`
****
[source,php]
----
/*
$params['index']            = (string) The name of the index
$params['type']             = DEPRECATED (string) The type of the document
$params['stored_fields']    = (list) A comma-separated list of stored fields to return in the response
$params['preference']       = (string) Specify the node or shard the operation should be performed on (default: random)
$params['realtime']         = (boolean) Specify whether to perform the operation in realtime or search mode
$params['refresh']          = (boolean) Refresh the shard containing the document before performing the operation
$params['routing']          = (string) Specific routing value
$params['_source']          = (list) True or false to return the _source field or not, or a list of fields to return
$params['_source_excludes'] = (list) A list of fields to exclude from the returned _source field
$params['_source_includes'] = (list) A list of fields to extract and return from the _source field
$params['body']             = (array) Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL. (Required)
*/
----
****



[[Elasticsearch_Clientmsearch_msearch]]
.`msearch(array $params = [])`
****
[source,php]
----
/*
$params['index']                         = (list) A comma-separated list of index names to use as default
$params['type']                          = DEPRECATED (list) A comma-separated list of document types to use as default
$params['search_type']                   = (enum) Search operation type (Options = query_then_fetch,query_and_fetch,dfs_query_then_fetch,dfs_query_and_fetch)
$params['max_concurrent_searches']       = (number) Controls the maximum number of concurrent searches the multi search api will execute
$params['typed_keys']                    = (boolean) Specify whether aggregation and suggester names should be prefixed by their respective types in the response
$params['pre_filter_shard_size']         = (number) A threshold that enforces a pre-filter roundtrip to prefilter search shards based on query rewriting if the number of shards the search request expands to exceeds the threshold. This filter roundtrip can limit the number of shards significantly if for instance a shard can not match any documents based on its rewrite method ie. if date filters are mandatory to match but the shard bounds and the query are disjoint.
*/
----
****



[[Elasticsearch_ClientmsearchTemplate_msearchTemplate]]
.`msearchTemplate(array $params = [])`
****
[source,php]
----
/*
$params['index']                   = (list) A comma-separated list of index names to use as default
$params['type']                    = DEPRECATED (list) A comma-separated list of document types to use as default
$params['search_type']             = (enum) Search operation type (Options = query_then_fetch,query_and_fetch,dfs_query_then_fetch,dfs_query_and_fetch)
$params['typed_keys']              = (boolean) Specify whether aggregation and suggester names should be prefixed by their respective types in the response
$params['max_concurrent_searches'] = (number) Controls the maximum number of concurrent searches the multi search api will execute
$params['rest_total_hits_as_int']  = (boolean) Indicates whether hits.total should be rendered as an integer or an object in the rest search response (Default = false)
$params['ccs_minimize_roundtrips'] = (boolean) Indicates whether network round-trips should be minimized as part of cross-cluster search requests execution (Default = true)
$params['body']                    = (array) The request definitions (metadata-search request definition pairs), separated by newlines (Required)
*/
----
****



[[Elasticsearch_Clientmtermvectors_mtermvectors]]
.`mtermvectors(array $params = [])`
****
[source,php]
----
/*
$params['index']            = (string) The index in which the document resides.
*/
----
****



[[Elasticsearch_ClientopenPointInTime_openPointInTime]]
.`openPointInTime(array $params = [])`
****
[source,php]
----
/*
$params['index']              = (list) A comma-separated list of index names to open point in time; use `_all` or empty string to perform the operation on all indices
$params['preference']         = (string) Specify the node or shard the operation should be performed on (default: random)
$params['routing']            = (string) Specific routing value
$params['ignore_unavailable'] = (boolean) Whether specified concrete indices should be ignored when unavailable (missing or closed)
$params['expand_wildcards']   = (enum) Whether to expand wildcard expression to concrete indices that are open, closed or both. (Options = open,closed,hidden,none,all) (Default = open)
$params['keep_alive']         = (string) Specific the time to live for the point in time
*/
----
****



[[Elasticsearch_Clientping_ping]]
.`ping(array $params = [])`
****
[source,php]
----
/*
*/
----
****



[[Elasticsearch_ClientputScript_putScript]]
.`putScript(array $params = [])`
****
[source,php]
----
/*
$params['id']             = (string) Script ID (Required)
$params['context']        = (string) Script context
$params['timeout']        = (time) Explicit operation timeout
$params['master_timeout'] = (time) Specify timeout for connection to master
$params['body']           = (array) The document (Required)
*/
----
****



[[Elasticsearch_ClientrankEval_rankEval]]
.`rankEval(array $params = [])`
*NOTE:* This API is EXPERIMENTAL and may be changed or removed completely in a future release
****
[source,php]
----
/*
$params['index']              = (list) A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices
$params['ignore_unavailable'] = (boolean) Whether specified concrete indices should be ignored when unavailable (missing or closed)
$params['allow_no_indices']   = (boolean) Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
$params['expand_wildcards']   = (enum) Whether to expand wildcard expression to concrete indices that are open, closed or both. (Options = open,closed,hidden,none,all) (Default = open)
$params['search_type']        = (enum) Search operation type (Options = query_then_fetch,dfs_query_then_fetch)
$params['body']               = (array) The ranking evaluation search definition, including search requests, document ratings and ranking metric definition. (Required)
*/
----
****



[[Elasticsearch_Clientreindex_reindex]]
.`reindex(array $params = [])`
****
[source,php]
----
/*
$params['refresh']                = (boolean) Should the affected indexes be refreshed?
$params['timeout']                = (time) Time each individual bulk request should wait for shards that are unavailable. (Default = 1m)
$params['wait_for_active_shards'] = (string) Sets the number of shard copies that must be active before proceeding with the reindex operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
$params['wait_for_completion']    = (boolean) Should the request should block until the reindex is complete. (Default = true)
$params['requests_per_second']    = (number) The throttle to set on this request in sub-requests per second. -1 means no throttle. (Default = 0)
$params['scroll']                 = (time) Control how long to keep the search context alive (Default = 5m)
$params['slices']                 = (number|string) The number of slices this task should be divided into. Defaults to 1, meaning the task isn't sliced into subtasks. Can be set to `auto`. (Default = 1)
$params['max_docs']               = (number) Maximum number of documents to process (default: all documents)
$params['body']                   = (array) The search definition using the Query DSL and the prototype for the index request. (Required)
*/
----
****



[[Elasticsearch_ClientreindexRethrottle_reindexRethrottle]]
.`reindexRethrottle(array $params = [])`
****
[source,php]
----
/*
$params['task_id']             = (string) The task id to rethrottle
$params['requests_per_second'] = (number) The throttle to set on this request in floating sub-requests per second. -1 means set no throttle. (Required)
*/
----
****



[[Elasticsearch_ClientrenderSearchTemplate_renderSearchTemplate]]
.`renderSearchTemplate(array $params = [])`
****
[source,php]
----
/*
$params['id']   = (string) The id of the stored search template
$params['body'] = (array) The search definition template and its params
*/
----
****



[[Elasticsearch_ClientscriptsPainlessExecute_scriptsPainlessExecute]]
.`scriptsPainlessExecute(array $params = [])`
*NOTE:* This API is EXPERIMENTAL and may be changed or removed completely in a future release
****
[source,php]
----
/*
$params['body'] = (array) The script to execute
*/
----
****



[[Elasticsearch_Clientscroll_scroll]]
.`scroll(array $params = [])`
****
[source,php]
----
/*
$params['scroll_id']              = DEPRECATED (string) The scroll ID
$params['scroll']                 = (time) Specify how long a consistent view of the index should be maintained for scrolled search
$params['rest_total_hits_as_int'] = (boolean) Indicates whether hits.total should be rendered as an integer or an object in the rest search response (Default = false)
$params['body']                   = (array) The scroll ID if not passed by URL or query parameter.
*/
----
****



[[Elasticsearch_Clientsearch_search]]
.`search(array $params = [])`
****
[source,php]
----
/*
$params['index']                         = (list) A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices
$params['type']                          = DEPRECATED (list) A comma-separated list of document types to search; leave empty to perform the operation on all types
$params['analyzer']                      = (string) The analyzer to use for the query string
$params['analyze_wildcard']              = (boolean) Specify whether wildcard and prefix queries should be analyzed (default: false)
$params['ccs_minimize_roundtrips']       = (boolean) Indicates whether network round-trips should be minimized as part of cross-cluster search requests execution (Default = true)
$params['default_operator']              = (enum) The default operator for query string query (AND or OR) (Options = AND,OR) (Default = OR)
$params['df']                            = (string) The field to use as default where no field prefix is given in the query string
$params['explain']                       = (boolean) Specify whether to return detailed information about score computation as part of a hit
$params['stored_fields']                 = (list) A comma-separated list of stored fields to return as part of a hit
$params['docvalue_fields']               = (list) A comma-separated list of fields to return as the docvalue representation of a field for each hit
$params['from']                          = (number) Starting offset (default: 0)
$params['ignore_unavailable']            = (boolean) Whether specified concrete indices should be ignored when unavailable (missing or closed)
$params['ignore_throttled']              = (boolean) Whether specified concrete, expanded or aliased indices should be ignored when throttled
$params['allow_no_indices']              = (boolean) Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
$params['expand_wildcards']              = (enum) Whether to expand wildcard expression to concrete indices that are open, closed or both. (Options = open,closed,hidden,none,all) (Default = open)
$params['lenient']                       = (boolean) Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
$params['preference']                    = (string) Specify the node or shard the operation should be performed on (default: random)
$params['q']                             = (string) Query in the Lucene query string syntax
$params['routing']                       = (list) A comma-separated list of specific routing values
$params['scroll']                        = (time) Specify how long a consistent view of the index should be maintained for scrolled search
$params['search_type']                   = (enum) Search operation type (Options = query_then_fetch,dfs_query_then_fetch)
$params['size']                          = (number) Number of hits to return (default: 10)
$params['sort']                          = (list) A comma-separated list of <field>:<direction> pairs
$params['_source']                       = (list) True or false to return the _source field or not, or a list of fields to return
$params['_source_excludes']              = (list) A list of fields to exclude from the returned _source field
$params['_source_includes']              = (list) A list of fields to extract and return from the _source field
$params['terminate_after']               = (number) The maximum number of documents to collect for each shard, upon reaching which the query execution will terminate early.
*/
----
****



[[Elasticsearch_ClientsearchShards_searchShards]]
.`searchShards(array $params = [])`
****
[source,php]
----
/*
$params['index']              = (list) A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices
$params['preference']         = (string) Specify the node or shard the operation should be performed on (default: random)
$params['routing']            = (string) Specific routing value
$params['local']              = (boolean) Return local information, do not retrieve the state from master node (default: false)
$params['ignore_unavailable'] = (boolean) Whether specified concrete indices should be ignored when unavailable (missing or closed)
$params['allow_no_indices']   = (boolean) Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
$params['expand_wildcards']   = (enum) Whether to expand wildcard expression to concrete indices that are open, closed or both. (Options = open,closed,hidden,none,all) (Default = open)
*/
----
****



[[Elasticsearch_ClientsearchTemplate_searchTemplate]]
.`searchTemplate(array $params = [])`
****
[source,php]
----
/*
$params['index']                   = (list) A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices
$params['type']                    = DEPRECATED (list) A comma-separated list of document types to search; leave empty to perform the operation on all types
$params['ignore_unavailable']      = (boolean) Whether specified concrete indices should be ignored when unavailable (missing or closed)
$params['ignore_throttled']        = (boolean) Whether specified concrete, expanded or aliased indices should be ignored when throttled
$params['allow_no_indices']        = (boolean) Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
$params['expand_wildcards']        = (enum) Whether to expand wildcard expression to concrete indices that are open, closed or both. (Options = open,closed,hidden,none,all) (Default = open)
$params['preference']              = (string) Specify the node or shard the operation should be performed on (default: random)
$params['routing']                 = (list) A comma-separated list of specific routing values
$params['scroll']                  = (time) Specify how long a consistent view of the index should be maintained for scrolled search
$params['search_type']             = (enum) Search operation type (Options = query_then_fetch,query_and_fetch,dfs_query_then_fetch,dfs_query_and_fetch)
$params['explain']                 = (boolean) Specify whether to return detailed information about score computation as part of a hit
$params['profile']                 = (boolean) Specify whether to profile the query execution
$params['typed_keys']              = (boolean) Specify whether aggregation and suggester names should be prefixed by their respective types in the response
$params['rest_total_hits_as_int']  = (boolean) Indicates whether hits.total should be rendered as an integer or an object in the rest search response (Default = false)
$params['ccs_minimize_roundtrips'] = (boolean) Indicates whether network round-trips should be minimized as part of cross-cluster search requests execution (Default = true)
$params['body']                    = (array) The search definition template and its params (Required)
*/
----
****



[[Elasticsearch_Clienttermvectors_termvectors]]
.`termvectors(array $params = [])`
****
[source,php]
----
/*
$params['index']            = (string) The index in which the document resides. (Required)
$params['id']               = (string) The id of the document, when not specified a doc param should be supplied.
*/
----
****



[[Elasticsearch_Clientupdate_update]]
.`update(array $params = [])`
****
[source,php]
----
/*
$params['id']                     = (string) Document ID (Required)
$params['index']                  = (string) The name of the index (Required)
$params['type']                   = DEPRECATED (string) The type of the document
$params['wait_for_active_shards'] = (string) Sets the number of shard copies that must be active before proceeding with the update operation. Defaults to 1, meaning the primary shard only. Set to `all` for all shard copies, otherwise set to any non-negative value less than or equal to the total number of copies for the shard (number of replicas + 1)
$params['_source']                = (list) True or false to return the _source field or not, or a list of fields to return
$params['_source_excludes']       = (list) A list of fields to exclude from the returned _source field
$params['_source_includes']       = (list) A list of fields to extract and return from the _source field
$params['lang']                   = (string) The script language (default: painless)
$params['refresh']                = (enum) If `true` then refresh the affected shards to make this operation visible to search, if `wait_for` then wait for a refresh to make this operation visible to search, if `false` (the default) then do nothing with refreshes. (Options = true,false,wait_for)
$params['retry_on_conflict']      = (number) Specify how many times should the operation be retried when a conflict occurs (default: 0)
$params['routing']                = (string) Specific routing value
$params['timeout']                = (time) Explicit operation timeout
$params['if_seq_no']              = (number) only perform the update operation if the last operation that has changed the document has the specified sequence number
$params['if_primary_term']        = (number) only perform the update operation if the last operation that has changed the document has the specified primary term
$params['require_alias']          = (boolean) When true, requires destination is an alias. Default is false
$params['body']                   = (array) The request definition requires either `script` or partial `doc` (Required)
*/
----
****



[[Elasticsearch_ClientupdateByQuery_updateByQuery]]
.`updateByQuery(array $params = [])`
****
[source,php]
----
/*
$params['index']                  = (list) A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices (Required)
$params['type']                   = DEPRECATED (list) A comma-separated list of document types to search; leave empty to perform the operation on all types
$params['analyzer']               = (string) The analyzer to use for the query string
$params['analyze_wildcard']       = (boolean) Specify whether wildcard and prefix queries should be analyzed (default: false)
$params['default_operator']       = (enum) The default operator for query string query (AND or OR) (Options = AND,OR) (Default = OR)
$params['df']                     = (string) The field to use as default where no field prefix is given in the query string
$params['from']                   = (number) Starting offset (default: 0)
$params['ignore_unavailable']     = (boolean) Whether specified concrete indices should be ignored when unavailable (missing or closed)
$params['allow_no_indices']       = (boolean) Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)
$params['conflicts']              = (enum) What to do when the update by query hits version conflicts? (Options = abort,proceed) (Default = abort)
$params['expand_wildcards']       = (enum) Whether to expand wildcard expression to concrete indices that are open, closed or both. (Options = open,closed,hidden,none,all) (Default = open)
$params['lenient']                = (boolean) Specify whether format-based query failures (such as providing text to a numeric field) should be ignored
$params['pipeline']               = (string) Ingest pipeline to set on index requests made by this action. (default: none)
$params['preference']             = (string) Specify the node or shard the operation should be performed on (default: random)
$params['q']                      = (string) Query in the Lucene query string syntax
$params['routing']                = (list) A comma-separated list of specific routing values
$params['scroll']                 = (time) Specify how long a consistent view of the index should be maintained for scrolled search
$params['search_type']            = (enum) Search operation type (Options = query_then_fetch,dfs_query_then_fetch)
$params['search_timeout']         = (time) Explicit timeout for each search request. Defaults to no timeout.
*/
----
****



[[Elasticsearch_ClientupdateByQueryRethrottle_updateByQueryRethrottle]]
.`updateByQueryRethrottle(array $params = [])`
****
[source,php]
----
/*
$params['task_id']             = (string) The task id to rethrottle
$params['requests_per_second'] = (number) The throttle to set on this request in floating sub-requests per second. -1 means set no throttle. (Required)
*/
----
****



[[Elasticsearch_ClientasyncSearch_asyncSearch]]
.`asyncSearch()`
****
[source,php]
----
/*
Returns the asyncSearch namespace
*/
----
****



[[Elasticsearch_Clientautoscaling_autoscaling]]
.`autoscaling()`
****
[source,php]
----
/*
Returns the autoscaling namespace
*/
----
****



[[Elasticsearch_Clientcat_cat]]
.`cat()`
****
[source,php]
----
/*
Returns the cat namespace
*/
----
****



[[Elasticsearch_Clientccr_ccr]]
.`ccr()`
****
[source,php]
----
/*
Returns the ccr namespace
*/
----
****



[[Elasticsearch_Clientcluster_cluster]]
.`cluster()`
****
[source,php]
----
/*
Returns the cluster namespace
*/
----
****



[[Elasticsearch_ClientdanglingIndices_danglingIndices]]
.`danglingIndices()`
****
[source,php]
----
/*
Returns the danglingIndices namespace
*/
----
****



[[Elasticsearch_ClientdataFrameTransformDeprecated_dataFrameTransformDeprecated]]
.`dataFrameTransformDeprecated()`
****
[source,php]
----
/*
Returns the dataFrameTransformDeprecated namespace
*/
----
****



[[Elasticsearch_Clientenrich_enrich]]
.`enrich()`
****
[source,php]
----
/*
Returns the enrich namespace
*/
----
****



[[Elasticsearch_Clienteql_eql]]
.`eql()`
****
[source,php]
----
/*
Returns the eql namespace
*/
----
****



[[Elasticsearch_Clientfeatures_features]]
.`features()`
****
[source,php]
----
/*
Returns the features namespace
*/
----
****



[[Elasticsearch_Clientgraph_graph]]
.`graph()`
****
[source,php]
----
/*
Returns the graph namespace
*/
----
****



[[Elasticsearch_Clientilm_ilm]]
.`ilm()`
****
[source,php]
----
/*
Returns the ilm namespace
*/
----
****



[[Elasticsearch_Clientindices_indices]]
.`indices()`
****
[source,php]
----
/*
Returns the indices namespace
*/
----
****



[[Elasticsearch_Clientingest_ingest]]
.`ingest()`
****
[source,php]
----
/*
Returns the ingest namespace
*/
----
****



[[Elasticsearch_Clientlicense_license]]
.`license()`
****
[source,php]
----
/*
Returns the license namespace
*/
----
****



[[Elasticsearch_Clientlogstash_logstash]]
.`logstash()`
****
[source,php]
----
/*
Returns the logstash namespace
*/
----
****



[[Elasticsearch_Clientmigration_migration]]
.`migration()`
****
[source,php]
----
/*
Returns the migration namespace
*/
----
****



[[Elasticsearch_Clientml_ml]]
.`ml()`
****
[source,php]
----
/*
Returns the ml namespace
*/
----
****



[[Elasticsearch_Clientmonitoring_monitoring]]
.`monitoring()`
****
[source,php]
----
/*
Returns the monitoring namespace
*/
----
****



[[Elasticsearch_Clientnodes_nodes]]
.`nodes()`
****
[source,php]
----
/*
Returns the nodes namespace
*/
----
****



[[Elasticsearch_Clientrollup_rollup]]
.`rollup()`
****
[source,php]
----
/*
Returns the rollup namespace
*/
----
****



[[Elasticsearch_ClientsearchableSnapshots_searchableSnapshots]]
.`searchableSnapshots()`
****
[source,php]
----
/*
Returns the searchableSnapshots namespace
*/
----
****



[[Elasticsearch_Clientsecurity_security]]
.`security()`
****
[source,php]
----
/*
Returns the security namespace
*/
----
****



[[Elasticsearch_Clientslm_slm]]
.`slm()`
****
[source,php]
----
/*
Returns the slm namespace
*/
----
****



[[Elasticsearch_Clientsnapshot_snapshot]]
.`snapshot()`
****
[source,php]
----
/*
Returns the snapshot namespace
*/
----
****



[[Elasticsearch_Clientsql_sql]]
.`sql()`
****
[source,php]
----
/*
Returns the sql namespace
*/
----
****



[[Elasticsearch_Clientssl_ssl]]
.`ssl()`
****
[source,php]
----
/*
Returns the ssl namespace
*/
----
****



[[Elasticsearch_Clienttasks_tasks]]
.`tasks()`
****
[source,php]
----
/*
Returns the tasks namespace
*/
----
****



[[Elasticsearch_ClienttextStructure_textStructure]]
.`textStructure()`
****
[source,php]
----
/*
Returns the textStructure namespace
*/
----
****



[[Elasticsearch_Clienttransform_transform]]
.`transform()`
****
[source,php]
----
/*
Returns the transform namespace
*/
----
****



[[Elasticsearch_Clientwatcher_watcher]]
.`watcher()`
****
[source,php]
----
/*
Returns the watcher namespace
*/
----
****



[[Elasticsearch_Clientxpack_xpack]]
.`xpack()`
****
[source,php]
----
/*
Returns the xpack namespace
*/
----
****



[[Elasticsearch_Client-call-_call]]
.`__call(string $name, array $arguments)`
****
[source,php]
----
/*
Catchall for registered namespaces
*/
----
****



[[Elasticsearch_ClientextractArgument_extractArgument]]
.`extractArgument(array $params, string $arg)`
****
[source,php]
----
/*
Extract an argument from the array of parameters
*/
----
****


",12048,True,2923.5683804116934,median
"[[pc]]
== Persistence Context
:sourcedir: ../../../../../test/java/org/hibernate/userguide/pc
:sourcedir-caching: ../../../../../test/java/org/hibernate/userguide/caching
:extrasdir: extras

Both the `org.hibernate.Session` API and `javax.persistence.EntityManager` API represent a context for dealing with persistent data.
This concept is called a `persistence context`.
Persistent data has a state in relation to both a persistence context and the underlying database.

`transient`:: the entity has just been instantiated and is not associated with a persistence context.
It has no persistent representation in the database and typically no identifier value has been assigned (unless the _assigned_ generator was used).
`managed` or `persistent`:: the entity has an associated identifier and is associated with a persistence context.
It may or may not physically exist in the database yet.
`detached`:: the entity has an associated identifier but is no longer associated with a persistence context (usually because the persistence context was closed or the instance was evicted from the context)
`removed`:: the entity has an associated identifier and is associated with a persistence context, however, it is scheduled for removal from the database.

Much of the `org.hibernate.Session` and `javax.persistence.EntityManager` methods deal with moving entities among these states.

[[pc-unwrap]]
=== Accessing Hibernate APIs from JPA

JPA defines an incredibly useful method to allow applications access to the APIs of the underlying provider.

[[pc-unwrap-example]]
.Accessing Hibernate APIs from JPA
====
[source, JAVA, indent=0]
----
include::{sourcedir}/PersistenceContextTest.java[tags=pc-unwrap-example]
----
====

include::BytecodeEnhancement.adoc[]

[[pc-persist]]
=== Making entities persistent

Once you've created a new entity instance (using the standard `new` operator) it is in `new` state.
You can make it persistent by associating it to either an `org.hibernate.Session` or a `javax.persistence.EntityManager`.

[[pc-persist-jpa-example]]
.Making an entity persistent with JPA
====
[source, JAVA, indent=0]
----
include::{sourcedir}/PersistenceContextTest.java[tags=pc-persist-jpa-example]
----
====

[[pc-persist-native-example]]
.Making an entity persistent with Hibernate API
====
[source, JAVA, indent=0]
----
include::{sourcedir}/PersistenceContextTest.java[tags=pc-persist-native-example]
----
====

`org.hibernate.Session` also has a method named persist which follows the exact semantics defined in the JPA specification for the persist method.
It is this `org.hibernate.Session` method to which the Hibernate `javax.persistence.EntityManager` implementation delegates.

If the `DomesticCat` entity type has a generated identifier, the value is associated with the instance when the save or persist is called.
If the identifier is not automatically generated, the manually assigned (usually natural) key value has to be set on the instance before the save or persist methods are called.

[[pc-remove]]
=== Deleting (removing) entities

Entities can also be deleted.

[[pc-remove-jpa-example]]
.Deleting an entity with JPA
====
[source, JAVA, indent=0]
----
include::{sourcedir}/PersistenceContextTest.java[tags=pc-remove-jpa-example]
----
====

[[pc-remove-native-example]]
.Deleting an entity with the Hibernate API
====
[source, JAVA, indent=0]
----
include::{sourcedir}/PersistenceContextTest.java[tags=pc-remove-native-example]
----
====

[NOTE]
====
Hibernate itself can handle deleting entities in detached state.
JPA, however, disallows this behavior.

The implication here is that the entity instance passed to the `org.hibernate.Session` delete method can be either in managed or detached state,
while the entity instance passed to remove on `javax.persistence.EntityManager` must be in the managed state.
====

[[pc-get-reference]]
=== Obtain an entity reference without initializing its data

Sometimes referred to as lazy loading, the ability to obtain a reference to an entity without having to load its data is hugely important.
The most common case being the need to create an association between an entity and another existing entity.

[[pc-get-reference-jpa-example]]
.Obtaining an entity reference without initializing its data with JPA
====
[source, JAVA, indent=0]
----
include::{sourcedir}/PersistenceContextTest.java[tags=pc-get-reference-jpa-example]
----
====

[[pc-get-reference-native-example]]
.Obtaining an entity reference without initializing its data with Hibernate API
====
[source, JAVA, indent=0]
----
include::{sourcedir}/PersistenceContextTest.java[tags=pc-get-reference-native-example]
----
====

The above works on the assumption that the entity is defined to allow lazy loading, generally through use of runtime proxies.
In both cases an exception will be thrown later if the given entity does not refer to actual database state when the application attempts to use the returned proxy in any way that requires access to its data.

[IMPORTANT]
====
Unless the entity class is declared `final`, the proxy extends the entity class. If the entity class is `final`, the proxy will implement an interface instead. See the <<chapters/domain/entity.adoc#entity-proxy, `@Proxy` mapping>> section for more info.
====

[[pc-find]]
=== Obtain an entity with its data initialized

It is also quite common to want to obtain an entity along with its data (e.g. like when we need to display it in the UI).

[[pc-find-jpa-example]]
.Obtaining an entity reference with its data initialized with JPA
====
[source, JAVA, indent=0]
----
include::{sourcedir}/PersistenceContextTest.java[tags=pc-find-jpa-example]
----
====

[[pc-find-native-example]]
.Obtaining an entity reference with its data initialized with Hibernate API
====

[source, JAVA, indent=0]
----
include::{sourcedir}/PersistenceContextTest.java[tags=pc-find-native-example]
----
====

[[pc-find-by-id-native-example]]
.Obtaining an entity reference with its data initialized using the `byId()` Hibernate API
====

[source, JAVA, indent=0]
----
include::{sourcedir}/PersistenceContextTest.java[tags=pc-find-by-id-native-example]
----
====

In both cases null is returned if no matching database row was found.

It's possible to return a Java 8 `Optional` as well:

[[tag::pc-find-optional-by-id-native-example]]
.Obtaining an Optional entity reference with its data initialized using the `byId()` Hibernate API
====

[source, JAVA, indent=0]
----
include::{sourcedir}/PersistenceContextTest.java[tags=pc-find-optional-by-id-native-example]
----
====

[[pc-by-multiple-ids]]
=== Obtain multiple entities by their identifiers

If you want to load multiple entities by providing their identifiers, calling the `EntityManager#find` method multiple times is not only inconvenient,
but also inefficient.

While the JPA standard does not support retrieving multiple entities at once, other than running a JPQL or Criteria API query,
Hibernate offers this functionality via the
https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/Session.html#byMultipleIds-java.lang.Class-[`byMultipleIds` method] of the Hibernate `Session`.

The `byMultipleIds` method returns a
https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/MultiIdentifierLoadAccess.html[`MultiIdentifierLoadAccess`]
which you can use to customize the multi-load request.

The `MultiIdentifierLoadAccess` interface provides several methods which you can use to
change the behavior of the multi-load call:

`enableOrderedReturn(boolean enabled)`::
This setting controls whether the returned `List` is ordered and positional in relation to the
incoming ids.  If enabled (the default), the return `List` is ordered and
positional relative to the incoming ids.  In other words, a request to
`multiLoad([2,1,3])` will return `[Entity#2, Entity#1, Entity#3]`.
+
An important distinction is made here in regards to the handling of
unknown entities depending on this ""ordered return"" setting.
If enabled, a null is inserted into the `List` at the proper position(s).
If disabled, the nulls are not put into the return List.
+
In other words, consumers of the returned ordered List would need to be able to handle null elements.
`enableSessionCheck(boolean enabled)`::
This setting, which is disabled by default, tells Hibernate to check the first-level cache (a.k.a `Session` or Persistence Context) first and, if the entity is found and already managed by the Hibernate `Session`, the cached entity will be added to the returned `List`, therefore skipping it from being fetched via the multi-load query.
`enableReturnOfDeletedEntities(boolean enabled)`::
This setting instructs Hibernate if the multi-load operation is allowed to return entities that were deleted by the current Persistence Context. A deleted entity is one which has been passed to this
`Session.delete` or `Session.remove` method, but the `Session` was not flushed yet, meaning that the
associated row was not deleted in the database table.
+
The default behavior is to handle them as null in the return (see `enableOrderedReturn`).
When enabled, the result set will contain deleted entities.
When disabled (which is the default behavior), deleted entities are not included in the returning `List`.
`with(LockOptions lockOptions)`::
This setting allows you to pass a given
https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/LockOptions.html[`LockOptions`] mode to the multi-load query.
`with(CacheMode cacheMode)`::
This setting allows you to pass a given
https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/CacheMode.html[`CacheMode`]
strategy so that we can load entities from the second-level cache, therefore skipping the cached entities from being fetched via the multi-load query.
`withBatchSize(int batchSize)`::
This setting allows you to specify a batch size for loading the entities (e.g. how many at a time).
+
The default is to use a batch sizing strategy defined by the `Dialect.getDefaultBatchLoadSizingStrategy()` method.
+
Any greater-than-one value here will override that default behavior.
`with(RootGraph<T> graph)`::
The `RootGraph` is a Hibernate extension to the JPA `EntityGraph` contract,
and this method allows you to pass a specific `RootGraph` to the multi-load query
so that it can fetch additional relationships of the current loading entity.

Now, assuming we have 3 `Person` entities in the database, we can load all of them with a single call
as illustrated by the following example:

[[tag::pc-by-multiple-ids-example]]
.Loading multiple entities using the `byMultipleIds()` Hibernate API
====

[source, JAVA, indent=0]
----
include::{sourcedir}/MultiLoadIdTest.java[tags=pc-by-multiple-ids-example]
----

[source, SQL, indent=0]
----
include::{extrasdir}/pc-by-multiple-ids-example.sql[]
----
====

Notice that only one SQL SELECT statement was executed since the second call uses the
https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/MultiIdentifierLoadAccess.html#enableSessionCheck-boolean-[`enableSessionCheck`] method of the `MultiIdentifierLoadAccess`
to instruct Hibernate to skip entities that are already loaded in the current Persistence Context.

If the entities are not available in the current Persistence Context but they could be loaded from the second-level cache, you can use the
https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/MultiIdentifierLoadAccess.html#with-org.hibernate.CacheMode-[`with(CacheMode)`] method of the `MultiIdentifierLoadAccess` object.

[[tag::pc-by-multiple-ids-second-level-cache-example]]
.Loading multiple entities from the second-level cache
====
[source, JAVA, indent=0]
----
include::{sourcedir}/MultiLoadIdTest.java[tags=pc-by-multiple-ids-second-level-cache-example]
----
====

In the example above, we first make sure that we clear the second-level cache to demonstrate that
the multi-load query will put the returning entities into the second-level cache.

After executing the first `byMultipleIds` call, Hibernate is going to fetch the requested entities,
and as illustrated by the `getSecondLevelCachePutCount` method call, 3 entities were indeed added to the
shared cache.

Afterward, when executing the second `byMultipleIds` call for the same entities in a new Hibernate `Session`,
we set the
https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/CacheMode.html#NORMAL[`CacheMode.NORMAL`] second-level cache mode so that entities are going to be returned from the second-level cache.

The `getSecondLevelCacheHitCount` statistics method returns 3 this time, since the 3 entities were loaded from the second-level cache, and, as illustrated by `sqlStatementInterceptor.getSqlQueries()`, no multi-load SELECT statement was executed this time.

[[pc-find-natural-id]]
=== Obtain an entity by natural-id

In addition to allowing to load the entity by its identifier, Hibernate allows applications to load entities by the declared natural identifier.

[[pc-find-by-natural-id-entity-example]]
.Natural-id mapping
====
[source, JAVA, indent=0]
----
include::{sourcedir}/PersistenceContextTest.java[tags=pc-find-by-natural-id-entity-example]
----
====

We can also opt to fetch the entity or just retrieve a reference to it when using the natural identifier loading methods.

[[pc-find-by-simple-natural-id-example]]
.Get entity reference by simple natural-id
====
[source, JAVA, indent=0]
----
include::{sourcedir}/PersistenceContextTest.java[tags=pc-find-by-simple-natural-id-example]
----
====

[[pc-find-by-natural-id-example]]
.Load entity by natural-id
====
[source, JAVA, indent=0]
----
include::{sourcedir}/PersistenceContextTest.java[tags=pc-find-by-natural-id-example]
----
====

We can also use a Java 8 `Optional` to load an entity by its natural id:

[[pc-find-optional-by-simple-natural-id-example]]
.Load an Optional entity by natural-id
====
[source, JAVA, indent=0]
----
include::{sourcedir}/PersistenceContextTest.java[tags=pc-find-optional-by-simple-natural-id-example]
----
====

Hibernate offers a consistent API for accessing persistent data by identifier or by the natural-id. Each of these defines the same two data access methods:

getReference::
	Should be used in cases where the identifier is assumed to exist, where non-existence would be an actual error.
	Should never be used to test existence.
	That is because this method will prefer to create and return a proxy if the data is not already associated with the Session rather than hit the database.
	The quintessential use-case for using this method is to create foreign key based associations.
load::
	Will return the persistent data associated with the given identifier value or null if that identifier does not exist.

Each of these two methods defines an overloading variant accepting a `org.hibernate.LockOptions` argument.
Locking is discussed in a separate <<chapters/locking/Locking.adoc#locking,chapter>>.

[[pc-filtering]]
=== Filtering entities and associations

Hibernate offers two options if you want to filter entities or entity associations:

static (e.g. `@Where` and `@WhereJoinTable`):: which are defined at mapping time and
cannot change at runtime.
dynamic (e.g. `@Filter` and `@FilterJoinTable`):: which are applied and configured at runtime.

[[pc-where]]
==== `@Where`

Sometimes, you want to filter out entities or collections using custom SQL criteria.
This can be achieved using the `@Where` annotation, which can be applied to entities and collections.

[[pc-where-example]]
.`@Where` mapping usage
====
[source, JAVA, indent=0]
----
include::{sourcedir}/WhereTest.java[tags=pc-where-example]
----
====

If the database contains the following entities:

[[pc-where-persistence-example]]
.Persisting and fetching entities with a `@Where` mapping
====
[source, JAVA, indent=0]
----
include::{sourcedir}/WhereTest.java[tags=pc-where-persistence-example]
----

[source, SQL, indent=0]
----
include::{extrasdir}/pc-where-persistence-example.sql[]
----
====

When executing an `Account` entity query, Hibernate is going to filter out all records that are not active.

[[pc-where-entity-query-example]]
.Query entities mapped with `@Where`
====
[source, JAVA, indent=0]
----
include::{sourcedir}/WhereTest.java[tags=pc-where-entity-query-example]
----

[source, SQL, indent=0]
----
include::{extrasdir}/pc-where-entity-query-example.sql[]
----
====

When fetching the `debitAccounts` or the `creditAccounts` collections, Hibernate is going to apply the `@Where` clause filtering criteria to the associated child entities.

[[pc-where-collection-query-example]]
.Traversing collections mapped with `@Where`
====
[source, JAVA, indent=0]
----
include::{sourcedir}/WhereTest.java[tags=pc-where-collection-query-example]
----

[source, SQL, indent=0]
----
include::{extrasdir}/pc-where-collection-query-example.sql[]
----
====

[[pc-where-join-table]]
==== `@WhereJoinTable`

Just like `@Where` annotation, `@WhereJoinTable` is used to filter out collections using a joined table (e.g. @ManyToMany association).

[[pc-where-join-table-example]]
.`@WhereJoinTable` mapping example
====
[source, JAVA, indent=0]
----
include::{sourcedir}/WhereJoinTableTest.java[tags=pc-where-join-table-example]
----

[source, SQL, indent=0]
----
include::{extrasdir}/pc-where-join-table-example.sql[]
----
====

In the example above, the current week `Reader` entities are included in the `currentWeekReaders` collection
which uses the `@WhereJoinTable` annotation to filter the joined table rows according to the provided SQL clause.

Considering that the following two `Book_Reader` entries are added into our system:

[[pc-where-join-table-persist-example]]
.`@WhereJoinTable` test data
====
[source, JAVA, indent=0]
----
include::{sourcedir}/WhereJoinTableTest.java[tags=pc-where-join-table-persist-example]
----
====

When fetching the `currentWeekReaders` collection, Hibernate is going to find only one entry:

[[pc-where-join-table-fetch-example]]
.`@WhereJoinTable` fetch example
====
[source, JAVA, indent=0]
----
include::{sourcedir}/WhereJoinTableTest.java[tags=pc-where-join-table-fetch-example]
----
====

[[pc-filter]]
==== `@Filter`

The `@Filter` annotation is another way to filter out entities or collections using custom SQL criteria.
Unlike the `@Where` annotation, `@Filter` allows you to parameterize the filter clause at runtime.

Now, considering we have the following `Account` entity:

[[pc-filter-account-example]]
.`@Filter` mapping entity-level usage
====
[source, JAVA, indent=0]
----
include::{sourcedir}/FilterTest.java[tags=pc-filter-Account-example]
----
====

[NOTE]
====
Notice that the `active` property is mapped to the `active_status` column.

This mapping was done to show you that the `@Filter` condition uses a SQL condition and not a JPQL filtering predicate.
====

As already explained, we can also apply the `@Filter` annotation for collections as illustrated by the `Client` entity:

[[pc-filter-client-example]]
.`@Filter` mapping collection-level usage
====
[source, JAVA, indent=0]
----
include::{sourcedir}/FilterTest.java[tags=pc-filter-Client-example]
----
====

If we persist a `Client` with three associated `Account` entities,
Hibernate will execute the following SQL statements:

[[pc-filter-persistence-example]]
.Persisting and fetching entities with a `@Filter` mapping
====
[source, JAVA, indent=0]
----
include::{sourcedir}/FilterTest.java[tags=pc-filter-persistence-example]
----

[source, SQL, indent=0]
----
include::{extrasdir}/pc-filter-persistence-example.sql[]
----
====

By default, without explicitly enabling the filter, Hibernate is going to fetch all `Account` entities.

[[pc-no-filter-entity-query-example]]
.Query entities mapped without activating the `@Filter`
====
[source, JAVA, indent=0]
----
include::{sourcedir}/FilterTest.java[tags=pc-no-filter-entity-query-example]
----

[source, SQL, indent=0]
----
include::{extrasdir}/pc-no-filter-entity-query-example.sql[]
----
====

If the filter is enabled and the filter parameter value is provided,
then Hibernate is going to apply the filtering criteria to the associated `Account` entities.

[[pc-filter-entity-query-example]]
.Query entities mapped with `@Filter`
====
[source, JAVA, indent=0]
----
include::{sourcedir}/FilterTest.java[tags=pc-filter-entity-query-example]
----

[source, SQL, indent=0]
----
include::{extrasdir}/pc-filter-entity-query-example.sql[]
----
====

[IMPORTANT]
====
Filters apply to entity queries, but not to direct fetching.

Therefore, in the following example, the filter is not taken into consideration when fetching an entity from the Persistence Context.

[[pc-filter-entity-example]]
.Fetching entities mapped with `@Filter`
[source, JAVA, indent=0]
----
include::{sourcedir}/FilterTest.java[tags=pc-filter-entity-example]
----

[source, SQL, indent=0]
----
include::{extrasdir}/pc-filter-entity-example.sql[]
----

As you can see from the example above, contrary to an entity query, the filter does not prevent the entity from being loaded.
====

Just like with entity queries, collections can be filtered as well, but only if the filter is explicitly enabled on the currently running Hibernate `Session`.

[[pc-no-filter-collection-query-example]]
.Traversing collections without activating the `@Filter`
====
[source, JAVA, indent=0]
----
include::{sourcedir}/FilterTest.java[tags=pc-no-filter-collection-query-example]
----

[source, SQL, indent=0]
----
include::{extrasdir}/pc-no-filter-collection-query-example.sql[]
----
====

When activating the `@Filter` and fetching the `accounts` collections, Hibernate is going to apply the filter condition to the associated collection entries.

[[pc-filter-collection-query-example]]
.Traversing collections mapped with `@Filter`
====
[source, JAVA, indent=0]
----
include::{sourcedir}/FilterTest.java[tags=pc-filter-collection-query-example]
----

[source, SQL, indent=0]
----
include::{extrasdir}/pc-filter-collection-query-example.sql[]
----
====

[NOTE]
====
The main advantage of `@Filter` over the `@Where` clause is that the filtering criteria can be customized at runtime.
====

[WARNING]
====
It's not possible to combine the `@Filter` and `@Cache` collection annotations.
This limitation is due to ensuring consistency and because the filtering information is not stored in the second-level cache.

If caching were allowed for a currently filtered collection, then the second-level cache would store only a subset of the whole collection.
Afterward, every other Session will get the filtered collection from the cache, even if the Session-level filters have not been explicitly activated.

For this reason, the second-level collection cache is limited to storing whole collections, and not subsets.
====

[[pc-filter-sql-fragment-alias]]
==== `@Filter` with `@SqlFragmentAlias`

When using the `@Filter` annotation and working with entities that are mapped onto multiple database tables,
you will need to use the
https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/annotations/SqlFragmentAlias.html[`@SqlFragmentAlias`] annotation
if the `@Filter` defines a condition that uses predicates across multiple tables.

[[pc-filter-sql-fragment-alias-example]]
.`@SqlFragmentAlias` mapping usage
====
[source, JAVA, indent=0]
----
include::{sourcedir}/FilterSqlFragementAliasTest.java[tags=pc-filter-sql-fragment-alias-example]
----
====

Now, when fetching the `Account` entities and activating the filter,
Hibernate is going to apply the right table aliases to the filter predicates:

[[pc-filter-sql-fragment-alias-query-example]]
.Fetching a collection filtered with `@SqlFragmentAlias`
====
[source, JAVA, indent=0]
----
include::{sourcedir}/FilterSqlFragementAliasTest.java[tags=pc-filter-sql-fragment-alias-query-example]
----

[source, SQL, indent=0]
----
include::{extrasdir}/pc-filter-sql-fragment-alias-query-example.sql[]
----
====

[[pc-filter-join-table]]
==== `@FilterJoinTable`

When using the `@Filter` annotation with collections, the filtering is done against the child entries (entities or embeddables).
However, if you have a link table between the parent entity and the child table, then you need to use the `@FilterJoinTable` to filter child entries according to some column contained in the join table.

The `@FilterJoinTable` annotation can be, therefore, applied to a unidirectional `@OneToMany` collection as illustrated in the following mapping:

[[pc-filter-join-table-example]]
.`@FilterJoinTable` mapping usage
====
[source, JAVA, indent=0]
----
include::{sourcedir}/FilterJoinTableTest.java[tags=pc-filter-join-table-example]
----
====

The `firstAccounts` filter will allow us to get only the `Account` entities that have the `order_id`
(which tells the position of every entry inside the `accounts` collection)
less than a given number (e.g. `maxOrderId`).

Let's assume our database contains the following entities:

[[pc-filter-join-table-persistence-example]]
.Persisting and fetching entities with a `@FilterJoinTable` mapping
====
[source, JAVA, indent=0]
----
include::{sourcedir}/FilterJoinTableTest.java[tags=pc-filter-join-table-persistence-example]
----

[source, SQL, indent=0]
----
include::{extrasdir}/pc-filter-join-table-persistence-example.sql[]
----
====

The collections can be filtered only if the associated filter is enabled on the currently running Hibernate `Session`.

[[pc-no-filter-join-table-collection-query-example]]
.Traversing collections mapped with `@FilterJoinTable` without enabling the filter
====
[source, JAVA, indent=0]
----
include::{sourcedir}/FilterJoinTableTest.java[tags=pc-no-filter-join-table-collection-query-example]
----

[source, SQL, indent=0]
----
include::{extrasdir}/pc-no-filter-join-table-collection-query-example.sql[]
----
====

If we enable the filter and set the `maxOrderId` to `1` when fetching the `accounts` collections, Hibernate is going to apply the `@FilterJoinTable` clause filtering criteria, and we will get just
`2` `Account` entities, with the `order_id` values of `0` and `1`.

[[pc-filter-join-table-collection-query-example]]
.Traversing collections mapped with `@FilterJoinTable`
====
[source, JAVA, indent=0]
----
include::{sourcedir}/FilterJoinTableTest.java[tags=pc-filter-join-table-collection-query-example]
----

[source, SQL, indent=0]
----
include::{extrasdir}/pc-filter-join-table-collection-query-example.sql[]
----
====

[[pc-managed-state]]
=== Modifying managed/persistent state

Entities in managed/persistent state may be manipulated by the application, and any changes will be automatically detected and persisted when the persistence context is flushed.
There is no need to call a particular method to make your modifications persistent.

[[pc-managed-state-jpa-example]]
.Modifying managed state with JPA
====
[source, JAVA, indent=0]
----
include::{sourcedir}/PersistenceContextTest.java[tags=pc-managed-state-jpa-example]
----
====

[[pc-managed-state-native-example]]
.Modifying managed state with Hibernate API
====
[source, JAVA, indent=0]
----
include::{sourcedir}/PersistenceContextTest.java[tags=pc-managed-state-native-example]
----
====

By default, when you modify an entity, all columns but the identifier are being set during update.

Therefore, considering you have the following `Product` entity mapping:

[[pc-managed-state-update-mapping-example]]
.`Product` entity mapping
====
[source, JAVA, indent=0]
----
include::{sourcedir}/NoDynamicUpdateTest.java[tags=pc-managed-state-update-mapping-example]
----
====

If you persist the following `Product` entity:

[[pc-managed-state-update-persist-example]]
.Persisting a `Product` entity
====
[source, JAVA, indent=0]
----
include::{sourcedir}/NoDynamicUpdateTest.java[tags=pc-managed-state-update-persist-example]
----
====

When you modify the `Product` entity, Hibernate generates the following SQL UPDATE statement:

[[pc-managed-state-update-example]]
.Modifying the `Product` entity
====
[source, JAVA, indent=0]
----
include::{sourcedir}/NoDynamicUpdateTest.java[tags=pc-managed-state-update-example]
----

[source, SQL, indent=0]
----
include::{extrasdir}/pc-managed-state-update-example.sql[]
----
====

The default UPDATE statement containing all columns has two advantages:

- it allows you to better benefit from JDBC Statement caching.
- it allows you to enable batch updates even if multiple entities modify different properties.

However, there is also one downside to including all columns in the SQL UPDATE statement.
If you have multiple indexes, the database might update those redundantly even if you don't actually modify all column values.

To fix this issue, you can use dynamic updates.

[[pc-managed-state-dynamic-update]]
==== Dynamic updates

To enable dynamic updates, you need to annotate the entity with the `@DynamicUpdate` annotation:

[[pc-managed-state-dynamic-update-mapping-example]]
.`Product` entity mapping
====
[source, JAVA, indent=0]
----
include::{sourcedir}/DynamicUpdateTest.java[tags=pc-managed-state-dynamic-update-mapping-example]
----
====

This time, when rerunning the previous test case, Hibernate generates the following SQL UPDATE statement:

[[pc-managed-state-dynamic-update-example]]
.Modifying the `Product` entity with a dynamic update
====
[source, SQL, indent=0]
----
include::{extrasdir}/pc-managed-state-dynamic-update-example.sql[]
----
====

The dynamic update allows you to set just the columns that were modified in the associated entity.

[[pc-refresh]]
=== Refresh entity state

You can reload an entity instance and its collections at any time.

[[pc-refresh-jpa-example]]
.Refreshing entity state with JPA
====
[source, JAVA, indent=0]
----
include::{sourcedir}/PersistenceContextTest.java[tags=pc-refresh-jpa-example]
----
====

[[pc-refresh-native-example]]
.Refreshing entity state with Hibernate API
====
[source, JAVA, indent=0]
----
include::{sourcedir}/PersistenceContextTest.java[tags=pc-refresh-native-example]
----
====

One case where this is useful is when it is known that the database state has changed since the data was read.
Refreshing allows the current database state to be pulled into the entity instance and the persistence context.

Another case where this might be useful is when database triggers are used to initialize some of the properties of the entity.

[NOTE]
====
Only the entity instance and its value type collections are refreshed unless you specify `REFRESH` as a cascade style of any associations.
However, please note that Hibernate has the capability to handle this automatically through its notion of generated properties.
See the discussion of non-identifier <<chapters/domain/basic_types.adoc#mapping-generated,generated attributes>>.
====

[IMPORTANT]
====
Traditionally, Hibernate allowed detached entities to be refreshed.
Unfortunately, JPA prohibits this practice and specifies that an `IllegalArgumentException` should be thrown instead.

For this reason, when bootstrapping the Hibernate `SessionFactory` using the native API, the legacy detached entity refresh behavior is going to be preserved.
On the other hand, when bootstrapping Hibernate through the JPA `EntityManagerFactory` building process, detached entities are not allowed to be refreshed by default.

However, this default behavior can be overwritten through the `hibernate.allow_refresh_detached_entity` configuration property.
If this property is explicitly set to `true`, then you can refresh detached entities even when using the JPA bootstraps mechanism, therefore bypassing the JPA specification restriction.

For more about the `hibernate.allow_refresh_detached_entity` configuration property,
check out the <<appendices/Configurations.adoc#misc,Configurations>> section as well.
====

[[pc-refresh-gotchas]]
==== Refresh gotchas

The `refresh` entity state transition is meant to overwrite the entity attributes according to the info currently contained in the associated database record.

However, you have to be very careful when cascading the refresh action to any transient entity.

For instance, consider the following example:

[[pc-refresh-child-entity-jpa-example]]
.Refreshing entity state gotcha
====
[source, JAVA, indent=0]
----
include::{sourcedir}/PersistenceContextTest.java[tags=pc-refresh-child-entity-jpa-example]
----
====

In the aforementioned example, an `EntityNotFoundException` is thrown because the `Book` entity is still in a transient state.
When the refresh action is cascaded from the `Person` entity, Hibernate will not be able to locate the `Book` entity in the database.

For this reason, you should be very careful when mixing the refresh action with transient child entity objects.

[[pc-detach]]
=== Working with detached data

Detachment is the process of working with data outside the scope of any persistence context.
Data becomes detached in a number of ways.
Once the persistence context is closed, all data that was associated with it becomes detached.
Clearing the persistence context has the same effect.
Evicting a particular entity from the persistence context makes it detached.
And finally, serialization will make the deserialized form be detached (the original instance is still managed).

Detached data can still be manipulated, however, the persistence context will no longer automatically know about these modifications, and the application will need to intervene to make the changes persistent again.

[[pc-detach-reattach]]
==== Reattaching detached data

Reattachment is the process of taking an incoming entity instance that is in the detached state and re-associating it with the current persistence context.

[IMPORTANT]
====
JPA does not support reattaching detached data. This is only available through Hibernate `org.hibernate.Session`.
====

[[pc-detach-reattach-lock-example]]
.Reattaching a detached entity using `lock`
====
[source, JAVA, indent=0]
----
include::{sourcedir}/PersistenceContextTest.java[tags=pc-detach-reattach-lock-example]
----
====

[[pc-detach-reattach-saveOrUpdate-example]]
.Reattaching a detached entity using `saveOrUpdate`
====
[source, JAVA, indent=0]
----
include::{sourcedir}/PersistenceContextTest.java[tags=pc-detach-reattach-saveOrUpdate-example]
----
====

[NOTE]
====
The method name `update` is a bit misleading here.
It does not mean that an `SQL` `UPDATE` is immediately performed.
It does, however, mean that an `SQL` `UPDATE` will be performed when the persistence context is flushed since Hibernate does not know its previous state against which to compare for changes.
If the entity is mapped with `select-before-update`, Hibernate will pull the current state from the database and see if an update is needed.
====

Provided the entity is detached, `update` and `saveOrUpdate` operate exactly the same.

[[pc-merge]]
==== Merging detached data

Merging is the process of taking an incoming entity instance that is in the detached state and copying its data over onto a new managed instance.

Although not exactly per se, the following example is a good visualization of the `merge` operation internals.

[[pc-merge-visualize-example]]
.Visualizing merge
====
[source, JAVA, indent=0]
----
include::{sourcedir}/PersistenceContextTest.java[tags=pc-merge-visualize-example]
----
====

[[pc-merge-jpa-example]]
.Merging a detached entity with JPA
====
[source, JAVA, indent=0]
----
include::{sourcedir}/PersistenceContextTest.java[tags=pc-merge-jpa-example]
----
====

[[pc-merge-native-example]]
.Merging a detached entity with Hibernate API
====
[source, JAVA, indent=0]
----
include::{sourcedir}/PersistenceContextTest.java[tags=pc-merge-native-example]
----
====

[[pc-merge-gotchas]]
===== Merging gotchas

For example, Hibernate throws `IllegalStateException` when merging a parent entity which has references to 2 detached child entities `child1` and `child2` (obtained from different sessions), and `child1` and `child2` represent the same persistent entity, `Child`.

A new configuration property, `hibernate.event.merge.entity_copy_observer`, controls how Hibernate will respond when multiple representations of the same persistent entity (""entity copy"") is detected while merging.

The possible values are:

disallow (the default):: throws `IllegalStateException` if an entity copy is detected
allow:: performs the merge operation on each entity copy that is detected
log:: (provided for testing only) performs the merge operation on each entity copy that is detected and logs information about the entity copies.
This setting requires DEBUG logging be enabled for `org.hibernate.event.internal.EntityCopyAllowedLoggedObserver`

In addition, the application may customize the behavior by providing an implementation of `org.hibernate.event.spi.EntityCopyObserver` and setting `hibernate.event.merge.entity_copy_observer` to the class name.
When this property is set to `allow` or `log`, Hibernate will merge each entity copy detected while cascading the merge operation.
In the process of merging each entity copy, Hibernate will cascade the merge operation from each entity copy to its associations with `cascade=CascadeType.MERGE` or `CascadeType.ALL`.
The entity state resulting from merging an entity copy will be overwritten when another entity copy is merged.

[WARNING]
====
Because cascade order is undefined, the order in which the entity copies are merged is undefined.
As a result, if property values in the entity copies are not consistent, the resulting entity state will be indeterminate, and data will be lost from all entity copies except for the last one merged.
Therefore, the *last writer wins*.


If an entity copy cascades the merge operation to an association that is (or contains) a new entity, that new entity will be merged (i.e., persisted and the merge operation will be cascaded to its associations according to its mapping),
even if that same association is ultimately overwritten when Hibernate merges a different representation having a different value for its association.

If the association is mapped with `orphanRemoval = true`, the new entity will not be deleted because the semantics of orphanRemoval do not apply if the entity being orphaned is a new entity.

There are known issues when representations of the same persistent entity have different values for a collection.
See https://hibernate.atlassian.net/browse/HHH-9239[HHH-9239] and https://hibernate.atlassian.net/browse/HHH-9240[HHH-9240] for more details.
These issues can cause data loss or corruption.

By setting `hibernate.event.merge.entity_copy_observer` configuration property to `allow` or `log`,
Hibernate will allow entity copies of any type of entity to be merged.

The only way to exclude particular entity classes or associations that contain critical data is to provide a custom implementation of `org.hibernate.event.spi.EntityCopyObserver` with the desired behavior,
and setting `hibernate.event.merge.entity_copy_observer` to the class name.
====

[TIP]
====
Hibernate provides limited DEBUG logging capabilities that can help determine the entity classes for which entity copies were found.
By setting `hibernate.event.merge.entity_copy_observer` to `log` and enabling DEBUG logging for `org.hibernate.event.internal.EntityCopyAllowedLoggedObserver`,
the following will be logged each time an application calls `EntityManager.merge( entity )` or +
`Session.merge( entity )`:

- number of times multiple representations of the same persistent entity was detected summarized by entity name;
- details by entity name and ID, including output from calling toString() on each representation being merged as well as the merge result.

The log should be reviewed to determine if multiple representations of entities containing critical data are detected.
If so, the application should be modified so there is only one representation, and a custom implementation of `org.hibernate.event.spi.EntityCopyObserver` should be provided to disallow entity copies for entities with critical data.

Using optimistic locking is recommended to detect if different representations are from different versions of the same persistent entity.
If they are not from the same version, Hibernate will throw either the JPA `OptimisticLockException` or the native `StaleObjectStateException` depending on your bootstrapping strategy.
====

[[pc-contains]]
=== Checking persistent state

An application can verify the state of entities and collections in relation to the persistence context.

[[pc-contains-jpa-example]]
.Verifying managed state with JPA
====
[source, JAVA, indent=0]
----
include::{sourcedir}/PersistenceContextTest.java[tags=pc-contains-jpa-example]
----
====

[[pc-contains-native-example]]
.Verifying managed state with Hibernate API
====
[source, JAVA, indent=0]
----
include::{sourcedir}/PersistenceContextTest.java[tags=pc-contains-native-example]
----
====

[[pc-verify-lazy-jpa-example]]
.Verifying laziness with JPA
====
[source, JAVA, indent=0]
----
include::{sourcedir}/PersistenceContextTest.java[tags=pc-verify-lazy-jpa-example]
----
====

[[pc-verify-lazy-native-example]]
.Verifying laziness with Hibernate API
====
[source, JAVA, indent=0]
----
include::{sourcedir}/PersistenceContextTest.java[tags=pc-verify-lazy-native-example]
----
====

In JPA there is an alternative means to check laziness using the following `javax.persistence.PersistenceUtil` pattern (which is recommended wherever possible).

[[pc-verify-lazy-jpa-alternative-example]]
.Alternative JPA means to verify laziness
====
[source, JAVA, indent=0]
----
include::{sourcedir}/PersistenceContextTest.java[tags=pc-verify-lazy-jpa-alternative-example]
----
====

=== Evicting entities

When the `flush()` method is called, the state of the entity is synchronized with the database.
If you do not want this synchronization to occur, or if you are processing a huge number of objects and need to manage memory efficiently,
the `evict()` method can be used to remove the object and its collections from the first-level cache.

[[caching-management-jpa-detach-example]]
.Detaching an entity from the `EntityManager`
====
[source, JAVA, indent=0]
----
include::{sourcedir-caching}/FirstLevelCacheTest.java[tags=caching-management-jpa-detach-example]
----
====

[[caching-management-native-evict-example]]
.Evicting an entity from the Hibernate `Session`
====
[source, JAVA, indent=0]
----
include::{sourcedir-caching}/FirstLevelCacheTest.java[tags=caching-management-native-evict-example]
----
====

To detach all entities from the current persistence context, both the `EntityManager` and the Hibernate `Session` define a `clear()` method.

[[caching-management-clear-example]]
.Clearing the persistence context
====
[source, JAVA, indent=0]
----
include::{sourcedir-caching}/FirstLevelCacheTest.java[tags=caching-management-clear-example]
----
====

To verify if an entity instance is currently attached to the running persistence context, both the `EntityManager` and the Hibernate `Session` define a `contains(Object entity)` method.

[[caching-management-contains-example]]
.Verify if an entity is contained in a persistence context
====
[source, JAVA, indent=0]
----
include::{sourcedir-caching}/FirstLevelCacheTest.java[tags=caching-management-contains-example]
----
====

[[pc-cascade]]
=== Cascading entity state transitions

JPA allows you to propagate the state transition from a parent entity to a child.
For this purpose, the JPA `javax.persistence.CascadeType` defines various cascade types:

`ALL`:: cascades all entity state transitions.
`PERSIST`:: cascades the entity persist operation.
`MERGE`:: cascades the entity merge operation.
`REMOVE`:: cascades the entity remove operation.
`REFRESH`:: cascades the entity refresh operation.
`DETACH`:: cascades the entity detach operation.

Additionally, the `CascadeType.ALL` will propagate any Hibernate-specific operation, which is defined by the `org.hibernate.annotations.CascadeType` enum:

`SAVE_UPDATE`:: cascades the entity saveOrUpdate operation.
`REPLICATE`:: cascades the entity replicate operation.
`LOCK`:: cascades the entity lock operation.

The following examples will explain some of the aforementioned cascade operations using the following entities:

[source, JAVA, indent=0]
----
include::{sourcedir}/Person.java[tags=pc-cascade-domain-model-example]

include::{sourcedir}/Phone.java[tags=pc-cascade-domain-model-example]
----

[[pc-cascade-persist]]
==== `CascadeType.PERSIST`

The `CascadeType.PERSIST` allows us to persist a child entity along with the parent one.

[[pc-cascade-persist-example]]
.`CascadeType.PERSIST` example
====
[source, JAVA, indent=0]
----
include::{sourcedir}/CascadePersistTest.java[tags=pc-cascade-persist-example]
----

[source, SQL, indent=0]
----
include::{extrasdir}/pc-cascade-persist-example.sql[]
----
====

Even if just the `Person` parent entity was persisted, Hibernate has managed to cascade the persist operation to the associated `Phone` child entity as well.

[[pc-cascade-merge]]
==== `CascadeType.MERGE`

The `CascadeType.MERGE` allows us to merge a child entity along with the parent one.

[[pc-cascade-merge-example]]
.`CascadeType.MERGE` example
====
[source, JAVA, indent=0]
----
include::{sourcedir}/CascadeMergeTest.java[tags=pc-cascade-merge-example]
----

[source, SQL, indent=0]
----
include::{extrasdir}/pc-cascade-merge-example.sql[]
----
====

During merge, the current state of the entity is copied onto the entity version that was just fetched from the database.
That's the reason why Hibernate executed the SELECT statement which fetched both the `Person` entity along with its children.

[[pc-cascade-remove]]
==== `CascadeType.REMOVE`

The `CascadeType.REMOVE` allows us to remove a child entity along with the parent one.
Traditionally, Hibernate called this operation delete, that's why the `org.hibernate.annotations.CascadeType` provides a `DELETE` cascade option.
However, `CascadeType.REMOVE` and `org.hibernate.annotations.CascadeType.DELETE` are identical.

[[pc-cascade-remove-example]]
.`CascadeType.REMOVE` example
====
[source, JAVA, indent=0]
----
include::{sourcedir}/CascadeRemoveTest.java[tags=pc-cascade-remove-example]
----

[source, SQL, indent=0]
----
include::{extrasdir}/pc-cascade-remove-example.sql[]
----
====

[[pc-cascade-detach]]
==== `CascadeType.DETACH`

`CascadeType.DETACH` is used to propagate the detach operation from a parent entity to a child.

[[pc-cascade-detach-example]]
.`CascadeType.DETACH` example
====
[source, JAVA, indent=0]
----
include::{sourcedir}/CascadeDetachTest.java[tags=pc-cascade-detach-example]
----
====

[[pc-cascade-lock]]
==== `CascadeType.LOCK`

Although unintuitively, `CascadeType.LOCK` does not propagate a lock request from a parent entity to its children.
Such a use case requires the use of the `PessimisticLockScope.EXTENDED` value of the `javax.persistence.lock.scope` property.

However, `CascadeType.LOCK` allows us to reattach a parent entity along with its children to the currently running Persistence Context.

[[pc-cascade-lock-example]]
.`CascadeType.LOCK` example
====
[source, JAVA, indent=0]
----
include::{sourcedir}/CascadeLockTest.java[tags=pc-cascade-lock-example]
----
====

[[pc-cascade-refresh]]
==== `CascadeType.REFRESH`

The `CascadeType.REFRESH` is used to propagate the refresh operation from a parent entity to a child.
The refresh operation will discard the current entity state, and it will override it using the one loaded from the database.

[[pc-cascade-refresh-example]]
.`CascadeType.REFRESH` example
====
[source, JAVA, indent=0]
----
include::{sourcedir}/CascadeRefreshTest.java[tags=pc-cascade-refresh-example]
----

[source, SQL, indent=0]
----
include::{extrasdir}/pc-cascade-refresh-example.sql[]
----
====

In the aforementioned example, you can see that both the `Person` and `Phone` entities are refreshed even if we only called this operation on the parent entity only.

[[pc-cascade-replicate]]
==== `CascadeType.REPLICATE`

The `CascadeType.REPLICATE` is to replicate both the parent and the child entities.
The replicate operation allows you to synchronize entities coming from different sources of data.

[[pc-cascade-replicate-example]]
.`CascadeType.REPLICATE` example
====
[source, JAVA, indent=0]
----
include::{sourcedir}/CascadeReplicateTest.java[tags=pc-cascade-replicate-example]
----

[source, SQL, indent=0]
----
include::{extrasdir}/pc-cascade-replicate-example.sql[]
----
====

As illustrated by the SQL statements being generated, both the `Person` and `Phone` entities are replicated to the underlying database rows.

[[pc-cascade-on-delete]]
==== `@OnDelete` cascade

While the previous cascade types propagate entity state transitions, the `@OnDelete` cascade is a DDL-level FK feature which allows you
to remove a child record whenever the parent row is deleted.

So, when annotating the `@ManyToOne` association with `@OnDelete( action = OnDeleteAction.CASCADE )`,
the automatic schema generator will apply the ON DELETE CASCADE SQL directive to the Foreign Key declaration,
as illustrated by the following example.

[[pc-cascade-on-delete-mapping-example]]
.`@OnDelete` `@ManyToOne` mapping
====
[source, JAVA, indent=0]
----
include::{sourcedir}/CascadeOnDeleteTest.java[tags=pc-cascade-on-delete-mapping-Person-example]
----

[source, JAVA, indent=0]
----
include::{sourcedir}/CascadeOnDeleteTest.java[tags=pc-cascade-on-delete-mapping-Phone-example]
----

[source, SQL, indent=0]
----
include::{extrasdir}/pc-cascade-on-delete-mapping-example.sql[]
----
====

Now, you can just remove the `Person` entity, and the associated `Phone` entities are going to be deleted automatically via the Foreign Key cascade.

[[pc-cascade-on-delete-example]]
.`@OnDelete` `@ManyToOne` delete example
====
[source, JAVA, indent=0]
----
include::{sourcedir}/CascadeOnDeleteTest.java[tags=pc-cascade-on-delete-example]
----

[source, SQL, indent=0]
----
include::{extrasdir}/pc-cascade-on-delete-example.sql[]
----
====

The `@OnDelete` annotation can also be placed on a collection, as
illustrated in the following example.

[[pc-cascade-on-delete-collection-mapping-example]]
.`@OnDelete` `@OneToMany` mapping
====
[source, JAVA, indent=0]
----
include::{sourcedir}/CascadeOnDeleteCollectionTest.java[tags=pc-cascade-on-delete-collection-mapping-Person-example]
----

[source, JAVA, indent=0]
----
include::{sourcedir}/CascadeOnDeleteCollectionTest.java[tags=pc-cascade-on-delete-collection-mapping-Phone-example]
----
====

Now, when removing the `Person` entity, all the associated `Phone` child entities are deleted via the Foreign Key cascade even if the `@OneToMany` collection was using the `CascadeType.ALL` attribute.

[[pc-cascade-on-delete-collection-example]]
.`@OnDelete` `@ManyToOne` delete example
====
[source, JAVA, indent=0]
----
include::{sourcedir}/CascadeOnDeleteCollectionTest.java[tags=pc-cascade-on-delete-collection-example]
----

[source, SQL, indent=0]
----
include::{extrasdir}/pc-cascade-on-delete-example.sql[]
----
====

[NOTE]
====
Without the `@OnDelete` annotation, the `@OneToMany` association relies on the `cascade` attribute to propagate the `remove` entity state transition from the parent entity to its children.
However, when the `@OnDelete` annotation is in place, Hibernate prevents the child entity `DELETE` statement from being executed while flushing the Persistence Context.

This way, only the parent entity gets deleted, and all the associated child records are removed by the database engine, instead of being deleted explicitly via `DELETE` statements.
====

[[pc-exception-handling]]
=== Exception handling

If the JPA `EntityManager` or the Hibernate-specific `Session` throws an exception, including any JDBC https://docs.oracle.com/javase/8/docs/api/java/sql/SQLException.html[`SQLException`], you have to immediately rollback the database transaction and close the current `EntityManager` or `Session`.

Certain methods of the JPA `EntityManager` or the Hibernate `Session` will not leave the Persistence Context in a consistent state. As a rule of thumb, no exception thrown by Hibernate can be treated as recoverable. Ensure that the Session will be closed by calling the `close()` method in a finally block.

Rolling back the database transaction does not put your business objects back into the state they were at the start of the transaction. This means that the database state and the business objects will be out of sync. Usually, this is not a problem because exceptions are not recoverable and you will have to start over after rollback anyway.

The JPA {jpaJavadocUrlPrefix}PersistenceException.html[`PersistenceException`] or the
https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/HibernateException.html[`HibernateException`] wraps most of the errors that can occur in a Hibernate persistence layer.

Both the `PersistenceException` and the `HibernateException` are runtime exceptions because, in our opinion, we should not force the application developer to catch an unrecoverable exception at a low layer. In most systems, unchecked and fatal exceptions are handled in one of the first frames of the method call stack (i.e., in higher layers) and either an error message is presented to the application user or some other appropriate action is taken. Note that Hibernate might also throw other unchecked exceptions that are not a `HibernateException`. These are not recoverable either, and appropriate action should be taken.

Hibernate wraps the JDBC `SQLException`, thrown while interacting with the database, in a
https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/JDBCException.html[`JDBCException`].
In fact, Hibernate will attempt to convert the exception into a more meaningful subclass of `JDBCException`. The underlying `SQLException` is always available via https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/JDBCException.html#getSQLException--[`JDBCException.getSQLException()`]. Hibernate converts the `SQLException` into an appropriate JDBCException subclass using the
https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/exception/spi/SQLExceptionConverter.html[`SQLExceptionConverter`]
attached to the current `SessionFactory`.

By default, the `SQLExceptionConverter` is defined by the configured Hibernate `Dialect` via the
https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/dialect/Dialect.html#buildSQLExceptionConversionDelegate--[`buildSQLExceptionConversionDelegate`] method
which is overridden by several database-specific ``Dialect``s.

However, it is also possible to plug in a custom implementation. See the
<<appendices/Configurations.adoc#configurations-exception-handling,`hibernate.jdbc.sql_exception_converter`>> configuration property for more details.

The standard `JDBCException` subtypes are:

ConstraintViolationException::
	indicates some form of integrity constraint violation.
DataException::
	indicates that evaluation of the valid SQL statement against the given data
	resulted in some illegal operation, mismatched types, truncation or incorrect cardinality.
GenericJDBCException::
	a generic exception which did not fall into any of the other categories.
JDBCConnectionException::
	indicates an error with the underlying JDBC communication.
LockAcquisitionException::
	indicates an error acquiring a lock level necessary to perform the requested operation.
LockTimeoutException::
	indicates that the lock acquisition request has timed out.
PessimisticLockException::
	indicates that a lock acquisition request has failed.
QueryTimeoutException::
	indicates that the current executing query has timed out.
SQLGrammarException::
	indicates a grammar or syntax problem with the issued SQL.

[NOTE]
====
Starting with Hibernate 5.2, the Hibernate `Session` extends the JPA `EntityManager`. For this reason, when a `SessionFactory` is built via Hibernate's native bootstrapping,
the `HibernateException` or `SQLException` can be wrapped in a JPA {jpaJavadocUrlPrefix}PersistenceException.html[`PersistenceException`] when thrown
by `Session` methods that implement `EntityManager` methods (e.g., https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/Session.html#merge-java.lang.Object-[Session.merge(Object object)],
https://docs.jboss.org/hibernate/orm/{majorMinorVersion}/javadocs/org/hibernate/Session.html#flush--[Session.flush()]).

If your `SessionFactory` is built via Hibernate's native bootstrapping, and you don't want the Hibernate exceptions to be wrapped in the JPA `PersistenceException`, you need to set the
`hibernate.native_exception_handling_51_compliance` configuration property to `true`. See the
<<appendices/Configurations.adoc#configurations-exception-handling,`hibernate.native_exception_handling_51_compliance`>> configuration property for more details.
====
",12530,True,2598.601964338979,median
"/*******************************************************************************
* Copyright 2016-2018 Intel Corporation
*
* Licensed under the Apache License, Version 2.0 (the ""License"");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an ""AS IS"" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*******************************************************************************/

#include <assert.h>
#include ""mkldnn_types.h""

#include ""c_types_map.hpp""
#include ""memory_desc_wrapper.hpp""
#include ""memory_pd.hpp""
#include ""type_helpers.hpp""
#include ""utils.hpp""

namespace mkldnn {
namespace impl {

memory_desc_wrapper::memory_desc_wrapper(const memory_pd_t *m_pd)
    : _md(m_pd == nullptr ? nullptr : m_pd->desc()) {}

namespace {
using namespace mkldnn::impl::utils;
using namespace mkldnn::impl::status;
using namespace mkldnn::impl::memory_format;

status_t fill_x(memory_desc_t &md) {
    const int ndims = md.ndims;
    if (ndims != 1) return invalid_arguments;
    blocking_desc_t &blk = md.layout_desc.blocking;
    array_set(blk.block_dims, 1, ndims);
    array_set(blk.strides[1], 1, ndims);
    blk.strides[0][0] = 1;
    array_copy(blk.padding_dims, md.dims, ndims);
    array_set(blk.offset_padding_to_data, 0, ndims);
    blk.offset_padding = 0;
    return success;
}

/* TODO: improve me maybe... and put this to utils */
inline void set_default_strides(strides_t strides, const dims_t dims,
        int ndims, const int *perm = NULL) {
    int id_perm[TENSOR_MAX_DIMS] = {0};
    for (int i = 0; i < ndims; ++i)
        id_perm[i] = i;
    if (perm == NULL)
        perm = id_perm;

    strides[perm[ndims - 1]] = 1;
    for (int d = 1; d < ndims; ++d) {
        const int prev_idx = perm[ndims - d];
        const int curr_idx = perm[ndims - 1 - d];

        strides[curr_idx] = dims[curr_idx] == 0
            ? 1
            : strides[prev_idx] * nstl::max(1, dims[prev_idx]);
    }
}

status_t fill_nonblocked(memory_desc_t &md, const int perm[]) {
    const int ndims = md.ndims;
    blocking_desc_t &blk = md.layout_desc.blocking;
    array_set(blk.block_dims, 1, ndims);
    array_set(blk.strides[1], 1, ndims);
    set_default_strides(blk.strides[0], md.dims, ndims, perm);
    array_copy(blk.padding_dims, md.dims, ndims);
    array_set(blk.offset_padding_to_data, 0, ndims);
    blk.offset_padding = 0;
    return success;
}

status_t fill_contiguous_blocked(memory_desc_t &md, const dims_t block_dims,
        const int perm[]) {
    const int ndims = md.ndims;

    blocking_desc_t &blk = md.layout_desc.blocking;
    array_copy(blk.block_dims, block_dims, ndims);

    dim_t unrolled_dims[2*TENSOR_MAX_DIMS];
    stride_t unrolled_strides[2*TENSOR_MAX_DIMS];
    dims_t padding_dims;

    for (int d = 0; d < ndims; ++d) {
        unrolled_dims[d] = div_up(md.dims[d], block_dims[d]);
        unrolled_dims[ndims + d] = block_dims[d];
        padding_dims[d] = rnd_up(md.dims[d], block_dims[d]);
    }

    set_default_strides(unrolled_strides, unrolled_dims, 2*ndims, perm);
    array_copy(blk.strides[0], &unrolled_strides[0], ndims);
    array_copy(blk.strides[1], &unrolled_strides[ndims], ndims);
    array_copy(blk.padding_dims, padding_dims, ndims);
    array_set(blk.offset_padding_to_data, 0, ndims);
    blk.offset_padding = 0;
    return success;
}

status_t fill_nc(memory_desc_t &md) {
    if (md.ndims != 2) return invalid_arguments;

    const int perm[2] = {0, 1};
    return fill_nonblocked(md, perm);
}

status_t fill_ncw(memory_desc_t &md) {
    if (md.ndims != 3) return invalid_arguments;

    const int perm[3] = {0, 1, 2};
    return fill_nonblocked(md, perm);
}

status_t fill_nwc(memory_desc_t &md) {
    if (md.ndims != 3) return invalid_arguments;

    const int perm[3] = {0, 2, 1};
    return fill_nonblocked(md, perm);
}

status_t fill_nCw4c(memory_desc_t &md) {
    if (md.ndims != 3) return invalid_arguments;

    const dims_t block_dims = { 1, 4, 1 };
    const int perm[] = {
        0, 1, 2,
        3, 4, 5 };
    return fill_contiguous_blocked(md, block_dims, perm);
}


status_t fill_nCw8c(memory_desc_t &md) {
    if (md.ndims != 3) return invalid_arguments;

    const dims_t block_dims = {1, 8, 1, 1};
    const int perm[] = {
        0, 1, 2,
        3, 4, 5};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_nCw16c(memory_desc_t &md) {
    if (md.ndims != 3) return invalid_arguments;

    const dims_t block_dims = {1, 16, 1};
    const int perm[] = {
        0, 1, 2,
        3, 4, 5};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_nchw(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const int perm[4] = {0, 1, 2, 3};
    return fill_nonblocked(md, perm);
}

status_t fill_ncdhw(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const int perm[5] = {0, 1, 2, 3, 4};
    return fill_nonblocked(md, perm);
}

status_t fill_oidhw(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const int perm[5] = {0, 1, 2, 3, 4};
    return fill_nonblocked(md, perm);
}

status_t fill_goidhw(memory_desc_t &md) {
    if (md.ndims != 6) return invalid_arguments;

    const int perm[6] = {0, 1, 2, 3, 4, 5};
    return fill_nonblocked(md, perm);
}

status_t fill_nhwc(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const int perm[4] = {0, 2, 3, 1};
    return fill_nonblocked(md, perm);
}

status_t fill_ndhwc(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const int perm[5] = {0, 2, 3, 4, 1};
    return fill_nonblocked(md, perm);
}

status_t fill_chwn(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const int perm[4] = {1, 2, 3, 0};
    return fill_nonblocked(md, perm);
}

status_t fill_nChw4c(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = { 1, 4, 1, 1 };
    const int perm[] = {
        0, 1, 2, 3,
        4, 5, 6, 7 };
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_nChw8c(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = {1, 8, 1, 1};
    const int perm[] = {
        0, 1, 2, 3,
        4, 5, 6, 7};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_nChw16c(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = {1, 16, 1, 1};
    const int perm[] = {
        0, 1, 2, 3,
        4, 5, 6, 7};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_nCdhw16c(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = {1, 16, 1, 1, 1};
    const int perm[] = {
        0, 1, 2, 3, 4,
        5, 6, 7, 8, 9};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_nCdhw4c(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = { 1, 4, 1, 1, 1 };
    const int perm[] = {
        0, 1, 2, 3, 4,
        5, 6, 7, 8, 9 };
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_nCdhw8c(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = {1, 8, 1, 1, 1};
    const int perm[] = {
        0, 1, 2, 3, 4,
        5, 6, 7, 8, 9};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_oi(memory_desc_t &md) {
    if (md.ndims != 2) return invalid_arguments;

    const int perm[2] = {0, 1};
    return fill_nonblocked(md, perm);
}

status_t fill_io(memory_desc_t &md) {
    if (md.ndims != 2) return invalid_arguments;

    const int perm[2] = {1, 0};
    return fill_nonblocked(md, perm);
}

status_t fill_oiw(memory_desc_t &md) {
    if (md.ndims != 3) return invalid_arguments;

    const int perm[3] = {0, 1, 2};
    return fill_nonblocked(md, perm);
}

status_t fill_wio(memory_desc_t &md) {
    if (md.ndims != 3) return invalid_arguments;

    const int perm[3] = {2, 1, 0};
    return fill_nonblocked(md, perm);
}

status_t fill_owi(memory_desc_t &md) {
    if (md.ndims != 3) return invalid_arguments;

    const int perm[3] = {0, 2, 1};
    return fill_nonblocked(md, perm);
}

status_t fill_Owi4o(memory_desc_t &md) {
    if (md.ndims != 3) return invalid_arguments;

    const dims_t block_dims = { 4, 1, 1 };
    const int perm[] = {
        0, 2, 1,
        3, 4, 5 };
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_Owi8o(memory_desc_t &md) {
    if (md.ndims != 3) return invalid_arguments;

    const dims_t block_dims = {8, 1, 1};
    const int perm[] = {
        0, 2, 1,
        3, 4, 5};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_OIw8o8i(memory_desc_t &md) {
    if (md.ndims != 3) return invalid_arguments;

    const dims_t block_dims = {8, 8, 1};
    const int perm[] = {
        0, 1, 2,
        3, 4, 5};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_OIw4i4o(memory_desc_t &md) {
    if (md.ndims != 3) return invalid_arguments;

    const dims_t block_dims = { 4, 4, 1 };
    const int perm[] = {
        0, 1, 2,
        4, 3, 5 };
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_OIw8i8o(memory_desc_t &md) {
    if (md.ndims != 3) return invalid_arguments;

    const dims_t block_dims = {8, 8, 1};
    const int perm[] = {
        0, 1, 2,
        4, 3, 5};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_OIw16i16o(memory_desc_t &md) {
    if (md.ndims != 3) return invalid_arguments;

    const dims_t block_dims = {16, 16, 1};
    const int perm[] = {
        0, 1, 2,
        4, 3, 5};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_OIw16o16i(memory_desc_t &md) {
    if (md.ndims != 3) return invalid_arguments;

    const dims_t block_dims = {16, 16, 1};
    const int perm[] = {
        0, 1, 2,
        3, 4, 5};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_Oiw4o(memory_desc_t &md) {
    if (md.ndims != 3) return invalid_arguments;

    const dims_t block_dims = {4, 1, 1};
    const int perm[] = {
        0, 1, 2,
        3, 4, 5};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_Oiw16o(memory_desc_t &md) {
    if (md.ndims != 3) return invalid_arguments;

    const dims_t block_dims = { 16, 1, 1 };
    const int perm[] = {
        0, 1, 2,
        3, 4, 5 };
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_Owi16o(memory_desc_t &md) {
    if (md.ndims != 3) return invalid_arguments;

    const dims_t block_dims = {16, 1, 1};
    const int perm[] = {
        0, 2, 1,
        3, 4, 5};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_OIw8i16o2i(memory_desc_t &md) {
    if (md.ndims != 3) return invalid_arguments;

    const dims_t block_dims = {16, 16, 1};
    const int perm[] = {
        0, 1, 2,
        4, 3, 5};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_IOw16o16i(memory_desc_t &md) {
    if (md.ndims != 3) return invalid_arguments;

    const dims_t block_dims = {16, 16, 1};
    const int perm[] = {
        1, 0, 2,
        3, 4, 5};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_OIw8o16i2o(memory_desc_t &md) {
    if (md.ndims != 3) return invalid_arguments;

    const dims_t block_dims = {16, 16, 1};
    const int perm[] = {
        0, 1, 2,
        3, 4, 5};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_IOw8o16i2o(memory_desc_t &md) {
    if (md.ndims != 3) return invalid_arguments;

    const dims_t block_dims = {16, 16, 1};
    const int perm[] = {
        1, 0, 2,
        3, 4, 5};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_oihw(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const int perm[4] = {0, 1, 2, 3};
    return fill_nonblocked(md, perm);
}

status_t fill_ihwo(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const int perm[4] = {1, 2, 3, 0};
    return fill_nonblocked(md, perm);
}

status_t fill_hwio(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const int perm[4] = {2, 3, 1, 0};
    return fill_nonblocked(md, perm);
}

status_t fill_ohwi(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const int perm[4] = {0, 2, 3, 1};
    return fill_nonblocked(md, perm);
}

status_t fill_iohw(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const int perm[4] = {1, 0, 2, 3};
    return fill_nonblocked(md, perm);
}

status_t fill_dhwio(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const int perm[5] = {2, 3, 4, 1, 0};
    return fill_nonblocked(md, perm);
}

status_t fill_odhwi(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const int perm[5] = {0, 2, 3, 4, 1};
    return fill_nonblocked(md, perm);
}

status_t fill_OIhw4i4o(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = { 4, 4, 1, 1 };
    const int perm[] = {
        0, 1, 2, 3,
        5, 4, 6, 7 };
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_OIhw8i8o(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = {8, 8, 1, 1};
    const int perm[] = {
        0, 1, 2, 3,
        5, 4, 6, 7};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_OIhw16i16o(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = {16, 16, 1, 1};
    const int perm[] = {
        0, 1, 2, 3,
        5, 4, 6, 7};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_OIdhw16i16o(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = {16, 16, 1, 1, 1};
    const int perm[] = {
        0, 1, 2, 3, 4,
        6, 5, 7, 8, 9};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_OIdhw4i4o(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = { 4, 4, 1, 1, 1 };
    const int perm[] = {
        0, 1, 2, 3, 4,
        6, 5, 7, 8, 9 };
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_OIdhw8i8o(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = {8, 8, 1, 1, 1};
    const int perm[] = {
        0, 1, 2, 3, 4,
        6, 5, 7, 8, 9};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_OIw4i16o4i(memory_desc_t &md) {
    if (md.ndims != 3) return invalid_arguments;

    const dims_t block_dims = {16, 16, 1};
    const int perm[] = {
        0, 1, 2,
        4, 3, 5};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_OIhw4i16o4i(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = {16, 16, 1, 1};
    const int perm[] = {
        0, 1, 2, 3,
        5, 4, 6, 7};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_OIhw8i16o2i(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = {16, 16, 1, 1};
    const int perm[] = {
        0, 1, 2, 3,
        5, 4, 6, 7};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_IOhw8i16o2i(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = {16, 16, 1, 1};
    const int perm[] = {
        1, 0, 2, 3,
        5, 4, 6, 7};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_OIdhw8i16o2i(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = {16, 16, 1, 1, 1};
    const int perm[] = {
        0, 1, 2, 3, 4,
        6, 5, 7, 8, 9};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_OIhw8o8i(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = {8, 8, 1, 1};
    const int perm[] = {
        0, 1, 2, 3,
        4, 5, 6, 7};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_OIhw16o16i(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = {16, 16, 1, 1};
    const int perm[] = {
        0, 1, 2, 3,
        4, 5, 6, 7};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_OIdhw16o16i(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = {16, 16, 1, 1, 1};
    const int perm[] = {
        0, 1, 2, 3, 4,
        5, 6, 7, 8, 9};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_OIdhw8o8i(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = {8, 8, 1, 1, 1};
    const int perm[] = {
        0, 1, 2, 3, 4,
        5, 6, 7, 8, 9};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_IOhw16o16i(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = {16, 16, 1, 1};
    const int perm[] = {
        1, 0, 2, 3,
        4, 5, 6, 7};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_OIhw8o16i2o(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = {16, 16, 1, 1};
    const int perm[] = {
        0, 1, 2, 3,
        4, 5, 6, 7};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_IOhw8o16i2o(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = {16, 16, 1, 1};
    const int perm[] = {
        1, 0, 2, 3,
        4, 5, 6, 7};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_Oihw4o(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = {4, 1, 1, 1};
    const int perm[] = {
        0, 1, 2, 3,
        4, 5, 6, 7};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_Oihw16o(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = { 16, 1, 1, 1 };
    const int perm[] = {
        0, 1, 2, 3,
        4, 5, 6, 7 };
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_Oidhw4o(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = { 4, 1, 1, 1, 1 };
    const int perm[] = {
        0, 1, 2, 3, 4,
        5, 6, 7, 8, 9 };
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_Oidhw16o(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = {16, 1, 1, 1, 1};
    const int perm[] = {
        0, 1, 2, 3, 4,
        5, 6, 7, 8, 9};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_Ohwi8o(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = {8, 1, 1, 1};
    const int perm[] = {
        0, 2, 3, 1,
        4, 5, 6, 7};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_Ohwi4o(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = {4, 1, 1, 1};
    const int perm[] = {
        0, 2, 3, 1,
        4, 5, 6, 7};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_Ohwi16o(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = { 16, 1, 1, 1 };
    const int perm[] = {
        0, 2, 3, 1,
        4, 5, 6, 7 };
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_Odhwi16o(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = {16, 1, 1, 1, 1};
    const int perm[] = {
        0, 2, 3, 4, 1,
        5, 6, 7, 8, 9};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_Odhwi8o(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = {8, 1, 1, 1, 1};
    const int perm[] = {
        0, 2, 3, 4, 1,
        5, 6, 7, 8, 9};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_goiw(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const int perm[4] = {0, 1, 2, 3};
    return fill_nonblocked(md, perm);
}

status_t fill_gOwi4o(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = {1, 4, 1, 1};
    const int perm[] = {
        0, 1, 3, 2,
        4, 5, 6, 7};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOwi8o(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = { 1, 8, 1, 1 };
    const int perm[] = {
        0, 1, 3, 2,
        4, 5, 6, 7 };
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOIw8o8i(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = { 1, 8, 8, 1 };
    const int perm[] = {
        0, 1, 2, 3,
        4, 5, 6, 7 };
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOIw4i4o(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = { 1, 4, 4, 1 };
    const int perm[] = {
        0, 1, 2, 3,
        4, 6, 5, 7 };
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOIw8i8o(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = {1, 8, 8, 1};
    const int perm[] = {
        0, 1, 2, 3,
        4, 6, 5, 7};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOIw16i16o(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = {1, 16, 16, 1};
    const int perm[] = {
        0, 1, 2, 3,
        4, 6, 5, 7};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOIw16o16i(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = {1, 16, 16, 1};
    const int perm[] = {
        0, 1, 2, 3,
        4, 5, 6, 7};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOiw4o(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = { 1, 4, 1, 1 };
    const int perm[] = {
        0, 1, 2, 3,
        4, 5, 6, 7 };
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOiw16o(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = {1, 16, 1, 1};
    const int perm[] = {
        0, 1, 2, 3,
        4, 5, 6, 7};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOwi16o(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = {1, 16, 1, 1};
    const int perm[] = {
        0, 1, 3, 2,
        4, 5, 6, 7};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOIw8i16o2i(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = {1, 16, 16, 1};
    const int perm[] = {
        0, 1, 2, 3,
        4, 6, 5, 7};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOIw8o16i2o(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = {1, 16, 16, 1};
    const int perm[] = {
        0, 1, 2, 3,
        4, 5, 6, 7};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gIOw8o16i2o(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = {1, 16, 16, 1};
    const int perm[] = {
        0, 2, 1, 3,
        4, 5, 6, 7};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gIOw16o16i(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = {1, 16, 16, 1};
    const int perm[] = {
        0, 2, 1, 3,
        4, 5, 6, 7};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_goihw(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const int perm[5] = {0, 1, 2, 3, 4};
    return fill_nonblocked(md, perm);
}

status_t fill_hwigo(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const int perm[5] = {3, 4, 2, 0, 1};
    return fill_nonblocked(md, perm);
}

status_t fill_giohw(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const int perm[5] = {0, 2, 1, 3, 4};
    return fill_nonblocked(md, perm);
}

status_t fill_gOIhw4o4i(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = {1, 4, 4, 1, 1};
    const int perm[] = {
        0, 1, 2, 3, 4,
        5, 6, 7, 8, 9};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOIhw4i4o(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = { 1, 4, 4, 1, 1 };
    const int perm[] = {
        0, 1, 2, 3, 4,
        5, 7, 6, 8, 9 };
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOIhw8i8o(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = { 1, 8, 8, 1, 1 };
    const int perm[] = {
        0, 1, 2, 3, 4,
        5, 7, 6, 8, 9 };
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOIhw16i16o(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = {1, 16, 16, 1, 1};
    const int perm[] = {
        0, 1, 2, 3, 4,
        5, 7, 6, 8, 9};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOIdhw16i16o(memory_desc_t &md) {
    if (md.ndims != 6) return invalid_arguments;

    const dims_t block_dims = {1, 16, 16, 1, 1, 1};
    const int perm[] = {
        0, 1, 2, 3, 4, 5,
        6, 8, 7, 9, 10, 11};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_OIdhw8o16i2o(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = {16, 16, 1, 1, 1};
    const int perm[] = {
        0, 1, 2, 3, 4,
        5, 6, 7, 8, 9};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_IOdhw8o16i2o(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = {16, 16, 1, 1, 1};
    const int perm[] = {
        1, 0, 2, 3, 4,
        5, 6, 7, 8, 9};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOIdhw4i4o(memory_desc_t &md) {
    if (md.ndims != 6) return invalid_arguments;

    const dims_t block_dims = {1, 4, 4, 1, 1, 1};
    const int perm[] = {
        0, 1, 2, 3, 4, 5,
        6, 8, 7, 9, 10, 11};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOIdhw8i8o(memory_desc_t &md) {
    if (md.ndims != 6) return invalid_arguments;

    const dims_t block_dims = { 1, 8, 8, 1, 1, 1 };
    const int perm[] = {
        0, 1, 2, 3, 4, 5,
        6, 8, 7, 9, 10, 11 };
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOihw4o(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = {1, 4, 1, 1, 1};
    const int perm[] = {
        0, 1, 2, 3, 4,
        5, 6, 7, 8, 9};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOihw16o(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = { 1, 16, 1, 1, 1 };
    const int perm[] = {
        0, 1, 2, 3, 4,
        5, 6, 7, 8, 9 };
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOidhw4o(memory_desc_t &md) {
    if (md.ndims != 6) return invalid_arguments;

    const dims_t block_dims = {1, 4, 1, 1, 1, 1};
    const int perm[] = {
        0, 1, 2, 3, 4, 5,
        6, 7, 8, 9, 10, 11};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOidhw16o(memory_desc_t &md) {
    if (md.ndims != 6) return invalid_arguments;

    const dims_t block_dims = { 1, 16, 1, 1, 1, 1 };
    const int perm[] = {
        0, 1, 2, 3, 4, 5,
        6, 7, 8, 9, 10, 11 };
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOhwi8o(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = {1, 8, 1, 1, 1};
    const int perm[] = {
        0, 1, 3, 4, 2,
        5, 6, 7, 8, 9};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOhwi4o(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = {1, 4, 1, 1, 1};
    const int perm[] = {
        0, 1, 3, 4, 2,
        5, 6, 7, 8, 9};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOhwi16o(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = { 1, 16, 1, 1, 1 };
    const int perm[] = {
        0, 1, 3, 4, 2,
        5, 6, 7, 8, 9 };
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOdhwi16o(memory_desc_t &md) {
    if (md.ndims != 6) return invalid_arguments;

    const dims_t block_dims = {1, 16, 1, 1, 1, 1};
    const int perm[] = {
        0, 1, 3, 4, 5, 2,
        6, 7, 8, 9, 10, 11};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOdhwi8o(memory_desc_t &md) {
    if (md.ndims != 6) return invalid_arguments;

    const dims_t block_dims = {1, 8, 1, 1, 1, 1};
    const int perm[] = {
        0, 1, 3, 4, 5, 2,
        6, 7, 8, 9, 10, 11};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOIw4i16o4i(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = {1, 16, 16, 1};
    const int perm[] = {
        0, 1, 2, 3,
        4, 6, 5, 7};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOIhw4i16o4i(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = {1, 16, 16, 1, 1};
    const int perm[] = {
        0, 1, 2, 3, 4,
        5, 7, 6, 8, 9};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOIhw2i8o4i(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = {1, 8, 8, 1, 1};
    const int perm[] = {
        0, 1, 2, 3, 4,
        5, 7, 6, 8, 9};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_Goihw8g(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = {8, 1, 1, 1, 1};
    const int perm[] = {
         0, 1, 2, 3, 4,
         5, 6, 7, 8, 9};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_Goiw16g(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const dims_t block_dims = {16, 1, 1, 1};
    const int perm[] = {
         0, 1, 2, 3,
         4, 5, 6, 7};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_Goihw16g(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = {16, 1, 1, 1, 1};
    const int perm[] = {
         0, 1, 2, 3, 4,
         5, 6, 7, 8, 9};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOIhw8i16o2i(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = {1, 16, 16, 1, 1};
    const int perm[] = {
        0, 1, 2, 3, 4,
        5, 7, 6, 8, 9};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gIOhw8i16o2i(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = {1, 16, 16, 1, 1};
    const int perm[] = {
        0, 2, 1, 3, 4,
        5, 7, 6, 8, 9};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOIdhw8i16o2i(memory_desc_t &md) {
    if (md.ndims != 6) return invalid_arguments;

    const dims_t block_dims = {1, 16, 16, 1, 1, 1};
    const int perm[] = {
        0, 1, 2, 3, 4, 5,
        6, 8, 7, 9, 10, 11};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOIhw8o8i(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = {1, 8, 8, 1, 1};
    const int perm[] = {
        0, 1, 2, 3, 4,
        5, 6, 7, 8, 9};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOIhw16o16i(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = {1, 16, 16, 1, 1};
    const int perm[] = {
        0, 1, 2, 3, 4,
        5, 6, 7, 8, 9};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOIdhw16o16i(memory_desc_t &md) {
    if (md.ndims != 6) return invalid_arguments;

    const dims_t block_dims = {1, 16, 16, 1, 1, 1};
    const int perm[] = {
        0, 1, 2, 3, 4, 5,
        6, 7, 8, 9, 10, 11};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOIdhw8o8i(memory_desc_t &md) {
    if (md.ndims != 6) return invalid_arguments;

    const dims_t block_dims = {1, 8, 8, 1, 1, 1};
    const int perm[] = {
        0, 1, 2, 3, 4, 5,
        6, 7, 8, 9, 10, 11};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gIOhw16o16i(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = {1, 16, 16, 1, 1};
    const int perm[] = {
        0, 2, 1, 3, 4,
        5, 6, 7, 8, 9};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOIhw8o16i2o(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = {1, 16, 16, 1, 1};
    const int perm[] = {
        0, 1, 2, 3, 4,
        5, 6, 7, 8, 9};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gIOhw8o16i2o(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const dims_t block_dims = {1, 16, 16, 1, 1};
    const int perm[] = {
        0, 2, 1, 3, 4,
        5, 6, 7, 8, 9};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gOIdhw8o16i2o(memory_desc_t &md) {
    if (md.ndims != 6) return invalid_arguments;

    const dims_t block_dims = {1, 16, 16, 1, 1, 1};
    const int perm[] = {
        0, 1, 2, 3, 4, 5,
        6, 7, 8, 9, 10, 11};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_gIOdhw8o16i2o(memory_desc_t &md) {
    if (md.ndims != 6) return invalid_arguments;

    const dims_t block_dims = {1, 16, 16, 1, 1, 1};
    const int perm[] = {
        0, 2, 1, 3, 4, 5,
        6, 7, 8, 9, 10, 11};
    return fill_contiguous_blocked(md, block_dims, perm);
}

status_t fill_ntc(memory_desc_t &md) {
    if (md.ndims != 3) return invalid_arguments;

    const int perm[3] = { 1, 0, 2 };
    return fill_nonblocked(md, perm);
}

status_t fill_tnc(memory_desc_t &md) {
    if (md.ndims != 3) return invalid_arguments;
    const int perm[3] = { 0, 1, 2 };
    return fill_nonblocked(md, perm);
}

status_t fill_ldsnc(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;
    const int perm[5] = { 0, 1, 2, 3, 4 };
    return fill_nonblocked(md, perm);
}

status_t fill_ldigo(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const int perm[5] = { 0, 1, 2, 3, 4 };
    return fill_nonblocked(md, perm);
}

status_t fill_ldgoi(memory_desc_t &md) {
    if (md.ndims != 5) return invalid_arguments;

    const int perm[5] = { 0, 1, 3, 4, 2 };
    return fill_nonblocked(md, perm);
}

status_t fill_ldgo(memory_desc_t &md) {
    if (md.ndims != 4) return invalid_arguments;

    const int perm[4] = { 0, 1, 2, 3 };
    return fill_nonblocked(md, perm);
}

}

status_t memory_desc_wrapper::compute_blocking(memory_desc_t &memory_desc)
{
    if (memory_desc.ndims == 0) return invalid_arguments;

    switch (memory_desc.format) {
    case x: return fill_x(memory_desc);
    case nc: return fill_nc(memory_desc);
    case ncw: return fill_ncw(memory_desc);
    case nwc: return fill_nwc(memory_desc);
    case nCw4c: return fill_nCw4c(memory_desc);
    case nCw8c: return fill_nCw8c(memory_desc);
    case nCw16c: return fill_nCw16c(memory_desc);
    case nchw: return fill_nchw(memory_desc);
    case nhwc: return fill_nhwc(memory_desc);
    case chwn: return fill_chwn(memory_desc);
    case nChw4c: return fill_nChw4c(memory_desc);
    case nChw8c: case oIhw8i: return fill_nChw8c(memory_desc);
    case nChw16c: case oIhw16i: return fill_nChw16c(memory_desc);
    case oi: return fill_oi(memory_desc);
    case io: return fill_io(memory_desc);
    case oiw: return fill_oiw(memory_desc);
    case wio: return fill_wio(memory_desc);
    case owi: return fill_owi(memory_desc);
    case Owi4o: return fill_Owi4o(memory_desc);
    case OIw4i4o: return fill_OIw4i4o(memory_desc);
    case Owi8o: return fill_Owi8o(memory_desc);
    case OIw8o8i: return fill_OIw8o8i(memory_desc);
    case OIw8i8o: return fill_OIw8i8o(memory_desc);
    case OIw16i16o: return fill_OIw16i16o(memory_desc);
    case OIw16o16i: return fill_OIw16o16i(memory_desc);
    case Oiw4o: return fill_Oiw4o(memory_desc);
    case Oiw16o: return fill_Oiw16o(memory_desc);
    case Owi16o: return fill_Owi16o(memory_desc);
    case OIw8i16o2i: return fill_OIw8i16o2i(memory_desc);
    case OIw8o16i2o: return fill_OIw8o16i2o(memory_desc);
    case IOw8o16i2o: return fill_IOw8o16i2o(memory_desc);
    case IOw16o16i: return fill_IOw16o16i(memory_desc);
    case oihw: return fill_oihw(memory_desc);
    case ihwo: return fill_ihwo(memory_desc);
    case hwio: return fill_hwio(memory_desc);
    case ohwi: return fill_ohwi(memory_desc);
    case iohw: return fill_iohw(memory_desc);
    case hwio_s8s8: return fill_hwio(memory_desc);
    case dhwio: return fill_dhwio(memory_desc);
    case odhwi: return fill_odhwi(memory_desc);
    case OIhw4i4o: return fill_OIhw4i4o(memory_desc);
    case OIhw8i8o: return fill_OIhw8i8o(memory_desc);
    case OIhw16i16o: return fill_OIhw16i16o(memory_desc);
    case OIw4i16o4i: return fill_OIw4i16o4i(memory_desc);
    case OIw4i16o4i_s8s8: return fill_OIw4i16o4i(memory_desc);
    case OIhw4i16o4i: return fill_OIhw4i16o4i(memory_desc);
    case OIhw4i16o4i_s8s8: return fill_OIhw4i16o4i(memory_desc);
    case OIhw8i16o2i: return fill_OIhw8i16o2i(memory_desc);
    case IOhw8i16o2i: return fill_IOhw8i16o2i(memory_desc);
    case OIhw8o16i2o: return fill_OIhw8o16i2o(memory_desc);
    case IOhw8o16i2o: return fill_IOhw8o16i2o(memory_desc);
    case OIdhw8i16o2i: return fill_OIdhw8i16o2i(memory_desc);
    case OIdhw8o16i2o: return fill_OIdhw8o16i2o(memory_desc);
    case IOdhw8o16i2o: return fill_IOdhw8o16i2o(memory_desc);
    case OIhw8o8i: return fill_OIhw8o8i(memory_desc);
    case OIhw16o16i: return fill_OIhw16o16i(memory_desc);
    case IOhw16o16i: return fill_IOhw16o16i(memory_desc);
    case Oihw4o: return fill_Oihw4o(memory_desc);
    case Oihw16o: return fill_Oihw16o(memory_desc);
    case Ohwi8o: return fill_Ohwi8o(memory_desc);
    case Ohwi4o: return fill_Ohwi4o(memory_desc);
    case Ohwi16o: return fill_Ohwi16o(memory_desc);
    case goiw: return fill_goiw(memory_desc);
    case gOwi4o: return fill_gOwi4o(memory_desc);
    case gOIw4i4o: return fill_gOIw4i4o(memory_desc);
    case gOwi8o: return fill_gOwi8o(memory_desc);
    case gOIw8o8i: return fill_gOIw8o8i(memory_desc);
    case gOIw8i8o: return fill_gOIw8i8o(memory_desc);
    case gOIw16i16o: return fill_gOIw16i16o(memory_desc);
    case gOIw16o16i: return fill_gOIw16o16i(memory_desc);
    case gOiw4o: return fill_gOiw4o(memory_desc);
    case gOiw16o: return fill_gOiw16o(memory_desc);
    case gOwi16o: return fill_gOwi16o(memory_desc);
    case gOIw8i16o2i: return fill_gOIw8i16o2i(memory_desc);
    case gOIw8o16i2o: return fill_gOIw8o16i2o(memory_desc);
    case gIOw8o16i2o: return fill_gIOw8o16i2o(memory_desc);
    case gIOw16o16i: return fill_gIOw16o16i(memory_desc);
    case goihw: return fill_goihw(memory_desc);
    case hwigo: return fill_hwigo(memory_desc);
    case giohw: return fill_giohw(memory_desc);
    case hwigo_s8s8: return fill_hwigo(memory_desc);
    case gOIhw4i4o: return fill_gOIhw4i4o(memory_desc);
    case gOIhw8i8o: return fill_gOIhw8i8o(memory_desc);
    case gOIhw16i16o: return fill_gOIhw16i16o(memory_desc);
    case gOIw4i16o4i: return fill_gOIw4i16o4i(memory_desc);
    case gOIw4i16o4i_s8s8: return fill_gOIw4i16o4i(memory_desc);
    case gOIhw4i16o4i: return fill_gOIhw4i16o4i(memory_desc);
    case gOIhw4i16o4i_s8s8: return fill_gOIhw4i16o4i(memory_desc);
    case gOIhw2i8o4i: return fill_gOIhw2i8o4i(memory_desc);
    case gOIhw2i8o4i_s8s8: return fill_gOIhw2i8o4i(memory_desc);
    case gOIhw8i16o2i: return fill_gOIhw8i16o2i(memory_desc);
    case gIOhw8i16o2i: return fill_gIOhw8i16o2i(memory_desc);
    case gOIhw8o16i2o: return fill_gOIhw8o16i2o(memory_desc);
    case gIOhw8o16i2o: return fill_gIOhw8o16i2o(memory_desc);
    case gOIhw4o4i: return fill_gOIhw4o4i(memory_desc);
    case gOIhw4o4i_s8s8: return fill_gOIhw4o4i(memory_desc);
    case gOIhw8o8i: return fill_gOIhw8o8i(memory_desc);
    case gOIhw16o16i: return fill_gOIhw16o16i(memory_desc);
    case gIOhw16o16i: return fill_gIOhw16o16i(memory_desc);
    case gOihw4o: return fill_gOihw4o(memory_desc);
    case gOihw16o: return fill_gOihw16o(memory_desc);
    case gOhwi8o: return fill_gOhwi8o(memory_desc);
    case gOhwi4o: return fill_gOhwi4o(memory_desc);
    case gOhwi16o: return fill_gOhwi16o(memory_desc);
    case Goihw8g: return fill_Goihw8g(memory_desc);
    case Goiw16g: return fill_Goiw16g(memory_desc);
    case Goiw16g_s8s8: return fill_Goiw16g(memory_desc);
    case Goihw16g: return fill_Goihw16g(memory_desc);
    case Goihw16g_s8s8: return fill_Goihw16g(memory_desc);
    case ncdhw: return fill_ncdhw(memory_desc);
    case ndhwc: return fill_ndhwc(memory_desc);
    case oidhw: return fill_oidhw(memory_desc);
    case goidhw: return fill_goidhw(memory_desc);
    case nCdhw4c: return fill_nCdhw4c(memory_desc);
    case nCdhw8c: case oIdhw8i: return fill_nCdhw8c(memory_desc);
    case nCdhw16c: case oIdhw16i: return fill_nCdhw16c(memory_desc);
    case OIdhw16i16o: return fill_OIdhw16i16o(memory_desc);
    case gOIdhw16i16o: return fill_gOIdhw16i16o(memory_desc);
    case OIdhw4i4o: return fill_OIdhw4i4o(memory_desc);
    case gOIdhw4i4o: return fill_gOIdhw4i4o(memory_desc);
    case OIdhw8i8o: return fill_OIdhw8i8o(memory_desc);
    case gOIdhw8i8o: return fill_gOIdhw8i8o(memory_desc);
    case OIdhw16o16i: return fill_OIdhw16o16i(memory_desc);
    case gOIdhw8i16o2i: return fill_gOIdhw8i16o2i(memory_desc);
    case gOIdhw8o16i2o: return fill_gOIdhw8o16i2o(memory_desc);
    case gIOdhw8o16i2o: return fill_gIOdhw8o16i2o(memory_desc);
    case gOIdhw16o16i: return fill_gOIdhw16o16i(memory_desc);
    case OIdhw8o8i: return fill_OIdhw8o8i(memory_desc);
    case gOIdhw8o8i: return fill_gOIdhw8o8i(memory_desc);
    case Oidhw4o: return fill_Oidhw4o(memory_desc);
    case Oidhw16o: return fill_Oidhw16o(memory_desc);
    case Odhwi16o: return fill_Odhwi16o(memory_desc);
    case Odhwi8o: return fill_Odhwi8o(memory_desc);
    case gOidhw4o: return fill_gOidhw4o(memory_desc);
    case gOidhw16o: return fill_gOidhw16o(memory_desc);
    case gOdhwi16o: return fill_gOdhwi16o(memory_desc);
    case gOdhwi8o: return fill_gOdhwi8o(memory_desc);
    case ntc: return fill_ntc(memory_desc);
    case tnc: return fill_tnc(memory_desc);
    case ldsnc: return fill_ldsnc(memory_desc);
    case ldigo: return fill_ldigo(memory_desc);
    case ldgoi: return fill_ldgoi(memory_desc);
    case ldgo: return fill_ldgo(memory_desc);
    case wino_fmt:
    case rnn_packed: return success;
    default: break;
    }

    return invalid_arguments;
}

}
}

// vim: et ts=4 sw=4 cindent cino^=l0,\\:0,N-s
",16157,True,4813.700364048503,median
"#include <FWCore/Framework/interface/MakerMacros.h>

#include <DataFormats/Common/interface/DetSetVector.h>

#include <DataFormats/SiStripCommon/interface/SiStripEventSummary.h>
#include <DataFormats/SiStripDigi/interface/SiStripDigi.h>
#include <DataFormats/SiStripDigi/interface/SiStripRawDigi.h>
#include <DataFormats/SiStripDigi/interface/SiStripProcessedRawDigi.h>
#include <FWCore/Framework/interface/EventSetup.h> 
#include <FWCore/Framework/interface/EventSetupRecord.h> 

#include <Alignment/LaserAlignment/interface/LASGlobalLoop.h>

#include ""TFile.h""
#include ""TTree.h""

#include ""RawDataConverter.h""

///
/// constructors and destructor
///
RawDataConverter::RawDataConverter( const edm::ParameterSet& iConfig ) :
  theOutputFile(0),
  theOutputTree(0),
  latency(-1),
  eventnumber(-1),
  runnumber(-1),
  lumiBlock(-1)
  
{
  theOutputFile = new TFile( iConfig.getUntrackedParameter<std::string>( ""OutputFileName"" ).c_str() , ""RECREATE"" );
  theOutputFile->cd();
  theOutputTree = new TTree( ""lasRawDataTree"", ""lasRawDataTree"" );
  theOutputTree->Branch( ""lasRawData"", &theData );
  theOutputTree->Branch( ""latency"", &latency, ""latency/I"" );
  theOutputTree->Branch( ""eventnumber"", &eventnumber, ""eventnumber/I"" );
  theOutputTree->Branch( ""runnumber"", &runnumber, ""runnumber/I"" );
  theOutputTree->Branch( ""lumiblock"", &lumiBlock, ""lumiblock/I"" );
  
  theDigiModuleLabels = iConfig.getParameter<std::vector<std::string> >( ""DigiModuleLabels"" );
  theProductInstanceLabels = iConfig.getParameter<std::vector<std::string> >( ""ProductInstanceLabels"" );
}


///
///
///
RawDataConverter::~RawDataConverter() {
}


///
///
///
void RawDataConverter::beginJob() 
{  
  fillDetectorId();

}



///
///
///
void RawDataConverter::beginRun(edm::Run const & theRun, edm::EventSetup const & theEventSetup) 
{
  std::vector< edm::eventsetup::EventSetupRecordKey > oToFill;
  theEventSetup.fillAvailableRecordKeys (oToFill);
  std::ostringstream o;
  for(std::vector<edm::eventsetup::EventSetupRecordKey>::size_type i = 0; i < oToFill.size(); i++){
    o << oToFill[i].name() << ""\\n"";
  }
  LogDebug(""RawDataConverter"") << ""The size of EventSetup is: "" << oToFill.size() << ""\\n"" << o.str();
}



RawDataConverter::DigiType RawDataConverter::GetValidLabels( const edm::Event& iEvent ) // Check what kind of file is being processed and get valid module and instance labels
{
  // Clear the current labels
  CurrentModuleLabel = """";
  CurrentInstanceLabel = """";

  //Create handles for testing
  edm::Handle< edm::DetSetVector<SiStripDigi> > theStripDigis;
  edm::Handle< edm::DetSetVector<SiStripRawDigi> > theStripRawDigis;
  edm::Handle< edm::DetSetVector<SiStripProcessedRawDigi> > theStripProcessedRawDigis;

  // Create stream foer debug message
  std::ostringstream search_message;
  search_message << ""Searching for SiStripDigis\\n"";
  // Loop through Module and instance labels that were defined in the configuration
  for( std::vector<std::string>::iterator moduleLabel = theDigiModuleLabels.begin(); moduleLabel != theDigiModuleLabels.end(); ++moduleLabel ) {
    for( std::vector<std::string>::iterator instanceLabel = theProductInstanceLabels.begin(); instanceLabel != theProductInstanceLabels.end(); ++instanceLabel ) {

      search_message << ""Checking for Module "" << *moduleLabel << "" Instance "" << *instanceLabel << ""\\n"";

      //First try ZeroSuppressed Digis
      iEvent.getByLabel( *moduleLabel , *instanceLabel , theStripDigis );
      if(theStripDigis.isValid()){
	search_message << ""Found ZeroSuppressed\\n"";
	edm::LogInfo(""RawDataConverter"") << search_message.str();
	CurrentModuleLabel = *moduleLabel;
	CurrentInstanceLabel = *instanceLabel;
	return ZeroSuppressed;
      }

      // Next try VirginRaw Digis      
      iEvent.getByLabel( *moduleLabel , *instanceLabel , theStripRawDigis );
      if(theStripRawDigis.isValid()){
	search_message << ""Found Raw\\n"";
	edm::LogInfo(""RawDataConverter"") << search_message.str();
	CurrentModuleLabel = *moduleLabel;
	CurrentInstanceLabel = *instanceLabel;
	return VirginRaw;
      }

      // Next try ProcessedRaw Digis      
      iEvent.getByLabel( *moduleLabel , *instanceLabel , theStripProcessedRawDigis );
      if(theStripProcessedRawDigis.isValid()){
	search_message << ""Found ProcessedRaw\\n"";
	edm::LogInfo(""RawDataConverter"") << search_message.str();
	CurrentModuleLabel = *moduleLabel;
	CurrentInstanceLabel = *instanceLabel;
	return ProcessedRaw;
      }
    }
  }
  return Unknown;
}

///
///
///
void RawDataConverter::analyze( const edm::Event& iEvent, const edm::EventSetup& iSetup )
{
  // Determine the digi type to be used (only for the first time this methosd is called)
  static DigiType digitype = Unknown;  // Type of digis in this run
  if(digitype == Unknown) digitype = GetValidLabels( iEvent );   // Initialization of Digi Type

  //////////////////////////////////////////////////////////
  // Retrieve SiStripEventSummary produced by the digitizer
  //////////////////////////////////////////////////////////
  edm::Handle<SiStripEventSummary> summary;
  //iEvent.getByLabel( digiProducer, summary );
  iEvent.getByLabel( ""siStripDigis"", summary );
  latency = static_cast<int32_t>( summary->latency() );
  eventnumber = iEvent.id().event();
  runnumber = iEvent.run();
  lumiBlock = iEvent.luminosityBlock();
  //edm::LogAbsolute(""RawdataConverter"") << "" > run: "" << runnumber << "" event: "" << eventnumber << "" lumiBlock: "" << lumiBlock << "" latency: "" << latency << std::endl;

  ///////////////////////////////////////////////////////////
  // Handles for holding possible Digis
  edm::Handle< edm::DetSetVector<SiStripRawDigi> > theStripRawDigis;
  edm::Handle< edm::DetSetVector<SiStripProcessedRawDigi> > theStripProcessedRawDigis;

  // Get the Digis as definef by digitype
  // Currently only ZeroSuppressed is implemented properly
  switch( digitype){
  case ZeroSuppressed:
    GetDigis<SiStripDigi>(iEvent);
    break;
  case VirginRaw:
    throw std::runtime_error(""RawDataConverter is not yet able to process VirginRaw Data"");
    break;
  case ProcessedRaw:
    throw std::runtime_error(""RawDataConverter is not yet able to process ProcessedRaw Data"");
    break;
  default:
    throw std::runtime_error(""Did not find valid Module or Instance label"");
  }


  // Push Container into the Tree
  theOutputTree->Fill();

  return;
}


///
///
///
void RawDataConverter::endJob()
{
  theOutputFile->Write();
  theOutputFile->Close();
}


///
/// set all strips to zero
///
void RawDataConverter::ClearData( void ) {

  // Assign a vector filled with zeros to all module entries
  // The vector is const static to increase performance
  // Even more performant would be to have a complete data object that is filled with zero
  
  // Empty object to be assigned to all modules
  static const std::vector<float> zero_buffer(512,0);

  // loop helper and its variables
  LASGlobalLoop loop;
  int det, ring, beam, disk, pos;

  // loop TEC+- (internal)
  det = 0; ring = 0; beam = 0; disk = 0;
  do {
    theData.GetTECEntry( det, ring, beam, disk ) = zero_buffer;
  } while( loop.TECLoop( det, ring, beam, disk ) );
  
  // loop TIB/TOB
  det = 2; beam = 0; pos = 0; // <- set det = 2 (TIB)
  do {
    theData.GetTIBTOBEntry( det, beam, pos ) = zero_buffer;
  } while( loop.TIBTOBLoop( det, beam, pos ) );

  // loop TEC (AT)
  det = 0; beam = 0; disk = 0;
  do {
    theData.GetTEC2TECEntry( det, beam, disk ) = zero_buffer;
  } while( loop.TEC2TECLoop( det, beam, disk ) );
  
}


///
/// all the detector ids for the LAS modules hard-coded (this should be changed...)
///
void RawDataConverter::fillDetectorId( void ) {
  
  // TEC+
  detectorId.SetTECEntry( 0, 0, 0, 0, 470307208 );
  detectorId.SetTECEntry( 0, 0, 0, 1, 470323592 );
  detectorId.SetTECEntry( 0, 0, 0, 2, 470339976 );
  detectorId.SetTECEntry( 0, 0, 0, 3, 470356360 );
  detectorId.SetTECEntry( 0, 0, 0, 4, 470372744 );
  detectorId.SetTECEntry( 0, 0, 0, 5, 470389128 );
  detectorId.SetTECEntry( 0, 0, 0, 6, 470405512 );
  detectorId.SetTECEntry( 0, 0, 0, 7, 470421896 );
  detectorId.SetTECEntry( 0, 0, 0, 8, 470438280 );
  detectorId.SetTECEntry( 0, 0, 1, 0, 470307464 );
  detectorId.SetTECEntry( 0, 0, 1, 1, 470323848 );
  detectorId.SetTECEntry( 0, 0, 1, 2, 470340232 );
  detectorId.SetTECEntry( 0, 0, 1, 3, 470356616 );
  detectorId.SetTECEntry( 0, 0, 1, 4, 470373000 );
  detectorId.SetTECEntry( 0, 0, 1, 5, 470389384 );
  detectorId.SetTECEntry( 0, 0, 1, 6, 470405768 );
  detectorId.SetTECEntry( 0, 0, 1, 7, 470422152 );
  detectorId.SetTECEntry( 0, 0, 1, 8, 470438536 );
  detectorId.SetTECEntry( 0, 0, 2, 0, 470307720 );
  detectorId.SetTECEntry( 0, 0, 2, 1, 470324104 );
  detectorId.SetTECEntry( 0, 0, 2, 2, 470340488 );
  detectorId.SetTECEntry( 0, 0, 2, 3, 470356872 );
  detectorId.SetTECEntry( 0, 0, 2, 4, 470373256 );
  detectorId.SetTECEntry( 0, 0, 2, 5, 470389640 );
  detectorId.SetTECEntry( 0, 0, 2, 6, 470406024 );
  detectorId.SetTECEntry( 0, 0, 2, 7, 470422408 );
  detectorId.SetTECEntry( 0, 0, 2, 8, 470438792 );
  detectorId.SetTECEntry( 0, 0, 3, 0, 470307976 );
  detectorId.SetTECEntry( 0, 0, 3, 1, 470324360 );
  detectorId.SetTECEntry( 0, 0, 3, 2, 470340744 );
  detectorId.SetTECEntry( 0, 0, 3, 3, 470357128 );
  detectorId.SetTECEntry( 0, 0, 3, 4, 470373512 );
  detectorId.SetTECEntry( 0, 0, 3, 5, 470389896 );
  detectorId.SetTECEntry( 0, 0, 3, 6, 470406280 );
  detectorId.SetTECEntry( 0, 0, 3, 7, 470422664 );
  detectorId.SetTECEntry( 0, 0, 3, 8, 470439048 );
  detectorId.SetTECEntry( 0, 0, 4, 0, 470308232 );
  detectorId.SetTECEntry( 0, 0, 4, 1, 470324616 );
  detectorId.SetTECEntry( 0, 0, 4, 2, 470341000 );
  detectorId.SetTECEntry( 0, 0, 4, 3, 470357384 );
  detectorId.SetTECEntry( 0, 0, 4, 4, 470373768 );
  detectorId.SetTECEntry( 0, 0, 4, 5, 470390152 );
  detectorId.SetTECEntry( 0, 0, 4, 6, 470406536 );
  detectorId.SetTECEntry( 0, 0, 4, 7, 470422920 );
  detectorId.SetTECEntry( 0, 0, 4, 8, 470439304 );
  detectorId.SetTECEntry( 0, 0, 5, 0, 470308488 );
  detectorId.SetTECEntry( 0, 0, 5, 1, 470324872 );
  detectorId.SetTECEntry( 0, 0, 5, 2, 470341256 );
  detectorId.SetTECEntry( 0, 0, 5, 3, 470357640 );
  detectorId.SetTECEntry( 0, 0, 5, 4, 470374024 );
  detectorId.SetTECEntry( 0, 0, 5, 5, 470390408 );
  detectorId.SetTECEntry( 0, 0, 5, 6, 470406792 );
  detectorId.SetTECEntry( 0, 0, 5, 7, 470423176 );
  detectorId.SetTECEntry( 0, 0, 5, 8, 470439560 );
  detectorId.SetTECEntry( 0, 0, 6, 0, 470308744 );
  detectorId.SetTECEntry( 0, 0, 6, 1, 470325128 );
  detectorId.SetTECEntry( 0, 0, 6, 2, 470341512 );
  detectorId.SetTECEntry( 0, 0, 6, 3, 470357896 );
  detectorId.SetTECEntry( 0, 0, 6, 4, 470374280 );
  detectorId.SetTECEntry( 0, 0, 6, 5, 470390664 );
  detectorId.SetTECEntry( 0, 0, 6, 6, 470407048 );
  detectorId.SetTECEntry( 0, 0, 6, 7, 470423432 );
  detectorId.SetTECEntry( 0, 0, 6, 8, 470439816 );
  detectorId.SetTECEntry( 0, 0, 7, 0, 470309000 );
  detectorId.SetTECEntry( 0, 0, 7, 1, 470325384 );
  detectorId.SetTECEntry( 0, 0, 7, 2, 470341768 );
  detectorId.SetTECEntry( 0, 0, 7, 3, 470358152 );
  detectorId.SetTECEntry( 0, 0, 7, 4, 470374536 );
  detectorId.SetTECEntry( 0, 0, 7, 5, 470390920 );
  detectorId.SetTECEntry( 0, 0, 7, 6, 470407304 );
  detectorId.SetTECEntry( 0, 0, 7, 7, 470423688 );
  detectorId.SetTECEntry( 0, 0, 7, 8, 470440072 );
  detectorId.SetTECEntry( 0, 1, 0, 0, 470307272 );
  detectorId.SetTECEntry( 0, 1, 0, 1, 470323656 );
  detectorId.SetTECEntry( 0, 1, 0, 2, 470340040 );
  detectorId.SetTECEntry( 0, 1, 0, 3, 470356424 );
  detectorId.SetTECEntry( 0, 1, 0, 4, 470372808 );
  detectorId.SetTECEntry( 0, 1, 0, 5, 470389192 );
  detectorId.SetTECEntry( 0, 1, 0, 6, 470405576 );
  detectorId.SetTECEntry( 0, 1, 0, 7, 470421960 );
  detectorId.SetTECEntry( 0, 1, 0, 8, 470438344 );
  detectorId.SetTECEntry( 0, 1, 1, 0, 470307528 );
  detectorId.SetTECEntry( 0, 1, 1, 1, 470323912 );
  detectorId.SetTECEntry( 0, 1, 1, 2, 470340296 );
  detectorId.SetTECEntry( 0, 1, 1, 3, 470356680 );
  detectorId.SetTECEntry( 0, 1, 1, 4, 470373064 );
  detectorId.SetTECEntry( 0, 1, 1, 5, 470389448 );
  detectorId.SetTECEntry( 0, 1, 1, 6, 470405832 );
  detectorId.SetTECEntry( 0, 1, 1, 7, 470422216 );
  detectorId.SetTECEntry( 0, 1, 1, 8, 470438600 );
  detectorId.SetTECEntry( 0, 1, 2, 0, 470307784 );
  detectorId.SetTECEntry( 0, 1, 2, 1, 470324168 );
  detectorId.SetTECEntry( 0, 1, 2, 2, 470340552 );
  detectorId.SetTECEntry( 0, 1, 2, 3, 470356936 );
  detectorId.SetTECEntry( 0, 1, 2, 4, 470373320 );
  detectorId.SetTECEntry( 0, 1, 2, 5, 470389704 );
  detectorId.SetTECEntry( 0, 1, 2, 6, 470406088 );
  detectorId.SetTECEntry( 0, 1, 2, 7, 470422472 );
  detectorId.SetTECEntry( 0, 1, 2, 8, 470438856 );
  detectorId.SetTECEntry( 0, 1, 3, 0, 470308040 );
  detectorId.SetTECEntry( 0, 1, 3, 1, 470324424 );
  detectorId.SetTECEntry( 0, 1, 3, 2, 470340808 );
  detectorId.SetTECEntry( 0, 1, 3, 3, 470357192 );
  detectorId.SetTECEntry( 0, 1, 3, 4, 470373576 );
  detectorId.SetTECEntry( 0, 1, 3, 5, 470389960 );
  detectorId.SetTECEntry( 0, 1, 3, 6, 470406344 );
  detectorId.SetTECEntry( 0, 1, 3, 7, 470422728 );
  detectorId.SetTECEntry( 0, 1, 3, 8, 470439112 );
  detectorId.SetTECEntry( 0, 1, 4, 0, 470308296 );
  detectorId.SetTECEntry( 0, 1, 4, 1, 470324680 );
  detectorId.SetTECEntry( 0, 1, 4, 2, 470341064 );
  detectorId.SetTECEntry( 0, 1, 4, 3, 470357448 );
  detectorId.SetTECEntry( 0, 1, 4, 4, 470373832 );
  detectorId.SetTECEntry( 0, 1, 4, 5, 470390216 );
  detectorId.SetTECEntry( 0, 1, 4, 6, 470406600 );
  detectorId.SetTECEntry( 0, 1, 4, 7, 470422984 );
  detectorId.SetTECEntry( 0, 1, 4, 8, 470439368 );
  detectorId.SetTECEntry( 0, 1, 5, 0, 470308552 );
  detectorId.SetTECEntry( 0, 1, 5, 1, 470324936 );
  detectorId.SetTECEntry( 0, 1, 5, 2, 470341320 );
  detectorId.SetTECEntry( 0, 1, 5, 3, 470357704 );
  detectorId.SetTECEntry( 0, 1, 5, 4, 470374088 );
  detectorId.SetTECEntry( 0, 1, 5, 5, 470390472 );
  detectorId.SetTECEntry( 0, 1, 5, 6, 470406856 );
  detectorId.SetTECEntry( 0, 1, 5, 7, 470423240 );
  detectorId.SetTECEntry( 0, 1, 5, 8, 470439624 );
  detectorId.SetTECEntry( 0, 1, 6, 0, 470308808 );
  detectorId.SetTECEntry( 0, 1, 6, 1, 470325192 );
  detectorId.SetTECEntry( 0, 1, 6, 2, 470341576 );
  detectorId.SetTECEntry( 0, 1, 6, 3, 470357960 );
  detectorId.SetTECEntry( 0, 1, 6, 4, 470374344 );
  detectorId.SetTECEntry( 0, 1, 6, 5, 470390728 );
  detectorId.SetTECEntry( 0, 1, 6, 6, 470407112 );
  detectorId.SetTECEntry( 0, 1, 6, 7, 470423496 );
  detectorId.SetTECEntry( 0, 1, 6, 8, 470439880 );
  detectorId.SetTECEntry( 0, 1, 7, 0, 470309064 );
  detectorId.SetTECEntry( 0, 1, 7, 1, 470325448 );
  detectorId.SetTECEntry( 0, 1, 7, 2, 470341832 );
  detectorId.SetTECEntry( 0, 1, 7, 3, 470358216 );
  detectorId.SetTECEntry( 0, 1, 7, 4, 470374600 );
  detectorId.SetTECEntry( 0, 1, 7, 5, 470390984 );
  detectorId.SetTECEntry( 0, 1, 7, 6, 470407368 );
  detectorId.SetTECEntry( 0, 1, 7, 7, 470423752 );
  detectorId.SetTECEntry( 0, 1, 7, 8, 470440136 );

  // TEC-
  detectorId.SetTECEntry( 1, 0, 0, 0, 470045064 );
  detectorId.SetTECEntry( 1, 0, 0, 1, 470061448 );
  detectorId.SetTECEntry( 1, 0, 0, 2, 470077832 );
  detectorId.SetTECEntry( 1, 0, 0, 3, 470094216 );
  detectorId.SetTECEntry( 1, 0, 0, 4, 470110600 );
  detectorId.SetTECEntry( 1, 0, 0, 5, 470126984 );
  detectorId.SetTECEntry( 1, 0, 0, 6, 470143368 );
  detectorId.SetTECEntry( 1, 0, 0, 7, 470159752 );
  detectorId.SetTECEntry( 1, 0, 0, 8, 470176136 );
  detectorId.SetTECEntry( 1, 0, 1, 0, 470045320 );
  detectorId.SetTECEntry( 1, 0, 1, 1, 470061704 );
  detectorId.SetTECEntry( 1, 0, 1, 2, 470078088 );
  detectorId.SetTECEntry( 1, 0, 1, 3, 470094472 );
  detectorId.SetTECEntry( 1, 0, 1, 4, 470110856 );
  detectorId.SetTECEntry( 1, 0, 1, 5, 470127240 );
  detectorId.SetTECEntry( 1, 0, 1, 6, 470143624 );
  detectorId.SetTECEntry( 1, 0, 1, 7, 470160008 );
  detectorId.SetTECEntry( 1, 0, 1, 8, 470176392 );
  detectorId.SetTECEntry( 1, 0, 2, 0, 470045576 );
  detectorId.SetTECEntry( 1, 0, 2, 1, 470061960 );
  detectorId.SetTECEntry( 1, 0, 2, 2, 470078344 );
  detectorId.SetTECEntry( 1, 0, 2, 3, 470094728 );
  detectorId.SetTECEntry( 1, 0, 2, 4, 470111112 );
  detectorId.SetTECEntry( 1, 0, 2, 5, 470127496 );
  detectorId.SetTECEntry( 1, 0, 2, 6, 470143880 );
  detectorId.SetTECEntry( 1, 0, 2, 7, 470160264 );
  detectorId.SetTECEntry( 1, 0, 2, 8, 470176648 );
  detectorId.SetTECEntry( 1, 0, 3, 0, 470045832 );
  detectorId.SetTECEntry( 1, 0, 3, 1, 470062216 );
  detectorId.SetTECEntry( 1, 0, 3, 2, 470078600 );
  detectorId.SetTECEntry( 1, 0, 3, 3, 470094984 );
  detectorId.SetTECEntry( 1, 0, 3, 4, 470111368 );
  detectorId.SetTECEntry( 1, 0, 3, 5, 470127752 );
  detectorId.SetTECEntry( 1, 0, 3, 6, 470144136 );
  detectorId.SetTECEntry( 1, 0, 3, 7, 470160520 );
  detectorId.SetTECEntry( 1, 0, 3, 8, 470176904 );
  detectorId.SetTECEntry( 1, 0, 4, 0, 470046088 );
  detectorId.SetTECEntry( 1, 0, 4, 1, 470062472 );
  detectorId.SetTECEntry( 1, 0, 4, 2, 470078856 );
  detectorId.SetTECEntry( 1, 0, 4, 3, 470095240 );
  detectorId.SetTECEntry( 1, 0, 4, 4, 470111624 );
  detectorId.SetTECEntry( 1, 0, 4, 5, 470128008 );
  detectorId.SetTECEntry( 1, 0, 4, 6, 470144392 );
  detectorId.SetTECEntry( 1, 0, 4, 7, 470160776 );
  detectorId.SetTECEntry( 1, 0, 4, 8, 470177160 );
  detectorId.SetTECEntry( 1, 0, 5, 0, 470046344 );
  detectorId.SetTECEntry( 1, 0, 5, 1, 470062728 );
  detectorId.SetTECEntry( 1, 0, 5, 2, 470079112 );
  detectorId.SetTECEntry( 1, 0, 5, 3, 470095496 );
  detectorId.SetTECEntry( 1, 0, 5, 4, 470111880 );
  detectorId.SetTECEntry( 1, 0, 5, 5, 470128264 );
  detectorId.SetTECEntry( 1, 0, 5, 6, 470144648 );
  detectorId.SetTECEntry( 1, 0, 5, 7, 470161032 );
  detectorId.SetTECEntry( 1, 0, 5, 8, 470177416 );
  detectorId.SetTECEntry( 1, 0, 6, 0, 470046600 );
  detectorId.SetTECEntry( 1, 0, 6, 1, 470062984 );
  detectorId.SetTECEntry( 1, 0, 6, 2, 470079368 );
  detectorId.SetTECEntry( 1, 0, 6, 3, 470095752 );
  detectorId.SetTECEntry( 1, 0, 6, 4, 470112136 );
  detectorId.SetTECEntry( 1, 0, 6, 5, 470128520 );
  detectorId.SetTECEntry( 1, 0, 6, 6, 470144904 );
  detectorId.SetTECEntry( 1, 0, 6, 7, 470161288 );
  detectorId.SetTECEntry( 1, 0, 6, 8, 470177672 );
  detectorId.SetTECEntry( 1, 0, 7, 0, 470046856 );
  detectorId.SetTECEntry( 1, 0, 7, 1, 470063240 );
  detectorId.SetTECEntry( 1, 0, 7, 2, 470079624 );
  detectorId.SetTECEntry( 1, 0, 7, 3, 470096008 );
  detectorId.SetTECEntry( 1, 0, 7, 4, 470112392 );
  detectorId.SetTECEntry( 1, 0, 7, 5, 470128776 );
  detectorId.SetTECEntry( 1, 0, 7, 6, 470145160 );
  detectorId.SetTECEntry( 1, 0, 7, 7, 470161544 );
  detectorId.SetTECEntry( 1, 0, 7, 8, 470177928 );
  detectorId.SetTECEntry( 1, 1, 0, 0, 470045128 );
  detectorId.SetTECEntry( 1, 1, 0, 1, 470061512 );
  detectorId.SetTECEntry( 1, 1, 0, 2, 470077896 );
  detectorId.SetTECEntry( 1, 1, 0, 3, 470094280 );
  detectorId.SetTECEntry( 1, 1, 0, 4, 470110664 );
  detectorId.SetTECEntry( 1, 1, 0, 5, 470127048 );
  detectorId.SetTECEntry( 1, 1, 0, 6, 470143432 );
  detectorId.SetTECEntry( 1, 1, 0, 7, 470159816 );
  detectorId.SetTECEntry( 1, 1, 0, 8, 470176200 );
  detectorId.SetTECEntry( 1, 1, 1, 0, 470045384 );
  detectorId.SetTECEntry( 1, 1, 1, 1, 470061768 );
  detectorId.SetTECEntry( 1, 1, 1, 2, 470078152 );
  detectorId.SetTECEntry( 1, 1, 1, 3, 470094536 );
  detectorId.SetTECEntry( 1, 1, 1, 4, 470110920 );
  detectorId.SetTECEntry( 1, 1, 1, 5, 470127304 );
  detectorId.SetTECEntry( 1, 1, 1, 6, 470143688 );
  detectorId.SetTECEntry( 1, 1, 1, 7, 470160072 );
  detectorId.SetTECEntry( 1, 1, 1, 8, 470176456 );
  detectorId.SetTECEntry( 1, 1, 2, 0, 470045640 );
  detectorId.SetTECEntry( 1, 1, 2, 1, 470062024 );
  detectorId.SetTECEntry( 1, 1, 2, 2, 470078408 );
  detectorId.SetTECEntry( 1, 1, 2, 3, 470094792 );
  detectorId.SetTECEntry( 1, 1, 2, 4, 470111176 );
  detectorId.SetTECEntry( 1, 1, 2, 5, 470127560 );
  detectorId.SetTECEntry( 1, 1, 2, 6, 470143944 );
  detectorId.SetTECEntry( 1, 1, 2, 7, 470160328 );
  detectorId.SetTECEntry( 1, 1, 2, 8, 470176712 );
  detectorId.SetTECEntry( 1, 1, 3, 0, 470045896 );
  detectorId.SetTECEntry( 1, 1, 3, 1, 470062280 );
  detectorId.SetTECEntry( 1, 1, 3, 2, 470078664 );
  detectorId.SetTECEntry( 1, 1, 3, 3, 470095048 );
  detectorId.SetTECEntry( 1, 1, 3, 4, 470111432 );
  detectorId.SetTECEntry( 1, 1, 3, 5, 470127816 );
  detectorId.SetTECEntry( 1, 1, 3, 6, 470144200 );
  detectorId.SetTECEntry( 1, 1, 3, 7, 470160584 );
  detectorId.SetTECEntry( 1, 1, 3, 8, 470176968 );
  detectorId.SetTECEntry( 1, 1, 4, 0, 470046152 );
  detectorId.SetTECEntry( 1, 1, 4, 1, 470062536 );
  detectorId.SetTECEntry( 1, 1, 4, 2, 470078920 );
  detectorId.SetTECEntry( 1, 1, 4, 3, 470095304 );
  detectorId.SetTECEntry( 1, 1, 4, 4, 470111688 );
  detectorId.SetTECEntry( 1, 1, 4, 5, 470128072 );
  detectorId.SetTECEntry( 1, 1, 4, 6, 470144456 );
  detectorId.SetTECEntry( 1, 1, 4, 7, 470160840 );
  detectorId.SetTECEntry( 1, 1, 4, 8, 470177224 );
  detectorId.SetTECEntry( 1, 1, 5, 0, 470046408 );
  detectorId.SetTECEntry( 1, 1, 5, 1, 470062792 );
  detectorId.SetTECEntry( 1, 1, 5, 2, 470079176 );
  detectorId.SetTECEntry( 1, 1, 5, 3, 470095560 );
  detectorId.SetTECEntry( 1, 1, 5, 4, 470111944 );
  detectorId.SetTECEntry( 1, 1, 5, 5, 470128328 );
  detectorId.SetTECEntry( 1, 1, 5, 6, 470144712 );
  detectorId.SetTECEntry( 1, 1, 5, 7, 470161096 );
  detectorId.SetTECEntry( 1, 1, 5, 8, 470177480 );
  detectorId.SetTECEntry( 1, 1, 6, 0, 470046664 );
  detectorId.SetTECEntry( 1, 1, 6, 1, 470063048 );
  detectorId.SetTECEntry( 1, 1, 6, 2, 470079432 );
  detectorId.SetTECEntry( 1, 1, 6, 3, 470095816 );
  detectorId.SetTECEntry( 1, 1, 6, 4, 470112200 );
  detectorId.SetTECEntry( 1, 1, 6, 5, 470128584 );
  detectorId.SetTECEntry( 1, 1, 6, 6, 470144968 );
  detectorId.SetTECEntry( 1, 1, 6, 7, 470161352 );
  detectorId.SetTECEntry( 1, 1, 6, 8, 470177736 );
  detectorId.SetTECEntry( 1, 1, 7, 0, 470046920 );
  detectorId.SetTECEntry( 1, 1, 7, 1, 470063304 );
  detectorId.SetTECEntry( 1, 1, 7, 2, 470079688 );
  detectorId.SetTECEntry( 1, 1, 7, 3, 470096072 );
  detectorId.SetTECEntry( 1, 1, 7, 4, 470112456 );
  detectorId.SetTECEntry( 1, 1, 7, 5, 470128840 );
  detectorId.SetTECEntry( 1, 1, 7, 6, 470145224 );
  detectorId.SetTECEntry( 1, 1, 7, 7, 470161608 );
  detectorId.SetTECEntry( 1, 1, 7, 8, 470177992 );

  // TIB
  detectorId.SetTIBTOBEntry( 2, 0, 0, 369174604 );
  detectorId.SetTIBTOBEntry( 2, 0, 1, 369174600 );
  detectorId.SetTIBTOBEntry( 2, 0, 2, 369174596 );
  detectorId.SetTIBTOBEntry( 2, 0, 3, 369170500 );
  detectorId.SetTIBTOBEntry( 2, 0, 4, 369170504 );
  detectorId.SetTIBTOBEntry( 2, 0, 5, 369170508 );
  detectorId.SetTIBTOBEntry( 2, 1, 0, 369174732 );
  detectorId.SetTIBTOBEntry( 2, 1, 1, 369174728 );
  detectorId.SetTIBTOBEntry( 2, 1, 2, 369174724 );
  detectorId.SetTIBTOBEntry( 2, 1, 3, 369170628 );
  detectorId.SetTIBTOBEntry( 2, 1, 4, 369170632 );
  detectorId.SetTIBTOBEntry( 2, 1, 5, 369170636 );
  detectorId.SetTIBTOBEntry( 2, 2, 0, 369174812 );
  detectorId.SetTIBTOBEntry( 2, 2, 1, 369174808 );
  detectorId.SetTIBTOBEntry( 2, 2, 2, 369174804 );
  detectorId.SetTIBTOBEntry( 2, 2, 3, 369170708 );
  detectorId.SetTIBTOBEntry( 2, 2, 4, 369170712 );
  detectorId.SetTIBTOBEntry( 2, 2, 5, 369170716 );
  detectorId.SetTIBTOBEntry( 2, 3, 0, 369174940 );
  detectorId.SetTIBTOBEntry( 2, 3, 1, 369174936 );
  detectorId.SetTIBTOBEntry( 2, 3, 2, 369174932 );
  detectorId.SetTIBTOBEntry( 2, 3, 3, 369170836 );
  detectorId.SetTIBTOBEntry( 2, 3, 4, 369170840 );
  detectorId.SetTIBTOBEntry( 2, 3, 5, 369170844 );
  detectorId.SetTIBTOBEntry( 2, 4, 0, 369175068 );
  detectorId.SetTIBTOBEntry( 2, 4, 1, 369175064 );
  detectorId.SetTIBTOBEntry( 2, 4, 2, 369175060 );
  detectorId.SetTIBTOBEntry( 2, 4, 3, 369170964 );
  detectorId.SetTIBTOBEntry( 2, 4, 4, 369170968 );
  detectorId.SetTIBTOBEntry( 2, 4, 5, 369170972 );
  detectorId.SetTIBTOBEntry( 2, 5, 0, 369175164 );
  detectorId.SetTIBTOBEntry( 2, 5, 1, 369175160 );
  detectorId.SetTIBTOBEntry( 2, 5, 2, 369175156 );
  detectorId.SetTIBTOBEntry( 2, 5, 3, 369171060 );
  detectorId.SetTIBTOBEntry( 2, 5, 4, 369171064 );
  detectorId.SetTIBTOBEntry( 2, 5, 5, 369171068 );
  detectorId.SetTIBTOBEntry( 2, 6, 0, 369175292 );
  detectorId.SetTIBTOBEntry( 2, 6, 1, 369175288 );
  detectorId.SetTIBTOBEntry( 2, 6, 2, 369175284 );
  detectorId.SetTIBTOBEntry( 2, 6, 3, 369171188 );
  detectorId.SetTIBTOBEntry( 2, 6, 4, 369171192 );
  detectorId.SetTIBTOBEntry( 2, 6, 5, 369171196 );
  detectorId.SetTIBTOBEntry( 2, 7, 0, 369175372 );
  detectorId.SetTIBTOBEntry( 2, 7, 1, 369175368 );
  detectorId.SetTIBTOBEntry( 2, 7, 2, 369175364 );
  detectorId.SetTIBTOBEntry( 2, 7, 3, 369171268 );
  detectorId.SetTIBTOBEntry( 2, 7, 4, 369171272 );
  detectorId.SetTIBTOBEntry( 2, 7, 5, 369171276 );

  // TOB
  detectorId.SetTIBTOBEntry( 3, 0, 0, 436232314 );
  detectorId.SetTIBTOBEntry( 3, 0, 1, 436232306 );
  detectorId.SetTIBTOBEntry( 3, 0, 2, 436232298 );
  detectorId.SetTIBTOBEntry( 3, 0, 3, 436228198 );
  detectorId.SetTIBTOBEntry( 3, 0, 4, 436228206 );
  detectorId.SetTIBTOBEntry( 3, 0, 5, 436228214 );
  detectorId.SetTIBTOBEntry( 3, 1, 0, 436232506 );
  detectorId.SetTIBTOBEntry( 3, 1, 1, 436232498 );
  detectorId.SetTIBTOBEntry( 3, 1, 2, 436232490 );
  detectorId.SetTIBTOBEntry( 3, 1, 3, 436228390 );
  detectorId.SetTIBTOBEntry( 3, 1, 4, 436228398 );
  detectorId.SetTIBTOBEntry( 3, 1, 5, 436228406 );
  detectorId.SetTIBTOBEntry( 3, 2, 0, 436232634 );
  detectorId.SetTIBTOBEntry( 3, 2, 1, 436232626 );
  detectorId.SetTIBTOBEntry( 3, 2, 2, 436232618 );
  detectorId.SetTIBTOBEntry( 3, 2, 3, 436228518 );
  detectorId.SetTIBTOBEntry( 3, 2, 4, 436228526 );
  detectorId.SetTIBTOBEntry( 3, 2, 5, 436228534 );
  detectorId.SetTIBTOBEntry( 3, 3, 0, 436232826 );
  detectorId.SetTIBTOBEntry( 3, 3, 1, 436232818 );
  detectorId.SetTIBTOBEntry( 3, 3, 2, 436232810 );
  detectorId.SetTIBTOBEntry( 3, 3, 3, 436228710 );
  detectorId.SetTIBTOBEntry( 3, 3, 4, 436228718 );
  detectorId.SetTIBTOBEntry( 3, 3, 5, 436228726 );
  detectorId.SetTIBTOBEntry( 3, 4, 0, 436233018 );
  detectorId.SetTIBTOBEntry( 3, 4, 1, 436233010 );
  detectorId.SetTIBTOBEntry( 3, 4, 2, 436233002 );
  detectorId.SetTIBTOBEntry( 3, 4, 3, 436228902 );
  detectorId.SetTIBTOBEntry( 3, 4, 4, 436228910 );
  detectorId.SetTIBTOBEntry( 3, 4, 5, 436228918 );
  detectorId.SetTIBTOBEntry( 3, 5, 0, 436233146 );
  detectorId.SetTIBTOBEntry( 3, 5, 1, 436233138 );
  detectorId.SetTIBTOBEntry( 3, 5, 2, 436233130 );
  detectorId.SetTIBTOBEntry( 3, 5, 3, 436229030 );
  detectorId.SetTIBTOBEntry( 3, 5, 4, 436229038 );
  detectorId.SetTIBTOBEntry( 3, 5, 5, 436229046 );
  detectorId.SetTIBTOBEntry( 3, 6, 0, 436233338 );
  detectorId.SetTIBTOBEntry( 3, 6, 1, 436233330 );
  detectorId.SetTIBTOBEntry( 3, 6, 2, 436233322 );
  detectorId.SetTIBTOBEntry( 3, 6, 3, 436229222 );
  detectorId.SetTIBTOBEntry( 3, 6, 4, 436229230 );
  detectorId.SetTIBTOBEntry( 3, 6, 5, 436229238 );
  detectorId.SetTIBTOBEntry( 3, 7, 0, 436233466 );
  detectorId.SetTIBTOBEntry( 3, 7, 1, 436233458 );
  detectorId.SetTIBTOBEntry( 3, 7, 2, 436233450 );
  detectorId.SetTIBTOBEntry( 3, 7, 3, 436229350 );
  detectorId.SetTIBTOBEntry( 3, 7, 4, 436229358 );
  detectorId.SetTIBTOBEntry( 3, 7, 5, 436229366 );

  // TEC+ AT
  detectorId.SetTEC2TECEntry( 0, 0, 0, 470307208 );
  detectorId.SetTEC2TECEntry( 0, 0, 1, 470323592 );
  detectorId.SetTEC2TECEntry( 0, 0, 2, 470339976 );
  detectorId.SetTEC2TECEntry( 0, 0, 3, 470356360 );
  detectorId.SetTEC2TECEntry( 0, 0, 4, 470372744 );
  detectorId.SetTEC2TECEntry( 0, 1, 0, 470307468 );
  detectorId.SetTEC2TECEntry( 0, 1, 1, 470323852 );
  detectorId.SetTEC2TECEntry( 0, 1, 2, 470340236 );
  detectorId.SetTEC2TECEntry( 0, 1, 3, 470356620 );
  detectorId.SetTEC2TECEntry( 0, 1, 4, 470373004 );
  detectorId.SetTEC2TECEntry( 0, 2, 0, 470307716 );
  detectorId.SetTEC2TECEntry( 0, 2, 1, 470324100 );
  detectorId.SetTEC2TECEntry( 0, 2, 2, 470340484 );
  detectorId.SetTEC2TECEntry( 0, 2, 3, 470356868 );
  detectorId.SetTEC2TECEntry( 0, 2, 4, 470373252 );
  detectorId.SetTEC2TECEntry( 0, 3, 0, 470307976 );
  detectorId.SetTEC2TECEntry( 0, 3, 1, 470324360 );
  detectorId.SetTEC2TECEntry( 0, 3, 2, 470340744 );
  detectorId.SetTEC2TECEntry( 0, 3, 3, 470357128 );
  detectorId.SetTEC2TECEntry( 0, 3, 4, 470373512 );
  detectorId.SetTEC2TECEntry( 0, 4, 0, 470308236 );
  detectorId.SetTEC2TECEntry( 0, 4, 1, 470324620 );
  detectorId.SetTEC2TECEntry( 0, 4, 2, 470341004 );
  detectorId.SetTEC2TECEntry( 0, 4, 3, 470357388 );
  detectorId.SetTEC2TECEntry( 0, 4, 4, 470373772 );
  detectorId.SetTEC2TECEntry( 0, 5, 0, 470308488 );
  detectorId.SetTEC2TECEntry( 0, 5, 1, 470324872 );
  detectorId.SetTEC2TECEntry( 0, 5, 2, 470341256 );
  detectorId.SetTEC2TECEntry( 0, 5, 3, 470357640 );
  detectorId.SetTEC2TECEntry( 0, 5, 4, 470374024 );
  detectorId.SetTEC2TECEntry( 0, 6, 0, 470308748 );
  detectorId.SetTEC2TECEntry( 0, 6, 1, 470325132 );
  detectorId.SetTEC2TECEntry( 0, 6, 2, 470341516 );
  detectorId.SetTEC2TECEntry( 0, 6, 3, 470357900 );
  detectorId.SetTEC2TECEntry( 0, 6, 4, 470374284 );
  detectorId.SetTEC2TECEntry( 0, 7, 0, 470308996 );
  detectorId.SetTEC2TECEntry( 0, 7, 1, 470325380 );
  detectorId.SetTEC2TECEntry( 0, 7, 2, 470341764 );
  detectorId.SetTEC2TECEntry( 0, 7, 3, 470358148 );
  detectorId.SetTEC2TECEntry( 0, 7, 4, 470374532 );

  // TEC- AT
  detectorId.SetTEC2TECEntry( 1, 0, 0, 470045064 );
  detectorId.SetTEC2TECEntry( 1, 0, 1, 470061448 );
  detectorId.SetTEC2TECEntry( 1, 0, 2, 470077832 );
  detectorId.SetTEC2TECEntry( 1, 0, 3, 470094216 );
  detectorId.SetTEC2TECEntry( 1, 0, 4, 470110600 );
  detectorId.SetTEC2TECEntry( 1, 1, 0, 470045316 );
  detectorId.SetTEC2TECEntry( 1, 1, 1, 470061700 );
  detectorId.SetTEC2TECEntry( 1, 1, 2, 470078084 );
  detectorId.SetTEC2TECEntry( 1, 1, 3, 470094468 );
  detectorId.SetTEC2TECEntry( 1, 1, 4, 470110852 );
  detectorId.SetTEC2TECEntry( 1, 2, 0, 470045580 );
  detectorId.SetTEC2TECEntry( 1, 2, 1, 470061964 );
  detectorId.SetTEC2TECEntry( 1, 2, 2, 470078348 );
  detectorId.SetTEC2TECEntry( 1, 2, 3, 470094732 );
  detectorId.SetTEC2TECEntry( 1, 2, 4, 470111116 );
  detectorId.SetTEC2TECEntry( 1, 3, 0, 470045832 );
  detectorId.SetTEC2TECEntry( 1, 3, 1, 470062216 );
  detectorId.SetTEC2TECEntry( 1, 3, 2, 470078600 );
  detectorId.SetTEC2TECEntry( 1, 3, 3, 470094984 );
  detectorId.SetTEC2TECEntry( 1, 3, 4, 470111368 );
  detectorId.SetTEC2TECEntry( 1, 4, 0, 470046084 );
  detectorId.SetTEC2TECEntry( 1, 4, 1, 470062468 );
  detectorId.SetTEC2TECEntry( 1, 4, 2, 470078852 );
  detectorId.SetTEC2TECEntry( 1, 4, 3, 470095236 );
  detectorId.SetTEC2TECEntry( 1, 4, 4, 470111620 );
  detectorId.SetTEC2TECEntry( 1, 5, 0, 470046344 );
  detectorId.SetTEC2TECEntry( 1, 5, 1, 470062728 );
  detectorId.SetTEC2TECEntry( 1, 5, 2, 470079112 );
  detectorId.SetTEC2TECEntry( 1, 5, 3, 470095496 );
  detectorId.SetTEC2TECEntry( 1, 5, 4, 470111880 );
  detectorId.SetTEC2TECEntry( 1, 6, 0, 470046596 );
  detectorId.SetTEC2TECEntry( 1, 6, 1, 470062980 );
  detectorId.SetTEC2TECEntry( 1, 6, 2, 470079364 );
  detectorId.SetTEC2TECEntry( 1, 6, 3, 470095748 );
  detectorId.SetTEC2TECEntry( 1, 6, 4, 470112132 );
  detectorId.SetTEC2TECEntry( 1, 7, 0, 470046860 );
  detectorId.SetTEC2TECEntry( 1, 7, 1, 470063244 );
  detectorId.SetTEC2TECEntry( 1, 7, 2, 470079628 );
  detectorId.SetTEC2TECEntry( 1, 7, 3, 470096012 );
  detectorId.SetTEC2TECEntry( 1, 7, 4, 470112396 );

}

//define this as a plug-in
DEFINE_FWK_MODULE(RawDataConverter);

",16374,True,5071.43235114199,median
"[[install-config-syncing-groups-with-ldap]]
= Syncing Groups With LDAP
{product-author}
{product-version}
:data-uri:
:icons:
:experimental:
:toc: macro
:toc-title:

toc::[]

== Overview
As an {product-title} administrator, you can use groups to manage users, change
their permissions, and enhance collaboration. Your organization may have already
created user groups and stored them in an LDAP server. {product-title} can sync
those LDAP records with internal {product-title} records, enabling you to manage
your groups in one place. {product-title} currently supports group sync with
LDAP servers using three common schemas for defining group membership: RFC 2307,
Active Directory, and augmented Active Directory.

[NOTE]
====
You must have
xref:../architecture/additional_concepts/authorization.adoc#roles[`cluster-admin`
privileges] to sync groups.
====

[[configuring-ldap-sync]]
== Configuring LDAP Sync

Before you can xref:running-ldap-sync[run LDAP sync], you need a sync
configuration file. This file contains LDAP client configuration details:

* Configuration for connecting to your LDAP server.
* Sync configuration options that are dependent on the schema used in your LDAP
server.

A sync configuration file can also contain an administrator-defined list of name
mappings that maps {product-title} Group names to groups in your LDAP server.

[[ldap-client-configuration]]
=== LDAP Client Configuration

.LDAP Client Configuration
====
[source,yaml]
----
url: ldap://10.0.0.0:389 <1>
bindDN: cn=admin,dc=example,dc=com <2>
bindPassword: password <3>
insecure: false <4>
ca: my-ldap-ca-bundle.crt <5>
----
<1> The connection protocol, IP address of the LDAP server hosting your
database, and the port to connect to, formatted as `scheme://host:port`.
<2> Optional distinguished name (DN) to use as the Bind DN.
{product-title} uses this if elevated privilege is required to retrieve entries for
the sync operation.
<3> Optional password to use to bind. {product-title} uses this if elevated privilege is
necessary to retrieve entries for the sync operation. This value may also be
provided in an
xref:../install_config/master_node_configuration.adoc#master-node-configuration-passwords-and-other-data[environment
variable, external file, or encrypted file].
<4> When `true`, no TLS connection is made to the server. When `false`, secure
LDAP (`ldaps://`) URLs connect using TLS, and insecure LDAP (`ldap://`) URLs are
upgraded to TLS.
<5> The certificate bundle to use for validating server certificates for the
configured URL. If empty, {product-title} uses system-trusted roots. This only applies
if `insecure` is set to `false`.
====

[[ldap-query-definition]]
=== LDAP Query Definition

Sync configurations consist of LDAP query definitions for the entries that are
required for synchronization. The specific definition of an LDAP query depends
on the schema used to store membership information in the LDAP server.

.LDAP Query Definition
====
[source,yaml]
----
baseDN: ou=users,dc=example,dc=com <1>
scope: sub <2>
derefAliases: never <3>
timeout: 0 <4>
filter: (objectClass=inetOrgPerson) <5>
pageSize: 0 <6>
----
<1> The distinguished name (DN) of the branch of the directory where all
searches will start from. It is required that you specify the top of your
directory tree, but you can also specify a subtree in the directory.
<2> The scope of the search. Valid values are `base`, `one`, or `sub`. If this
is left undefined, then a scope of `sub` is assumed. Descriptions of the scope
options can be found in the xref:ldap-search[table below].
<3> The behavior of the search with respect to aliases in the LDAP tree. Valid
values are `never`, `search`, `base`, or `always`. If this is left undefined,
then the default is to `always` dereference aliases. Descriptions of the
dereferencing behaviors can be found in the xref:deref-aliases[table below].
<4> The time limit allowed for the search by the client, in seconds. A value of
0 imposes no client-side limit.
<5> A valid LDAP search filter. If this is left undefined, then the default is
`(objectClass=*)`.
<6> The optional maximum size of response pages from the server, measured in LDAP
entries. If set to 0, no size restrictions will be made on pages of responses.
Setting paging sizes is necessary when queries return more entries than the
client or server allow by default.
====

[[ldap-search]]
.LDAP Search Scope Options
[cols=""2a,8a"",options=""header""]
|===
|LDAP Search Scope | Description
.^|`base`          | Only consider the object specified by the base DN given for the query.
.^|`one`           | Consider all of the objects on the same level in the tree as the base DN for
the query.
.^|`sub`           | Consider the entire subtree rooted at the base DN given for the query.
|===

[[deref-aliases]]
.LDAP Dereferencing Behaviors
[cols=""2a,8a"",options=""header""]
|===
|Dereferencing Behavior | Description
.^|`never`              | Never dereference any aliases found in the LDAP tree.
.^|`search`             | Only dereference aliases found while searching.
.^|`base`               | Only dereference aliases while finding the base object.
.^|`always`             | Always dereference all aliases found in the LDAP tree.
|===

[[user-defined-name-mapping]]
=== User-Defined Name Mapping

A user-defined name mapping explicitly maps the names of {product-title} Groups to
unique identifiers that find groups on your LDAP server. The mapping uses normal
YAML syntax. A user-defined mapping can contain an entry for every group in your
LDAP server or only a subset of those groups. If there are groups on the LDAP
server that do not have a user-defined name mapping, the default behavior during
sync is to use the attribute specified as the Group's name.

.User-Defined Name Mapping
====
[source,yaml]
----
groupUIDNameMapping:
  ""cn=group1,ou=groups,dc=example,dc=com"": firstgroup
  ""cn=group2,ou=groups,dc=example,dc=com"": secondgroup
  ""cn=group3,ou=groups,dc=example,dc=com"": thirdgroup
----
====

[[running-ldap-sync]]
== Running LDAP Sync

Once you have created a xref:configuring-ldap-sync[sync configuration file],
then sync can begin. {product-title} allows administrators to perform a number of
different sync types with the same server.

[NOTE]
====
By default, all group synchronization or pruning operations are dry-run, so you
must set the `--confirm` flag on the `oadm groups sync` command in order to make
changes to {product-title} group records.
====

To sync all groups from the LDAP server with {product-title}:

----
$ oadm groups sync --sync-config=config.yaml --confirm
----

To sync all Groups already in {product-title} that correspond to groups in the
LDAP server specified in the configuration file:

----
$ oadm groups sync --type=openshift --sync-config=config.yaml --confirm
----

To sync a subset of LDAP groups with {product-title}, you can use whitelist files,
blacklist files, or both:

[NOTE]
====
Any combination of blacklist files, whitelist files, or whitelist literals will
work; whitelist literals can be included directly in the command itself. This
applies to groups found on LDAP servers, as well as Groups already present in
{product-title}. Your files must contain one unique group identifier per line.
====

----
$ oadm groups sync --whitelist=<whitelist_file> \\
                   --sync-config=config.yaml    \\
                   --confirm
$ oadm groups sync --blacklist=<blacklist_file> \\
                   --sync-config=config.yaml    \\
                   --confirm
$ oadm groups sync <group_unique_identifier>    \\
                   --sync-config=config.yaml    \\
                   --confirm
$ oadm groups sync <group_unique_identifier>    \\
                   --whitelist=<whitelist_file> \\
                   --blacklist=<blacklist_file> \\
                   --sync-config=config.yaml    \\
                   --confirm
$ oadm groups sync --type=openshift             \\
                   --whitelist=<whitelist_file> \\
                   --sync-config=config.yaml    \\
                   --confirm
----

[[running-a-group-pruning-job]]
== Running a Group Pruning Job

An administrator can also choose to remove groups from {product-title} records
if the records on the LDAP server that created them are no longer present. The
prune job will accept the same sync configuration file and white- or black-lists
as used for the sync job.

For example, if groups had previously been synchronized from LDAP using some
*_config.yaml_* file, and some of those groups no longer existed on the LDAP
server, the following command would determine which Groups in {product-title}
corresponded to the deleted groups in LDAP and then remove them from
{product-title}:

----
$ oadm groups prune --sync-config=config.yaml --confirm
----

[[sync-examples]]
== Sync Examples

This section contains examples for the xref:sync-ldap-rfc-2307[RFC 2307],
xref:sync-ldap-active-directory[Active Directory], and
xref:sync-ldap-augmented-active-directory[augmented Active Directory] schemas.
All of the following examples synchronize a group named `admins` that has two
members: `Jane` and `Jim`. Each example explains:

* How the group and users are added to the LDAP server.
* What the LDAP sync configuration file looks like.
* What the resulting Group record in {product-title} will be after synchronization.

[NOTE]
====
These examples assume that all users are direct members of their respective
groups. Specifically, no groups have other groups as members. See
xref:sync-ldap-nested-example[Nested Membership Sync Example] for information on
how to sync nested groups.
====

[[sync-ldap-rfc-2307]]
=== RFC 2307

In the RFC 2307 schema, both users (Jane and Jim) and groups exist on the LDAP
server as first-class entries, and group membership is stored in attributes on
the group. The following snippet of `ldif` defines the users and group for this
schema:

.LDAP Entries Using RFC 2307 Schema: *_rfc2307.ldif_*
====
[source,ldif]
----
  dn: ou=users,dc=example,dc=com
  objectClass: organizationalUnit
  ou: users

  dn: cn=Jane,ou=users,dc=example,dc=com
  objectClass: person
  objectClass: organizationalPerson
  objectClass: inetOrgPerson
  cn: Jane
  sn: Smith
  displayName: Jane Smith
  mail: jane.smith@example.com

  dn: cn=Jim,ou=users,dc=example,dc=com
  objectClass: person
  objectClass: organizationalPerson
  objectClass: inetOrgPerson
  cn: Jim
  sn: Adams
  displayName: Jim Adams
  mail: jim.adams@example.com

  dn: ou=groups,dc=example,dc=com
  objectClass: organizationalUnit
  ou: groups

  dn: cn=admins,ou=groups,dc=example,dc=com <1>
  objectClass: groupOfNames
  cn: admins
  owner: cn=admin,dc=example,dc=com
  description: System Administrators
  member: cn=Jane,ou=users,dc=example,dc=com <2>
  member: cn=Jim,ou=users,dc=example,dc=com
----
<1> The group is a first-class entry in the LDAP server.
<2> Members of a group are listed with an identifying reference as attributes on
the group.
====

To sync this group, you must first create the configuration file. The
RFC 2307 schema requires you to provide an LDAP query definition for both user
and group entries, as well as the attributes with which to represent them in the
internal {product-title} records.

For clarity, the Group you create in {product-title} should use attributes other
than the distinguished name whenever possible for user- or administrator-facing
fields. For example, identify the users of a Group by their e-mail, and use the
name of the group as the common name. The following configuration file creates
these relationships:

[NOTE]
====
If using user-defined name mappings, your
xref:rfc2307-with-user-defined-name-mappings[configuration file] will differ.
====

.LDAP Sync Configuration Using RFC 2307 Schema: *_rfc2307_config.yaml_*
====
[source,yaml]
----
kind: LDAPSyncConfig
apiVersion: v1
url: ldap://LDAP_SERVICE_IP:389 <1>
insecure: false <2>
rfc2307:
    groupsQuery:
        baseDN: ""ou=groups,dc=example,dc=com""
        scope: sub
        derefAliases: never
        pageSize: 0
    groupUIDAttribute: dn <3>
    groupNameAttributes: [ cn ] <4>
    groupMembershipAttributes: [ member ] <5>
    usersQuery:
        baseDN: ""ou=users,dc=example,dc=com""
        scope: sub
        derefAliases: never
        pageSize: 0
    userUIDAttribute: dn <6>
    userNameAttributes: [ mail ] <7>
    tolerateMemberNotFoundErrors: false
    tolerateMemberOutOfScopeErrors: false
----
<1> The IP address and host of the LDAP server where this group's record is
stored.
<2> When `true`, no TLS connection is made to the server. When `false`, secure
LDAP (`ldaps://`) URLs connect using TLS, and insecure LDAP (`ldap://`) URLs are
upgraded to TLS.
<3> The attribute that uniquely identifies a group on the LDAP server.
You cannot specify `groupsQuery` filters when using DN for groupUIDAttribute.
For fine-grained filtering, use the
xref:../install_config/syncing_groups_with_ldap.adoc#running-ldap-sync[whitelist / blacklist method].
<4> The attribute to use as the name of the Group.
<5> The attribute on the group that stores the membership information.
<6> The attribute that uniquely identifies a user on the LDAP server. You
cannot specify `usersQuery` filters when using DN for userUIDAttribute. For
fine-grained  filtering, use the
xref:../install_config/syncing_groups_with_ldap.adoc#running-ldap-sync[whitelist / blacklist method].
<7> The attribute to use as the name of the user in the {product-title} Group record.
====

To run sync with the *_rfc2307_config.yaml_* file:

----
$ oadm groups sync --sync-config=rfc2307_config.yaml --confirm
----

{product-title} creates the following Group record as a result of the above sync
operation:

.{product-title} Group Created Using *_rfc2307_config.yaml_*
====
[source,yaml]
----
apiVersion: v1
kind: Group
metadata:
  annotations:
    openshift.io/ldap.sync-time: 2015-10-13T10:08:38-0400 <1>
    openshift.io/ldap.uid: cn=admins,ou=groups,dc=example,dc=com <2>
    openshift.io/ldap.url: LDAP_SERVER_IP:389 <3>
  creationTimestamp:
  name: admins <4>
users: <5>
- jane.smith@example.com
- jim.adams@example.com
----
<1> The last time this Group was synchronized with the LDAP server, in ISO 6801
format.
<2> The unique identifier for the group on the LDAP server.
<3> The IP address and host of the LDAP server where this Group's record is
stored.
<4> The name of the Group as specified by the sync file.
<5> The users that are members of the Group, named as specified by the sync file.
====

[[rfc2307-with-user-defined-name-mappings]]
==== RFC2307 with User-Defined Name Mappings

When syncing groups with user-defined name mappings, the configuration file
changes to contain these mappings as shown below.

.LDAP Sync Configuration Using RFC 2307 Schema With User-Defined Name Mappings: *_rfc2307_config_user_defined.yaml_*
====
[source,yaml]
----
kind: LDAPSyncConfig
apiVersion: v1
groupUIDNameMapping:
  ""cn=admins,ou=groups,dc=example,dc=com"": Administrators <1>
rfc2307:
    groupsQuery:
        baseDN: ""ou=groups,dc=example,dc=com""
        scope: sub
        derefAliases: never
        pageSize: 0
    groupUIDAttribute: dn <2>
    groupNameAttributes: [ cn ] <3>
    groupMembershipAttributes: [ member ]
    usersQuery:
        baseDN: ""ou=users,dc=example,dc=com""
        scope: sub
        derefAliases: never
        pageSize: 0
    userUIDAttribute: dn <4>
    userNameAttributes: [ mail ]
    tolerateMemberNotFoundErrors: false
    tolerateMemberOutOfScopeErrors: false
----
<1> The user-defined name mapping.
<2> The unique identifier attribute that is used for the keys in the
user-defined name mapping. You cannot specify `groupsQuery` filters when using
DN for groupUIDAttribute. For fine-grained filtering, use the
xref:../install_config/syncing_groups_with_ldap.adoc#running-ldap-sync[whitelist / blacklist method].
<3> The attribute to name {product-title} Groups with if their unique identifier is
not in the user-defined name mapping.
<4> The attribute that uniquely identifies a user on the LDAP server. You
cannot specify `usersQuery` filters when using DN for userUIDAttribute. For
fine-grained  filtering, use the
xref:../install_config/syncing_groups_with_ldap.adoc#running-ldap-sync[whitelist / blacklist method].
====

To run sync with the *_rfc2307_config_user_defined.yaml_* file:

----
$ oadm groups sync --sync-config=rfc2307_config_user_defined.yaml --confirm
----

{product-title} creates the following Group record as a result of the above sync
operation:

.{product-title} Group Created Using *_rfc2307_config_user_defined.yaml_*
====
[source,yaml]
----
apiVersion: v1
kind: Group
metadata:
  annotations:
    openshift.io/ldap.sync-time: 2015-10-13T10:08:38-0400
    openshift.io/ldap.uid: cn=admins,ou=groups,dc=example,dc=com
    openshift.io/ldap.url: LDAP_SERVER_IP:389
  creationTimestamp:
  name: Administrators <1>
users:
- jane.smith@example.com
- jim.adams@example.com
----
<1> The name of the Group as specified by the user-defined name mapping.
====

[[rfc2307-with-error-tolerances]]
=== RFC 2307 with User-Defined Error Tolerances

By default, if the groups being synced contain members whose entries are outside
of the scope defined in the member query, the group sync fails with an error:

----
Error determining LDAP group membership for ""<group>"": membership lookup for user ""<user>"" in group ""<group>"" failed because of ""search for entry with dn=""<user-dn>"" would search outside of the base dn specified (dn=""<base-dn>"")"".
----

This often indicates a mis-configured `baseDN` in the `usersQuery` field.
However, in cases where the `baseDN` intentionally does not contain some of the
members of the group, setting `tolerateMemberOutOfScopeErrors: true` allows
the group sync to continue. Out of scope members will be ignored.

Similarly, when the group sync process fails to locate a member for a group, it
fails outright with errors:

----
Error determining LDAP group membership for ""<group>"": membership lookup for user ""<user>"" in group ""<group>"" failed because of ""search for entry with base dn=""<user-dn>"" refers to a non-existent entry"".

Error determining LDAP group membership for ""<group>"": membership lookup for user ""<user>"" in group ""<group>"" failed because of ""search for entry with base dn=""<user-dn>"" and filter ""<filter>"" did not return any results"".
----

This often indicates a mis-configured `usersQuery` field. However, in cases
where the group contains member entries that are known to be missing, setting
`tolerateMemberNotFoundErrors: true` allows the group sync to continue.
Problematic members will be ignored.

[WARNING]
====
Enabling error tolerances for the LDAP group sync causes the sync process to
ignore problematic member entries. If the LDAP group sync is not configured
correctly, this could result in synced {product-title} groups missing members.
====

.LDAP Entries Using RFC 2307 Schema With Problematic Group Membership: *_rfc2307_problematic_users.ldif_*
====
[source,ldif]
----
  dn: ou=users,dc=example,dc=com
  objectClass: organizationalUnit
  ou: users

  dn: cn=Jane,ou=users,dc=example,dc=com
  objectClass: person
  objectClass: organizationalPerson
  objectClass: inetOrgPerson
  cn: Jane
  sn: Smith
  displayName: Jane Smith
  mail: jane.smith@example.com

  dn: cn=Jim,ou=users,dc=example,dc=com
  objectClass: person
  objectClass: organizationalPerson
  objectClass: inetOrgPerson
  cn: Jim
  sn: Adams
  displayName: Jim Adams
  mail: jim.adams@example.com

  dn: ou=groups,dc=example,dc=com
  objectClass: organizationalUnit
  ou: groups

  dn: cn=admins,ou=groups,dc=example,dc=com
  objectClass: groupOfNames
  cn: admins
  owner: cn=admin,dc=example,dc=com
  description: System Administrators
  member: cn=Jane,ou=users,dc=example,dc=com
  member: cn=Jim,ou=users,dc=example,dc=com
  member: cn=INVALID,ou=users,dc=example,dc=com <1>
  member: cn=Jim,ou=OUTOFSCOPE,dc=example,dc=com <2>
----
<1> A member that does not exist on the LDAP server.
<2> A member that may exist, but is not under the `baseDN` in the
user query for the sync job.
====

In order to tolerate the errors in the above example, the following additions to
your sync configuration file must be made:

.LDAP Sync Configuration Using RFC 2307 Schema Tolerating Errors: *_rfc2307_config_tolerating.yaml_*
====
[source,yaml]
----
kind: LDAPSyncConfig
apiVersion: v1
url: ldap://LDAP_SERVICE_IP:389
rfc2307:
    groupsQuery:
        baseDN: ""ou=groups,dc=example,dc=com""
        scope: sub
        derefAliases: never
    groupUIDAttribute: dn
    groupNameAttributes: [ cn ]
    groupMembershipAttributes: [ member ]
    usersQuery:
        baseDN: ""ou=users,dc=example,dc=com""
        scope: sub
        derefAliases: never
    userUIDAttribute: dn <3>
    userNameAttributes: [ mail ]
    tolerateMemberNotFoundErrors: true <1>
    tolerateMemberOutOfScopeErrors: true <2>
----
<1> When `true`, the sync job tolerates groups for which some members were not
found, and members whose LDAP entries are not found are ignored. The
default behavior for the sync job is to fail if a member of a group is not
found.
<2> When `true`, the sync job tolerates groups for which some members are outside
the user scope given in the `usersQuery` base DN, and members outside the member
query scope are ignored. The default behavior for the sync job is to fail if a
member of a group is out of scope.
<3> The attribute that uniquely identifies a user on the LDAP server. You
cannot specify `usersQuery` filters when using DN for userUIDAttribute. For
fine-grained  filtering, use the
xref:../install_config/syncing_groups_with_ldap.adoc#running-ldap-sync[whitelist / blacklist method].
====

To run sync with the *_rfc2307_config_tolerating.yaml_* file:

----
$ oadm groups sync --sync-config=rfc2307_config_tolerating.yaml --confirm
----

{product-title} creates the following group record as a result of the above sync
operation:

.{product-title} Group Created Using *_rfc2307_config.yaml_*
====
[source,yaml]
----
apiVersion: v1
kind: Group
metadata:
  annotations:
    openshift.io/ldap.sync-time: 2015-10-13T10:08:38-0400
    openshift.io/ldap.uid: cn=admins,ou=groups,dc=example,dc=com
    openshift.io/ldap.url: LDAP_SERVER_IP:389
  creationTimestamp:
  name: admins
users: <1>
- jane.smith@example.com
- jim.adams@example.com
----
<1> The users that are members of the group, as specified by the sync file.
Members for which lookup encountered tolerated errors are absent.
====

[[sync-ldap-active-directory]]
=== Active Directory

In the Active Directory schema, both users (Jane and Jim) exist in the LDAP
server as first-class entries, and group membership is stored in attributes on
the user. The following snippet of `ldif` defines the users and group for this
schema:

.LDAP Entries Using Active Directory Schema: *_active_directory.ldif_*
====
[source,ldif]
----
dn: ou=users,dc=example,dc=com
objectClass: organizationalUnit
ou: users

dn: cn=Jane,ou=users,dc=example,dc=com
objectClass: person
objectClass: organizationalPerson
objectClass: inetOrgPerson
objectClass: testPerson
cn: Jane
sn: Smith
displayName: Jane Smith
mail: jane.smith@example.com
memberOf: admins <1>

dn: cn=Jim,ou=users,dc=example,dc=com
objectClass: person
objectClass: organizationalPerson
objectClass: inetOrgPerson
objectClass: testPerson
cn: Jim
sn: Adams
displayName: Jim Adams
mail: jim.adams@example.com
memberOf: admins
----
<1> The user's group memberships are listed as attributes on the user, and the
group does not exist as an entry on the server. The `memberOf` attribute does
not have to be a literal attribute on the user; in some LDAP servers, it is created
during search and returned to the client, but not committed to the database.
====

To sync this group, you must first create the configuration file. The
Active Directory schema requires you to provide an LDAP query definition for
user entries, as well as the attributes to represent them with in the internal
{product-title} Group records.

For clarity, the Group you create in {product-title} should use attributes other
than the distinguished name whenever possible for user- or administrator-facing
fields. For example, identify the users of a Group by their e-mail, but define
the name of the Group by the name of the group on the LDAP server.
The following configuration file creates these relationships:

.LDAP Sync Configuration Using Active Directory Schema: *_active_directory_config.yaml_*
====
[source,yaml]
----
kind: LDAPSyncConfig
apiVersion: v1
url: ldap://LDAP_SERVICE_IP:389
activeDirectory:
    usersQuery:
        baseDN: ""ou=users,dc=example,dc=com""
        scope: sub
        derefAliases: never
        filter: (objectclass=inetOrgPerson)
        pageSize: 0
    userNameAttributes: [ mail ] <1>
    groupMembershipAttributes: [ memberOf ] <2>
----
<1> The attribute to use as the name of the user in the {product-title} Group record.
<2> The attribute on the user that stores the membership information.
====

To run sync with the *_active_directory_config.yaml_* file:

----
$ oadm groups sync --sync-config=active_directory_config.yaml --confirm
----

{product-title} creates the following Group record as a result of the above sync
operation:

.{product-title} Group Created Using *_active_directory_config.yaml_*
====
[source,yaml]
----
apiVersion: v1
kind: Group
metadata:
  annotations:
    openshift.io/ldap.sync-time: 2015-10-13T10:08:38-0400 <1>
    openshift.io/ldap.uid: admins <2>
    openshift.io/ldap.url: LDAP_SERVER_IP:389 <3>
  creationTimestamp:
  name: admins <4>
users: <5>
- jane.smith@example.com
- jim.adams@example.com
----
<1> The last time this Group was synchronized with the LDAP server, in ISO 6801
format.
<2> The unique identifier for the group on the LDAP server.
<3> The IP address and host of the LDAP server where this Group's record is
stored.
<4> The name of the group as listed in the LDAP server.
<5> The users that are members of the Group, named as specified by the sync
file.
====

[[sync-ldap-augmented-active-directory]]
=== Augmented Active Directory

In the augmented Active Directory schema, both users (Jane and Jim) and groups
exist in the LDAP server as first-class entries, and group membership is stored
in attributes on the user. The following snippet of `ldif` defines the users and
group for this schema:

.LDAP Entries Using Augmented Active Directory Schema: *_augmented_active_directory.ldif_*
====
[source,ldif]
----
dn: ou=users,dc=example,dc=com
objectClass: organizationalUnit
ou: users

dn: cn=Jane,ou=users,dc=example,dc=com
objectClass: person
objectClass: organizationalPerson
objectClass: inetOrgPerson
objectClass: testPerson
cn: Jane
sn: Smith
displayName: Jane Smith
mail: jane.smith@example.com
memberOf: cn=admins,ou=groups,dc=example,dc=com <1>

dn: cn=Jim,ou=users,dc=example,dc=com
objectClass: person
objectClass: organizationalPerson
objectClass: inetOrgPerson
objectClass: testPerson
cn: Jim
sn: Adams
displayName: Jim Adams
mail: jim.adams@example.com
memberOf: cn=admins,ou=groups,dc=example,dc=com

dn: ou=groups,dc=example,dc=com
objectClass: organizationalUnit
ou: groups

dn: cn=admins,ou=groups,dc=example,dc=com <2>
objectClass: groupOfNames
cn: admins
owner: cn=admin,dc=example,dc=com
description: System Administrators
member: cn=Jane,ou=users,dc=example,dc=com
member: cn=Jim,ou=users,dc=example,dc=com
----
<1> The user's group memberships are listed as attributes on the user.
<2> The group is a first-class entry on the LDAP server.
====

To sync this group, you must first create the configuration file. The
augmented Active Directory schema requires you to provide an LDAP query
definition for both user entries and group entries, as well as the attributes
with which to represent them in the internal {product-title} Group records.

For clarity, the Group you create in {product-title} should use attributes other
than the distinguished name whenever possible for user- or administrator-facing
fields. For example, identify the users of a Group by their e-mail,
and use the name of the Group as the common name. The following configuration
file creates these relationships.

.LDAP Sync Configuration Using Augmented Active Directory Schema: *_augmented_active_directory_config.yaml_*
====
[source,yaml]
----
kind: LDAPSyncConfig
apiVersion: v1
url: ldap://LDAP_SERVICE_IP:389
augmentedActiveDirectory:
    groupsQuery:
        baseDN: ""ou=groups,dc=example,dc=com""
        scope: sub
        derefAliases: never
        pageSize: 0
    groupUIDAttribute: dn <1>
    groupNameAttributes: [ cn ] <2>
    usersQuery:
        baseDN: ""ou=users,dc=example,dc=com""
        scope: sub
        derefAliases: never
        pageSize: 0
    userNameAttributes: [ mail ] <3>
    groupMembershipAttributes: [ memberOf ] <4>
----
<1> The attribute that uniquely identifies a group on the LDAP server. You
cannot specify `groupsQuery` filters when using DN for groupUIDAttribute. For
fine-grained filtering, use the
xref:../install_config/syncing_groups_with_ldap.adoc#running-ldap-sync[whitelist / blacklist method].
<2> The attribute to use as the name of the Group.
<3> The attribute to use as the name of the user in the {product-title} Group record.
<4> The attribute on the user that stores the membership information.
====

To run sync with the *_augmented_active_directory_config.yaml_* file:

----
$ oadm groups sync --sync-config=augmented_active_directory_config.yaml --confirm
----

{product-title} creates the following Group record as a result of the above sync
operation:

.OpenShift Group Created Using *_augmented_active_directory_config.yaml_*
====
[source,yaml]
----
apiVersion: v1
kind: Group
metadata:
  annotations:
    openshift.io/ldap.sync-time: 2015-10-13T10:08:38-0400 <1>
    openshift.io/ldap.uid: cn=admins,ou=groups,dc=example,dc=com <2>
    openshift.io/ldap.url: LDAP_SERVER_IP:389 <3>
  creationTimestamp:
  name: admins <4>
users: <5>
- jane.smith@example.com
- jim.adams@example.com
----
<1> The last time this Group was synchronized with the LDAP server, in ISO 6801 format.
<2> The unique identifier for the group on the LDAP server.
<3> The IP address and host of the LDAP server where this Group's record is stored.
<4> The name of the Group as specified by the sync file.
<5> The users that are members of the Group, named as specified by the sync file.
====

[[sync-ldap-nested-example]]
== Nested Membership Sync Example

Groups in {product-title} do not nest. The LDAP server must flatten group
membership before the data can be consumed. Microsoft's Active Directory Server
supports this feature via the
link:https://msdn.microsoft.com/en-us/library/aa746475(v=vs.85).aspx[`LDAP_MATCHING_RULE_IN_CHAIN`]
rule, which has the OID `1.2.840.113556.1.4.1941`. Furthermore, only explicitly
xref:../install_config/syncing_groups_with_ldap.adoc#running-ldap-sync[whitelisted]
groups can be synced when using this matching rule.

This section has an example for the augmented Active Directory schema, which
synchronizes a group named `admins` that has one user `Jane` and one group
`otheradmins` as members. The `otheradmins` group has one user member: `Jim`.
This example explains:

* How the group and users are added to the LDAP server.
* What the LDAP sync configuration file looks like.
* What the resulting Group record in {product-title} will be after synchronization.

In the augmented Active Directory schema, both users (`Jane` and `Jim`) and
groups exist in the LDAP server as first-class entries, and group membership is
stored in attributes on the user or the group. The following snippet of `ldif`
defines the users and groups for this schema:

.LDAP Entries Using Augmented Active Directory Schema With Nested Members: *_augmented_active_directory_nested.ldif_*
[source,ldif]
----
dn: ou=users,dc=example,dc=com
objectClass: organizationalUnit
ou: users

dn: cn=Jane,ou=users,dc=example,dc=com
objectClass: person
objectClass: organizationalPerson
objectClass: inetOrgPerson
objectClass: testPerson
cn: Jane
sn: Smith
displayName: Jane Smith
mail: jane.smith@example.com
memberOf: cn=admins,ou=groups,dc=example,dc=com <1>

dn: cn=Jim,ou=users,dc=example,dc=com
objectClass: person
objectClass: organizationalPerson
objectClass: inetOrgPerson
objectClass: testPerson
cn: Jim
sn: Adams
displayName: Jim Adams
mail: jim.adams@example.com
memberOf: cn=otheradmins,ou=groups,dc=example,dc=com <1>

dn: ou=groups,dc=example,dc=com
objectClass: organizationalUnit
ou: groups

dn: cn=admins,ou=groups,dc=example,dc=com <2>
objectClass: group
cn: admins
owner: cn=admin,dc=example,dc=com
description: System Administrators
member: cn=Jane,ou=users,dc=example,dc=com
member: cn=otheradmins,ou=groups,dc=example,dc=com

dn: cn=otheradmins,ou=groups,dc=example,dc=com <2>
objectClass: group
cn: otheradmins
owner: cn=admin,dc=example,dc=com
description: Other System Administrators
memberOf: cn=admins,ou=groups,dc=example,dc=com <1> <3>
member: cn=Jim,ou=users,dc=example,dc=com
----
<1> The user's and group's memberships are listed as attributes on the object.
<2> The groups are first-class entries on the LDAP server.
<3> The `otheradmins` group is a member of the `admins` group.

To sync nested groups with Active Directory, you must provide an LDAP query
definition for both user entries and group entries, as well as the attributes
with which to represent them in the internal {product-title} Group records.
Furthermore, certain changes are required in this configuration:

- The `oadm groups sync` command must explicitly
xref:../install_config/syncing_groups_with_ldap.adoc#running-ldap-sync[whitelist]
groups.
- The user's `groupMembershipAttributes` must include
`""memberOf:1.2.840.113556.1.4.1941:""` to comply with the
https://msdn.microsoft.com/en-us/library/aa746475(v=vs.85).aspx[`LDAP_MATCHING_RULE_IN_CHAIN`]
rule.
- The `groupUIDAttribute` must be set to `dn`.
- The `groupsQuery`:
  * Must not set `filter`.
  * Must set a valid `derefAliases`.
  * Should not set `baseDN` as that value is ignored.
  * Should not set `scope` as that value is ignored.

For clarity, the Group you create in {product-title} should use attributes other
than the distinguished name whenever possible for user- or administrator-facing
fields. For example, identify the users of a Group by their e-mail, and use the
name of the Group as the common name. The following configuration file creates
these relationships:

.LDAP Sync Configuration Using Augmented Active Directory Schema With Nested Members: *_augmented_active_directory_config_nested.yaml_*
[source,yaml]
----
kind: LDAPSyncConfig
apiVersion: v1
url: ldap://LDAP_SERVICE_IP:389
augmentedActiveDirectory:
    groupsQuery: <1>
        derefAliases: never
        pageSize: 0
    groupUIDAttribute: dn <2>
    groupNameAttributes: [ cn ] <3>
    usersQuery:
        baseDN: ""ou=users,dc=example,dc=com""
        scope: sub
        derefAliases: never
        filter: (objectclass=inetOrgPerson)
        pageSize: 0
    userNameAttributes: [ mail ] <4>
    groupMembershipAttributes: [ ""memberOf:1.2.840.113556.1.4.1941:"" ] <5>
----
<1> `groupsQuery` filters cannot be specified. The `groupsQuery` base DN and scope
values are ignored. `groupsQuery` must set a valid `derefAliases`.
<2> The attribute that uniquely identifies a group on the LDAP server. It must be set to `dn`.
<3> The attribute to use as the name of the Group.
<4> The attribute to use as the name of the user in the {product-title} Group
record. `mail` or `sAMAccountName` are preferred choices in most installations.
<5> The attribute on the user that stores the membership information. Note the use
of https://msdn.microsoft.com/en-us/library/aa746475(v=vs.85).aspx[`LDAP_MATCHING_RULE_IN_CHAIN`].

To run sync with the *_augmented_active_directory_config_nested.yaml_* file:

----
$ oadm groups sync \\
    'cn=admins,ou=groups,dc=example,dc=com' \\
    --sync-config=augmented_active_directory_config_nested.yaml \\
    --confirm
----

[NOTE]
====
You must explicitly
xref:../install_config/syncing_groups_with_ldap.adoc#running-ldap-sync[whitelist]
the `cn=admins,ou=groups,dc=example,dc=com` group.
====

{product-title} creates the following Group record as a result of the above sync
operation:

.OpenShift Group Created Using *_augmented_active_directory_config_nested.yaml_*
[source,yaml]
----
apiVersion: v1
kind: Group
metadata:
  annotations:
    openshift.io/ldap.sync-time: 2015-10-13T10:08:38-0400 <1>
    openshift.io/ldap.uid: cn=admins,ou=groups,dc=example,dc=com <2>
    openshift.io/ldap.url: LDAP_SERVER_IP:389 <3>
  creationTimestamp:
  name: admins <4>
users: <5>
- jane.smith@example.com
- jim.adams@example.com
----
<1> The last time this Group was synchronized with the LDAP server, in ISO 6801 format.
<2> The unique identifier for the group on the LDAP server.
<3> The IP address and host of the LDAP server where this Group's record is stored.
<4> The name of the Group as specified by the sync file.
<5> The users that are members of the Group, named as specified by the sync file.
Note that members of nested groups are included since the group membership was
flattened by the Microsoft Active Directory Server.

[[sync-ldap-configuration]]
== LDAP Sync Configuration Specification

The object specification for the configuration file is below.  Note that the different schema
objects have different fields.  For example, xref:sync-ldap-v1-activedirectoryconfig[v1.ActiveDirectoryConfig] has no `groupsQuery`
field whereas xref:sync-ldap-v1-rfc2307config[v1.RFC2307Config] and xref:sync-ldap-v1-augmentedactivedirectoryconfig[v1.AugmentedActiveDirectoryConfig] both do.

[IMPORTANT]
====
There is no support for binary attributes. All attribute data coming from the
LDAP server must be in the format of a UTF-8 encoded string. For example, never
use a binary attribute, such as `objectGUID`, as an ID attribute. You must use
string attributes, such as `sAMAccountName` or `userPrincipalName`, instead.
====

[[sync-ldap-v1-ldapsyncconfig]]
=== v1.LDAPSyncConfig

`LDAPSyncConfig` holds the necessary configuration options to define an LDAP
group sync.

[options=""header""]
|===
|Name |Description |Schema

|`kind`
|String value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: link:http://releases.k8s.io/HEAD/docs/devel/api-conventions.md#types-kinds[]
|string

|`apiVersion`
|Defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: link:http://releases.k8s.io/HEAD/docs/devel/api-conventions.md#resources[]
|string

|`url`
|Host is the scheme, host and port of the LDAP server to connect to: `scheme://host:port`
|string

|`bindDN`
|Optional DN to bind to the LDAP server with.
|string

|`bindPassword`
|Optional password to bind with during the search phase. |xref:sync-ldap-v1-stringsource[v1.StringSource]

|`insecure`
|If `true`, indicates the connection should not use TLS. Cannot be set to true with a URL scheme of `ldaps://` If `false`, `ldaps://` URLs connect using TLS, and `ldap://` URLs are upgraded to a TLS connection using StartTLS as specified in link:https://tools.ietf.org/html/rfc2830[].
|boolean

|`ca`
|Optional trusted certificate authority bundle to use when making requests to the server. If empty, the default system roots are used.
|string

|`groupUIDNameMapping`
|Optional direct mapping of LDAP group UIDs to {product-title} Group names.
|object

|`rfc2307`
|Holds the configuration for extracting data from an LDAP server set up in a fashion similar to RFC2307: first-class group and user entries, with group membership determined by a multi-valued attribute on the group entry listing its members.
|xref:sync-ldap-v1-rfc2307config[v1.RFC2307Config]

|`activeDirectory`
|Holds the configuration for extracting data from an LDAP server set up in a fashion similar to that used in Active Directory: first-class user entries, with group membership determined by a multi-valued attribute on members listing groups they are a member of.
|xref:sync-ldap-v1-activedirectoryconfig[v1.ActiveDirectoryConfig]

|`augmentedActiveDirectory`
|Holds the configuration for extracting data from an LDAP server set up in a fashion similar to that used in Active Directory as described above, with one addition: first-class group entries exist and are used to hold metadata but not group membership.
|xref:sync-ldap-v1-augmentedactivedirectoryconfig[v1.AugmentedActiveDirectoryConfig]
|===

[[sync-ldap-v1-stringsource]]
=== v1.StringSource

`StringSource` allows specifying a string inline, or externally via environment
variable or file. When it contains only a string value, it marshals to a simple
JSON string.

[options=""header""]
|===
|Name |Description |Schema

|`value`
|Specifies the cleartext value, or an encrypted value if `keyFile` is specified.
|string

|`env`
|Specifies an environment variable containing the cleartext value, or an
encrypted value if the `keyFile` is specified.
|string

|`file`
|References a file containing the cleartext value, or an encrypted value if a `keyFile` is specified.
|string

|`keyFile`
|References a file containing the key to use to decrypt the value.
|string
|===

[[sync-ldap-v1-ldapquery]]
=== v1.LDAPQuery

`LDAPQuery` holds the options necessary to build an LDAP query.

[options=""header""]
|===
|Name |Description |Schema

|`baseDN`
|DN of the branch of the directory where all searches should start from.
|string

|`scope`
|The (optional) scope of the search. Can be `base` (only the base object), `one`
(all objects on the base level), `sub` (the entire subtree). Defaults to `sub`
if not set.
|string

|`derefAliases`
|The (optional) behavior of the search with regards to alisases. Can be `never`
(never dereference aliases), `search` (only dereference in searching), `base`
(only dereference in finding the base object), `always` (always dereference).
Defaults to `always` if not set.
|string

|`timeout`
|Holds the limit of time in seconds that any request to the server can remain outstanding before the wait for a response is given up. If this is `0`, no client-side limit is imposed.
|integer

|`filter`
|A valid LDAP search filter that retrieves all relevant entries from the LDAP server with the base DN.
|string

|`pageSize`
|Maximum preferred page size, measured in LDAP entries. A page size of `0` means no paging will be done.
|integer
|===

[[sync-ldap-v1-rfc2307config]]
=== v1.RFC2307Config

`RFC2307Config` holds the necessary configuration options to define how an LDAP
group sync interacts with an LDAP server using the RFC2307 schema.

[options=""header""]
|===
|Name |Description |Schema

|`groupsQuery`
|Holds the template for an LDAP query that returns group entries.
|xref:sync-ldap-v1-ldapquery[v1.LDAPQuery]

|`groupUIDAttribute`
|Defines which attribute on an LDAP group entry will be interpreted as its unique identifier. (`ldapGroupUID`)
|string

|`groupNameAttributes`
|Defines which attributes on an LDAP group entry will be interpreted as its name to use for an {product-title} group.
|string array

|`groupMembershipAttributes`
|Defines which attributes on an LDAP group entry will be interpreted as its members. The values contained in those attributes must be queryable by your `UserUIDAttribute`.
|string array

|`usersQuery`
|Holds the template for an LDAP query that returns user entries.
|xref:sync-ldap-v1-ldapquery[v1.LDAPQuery]

|`userUIDAttribute`
|Defines which attribute on an LDAP user entry will be interpreted as its unique identifier. It must correspond to values that will be found from the `GroupMembershipAttributes`.
|string

|`userNameAttributes`
|Defines which attributes on an LDAP user entry will be used, in order, as its {product-title} user name. The first attribute with a non-empty value is used. This should match your `PreferredUsername` setting for your `LDAPPasswordIdentityProvider`. The attribute to use as the name of the user in the {product-title} Group
record. `mail` or `sAMAccountName` are preferred choices in most installations.
|string array

|`tolerateMemberNotFoundErrors`
|Determines the behavior of the LDAP sync job when missing user entries are encountered. If `true`, an LDAP query for users that does not find any will be tolerated and an only and error will be logged. If `false`, the LDAP sync job will fail if a query for users doesn't find any. The default value is 'false'. Misconfigured LDAP sync jobs with this flag set to 'true' can cause group membership to be removed, so it is recommended to use this flag with caution.
|boolean

|`tolerateMemberOutOfScopeErrors`
|Determines the behavior of the LDAP sync job when out-of-scope user entries are encountered. If `true`, an LDAP query for a user that falls outside of the base DN given for the all user query will be tolerated and only an error will be logged. If `false`, the LDAP sync job will fail if a user query would search outside of the base DN specified by the all user query. Misconfigured LDAP sync jobs with this flag set to `true` can result in groups missing users, so it is recommended to use this flag with caution.
|boolean
|===

[[sync-ldap-v1-activedirectoryconfig]]
=== v1.ActiveDirectoryConfig

`ActiveDirectoryConfig` holds the necessary configuration options to define how
an LDAP group sync interacts with an LDAP server using the Active Directory
schema.

[options=""header""]
|===
|Name |Description |Schema

|`usersQuery`
|Holds the template for an LDAP query that returns user entries.
|xref:sync-ldap-v1-ldapquery[v1.LDAPQuery]

|`userNameAttributes`
|Defines which attributes on an LDAP user entry will be interpreted as its {product-title} user name. The attribute to use as the name of the user in the {product-title} Group
record. `mail` or `sAMAccountName` are preferred choices in most installations.
|string array

|`groupMembershipAttributes`
|Defines which attributes on an LDAP user entry will be interpreted as the groups it is a member of.
|string array
|===

[[sync-ldap-v1-augmentedactivedirectoryconfig]]
=== v1.AugmentedActiveDirectoryConfig

`AugmentedActiveDirectoryConfig` holds the necessary configuration options to
define how an LDAP group sync interacts with an LDAP server using the augmented
Active Directory schema.

[options=""header""]
|===
|Name |Description |Schema

|`usersQuery`
|Holds the template for an LDAP query that returns user entries.
|xref:sync-ldap-v1-ldapquery[v1.LDAPQuery]

|`userNameAttributes`
|Defines which attributes on an LDAP user entry will be interpreted as its {product-title} user name. The attribute to use as the name of the user in the {product-title} Group
record. `mail` or `sAMAccountName` are preferred choices in most installations.
|string array

|`groupMembershipAttributes`
|Defines which attributes on an LDAP user entry will be interpreted as the groups it is a member of.
|string array

|`groupsQuery`
|Holds the template for an LDAP query that returns group entries.
|xref:sync-ldap-v1-ldapquery[v1.LDAPQuery]

|`groupUIDAttribute`
|Defines which attribute on an LDAP group entry will be interpreted as its unique identifier. (`ldapGroupUID`)
|string

|`groupNameAttributes`
|Defines which attributes on an LDAP group entry will be interpreted as its name to use for an {product-title} group.
|string array
|===
",12045,True,2572.89244885454,median
"[[salesforce-component]]
= Salesforce Component

*Since Camel 2.12*

This component supports producer and consumer endpoints to communicate
with Salesforce using Java DTOs.  +
 There is a companion maven plugin Camel Salesforce Plugin that
generates these DTOs (see further below).

Maven users will need to add the following dependency to their `pom.xml`
for this component:

[source,xml]
----
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-salesforce</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>
----

NOTE: Developers wishing to contribute to the component are instructed
to look at the https://github.com/apache/camel/tree/master/components/camel-salesforce/camel-salesforce-component/README.md[README.md] file on instructions on how to get started and
setup your environment for running integration tests.

== Authenticating to Salesforce

The component supports three OAuth authentication flows:

* https://help.salesforce.com/articleView?id=remoteaccess_oauth_username_password_flow.htm[OAuth 2.0 Username-Password Flow]
* https://help.salesforce.com/articleView?id=remoteaccess_oauth_refresh_token_flow.htm[OAuth 2.0 Refresh Token Flow]
* https://help.salesforce.com/articleView?id=remoteaccess_oauth_jwt_flow.htm[OAuth 2.0 JWT Bearer Token Flow]

For each of the flow different set of properties needs to be set:

.Properties to set for each authentication flow
|===
| Property     | Where to find it on Salesforce     | Flow

| clientId     | Connected App, Consumer Key        | All flows
| clientSecret | Connected App, Consumer Secret     | Username-Password, Refresh Token
| userName     | Salesforce user username           | Username-Password, JWT Bearer Token
| password     | Salesforce user password           | Username-Password
| refreshToken | From OAuth flow callback           | Refresh Token
| keystore     | Connected App, Digital Certificate | JWT Bearer Token
|===

The component auto determines what flow you're trying to configure, to
be remove ambiguity set the `authenticationType` property.

NOTE: Using Username-Password Flow in production is not encouraged.

NOTE: The certificate used in JWT Bearer Token Flow can be a selfsigned 
certificate. The KeyStore holding the certificate and the private key
must contain only single certificate-private key entry.

== URI format

When used as a consumer, receiving streaming events, the URI scheme is:

[source,java]
----
salesforce:topic?options
----

When used as a producer, invoking the Salesforce REST APIs, the URI
scheme is:

[source,java]
----
salesforce:operationName?options
----

You can append query options to the URI in the following format,
`?option=value&option=value&...`

== Passing in Salesforce headers and fetching Salesforce response headers

There is support to pass https://developer.salesforce.com/docs/atlas.en-us.api_rest.meta/api_rest/headers.htm[Salesforce headers]
via inbound message headers, header names that start with `Sforce` or
`x-sfdc` on the Camel message will be passed on in the request, and
response headers that start with `Sforce` will be present in the outbound
message headers.

For example to fetch API limits you can specify:

[source,java]
----
// in your Camel route set the header before Salesforce endpoint
//...
  .setHeader(""Sforce-Limit-Info"", constant(""api-usage""))
  .to(""salesforce:getGlobalObjects"")
  .to(myProcessor);

// myProcessor will receive `Sforce-Limit-Info` header on the outbound
// message
class MyProcessor implements Processor {
    public void process(Exchange exchange) throws Exception {
        Message in = exchange.getIn();
        String apiLimits = in.getHeader(""Sforce-Limit-Info"", String.class);
   }
}
----

== Supported Salesforce APIs

The component supports the following Salesforce APIs

Producer endpoints can use the following APIs. Most of the APIs process
one record at a time, the Query API can retrieve multiple Records.

=== Rest API

You can use the following for `operationName`:

* getVersions - Gets supported Salesforce REST API versions
* getResources - Gets available Salesforce REST Resource endpoints
* getGlobalObjects - Gets metadata for all available SObject types
* getBasicInfo - Gets basic metadata for a specific SObject type
* getDescription - Gets comprehensive metadata for a specific SObject
type
* getSObject - Gets an SObject using its Salesforce Id
* createSObject - Creates an SObject
* updateSObject - Updates an SObject using Id
* deleteSObject - Deletes an SObject using Id
* getSObjectWithId - Gets an SObject using an external (user defined) id
field
* upsertSObject - Updates or inserts an SObject using an external id
* deleteSObjectWithId - Deletes an SObject using an external id
* query - Runs a Salesforce SOQL query
* queryMore - Retrieves more results (in case of large number of
results) using result link returned from the 'query' API
* search - Runs a Salesforce SOSL query
* limits - fetching organization API usage limits
* recent - fetching recent items
* approval - submit a record or records (batch) for approval process
* approvals - fetch a list of all approval processes
* composite - submit up to 25 possibly related REST requests and receive individual responses
* composite-tree - create up to 200 records with parent-child relationships (up to 5 levels) in one go
* composite-batch - submit a composition of requests in batch
* queryAll - Runs a SOQL query. It returns the results that are deleted because of a merge or delete. Also returns the  information about archived Task and Event records.
* getBlobField - Retrieves the specified blob field from an individual record.
* apexCall - Executes a user defined APEX REST API call.

For example, the following producer endpoint uses the upsertSObject API,
with the sObjectIdName parameter specifying 'Name' as the external id
field. 
The request message body should be an SObject DTO generated using the
maven plugin.  
The response message will either be `null` if an existing record was
updated, or `CreateSObjectResult` with an id of the new record, or a
list of errors while creating the new object.

[source,java]
----
...to(""salesforce:upsertSObject?sObjectIdName=Name"")...
----

=== Rest Bulk API

Producer endpoints can use the following APIs. All Job data formats,
i.e. xml, csv, zip/xml, and zip/csv are supported.  +
 The request and response have to be marshalled/unmarshalled by the
route. Usually the request will be some stream source like a CSV file,
 +
 and the response may also be saved to a file to be correlated with the
request.

You can use the following for `operationName`:

* createJob - Creates a Salesforce Bulk Job
* getJob - Gets a Job using its Salesforce Id
* closeJob - Closes a Job
* abortJob - Aborts a Job
* createBatch - Submits a Batch within a Bulk Job
* getBatch - Gets a Batch using Id
* getAllBatches - Gets all Batches for a Bulk Job Id
* getRequest - Gets Request data (XML/CSV) for a Batch
* getResults - Gets the results of the Batch when its complete
* createBatchQuery - Creates a Batch from an SOQL query
* getQueryResultIds - Gets a list of Result Ids for a Batch Query
* getQueryResult - Gets results for a Result Id
* getRecentReports - Gets up to 200 of the reports you most recently viewed by sending a GET request to the Report List resource.
* getReportDescription - Retrieves the report, report type, and related metadata for a report, either in a tabular or summary or matrix format.
* executeSyncReport - Runs a report synchronously with or without changing filters and returns the latest summary data.
* executeAsyncReport - Runs an instance of a report asynchronously with or without filters and returns the summary data with or without details.
* getReportInstances - Returns a list of instances for a report that you requested to be run asynchronously. Each item in the list is treated as a separate instance of the report.
* getReportResults: Contains the results of running a report.

For example, the following producer endpoint uses the createBatch API to
create a Job Batch. The in message must contain a body that can be converted into an
`InputStream` (usually UTF-8 CSV or XML content from a file, etc.) and
header fields 'jobId' for the Job and 'contentType' for the Job content
type, which can be XML, CSV, ZIP_XML or ZIP_CSV. The put message body
will contain `BatchInfo` on success, or throw a `SalesforceException` on
error.

[source,java]
----
...to(""salesforce:createBatchJob"")..
----

=== Rest Streaming API

Consumer endpoints can use the following syntax for streaming endpoints
to receive Salesforce notifications on create/update.

To create and subscribe to a topic

[source,java]
----
from(""salesforce:CamelTestTopic?notifyForFields=ALL&notifyForOperations=ALL&sObjectName=Merchandise__c&updateTopic=true&sObjectQuery=SELECT Id, Name FROM Merchandise__c"")...
----

To subscribe to an existing topic

[source,java]
----
from(""salesforce:CamelTestTopic&sObjectName=Merchandise__c"")...
----

=== Platform events

To emit a platform event use `createSObject` operation. And set the
message body can be JSON string or InputStream with key-value data --
in that case `sObjectName` needs to be set to the API name of the
event, or a class that extends from AbstractDTOBase with the
appropriate class name for the event.

For example using a DTO:

[source,java]
----
class Order_Event__e extends AbstractDTOBase {
  @JsonProperty(""OrderNumber"")
  private String orderNumber;
  // ... other properties and getters/setters
}

from(""timer:tick"")
    .process(exchange -> {
        final Message in = exchange.getIn();
        String orderNumber = ""ORD"" + String.valueOf(in.getHeader(Exchange.TIMER_COUNTER));
        Order_Event__e event = new Order_Event__e();
        event.setOrderNumber(orderNumber);
        in.setBody(event);
    })
    .to(""salesforce:createSObject"");
----

Or using JSON event data:

[source,java]
----
from(""timer:tick"")
    .process(exchange -> {
        final Message in = exchange.getIn();
        String orderNumber = ""ORD"" + String.valueOf(in.getHeader(Exchange.TIMER_COUNTER));
        in.setBody(""{\\""OrderNumber\\"":\\"""" + orderNumber + ""\\""}"");
    })
    .to(""salesforce:createSObject?sObjectName=Order_Event__e"");
----

To receive platform events use the consumer endpoint with the API name of
the platform event prefixed with `event/` (or `/event/`), e.g.:
`salesforce:events/Order_Event__e`. Processor consuming from that
endpoint will receive either `org.apache.camel.component.salesforce.api.dto.PlatformEvent`
object or `org.cometd.bayeux.Message` in the body depending on the
`rawPayload` being `false` or `true` respectively.

For example, in the simplest form to consume one event:

[source,java]
----
PlatformEvent event = consumer.receiveBody(""salesforce:event/Order_Event__e"", PlatformEvent.class);
----

=== Change data capture events

On the one hand, Salesforce could be configured to emit notifications for record changes of select objects.
On the other hand, the Camel Salesforce component could react to such notifications, allowing for instance to
https://trailhead.salesforce.com/en/content/learn/modules/change-data-capture/understand-change-data-capture[synchronize those changes into an external system].

The notifications of interest could be specified in the `from(""salesforce:XXX"")` clause of a Camel route via the subscription channel, e.g:

[source,java]
----
from(""salesforce:data/ChangeEvents?replayId=-1"").log(""being notified of all change events"")
from(""salesforce:data/AccountChangeEvent?replayId=-1"").log(""being notified of change events for Account records"")
from(""salesforce:data/Employee__ChangeEvent?replayId=-1"").log(""being notified of change events for Employee__c custom object"")
----

The received message contains either `java.util.Map<String,Object>` or `org.cometd.bayeux.Message` in the body depending on the `rawPayload` being `false` or `true` respectively. The `CamelSalesforceChangeType` header could be valued to one of `CREATE`, `UPDATE`,  `DELETE` or `UNDELETE`.

More details about how to use the Camel Salesforce component change data capture capabilities could be found in the https://github.com/apache/camel/tree/master/components/camel-salesforce/camel-salesforce-component/src/test/java/org/apache/camel/component/salesforce/ChangeEventsConsumerIntegrationTest.java[ChangeEventsConsumerIntegrationTest].

The https://developer.salesforce.com/docs/atlas.en-us.change_data_capture.meta/change_data_capture/cdc_intro.htm[Salesforce developer guide]
is a good fit to better know the subtleties of implementing a change data capture integration application.
The dynamic nature of change event body fields, high level replication steps as well as security considerations could be of interest.

== Examples

=== Uploading a document to a ContentWorkspace

Create the ContentVersion in Java, using a Processor instance:

[source,java]
----
public class ContentProcessor implements Processor {
    public void process(Exchange exchange) throws Exception {
        Message message = exchange.getIn();

        ContentVersion cv = new ContentVersion();
        ContentWorkspace cw = getWorkspace(exchange);
        cv.setFirstPublishLocationId(cw.getId());
        cv.setTitle(""test document"");
        cv.setPathOnClient(""test_doc.html"");
        byte[] document = message.getBody(byte[].class);
        ObjectMapper mapper = new ObjectMapper();
        String enc = mapper.convertValue(document, String.class);
        cv.setVersionDataUrl(enc);
        message.setBody(cv);
    }

    protected ContentWorkspace getWorkSpace(Exchange exchange) {
        // Look up the content workspace somehow, maybe use enrich() to add it to a
        // header that can be extracted here
        ....
    }
} 
----

Give the output from the processor to the Salesforce component:

[source,java]
----
from(""file:///home/camel/library"")
    .to(new ContentProcessor())     // convert bytes from the file into a ContentVersion SObject 
                                    // for the salesforce component
    .to(""salesforce:createSObject""); 
----

== Using Salesforce Limits API

With `salesforce:limits` operation you can fetch of API limits from Salesforce and then act upon that data received.
The result of `salesforce:limits` operation is mapped to `org.apache.camel.component.salesforce.api.dto.Limits`
class and can be used in a custom processors or expressions.

For instance, consider that you need to limit the API usage of Salesforce so that 10% of daily API requests is left for
other routes. The body of output message contains an instance of
`org.apache.camel.component.salesforce.api.dto.Limits` object that can be used in conjunction with
Content Based Router and Content Based Router and 
xref:spel-language.adoc[Spring Expression Language (SpEL)] to choose when to perform queries.

Notice how multiplying `1.0` with the integer value held in `body.dailyApiRequests.remaining` makes the expression
evaluate as with floating point arithmetic, without it - it would end up making integral division which would result
with either `0` (some API limits consumed) or `1` (no API limits consumed).

[source,java]
----
from(""direct:querySalesforce"")
    .to(""salesforce:limits"")
    .choice()
    .when(spel(""#{1.0 * body.dailyApiRequests.remaining / body.dailyApiRequests.max < 0.1}""))
        .to(""salesforce:query?..."")
    .otherwise()
        .setBody(constant(""Used up Salesforce API limits, leaving 10% for critical routes""))
    .endChoice()
----

== Working with approvals

All the properties are named exactly the same as in the Salesforce REST API prefixed with `approval.`. You can set
approval properties by setting `approval.PropertyName` of the Endpoint these will be used as template -- meaning
that any property not present in either body or header will be taken from the Endpoint configuration. Or you can set
the approval template on the Endpoint by assigning `approval` property to a reference onto a bean in the Registry.

You can also provide header values using the same `approval.PropertyName` in the incoming message headers.

And finally body can contain one `AprovalRequest` or an `Iterable` of `ApprovalRequest` objects to process as
a batch.

The important thing to remember is the priority of the values specified in these three mechanisms:

. value in body takes precedence before any other
. value in message header takes precedence before template value
. value in template is set if no other value in header or body was given

For example to send one record for approval using values in headers use:

Given a route:

[source,java]
----
from(""direct:example1"")//
        .setHeader(""approval.ContextId"", simple(""${body['contextId']}""))
        .setHeader(""approval.NextApproverIds"", simple(""${body['nextApproverIds']}""))
        .to(""salesforce:approval?""//
            + ""approval.actionType=Submit""//
            + ""&approval.comments=this is a test""//
            + ""&approval.processDefinitionNameOrId=Test_Account_Process""//
            + ""&approval.skipEntryCriteria=true"");
----

You could send a record for approval using:

[source,java]
----
final Map<String, String> body = new HashMap<>();
body.put(""contextId"", accountIds.iterator().next());
body.put(""nextApproverIds"", userId);

final ApprovalResult result = template.requestBody(""direct:example1"", body, ApprovalResult.class);
----

== Using Salesforce Recent Items API

To fetch the recent items use `salesforce:recent` operation. This operation returns an `java.util.List` of
`org.apache.camel.component.salesforce.api.dto.RecentItem` objects (`List<RecentItem>`) that in turn contain
the `Id`, `Name` and `Attributes` (with `type` and `url` properties). You can limit the number of returned items
by specifying `limit` parameter set to maximum number of records to return. For example:

[source,java]
----
from(""direct:fetchRecentItems"")
    to(""salesforce:recent"")
        .split().body()
            .log(""${body.name} at ${body.attributes.url}"");
----

== Using Salesforce Composite API to submit SObject tree

To create up to 200 records including parent-child relationships use `salesforce:composite-tree` operation. This
requires an instance of `org.apache.camel.component.salesforce.api.dto.composite.SObjectTree` in the input 
message and returns the same tree of objects in the output message. The 
`org.apache.camel.component.salesforce.api.dto.AbstractSObjectBase` instances within the tree get updated with
the identifier values (`Id` property) or their corresponding
`org.apache.camel.component.salesforce.api.dto.composite.SObjectNode` is populated with `errors` on failure.

Note that for some records operation can succeed and for some it can fail -- so you need to manually check for errors.

Easiest way to use this functionality is to use the DTOs generated by the `camel-salesforce-maven-plugin`, but you
also have the option of customizing the references that identify the each object in the tree, for instance primary keys
from your database.

Lets look at an example:

[source,java]
----
Account account = ...
Contact president = ...
Contact marketing = ...

Account anotherAccount = ...
Contact sales = ...
Asset someAsset = ...

// build the tree
SObjectTree request = new SObjectTree();
request.addObject(account).addChildren(president, marketing);
request.addObject(anotherAccount).addChild(sales).addChild(someAsset);

final SObjectTree response = template.requestBody(""salesforce:composite-tree"", tree, SObjectTree.class);
final Map<Boolean, List<SObjectNode>> result = response.allNodes()
                                                   .collect(Collectors.groupingBy(SObjectNode::hasErrors));

final List<SObjectNode> withErrors = result.get(true);
final List<SObjectNode> succeeded = result.get(false);

final String firstId = succeeded.get(0).getId();
----

== Using Salesforce Composite API to submit multiple requests in a batch
The Composite API batch operation (`composite-batch`) allows you to accumulate multiple requests in a batch and then
submit them in one go, saving the round trip cost of multiple individual requests. Each response is then received in a
list of responses with the order preserved, so that the n-th requests response is in the n-th place of the response.

NOTE: The results can vary from API to API so the result of the request is given as a `java.lang.Object`. In most cases
the result will be a `java.util.Map` with string keys and values or other `java.util.Map` as value. Requests made in
JSON format hold some type information (i.e. it is known what values are strings and what values are numbers), so in
general those will be more type friendly. Note that the responses will vary between XML and JSON, this is due to the
responses from Salesforce API being different. So be careful if you switch between formats without changing the response
handling code.

Lets look at an example:

[source,java]
----
final String acountId = ...
final SObjectBatch batch = new SObjectBatch(""38.0"");

final Account updates = new Account();
updates.setName(""NewName"");
batch.addUpdate(""Account"", accountId, updates);

final Account newAccount = new Account();
newAccount.setName(""Account created from Composite batch API"");
batch.addCreate(newAccount);

batch.addGet(""Account"", accountId, ""Name"", ""BillingPostalCode"");

batch.addDelete(""Account"", accountId);

final SObjectBatchResponse response = template.requestBody(""salesforce:composite-batch?format=JSON"", batch, SObjectBatchResponse.class);

boolean hasErrors = response.hasErrors(); // if any of the requests has resulted in either 4xx or 5xx HTTP status
final List<SObjectBatchResult> results = response.getResults(); // results of three operations sent in batch

final SObjectBatchResult updateResult = results.get(0); // update result
final int updateStatus = updateResult.getStatusCode(); // probably 204
final Object updateResultData = updateResult.getResult(); // probably null

final SObjectBatchResult createResult = results.get(1); // create result
@SuppressWarnings(""unchecked"")
final Map<String, Object> createData = (Map<String, Object>) createResult.getResult();
final String newAccountId = createData.get(""id""); // id of the new account, this is for JSON, for XML it would be createData.get(""Result"").get(""id"")

final SObjectBatchResult retrieveResult = results.get(2); // retrieve result
@SuppressWarnings(""unchecked"")
final Map<String, Object> retrieveData = (Map<String, Object>) retrieveResult.getResult();
final String accountName = retrieveData.get(""Name""); // Name of the retrieved account, this is for JSON, for XML it would be createData.get(""Account"").get(""Name"")
final String accountBillingPostalCode = retrieveData.get(""BillingPostalCode""); // Name of the retrieved account, this is for JSON, for XML it would be createData.get(""Account"").get(""BillingPostalCode"")

final SObjectBatchResult deleteResult = results.get(3); // delete result
final int updateStatus = deleteResult.getStatusCode(); // probably 204
final Object updateResultData = deleteResult.getResult(); // probably null
----

== Using Salesforce Composite API to submit multiple chained requests
The `composite` operation allows submitting up to 25 requests that can be chained together, for instance identifier
generated in previous request can be used in subsequent request. Individual requests and responses are linked with the
provided _reference_.

NOTE: Composite API supports only JSON payloads.

NOTE: As with the batch API the results can vary from API to API so the result of the request is given as a
`java.lang.Object`. In most cases the result will be a `java.util.Map` with string keys and values or other
`java.util.Map` as value. Requests made in JSON format hold some type information (i.e. it is known what values are
strings and what values are numbers), so in general those will be more type friendly.

Lets look at an example:

[source,java]
----
SObjectComposite composite = new SObjectComposite(""38.0"", true);

// first insert operation via an external id
final Account updateAccount = new TestAccount();
updateAccount.setName(""Salesforce"");
updateAccount.setBillingStreet(""Landmark @ 1 Market Street"");
updateAccount.setBillingCity(""San Francisco"");
updateAccount.setBillingState(""California"");
updateAccount.setIndustry(Account_IndustryEnum.TECHNOLOGY);
composite.addUpdate(""Account"", ""001xx000003DIpcAAG"", updateAccount, ""UpdatedAccount"");

final Contact newContact = new TestContact();
newContact.setLastName(""John Doe"");
newContact.setPhone(""1234567890"");
composite.addCreate(newContact, ""NewContact"");

final AccountContactJunction__c junction = new AccountContactJunction__c();
junction.setAccount__c(""001xx000003DIpcAAG"");
junction.setContactId__c(""@{NewContact.id}"");
composite.addCreate(junction, ""JunctionRecord"");

final SObjectCompositeResponse response = template.requestBody(""salesforce:composite?format=JSON"", composite, SObjectCompositeResponse.class);
final List<SObjectCompositeResult> results = response.getCompositeResponse();

final SObjectCompositeResult accountUpdateResult = results.stream().filter(r -> ""UpdatedAccount"".equals(r.getReferenceId())).findFirst().get()
final int statusCode = accountUpdateResult.getHttpStatusCode(); // should be 200
final Map<String, ?> accountUpdateBody = accountUpdateResult.getBody();

final SObjectCompositeResult contactCreationResult = results.stream().filter(r -> ""JunctionRecord"".equals(r.getReferenceId())).findFirst().get()
----

==  Sending null values to salesforce

By default, SObject fields with null values are not sent to salesforce. In order to
send null values to salesforce, use the `fieldsToNull` property, as follows:

[source,java]
----
accountSObject.getFieldsToNull().add(""Site"");
----

== Generating SOQL query strings

`org.apache.camel.component.salesforce.api.utils.QueryHelper` contains helper
methods to generate SOQL queries. For instance to fetch all custom fields from
_Account_ SObject you can simply generate the SOQL SELECT by invoking:

[source,java]
----
String allCustomFieldsQuery = QueryHelper.queryToFetchFilteredFieldsOf(new Account(), SObjectField::isCustom);
----

== Camel Salesforce Maven Plugin

This Maven plugin generates DTOs for the Camel. 

For obvious security reasons it is recommended that the clientId,
clientSecret, userName and password fields be not set in the pom.xml.  
The plugin should be configured for the rest of the properties, and can
be executed using the following command:

[source,java]
----
mvn camel-salesforce:generate -DcamelSalesforce.clientId=<clientid> -DcamelSalesforce.clientSecret=<clientsecret> \\
    -DcamelSalesforce.userName=<username> -DcamelSalesforce.password=<password>
----

The generated DTOs use Jackson and XStream annotations. All Salesforce
field types are supported. Date and time fields are mapped to
`java.time.ZonedDateTime` by default, and picklist fields are mapped to
generated Java Enumerations.

Please refer to
https://github.com/apache/camel/tree/master/components/camel-salesforce/camel-salesforce-maven-plugin[README.md]
for details on how to generate the DTO.

== Options







// component options: START
The Salesforce component supports 31 options, which are listed below.



[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *authenticationType* (security) | Explicit authentication method to be used, one of USERNAME_PASSWORD, REFRESH_TOKEN or JWT. Salesforce component can auto-determine the authentication method to use from the properties set, set this property to eliminate any ambiguity. |  | AuthenticationType
| *loginConfig* (security) | All authentication configuration in one nested bean, all properties set there can be set directly on the component as well |  | SalesforceLoginConfig
| *instanceUrl* (security) | URL of the Salesforce instance used after authentication, by default received from Salesforce on successful authentication |  | String
| *loginUrl* (security) | *Required* URL of the Salesforce instance used for authentication, by default set to \\https://login.salesforce.com | https://login.salesforce.com | String
| *clientId* (security) | *Required* OAuth Consumer Key of the connected app configured in the Salesforce instance setup. Typically a connected app needs to be configured but one can be provided by installing a package. |  | String
| *clientSecret* (security) | OAuth Consumer Secret of the connected app configured in the Salesforce instance setup. |  | String
| *keystore* (security) | KeyStore parameters to use in OAuth JWT flow. The KeyStore should contain only one entry with private key and certificate. Salesforce does not verify the certificate chain, so this can easily be a selfsigned certificate. Make sure that you upload the certificate to the corresponding connected app. |  | KeyStoreParameters
| *refreshToken* (security) | Refresh token already obtained in the refresh token OAuth flow. One needs to setup a web application and configure a callback URL to receive the refresh token, or configure using the builtin callback at \\https://login.salesforce.com/services/oauth2/success or \\https://test.salesforce.com/services/oauth2/success and then retrive the refresh_token from the URL at the end of the flow. Note that in development organizations Salesforce allows hosting the callback web application at localhost. |  | String
| *userName* (security) | Username used in OAuth flow to gain access to access token. It's easy to get started with password OAuth flow, but in general one should avoid it as it is deemed less secure than other flows. |  | String
| *password* (security) | Password used in OAuth flow to gain access to access token. It's easy to get started with password OAuth flow, but in general one should avoid it as it is deemed less secure than other flows. Make sure that you append security token to the end of the password if using one. |  | String
| *lazyLogin* (security) | If set to true prevents the component from authenticating to Salesforce with the start of the component. You would generally set this to the (default) false and authenticate early and be immediately aware of any authentication issues. | false | boolean
| *config* (common) | Global endpoint configuration - use to set values that are common to all endpoints |  | SalesforceEndpointConfig
| *httpClientProperties* (common) | Used to set any properties that can be configured on the underlying HTTP client. Have a look at properties of SalesforceHttpClient and the Jetty HttpClient for all available options. |  | Map
| *longPollingTransport Properties* (common) | Used to set any properties that can be configured on the LongPollingTransport used by the BayeuxClient (CometD) used by the streaming api |  | Map
| *sslContextParameters* (security) | SSL parameters to use, see SSLContextParameters class for all available options. |  | SSLContextParameters
| *useGlobalSslContext Parameters* (security) | Enable usage of global SSL context parameters | false | boolean
| *httpClientIdleTimeout* (common) | Timeout used by the HttpClient when waiting for response from the Salesforce server. | 10000 | long
| *httpClientConnection Timeout* (common) | Connection timeout used by the HttpClient when connecting to the Salesforce server. | 60000 | long
| *httpProxyHost* (proxy) | Hostname of the HTTP proxy server to use. |  | String
| *httpProxyPort* (proxy) | Port number of the HTTP proxy server to use. |  | Integer
| *httpProxyUsername* (security) | Username to use to authenticate against the HTTP proxy server. |  | String
| *httpProxyPassword* (security) | Password to use to authenticate against the HTTP proxy server. |  | String
| *isHttpProxySocks4* (proxy) | If set to true the configures the HTTP proxy to use as a SOCKS4 proxy. | false | boolean
| *isHttpProxySecure* (security) | If set to false disables the use of TLS when accessing the HTTP proxy. | true | boolean
| *httpProxyIncluded Addresses* (proxy) | A list of addresses for which HTTP proxy server should be used. |  | Set
| *httpProxyExcluded Addresses* (proxy) | A list of addresses for which HTTP proxy server should not be used. |  | Set
| *httpProxyAuthUri* (security) | Used in authentication against the HTTP proxy server, needs to match the URI of the proxy server in order for the httpProxyUsername and httpProxyPassword to be used for authentication. |  | String
| *httpProxyRealm* (security) | Realm of the proxy server, used in preemptive Basic/Digest authentication methods against the HTTP proxy server. |  | String
| *httpProxyUseDigest Auth* (security) | If set to true Digest authentication will be used when authenticating to the HTTP proxy,otherwise Basic authorization method will be used | false | boolean
| *packages* (common) | In what packages are the generated DTO classes. Typically the classes would be generated using camel-salesforce-maven-plugin. Set it if using the generated DTOs to gain the benefit of using short SObject names in parameters/header values. |  | String[]
| *basicPropertyBinding* (advanced) | Whether the component should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | boolean
|===
// component options: END










// endpoint options: START
The Salesforce endpoint is configured using URI syntax:

----
salesforce:operationName:topicName
----

with the following path and query parameters:

=== Path Parameters (2 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *operationName* | The operation to use |  | OperationName
| *topicName* | The name of the topic/channel to use |  | String
|===


=== Query Parameters (45 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *apexMethod* (common) | APEX method name |  | String
| *apexQueryParams* (common) | Query params for APEX method |  | Map
| *apexUrl* (common) | APEX method URL |  | String
| *apiVersion* (common) | Salesforce API version, defaults to SalesforceEndpointConfig.DEFAULT_VERSION |  | String
| *backoffIncrement* (common) | Backoff interval increment for Streaming connection restart attempts for failures beyond CometD auto-reconnect. |  | long
| *batchId* (common) | Bulk API Batch ID |  | String
| *contentType* (common) | Bulk API content type, one of XML, CSV, ZIP_XML, ZIP_CSV |  | ContentType
| *defaultReplayId* (common) | Default replayId setting if no value is found in initialReplayIdMap |  | Long
| *format* (common) | Payload format to use for Salesforce API calls, either JSON or XML, defaults to JSON |  | PayloadFormat
| *httpClient* (common) | Custom Jetty Http Client to use to connect to Salesforce. |  | SalesforceHttpClient
| *includeDetails* (common) | Include details in Salesforce1 Analytics report, defaults to false. |  | Boolean
| *initialReplayIdMap* (common) | Replay IDs to start from per channel name. |  | Map
| *instanceId* (common) | Salesforce1 Analytics report execution instance ID |  | String
| *jobId* (common) | Bulk API Job ID |  | String
| *limit* (common) | Limit on number of returned records. Applicable to some of the API, check the Salesforce documentation. |  | Integer
| *maxBackoff* (common) | Maximum backoff interval for Streaming connection restart attempts for failures beyond CometD auto-reconnect. |  | long
| *notFoundBehaviour* (common) | Sets the behaviour of 404 not found status received from Salesforce API. Should the body be set to NULL NotFoundBehaviour#NULL or should a exception be signaled on the exchange NotFoundBehaviour#EXCEPTION - the default. |  | NotFoundBehaviour
| *notifyForFields* (common) | Notify for fields, options are ALL, REFERENCED, SELECT, WHERE |  | NotifyForFieldsEnum
| *notifyForOperationCreate* (common) | Notify for create operation, defaults to false (API version = 29.0) |  | Boolean
| *notifyForOperationDelete* (common) | Notify for delete operation, defaults to false (API version = 29.0) |  | Boolean
| *notifyForOperations* (common) | Notify for operations, options are ALL, CREATE, EXTENDED, UPDATE (API version 29.0) |  | NotifyForOperationsEnum
| *notifyForOperationUndelete* (common) | Notify for un-delete operation, defaults to false (API version = 29.0) |  | Boolean
| *notifyForOperationUpdate* (common) | Notify for update operation, defaults to false (API version = 29.0) |  | Boolean
| *objectMapper* (common) | Custom Jackson ObjectMapper to use when serializing/deserializing Salesforce objects. |  | ObjectMapper
| *rawPayload* (common) | Use raw payload String for request and response (either JSON or XML depending on format), instead of DTOs, false by default | false | boolean
| *reportId* (common) | Salesforce1 Analytics report Id |  | String
| *reportMetadata* (common) | Salesforce1 Analytics report metadata for filtering |  | ReportMetadata
| *resultId* (common) | Bulk API Result ID |  | String
| *sObjectBlobFieldName* (common) | SObject blob field name |  | String
| *sObjectClass* (common) | Fully qualified SObject class name, usually generated using camel-salesforce-maven-plugin |  | String
| *sObjectFields* (common) | SObject fields to retrieve |  | String
| *sObjectId* (common) | SObject ID if required by API |  | String
| *sObjectIdName* (common) | SObject external ID field name |  | String
| *sObjectIdValue* (common) | SObject external ID field value |  | String
| *sObjectName* (common) | SObject name if required or supported by API |  | String
| *sObjectQuery* (common) | Salesforce SOQL query string |  | String
| *sObjectSearch* (common) | Salesforce SOSL search string |  | String
| *updateTopic* (common) | Whether to update an existing Push Topic when using the Streaming API, defaults to false | false | boolean
| *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | boolean
| *replayId* (consumer) | The replayId value to use when subscribing |  | Long
| *exceptionHandler* (consumer) | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this option is not in use. By default the consumer will deal with exceptions, that will be logged at WARN or ERROR level and ignored. |  | ExceptionHandler
| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. |  | ExchangePattern
| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing. | false | boolean
| *basicPropertyBinding* (advanced) | Whether the endpoint should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | boolean
| *synchronous* (advanced) | Sets whether synchronous processing should be strictly used, or Camel is allowed to use asynchronous processing (if supported). | false | boolean
|===
// endpoint options: END
// spring-boot-auto-configure options: START
== Spring Boot Auto-Configuration

When using Spring Boot make sure to use the following Maven dependency to have support for auto configuration:

[source,xml]
----
<dependency>
  <groupId>org.apache.camel</groupId>
  <artifactId>camel-salesforce-starter</artifactId>
  <version>x.x.x</version>
  <!-- use the same version as your Camel core version -->
</dependency>
----


The component supports 86 options, which are listed below.



[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *camel.component.salesforce.authentication-type* | Explicit authentication method to be used, one of USERNAME_PASSWORD, REFRESH_TOKEN or JWT. Salesforce component can auto-determine the authentication method to use from the properties set, set this property to eliminate any ambiguity. |  | AuthenticationType
| *camel.component.salesforce.basic-property-binding* | Whether the component should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | Boolean
| *camel.component.salesforce.client-id* | OAuth Consumer Key of the connected app configured in the Salesforce instance setup. Typically a connected app needs to be configured but one can be provided by installing a package. |  | String
| *camel.component.salesforce.client-secret* | OAuth Consumer Secret of the connected app configured in the Salesforce instance setup. |  | String
| *camel.component.salesforce.config.apex-method* | APEX method name |  | String
| *camel.component.salesforce.config.apex-query-params* | Query params for APEX method |  | Map
| *camel.component.salesforce.config.apex-url* | APEX method URL |  | String
| *camel.component.salesforce.config.api-version* | Salesforce API version, defaults to SalesforceEndpointConfig.DEFAULT_VERSION |  | String
| *camel.component.salesforce.config.approval* | The approval request for Approval API. |  | ApprovalRequest
| *camel.component.salesforce.config.approval-action-type* | Represents the kind of action to take: Submit, Approve, or Reject. |  | ApprovalRequest$Action
| *camel.component.salesforce.config.approval-comments* | The comment to add to the history step associated with this request. |  | String
| *camel.component.salesforce.config.approval-context-actor-id* | The ID of the submitter who’s requesting the approval record. |  | String
| *camel.component.salesforce.config.approval-context-id* | The ID of the item that is being acted upon. |  | String
| *camel.component.salesforce.config.approval-next-approver-ids* | If the process requires specification of the next approval, the ID of the user to be assigned the next request. |  | List
| *camel.component.salesforce.config.approval-process-definition-name-or-id* | The developer name or ID of the process definition. |  | String
| *camel.component.salesforce.config.approval-skip-entry-criteria* | Determines whether to evaluate the entry criteria for the process (true) or not (false) if the process definition name or ID isn’t null. If the process definition name or ID isn’t specified, this argument is ignored, and standard evaluation is followed based on process order. By default, the entry criteria isn’t skipped if it’s not set by this request. |  | Boolean
| *camel.component.salesforce.config.backoff-increment* | Backoff interval increment for Streaming connection restart attempts for failures beyond CometD auto-reconnect. |  | Long
| *camel.component.salesforce.config.batch-id* | Bulk API Batch ID |  | String
| *camel.component.salesforce.config.content-type* | Bulk API content type, one of XML, CSV, ZIP_XML, ZIP_CSV |  | ContentType
| *camel.component.salesforce.config.default-replay-id* | Default replayId setting if no value is found in {@link #initialReplayIdMap} |  | Long
| *camel.component.salesforce.config.format* | Payload format to use for Salesforce API calls, either JSON or XML, defaults to JSON |  | PayloadFormat
| *camel.component.salesforce.config.http-client* | Custom Jetty Http Client to use to connect to Salesforce. |  | SalesforceHttpClient
| *camel.component.salesforce.config.include-details* | Include details in Salesforce1 Analytics report, defaults to false. |  | Boolean
| *camel.component.salesforce.config.initial-replay-id-map* | Replay IDs to start from per channel name. |  | Map
| *camel.component.salesforce.config.instance-id* | Salesforce1 Analytics report execution instance ID |  | String
| *camel.component.salesforce.config.job-id* | Bulk API Job ID |  | String
| *camel.component.salesforce.config.limit* | Limit on number of returned records. Applicable to some of the API, check the Salesforce documentation. |  | Integer
| *camel.component.salesforce.config.max-backoff* | Maximum backoff interval for Streaming connection restart attempts for failures beyond CometD auto-reconnect. |  | Long
| *camel.component.salesforce.config.not-found-behaviour* | Sets the behaviour of 404 not found status received from Salesforce API. Should the body be set to NULL {@link NotFoundBehaviour#NULL} or should a exception be signaled on the exchange {@link NotFoundBehaviour#EXCEPTION} - the default. |  | NotFoundBehaviour
| *camel.component.salesforce.config.notify-for-fields* | Notify for fields, options are ALL, REFERENCED, SELECT, WHERE |  | NotifyForFieldsEnum
| *camel.component.salesforce.config.notify-for-operation-create* | Notify for create operation, defaults to false (API version >= 29.0) |  | Boolean
| *camel.component.salesforce.config.notify-for-operation-delete* | Notify for delete operation, defaults to false (API version >= 29.0) |  | Boolean
| *camel.component.salesforce.config.notify-for-operation-undelete* | Notify for un-delete operation, defaults to false (API version >= 29.0) |  | Boolean
| *camel.component.salesforce.config.notify-for-operation-update* | Notify for update operation, defaults to false (API version >= 29.0) |  | Boolean
| *camel.component.salesforce.config.notify-for-operations* | Notify for operations, options are ALL, CREATE, EXTENDED, UPDATE (API version < 29.0) |  | NotifyForOperationsEnum
| *camel.component.salesforce.config.object-mapper* | Custom Jackson ObjectMapper to use when serializing/deserializing Salesforce objects. |  | ObjectMapper
| *camel.component.salesforce.config.raw-payload* | Use raw payload {@link String} for request and response (either JSON or XML depending on {@code format}), instead of DTOs, false by default | false | Boolean
| *camel.component.salesforce.config.report-id* | Salesforce1 Analytics report Id |  | String
| *camel.component.salesforce.config.report-metadata* | Salesforce1 Analytics report metadata for filtering |  | ReportMetadata
| *camel.component.salesforce.config.result-id* | Bulk API Result ID |  | String
| *camel.component.salesforce.config.s-object-blob-field-name* | SObject blob field name |  | String
| *camel.component.salesforce.config.s-object-class* | Fully qualified SObject class name, usually generated using camel-salesforce-maven-plugin |  | String
| *camel.component.salesforce.config.s-object-fields* | SObject fields to retrieve |  | String
| *camel.component.salesforce.config.s-object-id* | SObject ID if required by API |  | String
| *camel.component.salesforce.config.s-object-id-name* | SObject external ID field name |  | String
| *camel.component.salesforce.config.s-object-id-value* | SObject external ID field value |  | String
| *camel.component.salesforce.config.s-object-name* | SObject name if required or supported by API |  | String
| *camel.component.salesforce.config.s-object-query* | Salesforce SOQL query string |  | String
| *camel.component.salesforce.config.s-object-search* | Salesforce SOSL search string |  | String
| *camel.component.salesforce.config.update-topic* | Whether to update an existing Push Topic when using the Streaming API, defaults to false | false | Boolean
| *camel.component.salesforce.enabled* | Enable salesforce component | true | Boolean
| *camel.component.salesforce.http-client-connection-timeout* | Connection timeout used by the HttpClient when connecting to the Salesforce server. | 60000 | Long
| *camel.component.salesforce.http-client-idle-timeout* | Timeout used by the HttpClient when waiting for response from the Salesforce server. | 10000 | Long
| *camel.component.salesforce.http-client-properties* | Used to set any properties that can be configured on the underlying HTTP client. Have a look at properties of SalesforceHttpClient and the Jetty HttpClient for all available options. |  | Map
| *camel.component.salesforce.http-proxy-auth-uri* | Used in authentication against the HTTP proxy server, needs to match the URI of the proxy server in order for the httpProxyUsername and httpProxyPassword to be used for authentication. |  | String
| *camel.component.salesforce.http-proxy-excluded-addresses* | A list of addresses for which HTTP proxy server should not be used. |  | Set
| *camel.component.salesforce.http-proxy-host* | Hostname of the HTTP proxy server to use. |  | String
| *camel.component.salesforce.http-proxy-included-addresses* | A list of addresses for which HTTP proxy server should be used. |  | Set
| *camel.component.salesforce.http-proxy-password* | Password to use to authenticate against the HTTP proxy server. |  | String
| *camel.component.salesforce.http-proxy-port* | Port number of the HTTP proxy server to use. |  | Integer
| *camel.component.salesforce.http-proxy-realm* | Realm of the proxy server, used in preemptive Basic/Digest authentication methods against the HTTP proxy server. |  | String
| *camel.component.salesforce.http-proxy-use-digest-auth* | If set to true Digest authentication will be used when authenticating to the HTTP proxy,otherwise Basic authorization method will be used | false | Boolean
| *camel.component.salesforce.http-proxy-username* | Username to use to authenticate against the HTTP proxy server. |  | String
| *camel.component.salesforce.instance-url* | URL of the Salesforce instance used after authentication, by default received from Salesforce on successful authentication |  | String
| *camel.component.salesforce.is-http-proxy-secure* | If set to false disables the use of TLS when accessing the HTTP proxy. | true | Boolean
| *camel.component.salesforce.is-http-proxy-socks4* | If set to true the configures the HTTP proxy to use as a SOCKS4 proxy. | false | Boolean
| *camel.component.salesforce.keystore* | KeyStore parameters to use in OAuth JWT flow. The KeyStore should contain only one entry with private key and certificate. Salesforce does not verify the certificate chain, so this can easily be a selfsigned certificate. Make sure that you upload the certificate to the corresponding connected app. The option is a org.apache.camel.support.jsse.KeyStoreParameters type. |  | String
| *camel.component.salesforce.lazy-login* | If set to true prevents the component from authenticating to Salesforce with the start of the component. You would generally set this to the (default) false and authenticate early and be immediately aware of any authentication issues. | false | Boolean
| *camel.component.salesforce.login-config.client-id* | Salesforce connected application Consumer Key |  | String
| *camel.component.salesforce.login-config.client-secret* | Salesforce connected application Consumer Secret |  | String
| *camel.component.salesforce.login-config.instance-url* | Configuration object for Salesforce login properties |  | String
| *camel.component.salesforce.login-config.keystore* | Keystore parameters for keystore containing certificate and private key needed for OAuth 2.0 JWT Bearer Token Flow. |  | KeyStoreParameters
| *camel.component.salesforce.login-config.lazy-login* | Flag to enable/disable lazy OAuth, default is false. When enabled, OAuth token retrieval or generation is not done until the first API call | false | Boolean
| *camel.component.salesforce.login-config.login-url* | Salesforce login URL, defaults to \\https://login.salesforce.com | https://login.salesforce.com | String
| *camel.component.salesforce.login-config.password* | Salesforce account password |  | String
| *camel.component.salesforce.login-config.refresh-token* | Salesforce connected application Consumer token |  | String
| *camel.component.salesforce.login-config.type* | Salesforce connected application Consumer token |  | AuthenticationType
| *camel.component.salesforce.login-config.user-name* | Salesforce account user name |  | String
| *camel.component.salesforce.login-url* | URL of the Salesforce instance used for authentication, by default set to \\https://login.salesforce.com | https://login.salesforce.com | String
| *camel.component.salesforce.long-polling-transport-properties* | Used to set any properties that can be configured on the LongPollingTransport used by the BayeuxClient (CometD) used by the streaming api |  | Map
| *camel.component.salesforce.packages* | In what packages are the generated DTO classes. Typically the classes would be generated using camel-salesforce-maven-plugin. Set it if using the generated DTOs to gain the benefit of using short SObject names in parameters/header values. |  | String[]
| *camel.component.salesforce.password* | Password used in OAuth flow to gain access to access token. It's easy to get started with password OAuth flow, but in general one should avoid it as it is deemed less secure than other flows. Make sure that you append security token to the end of the password if using one. |  | String
| *camel.component.salesforce.refresh-token* | Refresh token already obtained in the refresh token OAuth flow. One needs to setup a web application and configure a callback URL to receive the refresh token, or configure using the builtin callback at \\https://login.salesforce.com/services/oauth2/success or \\https://test.salesforce.com/services/oauth2/success and then retrive the refresh_token from the URL at the end of the flow. Note that in development organizations Salesforce allows hosting the callback web application at localhost. |  | String
| *camel.component.salesforce.ssl-context-parameters* | SSL parameters to use, see SSLContextParameters class for all available options. The option is a org.apache.camel.support.jsse.SSLContextParameters type. |  | String
| *camel.component.salesforce.use-global-ssl-context-parameters* | Enable usage of global SSL context parameters | false | Boolean
| *camel.component.salesforce.user-name* | Username used in OAuth flow to gain access to access token. It's easy to get started with password OAuth flow, but in general one should avoid it as it is deemed less secure than other flows. |  | String
|===
// spring-boot-auto-configure options: END
",12131,False,2167.961991122101,median
":source-highlighter: pygments
:pygments-style: emacs
:icons: font

Groovy 4 builds upon existing features of earlier versions of Groovy.
In addition, it incorporates numerous new features and streamlines various legacy aspects of the Groovy codebase.

[width=""80%"",align=""center""]
|===
a| NOTE: _WARNING:_
Some features of Groovy 4 are designated as ""incubating"".
Where appropriate, related classes or APIs of these features may be annotated with the `@Incubating` annotation. +
Caution should be exercised when using incubating features as the details may change
in subsequent versions of Groovy.
We don't recommend using incubating features for production systems.
|===


[[Groovy4.0-naming-changes]]
== Important naming/structuring changes

[[Groovy4.0-maven-coordinates]]
=== Maven coordinate change

In Groovy 4.0, the _groupId_ of the maven coordinates for Groovy have changed from `org.codehaus.groovy`
to `org.apache.groovy`. Please update your Gradle/Maven/other build settings appropriately.

[[Groovy4.0-split-package-renaming]]
=== Legacy package removal

The Java Platform Module System (JPMS) requires that classes in distinct modules
have distinct package names (known as the ""split packaging requirement"").
Groovy has its own ""modules"" that weren't
historically structured according to this requirement.

Groovy 3 provided duplicate versions of numerous classes (in old and new packages)
to allow Groovy users to migrate towards the new JPMS compliant package names.
See the link:http://groovy-lang.org/releasenotes/groovy-3.0.html#Groovy3.0releasenotes-Splitpackages[Groovy 3 release notes]
for more details. Groovy 4 no longer provides the duplicate legacy classes.

In short, time to stop using `groovy.util.XmlSlurper` and start using `groovy.xml.XmlSlurper`.
Similarly, you should now be using `groovy.xml.XmlParser`, `groovy.ant.AntBuilder`, `groovy.test.GroovyTestCase`
and the other classes mentioned in the prior mentioned Groovy 3 release notes.

[[Groovy4.0-module-changes]]
=== Module changes for groovy-all

Based on user feedback and download statistics, we rejigged which modules are included in the `groovy-all` pom
(link:https://issues.apache.org/jira/browse/GROOVY-9647[GROOVY-9647]).
The `groovy-yaml` module is fairly widely used and is now included in `groovy-all`.
The `groovy-testng` module is less widely used and is no longer included in `groovy-all`.
Please adjust your build script dependencies if needed.
If you are using the Groovy distribution, no changes are required since it
includes the optional modules.

[[Groovy4.0-new]]
== New features

[[Groovy4.0-switch-expressions]]
=== Switch expressions

Groovy has always had a very powerful switch _statement_, but there are times when
a switch _expression_ would be more convenient.

In switch statements, case branches with fallthrough behavior are usually much rarer
than branches which handle one case and then break out of the switch.
The `break` statements clutter the code as shown here.

[source,groovy]
--------------------------------------
def result
switch(i) {
  case 0: result = 'zero'; break
  case 1: result = 'one'; break
  case 2: result = 'two'; break
  default: throw new IllegalStateException('unknown number')
}
--------------------------------------

A common trick is to introduce a method to wrap the switch.
In simple cases, multiple statements might reduce to a single return statement.
The `break` statements are gone, albeit replaced by `return` statements.

[source,groovy]
--------------------------------------
def stringify(int i) {
  switch(i) {
    case 0: return 'zero'
    case 1: return 'one'
    case 2: return 'two'
    default: throw new IllegalStateException('unknown number')
  }
}

def result = stringify(i)
--------------------------------------

Switch expressions (borrowing heavily from Java) provide a nicer alternative still:

[source,groovy]
--------------------------------------
def result = switch(i) {
    case 0 -> 'zero'
    case 1 -> 'one'
    case 2 -> 'two'
    default -> throw new IllegalStateException('unknown number')
}
--------------------------------------

Here, the right-hand side (following the `\\->`) must be a single expression. If multiple statements are needed, a block can be used.
For example, the first case branch from the previous example could be re-written as:

[source,groovy]
--------------------------------------
    case 0 -> { def a = 'ze'; def b = 'ro'; a + b }
--------------------------------------

Switch expressions can also use the traditional `:` form with multiple statements
but in this case, a `yield` statement must be executed.

[source,groovy]
--------------------------------------
def result = switch(i) {
    case 0:
        def a = 'ze'
        def b = 'ro'
        if (true) yield a + b
        else yield b + a
    case 1:
        yield 'one'
    case 2:
        yield 'two'
    default:
        throw new IllegalStateException('unknown number')
}
--------------------------------------

The `\\->` and `:` forms cannot be mixed.

All of the normal Groovy case expressions are still catered for, e.g.:

[source,groovy]
--------------------------------------
class Custom {
  def isCase(o) { o == -1 }
}

class Coord {
  int x, y
}

def items = [10, -1, 5, null, 41, 3.5f, 38, 99, new Coord(x: 4, y: 5), 'foo']
def result = items.collect { a ->
  switch(a) {
    case null -> 'null'
    case 5 -> 'five'
    case new Custom() -> 'custom'
    case 0..15 -> 'range'
    case [37, 41, 43] -> 'prime'
    case Float -> 'float'
    case { it instanceof Number && it % 2 == 0 } -> 'even'
    case Coord -> a.with { ""x: $x, y: $y"" }
    case ~/../ -> 'two chars'
    default -> 'none of the above'
  }
}

assert result == ['range', 'custom', 'five', 'null', 'prime', 'float',
                  'even', 'two chars', 'x: 4, y: 5', 'none of the above']
--------------------------------------

Switch expressions are particularly handy for cases where
the visitor pattern might have been traditionally used, e.g.:

[source,groovy]
--------------------------------------
import groovy.transform.Immutable

interface Expr { }
@Immutable class IntExpr implements Expr { int i }
@Immutable class NegExpr implements Expr { Expr n }
@Immutable class AddExpr implements Expr { Expr left, right }
@Immutable class MulExpr implements Expr { Expr left, right }

int eval(Expr e) {
    e.with {
        switch(it) {
            case IntExpr -> i
            case NegExpr -> -eval(n)
            case AddExpr -> eval(left) + eval(right)
            case MulExpr -> eval(left) * eval(right)
            default -> throw new IllegalStateException()
        }
    }
}

@Newify(pattern="".*Expr"")
def test() {
    def exprs = [
        IntExpr(4),
        NegExpr(IntExpr(4)),
        AddExpr(IntExpr(4), MulExpr(IntExpr(3), IntExpr(2))), // 4 + (3*2)
        MulExpr(IntExpr(4), AddExpr(IntExpr(3), IntExpr(2)))  // 4 * (3+2)
    ]
    assert exprs.collect { eval(it) } == [4, -4, 10, 20]
}

test()
--------------------------------------

==== Differences to Java

* Currently, there is no requirement that all possible values of the switch target
are covered exhaustively by case branches.
If no `default` branch is present, an
implicit one returning `null` is added.
For this reason, in contexts where `null`
is not desired, e.g.&nbsp;storing the result in a primitive, or constructing
a non-nullable `Optional`, then an explicit `default` should be given, e.g.:
+
[source,groovy]
--------------------------------------
// default branch avoids GroovyCastException
int i = switch(s) {
    case 'one' -> 1
    case 'two' -> 2
    default -> 0
}

// default branch avoids NullPointerException
Optional.of(switch(i) {
    case 1 -> 'one'
    case 2 -> 'two'
    default -> 'buckle my shoe'
})
--------------------------------------
+
In future Groovy versions, or perhaps through tooling like CodeNarc,
we expect to support the stricter checking of exhaustive case branches similar to Java.
This may be implemented automatically when using Groovy's static nature
or via an additional optional type checking extension.
For this reason, developers may wish to not rely on the automatic
default branch returning `null` and instead provide their own default or exhaustively
cover all branches.

[[Groovy4.0-sealed-types]]
=== Sealed types

Sealed classes, interfaces and traits restrict which other classes or interfaces may extend or implement them.
Groovy supports using a `sealed` keyword or a `@Sealed` annotation when writing a sealed type.
The permitted subclasses for a sealed type can be given explicitly
(using a `permits` clause with the `sealed` keyword or a `permittedSubclasses` annotation attribute for `@Sealed`), or automatically detected if compiling the relevant types
all at the same time.
For further details, see (link:https://groovy.apache.org/wiki/GEP-13.html[GEP-13]) and the
Groovy documentation.

As a motivating example, sealed hierarchies can be useful when specifying
Algebraic or Abstract Data Types (ADTs) as shown in the following example
(using the annotation syntax):

[source,groovy]
--------------------------------------
import groovy.transform.*

@Sealed interface Tree<T> {}
@Singleton final class Empty implements Tree {
    String toString() { 'Empty' }
}
@Canonical final class Node<T> implements Tree<T> {
    T value
    Tree<T> left, right
}

Tree<Integer> tree = new Node<>(42, new Node<>(0, Empty.instance, Empty.instance), Empty.instance)
assert tree.toString() == 'Node(42, Node(0, Empty, Empty), Empty)'
--------------------------------------

As another example, sealed types can be useful when creating enhanced enum-like hierarchies. Here is a weather example using the `sealed` keyword:

[source,groovy]
--------------------------------------
sealed abstract class Weather { }
class Rainy extends Weather { Integer rainfall }
class Sunny extends Weather { Integer temp }
class Cloudy extends Weather { Integer uvIndex }
def threeDayForecast = [
    new Rainy(rainfall: 12),
    new Sunny(temp: 35),
    new Cloudy(uvIndex: 6)
]
--------------------------------------

==== Differences to Java

* The `non-sealed` keyword (or `@NonSealed` annotation) isn't required to indicate that
subclasses are open to extension. A future version of Codenarc may have a rule that allows
Groovy developers who wish to follow that Java practice if they desire. Having said that,
keeping restrictions on extension (by using `final` or `sealed`) will lead to more places
where future type checking can check for exhaustive use of types (e.g. switch expressions).
* Groovy uses the `@Sealed` annotation to support sealed classes for JDK8+.
These are known as _emulated_ sealed classes.
Such classes will be recognised as sealed by the Groovy
compiler but not the Java compiler.
For JDK17+, Groovy will write sealed class information into the bytecode.
These are known as _native_ sealed classes.
See the `@SealedOptions` annotation to have further control over whether
emulated or native sealed classes are created.
* Java has requirements around classes within a sealed hierarchy being in the same module or
same package. Groovy currently doesn't enforce this requirement but may do so in a future version.
In particular, it is likely _native_ sealed classes (see previous dot point) will need this requirement.

[width=""80%"",align=""center""]
|===
a| NOTE: _TIP:_
Sealed classes can use the `sealed` (and related) keywords
or the `@Sealed` (and related) annotations.
The keyword style is generally more succinct, however
if you have an editor or other tooling which doesn't yet provide
support for the new keywords, you might prefer the annotation style.
The syntax used for writing your sealed classes doesn't impact whether
_native_ or _emulated_ sealed classes are created.
This is determined solely by the bytecode version and options
given in `@SealedOptions`. Note that it is fine to use `@SealedOptions`
annotation on a class defined using the keyword style.
|===

[width=""80%"",align=""center""]
|===
a| NOTE: _WARNING:_
Sealed classes are an _incubating_ feature.
While we don't expect large changes, some minor details
may change in future Groovy versions.
|===

[[Groovy4.0-new-records]]
=== Records and record-like classes (incubating)

Java 14 and 15 introduced _records_ as a _preview_ feature and for Java 16 records graduated from preview status.
As per this https://www.infoq.com/articles/java-14-feature-spotlight/[records spotlight article],
records ""model _plain data aggregates_ with less ceremony"".

Groovy has features like the `@Immutable` and `@Canonical` AST transformations which already support
modeling data aggregates with less ceremony, and while these features overlap to some degree
with the design of records, they are not a direct equivalent.
Records are closest to `@Immutable` with a few variations added to the mix.

Groovy 4 adds support for _native_ records for JDK16+ and also for
record-like classes (also known as _emulated_ records) on earlier JDKs.
Record-like classes have all the features of native records but don't have the same information at the
bytecode level as native records, and so won't be recognised as records by a Java compiler in cross-language
integration scenarios.
See the `@RecordOptions` annotation for further control over whether
_emulated_ or _native_ records are created.

Record-like classes look somewhat similar to classes generated when using Groovy's `@Immutable` AST transform.
That transform is itself a meta-annotation (also known as annotation collector)
which combines more fine-grained features. It is relatively simple to provide a record-like re-mix
of those features and that is what Groovy 4 provides with its record implementation.

You can write a record definition as follows:

[source,groovy]
--------------------------------------
record Cyclist(String firstName, String lastName) { }
--------------------------------------

Or in this longer form (which is more or less what the above single-line definition is converted into):

[source,groovy]
--------------------------------------
@groovy.transform.RecordType
class Cyclist {
    String firstName
    String lastName
}
--------------------------------------

And you'd use it as per the following example:

[source,groovy]
--------------------------------------
def richie = new Cyclist('Richie', 'Porte')
--------------------------------------

This produces a class with the following characteristics:

* it is implicitly final
* it has a private final field `firstName` with an accessor method `firstName()`; ditto for `lastName`
* it has a default `Cyclist(String, String)` constructor
* it has a default `serialVersionUID` of 0L
* it has implicit `toString()`, `equals()` and `hashCode()` methods

The `@RecordType` annotation combines the following transforms/marker annotations:

[source,groovy]
--------------------------------------
@RecordBase
@RecordOptions
@TupleConstructor(namedVariant = true, force = true, defaultsMode = DefaultsMode.AUTO)
@PropertyOptions
@KnownImmutable
@POJO
@CompileStatic
--------------------------------------

The `RecordBase` annotation also provides
`@ToString` and `@EqualsAndHashCode` functionality, either delegating
to those transforms or providing special native record equivalents.

We are keen for further feedback on how Groovy users might use
records or record-like structures.

[width=""80%"",align=""center""]
|===
a| NOTE: _TIP:_
You can use the `record` keyword
or the `@RecordType` annotation for either _native_ or _emulated_ records.
The keyword style is generally more succinct, however
if you have an editor or other tooling which doesn't yet provide
support for the new keyword and compact syntax, you might prefer the annotation style.
The syntax used for writing your records doesn't impact whether
_native_ or _emulated_ records are created.
This is determined solely by the bytecode version and options
given in `@RecordOptions`. Note that it is fine to use `@RecordOptions`
annotation on a record defined using the keyword style.
|===

[width=""80%"",align=""center""]
|===
a| NOTE: _WARNING:_
Records are an _incubating_ feature.
While we don't expect large changes, some minor details
may change in future Groovy versions.
|===

[[Groovy4.0-new-checkers]]
=== Built-in type checkers

Groovy's static nature includes an extensible type-checking mechanism.
This mechanism allows users to:

* selectively weaken type checking to allow more dynamic style code to parse static checking, or
* strengthen type checking, allowing Groovy to be much stricter than Java in scenarios where that is desirable

So far, we know this feature has been used internally by companies (e.g. type-checked DSLs),
but we haven't seen widespread sharing of type checker extensions.
From Groovy 4, we bundle some select type checkers within the optional
`groovy-typecheckers` module,
to encourage further use of this feature.

The first inclusion is a checker for regular expressions. Consider the following code:

[source,groovy]
--------------------------------------
def newYearsEve = '2020-12-31'
def matcher = newYearsEve =~ /(\\d{4})-(\\d{1,2})-(\\d{1,2}/
--------------------------------------

This passes compilation but fails at runtime with a `PatternSyntaxException`
since we ""accidentally"" left off the final closing bracket.
We can get this feedback at compilation time using the new checker as follows:

[source,groovy]
--------------------------------------
import groovy.transform.TypeChecked

@TypeChecked(extensions = 'groovy.typecheckers.RegexChecker')
def whenIs2020Over() {
    def newYearsEve = '2020-12-31'
    def matcher = newYearsEve =~ /(\\d{4})-(\\d{1,2})-(\\d{1,2}/
}
--------------------------------------

Which gives this expected compilation error:

--------------------------------------
1 compilation error:
[Static type checking] - Bad regex: Unclosed group near index 26
(\\d{4})-(\\d{1,2})-(\\d{1,2}
 at line: 6, column: 19
--------------------------------------

As usual, Groovy's compiler customization mechanisms would allow you to
simplify application of such checkers, e.g. make it apply globally
using a compiler configuration script, as just one example.

We welcome further feedback on additional type checker extensions to include within Groovy.

[[Groovy4.0-new-macro-builtins]]
=== Built-in macro methods

Groovy macros were introduced in Groovy 2.5 to make it easier to create AST transforms
and other code which manipulates the compiler AST data structures.
One part of macros, known as macro methods, allows what looks like a global method call
to be replaced with transformed code during compilation.

A bit like type checker extensions, we know this feature has been used in numerous places,
but so far, we haven't seen widespread sharing of macro methods.
From Groovy 4, we bundle some select macro methods within the optional
`groovy-macro-library` module,
to encourage further use of this feature.

The first inclusions assist with old-school debugging (poor man's serialization?).
Suppose during coding you have defined numerous variables:

[source,groovy]
--------------------------------------
def num = 42
def list = [1 ,2, 3]
def range = 0..5
def string = 'foo'
--------------------------------------

Suppose now you want to print those out for debugging purposes.
You could write some appropriate `println` statements and maybe sprinkle in some
calls to `format()`. You might even have an IDE help you do that.
Alternatively, the `SV` and NV` macro methods come to the rescue.

The `SV` macro method creates a String (actually a gapi:groovy.lang.GString)
which contains the variables name and value.
Here is an example:

[source,groovy]
--------------------------------------
println SV(num, list, range, string)
--------------------------------------

which outputs:

--------------------------------------
num=42, list=[1, 2, 3], range=[0, 1, 2, 3, 4, 5], string=foo
--------------------------------------

Here, the `SV` macro method springs into action during the compilation process.
The compiler replaces the apparent global `SV` method call with an expression
which combines the names and `toString()` values of the supplied variables.

Two other variations exist. `SVI` calls Groovy's `inspect()` method rather than
`toString()` and `SVD` calls Groovy's `dump()` method. So this code:

[source,groovy]
--------------------------------------
println SVI(range)
--------------------------------------

produces the following output:

--------------------------------------
range=0..5
--------------------------------------

And this code:

[source,groovy]
--------------------------------------
println SVD(range)
--------------------------------------

yields:

--------------------------------------
range=<groovy.lang.IntRange@14 from=0 to=5 reverse=false inclusiveRight=true inclusiveLeft=true modCount=0>
--------------------------------------

The `NV` macro method provides similar functionality to `SV` but instead of
creating a ""string"", it creates a gapi:groovy.lang.NamedValue which lets
you further process the name and value information. Here is an example:

[source,groovy]
--------------------------------------
def r = NV(range)
assert r instanceof NamedValue
assert r.name == 'range' && r.val == 0..5
--------------------------------------

There is also a `NVL` macro method which creates a list of `NamedValue` instances.

[source,groovy]
--------------------------------------
def nsl = NVL(num, string)
assert nsl*.name == ['num', 'string']
assert nsl*.val == [42, 'foo']
--------------------------------------

We welcome further feedback on additional macro methods to include within Groovy.
If you do enable this optional module but want to limit which macro methods are enabled,
there is now a mechanism to disable individual macro methods (and extension methods)
link:https://issues.apache.org/jira/browse/GROOVY-9675[GROOVY-9675].

[[Groovy4.0-new-javashell]]
=== JavaShell (incubating)

A Java equivalent of GroovyShell, allowing to more easily work with snippets of Java code.
As an example, the following snippet shows compiling a _record_ (JDK14) and checking its `toString` with Groovy:

[source,groovy]
--------------------------------------
import org.apache.groovy.util.JavaShell
def opts = ['--enable-preview', '--release', '14']
def src = 'record Coord(int x, int y) {}'
Class coordClass = new JavaShell().compile('Coord', opts, src)
assert coordClass.newInstance(5, 10).toString() == 'Coord[x=5, y=10]'
--------------------------------------

This feature is used in numerous places within the Groovy codebase for testing purposes.
Various code snippets are compiled using both Java and Groovy to ensure the compiler is behaving as intended.
We also use this feature to provide a productivity enhancement for polyglot developers allowing
Java code to be compiled and/or run (as Java) from within the Groovy Console:

image:img/groovyconsole_run_as_java.png[image] +

[[Groovy4.0-new-pojo]]
=== POJO Annotation (incubating)

Groovy supports both dynamic and static natures.
Dynamic Groovy's power and flexibility comes from making (potentially extensive) use of the runtime.
Static Groovy relies on the runtime library much less. Many method calls will have bytecode
corresponding to direct JVM method calls (similar to Java bytecode)
while the Groovy runtime is often bypassed altogether.
But even for static Groovy, hard-links to the Groovy jars remain.
All Groovy classes still implement the `GroovyObject` interface (and so have methods like `getMetaClass` and `invokeMethod`)
and there are some other places which call into the Groovy runtime.

The `@POJO` marker interface is used to indicate that the generated class is more like a plain old Java object
than an enhanced Groovy object. The annotation is currently ignored unless combined with `@CompileStatic`.
For such a class, the compiler won't generate methods typically needed by Groovy, e.g. `getMetaClass()`.
This feature is typically used for generating classes which need to be used with Java or Java frameworks
in situations where Java might become confused by Groovy's ""plumbing"" methods.

The feature is incubating. Currently, the presence of the annotation should be
treated like a _hint_ to the compiler to produce bytecode not relying on the
Groovy runtime if it can, but _not a guarantee_.

Users of `@CompileStatic` will know that certain dynamic
features aren't possible when they switch to static Groovy.
They might expect that using `@CompileStatic` and `@POJO`
might result in even more restrictions.
This isn't strictly the case.
Adding `@POJO` does result in more Java-like code in certain places,
but numerous Groovy features still work.

Consider the following example. First a Groovy `Point` class:

[source,groovy]
--------------------------------------
@CompileStatic
@POJO
@Canonical(includeNames = true)
class Point {
    Integer x, y
}
--------------------------------------

And now a Groovy `PointList` class:

[source,groovy]
--------------------------------------
@CompileStatic
@POJO
class PointList {
    @Delegate
    List<Point> points
}
--------------------------------------

We can compile those classes using `groovyc` in the normal way
and should see the expected _Point.class_ and _PointList.class_ files produced.

We can then compile the following Java code.
We do not need the Groovy jars available for `javac` or `java`,
we only need the class files produced from the previous step.

[source,java]
--------------------------------------
Predicate<Point> xNeqY = p -> p.getX() != p.getY();  // <1>

Point p13 = new Point(1, 3);
List<Point> pts = List.of(p13, new Point(2, 2), new Point(3, 1));
PointList list = new PointList();
list.setPoints(pts);

System.out.println(list.size());
System.out.println(list.contains(p13));

list.forEach(System.out::println);

long count = list.stream().filter(xNeqY).collect(counting());  // <2>
System.out.println(count);
--------------------------------------
<1> Check whether x not equal to y
<2> Count points where x neq y

Note that while our `PointList` class has numerous list methods available
(`size`, `contains`, `forEach`, `stream`, etc.) courtesy of Groovy's `@Delegate` transform,
these are baked into the class file, and the bytecode produced doesn't call
into any Groovy libraries or rely on any runtime code.

When run, the following output is produced:

--------------------------------------
3
true
Point(x:1, y:3)
Point(x:2, y:2)
Point(x:3, y:1)
2
--------------------------------------

In essence, this opens up the possibility to use Groovy
as a kind of pre-processor similar to https://projectlombok.org/[Lombok] but backed by the Groovy language.

[width=""80%"",align=""center""]
|===
a| NOTE: _WARNING:_
Not all parts of the compiler and not all AST transforms yet know about `POJO`.
Your mileage may vary as to whether using this approach will or won't require
the Groovy jars to be on the classpath. While we anticipate some improvements over time
allowing more Groovy constructs to work with `@POJO`, we currently make no guarantees that
all constructs will eventually be supported. Hence the incubating status.
|===

[[Groovy4.0-new-contracts]]
=== Groovy Contracts (incubating)

This optional module supports design-by-contract style of programming.
More specifically, it provides contract annotations that support the
specification of class-invariants, pre-conditions, and post-conditions
on Groovy classes and interfaces.
Here is an example:

[source,groovy]
--------------------------------------
import groovy.contracts.*

@Invariant({ speed() >= 0 })
class Rocket {
    int speed = 0
    boolean started = true

    @Requires({ isStarted() })
    @Ensures({ old.speed < speed })
    def accelerate(inc) { speed += inc }

    def isStarted() { started }

    def speed() { speed }
}

def r = new Rocket()
r.accelerate(5)
--------------------------------------

This causes checking logic, corresponding to the contract declarations, to be injected
as required in the classes methods and constructors.
The checking logic will ensure that any pre-condition is satisfied
before a method executes, that any post-condition holds after any method executes
and that any class invariant is true before and after a method is called.

This module replaces the previously external `gcontracts` project which is now archived.

=== GINQ, a.k.a. Groovy-Integrated Query or GQuery (incubating)

GQuery supports querying collections in a SQL-like style.
This could involve lists and/or maps or your own domain objects
or those returned when processing for instance JSON, XML and other
structured data.

[source, sql]
--------------------------------------
from p in persons
leftjoin c in cities on p.city.name == c.name
where c.name == 'Shanghai'
select p.name, c.name as cityName

from p in persons
groupby p.gender
having p.gender == 'Male'
select p.gender, max(p.age)

from p in persons
orderby p.age in desc, p.name
select p.name

from n in numbers
where n > 0 && n <= 3
select n * 2

from n1 in nums1
innerjoin n2 in nums2 on n1 == n2
select n1 + 1, n2
--------------------------------------

Let's look at a complete example. Suppose we have information
in JSON format about fruits, their prices (per 100g) and
the concentration of vitamin C (per 100g).
We can process the JSON as follows:

[source,groovy]
--------------------------------------
import groovy.json.JsonSlurper
def json = new JsonSlurper().parseText('''
{
    ""prices"": [
        {""name"": ""Kakuda plum"",      ""price"": 13},
        {""name"": ""Camu camu"",        ""price"": 25},
        {""name"": ""Acerola cherries"", ""price"": 39},
        {""name"": ""Guava"",            ""price"": 2.5},
        {""name"": ""Kiwifruit"",        ""price"": 0.4},
        {""name"": ""Orange"",           ""price"": 0.4}
    ],
    ""vitC"": [
        {""name"": ""Kakuda plum"",      ""conc"": 5300},
        {""name"": ""Camu camu"",        ""conc"": 2800},
        {""name"": ""Acerola cherries"", ""conc"": 1677},
        {""name"": ""Guava"",            ""conc"": 228},
        {""name"": ""Kiwifruit"",        ""conc"": 144},
        {""name"": ""Orange"",           ""conc"": 53}
    ]
}
''')
--------------------------------------

Now, suppose we are on a budget and want to select
the most cost-effective fruits to buy to help us achieve
our daily vitamin C requirements.
We _join_ the _prices_ and _vitC_ information and
order by most cost-effective fruit.
We'll select the top 2 in case our first choice isn't in stock
when we go shopping. We can see, for this data,
Kakadu plums followed by Kiwifruit are our best choices:

[source,groovy]
--------------------------------------
assert GQ {
    from p in json.prices
    join c in json.vitC on c.name == p.name
    orderby c.conc / p.price in desc
    limit 2
    select p.name
}.toList() == ['Kakuda plum', 'Kiwifruit']
--------------------------------------

We can look at the same example again for XML.
Our XML processing code might look something like:

[source,groovy]
--------------------------------------
import groovy.xml.XmlSlurper
def root = new XmlSlurper().parseText('''
<root>
    <prices>
        <price name=""Kakuda plum"">13</price>
        <price name=""Camu camu"">25</price>
        <price name=""Acerola cherries"">39</price>
        <price name=""Guava"">2.5</price>
        <price name=""Kiwifruit"">0.4</price>
        <price name=""Orange"">0.4</price>
    </prices>
    <vitaminC>
        <conc name=""Kakuda plum"">5300</conc>
        <conc name=""Camu camuum"">2800</conc>
        <conc name=""Acerola cherries"">1677</conc>
        <conc name=""Guava"">228</conc>
        <conc name=""Kiwifruit"">144</conc>
        <conc name=""Orange"">53</conc>
    </vitaminC>
</root>
''')
--------------------------------------

Our GQuery code might look like:

[source,groovy]
--------------------------------------
assert GQ {
    from p in root.prices.price
    join c in root.vitaminC.conc on c.@name == p.@name
    orderby c.toInteger() / p.toDouble() in desc
    limit 2
    select p.@name
}.toList() == ['Kakuda plum', 'Kiwifruit']
--------------------------------------

In a future Groovy version we hope to provide GQuery support for SQL databases
where an optimised SQL query is generated based on the GQuery expression
much like Groovy's DataSet functionality.
In the meantime, for small volumes of data, you can use Groovy's standard
SQL capabilities which return queries from the database as collections.
Here is what the code would look like for a database with
`Price` and `VitaminC` tables both having `name` and `per100g` columns:

[source,groovy]
--------------------------------------
// ... create sql connection ...
def price = sql.rows('SELECT * FROM Price')
def vitC = sql.rows('SELECT * FROM VitaminC')
assert GQ {
    from p in price
    join c in vitC on c.name == p.name
    orderby c.per100g / p.per100g in desc
    limit 2
    select p.name
}.toList() == ['Kakuda plum', 'Kiwifruit']
// ... close connection ...
--------------------------------------

More examples could be found in the link:../using-ginq.html[GQuery documentation] (or directly in
link:https://github.com/apache/groovy/blob/master/subprojects/groovy-ginq/src/spec/test/org/apache/groovy/ginq/GinqTest.groovy[the source repo]).

=== TOML Support (incubating)

Support is now available for handling link:https://toml.io/en/[TOML]-based files including building:

[source,groovy]
--------------------------------------
def builder = new TomlBuilder()
builder.records {
    car {
        name 'HSV Maloo'
        make 'Holden'
        year 2006
        country 'Australia'
        homepage new URL('http://example.org')
        record {
            type 'speed'
            description 'production pickup truck with speed of 271kph'
        }
    }
}
--------------------------------------

and parsing:

[source,groovy]
--------------------------------------
def ts = new TomlSlurper()
def toml = ts.parseText(builder.toString())

assert 'HSV Maloo' == toml.records.car.name
assert 'Holden' == toml.records.car.make
assert 2006 == toml.records.car.year
assert 'Australia' == toml.records.car.country
assert 'http://example.org' == toml.records.car.homepage
assert 'speed' == toml.records.car.record.type
assert 'production pickup truck with speed of 271kph' == toml.records.car.record.description
--------------------------------------

More examples could be found in the link:../processing-toml.html[groovy-toml] documentation.

[[Groovy4.0-other]]
== Other improvements

=== GString performance improvements

GString internals were revamped to improve performance.
When safe to do so, GString toString values are now automatically cached.
While infrequently used, GStrings do permit their internal data structures to
be viewed (and even changed!). In such circumstances, caching is disabled.
If you wish to view and not change the internal data structures, you can
call a `freeze()` method in `GStringImpl` to disallow changing of the internal
data structures which allows caching to remain active.
link:https://issues.apache.org/jira/browse/GROOVY-9637[GROOVY-9637]

As an example, the following script takes about 10s to run with Groovy 3 and about 0.1s with Groovy 4:

[source,groovy]
--------------------------------------
def now = java.time.LocalDateTime.now()
def gs = ""integer: ${1}, double: ${1.2d}, string: ${'x'}, class: ${Map.class}, boolean: ${true}, date: ${now}""
long b = System.currentTimeMillis()
for (int i = 0; i < 10000000; i++) {
    gs.toString()
}
long e = System.currentTimeMillis()
println ""${e - b}ms""
--------------------------------------

=== Enhanced Ranges

Groovy has always supported inclusive, e.g. `3..5`, and exclusive (or open on the right), e.g. `4..<10`, ranges.
From Groovy 4, ranges can be closed, open on the left, e.g. `3<..5`, right or both sides, e.g. `0<..<3`.
The range will exclude the left or right-most values for such ranges.
link:https://issues.apache.org/jira/browse/GROOVY-9649[GROOVY-9649]

=== Support for decimal fraction literals without a leading zero

Groovy has previously required a leading zero for fractional values, but leaving off the leading zero is now also supported.

[source,groovy]
--------------------------------------
def half = .5
def otherHalf = 0.5  // leading zero remains supported
double third = .333d
float quarter = .25f
def fractions = [.1, .2, .3]

// can be used for ranges too (with a rare edge case you might want to avoid)
def range1 = -1.5..<.5    // okay here
def range2 = -1.5.. .5    // space is okay but harder for humans <1>
def range3 = -1.5..0.5    // leading zero edge case <1>
assert range3 == [-1.5, -.5, .5]
--------------------------------------
<1> A fractional value without a leading zero can't appear immediately after the range `..` operator.
The three dots in a row would be confusing and similar to the varargs notation.
You should leave a space (might still be confusing for humans readers) or
retain the leading zero (recommended).

=== JSR308 improvements (incubating)

Groovy has been improving JSR-308 support over recent versions.
In Groovy 4.0, additional support has been added. In particular,
type annotations are now supported on generic types. This is useful
for users of tools like the link:https://jqwik.net/[Jqwik] property-based testing library
and technologies like the link:https://beanvalidation.org/2.0/[Bean Validation 2] framework.
Here is an example of a Jqwik test:

[source,groovy]
--------------------------------------
@Grab('net.jqwik:jqwik:1.5.5')
import net.jqwik.api.*
import net.jqwik.api.constraints.*

class PropertyBasedTests {
    @Property
    def uniqueInList(@ForAll @Size(5) @UniqueElements List<@IntRange(min = 0, max = 10) Integer> aList) {
        assert aList.size() == aList.toSet().size()
        assert aList.every{ anInt -> anInt >= 0 && anInt <= 10 }
    }
}
--------------------------------------

In earlier versions of Groovy, the `@Forall`, `@Size`, and `@UniqueElements` annotations
were handled, but the `@IntRange` annotation on the `List` generic type didn't appear in the
generated bytecode and now does.

Here is a Bean Validation 2 framework example:

[source,groovy]
--------------------------------------
@Grab('org.hibernate.validator:hibernate-validator:7.0.1.Final')
@Grab('org.hibernate.validator:hibernate-validator-cdi:7.0.1.Final')
@Grab('org.glassfish:jakarta.el:4.0.0')
import jakarta.validation.constraints.*
import jakarta.validation.*
import groovy.transform.*

@Canonical
class Car {
    @NotNull @Size(min = 2, max = 14) String make
    @Min(1L) int seats
    List<@NotBlank String> owners
}

def validator = Validation.buildDefaultValidatorFactory().validator

def violations = validator.validate(new Car(make: 'T', seats: 1))
assert violations*.message == ['size must be between 2 and 14']

violations = validator.validate(new Car(make: 'Tesla', owners: ['']))
assert violations*.message.toSet() == ['must be greater than or equal to 1', 'must not be blank'] as Set

violations = validator.validate(new Car(make: 'Tesla', owners: ['Elon'], seats: 2))
assert !violations
--------------------------------------

Again, all annotations except the `@NonBlank` annotation on the `List` generic type
were previously supported, and now `@NonBlank` will appear in the bytecode too.

This feature is marked as incubating. The generated bytecode is not expected to change
but some minor details of the AST representation of the annotations during compilation
may change slightly before the feature leaves incubating status.

In addition, type annotations that appear in code,
e.g. local variable types, cast expression types, catch block exception types,
are still work in progress.

=== AST transformation priorities

The order in which AST transforms are processed is determined first by the `phase`
declared in a transform's `@GroovyASTTransformation` declaration.
For transforms declared to be in the same phase, the order in which the
associated transform annotations appear in the source code is then used.

Now, transformation writers can also specify a priority for their transforms.
To do so, the AST transformation must implement the `TransformWithPriority` interface
and return their priority as an integer in the implemented `priority()` method.
The default priority is `0`. The transformation with the highest positive priority
will be processed first. Negative priorities will be processed after all transformations
with a priority of zero (the default).

Note that transformations are still all processed together. The priority only
affects ordering between other transformations. Other parts of the respective
compiler phase remain unchanged.

[[Groovy4.0-consolidation]]
== Legacy consolidation

[[Groovy4.0-parrot-only]]
=== Old parser removal

Groovy 3 introduced the new ""Parrot"" parser which supports lambdas, method
references, and numerous other tweaks. In Groovy 3, You could still revert back to the old parser
if you wanted. In Groovy 4, the old Antlr2 based parser is removed.
Please use older versions of Groovy if you require the old parser.

[[Groovy4.0-indy-only]]
=== Classic bytecode generation removal

For many versions, Groovy could generate classic _call-site based_ bytecode
or bytecode targeting the JDK7+ invoke dynamic (""indy"") bytecode instructions.
You could switch between them with a compiler switch and we had two sets of
jars (""normal"" and ""-indy"") built with and without the switch enabled.
In Groovy 4.0, only bytecode using the latter approach can be generated.
There is now one set of jars and they happen to be indy flavored.

Currently, the Groovy runtime still contains any necessary support for
classes compiled using older versions of Groovy.
Please use Groovy versions up to 3.x if you need to generate the older
style bytecode.

This work was originally planned for Groovy 3.0, but there were numerous places
where ""indy"" code was noticeably slower than ""classic"" bytecode.
We have made numerous speed improvements (starting with https://issues.apache.org/jira/browse/GROOVY-8298[GROOVY-8298])
and have some ability to tune internal thresholds (search the code base for
`groovy.indy.optimize.threshold` and `groovy.indy.fallback.threshold`).
That work gave us useful speed improvements, but we welcome further feedback
to help improve overall performance of the indy bytecode.

[[Groovy4.0-breaking]]
== Other breaking changes

* Groovy added some very minor enhancements when using the link:https://javaee.github.io/jaxb-v2/[JAXB technology] in its optional `groovy-jaxb` module. Since JAXB is link:https://openjdk.java.net/jeps/320[no longer bundled in the JDK], we removed this module. Users wanting that functionality are likely able to use the Groovy 3 version of that module with Groovy 4, though we don't guarantee this going forward.
(link:https://issues.apache.org/jira/browse/GROOVY-10005[GROOVY-10005]).
* The optional `groovy-bsf` module provides a Groovy BSF engine for the version 2 of BSF (a.k.a. beanshell) framework. This version hasn't had a release since 2005 and has reached end-of-life. In Groovy 4 we have removed this module. Users wanting that functionality are likely able to use the Groovy 3 version of that module with Groovy 4, though we don't guarantee this going forward.
(link:https://issues.apache.org/jira/browse/GROOVY-10023[GROOVY-10023]).
* Numerous classes previously ""leaked"" ASM constants which are essentially an internal implementation detail by virtue of
implementing an `Opcodes` interface. This will not normally affect the majority of
Groovy scripts but might impact code which manipulates AST nodes such as AST transforms.
Before compiling with Groovy 4, some of these may need one or more appropriate static import statements added.
AST transforms which extend `AbstractASTTransformation` are one example of potentially affected classes.
(link:https://issues.apache.org/jira/browse/GROOVY-9736[GROOVY-9736]).
* `ASTTest` previously had `RUNTIME` retention but now has `SOURCE` retention.
We know of no users making use of the old retention but are aware of various
issues keeping the old value.
link:https://issues.apache.org/jira/browse/GROOVY-9702[GROOVY-9702]
* Groovy's `intersect` DGM method had a different semantics to other languages
when supplied with a projecting closure/comparator.
Other languages often have a `intersectBy` method in this case rather than overloading the `intersect` operator like Groovy does.
When no projecting function is in play,
`a.intersect(b)` should always equal `b.intersect(a)`.
When a projecting function is in play, most languages define `a.intersect(b)` as
the subset of elements from `a` which when projected match a projected value from `b`.
So the resulting values are always drawn from `a`. The objects involved can be reversed
to draw the elements from `b`. Groovy's semantics used to be the reverse of most
other languages but is now aligned. Some examples with the new behavior:
+
[source,groovy]
----
def abs = { a, b -> a.abs() <=> b.abs() }
assert [1, 2].intersect([-2, -3], abs) == [2]
assert [-2, -3].intersect([1, 2], abs) == [-2]

def round = { a, b -> a.round() <=> b.round() }
assert [1.1, 2.2].intersect([2.5, 3.5], round) == [2.2]
assert [2.5, 3.5].intersect([1.1, 2.2], round) == [2.5]
----
+
Simply reverse the order of the objects to get the previous behavior,
e.g. use `foo.intersect(bar)` instead of `bar.intersect(foo)`.
link:https://issues.apache.org/jira/browse/GROOVY-10275[GROOVY-10275]
* There were some inconsistencies with JavaBean property naming conventions
for various edge cases, e.g. for a field with a name being a single uppercase `X` and having a `getX` accessor,
then the field was given priority over the accessor.
link:https://issues.apache.org/jira/browse/GROOVY-9618[GROOVY-9618]
* Numerous mostly internal data structure classes, e.g. AbstractConcurrentMapBase, AbstractConcurrentMap, ManagedConcurrentMap
were deprecated and their usage replaced with better alternatives.
This should be mostly invisible but some changes might impact users using
internal Groovy classes directly.
link:https://issues.apache.org/jira/browse/GROOVY-9631[GROOVY-9631]
* We bumped our Picocli version. This resulted in minor formatting changes
of some CLI help messages. We recommend not relying on the exact format of such messages.
link:https://issues.apache.org/jira/browse/GROOVY-9627[GROOVY-9627]
* We are currently attempting to improve how Groovy code accesses private fields
in certain scenarios where such access is expected but problematic, e.g. within closure definitions where
subclasses or inner classes are involved
(link:https://issues.apache.org/jira/browse/GROOVY-5438[GROOVY-5438]).
You may notice breakages in Groovy 4 code in such scenarios until this issue is progressed.
As a workaround in the meantime, you may be able to use local variable outside a closure
to reference the relevant fields and then reference those local variables in the closure.
* Earlier Groovy versions unintentionally stored the constants -0.0f and -0.0d to be the same
as 0.0f and 0.0d respectively. This only applied to explicit constants, i.e. it didn't apply
to calculations which resulted in positive or negative zero. This also meant that certain
comparisons of positive and negative zero returned true in cases where they should have
been different, and calling `unique` might have resulted in a set containing just positive zero
instead of both positive and negative zero (the correct answer as per IEEE-745).
Depending on whether you are using primitive or wrapper floating point variants,
you may or may not be affected.
Consider using `equalsIgnoreZeroSign` and the boolean `ignoreZeroSign`
constructor variant to `NumberAwareComparator` if you are affected and desire the old behavior.
These modifications have also been back-ported to Groovy 3, so consider using them in
Groovy 3 code instead of relying on the old behavior so that your code can work
correctly across versions. The fix itself hasn't been back-ported to avoid breaking
existing code relying on the unintended flawed behavior. +
Bug fix:
link:https://issues.apache.org/jira/browse/GROOVY-9797[GROOVY-9797] +
Improved documentation and helper methods:
link:https://issues.apache.org/jira/browse/GROOVY-9981[GROOVY-9981]
* Various Groovy test classes had unnecessary hidden dependencies on JUnit 3/4 classes.
After modification, these classes can now be used with e.g. JUnit 5 (or Spock)
without Junit 3/4 on the classpath. It is a breaking change only if
code is looking explicitly at the class of thrown exceptions
or inspecting the class hierarchy through reflection. +
`NotYetImplemented`:
link:https://issues.apache.org/jira/browse/GROOVY-9492[GROOVY-9492] +
`GroovyAssert`:
link:https://issues.apache.org/jira/browse/GROOVY-9767[GROOVY-9767]
* Several `Sql#call` variants incorrectly throw `Exception` rather than `SQLException`.
This is a binary breaking change. Care should be taken with compiling code relying
on those methods with an older version of Groovy and then running on Groovy 4
and vice versa.
link:https://issues.apache.org/jira/browse/GROOVY-9923[GROOVY-9923]
* We removed `StaticTypeCheckingVisitor#collectAllInterfacesByName`
from our public API as it was buggy and there were numerous alternatives
available. We weren't aware of any framework use of this method.
Even though it was public, it was considered mostly internal.
link:https://issues.apache.org/jira/browse/GROOVY-10123[GROOVY-10123]
* Two jar files (`servlet-api.jar` and `jsp-api.jar`) were notionally ""provided"" dependencies but were previously
copied into the Groovy binary distribution. This is no longer the case.
link:https://issues.apache.org/jira/browse/GROOVY-9827[GROOVY-9827]
* Groovy code involving `plus` on arrays broke referential transparency
in certain contexts.
The expression `b + c`, where `b` and `c` are arrays,
potentially gave different results in the two expressions `a = b + c` and `b = b + c`.
The latter of these expressions (shorthand for `b += c`) was type preserving
but the former was returned as an Object[]. The type preserving behavior
was the intended one.
link:https://issues.apache.org/jira/browse/GROOVY-6837[GROOVY-6837].
+
[TIP]
====
To mimick the old behavior: If `b` is not an Object array and you desire an Object
array result, then instead of `b + c`, use one of:

* `b.union(c)`
* `new Object[0] + b + c`
* `[] as Object[] + b + c`
====
* Groovy's syntax borrows an ""information hiding principal"" idea from the Eiffel programming
language whereby accessing a public field or a property (private field with a getter)
can have the same syntactic form. This idea wasn't carried over to the `getProperties()`
method in an object's metaclass. Now `getProperties()` also returns public fields.
link:https://issues.apache.org/jira/browse/GROOVY-10449[GROOVY-10449].

[[Groovy4.0-requirements]]
== JDK requirements

Groovy 4.0 requires JDK16+ to build and JDK8 is the minimum version of the JRE that we support.
Groovy has been tested on JDK versions 8 through 17.

[[Groovy4.0-more-info]]
== More information

You can browse all the link:../changelogs/changelog-4.0.0-unreleased.html[tickets closed for Groovy 4.0 in JIRA].
",12258,False,2060.2948388365235,median
"[[cluster-nodes-stats]]
=== Nodes stats API
++++
<titleabbrev>Nodes stats</titleabbrev>
++++

Returns cluster nodes statistics.

[[cluster-nodes-stats-api-request]]
==== {api-request-title}

`GET /_nodes/stats` +

`GET /_nodes/<node_id>/stats` +

`GET/_nodes/stats/<metric>` +

`GET/_nodes/<node_id>/stats/<metric>` +

`GET /_nodes/stats/<metric>/<index_metric>` +

`GET /_nodes/<node_id>/stats/<metric>/<index_metric>`


[[cluster-nodes-stats-api-desc]]
==== {api-description-title}

You can use the cluster nodes stats API to retrieve statistics for nodes in a cluster.


All the nodes selective options are explained <<cluster-nodes,here>>.

By default, all stats are returned. You can limit the returned information by
using metrics.

[[cluster-nodes-stats-api-path-params]]
==== {api-path-parms-title}


`<metric>`::
    (Optional, string) Limits the information returned to the specific metrics.
    A comma-separated list of the following options:
+
--
  `adaptive_selection`::
      Statistics about <<search-adaptive-replica,adaptive replica selection>>.

  `breaker`::
      Statistics about the field data circuit breaker.

  `discovery`::
      Statistics about the discovery.

  `fs`::
      File system information, data path, free disk space, read/write
      stats.

  `http`::
      HTTP connection information.

  `indexing_pressure`::
        Statistics about the node's indexing load and related rejections.

  `indices`::
      Indices stats about size, document count, indexing and deletion times,
      search times, field cache size, merges and flushes.

  `ingest`::
      Statistics about ingest preprocessing.

  `jvm`::
      JVM stats, memory pool information, garbage collection, buffer
      pools, number of loaded/unloaded classes.

  `os`::
      Operating system stats, load average, mem, swap.

  `process`::
      Process statistics, memory consumption, cpu usage, open
      file descriptors.

  `thread_pool`::
      Statistics about each thread pool, including current size, queue and
      rejected tasks.

  `transport`::
      Transport statistics about sent and received bytes in cluster
      communication.
--

`<index_metric>`::
    (Optional, string) Limit the information returned for `indices` metric to
    the specific index metrics. It can be used only if `indices` (or `all`)
    metric is specified. Supported metrics are:
+
--
    * `completion`
    * `docs`
    * `fielddata`
    * `flush`
    * `get`
    * `indexing`
    * `merge`
    * `query_cache`
    * `recovery`
    * `refresh`
    * `request_cache`
    * `search`
    * `segments`
    * `store`
    * `translog`
    * `warmer`
--

include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=node-id]


[[cluster-nodes-stats-api-query-params]]
==== {api-query-parms-title}

include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=completion-fields]

include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=fielddata-fields]

include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=fields]

include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=groups]

include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=level]

`types`::
    (Optional, string) A comma-separated list of document types for the
    `indexing` index metric.

include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=timeoutparms]

include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=include-segment-file-sizes]

[role=""child_attributes""]
[[cluster-nodes-stats-api-response-body]]
==== {api-response-body-title}

`_nodes`::
(object)
Contains statistics about the number of nodes selected by the request.
+
.Properties of `_nodes`
[%collapsible%open]
====
`total`::
(integer)
Total number of nodes selected by the request.

`successful`::
(integer)
Number of nodes that responded successfully to the request.

`failed`::
(integer)
Number of nodes that rejected the request or failed to respond. If this value
is not `0`, a reason for the rejection or failure is included in the response.
====

`cluster_name`::
(string)
Name of the cluster. Based on the <<cluster.name>> setting.

`nodes`::
(object)
Contains statistics for the nodes selected by the request.
+
.Properties of `nodes`
[%collapsible%open]
====
`<node_id>`::
(object)
Contains statistics for the node.
+
.Properties of `<node_id>`
[%collapsible%open]
=====
`timestamp`::
(integer)
Time the node stats were collected for this response. Recorded in milliseconds
since the {wikipedia}/Unix_time[Unix Epoch].

`name`::
(string)
Human-readable identifier for the node. Based on the <<node.name>> setting.

`transport_address`::
(string)
Host and port for the <<modules-transport,transport layer>>, used for internal
communication between nodes in a cluster.

`host`::
(string)
Network host for the node, based on the <<network.host>> setting.

`ip`::
(string)
IP address and port for the node.

`roles`::
(array of strings)
Roles assigned to the node. See <<modules-node>>.

`attributes`::
(object)
Contains a list of attributes for the node.

[[cluster-nodes-stats-api-response-body-indices]]
`indices`::
(object)
Contains statistics about indices with shards assigned to the node.
+
.Properties of `indices`
[%collapsible%open]
======
`docs`::
(object)
Contains statistics about documents across all primary shards assigned to the
node.
+
.Properties of `docs`
[%collapsible%open]
=======
`count`::
(integer)
include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=docs-count]

`deleted`::
(integer)
include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=docs-deleted]
=======

`store`::
(object)
Contains statistics about the size of shards assigned to the node.
+
.Properties of `store`
[%collapsible%open]
=======
`size`::
(<<byte-units,byte value>>)
Total size of all shards assigned to the node.

`size_in_bytes`::
(integer)
Total size, in bytes, of all shards assigned to the node.

`reserved`::
(<<byte-units,byte value>>)
A prediction of how much larger the shard stores on this node will eventually
grow due to ongoing peer recoveries, restoring snapshots, and similar
activities. A value of `-1b` indicates that this is not available.

`reserved_in_bytes`::
(integer)
A prediction, in bytes, of how much larger the shard stores on this node will
eventually grow due to ongoing peer recoveries, restoring snapshots, and
similar activities. A value of `-1` indicates that this is not available.
=======

`indexing`::
(object)
Contains statistics about indexing operations for the node.
+
.Properties of `indexing`
[%collapsible%open]
=======
`index_total`::
(integer)
Total number of indexing operations.

`index_time`::
(<<time-units,time value>>)
Total time spent performing indexing operations.

`index_time_in_millis`::
(integer)
Total time in milliseconds
spent performing indexing operations.

`index_current`::
(integer)
Number of indexing operations currently running.

`index_failed`::
(integer)
Number of failed indexing operations.

`delete_total`::
(integer)
Total number of deletion operations.

`delete_time`::
(<<time-units,time value>>)
Time spent performing deletion operations.

`delete_time_in_millis`::
(integer)
Time in milliseconds
spent performing deletion operations.

`delete_current`::
(integer)
Number of deletion operations currently running.

`noop_update_total`::
(integer)
Total number of noop operations.

`is_throttled`::
(boolean)
Number of times
operations were throttled.

`throttle_time`::
(<<time-units,time value>>)
Total time spent throttling operations.

`throttle_time_in_millis`::
(integer)
Total time in milliseconds
spent throttling operations.
=======

`get`::
(object)
Contains statistics about get operations for the node.
+
.Properties of `get`
[%collapsible%open]
=======
`total`::
(integer)
Total number of get operations.

`getTime`::
(<<time-units,time value>>)
Time spent performing get operations.

`time_in_millis`::
(integer)
Time in milliseconds
spent performing get operations.

`exists_total`::
(integer)
Total number of successful get operations.

`exists_time`::
(<<time-units,time value>>)
Time spent performing successful get operations.

`exists_time_in_millis`::
(integer)
Time in milliseconds
spent performing successful get operations.

`missing_total`::
(integer)
Total number of failed get operations.

`missing_time`::
(<<time-units,time value>>)
Time spent performing failed get operations.

`missing_time_in_millis`::
(integer)
Time in milliseconds
spent performing failed get operations.

`current`::
(integer)
Number of get operations currently running.
=======

`search`::
(object)
Contains statistics about search operations for the node.
+
.Properties of `search`
[%collapsible%open]
=======
`open_contexts`::
(integer)
Number of open search contexts.

`query_total`::
(integer)
Total number of query operations.

`query_time`::
(<<time-units,time value>>)
Time spent performing query operations.

`query_time_in_millis`::
(integer)
Time in milliseconds
spent performing query operations.

`query_current`::
(integer)
Number of query operations currently running.

`fetch_total`::
(integer)
Total number of fetch operations.

`fetch_time`::
(<<time-units,time value>>)
Time spent performing fetch operations.

`fetch_time_in_millis`::
(integer)
Time in milliseconds
spent performing fetch operations.

`fetch_current`::
(integer)
Number of fetch operations currently running.

`scroll_total`::
(integer)
Total number of scroll operations.

`scroll_time`::
(<<time-units,time value>>)
Time spent performing scroll operations.

`scroll_time_in_millis`::
(integer)
Time in milliseconds
spent performing scroll operations.

`scroll_current`::
(integer)
Number of scroll operations currently running.

`suggest_total`::
(integer)
Total number of suggest operations.

`suggest_time`::
(<<time-units,time value>>)
Time spent performing suggest operations.

`suggest_time_in_millis`::
(integer)
Time in milliseconds
spent performing suggest operations.

`suggest_current`::
(integer)
Number of suggest operations currently running.
=======

`merges`::
(object)
Contains statistics about merge operations for the node.
+
.Properties of `merges`
[%collapsible%open]
=======
`current`::
(integer)
Number of merge operations currently running.

`current_docs`::
(integer)
Number of document merges currently running.

`current_size`::
(<<byte-units,byte value>>)
Memory used performing current document merges.

`current_size_in_bytes`::
(integer)
Memory, in bytes, used performing current document merges.

`total`::
(integer)
Total number of merge operations.

`total_time`::
(<<time-units,time value>>)
Total time spent performing merge operations.

`total_time_in_millis`::
(integer)
Total time in milliseconds
spent performing merge operations.

`total_docs`::
(integer)
Total number of merged documents.

`total_size`::
(<<byte-units,byte value>>)
Total size of document merges.

`total_size_in_bytes`::
(integer)
Total size of document merges in bytes.

`total_stopped_time`::
(<<time-units,time value>>)
Total time spent stopping merge operations.

`total_stopped_time_in_millis`::
(integer)
Total time in milliseconds
spent stopping merge operations.

`total_throttled_time`::
(<<time-units,time value>>)
Total time spent throttling merge operations.

`total_throttled_time_in_millis`::
(integer)
Total time in milliseconds
spent throttling merge operations.

`total_auto_throttle`::
(<<byte-units,byte value>>)
Size of automatically throttled merge operations.

`total_auto_throttle_in_bytes`::
(integer)
Size, in bytes, of automatically throttled merge operations.
=======

`refresh`::
(object)
Contains statistics about refresh operations for the node.
+
.Properties of `refresh`
[%collapsible%open]
=======
`total`::
(integer)
Total number of refresh operations.

`total_time`::
(<<time-units,time value>>)
Total time spent performing refresh operations.

`total_time_in_millis`::
(integer)
Total time in milliseconds
spent performing refresh operations.

`external_total`::
(integer)
Total number of external refresh operations.

`external_total_time`::
(<<time-units,time value>>)
Total time spent performing external operations.

`external_total_time_in_millis`::
(integer)
Total time in milliseconds
spent performing external operations.

`listeners`::
(integer)
Number of refresh listeners.
=======

`flush`::
(object)
Contains statistics about flush operations for the node.
+
.Properties of `flush`
[%collapsible%open]
=======
`total`::
(integer)
Number of flush operations.

`periodic`::
(integer)
Number of flush periodic operations.

`total_time`::
(<<time-units,time value>>)
Total time spent performing flush operations.

`total_time_in_millis`::
(integer)
Total time in milliseconds
spent performing flush operations.
=======

`warmer`::
(object)
Contains statistics about index warming operations for the node.
+
.Properties of `warmer`
[%collapsible%open]
=======
`current`::
(integer)
Number of active index warmers.

`total`::
(integer)
Total number of index warmers.

`total_time`::
(<<time-units,time value>>)
Total time spent performing index warming operations.

`total_time_in_millis`::
(integer)
Total time in milliseconds
spent performing index warming operations.
=======

`query_cache`::
(object)
Contains statistics about the query cache across all shards assigned to the
node.
+
.Properties of `query_cache`
[%collapsible%open]
=======
`memory_size`::
(<<byte-units,byte value>>)
Total amount of memory used for the query cache across all shards assigned to
the node.

`memory_size_in_bytes`::
(integer)
Total amount of memory, in bytes, used for the query cache across all shards
assigned to the node.

`total_count`::
(integer)
Total count of hits, misses, and cached queries
in the query cache.

`hit_count`::
(integer)
Number of query cache hits.

`miss_count`::
(integer)
Number of query cache misses.

`cache_size`::
(integer)
Size, in bytes, of the query cache.

`cache_count`::
(integer)
Count of queries
in the query cache.

`evictions`::
(integer)
Number of query cache evictions.
=======

`fielddata`::
(object)
Contains statistics about the field data cache across all shards
assigned to the node.
+
.Properties of `fielddata`
[%collapsible%open]
=======
`memory_size`::
(<<byte-units,byte value>>)
Total amount of memory used for the field data cache across all shards
assigned to the node.

`memory_size_in_bytes`::
(integer)
Total amount of memory, in bytes, used for the field data cache across all
shards assigned to the node.

`evictions`::
(integer)
Number of fielddata evictions.
=======

`completion`::
(object)
Contains statistics about completions across all shards assigned to the node.
+
.Properties of `completion`
[%collapsible%open]
=======
`size`::
(<<byte-units,byte value>>)
Total amount of memory used for completion across all shards assigned to
the node.

`size_in_bytes`::
(integer)
Total amount of memory, in bytes, used for completion across all shards assigned
to the node.
=======

`segments`::
(object)
Contains statistics about segments across all shards assigned to the node.
+
.Properties of `segments`
[%collapsible%open]
=======
`count`::
(integer)
Number of segments.

`memory`::
(<<byte-units,byte value>>)
Total amount of memory used for segments across all shards assigned to the
node.

`memory_in_bytes`::
(integer)
Total amount of memory, in bytes, used for segments across all shards assigned
to the node.

`terms_memory`::
(<<byte-units,byte value>>)
Total amount of memory used for terms across all shards assigned to the node.

`terms_memory_in_bytes`::
(integer)
Total amount of memory, in bytes, used for terms across all shards assigned to
the node.

`stored_fields_memory`::
(<<byte-units,byte value>>)
Total amount of memory used for stored fields across all shards assigned to
the node.

`stored_fields_memory_in_bytes`::
(integer)
Total amount of memory, in bytes, used for stored fields across all shards
assigned to the node.

`term_vectors_memory`::
(<<byte-units,byte value>>)
Total amount of memory used for term vectors across all shards assigned to
the node.

`term_vectors_memory_in_bytes`::
(integer)
Total amount of memory, in bytes, used for term vectors across all shards
assigned to the node.

`norms_memory`::
(<<byte-units,byte value>>)
Total amount of memory used for normalization factors across all shards assigned
to the node.

`norms_memory_in_bytes`::
(integer)
Total amount of memory, in bytes, used for normalization factors across all
shards assigned to the node.

`points_memory`::
(<<byte-units,byte value>>)
Total amount of memory used for points across all shards assigned to the node.

`points_memory_in_bytes`::
(integer)
Total amount of memory, in bytes, used for points across all shards assigned to
the node.

`doc_values_memory`::
(<<byte-units,byte value>>)
Total amount of memory used for doc values across all shards assigned to
the node.

`doc_values_memory_in_bytes`::
(integer)
Total amount of memory, in bytes, used for doc values across all shards assigned
to the node.

`index_writer_memory`::
(<<byte-units,byte value>>)
Total amount of memory used by all index writers across all shards assigned to
the node.

`index_writer_memory_in_bytes`::
(integer)
Total amount of memory, in bytes, used by all index writers across all shards
assigned to the node.

`version_map_memory`::
(<<byte-units,byte value>>)
Total amount of memory used by all version maps across all shards assigned to
the node.

`version_map_memory_in_bytes`::
(integer)
Total amount of memory, in bytes, used by all version maps across all shards
assigned to the node.

`fixed_bit_set`::
(<<byte-units,byte value>>)
Total amount of memory used by fixed bit sets across all shards assigned to
the node.
+
Fixed bit sets are used for nested object field types and
type filters for <<parent-join,join>> fields.

`fixed_bit_set_memory_in_bytes`::
(integer)
Total amount of memory, in bytes, used by fixed bit sets across all shards
assigned to the node.
+
Fixed bit sets are used for nested object field types and
type filters for <<parent-join,join>> fields.

`max_unsafe_auto_id_timestamp`::
(integer)
Time of the most recently retried indexing request. Recorded in milliseconds
since the {wikipedia}/Unix_time[Unix Epoch].

`file_sizes`::
(object)
Contains statistics about the size of the segment file.
+
.Properties of `file_sizes`
[%collapsible%open]
========
`size`::
(<<byte-units,byte value>>)
Size of the segment file.

`size_in_bytes`::
(integer)
Size, in bytes,
of the segment file.

`description`::
(string)
Description of the segment file.
========
=======

`translog`::
(object)
Contains statistics about transaction log operations for the node.
+
.Properties of `translog`
[%collapsible%open]
=======
`operations`::
(integer)
Number of transaction log operations.

`size`::
(<<byte-units,byte value>>)
Size of the transaction log.

`size_in_bytes`::
(integer)
Size, in bytes, of the transaction log.

`uncommitted_operations`::
(integer)
Number of uncommitted transaction log operations.

`uncommitted_size`::
(<<byte-units,byte value>>)
Size of uncommitted transaction log operations.

`uncommitted_size_in_bytes`::
(integer)
Size, in bytes, of uncommitted transaction log operations.

`earliest_last_modified_age`::
(integer)
Earliest last modified age
for the transaction log.
=======

`request_cache`::
(object)
Contains statistics about the request cache across all shards assigned to the
node.
+
.Properties of `request_cache`
[%collapsible%open]
=======
`memory_size`::
(<<byte-units,byte value>>)
Memory used by the request cache.

`memory_size_in_bytes`::
(integer)
Memory, in bytes, used by the request cache.

`evictions`::
(integer)
Number of request cache operations.

`hit_count`::
(integer)
Number of request cache hits.

`miss_count`::
(integer)
Number of request cache misses.
=======

`recovery`::
(object)
Contains statistics about recovery operations for the node.
+
.Properties of `recovery`
[%collapsible%open]
=======
`current_as_source`::
(integer)
Number of recoveries
that used an index shard as a source.

`current_as_target`::
(integer)
Number of recoveries
that used an index shard as a target.

`throttle_time`::
(<<time-units,time value>>)
Time by which recovery operations were delayed due to throttling.

`throttle_time_in_millis`::
(integer)
Time in milliseconds
recovery operations were delayed due to throttling.
=======
======

[[cluster-nodes-stats-api-response-body-os]]
`os`::
(object)
Contains statistics about the operating system for the node.
+
.Properties of `os`
[%collapsible%open]
======
`timestamp`::
(integer)
Last time the operating system statistics were refreshed. Recorded in
milliseconds since the {wikipedia}/Unix_time[Unix Epoch].

`cpu`::
(object)
Contains statistics about CPU usage for the node.
+
.Properties of `cpu`
[%collapsible%open]
=======
`percent`::
(integer)
Recent CPU usage for the whole system, or `-1` if not supported.

`load_average`::
(object)
Contains statistics about load averages on the system.
+
.Properties of `load_average`
[%collapsible%open]
========
`1m`::
(float)
One-minute load average on the system (field is not present if one-minute load
average is not available).

`5m`::
(float)
Five-minute load average on the system (field is not present if five-minute load
average is not available).

`15m`::
(float)
Fifteen-minute load average on the system (field is not present if
fifteen-minute load average is not available).
========
=======

`mem`::
(object)
Contains statistics about memory usage for the node.
+
.Properties of `mem`
[%collapsible%open]
=======
`total`::
(<<byte-units,byte value>>)
Total amount of physical memory.

`total_in_bytes`::
(integer)
Total amount of physical memory in bytes.

`free`::
(<<byte-units,byte value>>)
Amount of free physical memory.

`free_in_bytes`::
(integer)
Amount of free physical memory in bytes.

`used`::
(<<byte-units,byte value>>)
Amount of used physical memory.

`used_in_bytes`::
(integer)
Amount of used physical memory in bytes.

`free_percent`::
(integer)
Percentage of free memory.

`used_percent`::
(integer)
Percentage of used memory.
=======

`swap`::
(object)
Contains statistics about swap space for the node.
+
.Properties of `swap`
[%collapsible%open]
=======
`total`::
(<<byte-units,byte value>>)
Total amount of swap space.

`total_in_bytes`::
(integer)
Total amount of swap space in bytes.

`free`::
(<<byte-units,byte value>>)
Amount of free swap space.

`free_in_bytes`::
(integer)
Amount of free swap space in bytes.

`used`::
(<<byte-units,byte value>>)
Amount of used swap space.

`used_in_bytes`::
(integer)
Amount of used swap space in bytes.
=======

`cgroup` (Linux only)::
(object)
Contains cgroup statistics for the node.
+
NOTE: For the cgroup stats to be visible, cgroups must be compiled into the
kernel, the `cpu` and `cpuacct` cgroup subsystems must be configured and stats
must be readable from `/sys/fs/cgroup/cpu` and `/sys/fs/cgroup/cpuacct`.
+
.Properties of `cgroup`
[%collapsible%open]
=======

`cpuacct` (Linux only)::
(object)
Contains statistics about `cpuacct` control group for the node.
+
.Properties of `cpuacct`
[%collapsible%open]
========
`control_group` (Linux only)::
(string)
The `cpuacct` control group to which the {es} process belongs.

`usage_nanos` (Linux only)::
(integer)
The total CPU time (in nanoseconds) consumed by all tasks in the same cgroup
as the {es} process.
========

`cpu` (Linux only)::
(object)
Contains statistics about `cpu` control group for the node.
+
.Properties of `cpu`
[%collapsible%open]
========
`control_group` (Linux only)::
(string)
The `cpu` control group to which the {es} process belongs.

`cfs_period_micros` (Linux only)::
(integer)
The period of time (in microseconds) for how regularly all tasks in the same
cgroup as the {es} process should have their access to CPU resources
reallocated.

`cfs_quota_micros` (Linux only)::
(integer)
The total amount of time (in microseconds) for which all tasks in
the same cgroup as the {es} process can run during one period
`cfs_period_micros`.

`stat` (Linux only)::
(object)
Contains CPU statistics for the node.
+
.Properties of `stat`
[%collapsible%open]
=========
`number_of_elapsed_periods` (Linux only)::
(integer)
The number of reporting periods (as specified by
`cfs_period_micros`) that have elapsed.

`number_of_times_throttled` (Linux only)::
(integer)
The number of times all tasks in the same cgroup as the {es} process have
been throttled.

`time_throttled_nanos` (Linux only)::
(integer)
The total amount of time (in nanoseconds) for which all tasks in the same
cgroup as the {es} process have been throttled.
=========
========

`memory` (Linux only)::
(object)
Contains statistics about the `memory` control group for the node.
+
.Properties of `memory`
[%collapsible%open]
========
`control_group` (Linux only)::
(string)
The `memory` control group to which the {es} process belongs.

`limit_in_bytes` (Linux only)::
(string)
The maximum amount of user memory (including file cache) allowed for all
tasks in the same cgroup as the {es} process. This value can be too big to
store in a `long`, so is returned as a string so that the value returned can
exactly match what the underlying operating system interface returns. Any
value that is too large to parse into a `long` almost certainly means no
limit has been set for the cgroup.

`usage_in_bytes` (Linux only)::
(string)
The total current memory usage by processes in the cgroup (in bytes) by all
tasks in the same cgroup as the {es} process. This value is stored as a
string for consistency with `limit_in_bytes`.
========
=======
======

[[cluster-nodes-stats-api-response-body-process]]
`process`::
(object)
Contains process statistics for the node.
+
.Properties of `process`
[%collapsible%open]
======
`timestamp`::
(integer)
Last time the statistics were refreshed. Recorded in milliseconds
since the {wikipedia}/Unix_time[Unix Epoch].

`open_file_descriptors`::
(integer)
Number of opened file descriptors associated with the current  or
`-1` if not supported.

`max_file_descriptors`::
(integer)
Maximum number of file descriptors allowed on the system, or `-1` if not
supported.

`cpu`::
(object)
Contains CPU statistics for the node.
+
.Properties of `cpu`
[%collapsible%open]
=======
`percent`::
(integer)
CPU usage in percent, or `-1` if not known at the time the stats are
computed.

`total`::
(<<time-units,time value>>)
CPU time used by the process on which the Java virtual machine is running.

`total_in_millis`::
(integer)
CPU time (in milliseconds) used by the process on which the Java virtual
machine is running, or `-1` if not supported.
=======

`mem`::
(object)
Contains virtual memory statistics for the node.
+
.Properties of `mem`
[%collapsible%open]
=======
`total_virtual`::
(<<byte-units,byte value>>)
Size of virtual memory that is guaranteed to be available to the
running process.

`total_virtual_in_bytes`::
(integer)
Size in bytes of virtual memory that is guaranteed to be available to the
running process.
=======
======

[[cluster-nodes-stats-api-response-body-jvm]]
`jvm`::
(object)
Contains Java Virtual Machine (JVM) statistics for the node.
+
.Properties of `jvm`
[%collapsible%open]
======
`timestamp`::
(integer)
Last time JVM statistics were refreshed.

`uptime`::
(<<time-units,time value>>)
JVM uptime.

`uptime_in_millis`::
(integer)
JVM uptime in milliseconds.

`mem`::
(object)
Contains JVM memory usage statistics for the node.
+
.Properties of `mem`
[%collapsible%open]
=======
`heap_used`::
(<<byte-units,byte value>>)
Memory currently in use by the heap.

`heap_used_in_bytes`::
(integer)
Memory, in bytes, currently in use by the heap.

`heap_used_percent`::
(integer)
Percentage of memory currently in use by the heap.

`heap_committed`::
(<<byte-units,byte value>>)
Amount of memory available for use by the heap.

`heap_committed_in_bytes`::
(integer)
Amount of memory, in bytes, available for use by the heap.

`heap_max`::
(<<byte-units,byte value>>)
Maximum amount of memory available for use by the heap.

`heap_max_in_bytes`::
(integer)
Maximum amount of memory, in bytes, available for use by the heap.

`non_heap_used`::
(<<byte-units,byte value>>)
Non-heap memory used.

`non_heap_used_in_bytes`::
(integer)
Non-heap memory used, in bytes.

`non_heap_committed`::
(<<byte-units,byte value>>)
Amount of non-heap memory available.

`non_heap_committed_in_bytes`::
(integer)
Amount of non-heap memory available, in bytes.

`pools`::
(object)
Contains statistics about heap memory usage for the node.
+
.Properties of `pools`
[%collapsible%open]
========

`young`::
(object)
Contains statistics about memory usage by the young generation heap for the
node.
+
.Properties of `young`
[%collapsible%open]
=========
`used`::
(<<byte-units,byte value>>)
Memory used by the young generation heap.

`used_in_bytes`::
(integer)
Memory, in bytes, used by the young generation heap.

`max`::
(<<byte-units,byte value>>)
Maximum amount of memory available for use by the young generation heap.

`max_in_bytes`::
(integer)
Maximum amount of memory, in bytes, available for use by the young generation
heap.

`peak_used`::
(<<byte-units,byte value>>)
Largest amount of memory historically used by the young generation heap.

`peak_used_in_bytes`::
(integer)
Largest amount of memory, in bytes, historically used by the young generation
heap.

`peak_max`::
(<<byte-units,byte value>>)
Largest amount of memory historically used by the young generation heap.

`peak_max_in_bytes`::
(integer)
Largest amount of memory, in bytes, historically used by the young generation
heap.
=========

`survivor`::
(object)
Contains statistics about memory usage by the survivor space for the node.
+
.Properties of `survivor`
[%collapsible%open]
=========
`used`::
(<<byte-units,byte value>>)
Memory used by the survivor space.

`used_in_bytes`::
(integer)
Memory, in bytes, used by the survivor space.

`max`::
(<<byte-units,byte value>>)
Maximum amount of memory available for use by the survivor space.

`max_in_bytes`::
(integer)
Maximum amount of memory, in bytes, available for use by the survivor space.

`peak_used`::
(<<byte-units,byte value>>)
Largest amount of memory historically used by the survivor space.

`peak_used_in_bytes`::
(integer)
Largest amount of memory, in bytes, historically used by the survivor space.

`peak_max`::
(<<byte-units,byte value>>)
Largest amount of memory historically used by the survivor space.

`peak_max_in_bytes`::
(integer)
Largest amount of memory, in bytes, historically used by the survivor space.
=========

`old`::
(object)
Contains statistics about memory usage by the old generation heap for the node.
+
.Properties of `old`
[%collapsible%open]
=========
`used`::
(<<byte-units,byte value>>)
Memory used by the old generation heap.

`used_in_bytes`::
(integer)
Memory, in bytes, used by the old generation heap.

`max`::
(<<byte-units,byte value>>)
Maximum amount of memory available for use by the old generation heap.

`max_in_bytes`::
(integer)
Maximum amount of memory, in bytes, available for use by the old generation
heap.

`peak_used`::
(<<byte-units,byte value>>)
Largest amount of memory historically used by the old generation heap.

`peak_used_in_bytes`::
(integer)
Largest amount of memory, in bytes, historically used by the old generation
heap.

`peak_max`::
(<<byte-units,byte value>>)
Highest memory limit historically available for use by the old generation heap.

`peak_max_in_bytes`::
(integer)
Highest memory limit, in bytes, historically available for use by the old
generation heap.
=========
========
=======

`threads`::
(object)
Contains statistics about JVM thread usage for the node.
+
.Properties of `threads`
[%collapsible%open]
=======
`count`::
(integer)
Number of active threads in use by JVM.

`peak_count`::
(integer)
Highest number of threads used by JVM.
=======

`gc`::
(object)
Contains statistics about JVM garbage collectors for the node.
+
.Properties of `gc`
[%collapsible%open]
=======
`collectors`::
(object)
Contains statistics about JVM garbage collectors for the node.
+
.Properties of `collectors`
[%collapsible%open]
========
`young`::
(object)
Contains statistics about JVM garbage collectors that collect young generation
objects for the node.
+
.Properties of `young`
[%collapsible%open]
=========
`collection_count`::
(integer)
Number of JVM garbage collectors that collect young generation objects.

`collection_time`::
(<<time-units,time value>>)
Total time spent by JVM collecting young generation objects.

`collection_time_in_millis`::
(integer)
Total time in milliseconds spent by JVM collecting young generation objects.
=========

`old`::
(object)
Contains statistics about JVM garbage collectors that collect old generation
objects for the node.
+
.Properties of `old`
[%collapsible%open]
=========
`collection_count`::
(integer)
Number of JVM garbage collectors that collect old generation objects.

`collection_time`::
(<<time-units,time value>>)
Total time spent by JVM collecting old generation objects.

`collection_time_in_millis`::
(integer)
Total time in milliseconds spent by JVM collecting old generation objects.
=========
========
=======

`buffer_pools`::
(object)
Contains statistics about JVM buffer pools for the node.
+
.Properties of `buffer_pools`
[%collapsible%open]
=======
`mapped`::
(object)
Contains statistics about mapped JVM buffer pools for the node.
+
.Properties of `mapped`
[%collapsible%open]
========
`count`::
(integer)
Number of mapped buffer pools.

`used`::
(<<byte-units,byte value>>)
Size of mapped buffer pools.

`used_in_bytes`::
(integer)
Size, in bytes, of mapped buffer pools.

`total_capacity`::
(<<byte-units,byte value>>)
Total capacity of mapped buffer pools.

`total_capacity_in_bytes`::
(integer)
Total capacity, in bytes, of mapped buffer pools.
========

`direct`::
(object)
Contains statistics about direct JVM buffer pools for the node.
+
.Properties of `direct`
[%collapsible%open]
========
`count`::
(integer)
Number of direct buffer pools.

`used`::
(<<byte-units,byte value>>)
Size of direct buffer pools.

`used_in_bytes`::
(integer)
Size, in bytes, of direct buffer pools.

`total_capacity`::
(<<byte-units,byte value>>)
Total capacity of direct buffer pools.

`total_capacity_in_bytes`::
(integer)
Total capacity, in bytes, of direct buffer pools.
========
=======

`classes`::
(object)
Contains statistics about classes loaded by JVM for the node.
+
.Properties of `classes`
[%collapsible%open]
=======
`current_loaded_count`::
(integer)
Number of classes currently loaded by JVM.

`total_loaded_count`::
(integer)
Total number of classes loaded since the JVM started.

`total_unloaded_count`::
(integer)
Total number of classes unloaded since the JVM started.
=======
======

[[cluster-nodes-stats-api-response-body-threadpool]]
`thread_pool`::
(object)
Contains thread pool statistics for the node
+
.Properties of `thread_pool`
[%collapsible%open]
======
`<thread_pool_name>`::
(object)
Contains statistics about the thread pool for the node.
+
.Properties of `<thread_pool_name>`
[%collapsible%open]
=======
`threads`::
(integer)
Number of threads in the thread pool.

`queue`::
(integer)
Number of tasks in queue for the thread pool.

`active`::
(integer)
Number of active threads in the thread pool.

`rejected`::
(integer)
Number of tasks rejected by the thread pool executor.

`largest`::
(integer)
Highest number of active threads in the thread pool.

`completed`::
(integer)
Number of tasks completed by the thread pool executor.
=======
======

[[cluster-nodes-stats-api-response-body-fs]]
`fs`::
(object)
Contains file store statistics for the node.
+
.Properties of `fs`
[%collapsible%open]
======
`timestamp`::
(integer)
Last time the file stores statistics were refreshed. Recorded in
milliseconds since the {wikipedia}/Unix_time[Unix Epoch].

`total`::
(object)
Contains statistics for all file stores of the node.
+
.Properties of `total`
[%collapsible%open]
=======
`total`::
(<<byte-units,byte value>>)
Total size of all file stores.

`total_in_bytes`::
(integer)
Total size (in bytes) of all file stores.

`free`::
(<<byte-units,byte value>>)
Total unallocated disk space in all file stores.

`free_in_bytes`::
(integer)
Total number of unallocated bytes in all file stores.

`available`::
(<<byte-units,byte value>>)
Total disk space available to this Java virtual machine on all file
stores. Depending on OS or process level restrictions, this might appear
less than `free`. This is the actual amount of free disk
space the {es} node can utilise.

`available_in_bytes`::
(integer)
Total number of bytes available to this Java virtual machine on all file
stores. Depending on OS or process level restrictions, this might appear
less than `free_in_bytes`. This is the actual amount of free disk
space the {es} node can utilise.
=======

[[cluster-nodes-stats-fs-data]]
`data`::
(array of objects)
List of all file stores.
+
.Properties of `data`
[%collapsible%open]
=======
`path`::
(string)
Path to the file store.

`mount`::
(string)
Mount point of the file store (ex: /dev/sda2).

`type`::
(string)
Type of the file store (ex: ext4).

`total`::
(<<byte-units,byte value>>)
Total size of the file store.

`total_in_bytes`::
(integer)
Total size (in bytes) of the file store.

`free`::
(<<byte-units,byte value>>)
Total amount of unallocated disk space in the file store.

`free_in_bytes`::
(integer)
Total number of unallocated bytes in the file store.

`available`::
(<<byte-units,byte value>>)
Total amount of disk space available to this Java virtual machine on this file
store.

`available_in_bytes`::
(integer)
Total number of bytes available to this Java virtual machine on this file
store.
=======

`io_stats` (Linux only)::
(objects)
Contains I/O statistics for the node.
+
.Properties of `io_stats`
[%collapsible%open]
=======
`devices` (Linux only)::
(array)
Array of disk metrics for each device that is backing an {es} data path.
These disk metrics are probed periodically and averages between the last
probe and the current probe are computed.
+
.Properties of `devices`
[%collapsible%open]
========
`device_name` (Linux only)::
(string)
The Linux device name.

`operations` (Linux only)::
(integer)
The total number of read and write operations for the device completed since
starting {es}.

`read_operations` (Linux only)::
(integer)
The total number of read operations for the device completed since starting
{es}.

`write_operations` (Linux only)::
(integer)
The total number of write operations for the device completed since starting
{es}.

`read_kilobytes` (Linux only)::
(integer)
The total number of kilobytes read for the device since starting {es}.

`write_kilobytes` (Linux only)::
(integer)
The total number of kilobytes written for the device since starting {es}.
========

`operations` (Linux only)::
    (integer)
    The total number of read and write operations across all devices used by
    {es} completed since starting {es}.

`read_operations` (Linux only)::
    (integer)
    The total number of read operations for across all devices used by {es}
    completed since starting {es}.

`write_operations` (Linux only)::
    (integer)
    The total number of write operations across all devices used by {es}
    completed since starting {es}.

`read_kilobytes` (Linux only)::
    (integer)
    The total number of kilobytes read across all devices used by {es} since
    starting {es}.

`write_kilobytes` (Linux only)::
    (integer)
    The total number of kilobytes written across all devices used by {es} since
    starting {es}.
=======
======

[[cluster-nodes-stats-api-response-body-transport]]
`transport`::
(object)
Contains transport statistics for the node.
+
.Properties of `transport`
[%collapsible%open]
======
`server_open`::
(integer)
Current number of inbound TCP connections used for internal communication between nodes.

`total_outbound_connections`::
(integer)
The cumulative number of outbound transport connections that this node has
opened since it started. Each transport connection may comprise multiple TCP
connections but is only counted once in this statistic. Transport connections
are typically <<long-lived-connections,long-lived>> so this statistic should
remain constant in a stable cluster.

`rx_count`::
(integer)
Total number of RX (receive) packets received by the node during internal
cluster communication.

`rx_size`::
(<<byte-units,byte value>>)
Size of RX packets received by the node during internal cluster communication.

`rx_size_in_bytes`::
(integer)
Size, in bytes, of RX packets received by the node during internal cluster
communication.

`tx_count`::
(integer)
Total number of TX (transmit) packets sent by the node during internal cluster
communication.

`tx_size`::
(<<byte-units,byte value>>)
Size of TX packets sent by the node during internal cluster communication.

`tx_size_in_bytes`::
(integer)
Size, in bytes, of TX packets sent by the node during internal cluster
communication.
======

[[cluster-nodes-stats-api-response-body-http]]
`http`::
(object)
Contains http statistics for the node.
+
.Properties of `http`
[%collapsible%open]
======
`current_open`::
(integer)
Current number of open HTTP connections for the node.

`total_opened`::
(integer)
Total number of HTTP connections opened for the node.
======

[[cluster-nodes-stats-api-response-body-breakers]]
`beakers`::
(object)
Contains circuit breaker statistics for the node.
+
.Properties of `breakers`
[%collapsible%open]
======
`<circuit_breaker_name>`::
(object)
Contains statistics for the circuit breaker.
+
.Properties of `<circuit_breaker_name>`
[%collapsible%open]
=======
`limit_size_in_bytes`::
(integer)
Memory limit, in bytes, for the circuit breaker.

`limit_size`::
(<<byte-units,byte value>>)
Memory limit for the circuit breaker.

`estimated_size_in_bytes`::
(integer)
Estimated memory used, in bytes, for the operation.

`estimated_size`::
(<<byte-units,byte value>>)
Estimated memory used for the operation.

`overhead`::
(float)
A constant that all estimates for the circuit breaker are multiplied with to
calculate a final estimate.

`tripped`::
(integer)
Total number of times the circuit breaker has been triggered and prevented an
out of memory error.
=======
======

[[cluster-nodes-stats-api-response-body-script]]
`script`::
(object)
Contains script statistics for the node.
+
.Properties of `script`
[%collapsible%open]
======
`compilations`::
(integer)
Total number of inline script compilations performed by the node.

`cache_evictions`::
(integer)
Total number of times the script cache has evicted old data.

`compilation_limit_triggered`::
(integer)
Total number of times the <<script-compilation-circuit-breaker,script
compilation>> circuit breaker has limited inline script compilations.
======

[[cluster-nodes-stats-api-response-body-discovery]]
`discovery`::
(object)
Contains node discovery statistics for the node.
+
.Properties of `discovery`
[%collapsible%open]
======
`cluster_state_queue`::
(object)
Contains statistics for the cluster state queue of the node.
+
.Properties of `cluster_state_queue`
[%collapsible%open]
=======
`total`::
(integer)
Total number of cluster states in queue.

`pending`::
(integer)
Number of pending cluster states in queue.

`committed`::
(integer)
Number of committed cluster states in queue.
=======

`published_cluster_states`::
(object)
Contains statistics for the published cluster states of the node.
+
.Properties of `published_cluster_states`
[%collapsible%open]
=======
`full_states`::
(integer)
Number of published cluster states.

`incompatible_diffs`::
(integer)
Number of incompatible differences between published cluster states.

`compatible_diffs`::
(integer)
Number of compatible differences between published cluster states.
=======
======

[[cluster-nodes-stats-api-response-body-ingest]]
`ingest`::
(object)
Contains ingest statistics for the node.
+
.Properties of `ingest`
[%collapsible%open]
======
`total`::
(object)
Contains statistics about ingest operations for the node.
+
.Properties of `total`
[%collapsible%open]
=======
`count`::
(integer)
Total number of documents ingested during the lifetime of this node.

`time`::
(<<time-units,time value>>)
Total time spent preprocessing ingest documents during the lifetime of this
node.

`time_in_millis`::
(integer)
Total time, in milliseconds, spent preprocessing ingest documents during the
lifetime of this node.

`current`::
(integer)
Total number of documents currently being ingested.

`failed`::
(integer)
Total number of failed ingest operations during the lifetime of this node.
=======

`pipelines`::
(object)
Contains statistics about ingest pipelines for the node.
+
.Properties of `pipelines`
[%collapsible%open]
=======
`<pipeline_id>`::
(object)
Contains statistics about the ingest pipeline.
+
.Properties of `<pipeline_id>`
[%collapsible%open]
========
`count`::
(integer)
Number of documents preprocessed by the ingest pipeline.

`time`::
(<<time-units,time value>>)
Total time spent preprocessing documents in the ingest pipeline.

`time_in_millis`::
(integer)
Total time, in milliseconds, spent preprocessing documents in the ingest
pipeline.

`failed`::
(integer)
Total number of failed operations for the ingest pipeline.

`processors`::
(array of objects)
Contains statistics for the ingest processors for the ingest pipeline.
+
.Properties of `processors`
[%collapsible%open]
=========
`<processor>`::
(object)
Contains statistics for the ingest processor.
+
.Properties of `<processor>`
[%collapsible%open]
==========
`count`::
(integer)
Number of documents transformed by the processor.

`time`::
(<<time-units,time value>>)
Time spent by the processor transforming documents.

`time_in_millis`::
(integer)
Time, in milliseconds, spent by the processor transforming documents.

`current`::
(integer)
Number of documents currently being transformed by the processor.

`failed`::
(integer)
Number of failed operations for the processor.
==========
=========
========
=======
======

[[cluster-nodes-stats-api-response-body-indexing-pressure]]
`indexing_pressure`::
(object)
Contains <<index-modules-indexing-pressure,indexing pressure>> statistics for the node.
+
.Properties of `indexing_pressure`
[%collapsible%open]
======
`memory`::
(object)
Contains statistics for memory consumption from indexing load.
+
.Properties of `<memory>`
[%collapsible%open]
=======
`current`::
(object)
Contains statistics for current indexing load.
+
.Properties of `<current>`
[%collapsible%open]
========
`combined_coordinating_and_primary`::
(<<byte-units,byte value>>)
Memory consumed by indexing requests in the coordinating or primary stage. This
value is not the sum of coordinating and primary as a node can reuse the
coordinating memory if the primary stage is executed locally.

`combined_coordinating_and_primary_in_bytes`::
(integer)
Memory consumed, in bytes, by indexing requests in the coordinating or primary
stage. This value is not the sum of coordinating and primary as a node can
reuse the coordinating memory if the primary stage is executed locally.

`coordinating`::
(<<byte-units,byte value>>)
Memory consumed by indexing requests in the coordinating stage.

`coordinating_in_bytes`::
(integer)
Memory consumed, in bytes, by indexing requests in the coordinating stage.

`primary`::
(<<byte-units,byte value>>)
Memory consumed by indexing requests in the primary stage.

`primary_in_bytes`::
(integer)
Memory consumed, in bytes, by indexing requests in the primary stage.

`replica`::
(<<byte-units,byte value>>)
Memory consumed by indexing requests in the replica stage.

`replica_in_bytes`::
(integer)
Memory consumed, in bytes, by indexing requests in the replica stage.

`all`::
(<<byte-units,byte value>>)
Memory consumed by indexing requests in the coordinating, primary, or replica stage.

`all_in_bytes`::
(integer)
Memory consumed, in bytes, by indexing requests in the coordinating, primary,
or replica stage.
========
`total`::
(object)
Contains statistics for the cumulative indexing load since the node started.
+
.Properties of `<total>`
[%collapsible%open]
========
`combined_coordinating_and_primary`::
(<<byte-units,byte value>>)
Memory consumed by indexing requests in the coordinating or primary stage. This
value is not the sum of coordinating and primary as a node can reuse the
coordinating memory if the primary stage is executed locally.

`combined_coordinating_and_primary_in_bytes`::
(integer)
Memory consumed, in bytes, by indexing requests in the coordinating or primary
stage. This value is not the sum of coordinating and primary as a node can
reuse the coordinating memory if the primary stage is executed locally.

`coordinating`::
(<<byte-units,byte value>>)
Memory consumed by indexing requests in the coordinating stage.

`coordinating_in_bytes`::
(integer)
Memory consumed, in bytes, by indexing requests in the coordinating stage.

`primary`::
(<<byte-units,byte value>>)
Memory consumed by indexing requests in the primary stage.

`primary_in_bytes`::
(integer)
Memory consumed, in bytes, by indexing requests in the primary stage.

`replica`::
(<<byte-units,byte value>>)
Memory consumed by indexing requests in the replica stage.

`replica_in_bytes`::
(integer)
Memory consumed, in bytes, by indexing requests in the replica stage.

`all`::
(<<byte-units,byte value>>)
Memory consumed by indexing requests in the coordinating, primary, or replica stage.

`all_in_bytes`::
(integer)
Memory consumed, in bytes, by indexing requests in the coordinating, primary,
or replica stage.

`coordinating_rejections`::
(integer)
Number of indexing requests rejected in the coordinating stage.

`primary_rejections`::
(integer)
Number of indexing requests rejected in the primary stage.

`replica_rejections`::
(integer)
Number of indexing requests rejected in the replica stage.
========
`limit`::
(<<byte-units,byte value>>)
Configured memory limit for the indexing requests. Replica requests have an
automatic limit that is 1.5x this value.

`limit_in_bytes`::
(integer)
Configured memory limit, in bytes, for the indexing requests. Replica requests
have an automatic limit that is 1.5x this value.
=======
======

[[cluster-nodes-stats-api-response-body-adaptive-selection]]
`adaptive_selection`::
(object)
Contains adaptive selection statistics for the node.
+
.Properties of `adaptive_selection`
[%collapsible%open]
======
`outgoing_searches`::
(integer)
The number of outstanding search requests from the node these stats are for
to the keyed node.

`avg_queue_size`::
(integer)
The exponentially weighted moving average queue size of search requests on
the keyed node.

`avg_service_time`::
(<<time-units,time value>>)
The exponentially weighted moving average service time of search requests on
the keyed node.

`avg_service_time_ns`::
(integer)
The exponentially weighted moving average service time, in nanoseconds, of
search requests on the keyed node.

`avg_response_time`::
(<<time-units,time value>>)
The exponentially weighted moving average response time of search requests
on the keyed node.

`avg_response_time_ns`::
(integer)
The exponentially weighted moving average response time, in nanoseconds, of
search requests on the keyed node.

`rank`::
(string)
The rank of this node; used for shard selection when routing search
requests.
======
=====
====

[[cluster-nodes-stats-api-example]]
==== {api-examples-title}

[source,console]
--------------------------------------------------
# return just indices
GET /_nodes/stats/indices

# return just os and process
GET /_nodes/stats/os,process

# return just process for node with IP address 10.0.0.1
GET /_nodes/10.0.0.1/stats/process
--------------------------------------------------

All stats can be explicitly requested via `/_nodes/stats/_all` or
`/_nodes/stats?metric=_all`.

You can get information about indices stats on `node`, `indices`, or `shards`
level.

[source,console]
--------------------------------------------------
# Fielddata summarized by node
GET /_nodes/stats/indices/fielddata?fields=field1,field2

# Fielddata summarized by node and index
GET /_nodes/stats/indices/fielddata?level=indices&fields=field1,field2

# Fielddata summarized by node, index, and shard
GET /_nodes/stats/indices/fielddata?level=shards&fields=field1,field2

# You can use wildcards for field names
GET /_nodes/stats/indices/fielddata?fields=field*
--------------------------------------------------

You can get statistics about search groups for searches executed
on this node.

[source,console]
--------------------------------------------------
# All groups with all stats
GET /_nodes/stats?groups=_all

# Some groups from just the indices stats
GET /_nodes/stats/indices?groups=foo,bar
--------------------------------------------------

[[cluster-nodes-stats-ingest-ex]]
===== Retrieve ingest statistics only

To return only ingest-related node statistics, set the `<metric>` path
parameter to `ingest` and use the
<<common-options-response-filtering,`filter_path`>> query parameter.

[source,console]
--------------------------------------------------
GET /_nodes/stats/ingest?filter_path=nodes.*.ingest
--------------------------------------------------

You can use the `metric` and `filter_path` query parameters to get the same
response.

[source,console]
--------------------------------------------------
GET /_nodes/stats?metric=ingest&filter_path=nodes.*.ingest
--------------------------------------------------

To further refine the response, change the `filter_path` value.
For example, the following request only returns ingest pipeline statistics.

[source,console]
--------------------------------------------------
GET /_nodes/stats?metric=ingest&filter_path=nodes.*.ingest.pipelines
--------------------------------------------------
",12276,True,2566.4649909894415,median
"// tag::HeaderFullDisplayName[]
= reference.ReferenceTree_cyclic_union - V
// end::HeaderFullDisplayName[]

== existing_properties

// tag::existing_properties[]

:ExistsProperty--antorareferencedlist:
:ExistsProperty--antorareferencinglist:
:ExistsProperty--is_repo_managed:
:ExistsProperty--is_ssas:
:ExistsProperty--referencedobjectlist:
:ExistsProperty--sql_modules_definition:
:ExistsProperty--FK:
:ExistsProperty--Columns:
// end::existing_properties[]

== RepoObject_guid

// tag::RepoObject_guid[]
83E72F09-C5FD-EB11-850F-A81E8446D5B0
// end::RepoObject_guid[]

== RepoObject_FullDisplayName2

// tag::RepoObject_FullDisplayName2[]
reference.ReferenceTree_cyclic_union
// end::RepoObject_FullDisplayName2[]

== SysObject_type

// tag::SysObject_type[]
V 
// end::SysObject_type[]

== SysObject_type_name

// tag::SysObject_type_name[]
view
// end::SysObject_type_name[]

== SysObject_id

// tag::SysObject_id[]
753437758
// end::SysObject_id[]

== SysObject_modify_date

// tag::SysObject_modify_date[]
2021-08-17 19:11:15
// end::SysObject_modify_date[]

== AntoraColumnDetails

// tag::AntoraColumnDetails[]
[discrete]
== _


[#column-referencedunderlinefullname]
=== Referenced_fullname

[cols=""d,8a,m,m,m""]
|===
|
|Referenced_fullname
|nvarchar(261)
|NULL
|
|===


[#column-referencedunderlinefullname2]
=== Referenced_fullname2

[cols=""d,8a,m,m,m""]
|===
|
|Referenced_fullname2
|nvarchar(257)
|NULL
|
|===


[#column-referencedunderlineguid]
=== Referenced_guid

[cols=""d,8a,m,m,m""]
|===
|
|Referenced_guid
|uniqueidentifier
|NOT NULL
|
|===


[#column-referencedunderlinetype]
=== Referenced_type

[cols=""d,8a,m,m,m""]
|===
|
|Referenced_type
|char(2)
|NULL
|
|===


[#column-referencingunderlinefullname]
=== Referencing_fullname

[cols=""d,8a,m,m,m""]
|===
|
|Referencing_fullname
|nvarchar(261)
|NULL
|
|===


[#column-referencingunderlinefullname2]
=== Referencing_fullname2

[cols=""d,8a,m,m,m""]
|===
|
|Referencing_fullname2
|nvarchar(257)
|NULL
|
|===


[#column-referencingunderlineguid]
=== Referencing_guid

[cols=""d,8a,m,m,m""]
|===
|
|Referencing_guid
|uniqueidentifier
|NOT NULL
|
|===


[#column-referencingunderlinetype]
=== Referencing_type

[cols=""d,8a,m,m,m""]
|===
|
|Referencing_type
|varchar(2)
|NULL
|
|===


// end::AntoraColumnDetails[]

== AntoraPkColumnTableRows

// tag::AntoraPkColumnTableRows[]








// end::AntoraPkColumnTableRows[]

== AntoraNonPkColumnTableRows

// tag::AntoraNonPkColumnTableRows[]
|
|<<column-referencedunderlinefullname>>
|nvarchar(261)
|NULL
|

|
|<<column-referencedunderlinefullname2>>
|nvarchar(257)
|NULL
|

|
|<<column-referencedunderlineguid>>
|uniqueidentifier
|NOT NULL
|

|
|<<column-referencedunderlinetype>>
|char(2)
|NULL
|

|
|<<column-referencingunderlinefullname>>
|nvarchar(261)
|NULL
|

|
|<<column-referencingunderlinefullname2>>
|nvarchar(257)
|NULL
|

|
|<<column-referencingunderlineguid>>
|uniqueidentifier
|NOT NULL
|

|
|<<column-referencingunderlinetype>>
|varchar(2)
|NULL
|

// end::AntoraNonPkColumnTableRows[]

== AntoraIndexList

// tag::AntoraIndexList[]

// end::AntoraIndexList[]

== AntoraMeasureDetails

// tag::AntoraMeasureDetails[]

// end::AntoraMeasureDetails[]

== AntoraMeasureDescriptions



== AntoraParameterList

// tag::AntoraParameterList[]

// end::AntoraParameterList[]

== AntoraXrefCulturesList

// tag::AntoraXrefCulturesList[]
* xref:dhw:sqldb:reference.referencetree_cyclic_union.adoc[] - 
// end::AntoraXrefCulturesList[]

== cultures_count

// tag::cultures_count[]
1
// end::cultures_count[]

== Other tags

source: property.RepoObjectProperty_cross As rop_cross


=== additional_reference_csv

// tag::additional_reference_csv[]

// end::additional_reference_csv[]


=== AdocUspSteps

// tag::adocuspsteps[]

// end::adocuspsteps[]


=== AntoraReferencedList

// tag::antorareferencedlist[]
* xref:dhw:sqldb:reference.referencetree_cyclic_ref_persistenceusp.adoc[]
* xref:dhw:sqldb:reference.referencetree_cyclic_ref_primary.adoc[]
// end::antorareferencedlist[]


=== AntoraReferencingList

// tag::antorareferencinglist[]
* xref:dhw:sqldb:docs.objectrefcyclic_entitylist.adoc[]
* xref:dhw:sqldb:docs.objectrefcyclic_objectreflist.adoc[]
// end::antorareferencinglist[]


=== Description

// tag::description[]

// end::description[]


=== exampleUsage

// tag::exampleusage[]

// end::exampleusage[]


=== exampleUsage_2

// tag::exampleusage_2[]

// end::exampleusage_2[]


=== exampleUsage_3

// tag::exampleusage_3[]

// end::exampleusage_3[]


=== exampleUsage_4

// tag::exampleusage_4[]

// end::exampleusage_4[]


=== exampleUsage_5

// tag::exampleusage_5[]

// end::exampleusage_5[]


=== exampleWrong_Usage

// tag::examplewrong_usage[]

// end::examplewrong_usage[]


=== has_execution_plan_issue

// tag::has_execution_plan_issue[]

// end::has_execution_plan_issue[]


=== has_get_referenced_issue

// tag::has_get_referenced_issue[]

// end::has_get_referenced_issue[]


=== has_history

// tag::has_history[]

// end::has_history[]


=== has_history_columns

// tag::has_history_columns[]

// end::has_history_columns[]


=== InheritanceType

// tag::inheritancetype[]

// end::inheritancetype[]


=== is_persistence

// tag::is_persistence[]

// end::is_persistence[]


=== is_persistence_check_duplicate_per_pk

// tag::is_persistence_check_duplicate_per_pk[]

// end::is_persistence_check_duplicate_per_pk[]


=== is_persistence_check_for_empty_source

// tag::is_persistence_check_for_empty_source[]

// end::is_persistence_check_for_empty_source[]


=== is_persistence_delete_changed

// tag::is_persistence_delete_changed[]

// end::is_persistence_delete_changed[]


=== is_persistence_delete_missing

// tag::is_persistence_delete_missing[]

// end::is_persistence_delete_missing[]


=== is_persistence_insert

// tag::is_persistence_insert[]

// end::is_persistence_insert[]


=== is_persistence_truncate

// tag::is_persistence_truncate[]

// end::is_persistence_truncate[]


=== is_persistence_update_changed

// tag::is_persistence_update_changed[]

// end::is_persistence_update_changed[]


=== is_repo_managed

// tag::is_repo_managed[]
0
// end::is_repo_managed[]


=== is_ssas

// tag::is_ssas[]
0
// end::is_ssas[]


=== microsoft_database_tools_support

// tag::microsoft_database_tools_support[]

// end::microsoft_database_tools_support[]


=== MS_Description

// tag::ms_description[]

// end::ms_description[]


=== persistence_source_RepoObject_fullname

// tag::persistence_source_repoobject_fullname[]

// end::persistence_source_repoobject_fullname[]


=== persistence_source_RepoObject_fullname2

// tag::persistence_source_repoobject_fullname2[]

// end::persistence_source_repoobject_fullname2[]


=== persistence_source_RepoObject_guid

// tag::persistence_source_repoobject_guid[]

// end::persistence_source_repoobject_guid[]


=== persistence_source_RepoObject_xref

// tag::persistence_source_repoobject_xref[]

// end::persistence_source_repoobject_xref[]


=== pk_index_guid

// tag::pk_index_guid[]

// end::pk_index_guid[]


=== pk_IndexPatternColumnDatatype

// tag::pk_indexpatterncolumndatatype[]

// end::pk_indexpatterncolumndatatype[]


=== pk_IndexPatternColumnName

// tag::pk_indexpatterncolumnname[]

// end::pk_indexpatterncolumnname[]


=== pk_IndexSemanticGroup

// tag::pk_indexsemanticgroup[]

// end::pk_indexsemanticgroup[]


=== ReferencedObjectList

// tag::referencedobjectlist[]
* [reference].[ReferenceTree_cyclic_ref_PersistenceUsp]
* [reference].[ReferenceTree_cyclic_ref_primary]
// end::referencedobjectlist[]


=== usp_persistence_RepoObject_guid

// tag::usp_persistence_repoobject_guid[]

// end::usp_persistence_repoobject_guid[]


=== UspExamples

// tag::uspexamples[]

// end::uspexamples[]


=== uspgenerator_usp_id

// tag::uspgenerator_usp_id[]

// end::uspgenerator_usp_id[]


=== UspParameters

// tag::uspparameters[]

// end::uspparameters[]

== Boolean Attributes

source: property.RepoObjectProperty WHERE property_int = 1

// tag::boolean_attributes[]


// end::boolean_attributes[]

== PlantUML diagrams

=== PlantUML Entity

// tag::puml_entity[]
[plantuml, entity-{docname}, svg, subs=macros]
....
'Left to right direction
top to bottom direction
hide circle
'avoide ""."" issues:
set namespaceSeparator none


skinparam class {
  BackgroundColor White
  BackgroundColor<<FN>> Yellow
  BackgroundColor<<FS>> Yellow
  BackgroundColor<<FT>> LightGray
  BackgroundColor<<IF>> Yellow
  BackgroundColor<<IS>> Yellow
  BackgroundColor<<P>>  Aqua
  BackgroundColor<<PC>> Aqua
  BackgroundColor<<SN>> Yellow
  BackgroundColor<<SO>> SlateBlue
  BackgroundColor<<TF>> LightGray
  BackgroundColor<<TR>> Tomato
  BackgroundColor<<U>>  White
  BackgroundColor<<V>>  WhiteSmoke
  BackgroundColor<<X>>  Aqua
  BackgroundColor<<external>> AliceBlue
}


entity ""puml-link:dhw:sqldb:reference.referencetree_cyclic_union.adoc[]"" as reference.ReferenceTree_cyclic_union << V >> {
  Referenced_fullname : (nvarchar(261))
  Referenced_fullname2 : (nvarchar(257))
  - Referenced_guid : (uniqueidentifier)
  Referenced_type : (char(2))
  Referencing_fullname : (nvarchar(261))
  Referencing_fullname2 : (nvarchar(257))
  - Referencing_guid : (uniqueidentifier)
  Referencing_type : (varchar(2))
  --
}
....

// end::puml_entity[]

=== PlantUML Entity 1 1 FK

// tag::puml_entity_1_1_fk[]
[plantuml, entity_1_1_fk-{docname}, svg, subs=macros]
....
@startuml
left to right direction
'top to bottom direction
hide circle
'avoide ""."" issues:
set namespaceSeparator none


skinparam class {
  BackgroundColor White
  BackgroundColor<<FN>> Yellow
  BackgroundColor<<FS>> Yellow
  BackgroundColor<<FT>> LightGray
  BackgroundColor<<IF>> Yellow
  BackgroundColor<<IS>> Yellow
  BackgroundColor<<P>>  Aqua
  BackgroundColor<<PC>> Aqua
  BackgroundColor<<SN>> Yellow
  BackgroundColor<<SO>> SlateBlue
  BackgroundColor<<TF>> LightGray
  BackgroundColor<<TR>> Tomato
  BackgroundColor<<U>>  White
  BackgroundColor<<V>>  WhiteSmoke
  BackgroundColor<<X>>  Aqua
  BackgroundColor<<external>> AliceBlue
}


entity ""puml-link:dhw:sqldb:reference.referencetree_cyclic_union.adoc[]"" as reference.ReferenceTree_cyclic_union << V >> {

}



footer The diagram is interactive and contains links.

@enduml
....

// end::puml_entity_1_1_fk[]

=== PlantUML 1 1 ObjectRef

// tag::puml_entity_1_1_objectref[]
[plantuml, entity_1_1_objectref-{docname}, svg, subs=macros]
....
@startuml
left to right direction
'top to bottom direction
hide circle
'avoide ""."" issues:
set namespaceSeparator none


skinparam class {
  BackgroundColor White
  BackgroundColor<<FN>> Yellow
  BackgroundColor<<FS>> Yellow
  BackgroundColor<<FT>> LightGray
  BackgroundColor<<IF>> Yellow
  BackgroundColor<<IS>> Yellow
  BackgroundColor<<P>>  Aqua
  BackgroundColor<<PC>> Aqua
  BackgroundColor<<SN>> Yellow
  BackgroundColor<<SO>> SlateBlue
  BackgroundColor<<TF>> LightGray
  BackgroundColor<<TR>> Tomato
  BackgroundColor<<U>>  White
  BackgroundColor<<V>>  WhiteSmoke
  BackgroundColor<<X>>  Aqua
  BackgroundColor<<external>> AliceBlue
}


entity ""puml-link:dhw:sqldb:docs.objectrefcyclic_entitylist.adoc[]"" as docs.ObjectRefCyclic_EntityList << V >> {
  --
}

entity ""puml-link:dhw:sqldb:docs.objectrefcyclic_objectreflist.adoc[]"" as docs.ObjectRefCyclic_ObjectRefList << V >> {
  --
}

entity ""puml-link:dhw:sqldb:reference.referencetree_cyclic_ref_persistenceusp.adoc[]"" as reference.ReferenceTree_cyclic_ref_PersistenceUsp << V >> {
  --
}

entity ""puml-link:dhw:sqldb:reference.referencetree_cyclic_ref_primary.adoc[]"" as reference.ReferenceTree_cyclic_ref_primary << V >> {
  --
}

entity ""puml-link:dhw:sqldb:reference.referencetree_cyclic_union.adoc[]"" as reference.ReferenceTree_cyclic_union << V >> {
  --
}

reference.ReferenceTree_cyclic_ref_PersistenceUsp <.. reference.ReferenceTree_cyclic_union
reference.ReferenceTree_cyclic_ref_primary <.. reference.ReferenceTree_cyclic_union
reference.ReferenceTree_cyclic_union <.. docs.ObjectRefCyclic_EntityList
reference.ReferenceTree_cyclic_union <.. docs.ObjectRefCyclic_ObjectRefList

footer The diagram is interactive and contains links.

@enduml
....

// end::puml_entity_1_1_objectref[]

=== PlantUML 30 0 ObjectRef

// tag::puml_entity_30_0_objectref[]
[plantuml, entity_30_0_objectref-{docname}, svg, subs=macros]
....
@startuml
'Left to right direction
top to bottom direction
hide circle
'avoide ""."" issues:
set namespaceSeparator none


skinparam class {
  BackgroundColor White
  BackgroundColor<<FN>> Yellow
  BackgroundColor<<FS>> Yellow
  BackgroundColor<<FT>> LightGray
  BackgroundColor<<IF>> Yellow
  BackgroundColor<<IS>> Yellow
  BackgroundColor<<P>>  Aqua
  BackgroundColor<<PC>> Aqua
  BackgroundColor<<SN>> Yellow
  BackgroundColor<<SO>> SlateBlue
  BackgroundColor<<TF>> LightGray
  BackgroundColor<<TR>> Tomato
  BackgroundColor<<U>>  White
  BackgroundColor<<V>>  WhiteSmoke
  BackgroundColor<<X>>  Aqua
  BackgroundColor<<external>> AliceBlue
}


entity ""puml-link:dhw:sqldb:config.ftv_dwh_database.adoc[]"" as config.ftv_dwh_database << IF >> {
  --
}

entity ""puml-link:dhw:sqldb:config.ftv_get_parameter_value.adoc[]"" as config.ftv_get_parameter_value << IF >> {
  --
}

entity ""puml-link:dhw:sqldb:config.parameter.adoc[]"" as config.Parameter << U >> {
  - **Parameter_name** : (varchar(100))
  - **sub_Parameter** : (nvarchar(128))
  --
}

entity ""puml-link:dhw:sqldb:configt.parameter_default.adoc[]"" as configT.Parameter_default << V >> {
  - **Parameter_name** : (varchar(52))
  - **sub_Parameter** : (nvarchar(26))
  --
}

entity ""puml-link:dhw:sqldb:configt.spt_values.adoc[]"" as configT.spt_values << U >> {
  --
}

entity ""puml-link:dhw:sqldb:configt.type.adoc[]"" as configT.type << V >> {
  **type** : (nvarchar(128))
  --
}

entity ""puml-link:dhw:sqldb:docs.fs_cleanstringforfilename.adoc[]"" as docs.fs_cleanStringForFilename << FN >> {
  --
}

entity ""puml-link:dhw:sqldb:property.external_repoobjectproperty.adoc[]"" as property.external_RepoObjectProperty << U >> {
  - **RepoObject_guid** : (uniqueidentifier)
  - **property_name** : (nvarchar(128))
  --
}

entity ""puml-link:dhw:sqldb:property.propertyname_repoobject.adoc[]"" as property.PropertyName_RepoObject << V >> {
  **property_name** : (nvarchar(128))
  --
}

entity ""puml-link:dhw:sqldb:property.propertyname_repoobject_t.adoc[]"" as property.PropertyName_RepoObject_T << U >> {
  **property_name** : (nvarchar(128))
  --
}

entity ""puml-link:dhw:sqldb:property.repoobjectproperty.adoc[]"" as property.RepoObjectProperty << U >> {
  - **RepoObjectProperty_id** : (int)
  --
}

entity ""puml-link:dhw:sqldb:property.repoobjectproperty_external_src.adoc[]"" as property.RepoObjectProperty_external_src << V >> {
  - **RepoObject_guid** : (uniqueidentifier)
  - **property_name** : (nvarchar(128))
  --
}

entity ""puml-link:dhw:sqldb:property.repoobjectproperty_external_tgt.adoc[]"" as property.RepoObjectProperty_external_tgt << V >> {
  - **RepoObject_guid** : (uniqueidentifier)
  - **property_name** : (nvarchar(128))
  --
}

entity ""puml-link:dhw:sqldb:property.repoobjectproperty_selectedpropertyname_split.adoc[]"" as property.RepoObjectProperty_SelectedPropertyName_split << V >> {
  --
}

entity ""puml-link:dhw:sqldb:reference.additional_reference.adoc[]"" as reference.additional_Reference << U >> {
  - **Id** : (int)
  --
}

entity ""puml-link:dhw:sqldb:reference.additional_reference_from_properties_src.adoc[]"" as reference.additional_Reference_from_properties_src << V >> {
  **referenced_AntoraComponent** : (nvarchar(max))
  **referenced_AntoraModule** : (nvarchar(max))
  **referenced_Schema** : (nvarchar(max))
  **referenced_Object** : (nvarchar(max))
  **referenced_Column** : (nvarchar(max))
  **referencing_AntoraComponent** : (nvarchar(max))
  **referencing_AntoraModule** : (nvarchar(max))
  **referencing_Schema** : (nvarchar(max))
  **referencing_Object** : (nvarchar(max))
  **referencing_Column** : (nvarchar(max))
  --
}

entity ""puml-link:dhw:sqldb:reference.additional_reference_from_properties_tgt.adoc[]"" as reference.additional_Reference_from_properties_tgt << V >> {
  **referenced_AntoraComponent** : (nvarchar(max))
  **referenced_AntoraModule** : (nvarchar(max))
  **referenced_Schema** : (nvarchar(max))
  **referenced_Object** : (nvarchar(max))
  **referenced_Column** : (nvarchar(max))
  **referencing_AntoraComponent** : (nvarchar(max))
  **referencing_AntoraModule** : (nvarchar(max))
  **referencing_Schema** : (nvarchar(max))
  **referencing_Object** : (nvarchar(max))
  **referencing_Column** : (nvarchar(max))
  --
}

entity ""puml-link:dhw:sqldb:reference.additional_reference_from_ssas_src.adoc[]"" as reference.additional_Reference_from_ssas_src << V >> {
  **referenced_AntoraComponent** : (nvarchar(128))
  **referenced_AntoraModule** : (nvarchar(128))
  **referenced_Schema** : (nvarchar(max))
  **referenced_Object** : (nvarchar(max))
  **referenced_Column** : (nvarchar(500))
  **referencing_AntoraComponent** : (nvarchar(max))
  **referencing_AntoraModule** : (nvarchar(max))
  - **referencing_Schema** : (nvarchar(128))
  - **referencing_Object** : (nvarchar(128))
  **referencing_Column** : (nvarchar(128))
  --
}

entity ""puml-link:dhw:sqldb:reference.additional_reference_from_ssas_tgt.adoc[]"" as reference.additional_Reference_from_ssas_tgt << V >> {
  **referenced_AntoraComponent** : (nvarchar(128))
  **referenced_AntoraModule** : (nvarchar(128))
  **referenced_Schema** : (nvarchar(max))
  **referenced_Object** : (nvarchar(max))
  **referenced_Column** : (nvarchar(500))
  **referencing_AntoraComponent** : (nvarchar(max))
  **referencing_AntoraModule** : (nvarchar(max))
  - **referencing_Schema** : (nvarchar(128))
  - **referencing_Object** : (nvarchar(128))
  **referencing_Column** : (nvarchar(128))
  --
}

entity ""puml-link:dhw:sqldb:reference.additional_reference_guid.adoc[]"" as reference.additional_Reference_guid << V >> {
  --
}

entity ""puml-link:dhw:sqldb:reference.additional_reference_is_external.adoc[]"" as reference.additional_Reference_is_external << V >> {
  --
}

entity ""puml-link:dhw:sqldb:reference.additional_reference_object.adoc[]"" as reference.additional_Reference_Object << V >> {
  - **AntoraComponent** : (nvarchar(128))
  - **AntoraModule** : (nvarchar(128))
  - **SchemaName** : (nvarchar(128))
  - **ObjectName** : (nvarchar(128))
  --
}

entity ""puml-link:dhw:sqldb:reference.additional_reference_object_t.adoc[]"" as reference.additional_Reference_Object_T << U >> {
  - **RepoObject_guid** : (uniqueidentifier)
  --
}

entity ""puml-link:dhw:sqldb:reference.additional_reference_objectcolumn.adoc[]"" as reference.additional_Reference_ObjectColumn << V >> {
  - **AntoraComponent** : (nvarchar(128))
  - **AntoraModule** : (nvarchar(128))
  - **SchemaName** : (nvarchar(128))
  - **ObjectName** : (nvarchar(128))
  **ColumnName** : (nvarchar(128))
  --
}

entity ""puml-link:dhw:sqldb:reference.additional_reference_objectcolumn_t.adoc[]"" as reference.additional_Reference_ObjectColumn_T << U >> {
  - **RepoObjectColumn_guid** : (uniqueidentifier)
  --
}

entity ""puml-link:dhw:sqldb:reference.additional_reference_wo_columns_from_properties_src.adoc[]"" as reference.additional_Reference_wo_columns_from_properties_src << V >> {
  **referenced_AntoraComponent** : (nvarchar(max))
  **referenced_AntoraModule** : (nvarchar(max))
  **referenced_Schema** : (nvarchar(max))
  **referenced_Object** : (nvarchar(max))
  **referencing_AntoraComponent** : (nvarchar(max))
  **referencing_AntoraModule** : (nvarchar(max))
  **referencing_Schema** : (nvarchar(max))
  **referencing_Object** : (nvarchar(max))
  --
}

entity ""puml-link:dhw:sqldb:reference.additional_reference_wo_columns_from_properties_tgt.adoc[]"" as reference.additional_Reference_wo_columns_from_properties_tgt << V >> {
  **referenced_AntoraComponent** : (nvarchar(max))
  **referenced_AntoraModule** : (nvarchar(max))
  **referenced_Schema** : (nvarchar(max))
  **referenced_Object** : (nvarchar(max))
  **referencing_AntoraComponent** : (nvarchar(max))
  **referencing_AntoraModule** : (nvarchar(max))
  **referencing_Schema** : (nvarchar(max))
  **referencing_Object** : (nvarchar(max))
  --
}

entity ""puml-link:dhw:sqldb:reference.referencetree_cyclic_ref_persistenceusp.adoc[]"" as reference.ReferenceTree_cyclic_ref_PersistenceUsp << V >> {
  --
}

entity ""puml-link:dhw:sqldb:reference.referencetree_cyclic_ref_primary.adoc[]"" as reference.ReferenceTree_cyclic_ref_primary << V >> {
  --
}

entity ""puml-link:dhw:sqldb:reference.referencetree_cyclic_union.adoc[]"" as reference.ReferenceTree_cyclic_union << V >> {
  --
}

entity ""puml-link:dhw:sqldb:reference.repoobject_reference.adoc[]"" as reference.RepoObject_reference << V >> {
  --
}

entity ""puml-link:dhw:sqldb:reference.repoobject_reference_additional.adoc[]"" as reference.RepoObject_reference_additional << V >> {
  --
}

entity ""puml-link:dhw:sqldb:reference.repoobject_reference_persistence.adoc[]"" as reference.RepoObject_reference_persistence << V >> {
  **referenced_RepoObject_guid** : (uniqueidentifier)
  - **referencing_RepoObject_guid** : (uniqueidentifier)
  --
}

entity ""puml-link:dhw:sqldb:reference.repoobject_reference_persistence_target_as_source.adoc[]"" as reference.RepoObject_reference_persistence_target_as_source << V >> {
  --
}

entity ""puml-link:dhw:sqldb:reference.repoobject_reference_sqlexpressiondependencies.adoc[]"" as reference.RepoObject_reference_SqlExpressionDependencies << V >> {
  **referenced_RepoObject_guid** : (uniqueidentifier)
  **referencing_RepoObject_guid** : (uniqueidentifier)
  --
}

entity ""puml-link:dhw:sqldb:reference.repoobject_reference_t.adoc[]"" as reference.RepoObject_reference_T << U >> {
  **referenced_RepoObject_guid** : (uniqueidentifier)
  **referencing_RepoObject_guid** : (uniqueidentifier)
  --
}

entity ""puml-link:dhw:sqldb:reference.repoobject_reference_union.adoc[]"" as reference.RepoObject_reference_union << V >> {
  **referenced_RepoObject_guid** : (uniqueidentifier)
  **referencing_RepoObject_guid** : (uniqueidentifier)
  --
}

entity ""puml-link:dhw:sqldb:reference.repoobject_reference_virtual.adoc[]"" as reference.RepoObject_reference_virtual << V >> {
  --
}

entity ""puml-link:dhw:sqldb:reference.repoobject_referencetree.adoc[]"" as reference.RepoObject_ReferenceTree << U >> {
  - **RepoObject_guid** : (uniqueidentifier)
  **Referenced_Depth** : (int)
  **Referencing_Depth** : (int)
  - **Referenced_guid** : (uniqueidentifier)
  - **Referencing_guid** : (uniqueidentifier)
  --
}

entity ""puml-link:dhw:sqldb:reference.repoobject_referencetree_cyclic.adoc[]"" as reference.RepoObject_ReferenceTree_cyclic << V >> {
  --
}

entity ""puml-link:dhw:sqldb:reference.repoobjectsource_virtual.adoc[]"" as reference.RepoObjectSource_virtual << U >> {
  - **RepoObject_guid** : (uniqueidentifier)
  - **Source_RepoObject_guid** : (uniqueidentifier)
  --
}

entity ""puml-link:dhw:sqldb:repo.repoobject.adoc[]"" as repo.RepoObject << U >> {
  - **RepoObject_guid** : (uniqueidentifier)
  --
}

entity ""puml-link:dhw:sqldb:repo.repoobject_external_src.adoc[]"" as repo.RepoObject_external_src << V >> {
  - **RepoObject_guid** : (uniqueidentifier)
  --
}

entity ""puml-link:dhw:sqldb:repo.repoobject_external_tgt.adoc[]"" as repo.RepoObject_external_tgt << V >> {
  - **RepoObject_guid** : (uniqueidentifier)
  --
}

entity ""puml-link:dhw:sqldb:repo.repoobject_gross_persistence.adoc[]"" as repo.RepoObject_gross_persistence << V >> {
  --
}

entity ""puml-link:dhw:sqldb:repo.repoobject_persistence.adoc[]"" as repo.RepoObject_persistence << U >> {
  - **target_RepoObject_guid** : (uniqueidentifier)
  --
}

entity ""puml-link:dhw:sqldb:repo.repoobject_ssas_src.adoc[]"" as repo.RepoObject_SSAS_src << V >> {
  - **RepoObject_guid** : (uniqueidentifier)
  --
}

entity ""puml-link:dhw:sqldb:repo.repoobject_ssas_tgt.adoc[]"" as repo.RepoObject_SSAS_tgt << V >> {
  - **RepoObject_guid** : (uniqueidentifier)
  --
}

entity ""puml-link:dhw:sqldb:repo.repoobjectcolumn.adoc[]"" as repo.RepoObjectColumn << U >> {
  - **RepoObjectColumn_guid** : (uniqueidentifier)
  --
}

entity ""puml-link:dhw:sqldb:repo.repoobjectcolumn_external_src.adoc[]"" as repo.RepoObjectColumn_external_src << V >> {
  - **RepoObjectColumn_guid** : (uniqueidentifier)
  --
}

entity ""puml-link:dhw:sqldb:repo.repoobjectcolumn_external_tgt.adoc[]"" as repo.RepoObjectColumn_external_tgt << V >> {
  - **RepoObjectColumn_guid** : (uniqueidentifier)
  --
}

entity ""puml-link:dhw:sqldb:repo.repoobjectcolumn_ssas_src.adoc[]"" as repo.RepoObjectColumn_SSAS_src << V >> {
  - **RepoObjectColumn_guid** : (uniqueidentifier)
  --
}

entity ""puml-link:dhw:sqldb:repo.repoobjectcolumn_ssas_tgt.adoc[]"" as repo.RepoObjectColumn_SSAS_tgt << V >> {
  - **RepoObjectColumn_guid** : (uniqueidentifier)
  --
}

entity ""puml-link:dhw:sqldb:repo.reposchema.adoc[]"" as repo.RepoSchema << U >> {
  - **RepoSchema_guid** : (uniqueidentifier)
  --
}

entity ""puml-link:dhw:sqldb:repo.reposchema_ssas_src.adoc[]"" as repo.RepoSchema_ssas_src << V >> {
  - **RepoSchema_name** : (nvarchar(128))
  --
}

entity ""puml-link:dhw:sqldb:repo.reposchema_ssas_tgt.adoc[]"" as repo.RepoSchema_ssas_tgt << V >> {
  - **RepoSchema_guid** : (uniqueidentifier)
  --
}

entity ""puml-link:dhw:sqldb:repo.syscolumn_repoobjectcolumn_via_name.adoc[]"" as repo.SysColumn_RepoObjectColumn_via_name << V >> {
  --
}

entity ""puml-link:dhw:sqldb:repo.sysobject_repoobject_via_name.adoc[]"" as repo.SysObject_RepoObject_via_name << V >> {
  --
}

entity ""puml-link:dhw:sqldb:repo_sys.extendedproperties.adoc[]"" as repo_sys.ExtendedProperties << V >> {
  --
}

entity ""puml-link:dhw:sqldb:repo_sys.sql_expression_dependencies.adoc[]"" as repo_sys.sql_expression_dependencies << V >> {
  --
}

entity ""puml-link:dhw:sqldb:repo_sys.syscolumn.adoc[]"" as repo_sys.SysColumn << V >> {
  --
}

entity ""puml-link:dhw:sqldb:repo_sys.sysobject.adoc[]"" as repo_sys.SysObject << V >> {
  --
}

entity ""puml-link:dhw:sqldb:ssas.additional_reference_step1.adoc[]"" as ssas.additional_Reference_step1 << V >> {
  --
}

entity ""puml-link:dhw:sqldb:ssas.model_json.adoc[]"" as ssas.model_json << U >> {
  - **databasename** : (nvarchar(128))
  --
}

entity ""puml-link:dhw:sqldb:ssas.model_json_10.adoc[]"" as ssas.model_json_10 << V >> {
  --
}

entity ""puml-link:dhw:sqldb:ssas.model_json_20.adoc[]"" as ssas.model_json_20 << V >> {
  --
}

entity ""puml-link:dhw:sqldb:ssas.model_json_201_descriptions_multiline.adoc[]"" as ssas.model_json_201_descriptions_multiline << V >> {
  --
}

entity ""puml-link:dhw:sqldb:ssas.model_json_2011_descriptions_stragg.adoc[]"" as ssas.model_json_2011_descriptions_StrAgg << V >> {
  --
}

entity ""puml-link:dhw:sqldb:ssas.model_json_31_tables.adoc[]"" as ssas.model_json_31_tables << V >> {
  - **databasename** : (nvarchar(128))
  **tables_name** : (nvarchar(128))
  --
}

entity ""puml-link:dhw:sqldb:ssas.model_json_31_tables_t.adoc[]"" as ssas.model_json_31_tables_T << U >> {
  - **databasename** : (nvarchar(128))
  **tables_name** : (nvarchar(128))
  --
}

entity ""puml-link:dhw:sqldb:ssas.model_json_311_tables_columns.adoc[]"" as ssas.model_json_311_tables_columns << V >> {
  - **databasename** : (nvarchar(128))
  - **tables_name** : (nvarchar(128))
  **tables_columns_name** : (nvarchar(128))
  --
}

entity ""puml-link:dhw:sqldb:ssas.model_json_311_tables_columns_t.adoc[]"" as ssas.model_json_311_tables_columns_T << U >> {
  - **databasename** : (nvarchar(128))
  - **tables_name** : (nvarchar(128))
  **tables_columns_name** : (nvarchar(128))
  --
}

entity ""puml-link:dhw:sqldb:ssas.model_json_313_tables_partitions.adoc[]"" as ssas.model_json_313_tables_partitions << V >> {
  - **databasename** : (nvarchar(128))
  - **tables_name** : (nvarchar(128))
  **tables_partitions_name** : (nvarchar(500))
  --
}

entity ""puml-link:dhw:sqldb:ssas.model_json_3131_tables_partitions_source.adoc[]"" as ssas.model_json_3131_tables_partitions_source << V >> {
  - **databasename** : (nvarchar(128))
  - **tables_name** : (nvarchar(128))
  **tables_partitions_name** : (nvarchar(500))
  **tables_partitions_source_name** : (nvarchar(500))
  --
}

entity ""puml-link:dhw:sqldb:ssas.model_json_31311_tables_partitions_source_posfrom.adoc[]"" as ssas.model_json_31311_tables_partitions_source_PosFrom << V >> {
  --
}

entity ""puml-link:dhw:sqldb:ssas.model_json_313111_tables_partitions_source_stringfrom.adoc[]"" as ssas.model_json_313111_tables_partitions_source_StringFrom << V >> {
  --
}

entity ""puml-link:dhw:sqldb:ssas.model_json_3131111_tables_partitions_source_posdot.adoc[]"" as ssas.model_json_3131111_tables_partitions_source_PosDot << V >> {
  --
}

entity ""puml-link:dhw:sqldb:ssas.model_json_31311111_tables_partitions_source_part123.adoc[]"" as ssas.model_json_31311111_tables_partitions_source_Part123 << V >> {
  --
}

entity ""puml-link:dhw:sqldb:ssas.model_json_33_datasources.adoc[]"" as ssas.model_json_33_dataSources << V >> {
  - **databasename** : (nvarchar(128))
  **dataSources_name** : (nvarchar(500))
  --
}

entity ""puml-link:dhw:sqldb:ssas.model_json_33_datasources_t.adoc[]"" as ssas.model_json_33_dataSources_T << U >> {
  - **databasename** : (nvarchar(128))
  **dataSources_name** : (nvarchar(500))
  --
}

entity ""puml-link:dhw:sqldb:sys_dwh.columns.adoc[]"" as sys_dwh.columns << SN >> {
  --
}

entity ""puml-link:dhw:sqldb:sys_dwh.computed_columns.adoc[]"" as sys_dwh.computed_columns << SN >> {
  --
}

entity ""puml-link:dhw:sqldb:sys_dwh.default_constraints.adoc[]"" as sys_dwh.default_constraints << SN >> {
  --
}

entity ""puml-link:dhw:sqldb:sys_dwh.extended_properties.adoc[]"" as sys_dwh.extended_properties << SN >> {
  --
}

entity ""puml-link:dhw:sqldb:sys_dwh.identity_columns.adoc[]"" as sys_dwh.identity_columns << SN >> {
  --
}

entity ""puml-link:dhw:sqldb:sys_dwh.indexes.adoc[]"" as sys_dwh.indexes << SN >> {
  --
}

entity ""puml-link:dhw:sqldb:sys_dwh.objects.adoc[]"" as sys_dwh.objects << SN >> {
  --
}

entity ""puml-link:dhw:sqldb:sys_dwh.parameters.adoc[]"" as sys_dwh.parameters << SN >> {
  --
}

entity ""puml-link:dhw:sqldb:sys_dwh.schemas.adoc[]"" as sys_dwh.schemas << SN >> {
  --
}

entity ""puml-link:dhw:sqldb:sys_dwh.sql_expression_dependencies.adoc[]"" as sys_dwh.sql_expression_dependencies << SN >> {
  --
}

entity ""puml-link:dhw:sqldb:sys_dwh.sql_modules.adoc[]"" as sys_dwh.sql_modules << SN >> {
  --
}

entity ""puml-link:dhw:sqldb:sys_dwh.tables.adoc[]"" as sys_dwh.tables << SN >> {
  --
}

entity ""puml-link:dhw:sqldb:sys_dwh.types.adoc[]"" as sys_dwh.types << SN >> {
  --
}

config.ftv_dwh_database <.. repo_sys.ExtendedProperties
config.ftv_dwh_database <.. repo_sys.SysColumn
config.ftv_dwh_database <.. repo_sys.sql_expression_dependencies
config.ftv_get_parameter_value <.. repo.RepoObject_external_src
config.ftv_get_parameter_value <.. ssas.additional_Reference_step1
config.ftv_get_parameter_value <.. reference.additional_Reference_is_external
config.Parameter <.. property.PropertyName_RepoObject
config.Parameter <.. config.ftv_get_parameter_value
config.Parameter <.. config.ftv_dwh_database
configT.Parameter_default <.. config.Parameter
configT.spt_values <.. configT.type
configT.type <.. repo.RepoObject_gross_persistence
docs.fs_cleanStringForFilename <.. repo.RepoObject_gross_persistence
property.external_RepoObjectProperty <.. property.RepoObjectProperty_external_src
property.PropertyName_RepoObject <.. property.PropertyName_RepoObject_T
property.PropertyName_RepoObject_T <.. property.RepoObjectProperty_external_tgt
property.RepoObjectProperty <.. property.PropertyName_RepoObject
property.RepoObjectProperty <.. property.RepoObjectProperty_SelectedPropertyName_split
property.RepoObjectProperty_external_src <.. property.RepoObjectProperty_external_tgt
property.RepoObjectProperty_external_tgt <.. property.RepoObjectProperty
property.RepoObjectProperty_SelectedPropertyName_split <.. reference.additional_Reference_from_properties_src
property.RepoObjectProperty_SelectedPropertyName_split <.. reference.additional_Reference_wo_columns_from_properties_src
reference.additional_Reference <.. reference.additional_Reference_guid
reference.additional_Reference <.. reference.additional_Reference_is_external
reference.additional_Reference_from_properties_src <.. reference.additional_Reference_from_properties_tgt
reference.additional_Reference_from_properties_tgt <.. reference.additional_Reference
reference.additional_Reference_from_ssas_src <.. reference.additional_Reference_from_ssas_tgt
reference.additional_Reference_from_ssas_tgt <.. reference.additional_Reference
reference.additional_Reference_guid <.. reference.RepoObject_reference_additional
reference.additional_Reference_is_external <.. reference.additional_Reference_ObjectColumn
reference.additional_Reference_is_external <.. reference.additional_Reference_Object
reference.additional_Reference_Object <.. reference.additional_Reference_Object_T
reference.additional_Reference_Object_T <.. repo.RepoObject_external_src
reference.additional_Reference_Object_T <.. repo.RepoObjectColumn_external_src
reference.additional_Reference_ObjectColumn <.. reference.additional_Reference_ObjectColumn_T
reference.additional_Reference_ObjectColumn_T <.. repo.RepoObjectColumn_external_src
reference.additional_Reference_wo_columns_from_properties_src <.. reference.additional_Reference_wo_columns_from_properties_tgt
reference.additional_Reference_wo_columns_from_properties_tgt <.. reference.additional_Reference
reference.ReferenceTree_cyclic_ref_PersistenceUsp <.. reference.ReferenceTree_cyclic_union
reference.ReferenceTree_cyclic_ref_primary <.. reference.ReferenceTree_cyclic_ref_PersistenceUsp
reference.ReferenceTree_cyclic_ref_primary <.. reference.ReferenceTree_cyclic_union
reference.RepoObject_reference <.. reference.RepoObject_reference_T
reference.RepoObject_reference_additional <.. reference.RepoObject_reference_union
reference.RepoObject_reference_persistence <.. reference.RepoObject_reference_union
reference.RepoObject_reference_persistence_target_as_source <.. reference.RepoObject_reference_union
reference.RepoObject_reference_persistence_target_as_source <.. reference.RepoObject_reference
reference.RepoObject_reference_SqlExpressionDependencies <.. reference.RepoObject_reference_persistence_target_as_source
reference.RepoObject_reference_SqlExpressionDependencies <.. reference.RepoObject_reference_union
reference.RepoObject_reference_T <.. reference.ReferenceTree_cyclic_ref_PersistenceUsp
reference.RepoObject_reference_union <.. reference.RepoObject_reference
reference.RepoObject_reference_virtual <.. reference.RepoObject_reference_union
reference.RepoObject_ReferenceTree <.. reference.RepoObject_ReferenceTree_cyclic
reference.RepoObject_ReferenceTree_cyclic <.. reference.ReferenceTree_cyclic_ref_primary
reference.RepoObjectSource_virtual <.. reference.RepoObject_reference_virtual
repo.RepoObject <.. reference.RepoObject_reference_persistence
repo.RepoObject <.. repo.SysObject_RepoObject_via_name
repo.RepoObject <.. repo.SysColumn_RepoObjectColumn_via_name
repo.RepoObject <.. repo.RepoObject_gross_persistence
repo.RepoObject <.. repo.RepoObjectColumn_external_src
repo.RepoObject <.. property.RepoObjectProperty_external_tgt
repo.RepoObject <.. reference.RepoObject_reference_SqlExpressionDependencies
repo.RepoObject <.. reference.RepoObject_reference_virtual
repo.RepoObject <.. reference.additional_Reference_guid
repo.RepoObject <.. repo.RepoObject_external_src
repo.RepoObject_external_src <.. repo.RepoObject_external_tgt
repo.RepoObject_external_tgt <.. repo.RepoObject
repo.RepoObject_external_tgt <.. repo.RepoObjectColumn_external_tgt
repo.RepoObject_gross_persistence <.. reference.RepoObject_reference_persistence_target_as_source
repo.RepoObject_persistence <.. repo.RepoObject_gross_persistence
repo.RepoObject_persistence <.. reference.RepoObject_reference_persistence
repo.RepoObject_SSAS_src <.. repo.RepoObject_SSAS_tgt
repo.RepoObject_SSAS_tgt <.. repo.RepoObjectColumn_SSAS_tgt
repo.RepoObject_SSAS_tgt <.. repo.RepoObject
repo.RepoObjectColumn <.. repo.SysColumn_RepoObjectColumn_via_name
repo.RepoObjectColumn <.. reference.additional_Reference_guid
repo.RepoObjectColumn_external_src <.. repo.RepoObjectColumn_external_tgt
repo.RepoObjectColumn_external_tgt <.. repo.RepoObjectColumn
repo.RepoObjectColumn_SSAS_src <.. repo.RepoObjectColumn_SSAS_tgt
repo.RepoObjectColumn_SSAS_tgt <.. repo.RepoObjectColumn
repo.RepoSchema <.. repo.RepoObject_SSAS_src
repo.RepoSchema_ssas_src <.. repo.RepoSchema_ssas_tgt
repo.RepoSchema_ssas_tgt <.. repo.RepoSchema
repo.SysColumn_RepoObjectColumn_via_name <.. repo_sys.sql_expression_dependencies
repo.SysObject_RepoObject_via_name <.. repo_sys.sql_expression_dependencies
repo_sys.ExtendedProperties <.. repo_sys.SysObject
repo_sys.ExtendedProperties <.. repo_sys.SysColumn
repo_sys.sql_expression_dependencies <.. reference.RepoObject_reference_SqlExpressionDependencies
repo_sys.SysColumn <.. repo.SysColumn_RepoObjectColumn_via_name
repo_sys.SysObject <.. repo.SysObject_RepoObject_via_name
repo_sys.SysObject <.. repo_sys.SysColumn
ssas.additional_Reference_step1 <.. reference.additional_Reference_from_ssas_src
ssas.model_json <.. ssas.model_json_10
ssas.model_json_10 <.. ssas.model_json_20
ssas.model_json_20 <.. repo.RepoSchema_ssas_src
ssas.model_json_20 <.. ssas.model_json_201_descriptions_multiline
ssas.model_json_20 <.. ssas.model_json_33_dataSources
ssas.model_json_20 <.. ssas.model_json_31_tables
ssas.model_json_201_descriptions_multiline <.. ssas.model_json_2011_descriptions_StrAgg
ssas.model_json_2011_descriptions_StrAgg <.. repo.RepoSchema_ssas_src
ssas.model_json_31_tables <.. ssas.model_json_31_tables_T
ssas.model_json_31_tables_T <.. ssas.model_json_311_tables_columns
ssas.model_json_31_tables_T <.. repo.RepoObject_SSAS_src
ssas.model_json_31_tables_T <.. ssas.model_json_313_tables_partitions
ssas.model_json_311_tables_columns <.. ssas.model_json_311_tables_columns_T
ssas.model_json_311_tables_columns_T <.. repo.RepoObjectColumn_SSAS_src
ssas.model_json_311_tables_columns_T <.. ssas.additional_Reference_step1
ssas.model_json_313_tables_partitions <.. ssas.model_json_3131_tables_partitions_source
ssas.model_json_3131_tables_partitions_source <.. ssas.model_json_31311_tables_partitions_source_PosFrom
ssas.model_json_31311_tables_partitions_source_PosFrom <.. ssas.model_json_313111_tables_partitions_source_StringFrom
ssas.model_json_313111_tables_partitions_source_StringFrom <.. ssas.model_json_3131111_tables_partitions_source_PosDot
ssas.model_json_3131111_tables_partitions_source_PosDot <.. ssas.model_json_31311111_tables_partitions_source_Part123
ssas.model_json_31311111_tables_partitions_source_Part123 <.. ssas.additional_Reference_step1
ssas.model_json_33_dataSources <.. ssas.model_json_33_dataSources_T
ssas.model_json_33_dataSources_T <.. ssas.additional_Reference_step1
sys_dwh.columns <.. repo_sys.ExtendedProperties
sys_dwh.columns <.. repo_sys.SysColumn
sys_dwh.computed_columns <.. repo_sys.SysColumn
sys_dwh.default_constraints <.. repo_sys.SysColumn
sys_dwh.extended_properties <.. repo_sys.ExtendedProperties
sys_dwh.identity_columns <.. repo_sys.SysColumn
sys_dwh.indexes <.. repo_sys.ExtendedProperties
sys_dwh.objects <.. repo_sys.ExtendedProperties
sys_dwh.objects <.. repo_sys.SysObject
sys_dwh.parameters <.. repo_sys.ExtendedProperties
sys_dwh.schemas <.. repo_sys.ExtendedProperties
sys_dwh.schemas <.. repo_sys.SysObject
sys_dwh.sql_expression_dependencies <.. repo_sys.sql_expression_dependencies
sys_dwh.sql_modules <.. repo_sys.SysObject
sys_dwh.tables <.. repo_sys.SysObject
sys_dwh.types <.. repo_sys.SysColumn

footer The diagram is interactive and contains links.

@enduml
....

// end::puml_entity_30_0_objectref[]

=== PlantUML 0 30 ObjectRef

// tag::puml_entity_0_30_objectref[]
[plantuml, entity_0_30_objectref-{docname}, svg, subs=macros]
....
@startuml
'Left to right direction
top to bottom direction
hide circle
'avoide ""."" issues:
set namespaceSeparator none


skinparam class {
  BackgroundColor White
  BackgroundColor<<FN>> Yellow
  BackgroundColor<<FS>> Yellow
  BackgroundColor<<FT>> LightGray
  BackgroundColor<<IF>> Yellow
  BackgroundColor<<IS>> Yellow
  BackgroundColor<<P>>  Aqua
  BackgroundColor<<PC>> Aqua
  BackgroundColor<<SN>> Yellow
  BackgroundColor<<SO>> SlateBlue
  BackgroundColor<<TF>> LightGray
  BackgroundColor<<TR>> Tomato
  BackgroundColor<<U>>  White
  BackgroundColor<<V>>  WhiteSmoke
  BackgroundColor<<X>>  Aqua
  BackgroundColor<<external>> AliceBlue
}


entity ""puml-link:dhw:sqldb:docs.objectrefcyclic.adoc[]"" as docs.ObjectRefCyclic << V >> {
  --
}

entity ""puml-link:dhw:sqldb:docs.objectrefcyclic_entitylist.adoc[]"" as docs.ObjectRefCyclic_EntityList << V >> {
  --
}

entity ""puml-link:dhw:sqldb:docs.objectrefcyclic_objectreflist.adoc[]"" as docs.ObjectRefCyclic_ObjectRefList << V >> {
  --
}

entity ""puml-link:dhw:sqldb:reference.referencetree_cyclic_union.adoc[]"" as reference.ReferenceTree_cyclic_union << V >> {
  --
}

docs.ObjectRefCyclic_EntityList <.. docs.ObjectRefCyclic
docs.ObjectRefCyclic_ObjectRefList <.. docs.ObjectRefCyclic
reference.ReferenceTree_cyclic_union <.. docs.ObjectRefCyclic_ObjectRefList
reference.ReferenceTree_cyclic_union <.. docs.ObjectRefCyclic_EntityList

footer The diagram is interactive and contains links.

@enduml
....

// end::puml_entity_0_30_objectref[]

=== PlantUML 1 1 ColumnRef

// tag::puml_entity_1_1_colref[]
[plantuml, entity_1_1_colref-{docname}, svg, subs=macros]
....
@startuml
left to right direction
'top to bottom direction
hide circle
'avoide ""."" issues:
set namespaceSeparator none


skinparam class {
  BackgroundColor White
  BackgroundColor<<FN>> Yellow
  BackgroundColor<<FS>> Yellow
  BackgroundColor<<FT>> LightGray
  BackgroundColor<<IF>> Yellow
  BackgroundColor<<IS>> Yellow
  BackgroundColor<<P>>  Aqua
  BackgroundColor<<PC>> Aqua
  BackgroundColor<<SN>> Yellow
  BackgroundColor<<SO>> SlateBlue
  BackgroundColor<<TF>> LightGray
  BackgroundColor<<TR>> Tomato
  BackgroundColor<<U>>  White
  BackgroundColor<<V>>  WhiteSmoke
  BackgroundColor<<X>>  Aqua
  BackgroundColor<<external>> AliceBlue
}


entity ""puml-link:dhw:sqldb:docs.objectrefcyclic_entitylist.adoc[]"" as docs.ObjectRefCyclic_EntityList << V >> {
  - cultures_name : (nvarchar(10))
  PumlEntityList : (nvarchar(max))
  PumlEntityOnlyPkList : (nvarchar(max))
  XrefEntityList : (nvarchar(max))
  --
}

entity ""puml-link:dhw:sqldb:docs.objectrefcyclic_objectreflist.adoc[]"" as docs.ObjectRefCyclic_ObjectRefList << V >> {
  PumlObjectRefList : (nvarchar(max))
  --
}

entity ""puml-link:dhw:sqldb:reference.referencetree_cyclic_ref_persistenceusp.adoc[]"" as reference.ReferenceTree_cyclic_ref_PersistenceUsp << V >> {
  - referenced_fullname : (nvarchar(261))
  - referenced_fullname2 : (nvarchar(257))
  - Referenced_guid : (uniqueidentifier)
  referenced_type : (char(2))
  - referencing_fullname : (nvarchar(261))
  - referencing_fullname2 : (nvarchar(257))
  - Referencing_guid : (uniqueidentifier)
  referencing_type : (varchar(2))
  --
}

entity ""puml-link:dhw:sqldb:reference.referencetree_cyclic_ref_primary.adoc[]"" as reference.ReferenceTree_cyclic_ref_primary << V >> {
  Referenced_fullname : (nvarchar(261))
  Referenced_fullname2 : (nvarchar(257))
  - Referenced_guid : (uniqueidentifier)
  Referenced_type : (char(2))
  Referencing_fullname : (nvarchar(261))
  Referencing_fullname2 : (nvarchar(257))
  - Referencing_guid : (uniqueidentifier)
  Referencing_type : (varchar(2))
  --
}

entity ""puml-link:dhw:sqldb:reference.referencetree_cyclic_union.adoc[]"" as reference.ReferenceTree_cyclic_union << V >> {
  Referenced_fullname : (nvarchar(261))
  Referenced_fullname2 : (nvarchar(257))
  - Referenced_guid : (uniqueidentifier)
  Referenced_type : (char(2))
  Referencing_fullname : (nvarchar(261))
  Referencing_fullname2 : (nvarchar(257))
  - Referencing_guid : (uniqueidentifier)
  Referencing_type : (varchar(2))
  --
}

reference.ReferenceTree_cyclic_ref_PersistenceUsp <.. reference.ReferenceTree_cyclic_union
reference.ReferenceTree_cyclic_ref_primary <.. reference.ReferenceTree_cyclic_union
reference.ReferenceTree_cyclic_union <.. docs.ObjectRefCyclic_EntityList
reference.ReferenceTree_cyclic_union <.. docs.ObjectRefCyclic_ObjectRefList


footer The diagram is interactive and contains links.

@enduml
....

// end::puml_entity_1_1_colref[]


== sql_modules_definition

// tag::sql_modules_definition[]
[%collapsible]
=======
[source,sql,numbered,indent=0]
----


CREATE View reference.ReferenceTree_cyclic_union
As
Select
    Referencing_guid
  , Referenced_guid
  , Referenced_fullname
  , Referenced_fullname2
  , Referenced_type
  , Referencing_fullname
  , Referencing_fullname2
  , Referencing_type
From
    reference.ReferenceTree_cyclic_ref_primary
Union
Select
    Referencing_guid
  , Referenced_guid
  , referenced_fullname
  , referenced_fullname2
  , referenced_type
  , referencing_fullname
  , referencing_fullname2
  , referencing_type
From
    reference.ReferenceTree_cyclic_ref_PersistenceUsp

----
=======
// end::sql_modules_definition[]


",12301,True,2718.1507857080896,median
"//===----------------------------------------------------------------------===//
//
// This file implements the VirtualFileSystem interface.
//
//===----------------------------------------------------------------------===//
#include ""latino/Basic/VirtualFileSystem.h""
#include ""latino/Basic/LLVM.h""
#include ""llvm/ADT/ArrayRef.h""
#include ""llvm/ADT/DenseMap.h""
#include ""llvm/ADT/Optional.h""
#include ""llvm/ADT/STLExtras.h""
#include ""llvm/ADT/SmallString.h""
#include ""llvm/ADT/StringRef.h""
#include ""llvm/ADT/StringSet.h""
#include ""llvm/ADT/Twine.h""
#include ""llvm/ADT/iterator_range.h""
#include ""llvm/Config/llvm-config.h""
#include ""llvm/Support/Casting.h""
#include ""llvm/Support/Chrono.h""
#include ""llvm/Support/Compiler.h""
#include ""llvm/Support/Debug.h""
#include ""llvm/Support/Errc.h""
#include ""llvm/Support/ErrorHandling.h""
#include ""llvm/Support/ErrorOr.h""
#include ""llvm/Support/FileSystem.h""
#include ""llvm/Support/MemoryBuffer.h""
#include ""llvm/Support/Path.h""
#include ""llvm/Support/Process.h""
#include ""llvm/Support/SMLoc.h""
#include ""llvm/Support/SourceMgr.h""
#include ""llvm/Support/YAMLParser.h""
#include ""llvm/Support/raw_ostream.h""
#include <algorithm>
#include <atomic>
#include <cassert>
#include <cstdint>
#include <iterator>
#include <limits>
#include <map>
#include <memory>
#include <string>
#include <system_error>
#include <utility>
#include <vector>

using namespace latino;
using namespace vfs;
using namespace llvm;

using llvm::sys::fs::file_status;
using llvm::sys::fs::file_type;
using llvm::sys::fs::perms;
using llvm::sys::fs::UniqueID;

Status::Status(const file_status &Status)
    : UID(Status.getUniqueID()), MTime(Status.getLastModificationTime()),
      User(Status.getUser()), Group(Status.getGroup()), Size(Status.getSize()),
      Type(Status.type()), Perms(Status.permissions()) {}

Status::Status(StringRef Name, UniqueID UID, sys::TimePoint<> MTime,
               uint32_t User, uint32_t Group, uint64_t Size, file_type Type,
               perms Perms)
    : Name(Name), UID(UID), MTime(MTime), User(User), Group(Group), Size(Size),
      Type(Type), Perms(Perms) {}

Status Status::copyWithNewName(const Status &In, StringRef NewName) {
  return Status(NewName, In.getUniqueID(), In.getLastModificationTime(),
                In.getUser(), In.getGroup(), In.getSize(), In.getType(),
                In.getPermissions());
}

Status Status::copyWithNewName(const file_status &In, StringRef NewName) {
  return Status(NewName, In.getUniqueID(), In.getLastModificationTime(),
                In.getUser(), In.getGroup(), In.getSize(), In.type(),
                In.permissions());
}

bool Status::equivalent(const Status &Other) const {
  assert(isStatusKnown() && Other.isStatusKnown());
  return getUniqueID() == Other.getUniqueID();
}

bool Status::isDirectory() const { return Type == file_type::directory_file; }

bool Status::isRegularFile() const { return Type == file_type::regular_file; }

bool Status::isOther() const {
  return exists() && !isRegularFile() && !isDirectory() && !isSymlink();
}

bool Status::isSymlink() const { return Type == file_type::symlink_file; }

bool Status::isStatusKnown() const { return Type != file_type::status_error; }

bool Status::exists() const {
  return isStatusKnown() && Type != file_type::file_not_found;
}

File::~File() = default;

FileSystem::~FileSystem() = default;

ErrorOr<std::unique_ptr<MemoryBuffer>>
FileSystem::getBufferForFile(const llvm::Twine &Name, int64_t FileSize,
                             bool RequiresNullTerminator, bool IsVolatile) {
  auto F = openFileForRead(Name);
  if (!F)
    return F.getError();

  return (*F)->getBuffer(Name, FileSize, RequiresNullTerminator, IsVolatile);
}

std::error_code FileSystem::makeAbsolute(SmallVectorImpl<char> &Path) const {
  if (llvm::sys::path::is_absolute(Path))
    return {};

  auto WorkingDir = getCurrentWorkingDirectory();
  if (!WorkingDir)
    return WorkingDir.getError();

  llvm::sys::fs::make_absolute(WorkingDir.get(), Path);
  return {};
}

std::error_code FileSystem::getRealPath(const Twine &Path,
                                        SmallVectorImpl<char> &Output) const {
  return errc::operation_not_permitted;
}

bool FileSystem::exists(const Twine &Path) {
  auto Status = status(Path);
  return Status && Status->exists();
}

#ifndef NDEBUG
static bool isTraversalComponent(StringRef Component) {
  return Component.equals("".."") || Component.equals(""."");
}

static bool pathHasTraversal(StringRef Path) {
  using namespace llvm::sys;

  for (StringRef Comp : llvm::make_range(path::begin(Path), path::end(Path)))
    if (isTraversalComponent(Comp))
      return true;
  return false;
}
#endif

//===-----------------------------------------------------------------------===/
// RealFileSystem implementation
//===-----------------------------------------------------------------------===/

namespace {

/// Wrapper around a raw file descriptor.
class RealFile : public File {
  friend class RealFileSystem;

  int FD;
  Status S;
  std::string RealName;

  RealFile(int FD, StringRef NewName, StringRef NewRealPathName)
      : FD(FD), S(NewName, {}, {}, {}, {}, {},
                  llvm::sys::fs::file_type::status_error, {}),
        RealName(NewRealPathName.str()) {
    assert(FD >= 0 && ""Invalid or inactive file descriptor"");
  }

public:
  ~RealFile() override;

  ErrorOr<Status> status() override;
  ErrorOr<std::string> getName() override;
  ErrorOr<std::unique_ptr<MemoryBuffer>> getBuffer(const Twine &Name,
                                                   int64_t FileSize,
                                                   bool RequiresNullTerminator,
                                                   bool IsVolatile) override;
  std::error_code close() override;
};

} // namespace

RealFile::~RealFile() { close(); }

ErrorOr<Status> RealFile::status() {
  assert(FD != -1 && ""cannot stat closed file"");
  if (!S.isStatusKnown()) {
    file_status RealStatus;
    if (std::error_code EC = sys::fs::status(FD, RealStatus))
      return EC;
    S = Status::copyWithNewName(RealStatus, S.getName());
  }
  return S;
}

ErrorOr<std::string> RealFile::getName() {
  return RealName.empty() ? S.getName().str() : RealName;
}

ErrorOr<std::unique_ptr<MemoryBuffer>>
RealFile::getBuffer(const Twine &Name, int64_t FileSize,
                    bool RequiresNullTerminator, bool IsVolatile) {
  assert(FD != -1 && ""cannot get buffer for closed file"");
  return MemoryBuffer::getOpenFile(FD, Name, FileSize, RequiresNullTerminator,
                                   IsVolatile);
}

std::error_code RealFile::close() {
  std::error_code EC = sys::Process::SafelyCloseFileDescriptor(FD);
  FD = -1;
  return EC;
}

namespace {

/// The file system according to your operating system.
class RealFileSystem : public FileSystem {
public:
  ErrorOr<Status> status(const Twine &Path) override;
  ErrorOr<std::unique_ptr<File>> openFileForRead(const Twine &Path) override;
  directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override;

  llvm::ErrorOr<std::string> getCurrentWorkingDirectory() const override;
  std::error_code setCurrentWorkingDirectory(const Twine &Path) override;
  std::error_code getRealPath(const Twine &Path,
                              SmallVectorImpl<char> &Output) const override;
};

} // namespace

ErrorOr<Status> RealFileSystem::status(const Twine &Path) {
  sys::fs::file_status RealStatus;
  if (std::error_code EC = sys::fs::status(Path, RealStatus))
    return EC;
  return Status::copyWithNewName(RealStatus, Path.str());
}

ErrorOr<std::unique_ptr<File>>
RealFileSystem::openFileForRead(const Twine &Name) {
  int FD;
  SmallString<256> RealName;
  if (std::error_code EC =
          sys::fs::openFileForRead(Name, FD, sys::fs::OF_None, &RealName))
    return EC;
  return std::unique_ptr<File>(new RealFile(FD, Name.str(), RealName.str()));
}

llvm::ErrorOr<std::string> RealFileSystem::getCurrentWorkingDirectory() const {
  SmallString<256> Dir;
  if (std::error_code EC = llvm::sys::fs::current_path(Dir))
    return EC;
  return Dir.str().str();
}

std::error_code RealFileSystem::setCurrentWorkingDirectory(const Twine &Path) {
  // FIXME: chdir is thread hostile; on the other hand, creating the same
  // behavior as chdir is complex: chdir resolves the path once, thus
  // guaranteeing that all subsequent relative path operations work
  // on the same path the original chdir resulted in. This makes a
  // difference for example on network filesystems, where symlinks might be
  // switched during runtime of the tool. Fixing this depends on having a
  // file system abstraction that allows openat() style interactions.
  return llvm::sys::fs::set_current_path(Path);
}

std::error_code
RealFileSystem::getRealPath(const Twine &Path,
                            SmallVectorImpl<char> &Output) const {
  return llvm::sys::fs::real_path(Path, Output);
}

IntrusiveRefCntPtr<FileSystem> vfs::getRealFileSystem() {
  static IntrusiveRefCntPtr<FileSystem> FS = new RealFileSystem();
  return FS;
}

namespace {

class RealFSDirIter : public latino::vfs::detail::DirIterImpl {
  llvm::sys::fs::directory_iterator Iter;

public:
  RealFSDirIter(const Twine &Path, std::error_code &EC) : Iter(Path, EC) {
    if (Iter != llvm::sys::fs::directory_iterator()) {
      llvm::sys::fs::file_status S;
      std::error_code ErrorCode = llvm::sys::fs::status(Iter->path(), S, true);
      CurrentEntry = Status::copyWithNewName(S, Iter->path());
      if (!EC)
        EC = ErrorCode;
    }
  }

  std::error_code increment() override {
    std::error_code EC;
    Iter.increment(EC);
    if (Iter == llvm::sys::fs::directory_iterator()) {
      CurrentEntry = Status();
    } else {
      llvm::sys::fs::file_status S;
      std::error_code ErrorCode = llvm::sys::fs::status(Iter->path(), S, true);
      CurrentEntry = Status::copyWithNewName(S, Iter->path());
      if (!EC)
        EC = ErrorCode;
    }
    return EC;
  }
};

} // namespace

directory_iterator RealFileSystem::dir_begin(const Twine &Dir,
                                             std::error_code &EC) {
  return directory_iterator(std::make_shared<RealFSDirIter>(Dir, EC));
}

//===-----------------------------------------------------------------------===/
// OverlayFileSystem implementation
//===-----------------------------------------------------------------------===/

OverlayFileSystem::OverlayFileSystem(IntrusiveRefCntPtr<FileSystem> BaseFS) {
  FSList.push_back(std::move(BaseFS));
}

void OverlayFileSystem::pushOverlay(IntrusiveRefCntPtr<FileSystem> FS) {
  FSList.push_back(FS);
  // Synchronize added file systems by duplicating the working directory from
  // the first one in the list.
  FS->setCurrentWorkingDirectory(getCurrentWorkingDirectory().get());
}

ErrorOr<Status> OverlayFileSystem::status(const Twine &Path) {
  // FIXME: handle symlinks that cross file systems
  for (iterator I = overlays_begin(), E = overlays_end(); I != E; ++I) {
    ErrorOr<Status> Status = (*I)->status(Path);
    if (Status || Status.getError() != llvm::errc::no_such_file_or_directory)
      return Status;
  }
  return make_error_code(llvm::errc::no_such_file_or_directory);
}

ErrorOr<std::unique_ptr<File>>
OverlayFileSystem::openFileForRead(const llvm::Twine &Path) {
  // FIXME: handle symlinks that cross file systems
  for (iterator I = overlays_begin(), E = overlays_end(); I != E; ++I) {
    auto Result = (*I)->openFileForRead(Path);
    if (Result || Result.getError() != llvm::errc::no_such_file_or_directory)
      return Result;
  }
  return make_error_code(llvm::errc::no_such_file_or_directory);
}

llvm::ErrorOr<std::string>
OverlayFileSystem::getCurrentWorkingDirectory() const {
  // All file systems are synchronized, just take the first working directory.
  return FSList.front()->getCurrentWorkingDirectory();
}

std::error_code
OverlayFileSystem::setCurrentWorkingDirectory(const Twine &Path) {
  for (auto &FS : FSList)
    if (std::error_code EC = FS->setCurrentWorkingDirectory(Path))
      return EC;
  return {};
}

std::error_code
OverlayFileSystem::getRealPath(const Twine &Path,
                               SmallVectorImpl<char> &Output) const {
  for (auto &FS : FSList)
    if (FS->exists(Path))
      return FS->getRealPath(Path, Output);
  return errc::no_such_file_or_directory;
}

latino::vfs::detail::DirIterImpl::~DirIterImpl() = default;

namespace {

class OverlayFSDirIterImpl : public latino::vfs::detail::DirIterImpl {
  OverlayFileSystem &Overlays;
  std::string Path;
  OverlayFileSystem::iterator CurrentFS;
  directory_iterator CurrentDirIter;
  llvm::StringSet<> SeenNames;

  std::error_code incrementFS() {
    assert(CurrentFS != Overlays.overlays_end() && ""incrementing past end"");
    ++CurrentFS;
    for (auto E = Overlays.overlays_end(); CurrentFS != E; ++CurrentFS) {
      std::error_code EC;
      CurrentDirIter = (*CurrentFS)->dir_begin(Path, EC);
      if (EC && EC != errc::no_such_file_or_directory)
        return EC;
      if (CurrentDirIter != directory_iterator())
        break; // found
    }
    return {};
  }

  std::error_code incrementDirIter(bool IsFirstTime) {
    assert((IsFirstTime || CurrentDirIter != directory_iterator()) &&
           ""incrementing past end"");
    std::error_code EC;
    if (!IsFirstTime)
      CurrentDirIter.increment(EC);
    if (!EC && CurrentDirIter == directory_iterator())
      EC = incrementFS();
    return EC;
  }

  std::error_code incrementImpl(bool IsFirstTime) {
    while (true) {
      std::error_code EC = incrementDirIter(IsFirstTime);
      if (EC || CurrentDirIter == directory_iterator()) {
        CurrentEntry = Status();
        return EC;
      }
      CurrentEntry = *CurrentDirIter;
      StringRef Name = llvm::sys::path::filename(CurrentEntry.getName());
      if (SeenNames.insert(Name).second)
        return EC; // name not seen before
    }
    llvm_unreachable(""returned above"");
  }

public:
  OverlayFSDirIterImpl(const Twine &Path, OverlayFileSystem &FS,
                       std::error_code &EC)
      : Overlays(FS), Path(Path.str()), CurrentFS(Overlays.overlays_begin()) {
    CurrentDirIter = (*CurrentFS)->dir_begin(Path, EC);
    EC = incrementImpl(true);
  }

  std::error_code increment() override { return incrementImpl(false); }
};

} // namespace

directory_iterator OverlayFileSystem::dir_begin(const Twine &Dir,
                                                std::error_code &EC) {
  return directory_iterator(
      std::make_shared<OverlayFSDirIterImpl>(Dir, *this, EC));
}

namespace latino {
namespace vfs {

namespace detail {

enum InMemoryNodeKind { IME_File, IME_Directory };

/// The in memory file system is a tree of Nodes. Every node can either be a
/// file or a directory.
class InMemoryNode {
  Status Stat;
  InMemoryNodeKind Kind;

public:
  InMemoryNode(Status Stat, InMemoryNodeKind Kind)
      : Stat(std::move(Stat)), Kind(Kind) {}
  virtual ~InMemoryNode() = default;

  const Status &getStatus() const { return Stat; }
  InMemoryNodeKind getKind() const { return Kind; }
  virtual std::string toString(unsigned Indent) const = 0;
};

namespace {

class InMemoryFile : public InMemoryNode {
  std::unique_ptr<llvm::MemoryBuffer> Buffer;

public:
  InMemoryFile(Status Stat, std::unique_ptr<llvm::MemoryBuffer> Buffer)
      : InMemoryNode(std::move(Stat), IME_File), Buffer(std::move(Buffer)) {}

  llvm::MemoryBuffer *getBuffer() { return Buffer.get(); }

  std::string toString(unsigned Indent) const override {
    return (std::string(Indent, ' ') + getStatus().getName() + ""\\n"").str();
  }

  static bool classof(const InMemoryNode *N) {
    return N->getKind() == IME_File;
  }
};

/// Adapt a InMemoryFile for VFS' File interface.
class InMemoryFileAdaptor : public File {
  InMemoryFile &Node;

public:
  explicit InMemoryFileAdaptor(InMemoryFile &Node) : Node(Node) {}

  llvm::ErrorOr<Status> status() override { return Node.getStatus(); }

  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
  getBuffer(const Twine &Name, int64_t FileSize, bool RequiresNullTerminator,
            bool IsVolatile) override {
    llvm::MemoryBuffer *Buf = Node.getBuffer();
    return llvm::MemoryBuffer::getMemBuffer(
        Buf->getBuffer(), Buf->getBufferIdentifier(), RequiresNullTerminator);
  }

  std::error_code close() override { return {}; }
};

} // namespace

class InMemoryDirectory : public InMemoryNode {
  std::map<std::string, std::unique_ptr<InMemoryNode>> Entries;

public:
  InMemoryDirectory(Status Stat)
      : InMemoryNode(std::move(Stat), IME_Directory) {}

  InMemoryNode *getChild(StringRef Name) {
    auto I = Entries.find(Name);
    if (I != Entries.end())
      return I->second.get();
    return nullptr;
  }

  InMemoryNode *addChild(StringRef Name, std::unique_ptr<InMemoryNode> Child) {
    return Entries.insert(make_pair(Name, std::move(Child)))
        .first->second.get();
  }

  using const_iterator = decltype(Entries)::const_iterator;

  const_iterator begin() const { return Entries.begin(); }
  const_iterator end() const { return Entries.end(); }

  std::string toString(unsigned Indent) const override {
    std::string Result =
        (std::string(Indent, ' ') + getStatus().getName() + ""\\n"").str();
    for (const auto &Entry : Entries)
      Result += Entry.second->toString(Indent + 2);
    return Result;
  }

  static bool classof(const InMemoryNode *N) {
    return N->getKind() == IME_Directory;
  }
};

} // namespace detail

InMemoryFileSystem::InMemoryFileSystem(bool UseNormalizedPaths)
    : Root(new detail::InMemoryDirectory(
          Status("""", getNextVirtualUniqueID(), llvm::sys::TimePoint<>(), 0, 0,
                 0, llvm::sys::fs::file_type::directory_file,
                 llvm::sys::fs::perms::all_all))),
      UseNormalizedPaths(UseNormalizedPaths) {}

InMemoryFileSystem::~InMemoryFileSystem() = default;

std::string InMemoryFileSystem::toString() const {
  return Root->toString(/*Indent=*/0);
}

bool InMemoryFileSystem::addFile(const Twine &P, time_t ModificationTime,
                                 std::unique_ptr<llvm::MemoryBuffer> Buffer,
                                 Optional<uint32_t> User,
                                 Optional<uint32_t> Group,
                                 Optional<llvm::sys::fs::file_type> Type,
                                 Optional<llvm::sys::fs::perms> Perms) {
  SmallString<128> Path;
  P.toVector(Path);

  // Fix up relative paths. This just prepends the current working directory.
  std::error_code EC = makeAbsolute(Path);
  assert(!EC);
  (void)EC;

  if (useNormalizedPaths())
    llvm::sys::path::remove_dots(Path, /*remove_dot_dot=*/true);

  if (Path.empty())
    return false;

  detail::InMemoryDirectory *Dir = Root.get();
  auto I = llvm::sys::path::begin(Path), E = sys::path::end(Path);
  const auto ResolvedUser = User.getValueOr(0);
  const auto ResolvedGroup = Group.getValueOr(0);
  const auto ResolvedType = Type.getValueOr(sys::fs::file_type::regular_file);
  const auto ResolvedPerms = Perms.getValueOr(sys::fs::all_all);
  // Any intermediate directories we create should be accessible by
  // the owner, even if Perms says otherwise for the final path.
  const auto NewDirectoryPerms = ResolvedPerms | sys::fs::owner_all;
  while (true) {
    StringRef Name = *I;
    detail::InMemoryNode *Node = Dir->getChild(Name);
    ++I;
    if (!Node) {
      if (I == E) {
        // End of the path, create a new file or directory.
        Status Stat(P.str(), getNextVirtualUniqueID(),
                    llvm::sys::toTimePoint(ModificationTime), ResolvedUser,
                    ResolvedGroup, Buffer->getBufferSize(), ResolvedType,
                    ResolvedPerms);
        std::unique_ptr<detail::InMemoryNode> Child;
        if (ResolvedType == sys::fs::file_type::directory_file) {
          Child.reset(new detail::InMemoryDirectory(std::move(Stat)));
        } else {
          Child.reset(
              new detail::InMemoryFile(std::move(Stat), std::move(Buffer)));
        }
        Dir->addChild(Name, std::move(Child));
        return true;
      }

      // Create a new directory. Use the path up to here.
      Status Stat(
          StringRef(Path.str().begin(), Name.end() - Path.str().begin()),
          getNextVirtualUniqueID(), llvm::sys::toTimePoint(ModificationTime),
          ResolvedUser, ResolvedGroup, Buffer->getBufferSize(),
          sys::fs::file_type::directory_file, NewDirectoryPerms);
      Dir = cast<detail::InMemoryDirectory>(Dir->addChild(
          Name, llvm::make_unique<detail::InMemoryDirectory>(std::move(Stat))));
      continue;
    }

    if (auto *NewDir = dyn_cast<detail::InMemoryDirectory>(Node)) {
      Dir = NewDir;
    } else {
      assert(isa<detail::InMemoryFile>(Node) &&
             ""Must be either file or directory!"");

      // Trying to insert a directory in place of a file.
      if (I != E)
        return false;

      // Return false only if the new file is different from the existing one.
      return cast<detail::InMemoryFile>(Node)->getBuffer()->getBuffer() ==
             Buffer->getBuffer();
    }
  }
}

bool InMemoryFileSystem::addFileNoOwn(const Twine &P, time_t ModificationTime,
                                      llvm::MemoryBuffer *Buffer,
                                      Optional<uint32_t> User,
                                      Optional<uint32_t> Group,
                                      Optional<llvm::sys::fs::file_type> Type,
                                      Optional<llvm::sys::fs::perms> Perms) {
  return addFile(P, ModificationTime,
                 llvm::MemoryBuffer::getMemBuffer(
                     Buffer->getBuffer(), Buffer->getBufferIdentifier()),
                 std::move(User), std::move(Group), std::move(Type),
                 std::move(Perms));
}

static ErrorOr<detail::InMemoryNode *>
lookupInMemoryNode(const InMemoryFileSystem &FS, detail::InMemoryDirectory *Dir,
                   const Twine &P) {
  SmallString<128> Path;
  P.toVector(Path);

  // Fix up relative paths. This just prepends the current working directory.
  std::error_code EC = FS.makeAbsolute(Path);
  assert(!EC);
  (void)EC;

  if (FS.useNormalizedPaths())
    llvm::sys::path::remove_dots(Path, /*remove_dot_dot=*/true);

  if (Path.empty())
    return Dir;

  auto I = llvm::sys::path::begin(Path), E = llvm::sys::path::end(Path);
  while (true) {
    detail::InMemoryNode *Node = Dir->getChild(*I);
    ++I;
    if (!Node)
      return errc::no_such_file_or_directory;

    // Return the file if it's at the end of the path.
    if (auto File = dyn_cast<detail::InMemoryFile>(Node)) {
      if (I == E)
        return File;
      return errc::no_such_file_or_directory;
    }

    // Traverse directories.
    Dir = cast<detail::InMemoryDirectory>(Node);
    if (I == E)
      return Dir;
  }
}

llvm::ErrorOr<Status> InMemoryFileSystem::status(const Twine &Path) {
  auto Node = lookupInMemoryNode(*this, Root.get(), Path);
  if (Node)
    return (*Node)->getStatus();
  return Node.getError();
}

llvm::ErrorOr<std::unique_ptr<File>>
InMemoryFileSystem::openFileForRead(const Twine &Path) {
  auto Node = lookupInMemoryNode(*this, Root.get(), Path);
  if (!Node)
    return Node.getError();

  // When we have a file provide a heap-allocated wrapper for the memory buffer
  // to match the ownership semantics for File.
  if (auto *F = dyn_cast<detail::InMemoryFile>(*Node))
    return std::unique_ptr<File>(new detail::InMemoryFileAdaptor(*F));

  // FIXME: errc::not_a_file?
  return make_error_code(llvm::errc::invalid_argument);
}

namespace {

/// Adaptor from InMemoryDir::iterator to directory_iterator.
class InMemoryDirIterator : public latino::vfs::detail::DirIterImpl {
  detail::InMemoryDirectory::const_iterator I;
  detail::InMemoryDirectory::const_iterator E;

public:
  InMemoryDirIterator() = default;

  explicit InMemoryDirIterator(detail::InMemoryDirectory &Dir)
      : I(Dir.begin()), E(Dir.end()) {
    if (I != E)
      CurrentEntry = I->second->getStatus();
  }

  std::error_code increment() override {
    ++I;
    // When we're at the end, make CurrentEntry invalid and DirIterImpl will do
    // the rest.
    CurrentEntry = I != E ? I->second->getStatus() : Status();
    return {};
  }
};

} // namespace

directory_iterator InMemoryFileSystem::dir_begin(const Twine &Dir,
                                                 std::error_code &EC) {
  auto Node = lookupInMemoryNode(*this, Root.get(), Dir);
  if (!Node) {
    EC = Node.getError();
    return directory_iterator(std::make_shared<InMemoryDirIterator>());
  }

  if (auto *DirNode = dyn_cast<detail::InMemoryDirectory>(*Node))
    return directory_iterator(std::make_shared<InMemoryDirIterator>(*DirNode));

  EC = make_error_code(llvm::errc::not_a_directory);
  return directory_iterator(std::make_shared<InMemoryDirIterator>());
}

std::error_code InMemoryFileSystem::setCurrentWorkingDirectory(const Twine &P) {
  SmallString<128> Path;
  P.toVector(Path);

  // Fix up relative paths. This just prepends the current working directory.
  std::error_code EC = makeAbsolute(Path);
  assert(!EC);
  (void)EC;

  if (useNormalizedPaths())
    llvm::sys::path::remove_dots(Path, /*remove_dot_dot=*/true);

  if (!Path.empty())
    WorkingDirectory = Path.str();
  return {};
}

std::error_code
InMemoryFileSystem::getRealPath(const Twine &Path,
                                SmallVectorImpl<char> &Output) const {
  auto CWD = getCurrentWorkingDirectory();
  if (!CWD || CWD->empty())
    return errc::operation_not_permitted;
  Path.toVector(Output);
  if (auto EC = makeAbsolute(Output))
    return EC;
  llvm::sys::path::remove_dots(Output, /*remove_dot_dot=*/true);
  return {};
}

} // namespace vfs
} // namespace latino

//===-----------------------------------------------------------------------===/
// RedirectingFileSystem implementation
//===-----------------------------------------------------------------------===/

namespace {

enum EntryKind { EK_Directory, EK_File };

/// A single file or directory in the VFS.
class Entry {
  EntryKind Kind;
  std::string Name;

public:
  Entry(EntryKind K, StringRef Name) : Kind(K), Name(Name) {}
  virtual ~Entry() = default;

  StringRef getName() const { return Name; }
  EntryKind getKind() const { return Kind; }
};

class RedirectingDirectoryEntry : public Entry {
  std::vector<std::unique_ptr<Entry>> Contents;
  Status S;

public:
  RedirectingDirectoryEntry(StringRef Name,
                            std::vector<std::unique_ptr<Entry>> Contents,
                            Status S)
      : Entry(EK_Directory, Name), Contents(std::move(Contents)),
        S(std::move(S)) {}
  RedirectingDirectoryEntry(StringRef Name, Status S)
      : Entry(EK_Directory, Name), S(std::move(S)) {}

  Status getStatus() { return S; }

  void addContent(std::unique_ptr<Entry> Content) {
    Contents.push_back(std::move(Content));
  }

  Entry *getLastContent() const { return Contents.back().get(); }

  using iterator = decltype(Contents)::iterator;

  iterator contents_begin() { return Contents.begin(); }
  iterator contents_end() { return Contents.end(); }

  static bool classof(const Entry *E) { return E->getKind() == EK_Directory; }
};

class RedirectingFileEntry : public Entry {
public:
  enum NameKind { NK_NotSet, NK_External, NK_Virtual };

private:
  std::string ExternalContentsPath;
  NameKind UseName;

public:
  RedirectingFileEntry(StringRef Name, StringRef ExternalContentsPath,
                       NameKind UseName)
      : Entry(EK_File, Name), ExternalContentsPath(ExternalContentsPath),
        UseName(UseName) {}

  StringRef getExternalContentsPath() const { return ExternalContentsPath; }

  /// whether to use the external path as the name for this file.
  bool useExternalName(bool GlobalUseExternalName) const {
    return UseName == NK_NotSet ? GlobalUseExternalName
                                : (UseName == NK_External);
  }

  NameKind getUseName() const { return UseName; }

  static bool classof(const Entry *E) { return E->getKind() == EK_File; }
};

class RedirectingFileSystem;

class VFSFromYamlDirIterImpl : public latino::vfs::detail::DirIterImpl {
  std::string Dir;
  RedirectingFileSystem &FS;
  RedirectingDirectoryEntry::iterator Current, End;

public:
  VFSFromYamlDirIterImpl(const Twine &Path, RedirectingFileSystem &FS,
                         RedirectingDirectoryEntry::iterator Begin,
                         RedirectingDirectoryEntry::iterator End,
                         std::error_code &EC);

  std::error_code increment() override;
};

/// A virtual file system parsed from a YAML file.
///
/// Currently, this class allows creating virtual directories and mapping
/// virtual file paths to existing external files, available in \\c ExternalFS.
///
/// The basic structure of the parsed file is:
/// \\verbatim
/// {
///   'version': <version number>,
///   <optional configuration>
///   'roots': [
///              <directory entries>
///            ]
/// }
/// \\endverbatim
///
/// All configuration options are optional.
///   'case-sensitive': <boolean, default=true>
///   'use-external-names': <boolean, default=true>
///   'overlay-relative': <boolean, default=false>
///   'ignore-non-existent-contents': <boolean, default=true>
///
/// Virtual directories are represented as
/// \\verbatim
/// {
///   'type': 'directory',
///   'name': <string>,
///   'contents': [ <file or directory entries> ]
/// }
/// \\endverbatim
///
/// The default attributes for virtual directories are:
/// \\verbatim
/// MTime = now() when created
/// Perms = 0777
/// User = Group = 0
/// Size = 0
/// UniqueID = unspecified unique value
/// \\endverbatim
///
/// Re-mapped files are represented as
/// \\verbatim
/// {
///   'type': 'file',
///   'name': <string>,
///   'use-external-name': <boolean> # Optional
///   'external-contents': <path to external file>)
/// }
/// \\endverbatim
///
/// and inherit their attributes from the external contents.
///
/// In both cases, the 'name' field may contain multiple path components (e.g.
/// /path/to/file). However, any directory that contains more than one child
/// must be uniquely represented by a directory entry.
class RedirectingFileSystem : public vfs::FileSystem {
  friend class RedirectingFileSystemParser;

  /// The root(s) of the virtual file system.
  std::vector<std::unique_ptr<Entry>> Roots;

  /// The file system to use for external references.
  IntrusiveRefCntPtr<FileSystem> ExternalFS;

  /// If IsRelativeOverlay is set, this represents the directory
  /// path that should be prefixed to each 'external-contents' entry
  /// when reading from YAML files.
  std::string ExternalContentsPrefixDir;

  /// @name Configuration
  /// @{

  /// Whether to perform case-sensitive comparisons.
  ///
  /// Currently, case-insensitive matching only works correctly with ASCII.
  bool CaseSensitive = true;

  /// IsRelativeOverlay marks whether a IsExternalContentsPrefixDir path must
  /// be prefixed in every 'external-contents' when reading from YAML files.
  bool IsRelativeOverlay = false;

  /// Whether to use to use the value of 'external-contents' for the
  /// names of files.  This global value is overridable on a per-file basis.
  bool UseExternalNames = true;

  /// Whether an invalid path obtained via 'external-contents' should
  /// cause iteration on the VFS to stop. If 'true', the VFS should ignore
  /// the entry and continue with the next. Allows YAML files to be shared
  /// across multiple compiler invocations regardless of prior existent
  /// paths in 'external-contents'. This global value is overridable on a
  /// per-file basis.
  bool IgnoreNonExistentContents = true;
  /// @}

  /// Virtual file paths and external files could be canonicalized without "".."",
  /// ""."" and ""./"" in their paths. FIXME: some unittests currently fail on
  /// win32 when using remove_dots and remove_leading_dotslash on paths.
  bool UseCanonicalizedPaths =
#ifdef _WIN32
      false;
#else
      true;
#endif

private:
  RedirectingFileSystem(IntrusiveRefCntPtr<FileSystem> ExternalFS)
      : ExternalFS(std::move(ExternalFS)) {}

  /// Looks up the path <tt>[Start, End)</tt> in \\p From, possibly
  /// recursing into the contents of \\p From if it is a directory.
  ErrorOr<Entry *> lookupPath(sys::path::const_iterator Start,
                              sys::path::const_iterator End, Entry *From);

  /// Get the status of a given an \\c Entry.
  ErrorOr<Status> status(const Twine &Path, Entry *E);

public:
  /// Looks up \\p Path in \\c Roots.
  ErrorOr<Entry *> lookupPath(const Twine &Path);

  /// Parses \\p Buffer, which is expected to be in YAML format and
  /// returns a virtual file system representing its contents.
  static RedirectingFileSystem *
  create(std::unique_ptr<MemoryBuffer> Buffer,
         SourceMgr::DiagHandlerTy DiagHandler, StringRef YAMLFilePath,
         void *DiagContext, IntrusiveRefCntPtr<FileSystem> ExternalFS);

  ErrorOr<Status> status(const Twine &Path) override;
  ErrorOr<std::unique_ptr<File>> openFileForRead(const Twine &Path) override;

  llvm::ErrorOr<std::string> getCurrentWorkingDirectory() const override {
    return ExternalFS->getCurrentWorkingDirectory();
  }

  std::error_code setCurrentWorkingDirectory(const Twine &Path) override {
    return ExternalFS->setCurrentWorkingDirectory(Path);
  }

  directory_iterator dir_begin(const Twine &Dir, std::error_code &EC) override {
    ErrorOr<Entry *> E = lookupPath(Dir);
    if (!E) {
      EC = E.getError();
      return {};
    }
    ErrorOr<Status> S = status(Dir, *E);
    if (!S) {
      EC = S.getError();
      return {};
    }
    if (!S->isDirectory()) {
      EC = std::error_code(static_cast<int>(errc::not_a_directory),
                           std::system_category());
      return {};
    }

    auto *D = cast<RedirectingDirectoryEntry>(*E);
    return directory_iterator(std::make_shared<VFSFromYamlDirIterImpl>(
        Dir, *this, D->contents_begin(), D->contents_end(), EC));
  }

  void setExternalContentsPrefixDir(StringRef PrefixDir) {
    ExternalContentsPrefixDir = PrefixDir.str();
  }

  StringRef getExternalContentsPrefixDir() const {
    return ExternalContentsPrefixDir;
  }

  bool ignoreNonExistentContents() const { return IgnoreNonExistentContents; }

#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
  LLVM_DUMP_METHOD void dump() const {
    for (const auto &Root : Roots)
      dumpEntry(Root.get());
  }

  LLVM_DUMP_METHOD void dumpEntry(Entry *E, int NumSpaces = 0) const {
    StringRef Name = E->getName();
    for (int i = 0, e = NumSpaces; i < e; ++i)
      dbgs() << "" "";
    dbgs() << ""'"" << Name.str().c_str() << ""'""
           << ""\\n"";

    if (E->getKind() == EK_Directory) {
      auto *DE = dyn_cast<RedirectingDirectoryEntry>(E);
      assert(DE && ""Should be a directory"");

      for (std::unique_ptr<Entry> &SubEntry :
           llvm::make_range(DE->contents_begin(), DE->contents_end()))
        dumpEntry(SubEntry.get(), NumSpaces + 2);
    }
  }
#endif
};

/// A helper class to hold the common YAML parsing state.
class RedirectingFileSystemParser {
  yaml::Stream &Stream;

  void error(yaml::Node *N, const Twine &Msg) { Stream.printError(N, Msg); }

  // false on error
  bool parseScalarString(yaml::Node *N, StringRef &Result,
                         SmallVectorImpl<char> &Storage) {
    const auto *S = dyn_cast<yaml::ScalarNode>(N);

    if (!S) {
      error(N, ""expected string"");
      return false;
    }
    Result = S->getValue(Storage);
    return true;
  }

  // false on error
  bool parseScalarBool(yaml::Node *N, bool &Result) {
    SmallString<5> Storage;
    StringRef Value;
    if (!parseScalarString(N, Value, Storage))
      return false;

    if (Value.equals_lower(""true"") || Value.equals_lower(""on"") ||
        Value.equals_lower(""yes"") || Value == ""1"") {
      Result = true;
      return true;
    } else if (Value.equals_lower(""false"") || Value.equals_lower(""off"") ||
               Value.equals_lower(""no"") || Value == ""0"") {
      Result = false;
      return true;
    }

    error(N, ""expected boolean value"");
    return false;
  }

  struct KeyStatus {
    bool Required;
    bool Seen = false;

    KeyStatus(bool Required = false) : Required(Required) {}
  };

  using KeyStatusPair = std::pair<StringRef, KeyStatus>;

  // false on error
  bool checkDuplicateOrUnknownKey(yaml::Node *KeyNode, StringRef Key,
                                  DenseMap<StringRef, KeyStatus> &Keys) {
    if (!Keys.count(Key)) {
      error(KeyNode, ""unknown key"");
      return false;
    }
    KeyStatus &S = Keys[Key];
    if (S.Seen) {
      error(KeyNode, Twine(""duplicate key '"") + Key + ""'"");
      return false;
    }
    S.Seen = true;
    return true;
  }

  // false on error
  bool checkMissingKeys(yaml::Node *Obj, DenseMap<StringRef, KeyStatus> &Keys) {
    for (const auto &I : Keys) {
      if (I.second.Required && !I.second.Seen) {
        error(Obj, Twine(""missing key '"") + I.first + ""'"");
        return false;
      }
    }
    return true;
  }

  Entry *lookupOrCreateEntry(RedirectingFileSystem *FS, StringRef Name,
                             Entry *ParentEntry = nullptr) {
    if (!ParentEntry) { // Look for a existent root
      for (const auto &Root : FS->Roots) {
        if (Name.equals(Root->getName())) {
          ParentEntry = Root.get();
          return ParentEntry;
        }
      }
    } else { // Advance to the next component
      auto *DE = dyn_cast<RedirectingDirectoryEntry>(ParentEntry);
      for (std::unique_ptr<Entry> &Content :
           llvm::make_range(DE->contents_begin(), DE->contents_end())) {
        auto *DirContent = dyn_cast<RedirectingDirectoryEntry>(Content.get());
        if (DirContent && Name.equals(Content->getName()))
          return DirContent;
      }
    }

    // ... or create a new one
    std::unique_ptr<Entry> E = llvm::make_unique<RedirectingDirectoryEntry>(
        Name,
        Status("""", getNextVirtualUniqueID(), std::chrono::system_clock::now(),
               0, 0, 0, file_type::directory_file, sys::fs::all_all));

    if (!ParentEntry) { // Add a new root to the overlay
      FS->Roots.push_back(std::move(E));
      ParentEntry = FS->Roots.back().get();
      return ParentEntry;
    }

    auto *DE = dyn_cast<RedirectingDirectoryEntry>(ParentEntry);
    DE->addContent(std::move(E));
    return DE->getLastContent();
  }

  void uniqueOverlayTree(RedirectingFileSystem *FS, Entry *SrcE,
                         Entry *NewParentE = nullptr) {
    StringRef Name = SrcE->getName();
    switch (SrcE->getKind()) {
    case EK_Directory: {
      auto *DE = dyn_cast<RedirectingDirectoryEntry>(SrcE);
      assert(DE && ""Must be a directory"");
      // Empty directories could be present in the YAML as a way to
      // describe a file for a current directory after some of its subdir
      // is parsed. This only leads to redundant walks, ignore it.
      if (!Name.empty())
        NewParentE = lookupOrCreateEntry(FS, Name, NewParentE);
      for (std::unique_ptr<Entry> &SubEntry :
           llvm::make_range(DE->contents_begin(), DE->contents_end()))
        uniqueOverlayTree(FS, SubEntry.get(), NewParentE);
      break;
    }
    case EK_File: {
      auto *FE = dyn_cast<RedirectingFileEntry>(SrcE);
      assert(FE && ""Must be a file"");
      assert(NewParentE && ""Parent entry must exist"");
      auto *DE = dyn_cast<RedirectingDirectoryEntry>(NewParentE);
      DE->addContent(llvm::make_unique<RedirectingFileEntry>(
          Name, FE->getExternalContentsPath(), FE->getUseName()));
      break;
    }
    }
  }

  std::unique_ptr<Entry> parseEntry(yaml::Node *N, RedirectingFileSystem *FS) {
    auto *M = dyn_cast<yaml::MappingNode>(N);
    if (!M) {
      error(N, ""expected mapping node for file or directory entry"");
      return nullptr;
    }

    KeyStatusPair Fields[] = {
        KeyStatusPair(""name"", true),
        KeyStatusPair(""type"", true),
        KeyStatusPair(""contents"", false),
        KeyStatusPair(""external-contents"", false),
        KeyStatusPair(""use-external-name"", false),
    };

    DenseMap<StringRef, KeyStatus> Keys(std::begin(Fields), std::end(Fields));

    bool HasContents = false; // external or otherwise
    std::vector<std::unique_ptr<Entry>> EntryArrayContents;
    std::string ExternalContentsPath;
    std::string Name;
    auto UseExternalName = RedirectingFileEntry::NK_NotSet;
    EntryKind Kind;

    for (auto &I : *M) {
      StringRef Key;
      // Reuse the buffer for key and value, since we don't look at key after
      // parsing value.
      SmallString<256> Buffer;
      if (!parseScalarString(I.getKey(), Key, Buffer))
        return nullptr;

      if (!checkDuplicateOrUnknownKey(I.getKey(), Key, Keys))
        return nullptr;

      StringRef Value;
      if (Key == ""name"") {
        if (!parseScalarString(I.getValue(), Value, Buffer))
          return nullptr;

        if (FS->UseCanonicalizedPaths) {
          SmallString<256> Path(Value);
          // Guarantee that old YAML files containing paths with "".."" and "".""
          // are properly canonicalized before read into the VFS.
          Path = sys::path::remove_leading_dotslash(Path);
          sys::path::remove_dots(Path, /*remove_dot_dot=*/true);
          Name = Path.str();
        } else {
          Name = Value;
        }
      } else if (Key == ""type"") {
        if (!parseScalarString(I.getValue(), Value, Buffer))
          return nullptr;
        if (Value == ""file"")
          Kind = EK_File;
        else if (Value == ""directory"")
          Kind = EK_Directory;
        else {
          error(I.getValue(), ""unknown value for 'type'"");
          return nullptr;
        }
      } else if (Key == ""contents"") {
        if (HasContents) {
          error(I.getKey(),
                ""entry already has 'contents' or 'external-contents'"");
          return nullptr;
        }
        HasContents = true;
        auto *Contents = dyn_cast<yaml::SequenceNode>(I.getValue());
        if (!Contents) {
          // FIXME: this is only for directories, what about files?
          error(I.getValue(), ""expected array"");
          return nullptr;
        }

        for (auto &I : *Contents) {
          if (std::unique_ptr<Entry> E = parseEntry(&I, FS))
            EntryArrayContents.push_back(std::move(E));
          else
            return nullptr;
        }
      } else if (Key == ""external-contents"") {
        if (HasContents) {
          error(I.getKey(),
                ""entry already has 'contents' or 'external-contents'"");
          return nullptr;
        }
        HasContents = true;
        if (!parseScalarString(I.getValue(), Value, Buffer))
          return nullptr;

        SmallString<256> FullPath;
        if (FS->IsRelativeOverlay) {
          FullPath = FS->getExternalContentsPrefixDir();
          assert(!FullPath.empty() &&
                 ""External contents prefix directory must exist"");
          llvm::sys::path::append(FullPath, Value);
        } else {
          FullPath = Value;
        }

        if (FS->UseCanonicalizedPaths) {
          // Guarantee that old YAML files containing paths with "".."" and "".""
          // are properly canonicalized before read into the VFS.
          FullPath = sys::path::remove_leading_dotslash(FullPath);
          sys::path::remove_dots(FullPath, /*remove_dot_dot=*/true);
        }
        ExternalContentsPath = FullPath.str();
      } else if (Key == ""use-external-name"") {
        bool Val;
        if (!parseScalarBool(I.getValue(), Val))
          return nullptr;
        UseExternalName = Val ? RedirectingFileEntry::NK_External
                              : RedirectingFileEntry::NK_Virtual;
      } else {
        llvm_unreachable(""key missing from Keys"");
      }
    }

    if (Stream.failed())
      return nullptr;

    // check for missing keys
    if (!HasContents) {
      error(N, ""missing key 'contents' or 'external-contents'"");
      return nullptr;
    }
    if (!checkMissingKeys(N, Keys))
      return nullptr;

    // check invalid configuration
    if (Kind == EK_Directory &&
        UseExternalName != RedirectingFileEntry::NK_NotSet) {
      error(N, ""'use-external-name' is not supported for directories"");
      return nullptr;
    }

    // Remove trailing slash(es), being careful not to remove the root path
    StringRef Trimmed(Name);
    size_t RootPathLen = sys::path::root_path(Trimmed).size();
    while (Trimmed.size() > RootPathLen &&
           sys::path::is_separator(Trimmed.back()))
      Trimmed = Trimmed.slice(0, Trimmed.size() - 1);
    // Get the last component
    StringRef LastComponent = sys::path::filename(Trimmed);

    std::unique_ptr<Entry> Result;
    switch (Kind) {
    case EK_File:
      Result = llvm::make_unique<RedirectingFileEntry>(
          LastComponent, std::move(ExternalContentsPath), UseExternalName);
      break;
    case EK_Directory:
      Result = llvm::make_unique<RedirectingDirectoryEntry>(
          LastComponent, std::move(EntryArrayContents),
          Status("""", getNextVirtualUniqueID(), std::chrono::system_clock::now(),
                 0, 0, 0, file_type::directory_file, sys::fs::all_all));
      break;
    }

    StringRef Parent = sys::path::parent_path(Trimmed);
    if (Parent.empty())
      return Result;

    // if 'name' contains multiple components, create implicit directory entries
    for (sys::path::reverse_iterator I = sys::path::rbegin(Parent),
                                     E = sys::path::rend(Parent);
         I != E; ++I) {
      std::vector<std::unique_ptr<Entry>> Entries;
      Entries.push_back(std::move(Result));
      Result = llvm::make_unique<RedirectingDirectoryEntry>(
          *I, std::move(Entries),
          Status("""", getNextVirtualUniqueID(), std::chrono::system_clock::now(),
                 0, 0, 0, file_type::directory_file, sys::fs::all_all));
    }
    return Result;
  }

public:
  RedirectingFileSystemParser(yaml::Stream &S) : Stream(S) {}

  // false on error
  bool parse(yaml::Node *Root, RedirectingFileSystem *FS) {
    auto *Top = dyn_cast<yaml::MappingNode>(Root);
    if (!Top) {
      error(Root, ""expected mapping node"");
      return false;
    }

    KeyStatusPair Fields[] = {
        KeyStatusPair(""version"", true),
        KeyStatusPair(""case-sensitive"", false),
        KeyStatusPair(""use-external-names"", false),
        KeyStatusPair(""overlay-relative"", false),
        KeyStatusPair(""ignore-non-existent-contents"", false),
        KeyStatusPair(""roots"", true),
    };

    DenseMap<StringRef, KeyStatus> Keys(std::begin(Fields), std::end(Fields));
    std::vector<std::unique_ptr<Entry>> RootEntries;

    // Parse configuration and 'roots'
    for (auto &I : *Top) {
      SmallString<10> KeyBuffer;
      StringRef Key;
      if (!parseScalarString(I.getKey(), Key, KeyBuffer))
        return false;

      if (!checkDuplicateOrUnknownKey(I.getKey(), Key, Keys))
        return false;

      if (Key == ""roots"") {
        auto *Roots = dyn_cast<yaml::SequenceNode>(I.getValue());
        if (!Roots) {
          error(I.getValue(), ""expected array"");
          return false;
        }

        for (auto &I : *Roots) {
          if (std::unique_ptr<Entry> E = parseEntry(&I, FS))
            RootEntries.push_back(std::move(E));
          else
            return false;
        }
      } else if (Key == ""version"") {
        StringRef VersionString;
        SmallString<4> Storage;
        if (!parseScalarString(I.getValue(), VersionString, Storage))
          return false;
        int Version;
        if (VersionString.getAsInteger<int>(10, Version)) {
          error(I.getValue(), ""expected integer"");
          return false;
        }
        if (Version < 0) {
          error(I.getValue(), ""invalid version number"");
          return false;
        }
        if (Version != 0) {
          error(I.getValue(), ""version mismatch, expected 0"");
          return false;
        }
      } else if (Key == ""case-sensitive"") {
        if (!parseScalarBool(I.getValue(), FS->CaseSensitive))
          return false;
      } else if (Key == ""overlay-relative"") {
        if (!parseScalarBool(I.getValue(), FS->IsRelativeOverlay))
          return false;
      } else if (Key == ""use-external-names"") {
        if (!parseScalarBool(I.getValue(), FS->UseExternalNames))
          return false;
      } else if (Key == ""ignore-non-existent-contents"") {
        if (!parseScalarBool(I.getValue(), FS->IgnoreNonExistentContents))
          return false;
      } else {
        llvm_unreachable(""key missing from Keys"");
      }
    }

    if (Stream.failed())
      return false;

    if (!checkMissingKeys(Top, Keys))
      return false;

    // Now that we sucessefully parsed the YAML file, canonicalize the internal
    // representation to a proper directory tree so that we can search faster
    // inside the VFS.
    for (auto &E : RootEntries)
      uniqueOverlayTree(FS, E.get());

    return true;
  }
};

} // namespace

RedirectingFileSystem *
RedirectingFileSystem::create(std::unique_ptr<MemoryBuffer> Buffer,
                              SourceMgr::DiagHandlerTy DiagHandler,
                              StringRef YAMLFilePath, void *DiagContext,
                              IntrusiveRefCntPtr<FileSystem> ExternalFS) {
  SourceMgr SM;
  yaml::Stream Stream(Buffer->getMemBufferRef(), SM);

  SM.setDiagHandler(DiagHandler, DiagContext);
  yaml::document_iterator DI = Stream.begin();
  yaml::Node *Root = DI->getRoot();
  if (DI == Stream.end() || !Root) {
    SM.PrintMessage(SMLoc(), SourceMgr::DK_Error, ""expected root node"");
    return nullptr;
  }

  RedirectingFileSystemParser P(Stream);

  std::unique_ptr<RedirectingFileSystem> FS(
      new RedirectingFileSystem(std::move(ExternalFS)));

  if (!YAMLFilePath.empty()) {
    // Use the YAML path from -ivfsoverlay to compute the dir to be prefixed
    // to each 'external-contents' path.
    //
    // Example:
    //    -ivfsoverlay dummy.cache/vfs/vfs.yaml
    // yields:
    //  FS->ExternalContentsPrefixDir => /<absolute_path_to>/dummy.cache/vfs
    //
    SmallString<256> OverlayAbsDir = sys::path::parent_path(YAMLFilePath);
    std::error_code EC = llvm::sys::fs::make_absolute(OverlayAbsDir);
    assert(!EC && ""Overlay dir final path must be absolute"");
    (void)EC;
    FS->setExternalContentsPrefixDir(OverlayAbsDir);
  }

  if (!P.parse(Root, FS.get()))
    return nullptr;

  return FS.release();
}

ErrorOr<Entry *> RedirectingFileSystem::lookupPath(const Twine &Path_) {
  SmallString<256> Path;
  Path_.toVector(Path);

  // Handle relative paths
  if (std::error_code EC = makeAbsolute(Path))
    return EC;

  // Canonicalize path by removing ""."", "".."", ""./"", etc components. This is
  // a VFS request, do bot bother about symlinks in the path components
  // but canonicalize in order to perform the correct entry search.
  if (UseCanonicalizedPaths) {
    Path = sys::path::remove_leading_dotslash(Path);
    sys::path::remove_dots(Path, /*remove_dot_dot=*/true);
  }

  if (Path.empty())
    return make_error_code(llvm::errc::invalid_argument);

  sys::path::const_iterator Start = sys::path::begin(Path);
  sys::path::const_iterator End = sys::path::end(Path);
  for (const auto &Root : Roots) {
    ErrorOr<Entry *> Result = lookupPath(Start, End, Root.get());
    if (Result || Result.getError() != llvm::errc::no_such_file_or_directory)
      return Result;
  }
  return make_error_code(llvm::errc::no_such_file_or_directory);
}

ErrorOr<Entry *>
RedirectingFileSystem::lookupPath(sys::path::const_iterator Start,
                                  sys::path::const_iterator End, Entry *From) {
#ifndef _WIN32
  assert(!isTraversalComponent(*Start) &&
         !isTraversalComponent(From->getName()) &&
         ""Paths should not contain traversal components"");
#else
  // FIXME: this is here to support windows, remove it once canonicalized
  // paths become globally default.
  if (Start->equals("".""))
    ++Start;
#endif

  StringRef FromName = From->getName();

  // Forward the search to the next component in case this is an empty one.
  if (!FromName.empty()) {
    if (CaseSensitive ? !Start->equals(FromName)
                      : !Start->equals_lower(FromName))
      // failure to match
      return make_error_code(llvm::errc::no_such_file_or_directory);

    ++Start;

    if (Start == End) {
      // Match!
      return From;
    }
  }

  auto *DE = dyn_cast<RedirectingDirectoryEntry>(From);
  if (!DE)
    return make_error_code(llvm::errc::not_a_directory);

  for (const std::unique_ptr<Entry> &DirEntry :
       llvm::make_range(DE->contents_begin(), DE->contents_end())) {
    ErrorOr<Entry *> Result = lookupPath(Start, End, DirEntry.get());
    if (Result || Result.getError() != llvm::errc::no_such_file_or_directory)
      return Result;
  }
  return make_error_code(llvm::errc::no_such_file_or_directory);
}

static Status getRedirectedFileStatus(const Twine &Path, bool UseExternalNames,
                                      Status ExternalStatus) {
  Status S = ExternalStatus;
  if (!UseExternalNames)
    S = Status::copyWithNewName(S, Path.str());
  S.IsVFSMapped = true;
  return S;
}

ErrorOr<Status> RedirectingFileSystem::status(const Twine &Path, Entry *E) {
  assert(E != nullptr);
  if (auto *F = dyn_cast<RedirectingFileEntry>(E)) {
    ErrorOr<Status> S = ExternalFS->status(F->getExternalContentsPath());
    assert(!S || S->getName() == F->getExternalContentsPath());
    if (S)
      return getRedirectedFileStatus(Path, F->useExternalName(UseExternalNames),
                                     *S);
    return S;
  } else { // directory
    auto *DE = cast<RedirectingDirectoryEntry>(E);
    return Status::copyWithNewName(DE->getStatus(), Path.str());
  }
}

ErrorOr<Status> RedirectingFileSystem::status(const Twine &Path) {
  ErrorOr<Entry *> Result = lookupPath(Path);
  if (!Result)
    return Result.getError();
  return status(Path, *Result);
}

namespace {

/// Provide a file wrapper with an overriden status.
class FileWithFixedStatus : public File {
  std::unique_ptr<File> InnerFile;
  Status S;

public:
  FileWithFixedStatus(std::unique_ptr<File> InnerFile, Status S)
      : InnerFile(std::move(InnerFile)), S(std::move(S)) {}

  ErrorOr<Status> status() override { return S; }
  ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>

  getBuffer(const Twine &Name, int64_t FileSize, bool RequiresNullTerminator,
            bool IsVolatile) override {
    return InnerFile->getBuffer(Name, FileSize, RequiresNullTerminator,
                                IsVolatile);
  }

  std::error_code close() override { return InnerFile->close(); }
};

} // namespace

ErrorOr<std::unique_ptr<File>>
RedirectingFileSystem::openFileForRead(const Twine &Path) {
  ErrorOr<Entry *> E = lookupPath(Path);
  if (!E)
    return E.getError();

  auto *F = dyn_cast<RedirectingFileEntry>(*E);
  if (!F) // FIXME: errc::not_a_file?
    return make_error_code(llvm::errc::invalid_argument);

  auto Result = ExternalFS->openFileForRead(F->getExternalContentsPath());
  if (!Result)
    return Result;

  auto ExternalStatus = (*Result)->status();
  if (!ExternalStatus)
    return ExternalStatus.getError();

  // FIXME: Update the status with the name and VFSMapped.
  Status S = getRedirectedFileStatus(Path, F->useExternalName(UseExternalNames),
                                     *ExternalStatus);
  return std::unique_ptr<File>(
      llvm::make_unique<FileWithFixedStatus>(std::move(*Result), S));
}

IntrusiveRefCntPtr<FileSystem>
vfs::getVFSFromYAML(std::unique_ptr<MemoryBuffer> Buffer,
                    SourceMgr::DiagHandlerTy DiagHandler,
                    StringRef YAMLFilePath, void *DiagContext,
                    IntrusiveRefCntPtr<FileSystem> ExternalFS) {
  return RedirectingFileSystem::create(std::move(Buffer), DiagHandler,
                                       YAMLFilePath, DiagContext,
                                       std::move(ExternalFS));
}

static void getVFSEntries(Entry *SrcE, SmallVectorImpl<StringRef> &Path,
                          SmallVectorImpl<YAMLVFSEntry> &Entries) {
  auto Kind = SrcE->getKind();
  if (Kind == EK_Directory) {
    auto *DE = dyn_cast<RedirectingDirectoryEntry>(SrcE);
    assert(DE && ""Must be a directory"");
    for (std::unique_ptr<Entry> &SubEntry :
         llvm::make_range(DE->contents_begin(), DE->contents_end())) {
      Path.push_back(SubEntry->getName());
      getVFSEntries(SubEntry.get(), Path, Entries);
      Path.pop_back();
    }
    return;
  }

  assert(Kind == EK_File && ""Must be a EK_File"");
  auto *FE = dyn_cast<RedirectingFileEntry>(SrcE);
  assert(FE && ""Must be a file"");
  SmallString<128> VPath;
  for (auto &Comp : Path)
    llvm::sys::path::append(VPath, Comp);
  Entries.push_back(YAMLVFSEntry(VPath.c_str(), FE->getExternalContentsPath()));
}

void vfs::collectVFSFromYAML(std::unique_ptr<MemoryBuffer> Buffer,
                             SourceMgr::DiagHandlerTy DiagHandler,
                             StringRef YAMLFilePath,
                             SmallVectorImpl<YAMLVFSEntry> &CollectedEntries,
                             void *DiagContext,
                             IntrusiveRefCntPtr<FileSystem> ExternalFS) {
  RedirectingFileSystem *VFS = RedirectingFileSystem::create(
      std::move(Buffer), DiagHandler, YAMLFilePath, DiagContext,
      std::move(ExternalFS));
  ErrorOr<Entry *> RootE = VFS->lookupPath(""/"");
  if (!RootE)
    return;
  SmallVector<StringRef, 8> Components;
  Components.push_back(""/"");
  getVFSEntries(*RootE, Components, CollectedEntries);
}

UniqueID vfs::getNextVirtualUniqueID() {
  static std::atomic<unsigned> UID;
  unsigned ID = ++UID;
  // The following assumes that uint64_t max will never collide with a real
  // dev_t value from the OS.
  return UniqueID(std::numeric_limits<uint64_t>::max(), ID);
}

void YAMLVFSWriter::addFileMapping(StringRef VirtualPath, StringRef RealPath) {
  assert(sys::path::is_absolute(VirtualPath) && ""virtual path not absolute"");
  assert(sys::path::is_absolute(RealPath) && ""real path not absolute"");
  assert(!pathHasTraversal(VirtualPath) && ""path traversal is not supported"");
  Mappings.emplace_back(VirtualPath, RealPath);
}

namespace {

class JSONWriter {
  llvm::raw_ostream &OS;
  SmallVector<StringRef, 16> DirStack;

  unsigned getDirIndent() { return 4 * DirStack.size(); }
  unsigned getFileIndent() { return 4 * (DirStack.size() + 1); }
  bool containedIn(StringRef Parent, StringRef Path);
  StringRef containedPart(StringRef Parent, StringRef Path);
  void startDirectory(StringRef Path);
  void endDirectory();
  void writeEntry(StringRef VPath, StringRef RPath);

public:
  JSONWriter(llvm::raw_ostream &OS) : OS(OS) {}

  void write(ArrayRef<YAMLVFSEntry> Entries, Optional<bool> UseExternalNames,
             Optional<bool> IsCaseSensitive, Optional<bool> IsOverlayRelative,
             Optional<bool> IgnoreNonExistentContents, StringRef OverlayDir);
};

} // namespace

bool JSONWriter::containedIn(StringRef Parent, StringRef Path) {
  using namespace llvm::sys;

  // Compare each path component.
  auto IParent = path::begin(Parent), EParent = path::end(Parent);
  for (auto IChild = path::begin(Path), EChild = path::end(Path);
       IParent != EParent && IChild != EChild; ++IParent, ++IChild) {
    if (*IParent != *IChild)
      return false;
  }
  // Have we exhausted the parent path?
  return IParent == EParent;
}

StringRef JSONWriter::containedPart(StringRef Parent, StringRef Path) {
  assert(!Parent.empty());
  assert(containedIn(Parent, Path));
  return Path.slice(Parent.size() + 1, StringRef::npos);
}

void JSONWriter::startDirectory(StringRef Path) {
  StringRef Name =
      DirStack.empty() ? Path : containedPart(DirStack.back(), Path);
  DirStack.push_back(Path);
  unsigned Indent = getDirIndent();
  OS.indent(Indent) << ""{\\n"";
  OS.indent(Indent + 2) << ""'type': 'directory',\\n"";
  OS.indent(Indent + 2) << ""'name': \\"""" << llvm::yaml::escape(Name) << ""\\"",\\n"";
  OS.indent(Indent + 2) << ""'contents': [\\n"";
}

void JSONWriter::endDirectory() {
  unsigned Indent = getDirIndent();
  OS.indent(Indent + 2) << ""]\\n"";
  OS.indent(Indent) << ""}"";

  DirStack.pop_back();
}

void JSONWriter::writeEntry(StringRef VPath, StringRef RPath) {
  unsigned Indent = getFileIndent();
  OS.indent(Indent) << ""{\\n"";
  OS.indent(Indent + 2) << ""'type': 'file',\\n"";
  OS.indent(Indent + 2) << ""'name': \\"""" << llvm::yaml::escape(VPath) << ""\\"",\\n"";
  OS.indent(Indent + 2) << ""'external-contents': \\""""
                        << llvm::yaml::escape(RPath) << ""\\""\\n"";
  OS.indent(Indent) << ""}"";
}

void JSONWriter::write(ArrayRef<YAMLVFSEntry> Entries,
                       Optional<bool> UseExternalNames,
                       Optional<bool> IsCaseSensitive,
                       Optional<bool> IsOverlayRelative,
                       Optional<bool> IgnoreNonExistentContents,
                       StringRef OverlayDir) {
  using namespace llvm::sys;

  OS << ""{\\n""
        ""  'version': 0,\\n"";
  if (IsCaseSensitive.hasValue())
    OS << ""  'case-sensitive': '""
       << (IsCaseSensitive.getValue() ? ""true"" : ""false"") << ""',\\n"";
  if (UseExternalNames.hasValue())
    OS << ""  'use-external-names': '""
       << (UseExternalNames.getValue() ? ""true"" : ""false"") << ""',\\n"";
  bool UseOverlayRelative = false;
  if (IsOverlayRelative.hasValue()) {
    UseOverlayRelative = IsOverlayRelative.getValue();
    OS << ""  'overlay-relative': '"" << (UseOverlayRelative ? ""true"" : ""false"")
       << ""',\\n"";
  }
  if (IgnoreNonExistentContents.hasValue())
    OS << ""  'ignore-non-existent-contents': '""
       << (IgnoreNonExistentContents.getValue() ? ""true"" : ""false"") << ""',\\n"";
  OS << ""  'roots': [\\n"";

  if (!Entries.empty()) {
    const YAMLVFSEntry &Entry = Entries.front();
    startDirectory(path::parent_path(Entry.VPath));

    StringRef RPath = Entry.RPath;
    if (UseOverlayRelative) {
      unsigned OverlayDirLen = OverlayDir.size();
      assert(RPath.substr(0, OverlayDirLen) == OverlayDir &&
             ""Overlay dir must be contained in RPath"");
      RPath = RPath.slice(OverlayDirLen, RPath.size());
    }

    writeEntry(path::filename(Entry.VPath), RPath);

    for (const auto &Entry : Entries.slice(1)) {
      StringRef Dir = path::parent_path(Entry.VPath);
      if (Dir == DirStack.back())
        OS << "",\\n"";
      else {
        while (!DirStack.empty() && !containedIn(DirStack.back(), Dir)) {
          OS << ""\\n"";
          endDirectory();
        }
        OS << "",\\n"";
        startDirectory(Dir);
      }
      StringRef RPath = Entry.RPath;
      if (UseOverlayRelative) {
        unsigned OverlayDirLen = OverlayDir.size();
        assert(RPath.substr(0, OverlayDirLen) == OverlayDir &&
               ""Overlay dir must be contained in RPath"");
        RPath = RPath.slice(OverlayDirLen, RPath.size());
      }
      writeEntry(path::filename(Entry.VPath), RPath);
    }

    while (!DirStack.empty()) {
      OS << ""\\n"";
      endDirectory();
    }
    OS << ""\\n"";
  }

  OS << ""  ]\\n""
     << ""}\\n"";
}

void YAMLVFSWriter::write(llvm::raw_ostream &OS) {
  llvm::sort(Mappings.begin(), Mappings.end(),
             [](const YAMLVFSEntry &LHS, const YAMLVFSEntry &RHS) {
               return LHS.VPath < RHS.VPath;
             });

  JSONWriter(OS).write(Mappings, UseExternalNames, IsCaseSensitive,
                       IsOverlayRelative, IgnoreNonExistentContents,
                       OverlayDir);
}

VFSFromYamlDirIterImpl::VFSFromYamlDirIterImpl(
    const Twine &_Path, RedirectingFileSystem &FS,
    RedirectingDirectoryEntry::iterator Begin,
    RedirectingDirectoryEntry::iterator End, std::error_code &EC)
    : Dir(_Path.str()), FS(FS), Current(Begin), End(End) {
  while (Current != End) {
    SmallString<128> PathStr(Dir);
    llvm::sys::path::append(PathStr, (*Current)->getName());
    llvm::ErrorOr<vfs::Status> S = FS.status(PathStr);
    if (S) {
      CurrentEntry = *S;
      return;
    }
    // Skip entries which do not map to a reliable external content.
    if (FS.ignoreNonExistentContents() &&
        S.getError() == llvm::errc::no_such_file_or_directory) {
      ++Current;
      continue;
    } else {
      EC = S.getError();
      break;
    }
  }
}

std::error_code VFSFromYamlDirIterImpl::increment() {
  assert(Current != End && ""cannot iterate past end"");
  while (++Current != End) {
    SmallString<128> PathStr(Dir);
    llvm::sys::path::append(PathStr, (*Current)->getName());
    llvm::ErrorOr<vfs::Status> S = FS.status(PathStr);
    if (!S) {
      // Skip entries which do not map to a reliable external content.
      if (FS.ignoreNonExistentContents() &&
          S.getError() == llvm::errc::no_such_file_or_directory) {
        continue;
      } else {
        return S.getError();
      }
    }
    CurrentEntry = *S;
    break;
  }

  if (Current == End)
    CurrentEntry = Status();
  return {};
}

vfs::recursive_directory_iterator::recursive_directory_iterator(
    FileSystem &FS_, const Twine &Path, std::error_code &EC)
    : FS(&FS_) {
  directory_iterator I = FS->dir_begin(Path, EC);
  if (I != directory_iterator()) {
    State = std::make_shared<IterState>();
    State->push(I);
  }
}

vfs::recursive_directory_iterator &
recursive_directory_iterator::increment(std::error_code &EC) {
  assert(FS && State && !State->empty() && ""incrementing past end"");
  assert(State->top()->isStatusKnown() && ""non-canonical end iterator"");
  vfs::directory_iterator End;
  if (State->top()->isDirectory()) {
    vfs::directory_iterator I = FS->dir_begin(State->top()->getName(), EC);
    if (I != End) {
      State->push(I);
      return *this;
    }
  }

  while (!State->empty() && State->top().increment(EC) == End)
    State->pop();

  if (State->empty())
    State.reset(); // end iterator

  return *this;
}
",16183,True,2940.511560465651,median
"/*
 * Copyright (C) 2017-2019 Intel Corporation
 *
 * SPDX-License-Identifier: MIT
 *
 */

#include ""runtime/command_queue/command_queue_hw.h""
#include ""runtime/command_stream/command_stream_receiver.h""
#include ""runtime/event/perf_counter.h""
#include ""runtime/helpers/hw_info.h""
#include ""runtime/helpers/task_information.h""
#include ""runtime/memory_manager/internal_allocation_storage.h""
#include ""runtime/memory_manager/surface.h""
#include ""runtime/os_interface/os_interface.h""
#include ""runtime/utilities/tag_allocator.h""
#include ""test.h""
#include ""unit_tests/fixtures/image_fixture.h""
#include ""unit_tests/helpers/debug_manager_state_restore.h""
#include ""unit_tests/mocks/mock_command_queue.h""
#include ""unit_tests/mocks/mock_context.h""
#include ""unit_tests/mocks/mock_csr.h""
#include ""unit_tests/mocks/mock_device.h""
#include ""unit_tests/mocks/mock_event.h""
#include ""unit_tests/mocks/mock_kernel.h""
#include ""unit_tests/mocks/mock_mdi.h""
#include ""unit_tests/mocks/mock_memory_manager.h""
#include ""unit_tests/mocks/mock_program.h""
#include ""unit_tests/os_interface/mock_performance_counters.h""

#include ""event_fixture.h""

#include <memory>
#include <type_traits>

TEST(Event, NonCopyable) {
    EXPECT_FALSE(std::is_move_constructible<Event>::value);
    EXPECT_FALSE(std::is_copy_constructible<Event>::value);
}

TEST(Event, NonAssignable) {
    EXPECT_FALSE(std::is_move_assignable<Event>::value);
    EXPECT_FALSE(std::is_copy_assignable<Event>::value);
}

TEST(Event, dontUpdateExecutionStatusOnNotReadyEvent) {
    std::unique_ptr<MockDevice> mockDevice(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
    MockContext ctx;
    MockCommandQueue cmdQ(&ctx, mockDevice.get(), 0);
    Event event(&cmdQ, CL_COMMAND_NDRANGE_KERNEL, Event::eventNotReady, 0);

    EXPECT_FALSE(event.peekIsBlocked());
    EXPECT_EQ(CL_QUEUED, event.peekExecutionStatus());
    event.updateExecutionStatus();
    EXPECT_EQ(CL_QUEUED, event.peekExecutionStatus());
}

TEST(Event, givenEventThatStatusChangeWhenPeekIsCalledThenEventIsNotUpdated) {
    std::unique_ptr<MockDevice> mockDevice(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
    MockContext ctx;
    MockCommandQueue cmdQ(&ctx, mockDevice.get(), 0);

    struct mockEvent : public Event {
        using Event::Event;
        void updateExecutionStatus() override {
            callCount++;
        }
        uint32_t callCount = 0u;
    };

    mockEvent event(&cmdQ, CL_COMMAND_NDRANGE_KERNEL, Event::eventNotReady, 0);
    EXPECT_EQ(0u, event.callCount);
    event.peekExecutionStatus();
    EXPECT_EQ(0u, event.callCount);
    event.updateEventAndReturnCurrentStatus();
    EXPECT_EQ(1u, event.callCount);
    event.updateEventAndReturnCurrentStatus();
    EXPECT_EQ(2u, event.callCount);
}

TEST(Event, givenEventWithHigherTaskCountWhenLowerTaskCountIsBeingSetThenTaskCountRemainsUnmodifed) {
    Event *event = new Event(nullptr, CL_COMMAND_NDRANGE_KERNEL, 4, 10);

    EXPECT_EQ(10u, event->peekTaskCount());
    event->updateTaskCount(8);
    EXPECT_EQ(10u, event->peekTaskCount());
    delete event;
}

TEST(Event_, testGetTaskLevel) {
    class TempEvent : public Event {
      public:
        TempEvent() : Event(nullptr, CL_COMMAND_NDRANGE_KERNEL, 5, 7){};

        uint32_t getTaskLevel() override {
            return Event::getTaskLevel();
        }
    };
    TempEvent event;
    // taskLevel and getTaskLevel() should give the same result
    EXPECT_EQ(5u, event.taskLevel);
    EXPECT_EQ(5u, event.getTaskLevel());
}

TEST(Event_, testGetTaskCount) {
    Event event(nullptr, CL_COMMAND_NDRANGE_KERNEL, 5, 7);
    EXPECT_EQ(7u, event.getCompletionStamp());
}

TEST(Event_, testGetEventInfoReturnsTheCQ) {
    std::unique_ptr<MockDevice> mockDevice(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
    auto ctx = std::unique_ptr<Context>(new MockContext());
    auto cmdQ = std::unique_ptr<CommandQueue>(new MockCommandQueue(ctx.get(), mockDevice.get(), 0));
    Event *event = new Event(cmdQ.get(), CL_COMMAND_NDRANGE_KERNEL, 1, 5);
    cl_event clEvent = event;
    cl_command_queue cmdQResult = nullptr;
    size_t sizeReturned = 0;

    auto result = clGetEventInfo(clEvent, CL_EVENT_COMMAND_QUEUE, 0, nullptr, &sizeReturned);
    EXPECT_EQ(CL_SUCCESS, result);
    EXPECT_EQ(sizeof(cl_command_queue), sizeReturned);

    result = clGetEventInfo(clEvent, CL_EVENT_COMMAND_QUEUE, sizeof(cmdQResult), &cmdQResult, &sizeReturned);
    ASSERT_EQ(CL_SUCCESS, result);
    EXPECT_EQ(cmdQ.get(), cmdQResult);
    EXPECT_EQ(sizeReturned, sizeof(cmdQResult));
    delete event;
}

TEST(Event, givenCommandQueueWhenEventIsCreatedWithCommandQueueThenCommandQueueInternalRefCountIsIncremented) {
    std::unique_ptr<MockDevice> mockDevice(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
    MockContext ctx;
    MockCommandQueue cmdQ(&ctx, mockDevice.get(), 0);
    auto intitialRefCount = cmdQ.getRefInternalCount();

    Event *event = new Event(&cmdQ, CL_COMMAND_NDRANGE_KERNEL, 4, 10);
    auto newRefCount = cmdQ.getRefInternalCount();

    EXPECT_EQ(intitialRefCount + 1, newRefCount);
    delete event;

    auto finalRefCount = cmdQ.getRefInternalCount();
    EXPECT_EQ(intitialRefCount, finalRefCount);
}

TEST(Event, givenCommandQueueWhenEventIsCreatedWithoutCommandQueueThenCommandQueueInternalRefCountIsNotModified) {
    MockContext ctx;
    MockCommandQueue cmdQ(&ctx, nullptr, 0);
    auto intitialRefCount = cmdQ.getRefInternalCount();

    Event *event = new Event(nullptr, CL_COMMAND_NDRANGE_KERNEL, 4, 10);
    auto newRefCount = cmdQ.getRefInternalCount();

    EXPECT_EQ(intitialRefCount, newRefCount);
    delete event;

    auto finalRefCount = cmdQ.getRefInternalCount();
    EXPECT_EQ(intitialRefCount, finalRefCount);
}

TEST(Event, waitForEventsFlushesAllQueues) {
    class MockCommandQueueWithFlushCheck : public MockCommandQueue {
      public:
        MockCommandQueueWithFlushCheck() = delete;
        MockCommandQueueWithFlushCheck(MockCommandQueueWithFlushCheck &) = delete;
        MockCommandQueueWithFlushCheck(Context &context, Device *device) : MockCommandQueue(&context, device, nullptr) {
        }
        cl_int flush() override {
            flushCounter++;
            return CL_SUCCESS;
        }
        uint32_t flushCounter = 0;
    };

    std::unique_ptr<Device> device(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
    MockContext context;

    std::unique_ptr<MockCommandQueueWithFlushCheck> cmdQ1(new MockCommandQueueWithFlushCheck(context, device.get()));
    std::unique_ptr<Event> event1(new Event(cmdQ1.get(), CL_COMMAND_NDRANGE_KERNEL, 4, 10));

    std::unique_ptr<MockCommandQueueWithFlushCheck> cmdQ2(new MockCommandQueueWithFlushCheck(context, device.get()));
    std::unique_ptr<Event> event2(new Event(cmdQ2.get(), CL_COMMAND_NDRANGE_KERNEL, 5, 20));

    cl_event eventWaitlist[] = {event1.get(), event2.get()};

    Event::waitForEvents(2, eventWaitlist);

    EXPECT_EQ(1u, cmdQ1->flushCounter);
    EXPECT_EQ(1u, cmdQ2->flushCounter);
}

TEST(Event, waitForEventsWithNotReadyEventDoesNotFlushQueue) {
    class MockCommandQueueWithFlushCheck : public MockCommandQueue {
      public:
        MockCommandQueueWithFlushCheck() = delete;
        MockCommandQueueWithFlushCheck(MockCommandQueueWithFlushCheck &) = delete;
        MockCommandQueueWithFlushCheck(Context &context, Device *device) : MockCommandQueue(&context, device, nullptr) {
        }
        cl_int flush() override {
            flushCounter++;
            return CL_SUCCESS;
        }
        uint32_t flushCounter = 0;
    };

    std::unique_ptr<Device> device(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
    MockContext context;

    std::unique_ptr<MockCommandQueueWithFlushCheck> cmdQ1(new MockCommandQueueWithFlushCheck(context, device.get()));
    std::unique_ptr<Event> event1(new Event(cmdQ1.get(), CL_COMMAND_NDRANGE_KERNEL, Event::eventNotReady, 0));
    cl_event eventWaitlist[] = {event1.get()};

    Event::waitForEvents(1, eventWaitlist);

    EXPECT_EQ(0u, cmdQ1->flushCounter);
}

TEST(Event, givenNotReadyEventOnWaitlistWhenCheckingUserEventDependeciesThenTrueIsReturned) {
    auto event1 = std::make_unique<Event>(nullptr, CL_COMMAND_NDRANGE_KERNEL, Event::eventNotReady, 0);
    cl_event eventWaitlist[] = {event1.get()};

    bool userEventDependencies = Event::checkUserEventDependencies(1, eventWaitlist);
    EXPECT_TRUE(userEventDependencies);
}

TEST(Event, givenReadyEventsOnWaitlistWhenCheckingUserEventDependeciesThenFalseIsReturned) {
    auto event1 = std::make_unique<Event>(nullptr, CL_COMMAND_NDRANGE_KERNEL, 5, 0);
    cl_event eventWaitlist[] = {event1.get()};

    bool userEventDependencies = Event::checkUserEventDependencies(1, eventWaitlist);
    EXPECT_FALSE(userEventDependencies);
}

TEST_F(EventTest, GetEventInfo_CL_EVENT_COMMAND_EXECUTION_STATUS_sizeReturned) {
    Event event(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, 1, 5);
    cl_int eventStatus = -1;
    size_t sizeReturned = 0;

    auto result = clGetEventInfo(&event, CL_EVENT_COMMAND_EXECUTION_STATUS, sizeof(eventStatus), &eventStatus, &sizeReturned);
    ASSERT_EQ(CL_SUCCESS, result);
    EXPECT_EQ(sizeReturned, sizeof(eventStatus));
}

TEST_F(EventTest, GetEventInfo_CL_EVENT_COMMAND_EXECUTION_STATUS_returns_CL_SUBMITTED_HW_LT_Event) {
    uint32_t tagHW = 4;
    uint32_t taskCount = 5;
    *pTagMemory = tagHW;

    Event event(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, 3, taskCount);
    cl_int eventStatus = -1;
    size_t sizeReturned = 0;

    auto result = clGetEventInfo(&event, CL_EVENT_COMMAND_EXECUTION_STATUS, sizeof(eventStatus), &eventStatus, &sizeReturned);
    ASSERT_EQ(CL_SUCCESS, result);

    // If tagCS < taskCount, we always return submitted (ie. no buffering!)
    EXPECT_EQ(CL_SUBMITTED, eventStatus);
}

TEST_F(EventTest, GetEventInfo_CL_EVENT_COMMAND_EXECUTION_STATUS_returns_CL_COMPLETE_HW_EQ_Event) {
    uint32_t tagHW = 5;
    uint32_t taskCount = 5;
    *pTagMemory = tagHW;

    Event event(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, 3, taskCount);
    cl_int eventStatus = -1;
    size_t sizeReturned = 0;

    auto result = clGetEventInfo(&event, CL_EVENT_COMMAND_EXECUTION_STATUS, sizeof(eventStatus), &eventStatus, &sizeReturned);
    ASSERT_EQ(CL_SUCCESS, result);

    // If tagCS == event.taskCount, the event is completed.
    EXPECT_EQ(CL_COMPLETE, eventStatus);
}

TEST_F(EventTest, GetEventInfo_CL_EVENT_COMMAND_EXECUTION_STATUS_returns_CL_SUBMITTED_HW_GT_Event) {
    uint32_t tagHW = 6;
    uint32_t taskCount = 5;
    *pTagMemory = tagHW;

    Event event(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, 3, taskCount);
    cl_int eventStatus = -1;
    size_t sizeReturned = 0;

    auto result = clGetEventInfo(&event, CL_EVENT_COMMAND_EXECUTION_STATUS, sizeof(eventStatus), &eventStatus, &sizeReturned);
    ASSERT_EQ(CL_SUCCESS, result);

    // If tagCS > taskCount, the event is not completed.
    EXPECT_EQ(CL_COMPLETE, eventStatus);
}

TEST_F(EventTest, GetEventInfo_CL_EVENT_COMMAND_EXECUTION_STATUS_returnsSetStatus) {
    Event event(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, Event::eventNotReady, Event::eventNotReady);
    cl_int eventStatus = -1;

    event.setStatus(-1);
    auto result = clGetEventInfo(&event, CL_EVENT_COMMAND_EXECUTION_STATUS, sizeof(eventStatus), &eventStatus, 0);
    EXPECT_EQ(CL_SUCCESS, result);
    EXPECT_EQ(-1, eventStatus);
}

TEST_F(EventTest, GetEventInfo_CL_EVENT_REFERENCE_COUNT_new_Event) {
    uint32_t tagEvent = 5;

    Event event(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, 3, tagEvent);
    cl_uint refCount = 0;
    size_t sizeReturned = 0;

    auto result = clGetEventInfo(&event, CL_EVENT_REFERENCE_COUNT, sizeof(refCount), &refCount, &sizeReturned);
    ASSERT_EQ(CL_SUCCESS, result);
    EXPECT_EQ(sizeof(refCount), sizeReturned);

    EXPECT_EQ(1u, refCount);
}

TEST_F(EventTest, GetEventInfo_CL_EVENT_REFERENCE_COUNT_Retain_Event) {
    uint32_t tagEvent = 5;

    Event event(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, 3, tagEvent);
    event.retain();

    cl_uint refCount = 0;
    size_t sizeReturned = 0;

    auto result = clGetEventInfo(&event, CL_EVENT_REFERENCE_COUNT, sizeof(refCount), &refCount, &sizeReturned);
    ASSERT_EQ(CL_SUCCESS, result);
    EXPECT_EQ(sizeof(refCount), sizeReturned);

    EXPECT_EQ(2u, refCount);
    event.release();
}

TEST_F(EventTest, GetEventInfo_CL_EVENT_REFERENCE_COUNT_Retain_Release_Event) {
    uint32_t tagEvent = 5;

    Event *pEvent = new Event(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, 3, tagEvent);
    ASSERT_NE(nullptr, pEvent);

    pEvent->retain();
    auto retVal = pEvent->getReference();
    EXPECT_EQ(2, retVal);

    cl_uint refCount = 0;
    size_t sizeReturned = 0;
    auto result = clGetEventInfo(pEvent, CL_EVENT_REFERENCE_COUNT, sizeof(refCount), &refCount, &sizeReturned);
    ASSERT_EQ(CL_SUCCESS, result);
    EXPECT_EQ(sizeof(refCount), sizeReturned);
    EXPECT_EQ(2u, refCount);

    pEvent->release();
    retVal = pEvent->getReference();
    EXPECT_EQ(1, retVal);

    delete pEvent;
}

TEST_F(EventTest, GetEventInfo_CL_EVENT_CONTEXT) {
    uint32_t tagEvent = 5;

    Event *pEvent = new Event(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, 3, tagEvent);
    ASSERT_NE(nullptr, pEvent);

    cl_context context;
    size_t sizeReturned = 0;
    auto result = clGetEventInfo(pEvent, CL_EVENT_CONTEXT, sizeof(context), &context, &sizeReturned);
    ASSERT_EQ(CL_SUCCESS, result);
    EXPECT_EQ(sizeof(context), sizeReturned);

    cl_context qCtx = (cl_context)&mockContext;
    EXPECT_EQ(qCtx, context);

    delete pEvent;
}

TEST_F(EventTest, GetEventInfo_InvalidParam) {
    uint32_t tagEvent = 5;

    Event event(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, 3, tagEvent);
    cl_int eventStatus = -1;

    auto result = clGetEventInfo(&event, -1, sizeof(eventStatus), &eventStatus, nullptr);
    EXPECT_EQ(CL_INVALID_VALUE, result);
}

TEST_F(EventTest, Event_Wait_NonBlocking) {
    Event event(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, 3, Event::eventNotReady);
    auto result = event.wait(false, false);
    EXPECT_FALSE(result);
}

struct UpdateEventTest : public ::testing::Test {

    void SetUp() override {
        executionEnvironment = platformImpl->peekExecutionEnvironment();
        memoryManager = new MockMemoryManager(*executionEnvironment);
        hostPtrManager = static_cast<MockHostPtrManager *>(memoryManager->getHostPtrManager());
        executionEnvironment->memoryManager.reset(memoryManager);
        device.reset(Device::create<Device>(executionEnvironment, 0u));
        context = std::make_unique<MockContext>(device.get());
        cl_int retVal = CL_OUT_OF_RESOURCES;
        commandQueue.reset(CommandQueue::create(context.get(), device.get(), nullptr, retVal));
        EXPECT_EQ(CL_SUCCESS, retVal);
    }

    ExecutionEnvironment *executionEnvironment;
    MockMemoryManager *memoryManager;
    MockHostPtrManager *hostPtrManager;
    std::unique_ptr<Device> device;
    std::unique_ptr<Context> context;
    std::unique_ptr<CommandQueue> commandQueue;
};

TEST_F(UpdateEventTest, givenEventContainingCommandQueueWhenItsStatusIsUpdatedToCompletedThenTemporaryAllocationsAreDeleted) {
    void *ptr = (void *)0x1000;
    size_t size = 4096;
    auto temporary = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{false, size}, ptr);
    temporary->updateTaskCount(3, commandQueue->getCommandStreamReceiver().getOsContext().getContextId());
    commandQueue->getCommandStreamReceiver().getInternalAllocationStorage()->storeAllocation(std::unique_ptr<GraphicsAllocation>(temporary), TEMPORARY_ALLOCATION);
    Event event(commandQueue.get(), CL_COMMAND_NDRANGE_KERNEL, 3, 3);

    EXPECT_EQ(1u, hostPtrManager->getFragmentCount());

    event.updateExecutionStatus();

    EXPECT_EQ(0u, hostPtrManager->getFragmentCount());
}

class SurfaceMock : public Surface {
  public:
    SurfaceMock() {
        resident = nonResident = 0;
    };
    ~SurfaceMock() override{};

    void makeResident(CommandStreamReceiver &csr) override {
        if (parent) {
            parent->resident++;
        } else {
            resident++;
        }
        if (this->graphicsAllocation) {
            csr.makeResident(*graphicsAllocation);
        }
    };
    Surface *duplicate() override {
        return new SurfaceMock(this);
    };

    SurfaceMock *parent = nullptr;
    std::atomic<uint32_t> resident;
    std::atomic<uint32_t> nonResident;

    GraphicsAllocation *graphicsAllocation = nullptr;

  protected:
    SurfaceMock(SurfaceMock *parent) : parent(parent){};
};

TEST_F(InternalsEventTest, processBlockedCommandsKernelOperation) {
    CommandQueue cmdQ(mockContext, pDevice, nullptr);
    MockEvent<Event> event(&cmdQ, CL_COMMAND_NDRANGE_KERNEL, 0, 0);

    auto cmdStream = new LinearStream(pDevice->getMemoryManager()->allocateGraphicsMemoryWithProperties({4096, GraphicsAllocation::AllocationType::COMMAND_BUFFER}));
    IndirectHeap *dsh = nullptr, *ioh = nullptr, *ssh = nullptr;
    cmdQ.allocateHeapMemory(IndirectHeap::DYNAMIC_STATE, 4096u, dsh);
    cmdQ.allocateHeapMemory(IndirectHeap::INDIRECT_OBJECT, 4096u, ioh);
    cmdQ.allocateHeapMemory(IndirectHeap::SURFACE_STATE, 4096u, ssh);
    using UniqueIH = std::unique_ptr<IndirectHeap>;
    auto blockedCommandsData = new KernelOperation(std::unique_ptr<LinearStream>(cmdStream), UniqueIH(dsh),
                                                   UniqueIH(ioh), UniqueIH(ssh),
                                                   *cmdQ.getCommandStreamReceiver().getInternalAllocationStorage());

    MockKernelWithInternals mockKernelWithInternals(*pDevice);
    auto pKernel = mockKernelWithInternals.mockKernel;

    auto &csr = cmdQ.getCommandStreamReceiver();
    std::vector<Surface *> v;
    SurfaceMock *surface = new SurfaceMock;
    surface->graphicsAllocation = new MockGraphicsAllocation((void *)0x1234, 100u);
    PreemptionMode preemptionMode = pDevice->getPreemptionMode();
    v.push_back(surface);
    auto cmd = new CommandComputeKernel(cmdQ, std::unique_ptr<KernelOperation>(blockedCommandsData), v, false, false, false, nullptr, preemptionMode, pKernel, 1);
    event.setCommand(std::unique_ptr<Command>(cmd));

    auto taskLevelBefore = csr.peekTaskLevel();

    event.submitCommand(false);

    auto taskLevelAfter = csr.peekTaskLevel();

    EXPECT_EQ(taskLevelBefore + 1, taskLevelAfter);

    EXPECT_EQ(surface->resident, 1u);
    EXPECT_FALSE(surface->graphicsAllocation->isResident(csr.getOsContext().getContextId()));
    delete surface->graphicsAllocation;
}

TEST_F(InternalsEventTest, processBlockedCommandsAbortKernelOperation) {
    CommandQueue cmdQ(mockContext, pDevice, nullptr);
    MockEvent<Event> event(&cmdQ, CL_COMMAND_NDRANGE_KERNEL, 0, 0);

    auto cmdStream = new LinearStream(pDevice->getMemoryManager()->allocateGraphicsMemoryWithProperties({4096, GraphicsAllocation::AllocationType::COMMAND_BUFFER}));
    IndirectHeap *dsh = nullptr, *ioh = nullptr, *ssh = nullptr;
    cmdQ.allocateHeapMemory(IndirectHeap::DYNAMIC_STATE, 4096u, dsh);
    cmdQ.allocateHeapMemory(IndirectHeap::INDIRECT_OBJECT, 4096u, ioh);
    cmdQ.allocateHeapMemory(IndirectHeap::SURFACE_STATE, 4096u, ssh);
    using UniqueIH = std::unique_ptr<IndirectHeap>;
    auto blockedCommandsData = new KernelOperation(std::unique_ptr<LinearStream>(cmdStream), UniqueIH(dsh),
                                                   UniqueIH(ioh), UniqueIH(ssh),
                                                   *cmdQ.getCommandStreamReceiver().getInternalAllocationStorage());

    MockKernelWithInternals mockKernelWithInternals(*pDevice);
    auto pKernel = mockKernelWithInternals.mockKernel;

    auto &csr = cmdQ.getCommandStreamReceiver();
    std::vector<Surface *> v;
    NullSurface *surface = new NullSurface;
    v.push_back(surface);
    PreemptionMode preemptionMode = pDevice->getPreemptionMode();
    auto cmd = new CommandComputeKernel(cmdQ, std::unique_ptr<KernelOperation>(blockedCommandsData), v, false, false, false, nullptr, preemptionMode, pKernel, 1);
    event.setCommand(std::unique_ptr<Command>(cmd));

    auto taskLevelBefore = csr.peekTaskLevel();

    event.submitCommand(true);

    auto taskLevelAfter = csr.peekTaskLevel();

    EXPECT_EQ(taskLevelBefore, taskLevelAfter);
}

TEST_F(InternalsEventTest, givenBlockedKernelWithPrintfWhenSubmittedThenPrintOutput) {
    testing::internal::CaptureStdout();
    CommandQueue cmdQ(mockContext, pDevice, nullptr);
    MockEvent<Event> event(&cmdQ, CL_COMMAND_NDRANGE_KERNEL, 0, 0);

    auto cmdStream = new LinearStream(pDevice->getMemoryManager()->allocateGraphicsMemoryWithProperties({4096, GraphicsAllocation::AllocationType::COMMAND_BUFFER}));
    IndirectHeap *dsh = nullptr, *ioh = nullptr, *ssh = nullptr;
    cmdQ.allocateHeapMemory(IndirectHeap::DYNAMIC_STATE, 4096u, dsh);
    cmdQ.allocateHeapMemory(IndirectHeap::INDIRECT_OBJECT, 4096u, ioh);
    cmdQ.allocateHeapMemory(IndirectHeap::SURFACE_STATE, 4096u, ssh);
    using UniqueIH = std::unique_ptr<IndirectHeap>;
    auto blockedCommandsData = new KernelOperation(std::unique_ptr<LinearStream>(cmdStream), UniqueIH(dsh),
                                                   UniqueIH(ioh), UniqueIH(ssh),
                                                   *cmdQ.getCommandStreamReceiver().getInternalAllocationStorage());

    SPatchAllocateStatelessPrintfSurface *pPrintfSurface = new SPatchAllocateStatelessPrintfSurface();
    pPrintfSurface->DataParamOffset = 0;
    pPrintfSurface->DataParamSize = 8;

    char *testString = new char[sizeof(""test"")];

    strcpy_s(testString, sizeof(""test""), ""test"");

    PrintfStringInfo printfStringInfo;
    printfStringInfo.SizeInBytes = sizeof(""test"");
    printfStringInfo.pStringData = testString;

    MockKernelWithInternals mockKernelWithInternals(*pDevice);
    auto pKernel = mockKernelWithInternals.mockKernel;
    KernelInfo *kernelInfo = const_cast<KernelInfo *>(&pKernel->getKernelInfo());
    kernelInfo->patchInfo.pAllocateStatelessPrintfSurface = pPrintfSurface;
    kernelInfo->patchInfo.stringDataMap.insert(std::make_pair(0, printfStringInfo));
    uint64_t crossThread[10];
    pKernel->setCrossThreadData(&crossThread, sizeof(uint64_t) * 8);

    MockMultiDispatchInfo multiDispatchInfo(pKernel);
    std::unique_ptr<PrintfHandler> printfHandler(PrintfHandler::create(multiDispatchInfo, *pDevice));
    printfHandler.get()->prepareDispatch(multiDispatchInfo);
    auto surface = printfHandler.get()->getSurface();

    auto printfSurface = reinterpret_cast<uint32_t *>(surface->getUnderlyingBuffer());
    printfSurface[0] = 8;
    printfSurface[1] = 0;

    std::vector<Surface *> v;
    PreemptionMode preemptionMode = pDevice->getPreemptionMode();
    auto cmd = new CommandComputeKernel(cmdQ, std::unique_ptr<KernelOperation>(blockedCommandsData), v, false, false, false, std::move(printfHandler), preemptionMode, pKernel, 1);
    event.setCommand(std::unique_ptr<Command>(cmd));

    event.submitCommand(false);

    std::string output = testing::internal::GetCapturedStdout();
    EXPECT_STREQ(""test"", output.c_str());
    EXPECT_FALSE(surface->isResident(pDevice->getDefaultEngine().osContext->getContextId()));

    delete pPrintfSurface;
}

TEST_F(InternalsEventTest, processBlockedCommandsMapOperation) {
    MockEvent<Event> event(nullptr, CL_COMMAND_NDRANGE_KERNEL, 0, 0);
    CommandQueue *pCmdQ = new CommandQueue(mockContext, pDevice, 0);

    auto &csr = pCmdQ->getCommandStreamReceiver();
    auto buffer = new MockBuffer;

    MemObjSizeArray size = {{1, 1, 1}};
    MemObjOffsetArray offset = {{0, 0, 0}};
    event.setCommand(std::unique_ptr<Command>(new CommandMapUnmap(MAP, *buffer, size, offset, false, csr, *pCmdQ)));

    auto taskLevelBefore = csr.peekTaskLevel();

    event.submitCommand(false);

    auto taskLevelAfter = csr.peekTaskLevel();

    EXPECT_EQ(taskLevelBefore + 1, taskLevelAfter);
    buffer->decRefInternal();
    delete pCmdQ;
}

TEST_F(InternalsEventTest, processBlockedCommandsMapOperationNonZeroCopyBuffer) {
    MockEvent<Event> event(nullptr, CL_COMMAND_NDRANGE_KERNEL, 0, 0);
    CommandQueue *pCmdQ = new CommandQueue(mockContext, pDevice, 0);

    auto &csr = pCmdQ->getCommandStreamReceiver();
    auto buffer = new UnalignedBuffer;

    MemObjSizeArray size = {{1, 1, 1}};
    MemObjOffsetArray offset = {{0, 0, 0}};
    event.setCommand(std::unique_ptr<Command>(new CommandMapUnmap(MAP, *buffer, size, offset, false, csr, *pCmdQ)));

    auto taskLevelBefore = csr.peekTaskLevel();

    event.submitCommand(false);

    auto taskLevelAfter = csr.peekTaskLevel();

    EXPECT_EQ(taskLevelBefore + 1, taskLevelAfter);
    buffer->decRefInternal();
    delete pCmdQ;
}

uint32_t commands[] = {
    CL_COMMAND_NDRANGE_KERNEL,
    CL_COMMAND_TASK,
    CL_COMMAND_NATIVE_KERNEL,
    CL_COMMAND_READ_BUFFER,
    CL_COMMAND_WRITE_BUFFER,
    CL_COMMAND_COPY_BUFFER,
    CL_COMMAND_READ_IMAGE,
    CL_COMMAND_WRITE_IMAGE,
    CL_COMMAND_COPY_IMAGE,
    CL_COMMAND_COPY_IMAGE_TO_BUFFER,
    CL_COMMAND_COPY_BUFFER_TO_IMAGE,
    CL_COMMAND_MAP_BUFFER,
    CL_COMMAND_MAP_IMAGE,
    CL_COMMAND_UNMAP_MEM_OBJECT,
    CL_COMMAND_MARKER,
    CL_COMMAND_ACQUIRE_GL_OBJECTS,
    CL_COMMAND_RELEASE_GL_OBJECTS,
    CL_COMMAND_READ_BUFFER_RECT,
    CL_COMMAND_WRITE_BUFFER_RECT,
    CL_COMMAND_COPY_BUFFER_RECT,
    CL_COMMAND_BARRIER,
    CL_COMMAND_MIGRATE_MEM_OBJECTS,
    CL_COMMAND_FILL_BUFFER,
    CL_COMMAND_FILL_IMAGE,
    CL_COMMAND_SVM_FREE,
    CL_COMMAND_SVM_MEMCPY,
    CL_COMMAND_SVM_MEMFILL,
    CL_COMMAND_SVM_MAP,
    CL_COMMAND_SVM_UNMAP,
};

class InternalsEventProfilingTest : public InternalsEventTest,
                                    public ::testing::WithParamInterface<uint32_t> {
    void SetUp() override {
        InternalsEventTest::SetUp();
    }

    void TearDown() override {
        InternalsEventTest::TearDown();
    }
};

TEST_P(InternalsEventProfilingTest, GivenProfilingWhenEventCreatedThenProfilingSet) {
    const cl_queue_properties props[3] = {CL_QUEUE_PROPERTIES, CL_QUEUE_PROFILING_ENABLE, 0};
    std::unique_ptr<CommandQueue> pCmdQ(new CommandQueue(mockContext, pDevice, props));

    std::unique_ptr<MockEvent<Event>> event(new MockEvent<Event>(pCmdQ.get(), GetParam(), 0, 0));
    EXPECT_TRUE(event.get()->isProfilingEnabled());
}

INSTANTIATE_TEST_CASE_P(InternalsEventProfilingTest,
                        InternalsEventProfilingTest,
                        ::testing::ValuesIn(commands));

TEST_F(InternalsEventTest, GivenProfilingWhenUserEventCreatedThenProfilingNotSet) {
    const cl_queue_properties props[3] = {CL_QUEUE_PROPERTIES, CL_QUEUE_PROFILING_ENABLE, 0};
    std::unique_ptr<CommandQueue> pCmdQ(new CommandQueue(mockContext, pDevice, props));

    std::unique_ptr<MockEvent<Event>> event(new MockEvent<Event>(pCmdQ.get(), CL_COMMAND_USER, 0, 0));
    EXPECT_FALSE(event.get()->isProfilingEnabled());
}

TEST_F(InternalsEventTest, GIVENProfilingWHENMapOperationTHENTimesSet) {
    const cl_queue_properties props[3] = {CL_QUEUE_PROPERTIES, CL_QUEUE_PROFILING_ENABLE, 0};
    CommandQueue *pCmdQ = new CommandQueue(mockContext, pDevice, props);

    MockEvent<Event> *event = new MockEvent<Event>(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, 0, 0);

    auto &csr = pCmdQ->getCommandStreamReceiver();
    UnalignedBuffer buffer;

    MemObjSizeArray size = {{1, 1, 1}};
    MemObjOffsetArray offset = {{0, 0, 0}};
    event->setCommand(std::unique_ptr<Command>(new CommandMapUnmap(MAP, buffer, size, offset, false, csr, *pCmdQ)));

    auto taskLevelBefore = csr.peekTaskLevel();

    event->submitCommand(false);
    uint64_t submitTime = 0ULL;
    event->getEventProfilingInfo(CL_PROFILING_COMMAND_SUBMIT, sizeof(uint64_t), &submitTime, 0);
    EXPECT_NE(0ULL, submitTime);
    auto taskLevelAfter = csr.peekTaskLevel();

    delete event;

    EXPECT_EQ(taskLevelBefore + 1, taskLevelAfter);
    delete pCmdQ;
}

TEST_F(InternalsEventTest, processBlockedCommandsUnMapOperation) {
    MockEvent<Event> event(nullptr, CL_COMMAND_NDRANGE_KERNEL, 0, 0);
    const cl_queue_properties props[3] = {CL_QUEUE_PROPERTIES, 0, 0};
    CommandQueue *pCmdQ = new CommandQueue(mockContext, pDevice, props);

    auto &csr = pCmdQ->getCommandStreamReceiver();
    auto buffer = new UnalignedBuffer;

    MemObjSizeArray size = {{1, 1, 1}};
    MemObjOffsetArray offset = {{0, 0, 0}};
    event.setCommand(std::unique_ptr<Command>(new CommandMapUnmap(UNMAP, *buffer, size, offset, false, csr, *pCmdQ)));

    auto taskLevelBefore = csr.peekTaskLevel();

    event.submitCommand(false);

    auto taskLevelAfter = csr.peekTaskLevel();

    EXPECT_EQ(taskLevelBefore + 1, taskLevelAfter);
    buffer->decRefInternal();
    delete pCmdQ;
}

TEST_F(InternalsEventTest, processBlockedCommandsUnMapOperationNonZeroCopyBuffer) {
    MockEvent<Event> event(nullptr, CL_COMMAND_NDRANGE_KERNEL, 0, 0);
    const cl_queue_properties props[3] = {CL_QUEUE_PROPERTIES, 0, 0};
    CommandQueue *pCmdQ = new CommandQueue(mockContext, pDevice, props);

    auto &csr = pCmdQ->getCommandStreamReceiver();
    auto buffer = new UnalignedBuffer;

    MemObjSizeArray size = {{1, 1, 1}};
    MemObjOffsetArray offset = {{0, 0, 0}};
    event.setCommand(std::unique_ptr<Command>(new CommandMapUnmap(UNMAP, *buffer, size, offset, false, csr, *pCmdQ)));

    auto taskLevelBefore = csr.peekTaskLevel();

    event.submitCommand(false);

    auto taskLevelAfter = csr.peekTaskLevel();

    EXPECT_EQ(taskLevelBefore + 1, taskLevelAfter);
    buffer->decRefInternal();
    delete pCmdQ;
}

HWTEST_F(InternalsEventTest, givenCpuProfilingPathWhenEnqueuedMarkerThenDontUseTimeStampNode) {
    const cl_queue_properties props[3] = {CL_QUEUE_PROPERTIES, CL_QUEUE_PROFILING_ENABLE, 0};
    CommandQueue *pCmdQ = new CommandQueue(mockContext, pDevice, props);
    MockEvent<Event> *event = new MockEvent<Event>(pCmdQ, CL_COMMAND_MARKER, 0, 0);
    event->setCPUProfilingPath(true);

    auto &csr = pCmdQ->getCommandStreamReceiver();

    event->setCommand(std::unique_ptr<Command>(new CommandMarker(*pCmdQ, csr, CL_COMMAND_MARKER, 4096u)));

    event->submitCommand(false);

    uint64_t submit, start, end;
    event->getEventProfilingInfo(CL_PROFILING_COMMAND_SUBMIT, sizeof(uint64_t), &submit, 0);
    event->getEventProfilingInfo(CL_PROFILING_COMMAND_START, sizeof(uint64_t), &start, 0);
    event->getEventProfilingInfo(CL_PROFILING_COMMAND_END, sizeof(uint64_t), &end, 0);

    EXPECT_LT(0u, submit);
    EXPECT_LT(submit, start);
    EXPECT_LT(start, end);
    delete event;
    delete pCmdQ;
}

struct InternalsEventWithPerfCountersTest
    : public InternalsEventTest,
      public PerformanceCountersFixture {
    void SetUp() override {
        PerformanceCountersFixture::SetUp();
        InternalsEventTest::SetUp();
        createPerfCounters();
        performanceCountersBase->initialize(platformDevices[0]);
        pDevice->setPerfCounters(performanceCountersBase.get());
    }

    void TearDown() override {
        performanceCountersBase.release();
        InternalsEventTest::TearDown();
        PerformanceCountersFixture::TearDown();
    }
};
HWTEST_F(InternalsEventWithPerfCountersTest, givenCpuProfilingPerfCountersPathWhenEnqueuedMarkerThenDontUseTimeStampNodePerfCounterNode) {
    const cl_queue_properties props[3] = {CL_QUEUE_PROPERTIES, CL_QUEUE_PROFILING_ENABLE, 0};
    CommandQueue *pCmdQ = new CommandQueue(mockContext, pDevice, props);
    bool ret = false;
    ret = pCmdQ->setPerfCountersEnabled(true, 1);
    EXPECT_TRUE(ret);
    ret = pCmdQ->setPerfCountersEnabled(true, 1);
    EXPECT_TRUE(ret);
    MockEvent<Event> *event = new MockEvent<Event>(pCmdQ, CL_COMMAND_MARKER, 0, 0);
    event->setCPUProfilingPath(true);

    auto &csr = pCmdQ->getCommandStreamReceiver();

    event->setCommand(std::unique_ptr<Command>(new CommandMarker(*pCmdQ, csr, CL_COMMAND_MARKER, 4096u)));

    event->submitCommand(false);

    uint64_t submit, start, end;
    event->getEventProfilingInfo(CL_PROFILING_COMMAND_SUBMIT, sizeof(uint64_t), &submit, 0);
    event->getEventProfilingInfo(CL_PROFILING_COMMAND_START, sizeof(uint64_t), &start, 0);
    event->getEventProfilingInfo(CL_PROFILING_COMMAND_END, sizeof(uint64_t), &end, 0);

    EXPECT_LT(0u, submit);
    EXPECT_LT(submit, start);
    EXPECT_LT(start, end);
    delete event;
    delete pCmdQ;
}

HWTEST_F(InternalsEventWithPerfCountersTest, givenCpuProfilingPerfCountersPathWhenEnqueuedMarkerThenUseTimeStampNodePerfCounterNode) {
    const cl_queue_properties props[3] = {CL_QUEUE_PROPERTIES, CL_QUEUE_PROFILING_ENABLE, 0};
    CommandQueue *pCmdQ = new CommandQueue(mockContext, pDevice, props);
    pCmdQ->setPerfCountersEnabled(true, 1);
    MockEvent<Event> *event = new MockEvent<Event>(pCmdQ, CL_COMMAND_MARKER, 0, 0);
    event->setCPUProfilingPath(true);
    HwPerfCounter *perfCounter = event->getHwPerfCounterNode()->tagForCpuAccess;
    ASSERT_NE(nullptr, perfCounter);
    HwTimeStamps *timeStamps = event->getHwTimeStampNode()->tagForCpuAccess;
    ASSERT_NE(nullptr, timeStamps);
    auto &csr = pCmdQ->getCommandStreamReceiver();

    event->setCommand(std::unique_ptr<Command>(new CommandMarker(*pCmdQ, csr, CL_COMMAND_MARKER, 4096u)));

    event->submitCommand(false);

    uint64_t submit, start, end;
    event->getEventProfilingInfo(CL_PROFILING_COMMAND_SUBMIT, sizeof(uint64_t), &submit, 0);
    event->getEventProfilingInfo(CL_PROFILING_COMMAND_START, sizeof(uint64_t), &start, 0);
    event->getEventProfilingInfo(CL_PROFILING_COMMAND_END, sizeof(uint64_t), &end, 0);

    EXPECT_LT(0u, submit);
    EXPECT_LT(submit, start);
    EXPECT_LT(start, end);
    delete event;
    delete pCmdQ;
}

TEST_F(InternalsEventWithPerfCountersTest, IsPerfCounter_Enabled) {
    const cl_queue_properties props[3] = {CL_QUEUE_PROPERTIES, CL_QUEUE_PROFILING_ENABLE, 0};
    CommandQueue *pCmdQ = new CommandQueue(mockContext, pDevice, props);
    pCmdQ->setPerfCountersEnabled(true, 2);
    Event *ev = new Event(pCmdQ, CL_COMMAND_COPY_BUFFER, 3, 0);
    EXPECT_TRUE(ev->isProfilingEnabled());
    EXPECT_TRUE(ev->isPerfCountersEnabled());
    delete ev;
    delete pCmdQ;
}

TEST(Event, GivenNoContextOnDeletionDeletesSelf) {
    UserEvent *ue = new UserEvent();
    auto autoptr = ue->release();
    ASSERT_TRUE(autoptr.isUnused());
}

HWTEST_F(EventTest, givenVirtualEventWhenCommandSubmittedThenLockCSROccurs) {
    using UniqueIH = std::unique_ptr<IndirectHeap>;
    class MockCommandComputeKernel : public CommandComputeKernel {
      public:
        using CommandComputeKernel::eventsWaitlist;
        MockCommandComputeKernel(CommandQueue &commandQueue, KernelOperation *kernelResources, std::vector<Surface *> &surfaces, Kernel *kernel)
            : CommandComputeKernel(commandQueue, std::unique_ptr<KernelOperation>(kernelResources), surfaces, false, false, false, nullptr, PreemptionMode::Disabled, kernel, 0) {}
    };
    class MockEvent : public Event {
      public:
        using Event::submitCommand;
        MockEvent(CommandQueue *cmdQueue, cl_command_type cmdType,
                  uint32_t taskLevel, uint32_t taskCount) : Event(cmdQueue, cmdType,
                                                                  taskLevel, taskCount) {}
    };

    MockKernelWithInternals kernel(*pDevice);

    IndirectHeap *ih1 = nullptr, *ih2 = nullptr, *ih3 = nullptr;
    pCmdQ->allocateHeapMemory(IndirectHeap::DYNAMIC_STATE, 1, ih1);
    pCmdQ->allocateHeapMemory(IndirectHeap::INDIRECT_OBJECT, 1, ih2);
    pCmdQ->allocateHeapMemory(IndirectHeap::SURFACE_STATE, 1, ih3);
    auto cmdStream = new LinearStream(pDevice->getMemoryManager()->allocateGraphicsMemoryWithProperties({4096, GraphicsAllocation::AllocationType::COMMAND_BUFFER}));

    std::vector<Surface *> surfaces;
    auto kernelOperation = new KernelOperation(std::unique_ptr<LinearStream>(cmdStream), UniqueIH(ih1), UniqueIH(ih2), UniqueIH(ih3),
                                               *pDevice->getDefaultEngine().commandStreamReceiver->getInternalAllocationStorage());

    std::unique_ptr<MockCommandComputeKernel> command = std::make_unique<MockCommandComputeKernel>(*pCmdQ, kernelOperation, surfaces, kernel);

    auto virtualEvent = make_releaseable<MockEvent>(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, Event::eventNotReady, Event::eventNotReady);

    virtualEvent->setCommand(std::move(command));

    virtualEvent->submitCommand(false);

    EXPECT_EQ(pDevice->getUltCommandStreamReceiver<FamilyType>().recursiveLockCounter, 2u);
}

HWTEST_F(EventTest, givenVirtualEventWhenSubmitCommandEventNotReadyAndEventWithoutCommandThenOneLockCSRNeeded) {
    class MockEvent : public Event {
      public:
        using Event::submitCommand;
        MockEvent(CommandQueue *cmdQueue, cl_command_type cmdType,
                  uint32_t taskLevel, uint32_t taskCount) : Event(cmdQueue, cmdType,
                                                                  taskLevel, taskCount) {}
    };

    auto virtualEvent = make_releaseable<MockEvent>(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, Event::eventNotReady, Event::eventNotReady);

    virtualEvent->submitCommand(false);

    EXPECT_EQ(pDevice->getUltCommandStreamReceiver<FamilyType>().recursiveLockCounter, 1u);
}

HWTEST_F(InternalsEventTest, GivenBufferWithoutZeroCopyOnCommandMapOrUnmapFlushesPreviousTasksBeforeMappingOrUnmapping) {
    struct MockNonZeroCopyBuff : UnalignedBuffer {
        MockNonZeroCopyBuff(int32_t &executionStamp)
            : executionStamp(executionStamp), dataTransferedStamp(-1) {
            hostPtr = &dataTransferedStamp;
            memoryStorage = &executionStamp;
            size = sizeof(executionStamp);
            hostPtrMinSize = size;
        }
        void setIsZeroCopy() {
            isZeroCopy = false;
        }

        void swapCopyDirection() {
            std::swap(hostPtr, memoryStorage);
        }

        int32_t &executionStamp;
        int32_t dataTransferedStamp;
    };

    int32_t executionStamp = 0;
    const cl_queue_properties props[3] = {CL_QUEUE_PROPERTIES, 0, 0};
    CommandQueue *pCmdQ = new CommandQueue(mockContext, pDevice, props);
    MockNonZeroCopyBuff buffer(executionStamp);
    MockCsr<FamilyType> csr(executionStamp, *pDevice->executionEnvironment);
    csr.setTagAllocation(pDevice->getDefaultEngine().commandStreamReceiver->getTagAllocation());
    csr.setupContext(*pDevice->getDefaultEngine().osContext);

    MemObjSizeArray size = {{4, 1, 1}};
    MemObjOffsetArray offset = {{0, 0, 0}};
    auto commandMap = std::unique_ptr<Command>(new CommandMapUnmap(MAP, buffer, size, offset, false, csr, *pCmdQ));
    EXPECT_EQ(0, executionStamp);
    EXPECT_EQ(-1, csr.flushTaskStamp);
    EXPECT_EQ(-1, buffer.dataTransferedStamp);

    auto latestSentFlushTaskCount = csr.peekLatestSentTaskCount();

    commandMap->submit(0, false);
    EXPECT_EQ(1, executionStamp);
    EXPECT_EQ(0, csr.flushTaskStamp);
    EXPECT_EQ(1, buffer.dataTransferedStamp);
    auto latestSentFlushTaskCountAfterSubmit = csr.peekLatestSentTaskCount();
    EXPECT_GT(latestSentFlushTaskCountAfterSubmit, latestSentFlushTaskCount);

    executionStamp = 0;
    csr.flushTaskStamp = -1;
    buffer.dataTransferedStamp = -1;
    buffer.swapCopyDirection();

    auto commandUnMap = std::unique_ptr<Command>(new CommandMapUnmap(UNMAP, buffer, size, offset, false, csr, *pCmdQ));
    EXPECT_EQ(0, executionStamp);
    EXPECT_EQ(-1, csr.flushTaskStamp);
    EXPECT_EQ(-1, buffer.dataTransferedStamp);
    commandUnMap->submit(0, false);
    EXPECT_EQ(1, executionStamp);
    EXPECT_EQ(0, csr.flushTaskStamp);
    EXPECT_EQ(1, buffer.dataTransferedStamp);
    EXPECT_EQ(nullptr, commandUnMap->getCommandStream());

    pCmdQ->getCommandStreamReceiver().setTagAllocation(nullptr);
    delete pCmdQ;
}

TEST(EventCallback, CallbackAfterStatusOverrideUsesNewStatus) {
    struct ClbFuncTempStruct {
        static void CL_CALLBACK ClbFuncT(cl_event e, cl_int status, void *retStatus) {
            *((cl_int *)retStatus) = status;
        }
    };

    cl_int retStatus = 7;
    Event::Callback clb(nullptr, ClbFuncTempStruct::ClbFuncT, CL_COMPLETE, &retStatus);
    EXPECT_EQ(CL_COMPLETE, clb.getCallbackExecutionStatusTarget());
    clb.execute();
    EXPECT_EQ(CL_COMPLETE, retStatus);

    retStatus = 7;
    clb.overrideCallbackExecutionStatusTarget(-1);
    EXPECT_EQ(-1, clb.getCallbackExecutionStatusTarget());
    clb.execute();
    EXPECT_EQ(-1, retStatus);
}

TEST_F(EventTest, WhensetTimeStampThenCorrectValues) {
    MyEvent ev(this->pCmdQ, CL_COMMAND_COPY_BUFFER, 3, 0);
    TimeStampData inTimeStamp = {1ULL, 2ULL};
    ev.setSubmitTimeStamp(&inTimeStamp);
    TimeStampData outtimeStamp = {0, 0};
    outtimeStamp = ev.getSubmitTimeStamp();
    EXPECT_EQ(1ULL, outtimeStamp.GPUTimeStamp);
    EXPECT_EQ(2ULL, outtimeStamp.CPUTimeinNS);
    inTimeStamp.GPUTimeStamp = 3;
    inTimeStamp.CPUTimeinNS = 4;
    ev.setQueueTimeStamp(&inTimeStamp);
    outtimeStamp = ev.getQueueTimeStamp();
    EXPECT_EQ(3ULL, outtimeStamp.GPUTimeStamp);
    EXPECT_EQ(4ULL, outtimeStamp.CPUTimeinNS);
}

TEST_F(EventTest, WhensetCPUTimeStampThenCorrectTimes) {
    MyEvent ev(this->pCmdQ, CL_COMMAND_COPY_BUFFER, 3, 0);

    ev.setProfilingEnabled(true);
    ev.setQueueTimeStamp();
    TimeStampData outtimeStamp = {0, 0};
    outtimeStamp = ev.getQueueTimeStamp();
    EXPECT_NE(0ULL, outtimeStamp.CPUTimeinNS);
    EXPECT_EQ(0ULL, outtimeStamp.GPUTimeStamp);

    ev.setSubmitTimeStamp();
    outtimeStamp = ev.getSubmitTimeStamp();
    EXPECT_NE(0ULL, outtimeStamp.CPUTimeinNS);
    EXPECT_EQ(0ULL, outtimeStamp.GPUTimeStamp);

    ev.setStartTimeStamp();
    uint64_t outCPUtimeStamp = ev.getStartTimeStamp();
    EXPECT_NE(0ULL, outCPUtimeStamp);

    ev.setEndTimeStamp();
    outCPUtimeStamp = ev.getEndTimeStamp();
    EXPECT_NE(0ULL, outCPUtimeStamp);

    outCPUtimeStamp = ev.getCompleteTimeStamp();
    EXPECT_NE(0ULL, outCPUtimeStamp);
}

TEST_F(EventTest, GIVENNoQueueWhensetCPUTimeStampThenTimesNotSet) {
    MyEvent ev(nullptr, CL_COMMAND_COPY_BUFFER, 3, 0);

    ev.setQueueTimeStamp();
    TimeStampData outtimeStamp = {0, 0};
    outtimeStamp = ev.getQueueTimeStamp();
    EXPECT_EQ(0ULL, outtimeStamp.CPUTimeinNS);
    EXPECT_EQ(0ULL, outtimeStamp.GPUTimeStamp);

    ev.setSubmitTimeStamp();
    outtimeStamp = ev.getSubmitTimeStamp();
    EXPECT_EQ(0ULL, outtimeStamp.CPUTimeinNS);
    EXPECT_EQ(0ULL, outtimeStamp.GPUTimeStamp);

    ev.setStartTimeStamp();
    uint64_t outCPUtimeStamp = ev.getStartTimeStamp();
    EXPECT_EQ(0ULL, outCPUtimeStamp);

    ev.setEndTimeStamp();
    outCPUtimeStamp = ev.getEndTimeStamp();
    EXPECT_EQ(0ULL, outCPUtimeStamp);

    outCPUtimeStamp = ev.getCompleteTimeStamp();
    EXPECT_EQ(0ULL, outCPUtimeStamp);
}

TEST_F(EventTest, getHwTimeStampsReturnsValidPointer) {
    std::unique_ptr<Event> event(new Event(this->pCmdQ, CL_COMMAND_COPY_BUFFER, 0, 0));
    ASSERT_NE(nullptr, event);

    HwTimeStamps *timeStamps = event->getHwTimeStampNode()->tagForCpuAccess;
    ASSERT_NE(nullptr, timeStamps);

    //this should not cause any heap corruptions
    ASSERT_EQ(0ULL, timeStamps->GlobalStartTS);
    ASSERT_EQ(0ULL, timeStamps->ContextStartTS);
    ASSERT_EQ(0ULL, timeStamps->GlobalEndTS);
    ASSERT_EQ(0ULL, timeStamps->ContextEndTS);
    ASSERT_EQ(0ULL, timeStamps->GlobalCompleteTS);
    ASSERT_EQ(0ULL, timeStamps->ContextCompleteTS);

    EXPECT_TRUE(timeStamps->canBeReleased());

    HwTimeStamps *timeStamps2 = event->getHwTimeStampNode()->tagForCpuAccess;
    ASSERT_EQ(timeStamps, timeStamps2);
}

TEST_F(EventTest, getHwTimeStampsAllocationReturnsValidPointer) {
    std::unique_ptr<Event> event(new Event(this->pCmdQ, CL_COMMAND_COPY_BUFFER, 0, 0));
    ASSERT_NE(nullptr, event);

    GraphicsAllocation *allocation = event->getHwTimeStampNode()->getBaseGraphicsAllocation();
    ASSERT_NE(nullptr, allocation);

    void *memoryStorage = allocation->getUnderlyingBuffer();
    size_t memoryStorageSize = allocation->getUnderlyingBufferSize();

    EXPECT_NE(nullptr, memoryStorage);
    EXPECT_GT(memoryStorageSize, 0u);
}

TEST_F(EventTest, hwTimeStampsMemoryIsPlacedInGraphicsAllocation) {
    std::unique_ptr<Event> event(new Event(this->pCmdQ, CL_COMMAND_COPY_BUFFER, 0, 0));
    ASSERT_NE(nullptr, event);

    HwTimeStamps *timeStamps = event->getHwTimeStampNode()->tagForCpuAccess;
    ASSERT_NE(nullptr, timeStamps);

    GraphicsAllocation *allocation = event->getHwTimeStampNode()->getBaseGraphicsAllocation();
    ASSERT_NE(nullptr, allocation);

    void *memoryStorage = allocation->getUnderlyingBuffer();
    size_t graphicsAllocationSize = allocation->getUnderlyingBufferSize();

    EXPECT_GE(timeStamps, memoryStorage);
    EXPECT_LE(timeStamps + 1, ptrOffset(memoryStorage, graphicsAllocationSize));
}

TEST_F(EventTest, getHwPerfCounterReturnsValidPointer) {
    std::unique_ptr<Event> event(new Event(this->pCmdQ, CL_COMMAND_COPY_BUFFER, 0, 0));
    ASSERT_NE(nullptr, event);

    HwPerfCounter *perfCounter = event->getHwPerfCounterNode()->tagForCpuAccess;
    ASSERT_NE(nullptr, perfCounter);

    ASSERT_EQ(0ULL, perfCounter->HWTimeStamp.GlobalStartTS);
    ASSERT_EQ(0ULL, perfCounter->HWTimeStamp.ContextStartTS);
    ASSERT_EQ(0ULL, perfCounter->HWTimeStamp.GlobalEndTS);
    ASSERT_EQ(0ULL, perfCounter->HWTimeStamp.ContextEndTS);
    ASSERT_EQ(0ULL, perfCounter->HWTimeStamp.GlobalCompleteTS);
    ASSERT_EQ(0ULL, perfCounter->HWTimeStamp.ContextCompleteTS);

    EXPECT_TRUE(perfCounter->canBeReleased());

    HwPerfCounter *perfCounter2 = event->getHwPerfCounterNode()->tagForCpuAccess;
    ASSERT_EQ(perfCounter, perfCounter2);
}

TEST_F(EventTest, getHwPerfCounterAllocationReturnsValidPointer) {
    std::unique_ptr<Event> event(new Event(this->pCmdQ, CL_COMMAND_COPY_BUFFER, 0, 0));
    ASSERT_NE(nullptr, event);

    GraphicsAllocation *allocation = event->getHwPerfCounterNode()->getBaseGraphicsAllocation();
    ASSERT_NE(nullptr, allocation);

    void *memoryStorage = allocation->getUnderlyingBuffer();
    size_t memoryStorageSize = allocation->getUnderlyingBufferSize();

    EXPECT_NE(nullptr, memoryStorage);
    EXPECT_GT(memoryStorageSize, 0u);
}

TEST_F(EventTest, hwPerfCounterMemoryIsPlacedInGraphicsAllocation) {
    std::unique_ptr<Event> event(new Event(this->pCmdQ, CL_COMMAND_COPY_BUFFER, 0, 0));
    ASSERT_NE(nullptr, event);

    HwPerfCounter *perfCounter = event->getHwPerfCounterNode()->tagForCpuAccess;
    ASSERT_NE(nullptr, perfCounter);

    GraphicsAllocation *allocation = event->getHwPerfCounterNode()->getBaseGraphicsAllocation();
    ASSERT_NE(nullptr, allocation);

    void *memoryStorage = allocation->getUnderlyingBuffer();
    size_t graphicsAllocationSize = allocation->getUnderlyingBufferSize();

    EXPECT_GE(perfCounter, memoryStorage);
    EXPECT_LE(perfCounter + 1, ptrOffset(memoryStorage, graphicsAllocationSize));
}

TEST_F(EventTest, IsPerfCounter_DisabledByNullQueue) {
    Event ev(nullptr, CL_COMMAND_COPY_BUFFER, 3, 0);
    EXPECT_FALSE(ev.isProfilingEnabled());
    EXPECT_FALSE(ev.isPerfCountersEnabled());
}

TEST_F(EventTest, IsPerfCounter_DisabledByNoProfiling) {
    Event ev(pCmdQ, CL_COMMAND_COPY_BUFFER, 3, 0);
    EXPECT_FALSE(ev.isProfilingEnabled());
    EXPECT_FALSE(ev.isPerfCountersEnabled());
}

TEST_F(InternalsEventTest, IsPerfCounter_DisabledByNoPerfCounter) {
    const cl_queue_properties props[3] = {CL_QUEUE_PROPERTIES, CL_QUEUE_PROFILING_ENABLE, 0};
    CommandQueue *pCmdQ = new CommandQueue(mockContext, pDevice, props);

    Event *ev = new Event(pCmdQ, CL_COMMAND_COPY_BUFFER, 3, 0);
    EXPECT_TRUE(ev->isProfilingEnabled());
    EXPECT_FALSE(ev->isPerfCountersEnabled());

    delete ev;
    delete pCmdQ;
}

TEST_F(InternalsEventWithPerfCountersTest, SetPerfCounter_negativeInvalidASInterface) {
    const cl_queue_properties props[3] = {CL_QUEUE_PROPERTIES, CL_QUEUE_PROFILING_ENABLE, 0};
    CommandQueue *pCmdQ = new CommandQueue(mockContext, pDevice, props);
    performanceCountersBase->setAutoSamplingStartFunc(autoSamplingStartFailing);
    bool ret = false;
    ret = pCmdQ->setPerfCountersEnabled(true, 1);
    EXPECT_FALSE(ret);
    delete pCmdQ;
}

TEST_F(InternalsEventWithPerfCountersTest, SetPerfCounter_AvailFalse) {
    const cl_queue_properties props[3] = {CL_QUEUE_PROPERTIES, CL_QUEUE_PROFILING_ENABLE, 0};
    CommandQueue *pCmdQ = new CommandQueue(mockContext, pDevice, props);

    bool ret = false;
    ret = pCmdQ->setPerfCountersEnabled(true, 1);
    EXPECT_TRUE(ret);
    performanceCountersBase->setAvailableFlag(false);
    ret = pCmdQ->setPerfCountersEnabled(false, 0);
    EXPECT_TRUE(ret);
    performanceCountersBase->shutdown();
    delete pCmdQ;
}

TEST_F(EventTest, GivenNullptrWhenpeekIsSubmittedThenFalse) {
    Event ev(this->pCmdQ, CL_COMMAND_COPY_BUFFER, 3, 0);
    bool executionStatus = ev.peekIsSubmitted(nullptr);
    EXPECT_NE(true, executionStatus);
}

TEST_F(EventTest, GivenCL_SUBMITTEDWhenpeekIsSubmittedThenTrue) {
    Event ev(this->pCmdQ, CL_COMMAND_COPY_BUFFER, 3, 0);
    int32_t executionStatusSnapshot = CL_SUBMITTED;
    bool executionStatus = ev.peekIsSubmitted(&executionStatusSnapshot);
    EXPECT_EQ(true, executionStatus);
}

TEST_F(EventTest, GivenCompletedEventWhenQueryingExecutionStatusAfterFlushThenCsrIsNotFlushed) {
    cl_int ret;
    Event ev(this->pCmdQ, CL_COMMAND_COPY_BUFFER, 3, 3);
    auto &csr = this->pCmdQ->getCommandStreamReceiver();
    *csr.getTagAddress() = 3;
    auto previousTaskLevel = csr.peekTaskLevel();
    EXPECT_GT(3u, previousTaskLevel);
    ret = clFlush(this->pCmdQ);
    ASSERT_EQ(CL_SUCCESS, ret);
    cl_int execState;
    ret = clGetEventInfo(&ev, CL_EVENT_COMMAND_EXECUTION_STATUS, sizeof(execState), &execState, nullptr);
    ASSERT_EQ(CL_SUCCESS, ret);
    EXPECT_EQ(previousTaskLevel, csr.peekTaskLevel());
}

HWTEST_F(EventTest, submitCommandOnEventCreatedOnMapBufferWithoutCommandUpdatesTaskCount) {
    MockEvent<Event> ev(this->pCmdQ, CL_COMMAND_MAP_BUFFER, Event::eventNotReady, Event::eventNotReady);

    EXPECT_EQ(Event::eventNotReady, ev.peekTaskCount());
    ev.submitCommand(false);
    EXPECT_EQ(0u, ev.peekTaskCount());
}

HWTEST_F(EventTest, submitCommandOnEventCreatedOnMapImageWithoutCommandUpdatesTaskCount) {
    MockEvent<Event> ev(this->pCmdQ, CL_COMMAND_MAP_IMAGE, Event::eventNotReady, Event::eventNotReady);

    EXPECT_EQ(Event::eventNotReady, ev.peekTaskCount());
    ev.submitCommand(false);
    EXPECT_EQ(0u, ev.peekTaskCount());
}

TEST_F(EventTest, givenCmdQueueWithoutProfilingWhenIsCpuProfilingIsCalledThenFalseIsReturned) {
    MockEvent<Event> ev(this->pCmdQ, CL_COMMAND_MAP_IMAGE, Event::eventNotReady, Event::eventNotReady);
    bool cpuProfiling = ev.isCPUProfilingPath() != 0;
    EXPECT_FALSE(cpuProfiling);
}

TEST_F(EventTest, givenOutEventWhenBlockingEnqueueHandledOnCpuThenUpdateTaskCountAndFlushStampFromCmdQ) {
    std::unique_ptr<Image> image(ImageHelper<Image1dDefaults>::create(&mockContext));
    EXPECT_TRUE(image->mappingOnCpuAllowed());

    pCmdQ->flushStamp->setStamp(10);
    pCmdQ->taskCount = 11;

    size_t origin[3] = {0, 0, 0};
    size_t region[3] = {1, 1, 1};

    cl_int retVal;
    cl_event clEvent;
    pCmdQ->enqueueMapImage(image.get(), CL_TRUE, CL_MAP_READ, origin, region, nullptr, nullptr, 0, nullptr, &clEvent, retVal);

    auto eventObj = castToObject<Event>(clEvent);
    EXPECT_EQ(pCmdQ->taskCount, eventObj->peekTaskCount());
    EXPECT_EQ(pCmdQ->flushStamp->peekStamp(), eventObj->flushStamp->peekStamp());
    eventObj->release();
}

TEST_F(EventTest, givenCmdQueueWithProfilingWhenIsCpuProfilingIsCalledThenTrueIsReturned) {
    const cl_queue_properties props[3] = {CL_QUEUE_PROPERTIES, CL_QUEUE_PROFILING_ENABLE, 0};
    std::unique_ptr<CommandQueue> pCmdQ(new CommandQueue(&mockContext, pDevice, props));

    MockEvent<Event> ev(pCmdQ.get(), CL_COMMAND_MAP_IMAGE, Event::eventNotReady, Event::eventNotReady);
    bool cpuProfiling = ev.isCPUProfilingPath() != 0;
    EXPECT_TRUE(cpuProfiling);
}

TEST(EventCallback, GivenEventWithCallbacksOnPeekHasCallbacksReturnsTrue) {
    DebugManagerStateRestore dbgRestore;
    DebugManager.flags.EnableAsyncEventsHandler.set(false);
    struct ClbFuncTempStruct {
        static void CL_CALLBACK ClbFuncT(cl_event, cl_int, void *) {
        }
    };

    struct SmallMockEvent : Event {
        SmallMockEvent()
            : Event(nullptr, CL_COMMAND_COPY_BUFFER, 0, 0) {
            this->parentCount = 1; // block event
        }
    };

    {
        SmallMockEvent ev;
        EXPECT_FALSE(ev.peekHasCallbacks());
    }

    {
        SmallMockEvent ev;
        ev.addCallback(ClbFuncTempStruct::ClbFuncT, CL_SUBMITTED, nullptr);
        EXPECT_TRUE(ev.peekHasCallbacks());
        ev.decRefInternal();
    }

    {
        SmallMockEvent ev;
        ev.addCallback(ClbFuncTempStruct::ClbFuncT, CL_RUNNING, nullptr);
        EXPECT_TRUE(ev.peekHasCallbacks());
        ev.decRefInternal();
    }

    {
        SmallMockEvent ev;
        ev.addCallback(ClbFuncTempStruct::ClbFuncT, CL_COMPLETE, nullptr);
        EXPECT_TRUE(ev.peekHasCallbacks());
        ev.decRefInternal();
    }

    {
        SmallMockEvent ev;
        ev.addCallback(ClbFuncTempStruct::ClbFuncT, CL_SUBMITTED, nullptr);
        ev.addCallback(ClbFuncTempStruct::ClbFuncT, CL_COMPLETE, nullptr);
        EXPECT_TRUE(ev.peekHasCallbacks());
        ev.decRefInternal();
        ev.decRefInternal();
    }

    {
        SmallMockEvent ev;
        ev.addCallback(ClbFuncTempStruct::ClbFuncT, CL_RUNNING, nullptr);
        ev.addCallback(ClbFuncTempStruct::ClbFuncT, CL_COMPLETE, nullptr);
        EXPECT_TRUE(ev.peekHasCallbacks());
        ev.decRefInternal();
        ev.decRefInternal();
    }

    {
        SmallMockEvent ev;
        ev.addCallback(ClbFuncTempStruct::ClbFuncT, CL_SUBMITTED, nullptr);
        ev.addCallback(ClbFuncTempStruct::ClbFuncT, CL_RUNNING, nullptr);
        ev.addCallback(ClbFuncTempStruct::ClbFuncT, CL_COMPLETE, nullptr);
        EXPECT_TRUE(ev.peekHasCallbacks());
        ev.decRefInternal();
        ev.decRefInternal();
        ev.decRefInternal();
    }
}

TEST_F(EventTest, addChildForEventUncompleted) {
    VirtualEvent virtualEvent(pCmdQ, &mockContext);
    {
        Event event(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, 0, 0);
        event.addChild(virtualEvent);
        EXPECT_NE(0U, virtualEvent.peekNumEventsBlockingThis());
    }
}

TEST(Event, whenCreatingRegularEventsThenExternalSynchronizationIsNotRequired) {
    Event *event = new Event(nullptr, 0, 0, 0);
    EXPECT_FALSE(event->isExternallySynchronized());
    event->release();

    UserEvent *userEvent = new UserEvent();
    EXPECT_FALSE(userEvent->isExternallySynchronized());
    userEvent->release();

    VirtualEvent *virtualEvent = new VirtualEvent();
    EXPECT_FALSE(virtualEvent->isExternallySynchronized());
    virtualEvent->release();
}

HWTEST_F(EventTest, givenEventWithNotReadyTaskLevelWhenUnblockedThenGetTaskLevelFromCsrIfGreaterThanParent) {
    uint32_t initialTaskLevel = 10;
    Event parentEventWithGreaterTaskLevel(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, initialTaskLevel + 5, 0);
    Event parentEventWithLowerTaskLevel(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, initialTaskLevel - 5, 0);

    Event childEvent0(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, Event::eventNotReady, Event::eventNotReady);
    Event childEvent1(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, Event::eventNotReady, Event::eventNotReady);

    auto &csr = reinterpret_cast<UltCommandStreamReceiver<FamilyType> &>(pCmdQ->getCommandStreamReceiver());
    csr.taskLevel = initialTaskLevel;

    parentEventWithGreaterTaskLevel.addChild(childEvent0);
    parentEventWithLowerTaskLevel.addChild(childEvent1);

    parentEventWithGreaterTaskLevel.setStatus(CL_COMPLETE);
    parentEventWithLowerTaskLevel.setStatus(CL_COMPLETE);

    EXPECT_EQ(parentEventWithGreaterTaskLevel.getTaskLevel() + 1, childEvent0.getTaskLevel());
    EXPECT_EQ(csr.taskLevel, childEvent1.getTaskLevel());
}

TEST_F(EventTest, addChildForEventCompleted) {
    VirtualEvent virtualEvent(pCmdQ, &mockContext);
    {
        Event event(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, 0, 0);
        event.setStatus(CL_COMPLETE);
        event.addChild(virtualEvent);
        EXPECT_EQ(0U, virtualEvent.peekNumEventsBlockingThis());
    }
}

HWTEST_F(EventTest, givenQuickKmdSleepRequestWhenWaitIsCalledThenPassRequestToWaitingFunction) {
    struct MyCsr : public UltCommandStreamReceiver<FamilyType> {
        MyCsr(const ExecutionEnvironment &executionEnvironment) : UltCommandStreamReceiver<FamilyType>(const_cast<ExecutionEnvironment &>(executionEnvironment)) {}
        MOCK_METHOD3(waitForCompletionWithTimeout, bool(bool enableTimeout, int64_t timeoutMs, uint32_t taskCountToWait));
    };
    HardwareInfo localHwInfo = pDevice->getHardwareInfo();
    localHwInfo.capabilityTable.kmdNotifyProperties.enableKmdNotify = true;
    localHwInfo.capabilityTable.kmdNotifyProperties.enableQuickKmdSleep = true;
    localHwInfo.capabilityTable.kmdNotifyProperties.delayQuickKmdSleepMicroseconds = 1;
    localHwInfo.capabilityTable.kmdNotifyProperties.delayKmdNotifyMicroseconds = 2;

    pDevice->executionEnvironment->setHwInfo(&localHwInfo);

    auto csr = new ::testing::NiceMock<MyCsr>(*pDevice->executionEnvironment);
    pDevice->resetCommandStreamReceiver(csr);

    Event event(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, 0, 0);
    event.updateCompletionStamp(1u, 1u, 1u);

    EXPECT_CALL(*csr, waitForCompletionWithTimeout(::testing::_,
                                                   localHwInfo.capabilityTable.kmdNotifyProperties.delayQuickKmdSleepMicroseconds, ::testing::_))
        .Times(1)
        .WillOnce(::testing::Return(true));

    event.wait(true, true);
}

HWTEST_F(EventTest, givenNonQuickKmdSleepRequestWhenWaitIsCalledThenPassRequestToWaitingFunction) {
    struct MyCsr : public UltCommandStreamReceiver<FamilyType> {
        MyCsr(const ExecutionEnvironment &executionEnvironment) : UltCommandStreamReceiver<FamilyType>(const_cast<ExecutionEnvironment &>(executionEnvironment)) {}
        MOCK_METHOD3(waitForCompletionWithTimeout, bool(bool enableTimeout, int64_t timeoutMs, uint32_t taskCountToWait));
    };
    HardwareInfo localHwInfo = pDevice->getHardwareInfo();
    localHwInfo.capabilityTable.kmdNotifyProperties.enableKmdNotify = true;
    localHwInfo.capabilityTable.kmdNotifyProperties.enableQuickKmdSleep = true;
    localHwInfo.capabilityTable.kmdNotifyProperties.enableQuickKmdSleepForSporadicWaits = false;
    localHwInfo.capabilityTable.kmdNotifyProperties.delayQuickKmdSleepMicroseconds = 1;
    localHwInfo.capabilityTable.kmdNotifyProperties.delayKmdNotifyMicroseconds = 2;

    pDevice->executionEnvironment->setHwInfo(&localHwInfo);

    auto csr = new ::testing::NiceMock<MyCsr>(*pDevice->executionEnvironment);
    pDevice->resetCommandStreamReceiver(csr);

    Event event(pCmdQ, CL_COMMAND_NDRANGE_KERNEL, 0, 0);
    event.updateCompletionStamp(1u, 1u, 1u);

    EXPECT_CALL(*csr, waitForCompletionWithTimeout(::testing::_,
                                                   localHwInfo.capabilityTable.kmdNotifyProperties.delayKmdNotifyMicroseconds, ::testing::_))
        .Times(1)
        .WillOnce(::testing::Return(true));

    event.wait(true, false);
}

HWTEST_F(InternalsEventTest, givenCommandWhenSubmitCalledThenUpdateFlushStamp) {
    auto pCmdQ = std::unique_ptr<CommandQueue>(new CommandQueue(mockContext, pDevice, 0));
    MockEvent<Event> *event = new MockEvent<Event>(pCmdQ.get(), CL_COMMAND_MARKER, 0, 0);
    auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
    csr.flushStamp->setStamp(5);

    FlushStamp expectedFlushStamp = 0;
    EXPECT_EQ(expectedFlushStamp, event->flushStamp->peekStamp());
    event->setCommand(std::unique_ptr<Command>(new CommandMarker(*pCmdQ.get(), csr, CL_COMMAND_MARKER, 4096u)));
    event->submitCommand(false);
    EXPECT_EQ(csr.flushStamp->peekStamp(), event->flushStamp->peekStamp());
    delete event;
}

HWTEST_F(InternalsEventTest, givenAbortedCommandWhenSubmitCalledThenDontUpdateFlushStamp) {
    auto pCmdQ = std::unique_ptr<CommandQueue>(new CommandQueue(mockContext, pDevice, 0));
    MockEvent<Event> *event = new MockEvent<Event>(pCmdQ.get(), CL_COMMAND_MARKER, 0, 0);
    auto &csr = pDevice->getUltCommandStreamReceiver<FamilyType>();
    csr.flushStamp->setStamp(5);

    MockKernelWithInternals mockKernelWithInternals(*pDevice);
    auto pKernel = mockKernelWithInternals.mockKernel;

    auto cmdStream = new LinearStream(pDevice->getMemoryManager()->allocateGraphicsMemoryWithProperties({4096, GraphicsAllocation::AllocationType::COMMAND_BUFFER}));
    IndirectHeap *dsh = nullptr, *ioh = nullptr, *ssh = nullptr;
    pCmdQ->allocateHeapMemory(IndirectHeap::DYNAMIC_STATE, 4096u, dsh);
    pCmdQ->allocateHeapMemory(IndirectHeap::INDIRECT_OBJECT, 4096u, ioh);
    pCmdQ->allocateHeapMemory(IndirectHeap::SURFACE_STATE, 4096u, ssh);
    using UniqueIH = std::unique_ptr<IndirectHeap>;
    auto blockedCommandsData = new KernelOperation(std::unique_ptr<LinearStream>(cmdStream), UniqueIH(dsh),
                                                   UniqueIH(ioh), UniqueIH(ssh), *pCmdQ->getCommandStreamReceiver().getInternalAllocationStorage());
    PreemptionMode preemptionMode = pDevice->getPreemptionMode();
    std::vector<Surface *> v;
    auto cmd = new CommandComputeKernel(*pCmdQ, std::unique_ptr<KernelOperation>(blockedCommandsData), v, false, false, false, nullptr, preemptionMode, pKernel, 1);
    event->setCommand(std::unique_ptr<Command>(cmd));

    FlushStamp expectedFlushStamp = 0;

    EXPECT_EQ(expectedFlushStamp, event->flushStamp->peekStamp());
    event->submitCommand(true);

    EXPECT_EQ(expectedFlushStamp, event->flushStamp->peekStamp());
    delete event;
}

TEST(EventLockerTests, givenEventWhenEventLockerIsUsedThenOwnershipIsAutomaticallyReleased) {
    Event ev(nullptr, CL_COMMAND_COPY_BUFFER, 3, 0);
    {
        TakeOwnershipWrapper<Event> locker(ev);
        EXPECT_TRUE(ev.hasOwnership());
    }
    EXPECT_FALSE(ev.hasOwnership());
}

TEST(EventLockerTests, givenEventWhenEventLockerIsUsedAndUnlockedThenOwnershipIsReleased) {
    Event ev(nullptr, CL_COMMAND_COPY_BUFFER, 3, 0);
    {
        TakeOwnershipWrapper<Event> locker(ev);
        locker.unlock();
        EXPECT_FALSE(ev.hasOwnership());
    }
    EXPECT_FALSE(ev.hasOwnership());
}

TEST(EventLockerTests, givenEventWhenEventLockerIsUsedAndlockedThenOwnershipIsAcquiredAgain) {
    Event ev(nullptr, CL_COMMAND_COPY_BUFFER, 3, 0);
    {
        TakeOwnershipWrapper<Event> locker(ev);
        locker.unlock();
        locker.lock();
        EXPECT_TRUE(ev.hasOwnership());
    }
    EXPECT_FALSE(ev.hasOwnership());
}
TEST(EventLockerTests, givenEventWhenEventLockerIsLockedTwiceThenOwnershipIsReleaseAfterLeavingTheScope) {
    Event ev(nullptr, CL_COMMAND_COPY_BUFFER, 3, 0);
    {
        TakeOwnershipWrapper<Event> locker(ev);
        locker.lock();
        EXPECT_TRUE(ev.hasOwnership());
    }
    EXPECT_FALSE(ev.hasOwnership());
}

TEST(EventsDebug, givenEventWhenTrackingOfParentsIsOnThenTrackParents) {
    DebugManagerStateRestore stateRestore;
    DebugManager.flags.TrackParentEvents.set(true);
    Event event(nullptr, CL_COMMAND_NDRANGE_KERNEL, 0, 0);
    Event event2(nullptr, CL_COMMAND_NDRANGE_KERNEL, 0, 0);

    auto &parentEvents = event.getParentEvents();
    auto &parentEvents2 = event2.getParentEvents();

    EXPECT_EQ(0u, parentEvents.size());
    EXPECT_EQ(0u, parentEvents2.size());

    event.addChild(event2);
    EXPECT_EQ(0u, parentEvents.size());
    EXPECT_EQ(1u, parentEvents2.size());
    EXPECT_EQ(&event, parentEvents2.at(0));
    event.setStatus(CL_COMPLETE);
}

TEST(EventsDebug, givenEventWhenTrackingOfParentsIsOffThenDoNotTrackParents) {
    DebugManagerStateRestore stateRestore;
    DebugManager.flags.TrackParentEvents.set(false);
    Event event(nullptr, CL_COMMAND_NDRANGE_KERNEL, 0, 0);
    Event event2(nullptr, CL_COMMAND_NDRANGE_KERNEL, 0, 0);

    auto &parentEvents = event.getParentEvents();
    auto &parentEvents2 = event2.getParentEvents();

    EXPECT_EQ(0u, parentEvents.size());
    EXPECT_EQ(0u, parentEvents2.size());

    event.addChild(event2);
    EXPECT_EQ(0u, parentEvents.size());
    EXPECT_EQ(0u, parentEvents2.size());
    event.setStatus(CL_COMPLETE);
}
",16345,True,2959.3116943178597,median
"#include <fstream>
#include <algorithm>
#include <numeric>
#include <boost/program_options.hpp> 
#include <boost/iostreams/filtering_stream.hpp>
#include <boost/iostreams/filter/gzip.hpp>
#include <iostream>
#include <memory>
#include <limits>
#include ""boost/filesystem.hpp""
#include ""usher_graph.hpp""
#include ""parsimony.pb.h""

namespace po = boost::program_options;
namespace MAT = Mutation_Annotated_Tree;

int main(int argc, char** argv) {
    //Variables to load command-line options using Boost program_options
    std::string tree_filename;
    std::string din_filename;
    std::string dout_filename;
    std::string outdir;
    std::string vcf_filename;
    uint32_t num_cores = tbb::task_scheduler_init::default_num_threads();
    uint32_t num_threads;
    uint32_t max_trees;
    uint32_t max_uncertainty;
    bool sort_before_placement_1 = false;
    bool sort_before_placement_2 = false;
    bool sort_before_placement_3 = false;
    bool reverse_sort = false;
    bool collapse_tree=false;
    bool collapse_output_tree=false;
    bool print_uncondensed_tree = false;
    bool print_parsimony_scores = false;
    bool retain_original_branch_len = false;
    size_t print_subtrees_size=0;
    size_t print_subtrees_single=0;
    po::options_description desc{""Options""};

    std::string num_threads_message = ""Number of threads to use when possible [DEFAULT uses all available cores, "" + std::to_string(num_cores) + "" detected on this machine]"";
    desc.add_options()
        (""vcf,v"", po::value<std::string>(&vcf_filename)->required(), ""Input VCF file (in uncompressed or gzip-compressed .gz format) [REQUIRED]"")
        (""tree,t"", po::value<std::string>(&tree_filename)->default_value(""""), ""Input tree file"")
        (""outdir,d"", po::value<std::string>(&outdir)->default_value("".""), ""Output directory to dump output and log files [DEFAULT uses current directory]"")
        (""load-mutation-annotated-tree,i"", po::value<std::string>(&din_filename)->default_value(""""), ""Load mutation-annotated tree object"")
        (""save-mutation-annotated-tree,o"", po::value<std::string>(&dout_filename)->default_value(""""), ""Save output mutation-annotated tree object to the specified filename"")
        (""sort-before-placement-1,s"", po::bool_switch(&sort_before_placement_1), \\
         ""Sort new samples based on computed parsimony score and then number of optimal placements before the actual placement [EXPERIMENTAL]."")
        (""sort-before-placement-2,S"", po::bool_switch(&sort_before_placement_2), \\
         ""Sort new samples based on the number of optimal placements and then the parsimony score before the actual placement [EXPERIMENTAL]."")
        (""sort-before-placement-3,A"", po::bool_switch(&sort_before_placement_3), \\
         ""Sort new samples based on the number of ambiguous bases [EXPERIMENTAL]."")
        (""reverse-sort,r"", po::bool_switch(&reverse_sort), \\
         ""Reverse the sorting order of sorting options (sort-before-placement-1 or sort-before-placement-2) [EXPERIMENTAL]"")
        (""collapse-tree,c"", po::bool_switch(&collapse_tree), \\
         ""Collapse internal nodes of the input tree with no mutations and condense identical sequences in polytomies into a single node and the save the tree to file condensed-tree.nh in outdir"")
        (""collapse-output-tree,C"", po::bool_switch(&collapse_output_tree), \\
         ""Collapse internal nodes of the output tree with no mutations before the saving the tree to file final-tree.nh in outdir"")
        (""max-uncertainty-per-sample,e"", po::value<uint32_t>(&max_uncertainty)->default_value(1e6), \\
         ""Maximum number of equally parsimonious placements allowed per sample beyond which the sample is ignored"")
        (""write-uncondensed-final-tree,u"", po::bool_switch(&print_uncondensed_tree), ""Write the final tree in uncondensed format and save to file uncondensed-final-tree.nh in outdir"")
        (""write-subtrees-size,k"", po::value<size_t>(&print_subtrees_size)->default_value(0), \\
         ""Write minimum set of subtrees covering the newly added samples of size equal to this value"")
        (""write-single-subtree,K"", po::value<size_t>(&print_subtrees_single)->default_value(0), \\
         ""Similar to write-subtrees-size but produces a single subtree with all newly added samples along with random samples up to the value specified by this argument"")
        (""write-parsimony-scores-per-node,p"", po::bool_switch(&print_parsimony_scores), \\
         ""Write the parsimony scores for adding new samples at each existing node in the tree without modifying the tree in a file names parsimony-scores.tsv in outdir"")
        (""multiple-placements,M"", po::value<uint32_t>(&max_trees)->default_value(1), \\
         ""Create a new tree up to this limit for each possibility of parsimony-optimal placement"")
        (""retain-input-branch-lengths,l"", po::bool_switch(&retain_original_branch_len), \\
         ""Retain the branch lengths from the input tree in out newick files instead of using number of mutations for the branch lengths."")
        (""threads,T"", po::value<uint32_t>(&num_threads)->default_value(num_cores), num_threads_message.c_str())
        (""help,h"", ""Print help messages"");
    
    po::options_description all_options;
    all_options.add(desc);

    po::variables_map vm;
    try{
        po::store(po::command_line_parser(argc, argv).options(all_options).run(), vm);
        po::notify(vm);
    }
    catch(std::exception &e){
        std::cerr << desc << std::endl;
        // Return with error code 1 unless the user specifies help
        if(vm.count(""help""))
            return 0;
        else
            return 1;
    }

    if (print_subtrees_size == 1) {
        std::cerr << ""ERROR: print-subtrees-size should be larger than 1\\n"";
        return 1;
    }

    if (sort_before_placement_1 + sort_before_placement_2 + sort_before_placement_3 > 1) {
        std::cerr << ""ERROR: Can't use two or more of sort-before-placement-1, sort-before-placement-2 and sort-before-placement-3 simultaneously. Please specify only one.\\n"";
        return 1;
    }

    if (sort_before_placement_1 || sort_before_placement_2 || sort_before_placement_3) { 
        std::cerr << ""WARNING: Using experimental option "";
        if (sort_before_placement_1) {
            std::cerr << ""--sort-before-placement-1 (-s)\\n"";
        }
        if (sort_before_placement_2) {
            std::cerr << ""--sort-before-placement-2 (-S)\\n"";
        }
        if (sort_before_placement_3) {
            std::cerr << ""--sort-before-placement-3 (-A)\\n"";
        }
    }
    else if (reverse_sort) {
        std::cerr << ""ERROR: Can't use reverse-sort without sorting options (sort-before-placement-1 or sort-before-placement-2 or sort-before-placement-3)\\n"";
        return 1;
    }

    if (print_parsimony_scores) {
        if (max_trees > 1) {
            std::cerr << ""ERROR: cannot use --multiple-placements (-M) and --print_parsimony_scores (-p) options simulaneously.\\n"";
            return 1;
        }
    
        if (sort_before_placement_1 || sort_before_placement_2 || sort_before_placement_3 ||
                collapse_tree || collapse_output_tree || print_uncondensed_tree || (print_subtrees_size > 0) || (dout_filename != """")) {
            fprintf (stderr, ""WARNING: --print-parsimony-scores-per-node is set. Will terminate without modifying the original tree.\\n"");
        }
    }

    if (max_trees == 0) {
        std::cerr << ""ERROR: Number of trees specified by --multiple-placements (-M) should be >= 1\\n"";
        return 1;
    }
    /*
    if (max_trees > 1) {
        if (max_trees < 256) {
            std::cerr << ""WARNING: Using experimental option --multiple-placements (-M)\\n"";
        }
        else { 
            std::cerr << ""ERROR: Number of trees specified by --multiple-placements (-M) should be <= 255\\n"";
            return 1; 
        }
    }
    */

    if (retain_original_branch_len) {
        fprintf(stderr, ""Output newick files will retain branch lengths from the input tree (unspecified at branches modified during the placement).\\n\\n"");
    }
    else {
        fprintf(stderr, ""Output newick files will have branch lengths equal to the number of mutations of that branch.\\n\\n"");
    }

    boost::filesystem::path path(outdir);
    if (!boost::filesystem::exists(path)) {
        fprintf(stderr, ""Creating output directory.\\n\\n"");
        boost::filesystem::create_directory(path);
    }
    path = boost::filesystem::canonical(outdir);
    outdir = path.generic_string();

    // timer object to be used to measure runtimes of individual stages
    Timer timer; 

    fprintf(stderr, ""Initializing %u worker threads.\\n\\n"", num_threads);
    tbb::task_scheduler_init init(num_threads);

#if SAVE_PROFILE == 1
    Instrumentor::Get().BeginSession(""test-main"", ""p1.json"");
#endif

    // Vector to store multiple trees, each corresponding to a different
    // possibility of a  parsimony-optimal placement, when --multiple-placements
    // is used. Otherwise, this vector maintains a single tree througout the
    // execution in which a tie-breaking strategy defined in usher_mapper is
    // used for multiple parsimony-optimal placements.
    std::vector<MAT::Tree> optimal_trees;
    // Tree pointer to point to some element in optimal_trees that would be
    // updated several times during the execution 
    MAT::Tree* T = NULL;

    // Since --multiple-placements can result in trees with different parsimony
    // scores, the vector below will be used to maintain the final parsimony
    // score of each tree 
    std::vector<size_t> tree_parsimony_scores;
    
    auto num_trees = optimal_trees.size();

    // Variables below used to store the different fields of the input VCF file 
    bool header_found = false;
    std::vector<std::string> variant_ids;
    std::vector<Missing_Sample> missing_samples;

    // Vector used to store all tree nodes in breadth-first search (BFS) order
    std::vector<MAT::Node*> bfs;
    // Map the node identifier string to index in the BFS traversal
    std::unordered_map<std::string, size_t> bfs_idx;
    
    // Vectore to store the names of samples which have a high number of 
    // parsimony-optimal placements
    std::vector<std::string> low_confidence_samples;

    // If tree filename is specified, UShER needs to first load the tree and
    // a create a new mutation-annotated tree object (stored in optimal_trees) 
    // using the sample variants in the input VCF file. If the VCF contains
    // samples missing in the input tree, they get added to missing_samples
    if (tree_filename != """") {
        fprintf(stderr, ""Loading input tree and vcf file.\\n""); 
        timer.Start();
        // Create a new tree from the input newick file and store it in
        // optimal_trees
        auto tmp_T = MAT::create_tree_from_newick(tree_filename);
        optimal_trees.emplace_back(std::move(tmp_T));

        // Nodes of T don't have mutations assigned yet
        T = &optimal_trees[0];

        // Breadth-first expansion to populate bfs and bfs_idx
        bfs = T->breadth_first_expansion();
        for (size_t idx = 0; idx < bfs.size(); idx++) {
            bfs_idx[bfs[idx]->identifier] = idx;
        }

        // Boost library used to stream the contents of the input VCF file in
        // uncompressed or compressed .gz format
        std::ifstream infile(vcf_filename, std::ios_base::in | std::ios_base::binary);
        if (!infile) {
            fprintf(stderr, ""ERROR: Could not open the VCF file: %s!\\n"", vcf_filename.c_str());
            exit(1);
        }
        boost::iostreams::filtering_istream instream;
        try {
            if (vcf_filename.find("".gz\\0"") != std::string::npos) {
                instream.push(boost::iostreams::gzip_decompressor());
            }
            instream.push(infile);
        }
        catch(const boost::iostreams::gzip_error& e) {
            std::cout << e.what() << '\\n';
        }
        
        fprintf(stderr, ""Completed in %ld msec \\n\\n"", timer.Stop());

        fprintf(stderr, ""Computing parsimonious assignments for input variants.\\n""); 
        timer.Start();

        // A TBB flow graph containing a single source_node (reader) connected
        // to several mappers. The source_node sequentially reads in the different 
        // lines of the input VCF file and constructs a mapper task for each
        // VCF line. Each mapper task takes a mapper_input as input, which stores
        // the alternate alleles, ambiguous bases and missing data (Ns) for
        // different tree samples at the corresponding VCF line/position. The 
        // mappers use Fitch-Sankoff algorithm to assign mutations at different
        // branches of the tree and update the mutation-annotated tree (T)
        // accordingly. 
        tbb::flow::graph mapper_graph;

        tbb::flow::function_node<mapper_input, int> mapper(mapper_graph, tbb::flow::unlimited, mapper_body());
        tbb::flow::source_node <mapper_input> reader (mapper_graph,
                [&] (mapper_input &inp) -> bool {
                
                //check if reached end-of-file
                int curr_char = instream.peek();
                if(curr_char == EOF)
                    return false;
                
                std::string s;
                std::getline(instream, s);
                std::vector<std::string> words;
                MAT::string_split(s, words);
                inp.variant_pos = -1;

                // Header is found when ""POS"" is the second word in the line
                if ((not header_found) && (words.size() > 1)) {
                  if (words[1] == ""POS"") {
                  // Sample names start from the 10th word in the header
                    for (size_t j=9; j < words.size(); j++) {
                      variant_ids.emplace_back(words[j]);
                      // If sample name not in tree, add it to missing_samples
                      if (bfs_idx.find(words[j]) == bfs_idx.end()) {
                        missing_samples.emplace_back(Missing_Sample(words[j]));
//                        num_missing++;
                      }
                    }
//                    missing_sample_mutations.resize(num_missing);
                    header_found = true;
                  }
                }
                else if (header_found) {
                    if (words.size() != 9+variant_ids.size()) {
                        fprintf(stderr, ""ERROR! Incorrect VCF format.\\n"");
                        exit(1);
                    }
                    std::vector<std::string> alleles;
                    alleles.clear();
                    inp.variant_pos = std::stoi(words[1]); 
                    MAT::string_split(words[4], ',', alleles);
                    // T will be modified by the mapper with mutation
                    // annotations
                    inp.T = T;
                    inp.chrom = words[0];
                    inp.bfs = &bfs;
                    inp.bfs_idx = &bfs_idx;
                    inp.variant_ids = &variant_ids;
                    inp.missing_samples = &missing_samples;
                    // Ref nuc id uses one-hot encoding (A:0b1, C:0b10, G:0b100,
                    // T:0b1000)
                    inp.ref_nuc = MAT::get_nuc_id(words[3][0]);
                    assert((inp.ref_nuc & (inp.ref_nuc-1)) == 0); //check if it is power of 2
                    inp.variants.clear();
                    for (size_t j=9; j < words.size(); j++) {
                        if (isdigit(words[j][0])) {
                            int allele_id = std::stoi(words[j]);
                            if (allele_id > 0) { 
                                std::string allele = alleles[allele_id-1];
                                inp.variants.emplace_back(std::make_tuple(j-9, MAT::get_nuc_id(allele[0])));
                            }
                        }
                        else {
                            inp.variants.emplace_back(std::make_tuple(j-9, MAT::get_nuc_id('N')));
                        }
                    }
                }
                return true;
                }, true );
        tbb::flow::make_edge(reader, mapper);
        mapper_graph.wait_for_all();

        fprintf(stderr, ""Completed in %ld msec \\n\\n"", timer.Stop());
    }
    // Check if input mutation-annotated tree filename is specified
    else if (din_filename != """") {
        timer.Start();

        fprintf(stderr, ""Loading existing mutation-annotated tree object from file %s\\n"", din_filename.c_str());
       
        // Load mutation-annotated tree and store it in optimal_trees
        auto tmp_T = MAT::load_mutation_annotated_tree(din_filename);
        optimal_trees.emplace_back(std::move(tmp_T));

        T = &optimal_trees[0];
        
        fprintf(stderr, ""Completed in %ld msec \\n\\n"", timer.Stop());
        
        fprintf(stderr, ""Loading VCF file\\n"");
        timer.Start();

        // Boost library used to stream the contents of the input VCF file in
        // uncompressed or compressed .gz format
        std::ifstream infile(vcf_filename, std::ios_base::in | std::ios_base::binary);
        if (!infile) {
            fprintf(stderr, ""ERROR: Could not open the VCF file: %s!\\n"", vcf_filename.c_str());
            exit(1);
        }
        boost::iostreams::filtering_istream instream;
        try {
            if (vcf_filename.find("".gz\\0"") != std::string::npos) {
                instream.push(boost::iostreams::gzip_decompressor());
            }
            instream.push(infile);
        }
        catch(const boost::iostreams::gzip_error& e) {
            std::cout << e.what() << '\\n';
        }

        std::vector<size_t> missing_idx;
        std::string s;
        // This while loop reads the VCF file line by line and populates
        // missing_samples and missing_sample_mutations based on the names and 
        // variants of missing samples. If a sample name in the VCF is already
        // found in the tree, it gets ignored with a warning message
        while (instream.peek() != EOF) {
            std::getline(instream, s);
            std::vector<std::string> words;
            MAT::string_split(s, words);
            if ((not header_found) && (words.size() > 1)) {
                if (words[1] == ""POS"") {
                    for (size_t j=9; j < words.size(); j++) {
                        variant_ids.emplace_back(words[j]);
                        if ((T->get_node(words[j]) == NULL) && (T->condensed_leaves.find(words[j]) == T->condensed_leaves.end())) {
                            missing_samples.emplace_back(Missing_Sample(words[j]));
                            missing_idx.emplace_back(j);
                        }
                        else {
                            fprintf(stderr, ""WARNING: Ignoring sample %s as it is already in the tree.\\n"", words[j].c_str());
                        }
                    }
                    header_found = true;
                }
            }
            else if (header_found) {
                if (words.size() != 9+variant_ids.size()) {
                    fprintf(stderr, ""ERROR! Incorrect VCF format. Expected %zu columns but got %zu.\\n"", 9+variant_ids.size(), words.size());
                    exit(1);
                }
                std::vector<std::string> alleles;
                alleles.clear();
                MAT::string_split(words[4], ',', alleles);
                for (size_t k = 0; k < missing_idx.size(); k++) {
                    size_t j = missing_idx[k];
                    auto iter = missing_samples.begin();
                    std::advance(iter, k);
                    if (iter != missing_samples.end()) {
                        MAT::Mutation m;
                        m.chrom = words[0];
                        m.position = std::stoi(words[1]);
                        m.ref_nuc = MAT::get_nuc_id(words[3][0]);
                        assert((m.ref_nuc & (m.ref_nuc-1)) == 0); //check if it is power of 2
                        m.par_nuc = m.ref_nuc;
                        // Alleles such as '.' should be treated as missing
                        // data. if the word is numeric, it is an index to one
                        // of the alleles 
                        if (isdigit(words[j][0])) {
                            int allele_id = std::stoi(words[j]);
                            if (allele_id > 0) { 
                                std::string allele = alleles[allele_id-1];
                                if (allele[0] == 'N') {
                                    m.is_missing = true;
                                    m.mut_nuc = MAT::get_nuc_id('N');
                                }
                                else {
                                    auto nuc = MAT::get_nuc_id(allele[0]);
                                    if (nuc == MAT::get_nuc_id('N')) {
                                        m.is_missing = true;
                                    }
                                    else {
                                        m.is_missing = false;
                                    }
                                    m.mut_nuc = nuc;
                                }
                                (*iter).mutations.emplace_back(m);
                            }
                        }
                        else {
                            m.is_missing = true;
                            m.mut_nuc = MAT::get_nuc_id('N');
                            (*iter).mutations.emplace_back(m);
                        }
                        if ((m.mut_nuc & (m.mut_nuc-1)) !=0) {
                            (*iter).num_ambiguous++;
                        }
                    }
                }
            }
        }
        fprintf(stderr, ""Completed in %ld msec \\n\\n"", timer.Stop());
    }
    else {
        fprintf(stderr, ""Error! No input tree or assignment file provided!\\n"");
        exit(1);
    }

    // Collapses the tree nodes not carrying a mutation and also condenses
    // identical sequences into a single node. 
    if (collapse_tree) {
        timer.Start();
        
        fprintf(stderr, ""Collapsing input tree.\\n"");
        
        assert (optimal_trees.size() == 1);

        T->collapse_tree();

        fprintf(stderr, ""Completed in %ld msec \\n\\n"", timer.Stop());

        fprintf(stderr, ""Condensing identical sequences. \\n"");

        T->condense_leaves();

        auto condensed_tree_filename = outdir + ""/condensed-tree.nh"";
        fprintf(stderr, ""Writing condensed input tree to file %s\\n"", condensed_tree_filename.c_str());
        
        FILE* condensed_tree_file = fopen(condensed_tree_filename.c_str(), ""w"");
        fprintf(condensed_tree_file, ""%s\\n"", MAT::get_newick_string(*T, T->root, true, true, retain_original_branch_len).c_str());
        fclose(condensed_tree_file);

        fprintf(stderr, ""Completed in %ld msec \\n\\n"", timer.Stop());
    }

    fprintf(stderr, ""Found %zu missing samples.\\n\\n"", missing_samples.size()); 

    FILE* parsimony_scores_file = NULL; 

    //Sort samples based on number of ambiguous bases if specified
    if (sort_before_placement_3) {
        timer.Start();
        fprintf(stderr, ""Sorting missing samples based on the number of ambiguous bases \\n"");
        std::stable_sort(missing_samples.begin(), missing_samples.end());
        // Reverse sorted order if specified
        if (reverse_sort) {
            std::reverse(missing_samples.begin(), missing_samples.end());
        }
        fprintf(stderr, ""Completed in %ld msec \\n\\n"", timer.Stop());
    }
        
    // If samples found in VCF that are missing from the input tree, they are
    // now placed using maximum parsimony or if print_parsimony_score is set,
    // the parsimony scores for placning the sample is printed (without the
    // actual placement). 
    if (missing_samples.size() > 0) {
        
        // indexes stores the order in which the missing samples should be
        // placed sequentially on the tree. It is initialized with sequentially
        // increasing values 0,1,2,.. which will be modified if one of the
        // sorting options is used
        std::vector<size_t> indexes(missing_samples.size());
        std::iota(indexes.begin(), indexes.end(), 0);
        
        // Write current tree with internal nodes labelled. Parsimony score of
        // placement at each node (including internal nodes) will be printed later.
        if (print_parsimony_scores) {
            timer.Start();
            auto current_tree_filename = outdir + ""/current-tree.nh"";
            
            fprintf(stderr, ""Writing current tree with internal nodes labelled to file %s \\n"", current_tree_filename.c_str());
            FILE* current_tree_file = fopen(current_tree_filename.c_str(), ""w"");
            fprintf(current_tree_file, ""%s\\n"", MAT::get_newick_string(*T, true, true, retain_original_branch_len).c_str());
            fclose(current_tree_file);
            
            fprintf(stderr, ""Completed in %ld msec \\n\\n"", timer.Stop());
        } 
        else {
            if ((sort_before_placement_1 || sort_before_placement_2) && (missing_samples.size() > 1)) {
                timer.Start();
                fprintf(stderr, ""Computing parsimony scores and number of parsimony-optimal placements for new samples and using them to sort the samples.\\n""); 
                if (max_trees > 1) {
                    fprintf(stderr, ""WARNING: --multiple-placements option is used but note that the samples will be sorted only once using the parsimony scores on input tree (without actual placements).\\n""); 
                }

                // vectors to store the best parsimony scores and the number of
                // parsimony-optimal placements for each of the new samples to
                // be placed on the tree
                std::vector<int> best_parsimony_scores;
                std::vector<size_t> num_best_placements;

                for (size_t s=0; s<missing_samples.size(); s++) {

                    //Sort the missing sample mutations by position
                    std::sort(missing_samples[s].mutations.begin(), missing_samples[s].mutations.end());

                    auto dfs = T->depth_first_expansion();
                    size_t total_nodes = dfs.size();

                    // Stores the excess mutations to place the sample at each
                    // node of the tree in DFS order. When placement is as a
                    // child, it only contains parsimony-increasing mutations in
                    // the sample. When placement is as a sibling, it contains 
                    // parsimony-increasing mutations as well as the mutations
                    // on the placed node in common with the new sample. Note
                    // guaranteed to be corrrect only for optimal nodes since
                    // the mapper can terminate the search early for non-optimal
                    // nodes
                    std::vector<std::vector<MAT::Mutation>> node_excess_mutations(total_nodes);
                    // Stores the imputed mutations for ambiguous bases in the
                    // sampled in order to place the sample at each node of the 
                    // tree in DFS order. Again, guaranteed to be corrrect only 
                    // for pasrimony-optimal nodes 
                    std::vector<std::vector<MAT::Mutation>> node_imputed_mutations(total_nodes);

                    // Stores the parsimony score to place the sample at each
                    // node of the tree in DFS order.
                    std::vector<int> node_set_difference;
                    if (print_parsimony_scores) {
                        node_set_difference.resize(total_nodes);
                    }

                    size_t best_node_num_leaves = 0;
                    // The maximum number of mutations is bound by the number
                    // of mutations in the missing sample (place at root)
                    //int best_set_difference = 1e9;
                    // TODO: currently number of root mutations is also added to
                    // this value since it forces placement as child but this
                    // could be changed later 
                    int best_set_difference = missing_samples[s].mutations.size() + T->root->mutations.size() + 1;

                    size_t best_j = 0;
                    size_t num_best = 1;
                    bool best_node_has_unique = false;
                    MAT::Node* best_node = T->root;

                    std::vector<bool> node_has_unique(total_nodes, false);
                    std::vector<size_t> best_j_vec;
                    best_j_vec.emplace_back(0);

                    // Parallel for loop to search for most parsimonious
                    // placements. Real action happens within mapper2_body
                    static tbb::affinity_partitioner ap;
                    tbb::parallel_for( tbb::blocked_range<size_t>(0, total_nodes),
                            [&](tbb::blocked_range<size_t> r) {
                            for (size_t k=r.begin(); k<r.end(); ++k){
                                mapper2_input inp;
                                inp.T = T;
                                inp.node = dfs[k];
                                inp.missing_sample_mutations = &missing_samples[s].mutations;
                                inp.excess_mutations = &node_excess_mutations[k];
                                inp.imputed_mutations = &node_imputed_mutations[k];
                                inp.best_node_num_leaves = &best_node_num_leaves;
                                inp.best_set_difference = &best_set_difference;
                                inp.best_node = &best_node;
                                inp.best_j =  &best_j;
                                inp.num_best = &num_best;
                                inp.j = k;
                                inp.has_unique = &best_node_has_unique;
                                inp.best_j_vec = &best_j_vec;
                                inp.node_has_unique = &(node_has_unique);

                                mapper2_body(inp, false);
                            }       
                    }, ap); 

                    best_parsimony_scores.emplace_back(best_set_difference);
                    num_best_placements.emplace_back(num_best);
                }

                // Sort samples order in indexes based on parsimony scores
                // and number of parsimony-optimal placements
                if (sort_before_placement_1) {
                    std::stable_sort(indexes.begin(), indexes.end(),
                            [&num_best_placements, &best_parsimony_scores](size_t i1, size_t i2) 
                            {return ((best_parsimony_scores[i1] < best_parsimony_scores[i2]) || \\
                                    ((best_parsimony_scores[i1] == best_parsimony_scores[i2]) && (num_best_placements[i1] < num_best_placements[i2])));});
                }
                else if (sort_before_placement_2) {
                    std::stable_sort(indexes.begin(), indexes.end(),
                            [&num_best_placements, &best_parsimony_scores](size_t i1, size_t i2) 
                            {return ((num_best_placements[i1] < num_best_placements[i2]) || \\
                                    ((num_best_placements[i1] == num_best_placements[i2]) && (best_parsimony_scores[i1] < best_parsimony_scores[i2])));});
                }
                
                // Reverse sorted order if specified
                if (reverse_sort) {
                    std::reverse(indexes.begin(), indexes.end());
                }

                fprintf(stderr, ""Completed in %ld msec \\n\\n"", timer.Stop());
            }

            fprintf(stderr, ""Adding missing samples to the tree.\\n"");  
        }

        // Traverse in sorted sample order
        for (size_t idx=0; idx<indexes.size(); idx++) {

            num_trees = optimal_trees.size();

            for (size_t t_idx=0; t_idx < num_trees; t_idx++) {
                timer.Start();
                
                T = &optimal_trees[t_idx];

                if (num_trees > 1) {
                    fprintf(stderr, ""==Tree %zu=== \\n"", t_idx+1);
                }

                size_t s = indexes[idx];
                auto sample = missing_samples[s].name;

                if (T->get_node(sample) != NULL) {
                    fprintf(stderr, ""WARNING: Sample %s already in the tree! Ignoring.\\n\\n"", sample.c_str());
                    continue;
                }

                if (print_parsimony_scores) {
                    auto parsimony_scores_filename = outdir + ""/parsimony-scores.tsv"";
                    if (s==0) {
                        fprintf(stderr, ""\\nNow computing branch parsimony scores for adding the missing samples at each of the %zu nodes in the existing tree without modifying the tree.\\n"", T->depth_first_expansion().size()); 
                        fprintf(stderr, ""The branch parsimony scores will be written to file %s\\n\\n"", parsimony_scores_filename.c_str());

                        parsimony_scores_file = fopen(parsimony_scores_filename.c_str(), ""w"");
                        fprintf (parsimony_scores_file, ""#Sample\\tTree node\\tParsimony score\\tOptimal (y/n)\\tParsimony-increasing mutations (for optimal nodes)\\n""); 
                    }
                }

                auto dfs = T->depth_first_expansion();
                size_t total_nodes = dfs.size();

                // Stores the excess mutations to place the sample at each
                // node of the tree in DFS order. When placement is as a
                // child, it only contains parsimony-increasing mutations in
                // the sample. When placement is as a sibling, it contains 
                // parsimony-increasing mutations as well as the mutations
                // on the placed node in common with the new sample. Note
                // guaranteed to be corrrect only for optimal nodes since
                // the mapper can terminate the search early for non-optimal
                // nodes
                std::vector<std::vector<MAT::Mutation>> node_excess_mutations(total_nodes);
                // Stores the imputed mutations for ambiguous bases in the
                // sampled in order to place the sample at each node of the 
                // tree in DFS order. Again, guaranteed to be corrrect only 
                // for pasrimony-optimal nodes 
                std::vector<std::vector<MAT::Mutation>> node_imputed_mutations(total_nodes);

                std::vector<int> node_set_difference;

                if (print_parsimony_scores) {
                    node_set_difference.resize(total_nodes);
                }

                size_t best_node_num_leaves = 0;
                // The maximum number of mutations is bound by the number
                // of mutations in the missing sample (place at root)
                //int best_set_difference = 1e9;
                // TODO: currently number of root mutations is also added to
                // this value since it forces placement as child but this
                // could be changed later 
                int best_set_difference = missing_samples[s].mutations.size() + T->root->mutations.size() + 1;
                
                size_t best_j = 0;
                bool best_node_has_unique = false;
                
                std::vector<bool> node_has_unique(total_nodes, false);
                std::vector<size_t> best_j_vec;
                
                size_t num_best = 1;
                MAT::Node* best_node = T->root;
                best_j_vec.emplace_back(0);

                // Parallel for loop to search for most parsimonious
                // placements. Real action happens within mapper2_body
                static tbb::affinity_partitioner ap;
                tbb::parallel_for( tbb::blocked_range<size_t>(0, total_nodes),
                        [&](tbb::blocked_range<size_t> r) {
                        for (size_t k=r.begin(); k<r.end(); ++k){
                        mapper2_input inp;
                        inp.T = T;
                        inp.node = dfs[k];
                        inp.missing_sample_mutations = &missing_samples[s].mutations;
                        inp.excess_mutations = &node_excess_mutations[k];
                        inp.imputed_mutations = &node_imputed_mutations[k];
                        inp.best_node_num_leaves = &best_node_num_leaves;
                        inp.best_set_difference = &best_set_difference;
                        inp.best_node = &best_node;
                        inp.best_j =  &best_j;
                        inp.num_best = &num_best;
                        inp.j = k;
                        inp.has_unique = &best_node_has_unique;

                        if (print_parsimony_scores) {
                        inp.set_difference = &node_set_difference[k];
                        }
                        inp.best_j_vec = &best_j_vec;
                        inp.node_has_unique = &(node_has_unique);

                        mapper2_body(inp, print_parsimony_scores);
                        }       
                        }, ap); 

                if (!print_parsimony_scores) {
                    fprintf(stderr, ""Current tree size (#nodes): %zu\\tSample name: %s\\tParsimony score: %d\\tNumber of parsimony-optimal placements: %zu\\n"", total_nodes, sample.c_str(), \\
                            best_set_difference, num_best);
                    // Prints a warning message if 2 or more
                    // parsimony-optimal placements found
                    if (num_best > 1) {
                        if (max_trees == 1) {
                            low_confidence_samples.emplace_back(sample);
                        }
                        if (num_best > max_uncertainty) {
                            fprintf(stderr, ""WARNING: Number of parsimony-optimal placements exceeds maximum allowed value (%u). Ignoring sample %s.\\n"", max_uncertainty, sample.c_str());
                        }
                        else {
                            fprintf(stderr, ""WARNING: Multiple parsimony-optimal placements found. Placement done without high confidence.\\n"");
                        }
                    }
                }
                else {
                    fprintf(stderr, ""Missing sample: %s\\t Best parsimony score: %d\\tNumber of parsimony-optimal placements: %zu\\n"", sample.c_str(), \\
                            best_set_difference, num_best);

                }

                // Debugging information to be printed if -DDEBUG compile-time
                // flag is set. This includes sample mutations, details of the
                // best node and the list of mutations at the best node
#if DEBUG == 1
                fprintf (stderr, ""Sample mutations:\\t"");
                if (missing_samples[s].mutations.size() > 0) {
                    for (auto m: missing_samples[s].mutations) {
                        if (m.is_missing) {
                            continue;
                        }
                        fprintf(stderr, ""|%s"", (MAT::get_nuc(m.par_nuc) + std::to_string(m.position) + MAT::get_nuc(m.mut_nuc)).c_str());
                        fprintf(stderr, ""| "");
                    }
                }
                fprintf (stderr, ""\\n"");

                assert(num_best > 0);

                //best_node_vec.emplace_back(best_node);
                if ((num_best > 0) && (num_best <= max_uncertainty)) {
                    for (auto j: best_j_vec) {
                        auto node = dfs[j];

                        std::vector<std::string> muts;

                        fprintf(stderr, ""Best node "");
                        if (node->is_leaf() || node_has_unique[j]) {
                            fprintf(stderr, ""(sibling)"");
                        }
                        else {
                            fprintf(stderr, ""(child)"");
                        }

                        if (node == best_node) {
                            fprintf(stderr, ""*: %s\\t"", node->identifier.c_str());
                        }
                        else {
                            fprintf(stderr, "": %s\\t"", node->identifier.c_str());
                        }

                        std::string s = ""|"";
                        for (auto m: node->mutations) {
                            s += MAT::get_nuc(m.par_nuc) + std::to_string(m.position) + MAT::get_nuc(m.mut_nuc) + '|';
                        }
                        if (node->mutations.size() > 0) {
                            muts.emplace_back(std::move(s));
                        }

                        for (auto anc: T->rsearch(node->identifier)) {
                            s = ""|"";
                            for (auto m: anc->mutations) {
                                s += MAT::get_nuc(m.par_nuc) + std::to_string(m.position) + MAT::get_nuc(m.mut_nuc) + '|';
                            }
                            if (anc->mutations.size() > 0) {
                                muts.emplace_back(std::move(s));
                            }
                        }


                        std::reverse(muts.begin(), muts.end());

                        fprintf(stderr, ""Mutations: ""); 
                        for (size_t m = 0; m < muts.size(); m++) {
                            fprintf(stderr, ""%s"", muts[m].c_str());
                            if (m+1 < muts.size()) {
                                fprintf(stderr, "" > ""); 
                            }
                        }
                        fprintf(stderr, ""\\n""); 
                    }
                    fprintf(stderr, ""\\n""); 
                }

#endif
                
                // If number of parsimony-optimal trees is more than 1 and if
                // the number of trees has not already exceeded the maximum
                // limit, create a copy of the current tree in curr_tree
                MAT::Tree curr_tree;
                if ((max_trees > 1) && (num_best > 1) && (num_trees < max_trees)) {
                    curr_tree = MAT::get_tree_copy(*T);
                }

                if (print_parsimony_scores) {
                    for (size_t k = 0; k < total_nodes; k++) {
                        char is_optimal = (node_set_difference[k] == best_set_difference) ? 'y' : 'n';
                        fprintf (parsimony_scores_file, ""%s\\t%s\\t%d\\t\\t%c\\t"", sample.c_str(), dfs[k]->identifier.c_str(), node_set_difference[k], is_optimal); 
                        if (node_set_difference[k] == best_set_difference) {
                            if (node_set_difference[k] == 0) {
                                fprintf(parsimony_scores_file, ""*"");
                            }
                            for (size_t idx = 0; idx < static_cast<size_t>(node_set_difference[k]); idx++) {
                                auto m = node_excess_mutations[k][idx];
                                assert (m.is_masked() || ((m.mut_nuc & (m.mut_nuc-1)) == 0));
                                fprintf(parsimony_scores_file, ""%s"", m.get_string().c_str());
                                if (idx+1 < static_cast<size_t>(node_set_difference[k])) {
                                    fprintf(parsimony_scores_file, "","");
                                }
                            }
                        }
                        else {
                            fprintf(parsimony_scores_file, ""N/A"");
                        }
                        fprintf(parsimony_scores_file, ""\\n"");
                    }
                }
                // Do placement only if number of parsimony-optimal placements
                // does not exceed the maximum allowed value
                else if (num_best <= max_uncertainty) {
                    if (num_best > 1) {
                        if (max_trees > 1) {
                            // Sorting by dfs order ensures reproducible results
                            // during multiple placements
                            std::sort(best_j_vec.begin(), best_j_vec.end());
                        }

                        // Update num_best so that the number of trees does
                        // not exceed maximum limit
                        if ((optimal_trees.size() <= max_trees) && (num_best + optimal_trees.size() > max_trees)) {
                            if ((num_best + optimal_trees.size() > max_trees+1) && (max_trees > 1))
                                fprintf (stderr, ""%zu parsimony-optimal placements found but total trees has already exceed the max possible value (%i)!\\n"", num_best, max_trees);
                            num_best = 1 + max_trees - optimal_trees.size();
                        }
                    }

                    // Iterate over the number of parsimony-optimal placements
                    // for which a new tree will be created
                    for (size_t k = 0; k < num_best; k++) {

                        // best_j is updated using best_j_vec if multiple
                        // placements are allowed and the number of new trees
                        // for the given sample is greater than 1. If not, the
                        // default tie-breaking strategy used in mapper2_body has
                        // already chosen a single best_j
                        if ((max_trees > 1) && (num_best > 1)) {
                            if ((k==0) && (num_best > 1)) {
                                fprintf (stderr, ""Creating %zu additional tree(s) for %zu parsimony-optimal placements.\\n"", num_best-1, num_best);
                            }
                            // If at second placement or higher, a new tree needs to
                            // be added to optimal_trees and T needs to point to its
                            // last element. If not, T is already pointing to the
                            // last element of optimal_trees on which placement will
                            // be carried out
                            if (k > 0) {
                                auto tmp_T = MAT::get_tree_copy(curr_tree);
                                optimal_trees.emplace_back(std::move(tmp_T));
                                T = &optimal_trees[optimal_trees.size()-1];
                                dfs = T->depth_first_expansion();
                            }

                            best_j = best_j_vec[k];                                                                                                                                                             
                            best_node_has_unique = node_has_unique[k];
                            best_node = dfs[best_j];
                        }
                        
                        // Ensure sample not already in the tree
                        if (T->get_node(sample) == NULL) {
                            // Is placement as sibling
                            if (best_node->is_leaf() || best_node_has_unique) {
                                std::string nid = std::to_string(++T->curr_internal_node);
                                T->create_node(nid, best_node->parent->identifier);
                                T->create_node(sample, nid);
                                T->move_node(best_node->identifier, nid);
                                // common_mut stores mutations common to the
                                // best node branch and the sample, l1_mut
                                // stores mutations unique to best node branch
                                // and l2_mut stores mutations unique to the
                                // sample not in best node branch
                                std::vector<MAT::Mutation> common_mut, l1_mut, l2_mut;
                                std::vector<MAT::Mutation> curr_l1_mut;

                                // Compute current best node branch mutations
                                for (auto m1: best_node->mutations) {
                                    MAT::Mutation m = m1.copy();
                                    curr_l1_mut.emplace_back(m);
                                }
                                // Clear mutations on the best node branch which
                                // will be later replaced by l1_mut
                                best_node->clear_mutations();
                                
                                // Compute l1_mut
                                for (auto m1: curr_l1_mut) {
                                    bool found = false;
                                    for (auto m2: node_excess_mutations[best_j]) {
                                        if (m1.is_masked()) {
                                            break;
                                        }
                                        if (m1.position == m2.position) {
                                            if (m1.mut_nuc == m2.mut_nuc) {
                                                found = true;
                                                break;
                                            }
                                        }
                                    }
                                    if (!found) {
                                        MAT::Mutation m = m1.copy();
                                        l1_mut.emplace_back(m);
                                    }
                                }
                                // Compute l2_mut
                                for (auto m1: node_excess_mutations[best_j]) {
                                    bool found = false;
                                    for (auto m2: curr_l1_mut) {
                                        if (m1.is_masked()) {
                                            break;
                                        }
                                        if (m1.position == m2.position) {
                                            if (m1.mut_nuc == m2.mut_nuc) {
                                                found = true;
                                                MAT::Mutation m = m1.copy();
                                                common_mut.emplace_back(m);
                                                break;
                                            }
                                        }
                                    }
                                    if (!found) {
                                        MAT::Mutation m = m1.copy();
                                        l2_mut.emplace_back(m);
                                    }
                                }
                                
                                // Add mutations to new node using common_mut
                                for (auto m: common_mut) {
                                    T->get_node(nid)->add_mutation(m);
                                }
                                // Add mutations to best node using l1_mut
                                for (auto m: l1_mut) {
                                    T->get_node(best_node->identifier)->add_mutation(m);
                                }
                                // Add new sample mutations using l2_mut
                                for (auto m: l2_mut) {
                                    T->get_node(sample)->add_mutation(m);
                                }
                            }
                            // Else placement as child
                            else {
                                T->create_node(sample, best_node->identifier);
                                MAT::Node* node = T->get_node(sample);
                                std::vector<MAT::Mutation> node_mut;

                                std::vector<MAT::Mutation> curr_l1_mut;

                                for (auto m1: best_node->mutations) {
                                    MAT::Mutation m = m1.copy();
                                    curr_l1_mut.emplace_back(m);
                                }

                                for (auto m1: node_excess_mutations[best_j]) {
                                    bool found = false;
                                    for (auto m2: curr_l1_mut) {
                                        if (m1.is_masked()) {
                                            break;
                                        }
                                        if (m1.position == m2.position) {
                                            if (m1.mut_nuc == m2.mut_nuc) {
                                                found = true;
                                                break;
                                            }
                                        }
                                    }
                                    if (!found) {
                                        MAT::Mutation m = m1.copy();
                                        node_mut.emplace_back(m);
                                    }
                                }
                                for (auto m: node_mut) {
                                    node->add_mutation(m);
                                }
                            }

                            if (node_imputed_mutations[best_j].size() > 0) {
                                fprintf (stderr, ""Imputed mutations:\\t"");
                                size_t tot = node_imputed_mutations[best_j].size();
                                for (size_t curr = 0; curr < tot; curr++) {
                                    if (curr < tot-1) {
                                        fprintf (stderr, ""%i:%c;"", node_imputed_mutations[best_j][curr].position, MAT::get_nuc(node_imputed_mutations[best_j][curr].mut_nuc));
                                    }
                                    else {
                                        fprintf (stderr, ""%i:%c"", node_imputed_mutations[best_j][curr].position, MAT::get_nuc(node_imputed_mutations[best_j][curr].mut_nuc));
                                    }
                                }
                                fprintf(stderr, ""\\n"");
                            }
                        }
                        
                        if (max_trees == 1) {
                            break;
                        }
                    }
                }

                fprintf(stderr, ""Completed in %ld msec \\n\\n"", timer.Stop());
            }
        }
        
    }

    num_trees = optimal_trees.size();
            
    // If user specified print_parsimony_scores, close corresponding file and
    // terminate normally
    if (print_parsimony_scores) {
        if (parsimony_scores_file) {
            fclose(parsimony_scores_file);
        }
        return 0;
    }

    // Collapse the output tree
    if (collapse_output_tree) {
        timer.Start();
        
        for (size_t t_idx = 0; t_idx < num_trees; t_idx++) {
            timer.Start();
            
            T = &optimal_trees[t_idx];
            
            if (num_trees > 1) {
                fprintf(stderr, ""Collapsing output tree %lu.\\n"", t_idx+1);
            }
            else {
                fprintf(stderr, ""Collapsing output tree.\\n"");
            }

            T->collapse_tree();

            fprintf(stderr, ""Completed in %ld msec \\n\\n"", timer.Stop());
        }
    }

    // If user need uncondensed tree output, write uncondensed tree(s) to
    // file(s)
    if (print_uncondensed_tree) {
        for (size_t t_idx = 0; t_idx < num_trees; t_idx++) {
            timer.Start();
            
            T = &optimal_trees[t_idx];

            auto uncondensed_final_tree_filename = outdir + ""/uncondensed-final-tree.nh"";
            if (num_trees > 1) {
                uncondensed_final_tree_filename = outdir + ""/uncondensed-final-tree-"" + std::to_string(t_idx+1) + "".nh""; 
                fprintf(stderr, ""Writing uncondensed final tree %zu to file %s \\n"", (t_idx+1), uncondensed_final_tree_filename.c_str());
            }
            else {
                fprintf(stderr, ""Writing uncondensed final tree to file %s \\n"", uncondensed_final_tree_filename.c_str());
            }

            auto parsimony_score = T->get_parsimony_score();
            fprintf(stderr, ""The parsimony score for this tree is: %zu \\n"", parsimony_score);
            //FILE* uncondensed_final_tree_file = fopen(uncondensed_final_tree_filename.c_str(), ""w"");
                
            //fprintf(uncondensed_final_tree_file, ""%s\\n"", MAT::get_newick_string(*T, true, true, retain_original_branch_len, true).c_str());

            //fclose(uncondensed_final_tree_file);
            std::ofstream uncondensed_final_tree_file(uncondensed_final_tree_filename.c_str(), std::ofstream::out);
            std::stringstream newick_ss;
            write_newick_string(newick_ss, *T, T->root, true, true, retain_original_branch_len, true);
            uncondensed_final_tree_file << newick_ss.rdbuf(); 
            uncondensed_final_tree_file.close();

            fprintf(stderr, ""Completed in %ld msec \\n\\n"", timer.Stop());
        }
    }
    else {
        // Write final tree(s) to file(s)
        for (size_t t_idx = 0; t_idx < num_trees; t_idx++) {
            timer.Start();

            T = &optimal_trees[t_idx];

            auto final_tree_filename = outdir + ""/final-tree.nh"";
            if (num_trees > 1) {
                final_tree_filename = outdir + ""/final-tree-"" + std::to_string(t_idx+1) + "".nh"";
                fprintf(stderr, ""Writing final tree %zu to file %s \\n"", t_idx+1, final_tree_filename.c_str());
            }
            else {
                fprintf(stderr, ""Writing final tree to file %s \\n"", final_tree_filename.c_str());
            }
            auto parsimony_score = T->get_parsimony_score();
            fprintf(stderr, ""The parsimony score for this tree is: %zu \\n"", parsimony_score);
            //FILE* final_tree_file = fopen(final_tree_filename.c_str(), ""w"");
            //fprintf(final_tree_file, ""%s\\n"", MAT::get_newick_string(*T, true, true, retain_original_branch_len).c_str());
            //fclose(final_tree_file);
            std::ofstream final_tree_file(final_tree_filename.c_str(), std::ofstream::out);
            std::stringstream newick_ss;
            write_newick_string(newick_ss, *T, T->root, true, true, retain_original_branch_len);
            final_tree_file << newick_ss.rdbuf(); 
            final_tree_file.close();

            tree_parsimony_scores.emplace_back(parsimony_score);

            fprintf(stderr, ""Completed in %ld msec \\n\\n"", timer.Stop());
        }
    }

    if (missing_samples.size() > 0) {
        // For each final tree write the path of mutations from tree root to the
        // sample for each newly placed sample
        for (size_t t_idx = 0; t_idx < num_trees; t_idx++) {
            timer.Start();

            T = &optimal_trees[t_idx];

            auto mutation_paths_filename = outdir + ""/mutation-paths.txt"";
            if (num_trees > 1) {
                mutation_paths_filename = outdir + ""/mutation-paths-"" + std::to_string(t_idx+1) + "".txt"";
                fprintf(stderr, ""Writing mutation paths for tree %zu to file %s \\n"", t_idx+1, mutation_paths_filename.c_str());
            }
            else {
                fprintf(stderr, ""Writing mutation paths to file %s \\n"", mutation_paths_filename.c_str());
            }

            FILE* mutation_paths_file = fopen(mutation_paths_filename.c_str(), ""w"");

            for (size_t s=0; s<missing_samples.size(); s++) {
                auto sample = missing_samples[s].name;
                auto sample_node = T->get_node(sample);
                
                // If the missing sample is not found in the tree, it was not placed
                // because of max_uncertainty.  
                if (T->get_node(sample) == NULL) {
                    continue; 
                }

                // Stack for last-in first-out ordering
                std::stack<std::string> mutation_stack;
                std::string curr_node_mutation_string;

                // Mutations on the added sample
                auto curr_node_mutations = sample_node->mutations;
                if (curr_node_mutations.size() > 0) {
                    curr_node_mutation_string = sample + "":"";
                    size_t num_mutations = curr_node_mutations.size();
                    for (size_t k = 0; k < num_mutations; k++) {
                        curr_node_mutation_string += curr_node_mutations[k].get_string();
                        if (k < num_mutations-1) {
                            curr_node_mutation_string += ',';
                        }
                        else {
                            curr_node_mutation_string += ' ';    
                        }
                    }
                    mutation_stack.push(curr_node_mutation_string);
                }

                // Mutations on the ancestors of added sample
                for (auto anc_node: T->rsearch(sample)) {
                    curr_node_mutations = anc_node->mutations;
                    if (curr_node_mutations.size() > 0) {
                        curr_node_mutation_string = anc_node->identifier + "":"";
                        size_t num_mutations = curr_node_mutations.size();
                        for (size_t k = 0; k < num_mutations; k++) {
                            curr_node_mutation_string += curr_node_mutations[k].get_string(); 
                            if (k < num_mutations-1) {
                                curr_node_mutation_string += ',';
                            }
                            else {
                                curr_node_mutation_string += ' ';    
                            }
                        }
                        mutation_stack.push(curr_node_mutation_string);
                    }
                }

                fprintf(mutation_paths_file, ""%s\\t"", sample.c_str()); 
                while (mutation_stack.size()) {
                    fprintf(mutation_paths_file, ""%s"", mutation_stack.top().c_str()); 
                    mutation_stack.pop();
                }
                fprintf(mutation_paths_file, ""\\n""); 
            }

            fclose(mutation_paths_file);

            fprintf(stderr, ""Completed in %ld msec \\n\\n"", timer.Stop());
            
        }

        // For each final tree write the annotations for each sample
        for (size_t t_idx = 0; t_idx < num_trees; t_idx++) {
            T = &optimal_trees[t_idx];

            size_t num_annotations = T->get_num_annotations();

            if (num_annotations > 0) {
                timer.Start();

                auto annotations_filename = outdir + ""/clades.txt"";
                if (num_trees > 1) {
                    annotations_filename = outdir + ""/clades"" + std::to_string(t_idx+1) + "".txt""; 
                    fprintf(stderr, ""Writing clade annotations for tree %zu to file %s \\n"", (t_idx+1), annotations_filename.c_str());
                }
                else {
                    fprintf(stderr, ""Writing clade annotations to file %s \\n"", annotations_filename.c_str());
                }

                FILE* annotations_file = fopen(annotations_filename.c_str(), ""w"");

                for (size_t s=0; s<missing_samples.size(); s++) {
                    auto sample = missing_samples[s].name;
                    std::vector<std::string> sample_annotations(num_annotations, ""UNDEFINED"");
                    for (auto anc: T->rsearch(sample, true)) {
                        for (size_t k=0; k<num_annotations; k++) {
                            //fprintf(stderr, ""%zu %zu %zu\\n"", k, anc->annotations.size(), sample_annotations.size());
                            if ((anc->clade_annotations[k] != """") && (sample_annotations[k] == ""UNDEFINED"")) {
                                sample_annotations[k] = anc->clade_annotations[k];
                            }
                        }
                    }

                    fprintf(annotations_file, ""%s\\t"", sample.c_str());
                    for (size_t k=0; k< num_annotations; k++) {
                        fprintf(annotations_file, ""%s"", sample_annotations[k].c_str());
                        if (k+1 < num_annotations) {
                            fprintf(annotations_file, ""\\t"");
                        }
                    }
                    fprintf(annotations_file, ""\\n"");
                }
                
                fclose(annotations_file);

                fprintf(stderr, ""Completed in %ld msec \\n\\n"", timer.Stop());
            }
        }
    }

    if ((print_subtrees_single > 1) && (missing_samples.size() > 0)) {
        fprintf(stderr, ""Computing the single subtree for added samples with %zu random leaves. \\n\\n"", print_subtrees_single);

        // For each final tree, write a subtree of user-specified size around
        // each newly placed sample in newick format
        for (size_t t_idx = 0; t_idx < num_trees; t_idx++) {
            timer.Start();

            if (num_trees > 1) {
                fprintf(stderr, ""==Tree %zu=== \\n"", t_idx+1);
            }

            T = &optimal_trees[t_idx];

            std::set<MAT::Node*> leaves_to_keep_set;
            for (size_t i = 0; i < missing_samples.size(); i++) {
                leaves_to_keep_set.insert(T->get_node(missing_samples[i].name));
            }

            auto all_leaves = T->get_leaves();
            for (size_t i=0; i< all_leaves.size(); i++) {
                auto l = all_leaves.begin();
                std::advance(l, std::rand() % all_leaves.size());
                leaves_to_keep_set.insert(*l);
                if (leaves_to_keep_set.size() >= print_subtrees_single + missing_samples.size()) {
                    break;
                }
            }

            std::vector<std::string> leaves_to_keep;
            for (auto l: leaves_to_keep_set) {
                leaves_to_keep.emplace_back(l->identifier);
            }

            auto new_T = MAT::get_subtree(*T, leaves_to_keep);

            // Write subtree to file
            auto subtree_filename = outdir + ""/single-subtree.nh"";
            if (num_trees > 1) {
                subtree_filename = outdir + ""/"" + ""tree-"" + std::to_string(t_idx+1) + ""-single-subtree.nh"";
            }
            fprintf(stderr, ""Writing single subtree with %zu randomly added leaves to file %s.\\n"", print_subtrees_single, subtree_filename.c_str());

            std::ofstream subtree_file(subtree_filename.c_str(), std::ofstream::out);
            std::stringstream newick_ss;
            write_newick_string(newick_ss, new_T, new_T.root, true, true, retain_original_branch_len);
            subtree_file << newick_ss.rdbuf(); 
            subtree_file.close();


            // Write list of mutations on the subtree to file
            auto subtree_mutations_filename = outdir + ""/single-subtree-mutations.txt"";
            if (num_trees > 1) {
                subtree_mutations_filename = outdir + ""/"" + ""tree-"" + std::to_string(t_idx+1) + ""-single-subtree-mutations.txt"";;
            }
            fprintf(stderr, ""Writing list of mutations at the nodes of the single subtree to file %s\\n"", subtree_mutations_filename.c_str());
            FILE* subtree_mutations_file = fopen(subtree_mutations_filename.c_str(), ""w"");

            for (auto n: new_T.depth_first_expansion()) {
                size_t tot_mutations = n->mutations.size();
                fprintf(subtree_mutations_file, ""%s: "", n->identifier.c_str());
                for (size_t idx = 0; idx < tot_mutations; idx++) {
                    auto m = n->mutations[idx];
                    fprintf(subtree_mutations_file, ""%s"", m.get_string().c_str());
                    if (idx+1 <tot_mutations) {
                        fprintf(subtree_mutations_file, "","");
                    }
                }
                fprintf(subtree_mutations_file, ""\\n"");
            }

            fclose(subtree_mutations_file);

            // Expand internal nodes that are condensed
            bool has_condensed = false;
            FILE* subtree_expanded_file = NULL;
            for (auto l: new_T.get_leaves()) {
                if (T->condensed_nodes.find(l->identifier) != T->condensed_nodes.end()) {
                    if (!has_condensed) {
                        auto subtree_expanded_filename = outdir + ""/single-subtree-expanded.txt"";
                        if (num_trees > 1) {
                            subtree_expanded_filename = outdir + ""/tree-"" + std::to_string(1+t_idx) + ""-single-subtree-expanded.txt"";
                        }
                        fprintf(stderr, ""Subtree has condensed nodes.\\nExpanding the condensed nodes for the single subtree in file %s\\n"", subtree_expanded_filename.c_str());
                        subtree_expanded_file = fopen(subtree_expanded_filename.c_str(), ""w"");
                        has_condensed = true;
                    }
                    fprintf(subtree_expanded_file, ""%s: "", l->identifier.c_str());
                    for (auto n: T->condensed_nodes[l->identifier]) {
                        fprintf(subtree_expanded_file, ""%s "", n.c_str());
                    }
                    fprintf(subtree_expanded_file, ""\\n"");
                }
            }
            if (has_condensed) {
                fclose(subtree_expanded_file);
            }
            fprintf(stderr, ""Completed in %ld msec \\n\\n"", timer.Stop());
        }
    }

    if ((print_subtrees_size > 1) && (missing_samples.size() > 0)) {
        fprintf(stderr, ""Computing subtrees for added samples. \\n\\n"");

        // For each final tree, write a subtree of user-specified size around
        // each newly placed sample in newick format
        for (size_t t_idx = 0; t_idx < num_trees; t_idx++) {
            timer.Start();
            
            if (num_trees > 1) {
                fprintf(stderr, ""==Tree %zu=== \\n"", t_idx+1);
            }

            T = &optimal_trees[t_idx];

            // We split the subtree size into two: one half for nearest sequences to
            // the samples and the other half randomly sampled
            //size_t random_subtree_size = print_subtrees_size/2;
            //size_t nearest_subtree_size = print_subtrees_size - random_subtree_size;
            
            size_t random_subtree_size = 0;
            size_t nearest_subtree_size = print_subtrees_size - random_subtree_size;

            //Set a constant random seed
            std::srand(0);

            // Randomly shuffle the leaves for selecting the random subtree
            auto all_leaves = T->get_leaves();
            std::set<MAT::Node*> random_ordered_leaves;
            for (size_t i=0; i< all_leaves.size(); i++) {
                auto l = all_leaves.begin();
                std::advance(l, std::rand() % all_leaves.size());
                random_ordered_leaves.insert(*l);
                if (random_ordered_leaves.size() >= print_subtrees_size) {
                    break;
                }
            }

            // Bool vector to mark which newly placed samples have already been
            // displayed in a subtree (initialized to false)
            std::vector<bool> displayed_mising_sample (missing_samples.size(), false);

            // If the missing sample is not found in the tree, it was not placed
            // because of max_uncertainty. Mark those samples as already
            // displayed. 
            for (size_t ms_idx = 0; ms_idx < missing_samples.size(); ms_idx++) {
                if (T->get_node(missing_samples[ms_idx].name) == NULL) {
                    displayed_mising_sample[ms_idx] = true;
                }
            }

            int num_subtrees = 0;
            for (size_t i = 0; i < missing_samples.size(); i++) {
                if (displayed_mising_sample[i]) {
                    continue;
                }

                MAT::Node* last_anc = T->get_node(missing_samples[i].name);
                std::vector<std::string> leaves_to_keep;

                // Keep moving up the tree till a subtree of required size is
                // found
                for (auto anc: T->rsearch(missing_samples[i].name, true)) {
                    size_t num_leaves = T->get_num_leaves(anc);
                    if (num_leaves <= nearest_subtree_size) {
                        last_anc = anc;
                        continue;
                    }

                    if (num_leaves > nearest_subtree_size) {
                        for (auto l: T->get_leaves(last_anc->identifier)) {
                            leaves_to_keep.emplace_back(l->identifier);
                        }

                        std::vector<MAT::Node*> siblings;
                        for (auto child: anc->children) {
                            if (child->identifier != last_anc->identifier) {
                                siblings.emplace_back(child);
                            }
                        }

                        for (size_t k=0; k<siblings.size(); k++) {
                            for (auto l: T->get_leaves(siblings[k]->identifier)) {
                                leaves_to_keep.emplace_back(l->identifier);
                            }
                        }

                        leaves_to_keep.resize(nearest_subtree_size);
                    }
                    else {
                        for (auto l: T->get_leaves(anc->identifier)) {
                            leaves_to_keep.emplace_back(l->identifier);
                        }
                    }

                    // Add non-overlapping random subtree samples
                    for (auto l: random_ordered_leaves) {
                        if (leaves_to_keep.size() < print_subtrees_size) {
                            if (std::find(leaves_to_keep.begin(), leaves_to_keep.end(), l->identifier) == leaves_to_keep.end()) {
                                leaves_to_keep.emplace_back(l->identifier);
                            }
                        }

                        if (leaves_to_keep.size() >= print_subtrees_size) {
                            break;
                        }
                    }
                    
                    auto new_T = MAT::get_subtree(*T, leaves_to_keep);

                    tbb::parallel_for (tbb::blocked_range<size_t>(i+1, missing_samples.size(), 100),
                            [&](tbb::blocked_range<size_t> r) {
                            for (size_t j=r.begin(); j<r.end(); ++j){
                              for (size_t j = i+1; j < missing_samples.size(); j++) {
                                if (!displayed_mising_sample[j]) {
                                  if (new_T.get_node(missing_samples[j].name) != NULL) {
                                    displayed_mising_sample[j] = true;
                                   }
                                 }
                               }
                             }
                            });

                    // Write subtree to file
                    ++num_subtrees;
                    auto subtree_filename = outdir + ""/subtree-"" + std::to_string(num_subtrees) + "".nh"";
                    if (num_trees > 1) {
                        subtree_filename = outdir + ""/"" + ""tree-"" + std::to_string(t_idx+1) + ""-subtree-"" + std::to_string(num_subtrees) + "".nh"";
                    }
                    fprintf(stderr, ""Writing subtree %d to file %s.\\n"", num_subtrees, subtree_filename.c_str());
                    //FILE* subtree_file = fopen(subtree_filename.c_str(), ""w"");
                    //fprintf(subtree_file, ""%s\\n"", newick.c_str());
                    //fclose(subtree_file);
                    std::ofstream subtree_file(subtree_filename.c_str(), std::ofstream::out);
                    std::stringstream newick_ss;
                    write_newick_string(newick_ss, new_T, new_T.root, true, true, retain_original_branch_len);
                    subtree_file << newick_ss.rdbuf(); 
                    subtree_file.close();


                    // Write list of mutations on the subtree to file
                    auto subtree_mutations_filename = outdir + ""/subtree-"" + std::to_string(num_subtrees) + ""-mutations.txt"";
                    if (num_trees > 1) {
                        subtree_mutations_filename = outdir + ""/"" + ""tree-"" + std::to_string(t_idx+1) + ""-subtree-"" + std::to_string(num_subtrees) + ""-mutations.txt"";;
                    }
                    fprintf(stderr, ""Writing list of mutations at the nodes of subtree %d to file %s\\n"", num_subtrees, subtree_mutations_filename.c_str());
                    FILE* subtree_mutations_file = fopen(subtree_mutations_filename.c_str(), ""w"");

                    for (auto n: new_T.depth_first_expansion()) {
                        size_t tot_mutations = n->mutations.size();
                        fprintf(subtree_mutations_file, ""%s: "", n->identifier.c_str());
                        for (size_t idx = 0; idx < tot_mutations; idx++) {
                            auto m = n->mutations[idx];
                            fprintf(subtree_mutations_file, ""%s"", m.get_string().c_str());
                            if (idx+1 <tot_mutations) {
                                fprintf(subtree_mutations_file, "","");
                            }
                        }
                        fprintf(subtree_mutations_file, ""\\n"");
                    }

                    fclose(subtree_mutations_file);

                    // Expand internal nodes that are condensed
                    bool has_condensed = false;
                    FILE* subtree_expanded_file = NULL;
                    for (auto l: new_T.get_leaves()) {
                        if (T->condensed_nodes.find(l->identifier) != T->condensed_nodes.end()) {
                            if (!has_condensed) {
                                auto subtree_expanded_filename = outdir + ""/subtree-"" + std::to_string(num_subtrees) + ""-expanded.txt"";
                                if (num_trees > 1) {
                                    subtree_expanded_filename = outdir + ""/tree-"" + std::to_string(1+t_idx) + ""-subtree-"" + std::to_string(num_subtrees) + ""-expanded.txt"";
                                }
                                fprintf(stderr, ""Subtree %d has condensed nodes.\\nExpanding the condensed nodes for subtree %d in file %s\\n"", num_subtrees, num_subtrees, subtree_expanded_filename.c_str());
                                subtree_expanded_file = fopen(subtree_expanded_filename.c_str(), ""w"");
                                has_condensed = true;
                            }
                            fprintf(subtree_expanded_file, ""%s: "", l->identifier.c_str());
                            for (auto n: T->condensed_nodes[l->identifier]) {
                                fprintf(subtree_expanded_file, ""%s "", n.c_str());
                            }
                            fprintf(subtree_expanded_file, ""\\n"");
                        }
                    }
                    if (has_condensed) {
                        fclose(subtree_expanded_file);
                    }
                    break;
                }
            }
            fprintf(stderr, ""Completed in %ld msec \\n\\n"", timer.Stop());
        }
    }

    // Print warning message with a list of all samples placed with low
    // confidence (>=2 parsimony-optimal placements)
    if (low_confidence_samples.size() > 0) {
        fprintf(stderr, ""WARNING: Following samples had multiple possibilities of parsimony-optimal placements:\\n"");
        for (auto lcs: low_confidence_samples) { 
            fprintf(stderr, ""%s\\n"", lcs.c_str());
        }
    }

    // Store mutation-annotated tree to a protobuf file if user has asked for it
    if (dout_filename != """") {

        timer.Start();

        fprintf(stderr, ""Saving mutation-annotated tree object to file (after condensing identical sequences) %s\\n"", dout_filename.c_str());
        if (num_trees > 1) {
            fprintf(stderr, ""WARNING: --multiple-placements option was used but only the first mutation-annotated tree object will be saved to file.\\n"");
        }

        Parsimony::data data;

        T = &optimal_trees[0];
        // Recondense tree with new samples
        if (T->condensed_nodes.size() > 0) {
            T->uncondense_leaves();
        }
        T->condense_leaves();
        MAT::save_mutation_annotated_tree(*T, dout_filename);
        
        fprintf(stderr, ""Completed in %ld msec \\n\\n"", timer.Stop());
    }
    
    /*
    // When multiple placements was used, print the tree names with lowest total
    // parsimony scores
    if (max_trees > 1) {
        size_t min_parsimony_score = *std::min_element(tree_parsimony_scores.begin(), tree_parsimony_scores.end());
        if (optimal_trees.size() > 1) {
            fprintf(stderr, ""Trees below have the lowest parsimony score of %zu among all trees: \\n"", min_parsimony_score);
            for (size_t t_idx = 0; t_idx < optimal_trees.size(); t_idx++) {
                if (tree_parsimony_scores[t_idx] == min_parsimony_score) {
                    fprintf(stderr, ""tree-%zu "", t_idx+1);
                }
            }
            fprintf(stderr, ""\\n\\n"");
        }
        else {
            fprintf(stderr, ""Single best tree with a parsimony score of %zu was found during multiple placements.\\n\\n"", min_parsimony_score);;
        }
    }
    */

    google::protobuf::ShutdownProtobufLibrary();

#if SAVE_PROFILE == 1
    Instrumentor::Get().EndSession();
#endif

    return 0;
}

",16374,True,3009.487212322544,median
"// Copyright 2020 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include ""../mem_config.h""

#include <lib/zbitl/error_string.h>
#include <lib/zbitl/image.h>
#include <lib/zbitl/items/mem_config.h>
#include <lib/zbitl/memory.h>
#include <lib/zbitl/storage_traits.h>
#include <lib/zbitl/view.h>
#include <zircon/boot/e820.h>
#include <zircon/boot/image.h>

#include <efi/boot-services.h>
#include <efi/runtime-services.h>
#include <fbl/array.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>

namespace {

// GMock matcher to determine if a given zbitl::View result was successful,
// printing the error if not.
//
// Can be used as: EXPECT_THAT(view.operation(), IsOk());
MATCHER(IsOk, """") {
  if (arg.is_ok()) {
    return true;
  }
  *result_listener << ""had error: "" << zbitl::ViewErrorString(arg.error_value());
  return false;
}

// As above, but also matches against the value:
//
// EXPECT_THAT(view.operation(), IsOkAndHolds(Eq(3u)));
template <typename X>
auto IsOkAndHolds(X matcher) {
  return ::testing::AllOf(
      IsOk(), ::testing::ResultOf([](const auto& val) { return val.value(); }, matcher));
}

using ZbiMemoryImage = zbitl::Image<fbl::Array<std::byte>>;

// Create an empty zbitl::Image that can be written to.
ZbiMemoryImage CreateImage() {
  ZbiMemoryImage image;

  // Initialise the ZBI header
  auto result = image.clear();
  ZX_ASSERT(result.is_ok());

  return image;
}

// Return a zbitl::View of the given ZbiMemoryImage.
zbitl::View<zbitl::ByteView> AsView(const ZbiMemoryImage& image) {
  return zbitl::View(zbitl::ByteView(image.storage().data(), image.storage().size()));
}

// Append the given payload to a zbitl::Image.
//
// Abort on error.
void AppendPayload(ZbiMemoryImage& zbi, uint32_t type, zbitl::ByteView bytes) {
  auto result = zbi.Append(zbi_header_t{.type = type}, bytes);
  ZX_ASSERT(result.is_ok());
}

// Append the given objects together as a series of bytes.
template <typename... T>
std::basic_string<std::byte> JoinBytes(const T&... object) {
  std::basic_string<std::byte> result;

  // Add the bytes from a single item to |result|.
  auto add_item = [&result](const auto& x) {
    zbitl::ByteView object_bytes = zbitl::AsBytes(x);
    result.append(object_bytes);
  };

  // Add each item.
  (add_item(object), ...);

  return result;
}

// Determine if two `zbi_mem_range_t` values are the same.
bool MemRangeEqual(const zbi_mem_range_t& a, const zbi_mem_range_t& b) {
  return std::tie(a.length, a.paddr, a.reserved, a.type) ==
         std::tie(b.length, b.paddr, b.reserved, b.type);
}

TEST(ToMemRange, Efi) {
  constexpr efi_memory_descriptor efi{
      .Type = EfiConventionalMemory,
      .PhysicalStart = 0x1234'abcd'ffff'0000,
      .VirtualStart = 0xaaaa'aaaa'aaaa'aaaa,
      .NumberOfPages = 100,
      .Attribute = EFI_MEMORY_MORE_RELIABLE,
  };
  constexpr zbi_mem_range_t expected{
      .paddr = 0x1234'abcd'ffff'0000,
      .length = 409600,  // ZX_PAGE_SIZE * 100
      .type = ZBI_MEM_RANGE_RAM,
  };
  EXPECT_TRUE(MemRangeEqual(zbitl::internal::ToMemRange(efi), expected));
}

TEST(ToMemRange, EfiReservedMemory) {
  auto efi = efi_memory_descriptor{
      .Type = EfiMemoryMappedIO,
      .PhysicalStart = 0x0,
      .VirtualStart = 0x0,
      .NumberOfPages = 1,
      .Attribute = 0,
  };
  EXPECT_EQ(zbitl::internal::ToMemRange(efi).type, static_cast<uint32_t>(ZBI_MEM_RANGE_RESERVED));
}

TEST(ToMemRange, E820) {
  auto input = e820entry_t{
      .addr = 0x1234'abcd'ffff'0000,
      .size = 0x10'0000,
      .type = E820_RAM,
  };
  auto expected = zbi_mem_range_t{
      .paddr = 0x1234'abcd'ffff'0000,
      .length = 0x10'0000,
      .type = ZBI_MEM_RANGE_RAM,
  };
  EXPECT_TRUE(MemRangeEqual(zbitl::internal::ToMemRange(input), expected));
}

TEST(MemRangeIterator, DefaultContainer) {
  zbitl::MemRangeTable container;

  EXPECT_EQ(container.begin(), container.end());
  EXPECT_THAT(container.take_error(), IsOk());
}

TEST(MemRangeIterator, EmptyZbi) {
  ZbiMemoryImage zbi = CreateImage();
  zbitl::MemRangeTable container{AsView(zbi)};

  // Expect nothing to be found.
  EXPECT_EQ(container.begin(), container.end());
  EXPECT_THAT(container.size(), IsOkAndHolds(0u));
  EXPECT_THAT(container.take_error(), IsOk());
}

TEST(MemRangeIterator, BadZbi) {
  zbi_header_t header = ZBI_CONTAINER_HEADER(0);
  header.crc32 = 0xffffffff;  // bad CRC.
  zbitl::View<zbitl::ByteView> view(zbitl::AsBytes(header));
  zbitl::MemRangeTable container{view};

  // Expect nothing to be found.
  EXPECT_EQ(container.begin(), container.end());

  // Expect an error.
  auto error = container.take_error();
  ASSERT_TRUE(error.is_error());
  EXPECT_EQ(error.error_value().zbi_error, ""bad crc32 field in item without CRC"");

  // Expect size() to return an error.
  auto size_error = container.size();
  ASSERT_TRUE(size_error.is_error());
  EXPECT_EQ(size_error.error_value().zbi_error, ""bad crc32 field in item without CRC"");
}

TEST(MemRangeIterator, RequireErrorToBeCalled) {
  ZbiMemoryImage zbi = CreateImage();

  // Iterate through an empty item and then destroy it without calling Error().
  ASSERT_DEATH(
      {
        zbitl::MemRangeTable container{AsView(zbi)};

        // Expect nothing to be found.
        EXPECT_EQ(container.begin(), container.end());

        // Don't call `take_error`: expect process death during object destruction.
      },
      ""destroyed .* without check"");
}

TEST(MemRangeIterator, NoErrorNeededAfterMove) {
  ZbiMemoryImage zbi = CreateImage();
  zbitl::MemRangeTable container{AsView(zbi)};

  // Iterate through an empty item.
  container.begin();

  // Move the value, and check the error in its new location. We shouldn't
  // need to check the first any longer.
  zbitl::MemRangeTable new_container = std::move(container);
  EXPECT_THAT(new_container.take_error(), IsOk());
}

TEST(MemRangeIterator, EmptyPayload) {
  // Construct a ZBI with an empty E820 memory map.
  ZbiMemoryImage zbi = CreateImage();
  AppendPayload(zbi, ZBI_TYPE_E820_TABLE, {});

  // Expect nothing to be found.
  zbitl::MemRangeTable container{AsView(zbi)};
  EXPECT_EQ(container.begin(), container.end());
  EXPECT_THAT(container.take_error(), IsOk());
}

TEST(MemRangeIterator, EfiItem) {
  // Construct a ZBI with a single payload consisting of EFI entries.
  ZbiMemoryImage zbi = CreateImage();
  AppendPayload(zbi, ZBI_TYPE_EFI_MEMORY_MAP,
                JoinBytes(uint64_t{sizeof(efi_memory_descriptor)},
                          efi_memory_descriptor{
                              .PhysicalStart = 0x1000,
                              .NumberOfPages = 1,
                          },
                          efi_memory_descriptor{
                              .PhysicalStart = 0x2000,
                              .NumberOfPages = 1,
                          }));

  // Ensure the entries are correct.
  zbitl::MemRangeTable container{AsView(zbi)};
  EXPECT_THAT(container.size(), IsOkAndHolds(2u));
  std::vector<zbi_mem_range_t> ranges(container.begin(), container.end());
  ASSERT_TRUE(container.take_error().is_ok());
  ASSERT_EQ(ranges.size(), 2u);
  EXPECT_EQ(ranges[0].paddr, 0x1000u);
  EXPECT_EQ(ranges[1].paddr, 0x2000u);
}

TEST(MemRangeIterator, ZbiMemRangeItem) {
  // Construct a ZBI with a single payload consisting of zbi_mem_range_t entries.
  ZbiMemoryImage zbi = CreateImage();
  AppendPayload(zbi, ZBI_TYPE_MEM_CONFIG,
                JoinBytes(
                    zbi_mem_range_t{
                        .paddr = 0x1000,
                        .length = 0x1000,
                    },
                    zbi_mem_range_t{
                        .paddr = 0x2000,
                        .length = 0x1000,
                    }));

  // Ensure the entries are correct.
  zbitl::MemRangeTable container{AsView(zbi)};
  EXPECT_THAT(container.size(), IsOkAndHolds(2u));
  std::vector<zbi_mem_range_t> ranges(container.begin(), container.end());
  ASSERT_TRUE(container.take_error().is_ok());
  ASSERT_EQ(ranges.size(), 2u);
  EXPECT_EQ(ranges[0].paddr, 0x1000u);
  EXPECT_EQ(ranges[1].paddr, 0x2000u);
}

TEST(MemRangeIterator, E820Item) {
  // Construct a ZBI with a single payload consisting of e820entry_t entries.
  ZbiMemoryImage zbi = CreateImage();
  AppendPayload(zbi, ZBI_TYPE_E820_TABLE,
                JoinBytes(
                    e820entry_t{
                        .addr = 0x1000,
                        .size = 0x1000,
                    },
                    e820entry_t{
                        .addr = 0x2000,
                        .size = 0x1000,
                    }));

  // Ensure the entries are correct.
  zbitl::MemRangeTable container{AsView(zbi)};
  EXPECT_THAT(container.size(), IsOkAndHolds(2u));
  std::vector<zbi_mem_range_t> ranges(container.begin(), container.end());
  ASSERT_TRUE(container.take_error().is_ok());
  ASSERT_EQ(ranges.size(), 2u);
  EXPECT_EQ(ranges[0].paddr, 0x1000u);
  EXPECT_EQ(ranges[1].paddr, 0x2000u);
}

TEST(MemRangeIterator, MixedItems) {
  // Construct a ZBI with a mixed set of payloads.
  ZbiMemoryImage zbi = CreateImage();
  AppendPayload(zbi, ZBI_TYPE_E820_TABLE,
                zbitl::AsBytes(e820entry_t{
                    .addr = 0x1000,
                    .size = 0x1000,
                }));
  AppendPayload(zbi, ZBI_TYPE_MEM_CONFIG,
                zbitl::AsBytes(zbi_mem_range_t{
                    .paddr = 0x2000,
                    .length = 0x2000,
                }));
  AppendPayload(zbi, ZBI_TYPE_EFI_MEMORY_MAP,
                JoinBytes(uint64_t{sizeof(efi_memory_descriptor)}, efi_memory_descriptor{
                                                                       .PhysicalStart = 0x3000,
                                                                       .NumberOfPages = 3,
                                                                   }));

  // Ensure the entries are correct.
  zbitl::MemRangeTable container{AsView(zbi)};
  EXPECT_THAT(container.size(), IsOkAndHolds(3u));
  std::vector<zbi_mem_range_t> ranges(container.begin(), container.end());
  ASSERT_TRUE(container.take_error().is_ok());
  ASSERT_EQ(ranges.size(), 3u);
  EXPECT_EQ(ranges[0].paddr, 0x1000u);
  EXPECT_EQ(ranges[1].paddr, 0x2000u);
  EXPECT_EQ(ranges[2].paddr, 0x3000u);
}

TEST(MemRangeIterator, OtherItems) {
  // Construct a ZBI with non-memory payloads.
  ZbiMemoryImage zbi = CreateImage();
  AppendPayload(zbi, ZBI_TYPE_PLATFORM_ID, {});
  AppendPayload(zbi, ZBI_TYPE_PLATFORM_ID, {});
  AppendPayload(zbi, ZBI_TYPE_MEM_CONFIG,
                zbitl::AsBytes(zbi_mem_range_t{
                    .paddr = 0x1000,
                    .length = 0x1000,
                }));

  // Ensure the entries are correct.
  zbitl::MemRangeTable container{AsView(zbi)};
  EXPECT_THAT(container.size(), IsOkAndHolds(1u));
  std::vector<zbi_mem_range_t> ranges(container.begin(), container.end());
  ASSERT_TRUE(container.take_error().is_ok());
  ASSERT_EQ(ranges.size(), 1u);
  EXPECT_EQ(ranges[0].paddr, 0x1000u);
}

// Call size() in the middle of iterating through a ZBI.
TEST(MemRangeIterator, SizeDuringIteration) {
  ZbiMemoryImage zbi = CreateImage();
  AppendPayload(zbi, ZBI_TYPE_E820_TABLE,
                zbitl::AsBytes(e820entry_t{
                    .addr = 0x1000,
                    .size = 0x1000,
                }));
  AppendPayload(zbi, ZBI_TYPE_MEM_CONFIG,
                zbitl::AsBytes(zbi_mem_range_t{
                    .paddr = 0x2000,
                    .length = 0x2000,
                }));

  // Start iteration.
  zbitl::MemRangeTable container{AsView(zbi)};
  auto it = container.begin();
  EXPECT_EQ((*it).paddr, 0x1000u);

  // Call size.
  EXPECT_THAT(container.size(), IsOkAndHolds(2u));

  // Finish the iteration.
  EXPECT_EQ((*it).paddr, 0x1000u);
  ++it;
  EXPECT_EQ((*it).paddr, 0x2000u);
  ++it;
  EXPECT_EQ(it, container.end());
  EXPECT_TRUE(container.take_error().is_ok());
}

TEST(MemRangeIterator, EfiRealData) {
  // Binary dump of the EFI table produced by OVMF (an open source EFI
  // implementation) running on QEMU.
  //
  // Collected by performing a hexdump to serial of the
  // ""ZBI_TYPE_EFI_MEMORY_MAP"" ZBI entry of an EFI platform on boot.
  constexpr uint8_t efi_table[] = {
      0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x9f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x01, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x63, 0x6c, 0x07, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30,
      0x06, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xbb,
      0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0xe0, 0xf1, 0x7b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xf3, 0x7b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x46, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x48, 0x7c, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa0, 0x4f, 0x7e, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0,
      0x52, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x53, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x81, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x9b, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0xa7, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xa5, 0x7e, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0xa6, 0x7e, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0,
      0xa7, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x15,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x10, 0xa9, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x8a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0xb1, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0xc4, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xcd, 0x7e, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0xa1, 0x7f, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd0,
      0xa1, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e,
      0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0xb0, 0xb9, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0xbc, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xbe, 0x7f, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0xbf, 0x7f, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0,
      0xbf, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0xf0, 0xbf, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0xe7, 0x7f, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0xe9, 0x7f, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa0,
      0xea, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0xb0, 0xec, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xed, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6, 0x7f, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0xc0, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  };
  zbitl::ByteView payload{reinterpret_cast<const std::byte*>(efi_table), sizeof(efi_table)};

  // Construct a ZBI with the EFI payload.
  ZbiMemoryImage zbi = CreateImage();
  AppendPayload(zbi, ZBI_TYPE_EFI_MEMORY_MAP, payload);

  // Ensure we read the correct number of entries.
  zbitl::MemRangeTable container{AsView(zbi)};
  std::vector<zbi_mem_range_t> ranges(container.begin(), container.end());
  ASSERT_TRUE(container.take_error().is_ok());
  ASSERT_EQ(ranges.size(), 40u);

  // Verify the first and last entries.
  EXPECT_TRUE(MemRangeEqual(
      zbi_mem_range_t{
          .paddr = 0,
          .length = 4096,
          .type = ZBI_MEM_RANGE_RAM,
      },
      ranges.front()));
  EXPECT_TRUE(MemRangeEqual(
      zbi_mem_range_t{
          .paddr = 0xffc00000,
          .length = 0x400000,
          .type = ZBI_MEM_RANGE_RESERVED,
      },
      ranges.back()));
}

TEST(MemRangeMerger, Empty) {
  std::vector<zbi_mem_range_t> input{};
  zbitl::MemRangeMerger merger(input.begin(), input.end());
  EXPECT_EQ(merger.begin(), merger.end());
}

TEST(MemRangeMerger, SingleItem) {
  // Create an input with just a single range.
  std::vector<zbi_mem_range_t> input = {
      zbi_mem_range_t{
          .paddr = 1,
          .length = 2,
          .type = 3,
      },
  };
  zbitl::MemRangeMerger merger(input.begin(), input.end());
  EXPECT_NE(merger.begin(), merger.end());

  // Check first element.
  auto it = merger.begin();
  EXPECT_EQ(it->paddr, 1u);
  EXPECT_EQ(it->length, 2u);
  EXPECT_EQ(it->type, 3u);

  // Should be no more elements.
  ++it;
  EXPECT_EQ(it, merger.end());
}

TEST(MemRangeMerger, MergeItems) {
  // Create an input with multiple ranges to be merged.
  std::vector<zbi_mem_range_t> input = {
      zbi_mem_range_t{
          .paddr = 0,
          .length = 100,
          .type = 1,
      },
      zbi_mem_range_t{
          .paddr = 100,
          .length = 200,
          .type = 1,
      },
      zbi_mem_range_t{
          .paddr = 300,
          .length = 100,
          .type = 1,
      },
  };
  zbitl::MemRangeMerger merger(input.begin(), input.end());

  // Merge the items.
  std::vector<zbi_mem_range_t> result(merger.begin(), merger.end());

  // Ensure we got the correctly merged results.
  ASSERT_EQ(result.size(), 1u);
  EXPECT_EQ(result[0].paddr, 0u);
  EXPECT_EQ(result[0].length, 400u);
  EXPECT_EQ(result[0].type, 1u);
}

TEST(MemRangeMerger, ShouldNotCombineNonContiguousItems) {
  // Ensure we don't merge non-contiguous items.
  std::vector<zbi_mem_range_t> input = {
      zbi_mem_range_t{
          .paddr = 0,
          .length = 1,
          .type = 1,
      },
      zbi_mem_range_t{
          .paddr = 2,  // skips byte 1; should not be merged.
          .length = 1,
          .type = 1,
      },
      zbi_mem_range_t{
          .paddr = 3,  // not the same type; should not be merged.
          .length = 1,
          .type = 2,
      },
  };
  zbitl::MemRangeMerger merger(input.begin(), input.end());

  // Merge the items.
  std::vector<zbi_mem_range_t> result(merger.begin(), merger.end());

  // Ensure the input matches the output.
  ASSERT_EQ(result.size(), input.size());
  for (size_t i = 0; i < input.size(); i++) {
    EXPECT_EQ(input[i].paddr, result[i].paddr);
    EXPECT_EQ(input[i].length, result[i].length);
    EXPECT_EQ(input[i].type, result[i].type);
  }
}

TEST(MemRangeMerger, MemRangeTableIterator) {
  // Create a MemRangeTable, and use it as our input.
  ZbiMemoryImage zbi = CreateImage();
  AppendPayload(zbi, ZBI_TYPE_EFI_MEMORY_MAP,
                JoinBytes(uint64_t{sizeof(efi_memory_descriptor)},
                          efi_memory_descriptor{
                              .Type = 1,
                              .PhysicalStart = 0x1000,
                              .NumberOfPages = 1,
                          },
                          efi_memory_descriptor{
                              .Type = 1,
                              .PhysicalStart = 0x2000,
                              .NumberOfPages = 2,
                          }));

  // Merge elements together.
  zbitl::MemRangeTable container{AsView(zbi)};
  zbitl::MemRangeMerger merger(container.begin(), container.end());
  std::vector<zbi_mem_range_t> ranges(merger.begin(), merger.end());
  ASSERT_TRUE(container.take_error().is_ok());
  ASSERT_EQ(ranges.size(), 1u);
  EXPECT_EQ(ranges[0].paddr, 0x1000u);
  EXPECT_EQ(ranges[0].length, 0x3000u);
  EXPECT_EQ(ranges[0].type, 1u);
}

}  // namespace
",16344,True,5426.307714520779,median
"[[oauth2resourceserver]]
== OAuth 2.0 Resource Server

Spring Security supports protecting endpoints using two forms of OAuth 2.0 https://tools.ietf.org/html/rfc6750.html[Bearer Tokens]:

* https://tools.ietf.org/html/rfc7519[JWT]
* Opaque Tokens

This is handy in circumstances where an application has delegated its authority management to an https://tools.ietf.org/html/rfc6749[authorization server] (for example, Okta or Ping Identity).
This authorization server can be consulted by resource servers to authorize requests.

[NOTE]
====
Working samples for both {gh-samples-url}/boot/oauth2resourceserver[JWTs] and {gh-samples-url}/boot/oauth2resourceserver-opaque[Opaque Tokens] are available in the {gh-samples-url}[Spring Security repository].
====

=== Dependencies

Most Resource Server support is collected into `spring-security-oauth2-resource-server`.
However, the support for decoding and verifying JWTs is in `spring-security-oauth2-jose`, meaning that both are necessary in order to have a working resource server that supports JWT-encoded Bearer Tokens.

[[oauth2resourceserver-jwt-minimalconfiguration]]
=== Minimal Configuration for JWTs

When using https://spring.io/projects/spring-boot[Spring Boot], configuring an application as a resource server consists of two basic steps.
First, include the needed dependencies and second, indicate the location of the authorization server.

==== Specifying the Authorization Server

In a Spring Boot application, to specify which authorization server to use, simply do:

[source,yml]
----
spring:
  security:
    oauth2:
      resourceserver:
        jwt:
          issuer-uri: https://idp.example.com/issuer
----

Where `https://idp.example.com/issuer` is the value contained in the `iss` claim for JWT tokens that the authorization server will issue.
Resource Server will use this property to further self-configure, discover the authorization server's public keys, and subsequently validate incoming JWTs.

[NOTE]
To use the `issuer-uri` property, it must also be true that one of `https://idp.example.com/issuer/.well-known/openid-configuration`, `https://idp.example.com/.well-known/openid-configuration/issuer`, or `https://idp.example.com/.well-known/oauth-authorization-server/issuer` is a supported endpoint for the authorization server.
This endpoint is referred to as a https://openid.net/specs/openid-connect-discovery-1_0.html#ProviderConfig[Provider Configuration] endpoint or a https://tools.ietf.org/html/rfc8414#section-3[Authorization Server Metadata] endpoint.

And that's it!

==== Startup Expectations

When this property and these dependencies are used, Resource Server will automatically configure itself to validate JWT-encoded Bearer Tokens.

It achieves this through a deterministic startup process:

1. Hit the Provider Configuration or Authorization Server Metadata endpoint, processing the response for the `jwks_url` property
2. Configure the validation strategy to query `jwks_url` for valid public keys
3. Configure the validation strategy to validate each JWTs `iss` claim against `https://idp.example.com`.

A consequence of this process is that the authorization server must be up and receiving requests in order for Resource Server to successfully start up.

[NOTE]
If the authorization server is down when Resource Server queries it (given appropriate timeouts), then startup will fail.

==== Runtime Expectations

Once the application is started up, Resource Server will attempt to process any request containing an `Authorization: Bearer` header:

[source,html]
----
GET / HTTP/1.1
Authorization: Bearer some-token-value # Resource Server will process this
----

So long as this scheme is indicated, Resource Server will attempt to process the request according to the Bearer Token specification.

Given a well-formed JWT, Resource Server will:

1. Validate its signature against a public key obtained from the `jwks_url` endpoint during startup and matched against the JWTs header
2. Validate the JWTs `exp` and `nbf` timestamps and the JWTs `iss` claim, and
3. Map each scope to an authority with the prefix `SCOPE_`.

[NOTE]
As the authorization server makes available new keys, Spring Security will automatically rotate the keys used to validate the JWT tokens.

The resulting `Authentication#getPrincipal`, by default, is a Spring Security `Jwt` object, and `Authentication#getName` maps to the JWT's `sub` property, if one is present.

From here, consider jumping to:

<<oauth2resourceserver-jwt-jwkseturi,How to Configure without Tying Resource Server startup to an authorization server's availability>>

<<oauth2resourceserver-jwt-sansboot,How to Configure without Spring Boot>>

[[oauth2resourceserver-jwt-jwkseturi]]
=== Specifying the Authorization Server JWK Set Uri Directly

If the authorization server doesn't support any configuration endpoints, or if Resource Server must be able to start up independently from the authorization server, then the `jwk-set-uri` can be supplied as well:

[source,yaml]
----
spring:
  security:
    oauth2:
      resourceserver:
        jwt:
          issuer-uri: https://idp.example.com
          jwk-set-uri: https://idp.example.com/.well-known/jwks.json
----

[NOTE]
The JWK Set uri is not standardized, but can typically be found in the authorization server's documentation

Consequently, Resource Server will not ping the authorization server at startup.
We still specify the `issuer-uri` so that Resource Server still validates the `iss` claim on incoming JWTs.

[NOTE]
This property can also be supplied directly on the <<oauth2resourceserver-jwt-jwkseturi-dsl,DSL>>.

[[oauth2resourceserver-jwt-sansboot]]
=== Overriding or Replacing Boot Auto Configuration

There are two `@Bean` s that Spring Boot generates on Resource Server's behalf.

The first is a `WebSecurityConfigurerAdapter` that configures the app as a resource server. When including `spring-security-oauth2-jose`, this `WebSecurityConfigurerAdapter` looks like:

[source,java]
----
protected void configure(HttpSecurity http) {
    http
        .authorizeRequests()
            .anyRequest().authenticated()
            .and()
        .oauth2ResourceServer(OAuth2ResourceServerConfigurer::jwt)
}
----

If the application doesn't expose a `WebSecurityConfigurerAdapter` bean, then Spring Boot will expose the above default one.

Replacing this is as simple as exposing the bean within the application:

[source,java]
----
@EnableWebSecurity
public class MyCustomSecurityConfiguration extends WebSecurityConfigurerAdapter {
    protected void configure(HttpSecurity http) {
        http
            .authorizeRequests()
                .mvcMatchers(""/messages/**"").hasAuthority(""SCOPE_message:read"")
                .anyRequest().authenticated()
                .and()
            .oauth2ResourceServer()
                .jwt()
                    .jwtAuthenticationConverter(myConverter());
    }
}
----

The above requires the scope of `message:read` for any URL that starts with `/messages/`.

Methods on the `oauth2ResourceServer` DSL will also override or replace auto configuration.

For example, the second `@Bean` Spring Boot creates is a `JwtDecoder`, which decodes `String` tokens into validated instances of `Jwt`:

[source,java]
----
@Bean
public JwtDecoder jwtDecoder() {
    return JwtDecoders.fromIssuerLocation(issuerUri);
}
----

[NOTE]
Calling `{security-api-url}org/springframework/security/oauth2/jwt/JwtDecoders.html#fromIssuerLocation-java.lang.String-[JwtDecoders#fromIssuerLocation]` is what invokes the Provider Configuration or Authorization Server Metadata endpoint in order to derive the JWK Set Uri.

If the application doesn't expose a `JwtDecoder` bean, then Spring Boot will expose the above default one.

And its configuration can be overridden using `jwkSetUri()` or replaced using `decoder()`.

[[oauth2resourceserver-jwt-jwkseturi-dsl]]
==== Using `jwkSetUri()`

An authorization server's JWK Set Uri can be configured <<oauth2resourceserver-jwt-jwkseturi,as a configuration property>> or it can be supplied in the DSL:

[source,java]
----
@EnableWebSecurity
public class DirectlyConfiguredJwkSetUri extends WebSecurityConfigurerAdapter {
    protected void configure(HttpSecurity http) {
        http
            .authorizeRequests()
                .anyRequest().authenticated()
                .and()
            .oauth2ResourceServer()
                .jwt()
                    .jwkSetUri(""https://idp.example.com/.well-known/jwks.json"");
    }
}
----

Using `jwkSetUri()` takes precedence over any configuration property.

[[oauth2resourceserver-jwt-decoder-dsl]]
==== Using `decoder()`

More powerful than `jwkSetUri()` is `decoder()`, which will completely replace any Boot auto configuration of `JwtDecoder`:

[source,java]
----
@EnableWebSecurity
public class DirectlyConfiguredJwtDecoder extends WebSecurityConfigurerAdapter {
    protected void configure(HttpSecurity http) {
        http
            .authorizeRequests()
                .anyRequest().authenticated()
                .and()
            .oauth2ResourceServer()
                .jwt()
                    .decoder(myCustomDecoder());
    }
}
----

This is handy when deeper configuration, like <<oauth2resourceserver-jwt-validation,validation>>, <<oauth2resourceserver-jwt-claimsetmapping,mapping>>, or <<oauth2resourceserver-jwt-timeouts,request timeouts>>, is necessary.

[[oauth2resourceserver-jwt-decoder-bean]]
==== Exposing a `JwtDecoder` `@Bean`

Or, exposing a `JwtDecoder` `@Bean` has the same effect as `decoder()`:

[source,java]
----
@Bean
public JwtDecoder jwtDecoder() {
    return NimbusJwtDecoder.withJwkSetUri(jwkSetUri).build();
}
----

[[oauth2resourceserver-jwt-decoder-algorithm]]
=== Configuring Trusted Algorithms

By default, `NimbusJwtDecoder`, and hence Resource Server, will only trust and verify tokens using `RS256`.

You can customize this via <<oauth2resourceserver-jwt-boot-algorithm,Spring Boot>>, <<oauth2resourceserver-jwt-decoder-builder,the NimbusJwtDecoder builder>>, or from the <<oauth2resourceserver-jwt-decoder-jwk-response,JWK Set response>>.

[[oauth2resourceserver-jwt-boot-algorithm]]
==== Via Spring Boot

The simplest way to set the algorithm is as a property:

[source,yaml]
----
spring:
  security:
    oauth2:
      resourceserver:
        jwt:
          jws-algorithm: RS512
          jwk-set-uri: https://idp.example.org/.well-known/jwks.json
----

[[oauth2resourceserver-jwt-decoder-builder]]
==== Using a Builder

For greater power, though, we can use a builder that ships with `NimbusJwtDecoder`:

[source,java]
----
@Bean
JwtDecoder jwtDecoder() {
    return NimbusJwtDecoder.fromJwkSetUri(this.jwkSetUri)
            .jwsAlgorithm(RS512).build();
}
----

Calling `jwsAlgorithm` more than once will configure `NimbusJwtDecoder` to trust more than one algorithm, like so:

[source,java]
----
@Bean
JwtDecoder jwtDecoder() {
    return NimbusJwtDecoder.fromJwkSetUri(this.jwkSetUri)
            .jwsAlgorithm(RS512).jwsAlgorithm(EC512).build();
}
----

Or, you can call `jwsAlgorithms`:

[source,java]
----
@Bean
JwtDecoder jwtDecoder() {
    return NimbusJwtDecoder.fromJwkSetUri(this.jwkSetUri)
            .jwsAlgorithms(algorithms -> {
                    algorithms.add(RS512);
                    algorithms.add(EC512);
            }).build();
}
----

[[oauth2resourceserver-jwt-decoder-jwk-response]]
==== From JWK Set response

Since Spring Security's JWT support is based off of Nimbus, you can use all it's great features as well.

For example, Nimbus has a `JWSKeySelector` implementation that will select the set of algorithms based on the JWK Set URI response.
You can use it to generate a `NimbusJwtDecoder` like so:

```java
@Bean
public JwtDecoder jwtDecoder() {
    // makes a request to the JWK Set endpoint
    JWSKeySelector<SecurityContext> jwsKeySelector =
            JWSAlgorithmFamilyJWSKeySelector.fromJWKSetURL(this.jwkSetUrl);

    DefaultJWTProcessor<SecurityContext> jwtProcessor =
            new DefaultJWTProcessor<>();
    jwtProcessor.setJWSKeySelector(jwsKeySelector);

    return new NimbusJwtDecoder(jwtProcessor);
}
```

[[oauth2resourceserver-jwt-decoder-public-key]]
=== Trusting a Single Asymmetric Key

Simpler than backing a Resource Server with a JWK Set endpoint is to hard-code an RSA public key.
The public key can be provided via <<oauth2resourceserver-jwt-decoder-public-key-boot,Spring Boot>> or by <<oauth2resourceserver-jwt-decoder-public-key-builder,Using a Builder>>.

[[oauth2resourceserver-jwt-decoder-public-key-boot]]
==== Via Spring Boot

Specifying a key via Spring Boot is quite simple.
The key's location can be specified like so:

[source,yaml]
----
spring:
  security:
    oauth2:
      resourceserver:
        jwt:
          public-key-location: classpath:my-key.pub
----

Or, to allow for a more sophisticated lookup, you can post-process the `RsaKeyConversionServicePostProcessor`:

[source,java]
----
@Bean
BeanFactoryPostProcessor conversionServiceCustomizer() {
    return beanFactory ->
        beanFactory.getBean(RsaKeyConversionServicePostProcessor.class)
                .setResourceLoader(new CustomResourceLoader());
}
----

Specify your key's location:

```yaml
key.location: hfds://my-key.pub
```

And then autowire the value:

```java
@Value(""${key.location}"")
RSAPublicKey key;
```

[[oauth2resourceserver-jwt-decoder-public-key-builder]]
==== Using a Builder

To wire an `RSAPublicKey` directly, you can simply use the appropriate `NimbusJwtDecoder` builder, like so:

```java
@Bean
public JwtDecoder jwtDecoder() {
    return NimbusJwtDecoder.withPublicKey(this.key).build();
}
```

[[oauth2resourceserver-jwt-decoder-secret-key]]
=== Trusting a Single Symmetric Key

Using a single symmetric key is also simple.
You can simply load in your `SecretKey` and use the appropriate `NimbusJwtDecoder` builder, like so:

[source,java]
----
@Bean
public JwtDecoder jwtDecoder() {
    return NimbusJwtDecoder.withSecretKey(this.key).build();
}
----

[[oauth2resourceserver-jwt-authorization]]
=== Configuring Authorization

A JWT that is issued from an OAuth 2.0 Authorization Server will typically either have a `scope` or `scp` attribute, indicating the scopes (or authorities) it's been granted, for example:

`{ ..., ""scope"" : ""messages contacts""}`

When this is the case, Resource Server will attempt to coerce these scopes into a list of granted authorities, prefixing each scope with the string ""SCOPE_"".

This means that to protect an endpoint or method with a scope derived from a JWT, the corresponding expressions should include this prefix:

[source,java]
----
@EnableWebSecurity
public class DirectlyConfiguredJwkSetUri extends WebSecurityConfigurerAdapter {
    protected void configure(HttpSecurity http) {
        http
            .authorizeRequests(authorizeRequests -> authorizeRequests
                .mvcMatchers(""/contacts/**"").hasAuthority(""SCOPE_contacts"")
                .mvcMatchers(""/messages/**"").hasAuthority(""SCOPE_messages"")
                .anyRequest().authenticated()
            )
            .oauth2ResourceServer(OAuth2ResourceServerConfigurer::jwt);
    }
}
----

Or similarly with method security:

[source,java]
----
@PreAuthorize(""hasAuthority('SCOPE_messages')"")
public List<Message> getMessages(...) {}
----

[[oauth2resourceserver-jwt-authorization-extraction]]
==== Extracting Authorities Manually

However, there are a number of circumstances where this default is insufficient.
For example, some authorization servers don't use the `scope` attribute, but instead have their own custom attribute.
Or, at other times, the resource server may need to adapt the attribute or a composition of attributes into internalized authorities.

To this end, the DSL exposes `jwtAuthenticationConverter()`:

[source,java]
----
@EnableWebSecurity
public class DirectlyConfiguredJwkSetUri extends WebSecurityConfigurerAdapter {
    protected void configure(HttpSecurity http) {
        http
            .authorizeRequests()
                .anyRequest().authenticated()
                .and()
            .oauth2ResourceServer()
                .jwt()
                    .jwtAuthenticationConverter(grantedAuthoritiesExtractor());
    }
}

Converter<Jwt, AbstractAuthenticationToken> grantedAuthoritiesExtractor() {
    JwtAuthenticationConverter jwtAuthenticationConverter =
            new JwtAuthenticationConverter();
    jwtAuthenticationConverter.setJwtGrantedAuthoritiesConverter
            (new GrantedAuthoritiesExtractor());
    return jwtAuthenticationConveter;
}
----

which is responsible for converting a `Jwt` into an `Authentication`.
As part of its configuration, we can supply a subsidiary converter to go from `Jwt` to a `Collection` of granted authorities.

That final converter might be something like `GrantedAuthoritiesExtractor` below:

[source,java]
----
static class GrantedAuthoritiesExtractor
        implements Converter<Jwt, Collection<GrantedAuthority>> {

    public Collection<GrantedAuthority> convert(Jwt jwt) {
        Collection<String> authorities = (Collection<String>)
                jwt.getClaims().get(""mycustomclaim"");

        return authorities.stream()
                .map(SimpleGrantedAuthority::new)
                .collect(Collectors.toList());
    }
}
----

For more flexibility, the DSL supports entirely replacing the converter with any class that implements `Converter<Jwt, AbstractAuthenticationToken>`:

[source,java]
----
static class CustomAuthenticationConverter implements Converter<Jwt, AbstractAuthenticationToken> {
    public AbstractAuthenticationToken convert(Jwt jwt) {
        return new CustomAuthenticationToken(jwt);
    }
}
----

[[oauth2resourceserver-jwt-validation]]
=== Configuring Validation

Using <<oauth2resourceserver-jwt-minimalconfiguration,minimal Spring Boot configuration>>, indicating the authorization server's issuer uri, Resource Server will default to verifying the `iss` claim as well as the `exp` and `nbf` timestamp claims.

In circumstances where validation needs to be customized, Resource Server ships with two standard validators and also accepts custom `OAuth2TokenValidator` instances.

[[oauth2resourceserver-jwt-validation-clockskew]]
==== Customizing Timestamp Validation

JWT's typically have a window of validity, with the start of the window indicated in the `nbf` claim and the end indicated in the `exp` claim.

However, every server can experience clock drift, which can cause tokens to appear expired to one server, but not to another.
This can cause some implementation heartburn as the number of collaborating servers increases in a distributed system.

Resource Server uses `JwtTimestampValidator` to verify a token's validity window, and it can be configured with a `clockSkew` to alleviate the above problem:

[source,java]
----
@Bean
JwtDecoder jwtDecoder() {
     NimbusJwtDecoder jwtDecoder = (NimbusJwtDecoder)
             JwtDecoders.fromIssuerLocation(issuerUri);

     OAuth2TokenValidator<Jwt> withClockSkew = new DelegatingOAuth2TokenValidator<>(
            new JwtTimestampValidator(Duration.ofSeconds(60)),
            new IssuerValidator(issuerUri));

     jwtDecoder.setJwtValidator(withClockSkew);

     return jwtDecoder;
}
----

[NOTE]
By default, Resource Server configures a clock skew of 30 seconds.

[[oauth2resourceserver-jwt-validation-custom]]
==== Configuring a Custom Validator

Adding a check for the `aud` claim is simple with the `OAuth2TokenValidator` API:

[source,java]
----
public class AudienceValidator implements OAuth2TokenValidator<Jwt> {
    OAuth2Error error = new OAuth2Error(""invalid_token"", ""The required audience is missing"", null);

    public OAuth2TokenValidatorResult validate(Jwt jwt) {
        if (jwt.getAudience().contains(""messaging"")) {
            return OAuth2TokenValidatorResult.success();
        } else {
            return OAuth2TokenValidatorResult.failure(error);
        }
    }
}
----

Then, to add into a resource server, it's a matter of specifying the `JwtDecoder` instance:

[source,java]
----
@Bean
JwtDecoder jwtDecoder() {
    NimbusJwtDecoder jwtDecoder = (NimbusJwtDecoder)
        JwtDecoders.fromIssuerLocation(issuerUri);

    OAuth2TokenValidator<Jwt> audienceValidator = new AudienceValidator();
    OAuth2TokenValidator<Jwt> withIssuer = JwtValidators.createDefaultWithIssuer(issuerUri);
    OAuth2TokenValidator<Jwt> withAudience = new DelegatingOAuth2TokenValidator<>(withIssuer, audienceValidator);

    jwtDecoder.setJwtValidator(withAudience);

    return jwtDecoder;
}
----

[[oauth2resourceserver-jwt-claimsetmapping]]
=== Configuring Claim Set Mapping

Spring Security uses the https://bitbucket.org/connect2id/nimbus-jose-jwt/wiki/Home[Nimbus] library for parsing JWTs and validating their signatures.
Consequently, Spring Security is subject to Nimbus's interpretation of each field value and how to coerce each into a Java type.

For example, because Nimbus remains Java 7 compatible, it doesn't use `Instant` to represent timestamp fields.

And it's entirely possible to use a different library or for JWT processing, which may make its own coercion decisions that need adjustment.

Or, quite simply, a resource server may want to add or remove claims from a JWT for domain-specific reasons.

For these purposes, Resource Server supports mapping the JWT claim set with `MappedJwtClaimSetConverter`.

[[oauth2resourceserver-jwt-claimsetmapping-singleclaim]]
==== Customizing the Conversion of a Single Claim

By default, `MappedJwtClaimSetConverter` will attempt to coerce claims into the following types:

|============
| Claim | Java Type
| `aud` | `Collection<String>`
| `exp` | `Instant`
| `iat` | `Instant`
| `iss` | `String`
| `jti` | `String`
| `nbf` | `Instant`
| `sub` | `String`
|============

An individual claim's conversion strategy can be configured using `MappedJwtClaimSetConverter.withDefaults`:

```java
@Bean
JwtDecoder jwtDecoder() {
    NimbusJwtDecoder jwtDecoder = NimbusJwtDecoder.withJwkSetUri(jwkSetUri).build();

    MappedJwtClaimSetConverter converter = MappedJwtClaimSetConverter
            .withDefaults(Collections.singletonMap(""sub"", this::lookupUserIdBySub));
    jwtDecoder.setClaimSetConverter(converter);

    return jwtDecoder;
}
```
This will keep all the defaults, except it will override the default claim converter for `sub`.

[[oauth2resourceserver-jwt-claimsetmapping-add]]
==== Adding a Claim

`MappedJwtClaimSetConverter` can also be used to add a custom claim, for example, to adapt to an existing system:

```java
MappedJwtClaimSetConverter.withDefaults(Collections.singletonMap(""custom"", custom -> ""value""));
```

[[oauth2resourceserver-jwt-claimsetmapping-remove]]
==== Removing a Claim

And removing a claim is also simple, using the same API:

```java
MappedJwtClaimSetConverter.withDefaults(Collections.singletonMap(""legacyclaim"", legacy -> null));
```

[[oauth2resourceserver-jwt-claimsetmapping-rename]]
==== Renaming a Claim

In more sophisticated scenarios, like consulting multiple claims at once or renaming a claim, Resource Server accepts any class that implements `Converter<Map<String, Object>, Map<String,Object>>`:

```java
public class UsernameSubClaimAdapter implements Converter<Map<String, Object>, Map<String, Object>> {
    private final MappedJwtClaimSetConverter delegate =
            MappedJwtClaimSetConverter.withDefaults(Collections.emptyMap());

    public Map<String, Object> convert(Map<String, Object> claims) {
        Map<String, Object> convertedClaims = this.delegate.convert(claims);

        String username = (String) convertedClaims.get(""user_name"");
        convertedClaims.put(""sub"", username);

        return convertedClaims;
    }
}
```

And then, the instance can be supplied like normal:

```java
@Bean
JwtDecoder jwtDecoder() {
    NimbusJwtDecoder jwtDecoder = NimbusJwtDecoder.withJwkSetUri(jwkSetUri).build();
    jwtDecoder.setClaimSetConverter(new UsernameSubClaimAdapter());
    return jwtDecoder;
}
```

[[oauth2resourceserver-jwt-timeouts]]
=== Configuring Timeouts

By default, Resource Server uses connection and socket timeouts of 30 seconds each for coordinating with the authorization server.

This may be too short in some scenarios.
Further, it doesn't take into account more sophisticated patterns like back-off and discovery.

To adjust the way in which Resource Server connects to the authorization server, `NimbusJwtDecoder` accepts an instance of `RestOperations`:

```java
@Bean
public JwtDecoder jwtDecoder(RestTemplateBuilder builder) {
    RestOperations rest = builder
            .setConnectionTimeout(60000)
            .setReadTimeout(60000)
            .build();

    NimbusJwtDecoder jwtDecoder = NimbusJwtDecoder.withJwkSetUri(jwkSetUri).restOperations(rest).build();
    return jwtDecoder;
}
```

[[oauth2resourceserver-opaque-minimalconfiguration]]
=== Minimal Configuration for Introspection

Typically, an opaque token can be verified via an https://tools.ietf.org/html/rfc7662[OAuth 2.0 Introspection Endpoint], hosted by the authorization server.
This can be handy when revocation is a requirement.

When using https://spring.io/projects/spring-boot[Spring Boot], configuring an application as a resource server that uses introspection consists of two basic steps.
First, include the needed dependencies and second, indicate the introspection endpoint details.

==== Specifying the Authorization Server

To specify where the introspection endpoint is, simply do:

[source,yaml]
----
security:
  oauth2:
    resourceserver:
      opaque-token:
        introspection-uri: https://idp.example.com/introspect
        client-id: client
        client-secret: secret
----

Where `https://idp.example.com/introspect` is the introspection endpoint hosted by your authorization server and `client-id` and `client-secret` are the credentials needed to hit that endpoint.

Resource Server will use these properties to further self-configure and subsequently validate incoming JWTs.

[NOTE]
When using introspection, the authorization server's word is the law.
If the authorization server responses that the token is valid, then it is.

And that's it!

==== Startup Expectations

When this property and these dependencies are used, Resource Server will automatically configure itself to validate Opaque Bearer Tokens.

This startup process is quite a bit simpler than for JWTs since no endpoints need to be discovered and no additional validation rules get added.

==== Runtime Expectations

Once the application is started up, Resource Server will attempt to process any request containing an `Authorization: Bearer` header:

```http
GET / HTTP/1.1
Authorization: Bearer some-token-value # Resource Server will process this
```

So long as this scheme is indicated, Resource Server will attempt to process the request according to the Bearer Token specification.

Given an Opaque Token, Resource Server will

1. Query the provided introspection endpoint using the provided credentials and the token
2. Inspect the response for an `{ 'active' : true }` attribute
3. Map each scope to an authority with the prefix `SCOPE_`

The resulting `Authentication#getPrincipal`, by default, is a Spring Security `{security-api-url}org/springframework/security/oauth2/core/OAuth2AuthenticatedPrincipal.html[OAuth2AuthenticatedPrincipal]` object, and `Authentication#getName` maps to the token's `sub` property, if one is present.

From here, you may want to jump to:

* <<oauth2resourceserver-opaque-attributes,Looking Up Attributes Post-Authentication>>
* <<oauth2resourceserver-opaque-authorization-extraction,Extracting Authorities Manually>>
* <<oauth2resourceserver-opaque-jwt-introspector,Using Introspection with JWTs>>

[[oauth2resourceserver-opaque-attributes]]
=== Looking Up Attributes Post-Authentication

Once a token is authenticated, an instance of `BearerTokenAuthentication` is set in the `SecurityContext`.

This means that it's available in `@Controller` methods when using `@EnableWebMvc` in your configuration:

[source,java]
----
@GetMapping(""/foo"")
public String foo(BearerTokenAuthentication authentication) {
    return authentication.getTokenAttributes().get(""sub"") + "" is the subject"";
}
----

Since `BearerTokenAuthentication` holds an `OAuth2AuthenticatedPrincipal`, that also means that it's available to controller methods, too:

[source,java]
----
@GetMapping(""/foo"")
public String foo(@AuthenticationPrincipal OAuth2AuthenticatedPrincipal principal) {
    return principal.getAttribute(""sub"") + "" is the subject"";
}
----

==== Looking Up Attributes Via SpEL

Of course, this also means that attributes can be accessed via SpEL.

For example, if using `@EnableGlobalMethodSecurity` so that you can use `@PreAuthorize` annotations, you can do:

```java
@PreAuthorize(""principal?.attributes['sub'] == 'foo'"")
public String forFoosEyesOnly() {
    return ""foo"";
}
```

[[oauth2resourceserver-opaque-sansboot]]
=== Overriding or Replacing Boot Auto Configuration

There are two `@Bean` s that Spring Boot generates on Resource Server's behalf.

The first is a `WebSecurityConfigurerAdapter` that configures the app as a resource server.
When use Opaque Token, this `WebSecurityConfigurerAdapter` looks like:

[source,java]
----
protected void configure(HttpSecurity http) {
    http
        .authorizeRequests()
            .anyRequest().authenticated()
            .and()
        .oauth2ResourceServer(OAuth2ResourceServerConfigurer::opaqueToken)
}
----

If the application doesn't expose a `WebSecurityConfigurerAdapter` bean, then Spring Boot will expose the above default one.

Replacing this is as simple as exposing the bean within the application:

[source,java]
----
@EnableWebSecurity
public class MyCustomSecurityConfiguration extends WebSecurityConfigurerAdapter {
    protected void configure(HttpSecurity http) {
        http
            .authorizeRequests()
                .mvcMatchers(""/messages/**"").hasAuthority(""SCOPE_message:read"")
                .anyRequest().authenticated()
                .and()
            .oauth2ResourceServer()
                .opaqueToken()
                    .introspector(myIntrospector());
    }
}
----

The above requires the scope of `message:read` for any URL that starts with `/messages/`.

Methods on the `oauth2ResourceServer` DSL will also override or replace auto configuration.

For example, the second `@Bean` Spring Boot creates is an `OpaqueTokenIntrospector`, which decodes `String` tokens into validated instances of `OAuth2AuthenticatedPrincipal`:

[source,java]
----
@Bean
public OpaqueTokenIntrospector introspector() {
    return new NimbusOpaqueTokenIntrospector(introspectionUri, clientId, clientSecret);
}
----

If the application doesn't expose a `OpaqueTokenIntrospector` bean, then Spring Boot will expose the above default one.

And its configuration can be overridden using `introspectionUri()` and `introspectionClientCredentials()` or replaced using `introspector()`.

[[oauth2resourceserver-opaque-introspectionuri-dsl]]
==== Using `introspectionUri()`

An authorization server's Introspection Uri can be configured <<oauth2resourceserver-opaque-introspectionuri,as a configuration property>> or it can be supplied in the DSL:

[source,java]
----
@EnableWebSecurity
public class DirectlyConfiguredIntrospectionUri extends WebSecurityConfigurerAdapter {
    protected void configure(HttpSecurity http) {
        http
            .authorizeRequests()
                .anyRequest().authenticated()
                .and()
            .oauth2ResourceServer()
                .opaqueToken()
                    .introspectionUri(""https://idp.example.com/introspect"")
                    .introspectionClientCredentials(""client"", ""secret"");
    }
}
----

Using `introspectionUri()` takes precedence over any configuration property.

[[oauth2resourceserver-opaque-introspector-dsl]]
==== Using `introspector()`

More powerful than `introspectionUri()` is `introspector()`, which will completely replace any Boot auto configuration of `OpaqueTokenIntrospector`:

[source,java]
----
@EnableWebSecurity
public class DirectlyConfiguredIntrospector extends WebSecurityConfigurerAdapter {
    protected void configure(HttpSecurity http) {
        http
            .authorizeRequests()
                .anyRequest().authenticated()
                .and()
            .oauth2ResourceServer()
                .opaqueToken()
                    .introspector(myCustomIntrospector());
    }
}
----

This is handy when deeper configuration, like <<oauth2resourceserver-opaque-authorization-extraction,authority mapping>>, <<oauth2resourceserver-opaque-jwt-introspector,JWT revocation>>, or <<oauth2resourceserver-opaque-timeouts,request timeouts>>, is necessary.

[[oauth2resourceserver-opaque-introspector-bean]]
==== Exposing a `OpaqueTokenIntrospector` `@Bean`

Or, exposing a `OpaqueTokenIntrospector` `@Bean` has the same effect as `introspector()`:

[source,java]
----
@Bean
public OpaqueTokenIntrospector introspector() {
    return new NimbusOpaqueTokenIntrospector(introspectionUri, clientId, clientSecret);
}
----

[[oauth2resourceserver-opaque-authorization]]
=== Configuring Authorization

An OAuth 2.0 Introspection endpoint will typically return a `scope` attribute, indicating the scopes (or authorities) it's been granted, for example:

`{ ..., ""scope"" : ""messages contacts""}`

When this is the case, Resource Server will attempt to coerce these scopes into a list of granted authorities, prefixing each scope with the string ""SCOPE_"".

This means that to protect an endpoint or method with a scope derived from an Opaque Token, the corresponding expressions should include this prefix:

```java
@EnableWebSecurity
public class MappedAuthorities extends WebSecurityConfigurerAdapter {
    protected void configure(HttpSecurity http) {
        http
            .authorizeRequests(authorizeRequests -> authorizeRequests
                .mvcMatchers(""/contacts/**"").hasAuthority(""SCOPE_contacts"")
                .mvcMatchers(""/messages/**"").hasAuthority(""SCOPE_messages"")
                .anyRequest().authenticated()
            )
            .oauth2ResourceServer(OAuth2ResourceServerConfigurer::opaqueToken);
    }
}
```

Or similarly with method security:

```java
@PreAuthorize(""hasAuthority('SCOPE_messages')"")
public List<Message> getMessages(...) {}
```

[[oauth2resourceserver-opaque-authorization-extraction]]
==== Extracting Authorities Manually

By default, Opaque Token support will extract the scope claim from an introspection response and parse it into individual `GrantedAuthority` instances.

For example, if the introspection response were:

[source,json]
----
{
    ""active"" : true,
    ""scope"" : ""message:read message:write""
}
----

Then Resource Server would generate an `Authentication` with two authorities, one for `message:read` and the other for `message:write`.

This can, of course, be customized using a custom `OpaqueTokenIntrospector` that takes a look at the attribute set and converts in its own way:

[source,java]
----
public class CustomAuthoritiesOpaqueTokenIntrospector implements OpaqueTokenIntrospector {
    private OpaqueTokenIntrospector delegate =
            new NimbusOpaqueTokenIntrospector(""https://idp.example.org/introspect"", ""client"", ""secret"");

    public OAuth2AuthenticatedPrincipal introspect(String token) {
        OAuth2AuthenticatedPrincipal principal = this.delegate.introspect(token);
        return new DefaultOAuth2AuthenticatedPrincipal(
                principal.getName(), principal.getAttributes(), extractAuthorities(principal));
    }

    private Collection<GrantedAuthority> extractAuthorities(OAuth2AuthenticatedPrincipal principal) {
        List<String> scopes = principal.getAttribute(OAuth2IntrospectionClaimNames.SCOPE);
        return scopes.stream()
                .map(SimpleGrantedAuthority::new)
                .collect(Collectors.toList());
    }
}
----

Thereafter, this custom introspector can be configured simply by exposing it as a `@Bean`:

[source,java]
----
@Bean
public OpaqueTokenIntrospector introspector() {
    return new CustomAuthoritiesOpaqueTokenIntrospector();
}
----

[[oauth2resourceserver-opaque-timeouts]]
=== Configuring Timeouts

By default, Resource Server uses connection and socket timeouts of 30 seconds each for coordinating with the authorization server.

This may be too short in some scenarios.
Further, it doesn't take into account more sophisticated patterns like back-off and discovery.

To adjust the way in which Resource Server connects to the authorization server, `NimbusOpaqueTokenIntrospector` accepts an instance of `RestOperations`:

```java
@Bean
public OpaqueTokenIntrospector introspector(RestTemplateBuilder builder) {
    RestOperations rest = builder
            .basicAuthentication(clientId, clientSecret)
            .setConnectionTimeout(60000)
            .setReadTimeout(60000)
            .build();

    return new NimbusOpaqueTokenIntrospector(introspectionUri, rest);
}
```

[[oauth2resourceserver-opaque-jwt-introspector]]
=== Using Introspection with JWTs

A common question is whether or not introspection is compatible with JWTs.
Spring Security's Opaque Token support has been designed to not care about the format of the token -- it will gladly pass any token to the introspection endpoint provided.

So, let's say that you've got a requirement that requires you to check with the authorization server on each request, in case the JWT has been revoked.

Even though you are using the JWT format for the token, your validation method is introspection, meaning you'd want to do:

[source,yaml]
----
spring:
  security:
    oauth2:
      resourceserver:
        opaque-token:
          introspection-uri: https://idp.example.org/introspection
          client-id: client
          client-secret: secret
----

In this case, the resulting `Authentication` would be `BearerTokenAuthentication`.
Any attributes in the corresponding `OAuth2AuthenticatedPrincipal` would be whatever was returned by the introspection endpoint.

But, let's say that, oddly enough, the introspection endpoint only returns whether or not the token is active.
Now what?

In this case, you can create a custom `OpaqueTokenIntrospector` that still hits the endpoint, but then updates the returned principal to have the JWTs claims as the attributes:

[source,java]
----
public class JwtOpaqueTokenIntrospector implements OpaqueTokenIntrospector {
    private OpaqueTokenIntrospector delegate =
            new NimbusOpaqueTokenIntrospector(""https://idp.example.org/introspect"", ""client"", ""secret"");
    private JwtDecoder jwtDecoder = new NimbusJwtDecoder(new ParseOnlyJWTProcessor());

    public OAuth2AuthenticatedPrincipal introspect(String token) {
        OAuth2AuthenticatedPrincipal principal = this.delegate.introspect(token);
        try {
            Jwt jwt = this.jwtDecoder.decode(token);
            return new DefaultOAuth2AuthenticatedPrincipal(jwt.getClaims(), NO_AUTHORITIES);
        } catch (JwtException e) {
            throw new OAuth2IntrospectionException(e);
        }
    }

    private static class ParseOnlyJWTProcessor extends DefaultJWTProcessor<SecurityContext> {
    	JWTClaimsSet process(SignedJWT jwt, SecurityContext context)
                throws JOSEException {
            return jwt.getJWTClaimSet();
        }
    }
}
----

Thereafter, this custom introspector can be configured simply by exposing it as a `@Bean`:

[source,java]
----
@Bean
public OpaqueTokenIntrospector introspector() {
    return new JwtOpaqueTokenIntropsector();
}
----

[[oauth2resourceserver-opaque-userinfo]]
=== Calling a `/userinfo` Endpoint

Generally speaking, a Resource Server doesn't care about the underlying user, but instead about the authorities that have been granted.

That said, at times it can be valuable to tie the authorization statement back to a user.

If an application is also using `spring-security-oauth2-client`, having set up the appropriate `ClientRegistrationRepository`, then this is quite simple with a custom `OpaqueTokenIntrospector`.
This implementation below does three things:

* Delegates to the introspection endpoint, to affirm the token's validity
* Looks up the appropriate client registration associated with the `/userinfo` endpoint
* Invokes and returns the response from the `/userinfo` endpoint

[source,java]
----
public class UserInfoOpaqueTokenIntrospector implements OpaqueTokenIntrospector {
    private final OpaqueTokenIntrospector delegate =
            new NimbusOpaqueTokenIntrospector(""https://idp.example.org/introspect"", ""client"", ""secret"");
    private final OAuth2UserService oauth2UserService = new DefaultOAuth2UserService();

    private final ClientRegistrationRepository repository;

    // ... constructor

    @Override
    public OAuth2AuthenticatedPrincipal introspect(String token) {
        OAuth2AuthenticatedPrincipal authorized = this.delegate.introspect(token);
        Instant issuedAt = authorized.getAttribute(ISSUED_AT);
        Instant expiresAt = authorized.getAttribute(EXPIRES_AT);
        ClientRegistration clientRegistration = this.repository.findByRegistrationId(""registration-id"");
        OAuth2AccessToken token = new OAuth2AccessToken(BEARER, token, issuedAt, expiresAt);
        OAuth2UserRequest oauth2UserRequest = new OAuth2UserRequest(clientRegistration, token);
        return this.oauth2UserService.loadUser(oauth2UserRequest);
    }
}
----

If you aren't using `spring-security-oauth2-client`, it's still quite simple.
You will simply need to invoke the `/userinfo` with your own instance of `WebClient`:

[source,java]
----
public class UserInfoOpaqueTokenIntrospector implements OpaqueTokenIntrospector {
    private final OpaqueTokenIntrospector delegate =
            new NimbusOpaqueTokenIntrospector(""https://idp.example.org/introspect"", ""client"", ""secret"");
    private final WebClient rest = WebClient.create();

    @Override
    public OAuth2AuthenticatedPrincipal introspect(String token) {
        OAuth2AuthenticatedPrincipal authorized = this.delegate.introspect(token);
        return makeUserInfoRequest(authorized);
    }
}
----

Either way, having created your `OpaqueTokenIntrospector`, you should publish it as a `@Bean` to override the defaults:

[source,java]
----
@Bean
OpaqueTokenIntrospector introspector() {
    return new UserInfoOpaqueTokenIntrospector(...);
}
----

[[oauth2reourceserver-opaqueandjwt]]
=== Supporting both JWT and Opaque Token

In some cases, you may have a need to access both kinds of tokens.
For example, you may support more than one tenant where one tenant issues JWTs and the other issues opaque tokens.

If this decision must be made at request-time, then you can use an `AuthenticationManagerResolver` to achieve it, like so:

[source,java]
----
@Bean
AuthenticationManagerResolver<HttpServletRequest> tokenAuthenticationManagerResolver() {
    BearerTokenResolver bearerToken = new DefaultBearerTokenResolver();
    JwtAuthenticationProvider jwt = jwt();
    OpaqueTokenAuthenticationProvider opaqueToken = opaqueToken();

    return request -> {
        String token = bearerToken.resolve(request);
        if (isAJwt(token)) {
            return jwt::authenticate;
        } else {
            return opaqueToken::authenticate;
        }
    }
}
----

And then specify this `AuthenticationManagerResolver` in the DSL:

[source,java]
----
http
    .authorizeRequests()
        .anyRequest().authenticated()
        .and()
    .oauth2ResourceServer()
        .authenticationManagerResolver(this.tokenAuthenticationManagerResolver);
----

[[oauth2resourceserver-multitenancy]]
=== Multi-tenancy

A resource server is considered multi-tenant when there are multiple strategies for verifying a bearer token, keyed by some tenant identifier.

For example, your resource server may accept bearer tokens from two different authorization servers.
Or, your authorization server may represent a multiplicity of issuers.

In each case, there are two things that need to be done and trade-offs associated with how you choose to do them:

1. Resolve the tenant
2. Propagate the tenant

==== Resolving the Tenant By Request Material

Resolving the tenant by request material can be done my implementing an `AuthenticationManagerResolver`, which determines the `AuthenticationManager` at runtime, like so:

[source,java]
----
@Component
public class TenantAuthenticationManagerResolver
        implements AuthenticationManagerResolver<HttpServletRequest> {
	private final BearerTokenResolver resolver = new DefaultBearerTokenResolver();
	private final TenantRepository tenants; <1>

	private final Map<String, AuthenticationManager> authenticationManagers = new ConcurrentHashMap<>(); <2>

	public TenantAuthenticationManagerResolver(TenantRepository tenants) {
		this.tenants = tenants;
	}

	@Override
	public AuthenticationManager resolve(HttpServletRequest request) {
		return this.authenticationManagers.computeIfAbsent(toTenant(request), this::fromTenant);
	}

	private String toTenant(HttpServletRequest request) {
		String[] pathParts = request.getRequestURI().split(""/"");
		return pathParts.length > 0 ? pathParts[1] : null;
	}

	private AuthenticationManager fromTenant(String tenant) {
		return Optional.ofNullable(this.tenants.get(tenant)) <3>
				.map(JwtDecoders::fromIssuerLocation) <4>
				.map(JwtAuthenticationProvider::new)
				.orElseThrow(() -> new IllegalArgumentException(""unknown tenant""))::authenticate;
	}
}
----
<1> A hypothetical source for tenant information
<2> A cache for `AuthenticationManager`s, keyed by tenant identifier
<3> Looking up the tenant is more secure than simply computing the issuer location on the fly - the lookup acts as a tenant whitelist
<4> Create a `JwtDecoder` via the discovery endpoint - the lazy lookup here means that you don't need to configure all tenants at startup

And then specify this `AuthenticationManagerResolver` in the DSL:

[source,java]
----
http
    .authorizeRequests()
        .anyRequest().authenticated()
        .and()
    .oauth2ResourceServer()
        .authenticationManagerResolver(this.tenantAuthenticationManagerResolver);
----

==== Resolving the Tenant By Claim

Resolving the tenant by claim is similar to doing so by request material.
The only real difference is the `toTenant` method implementation:

[source,java]
----
@Component
public class TenantAuthenticationManagerResolver implements AuthenticationManagerResolver<HttpServletRequest> {
	private final BearerTokenResolver resolver = new DefaultBearerTokenResolver();
	private final TenantRepository tenants; <1>

	private final Map<String, AuthenticationManager> authenticationManagers = new ConcurrentHashMap<>(); <2>

	public TenantAuthenticationManagerResolver(TenantRepository tenants) {
		this.tenants = tenants;
	}

	@Override
	public AuthenticationManager resolve(HttpServletRequest request) {
		return this.authenticationManagers.computeIfAbsent(toTenant(request), this::fromTenant); <3>
	}

	private String toTenant(HttpServletRequest request) {
		try {
			String token = this.resolver.resolve(request);
			return (String) JWTParser.parse(token).getJWTClaimsSet().getIssuer();
		} catch (Exception e) {
			throw new IllegalArgumentException(e);
		}
	}

	private AuthenticationManager fromTenant(String tenant) {
		return Optional.ofNullable(this.tenants.get(tenant)) <3>
				.map(JwtDecoders::fromIssuerLocation) <4>
				.map(JwtAuthenticationProvider::new)
				.orElseThrow(() -> new IllegalArgumentException(""unknown tenant""))::authenticate;
	}
}
----
<1> A hypothetical source for tenant information
<2> A cache for `AuthenticationManager`s, keyed by tenant identifier
<3> Looking up the tenant is more secure than simply computing the issuer location on the fly - the lookup acts as a tenant whitelist
<4> Create a `JwtDecoder` via the discovery endpoint - the lazy lookup here means that you don't need to configure all tenants at startup

[source,java]
----
http
    .authorizeRequests()
        .anyRequest().authenticated()
        .and()
    .oauth2ResourceServer()
        .authenticationManagerResolver(this.tenantAuthenticationManagerResolver);
----

==== Parsing the Claim Only Once

You may have observed that this strategy, while simple, comes with the trade-off that the JWT is parsed once by the `AuthenticationManagerResolver` and then again by the `JwtDecoder`.

This extra parsing can be alleviated by configuring the `JwtDecoder` directly with a `JWTClaimSetAwareJWSKeySelector` from Nimbus:

[source,java]
----
@Component
public class TenantJWSKeySelector
    implements JWTClaimSetAwareJWSKeySelector<SecurityContext> {

	private final TenantRepository tenants; <1>
	private final Map<String, JWSKeySelector<SecurityContext>> selectors = new ConcurrentHashMap<>(); <2>

	public TenantJWSKeySelector(TenantRepository tenants) {
		this.tenants = tenants;
	}

	@Override
	public List<? extends Key> selectKeys(JWSHeader jwsHeader, JWTClaimsSet jwtClaimsSet, SecurityContext securityContext)
			throws KeySourceException {
		return this.selectors.computeIfAbsent(toTenant(jwtClaimsSet), this::fromTenant)
				.selectJWSKeys(jwsHeader, securityContext);
	}

	private String toTenant(JWTClaimsSet claimSet) {
		return (String) claimSet.getClaim(""iss"");
	}

	private JWSKeySelector<SecurityContext> fromTenant(String tenant) {
		return Optional.ofNullable(this.tenantRepository.findById(tenant)) <3>
		        .map(t -> t.getAttrbute(""jwks_uri""))
				.map(this::fromUri)
				.orElseThrow(() -> new IllegalArgumentException(""unknown tenant""));
	}

	private JWSKeySelector<SecurityContext> fromUri(String uri) {
		try {
			return JWSAlgorithmFamilyJWSKeySelector.fromJWKSetURL(new URL(uri)); <4>
		} catch (Exception e) {
			throw new IllegalArgumentException(e);
		}
	}
}
----
<1> A hypothetical source for tenant information
<2> A cache for `JWKKeySelector`s, keyed by tenant identifier
<3> Looking up the tenant is more secure than simply calculating the JWK Set endpoint on the fly - the lookup acts as a tenant whitelist
<4> Create a `JWSKeySelector` via the types of keys that come back from the JWK Set endpoint - the lazy lookup here means that you don't need to configure all tenants at startup

The above key selector is a composition of many key selectors.
It chooses which key selector to use based on the `iss` claim in the JWT.

NOTE: To use this approach, make sure that the authorization server is configured to include the claim set as part of the token's signature.
Without this, you have no guarantee that the issuer hasn't been altered by a bad actor.

Next, we can construct a `JWTProcessor`:

[source,java]
----
@Bean
JWTProcessor jwtProcessor(JWTClaimSetJWSKeySelector keySelector) {
	ConfigurableJWTProcessor<SecurityContext> jwtProcessor =
            new DefaultJWTProcessor();
	jwtProcessor.setJWTClaimSetJWSKeySelector(keySelector);
	return jwtProcessor;
}
----

As you are already seeing, the trade-off for moving tenant-awareness down to this level is more configuration.
We have just a bit more.

Next, we still want to make sure you are validating the issuer.
But, since the issuer may be different per JWT, then you'll need a tenant-aware validator, too:

[source,java]
----
@Component
public class TenantJwtIssuerValidator implements OAuth2TokenValidator<Jwt> {
	private final TenantRepository tenants;
	private final Map<String, JwtIssuerValidator> validators = new ConcurrentHashMap<>();

	public TenantJwtIssuerValidator(TenantRepository tenants) {
		this.tenants = tenants;
	}

	@Override
	public OAuth2TokenValidatorResult validate(Jwt token) {
		return this.validators.computeIfAbsent(toTenant(token), this::fromTenant)
				.validate(token);
	}

	private String toTenant(Jwt jwt) {
		return jwt.getIssuer();
	}

	private JwtIssuerValidator fromTenant(String tenant) {
		return Optional.ofNullable(this.tenants.findById(tenant))
		        .map(t -> t.getAttribute(""issuer""))
				.map(JwtIssuerValidator::new)
				.orElseThrow(() -> new IllegalArgumentException(""unknown tenant""));
	}
}
----

Now that we have a tenant-aware processor and a tenant-aware validator, we can proceed with creating our `JwtDecoder`:

[source,java]
----
@Bean
JwtDecoder jwtDecoder(JWTProcessor jwtProcessor, OAuth2TokenValidator<Jwt> jwtValidator) {
	NimbusJwtDecoder decoder = new NimbusJwtDecoder(processor);
	OAuth2TokenValidator<Jwt> validator = new DelegatingOAuth2TokenValidator<>
			(JwtValidators.createDefault(), this.jwtValidator);
	decoder.setJwtValidator(validator);
	return decoder;
}
----

We've finished talking about resolving the tenant.

If you've chosen to resolve the tenant by request material, then you'll need to make sure you address your downstream resource servers in the same way.
For example, if you are resolving it by subdomain, you'll need to address the downstream resource server using the same subdomain.

However, if you resolve it by a claim in the bearer token, read on to learn about <<oauth2resourceserver-bearertoken-resolver,Spring Security's support for bearer token propagation>>.

[[oauth2resourceserver-bearertoken-resolver]]
=== Bearer Token Resolution

By default, Resource Server looks for a bearer token in the `Authorization` header.
This, however, can be customized in a couple of ways.

==== Reading the Bearer Token from a Custom Header

For example, you may have a need to read the bearer token from a custom header.
To achieve this, you can wire a `HeaderBearerTokenResolver` instance into the DSL, as you can see in the following example:

[source,java]
----
http
    .oauth2ResourceServer()
        .bearerTokenResolver(new HeaderBearerTokenResolver(""x-goog-iap-jwt-assertion""));
----

==== Reading the Bearer Token from a Form Parameter

Or, you may wish to read the token from a form parameter, which you can do by configuring the `DefaultBearerTokenResolver`, as you can see below:

[source,java]
----
DefaultBearerTokenResolver resolver = new DefaultBearerTokenResolver();
resolver.setAllowFormEncodedBodyParameter(true);
http
    .oauth2ResourceServer()
        .bearerTokenResolver(resolver);
----

=== Bearer Token Propagation

Now that you're in possession of a bearer token, it might be handy to pass that to downstream services.
This is quite simple with `{security-api-url}org/springframework/security/oauth2/server/resource/web/reactive/function/client/ServletBearerExchangeFilterFunction.html[ServletBearerExchangeFilterFunction]`, which you can see in the following example:

[source,java]
----
@Bean
public WebClient rest() {
    return WebClient.builder()
            .filter(new ServletBearerExchangeFilterFunction())
            .build();
}
----

When the above `WebClient` is used to perform requests, Spring Security will look up the current `Authentication` and extract any `{security-api-url}org/springframework/security/oauth2/core/AbstractOAuth2Token.html[AbstractOAuth2Token]` credential.
Then, it will propagate that token in the `Authorization` header.

For example:

[source,java]
----
this.rest.get()
        .uri(""https://other-service.example.com/endpoint"")
        .retrieve()
        .bodyToMono(String.class)
        .block()
----

Will invoke the `https://other-service.example.com/endpoint`, adding the bearer token `Authorization` header for you.

In places where you need to override this behavior, it's a simple matter of supplying the header yourself, like so:

[source,java]
----
this.rest.get()
        .uri(""https://other-service.example.com/endpoint"")
        .headers(headers -> headers.setBearerAuth(overridingToken))
        .retrieve()
        .bodyToMono(String.class)
        .block()
----

In this case, the filter will fall back and simply forward the request onto the rest of the web filter chain.

[NOTE]
Unlike the https://docs.spring.io/spring-security/site/docs/current-SNAPSHOT/api/org/springframework/security/oauth2/client/web/reactive/function/client/ServletOAuth2AuthorizedClientExchangeFilterFunction.html[OAuth 2.0 Client filter function], this filter function makes no attempt to renew the token, should it be expired.
To obtain this level of support, please use the OAuth 2.0 Client filter.

==== `RestTemplate` support

There is no dedicated support for `RestTemplate` at the moment, but you can achieve propagation quite simply with your own interceptor:

[source,java]
----
@Bean
RestTemplate rest() {
	RestTemplate rest = new RestTemplate();
	rest.getInterceptors().add((request, body, execution) -> {
		Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
		if (authentication == null) {
			return execution.execute(request, body);
		}

		if (!(authentication.getCredentials() instanceof AbstractOAuth2Token)) {
			return execution.execute(request, body);
		}

		AbstractOAuth2Token token = (AbstractOAuth2Token) authentication.getCredentials();
	    request.getHeaders().setBearerAuth(token.getTokenValue());
	    return execution.execute(request, body);
	});
	return rest;
}
----
",12097,False,2265.2209590868124,median
"== Batch Programming Model

The batch programming model is described by interfaces, abstract
classes, and field annotations. Interfaces define the essential contract
between batch applications and the batch runtime. Most interfaces have a
corresponding abstract class that provides default implementations of
certain methods for developer convenience.

=== Steps

A batch step is either chunk or batchlet.

==== Chunk

A chunk type step performs item-oriented processing using a
reader-processor-writer batch pattern and does checkpointing.

===== ItemReader Interface

An ItemReader is used to read items for a chunk step. ItemReader is one
of the three batch artifact types that comprise a chunk type step. The
other two are ItemProcessor and ItemWriter.

The ItemReader interface may be used to implement an ItemReader batch
artifact:

[[app-listing.ItemReader.java]]
[source,java]
.ItemReader.java
----
package jakarta.batch.api.chunk;

import java.io.Serializable;

/*
 * ItemReader defines the batch artifact that reads
 * items for chunk processing.
 */
public interface ItemReader {
  /**
   * The open method prepares the reader to read items
   * The input parameter represents the last checkpoint
   * for this reader in a given job instance. The
   * checkpoint data is defined by this reader and is
   * provided by the checkpointInfo method. The checkpoint
   * data provides the reader whatever information it needs
   * to resume reading items upon restart. A checkpoint value
   * of null is passed upon initial start.
   *
   * @param checkpoint specifies the last checkpoint
   * @throws Exception is thrown for any errors.
   */
  public void open(Serializable checkpoint) throws Exception;

  /**
   * The close method marks the end of use of the
   * ItemReader. The reader is free to do any cleanup
   * necessary.
   * @throws Exception is thrown for any errors.
   */
  public void close() throws Exception;

  /**
   * The readItem method returns the next item
   * for chunk processing.
   * It returns null to in dicate no more items, which
   * also means the current chunk will be committed and
   * the step will end.
   * *@return* next item or null
   * @throws Exception is thrown for any errors.
   */
  public Object readItem() throws Exception;

  /**
   * The checkpointInfo method returns the current
   * checkpoint data for this reader. It is
   * called before a chunk checkpoint is committed.
   * *@return* checkpoint data
   * @throws Exception is thrown for any errors.
   */
  public Serializable checkpointInfo() throws Exception;
}
----

[[app-listing.AbstractItemReader.java]]
[source,java]
.AbstractItemReader.java
----
package jakarta.batch.api.chunk;
import java.io.Serializable;
public abstract class AbstractItemReader implements ItemReader
{
    @Override
    public void open(Serializable checkpoint)throws Exception {
    }

    @Override
    public void close()throws Exception {
    }

    @Override
    public abstract Object readItem() throws Exception;

    @Override
    public Serializable checkpointInfo() throws Exception {
        return null;
    }
}
----


===== ItemProcessor Interface

An ItemProcessor is used to process items for a chunk step.
ItemProcessor is one of the three batch artifact types that comprise a
chunk type step. An ItemProcessor is an optional artifact on a chunk
type step. The other two are ItemReader and ItemWriter.

The ItemProcessor interface may be used to implement an ItemProcessor
batch artifact:

[[app-listing.ItemProcessor.java]]
[source,java]
.ItemProcessor.java
----
package jakarta.batch.api.chunk;
/**
* ItemProcessor is used in chunk processing
* to operate on an input item and produce
* an output item.
*
*/
public interface ItemProcessor {
    /**
    * The processItem method is part of a chunk
    * step. It accepts an input item from an
    * item reader and returns an item that gets
    * passed onto the item writer. Returning null
    * indicates that the item should not be continued
    * to be processed. This effectively enables processItem
    * to filter out unwanted input items.
    * @param item specifies the input item to process.
    * *@return* output item to write.
    * @throws Exception thrown for any errors.
    */
    public Object processItem(Object item) throws Exception;
}
----

===== ItemWriter Interface

An ItemWriter is used to write a list of output items for a chunk step.
ItemWriter is one of the three batch artifact types that comprise a
chunk type step. The other two are ItemProcessor and ItemReader.

The ItemWriter interface may be used to implement an ItemWriter batch
artifact:

[[app-listing.ItemWriter.java]]
[source,java]
.ItemWriter.java
----
package jakarta.batch.api.chunk;
import java.io.Serializable;
import java.util.List;
/**
*
* ItemWriter defines the batch artifact that writes to a
* list of items for chunk processing.
*
*/
public interface ItemWriter {
    /**
    * The open method prepares the writer to write items.
    *
    * The input parameter represents the last checkpoint
    * for this writer in a given job instance. The
    * checkpoint data is defined by this writer and is
    * provided by the checkpointInfo method. The checkpoint
    * data provides the writer whatever information it needs
    * to resume writing items upon restart. A checkpoint value
    * of null is passed upon initial start.
    *
    * @param checkpoint specifies the last checkpoint
    * @throws Exception is thrown for any errors.
    */
    public void open(Serializable checkpoint) throws Exception;
    /**
    * The close method marks the end of use of the
    * ItemWriter. The writer is free to do any cleanup
    * necessary.
    * @throws Exception is thrown for any errors.
    */
    public void close() throws Exception;
    /**
    * The writeItems method writes a list of item
    * for the current chunk.
    * @param items specifies the list of items to write.
    * This may be an empty list (e.g. if all the
    * items have been filtered out by the
    * ItemProcessor).
    * @throws Exception is thrown for any
    errors.
    */
    public void writeItems(List<Object> items) throws Exception;
    /**
    * The checkpointInfo method returns the current
    * checkpoint data for this writer. It is
    * called before a chunk checkpoint is committed.
    * *@return* checkpoint data
    * @throws Exception is thrown for any errors.
    */
    public Serializable checkpointInfo() throws Exception;
}
----

[[app-listing.AbstractItemWriter.java]]
[source,java]
.AbstractItemWriter.java
----
package jakarta.batch.api.chunk;
import java.io.Serializable;
import java.util.List;
/**
* The AbstractItemWriter provides default implementations
* of not commonly implemented methods.
*/
public abstract class AbstractItemWriter implements ItemWriter
{
    /**
    * Override this method if the ItemWriter requires
    * any open time processing.
    * The default implementation does nothing.
    *
    * @param last checkpoint for this ItemReader
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void open(Serializable checkpoint) throws Exception {
    }
    /**
    * Override this method if the ItemWriter requires
    * any close time processing.
    * The default implementation does nothing.
    *
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void close() throws Exception {
    }
    /**
    * Implement write logic for the ItemWriter in this
    * method.
    *
    * @param items specifies the list of items to write.
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public abstract void writeItems(List<Object> items) throws
    Exception;
    /**
    * Override this method if the ItemWriter supports
    * checkpoints.
    * The default implementation returns null.
    *
    * *@return* checkpoint data
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public Serializable checkpointInfo() throws Exception {
        return null;
    }
}
----

===== CheckpointAlgorithm Interface

A CheckpointAlgorithm implements a custom checkpoint policy for a chunk
step. The CheckpointAlgorithm interface may be used to implement an
CheckpointAlgorithm batch artifact:

[[app-listing.CheckpointAlgorithm.java]]
[source,java]
.CheckpointAlgorithm.java
----
package jakarta.batch.api.chunk;
/**
* CheckpointAlgorithm provides a custom checkpoint
* policy for chunk steps.
*
*/
public interface CheckpointAlgorithm {
    /**
    * The checkpointTimeout is invoked at the beginning of a new
    * checkpoint interval for the purpose of establishing the checkpoint
    * timeout.
    * It is invoked before the next chunk transaction begins. This
    * method returns an integer value, which is the timeout value
    * (expressed in seconds) which will be used for the next chunk
    * transaction.
    * This method is useful to automate the setting of the
    * checkpoint timeout based on factors known outside the job
    * definition.
    * A value of '0' signifies no maximum established by this
    * CheckpointAlgorithm, i.e. the maximum permissible timeout allowed by
    * the runtime environment.
    * @return the timeout interval (expressed in seconds)
    * to use for the next checkpoint interval
    * @throws Exception thrown for any errors.
    */
    public int checkpointTimeout() throws Exception;
    /**
    * The beginCheckpoint method is invoked before the
    * next checkpoint interval begins (before the next
    * chunk transaction begins).
    * @throws Exception thrown for any errors.
    */
    public void beginCheckpoint() throws Exception;
    /**
    * The isReadyToCheckpoint method is invoked by
    * the batch runtime after each item is processed
    * to determine if now is the time to checkpoint
    * the current chunk.
    * *@return* boolean indicating whether or not
    * to checkpoint now.
    * @throws Exception thrown for any errors.
    */
    public boolean isReadyToCheckpoint() throws Exception;
    /**
    * The endCheckpoint method is invoked after the
    * last checkpoint is taken (after the chunk
    * transaction is committed).
    * @throws Exception thrown for any errors.
    */
    public void endCheckpoint() throws Exception;
}
----

[[app-listing.AbstractCheckpointAlgorithm.java]]
[source,java]
.AbstractCheckpointAlgorithm.java
----
package jakarta.batch.api.chunk;
/**
* The AbstractCheckpointAlgorithm provides default
* implementations of less commonly implemented
* methods.
*/
public abstract class AbstractCheckpointAlgorithm implements
CheckpointAlgorithm {
    /**
    * Override this method if the CheckpointAlgorithm
    * establishes a checkpoint timeout.
    * The default implementation returns 0, which means
    * the maximum permissible timeout allowed by the
    * runtime environment.
    *
    * @return the timeout interval (expressed in seconds)
    * to use for the next checkpoint interval
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public int checkpointTimeout() throws Exception {
        return 0;
    }
    /**
    * Override this method for the CheckpointAlgorithm
    * to do something before a checkpoint interval
    * begins (before the next chunk transaction begins).
    * The default implementation does nothing.
    *
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void beginCheckpoint() throws Exception {
    }
    /**
    * Implement logic in this method
    * to decide if a checkpoint should be taken now.
    *
    * *@return* boolean indicating whether or not
    * to checkpoint now.
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public abstract boolean isReadyToCheckpoint() throws Exception;
    /**
    * Override this method for the CheckpointAlgorithm
    * to do something after a checkpoint is taken (after
    * the chunk transaction is committed).
    * The default implementation does nothing.
    *
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void endCheckpoint() throws Exception {
    }
}
----

==== Batchlet Interface
A Batchlet-type step implements a roll your own batch pattern. This
batch pattern is invoked once, runs to completion, and returns an exit
status.

The Batchlet interface may be used to implement a Batchlet batch
artifact:

[[app-listing.Batchlet.java]]
[source,java]
.Batchlet.java
----
package jakarta.batch.api;
/**
*
* A batchlet is type of batch step
* that can be used for any type of
* background processing that does not
* explicitly call for a chunk oriented
* approach.
* <p>
* A well-behaved batchlet responds
* to stop requests by implementing
* the stop method.
*
*/
public interface Batchlet {
    /**
    * The process method does the work
    * of the batchlet. If this method
    * throws an exception, the batchlet
    * step ends with a batch status of
    * FAILED.
    * *@return* exit status string
    * @throws Exception if an error occurs.
    */
    public String process() throws Exception;
    /**
    * The stop method is invoked by the batch
    * runtime as part of JobOperator.stop()
    * method processing. This method is invoked
    * on a thread other than the thread on which
    * the batchlet process method is running.
    *
    * @throws Exception if an error occurs.
    */
    public void stop() throws Exception;
}
----

[[app-listing.AbstractBatchlet.java]]
[source,java]
.AbstractBatchlet.java
----
package jakarta.batch.api;
/**
* The AbstractBatchlet provides default
* implementations of less commonly implemented methods.
*/
public abstract class AbstractBatchlet implements Batchlet {
    /**
    * Implement process logic for the Batchlet in this
    * method.
    *
    * *@return* exit status string
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public abstract String process() throws Exception;
    /**
    * Override this method if the Batchlet will
    * end in response to the JobOperator.stop()
    * operation.
    * The default implementation does nothing.
    *
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void stop() throws Exception {
    }
}
----

TIP: A well designed batchlet stops gracefully when the JobOperator.stop operation is invoked.  
See section xref:_stop_processing[11.13] for further information about stop processing.

=== Listeners
Use Listeners to interpose on batch execution.

==== JobListener Interface
A job listener receives control before and after a job execution runs,
and also if an exception is thrown during job processing. The
JobListener interface may be used to implement an JobListener batch
artifact:

[[app-listing.JobListener.java]]
[source,java]
.JobListener.java
----
package jakarta.batch.api.listener;
/**
* JobListener intercepts job execution.
*
*/
public interface JobListener {
    /**
    * The beforeJob method receives control
    * before the job execution begins.
    * @throws Exception throw if an error occurs.
    */
    public void beforeJob() throws Exception;
    /**
    * The afterJob method receives control
    * after the job execution ends.
    * @throws Exception throw if an error occurs.
    */
    public void afterJob() throws Exception;
}
----

[[app-listing.AbstractJobListener.java]]
[source,java]
.AbstractJobListener.java
----
package jakarta.batch.api.listener;
/**
* The AbstractJobListener provides default
* implementations of less commonly implemented methods.
*/
public abstract class AbstractJobListener implements JobListener
{
    /**
    * Override this method if the JobListener
    * will do something before the job begins.
    * The default implementation does nothing.
    *
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void beforeJob() throws Exception {
    }
    /**
    * Override this method if the JobListener
    * will do something after the job ends.
    * The default implementation does nothing.
    *
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void afterJob() throws Exception {
    }
}
----


==== StepListener Interface
A step listener can receive control before and after a step runs, and
also if an exception is thrown during step processing. The StepListener
interface may be used to implement an StepListener batch artifact:

[[app-listing.StepListener.java]]
[source,java]
.StepListener.java
----
package jakarta.batch.api.listener;
/**
* StepListener intercepts step execution.
*
*/
public interface StepListener {
    /**
    * The beforeStep method receives control
    * before a step execution begins.
    * @throws Exception throw if an error occurs.
    */
    public void beforeStep() throws Exception;
    /**
    * The afterStep method receives control
    * after a step execution ends.
    * @throws Exception throw if an error occurs.
    */
    public void afterStep() throws Exception;
}
----

[[app-listing.AbstractStepListener.java]]
[source,java]
.AbstractStepListener.java
----
package jakarta.batch.api.listener;
/**
* The AbstractStepListener provides default
* implementations of less commonly implemented methods.
*/
public abstract class AbstractStepListener implements
StepListener {
    /**
    * Override this method if the StepListener
    * will do something before the step begins.
    * The default implementation does nothing.
    *
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void beforeStep() throws Exception {
    }
    /**
    * Override this method if the StepListener
    * will do something after the step ends.
    * The default implementation does nothing.
    *
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void afterStep() throws Exception {
    }
}
----


==== ChunkListener Interface
A chunk listener can receive control at the beginning and the end of
chunk, and upon an exception thrown back to the runtime implementation.
The ChunkListener interface may be used to implement a ChunkListener
batch artifact:

[[app-listing.ChunkListener.java]]
[source,java]
.ChunkListener.java
----
package jakarta.batch.api.chunk.listener;
/**
* ChunkListener intercepts chunk processing.
*
*/
public interface ChunkListener {
    /**
    * The beforeChunk method receives control
    * before processing of the next
    * chunk begins. This method is invoked
    * in the same transaction as the chunk
    * processing.
    * @throws Exception throw if an error occurs.
    */
    public void beforeChunk() throws Exception;
    /**
    * The onError method receives control
    * before the chunk transaction is rolled back.
    * Note afterChunk is not invoked in this case.
    * @param ex specifies the exception that
    * caused the roll back.
    * @throws Exception throw if an error occurs.
    */
    public void onError(Exception ex) throws Exception;
    /**
    * The afterChunk method receives control
    * after processing of the current
    * chunk ends. This method is invoked
    * in the same transaction as the chunk
    * processing.
    * @throws Exception throw if an error occurs.
    */
    public void afterChunk() throws Exception;
}
----

[[app-listing.AbstractChunkListener.java]]
[source,java]
.AbstractChunkListener.java
----
package jakarta.batch.api.chunk.listener;
/**
* The AbstractChunkListener provides default
* implementations of less commonly implemented methods.
*/
public abstract class AbstractChunkListener implements
ChunkListener {
    /**
    * Override this method if the ChunkListener
    * will do something before the chunk begins.
    * The default implementation does nothing.
    *
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void beforeChunk() throws Exception {
    }
    /**
    * Override this method if the ChunkListener will do
    * something before the chunk transaction is rolled back.
    * Note afterChunk is not invoked in this case.
    * @param ex specifies the exception that
    * caused the roll back.
    * @throws Exception (or subclass) throw if an error occurs.
    */
    @Override
    public void onError(Exception ex) throws Exception {
    }
    /**
    * Override this method if the ChunkListener
    * will do something after the chunk ends.
    * The default implementation does nothing.
    *
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void afterChunk() throws Exception {
    }
}
----


==== ItemReadListener Interface
An item read listener can receive control before and after an item is
read by an item reader, and also if the reader throws an exception. The
ItemReadListener interface may be used to implement an ItemReadListener
batch artifact:

[[app-listing.ItemReadListener.java]]
[source,java]
.ItemReadListener.java
----
package jakarta.batch.api.chunk.listener;
/**
* ItemReadListener intercepts item reader
* processing.
*
*/
public interface ItemReadListener {
    /**
    * The beforeRead method receives control
    * before an item reader is called to read the next item.
    * @throws Exception is thrown if an error occurs.
    */
    public void beforeRead() throws Exception;
    /**
    * The afterRead method receives control after an item
    * reader reads an item. The method receives the item read as
    * an input.
    * @param item specifies the item read by the item reader.
    * @throws Exception is thrown if an error occurs.
    */
    public void afterRead(Object item) throws Exception;
    /**
    * The onReadError method receives control after an item reader
    * throws an exception in the readItem method.
    * This method receives the exception as an input.
    * @param ex specifies the exception that occurred in the item reader.
    * @throws Exception is thrown if an error occurs.
    */
    public void onReadError(Exception ex) throws Exception;
}
----

[[app-listing.AbstractItemReadListener.java]]
[source,java]
.AbstractItemReadListener.java
----
package jakarta.batch.api.chunk.listener;
/**
* The AbstractItemReadListener provides default
* implementations of less commonly implemented methods.
*/
public abstract class AbstractItemReadListener implements
ItemReadListener {
    /**
    * Override this method if the ItemReadListener
    * will do something before the item is read.
    * The default implementation does nothing.
    *
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void beforeRead() throws Exception {
    }
    /**
    * Override this method if the ItemReadListener
    * will do something after the item is read.
    * The default implementation does nothing.
    *
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void afterRead(Object item) throws Exception {
    }
    /**
    * Override this method if the ItemReadListener
    * will do something when the ItemReader readItem
    * method throws an exception.
    * The default implementation does nothing.
    *
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void onReadError(Exception ex) throws Exception {
    }
}
----



==== ItemProcessListener Interface
An item processor listener can receive control before and after an item
is processed by an item processor, and also if the processor throws an
exception. The ItemProcessListener interface may be used to implement an
ItemProcessListener batch artifact:


[[app-listing.ItemProcessListener.java]]
[source,java]
.ItemProcessListener.java
----
package jakarta.batch.api.chunk.listener;
/**
* ItemProcessListener intercepts item processing.
*
*/
public interface ItemProcessListener {
    /**
    * The beforeProcess method receives control before
    * an item processor is called to process the next item.
    * The method receives the item to be processed as an input.
    * @param item specifies the item about to be processed.
    * @throws Exception if an error occurs.
    */
    public void beforeProcess(Object item) throws Exception;
    /**
    * The afterProcess method receives control after an item
    * processor processes an item. The method receives the item processed
    * and the result item as an input.
    * @param item specifies the item processed by the item processor.
    * @param result specifies the item to pass to the item writer.
    * @throws Exception if an error occurs.
    */
    public void afterProcess(Object item, Object result) throws
    Exception;
    /**
    * The onProcessError method receives control after an
    * item processor processItem throws an exception. The method
    * receives the item sent to the item processor as input.
    * @param item specifies the item the processor attempted to process.
    * @param ex specifies the exception thrown by the item processor.
    * @throws Exception if an error occurs
    */
    public void onProcessError(Object item, Exception ex) throws
    Exception;
}
----

[[app-listing.AbstractItemProcessListener.java]]
[source,java]
.AbstractItemProcessListener.java
----
package jakarta.batch.api.chunk.listener;
/**
* The AbstractItemProcessListener provides default
* implementations of less commonly implemented methods.
*
*/
public abstract class AbstractItemProcessListener implements
ItemProcessListener {
    /**
    * Override this method if the ItemProcessListener
    * will do something before the item is processed.
    * The default implementation does nothing.
    *
    * @param item specifies the item about to be processed.
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void beforeProcess(Object item) throws Exception {
    }
    /**
    * Override this method if the ItemProcessListener
    * will do something after the item is processed.
    * The default implementation does nothing.
    *
    * @param item specifies the item about to be processed.
    * @param result specifies the item to pass to the item writer.
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void afterProcess(Object item, Object result) throws
    Exception {
    }
    /**
    * Override this method if the ItemProcessListener
    * will do something when the ItemProcessor processItem
    * method throws an exception.
    * The default implementation does nothing.
    *
    * @param item specifies the item about to be processed.
    * @param ex specifies the exception thrown by the item processor.
    * @throws Exception (or subclass) if an error occurs.
    */
    @Override
    public void onProcessError(Object item, Exception ex) throws
    Exception {
    }
}
----




==== ItemWriteListener Interface
A item write listener can receive control before and after an item is
written by an item writer, and also if the writer throws an exception.
The ItemWriteListener interface may be used to implement an
ItemWriteListener batch artifact:

[[app-listing.ItemWriteListener.java]]
[source,java]
.ItemWriteListener.java
----
package jakarta.batch.api.chunk.listener;
import java.util.List;
/**
* ItemWriteListener intercepts item writer
* processing.
*
*/
public interface ItemWriteListener {
    /**
    * The beforeWrite method receives control before
    * an item writer is called to write its items. The
    * method receives the list of items sent to the item
    * writer as an input.
    * @param items specifies the items about to be
    * written.
    * @throws Exception is thrown if an error occurs.
    */
    public void beforeWrite(List<Object> items) throws Exception;
    /**
    * The afterWrite method receives control after an
    * item writer writes its items. The method receives the
    * list of items sent to the item writer as an input.
    * @param items specifies the items written by the item writer.
    * @throws Exception is thrown if an error occurs.
    */
    public void afterWrite(List<Object> items) throws Exception;
    /**
    * The onWriteError method receives control after an
    * item writer writeItems throws an exception. The method
    * receives the list of items sent to the item writer as input.
    * @param items specifies the items which the item writer
    * attempted to write.
    * @param ex specifies the exception thrown by the item
    * writer.
    * @throws Exception is thrown if an error occurs.
    */
    public void onWriteError(List<Object> items, Exception ex) throws
    Exception;
}
----

==== Skip Listener Interfaces
A skip listener can receive control when a skippable exception is
thrown from an item reader, processor, or writer. Three interfaces are
provided to implement these listeners:

[[app-listing.SkipReadListener.java]]
[source,java]
.SkipReadListener.java
----
package jakarta.batch.api.chunk.listener;
/**
* SkipReadListener intercepts skippable
* itemReader exception handling.
*/
public interface SkipReadListener {
    /**
    * The onSkipReadItem method receives control
    * when a skippable exception is thrown from an
    * ItemReader readItem method. This method receives the
    * exception as an input.
    * @param ex specifies the exception thrown by the ItemReader.
    * @throws Exception is thrown if an error occurs.
    */
    public void onSkipReadItem(Exception ex) throws Exception;
}
----

[[app-listing.SkipProcessListener.java]]
[source,java]
.SkipProcessListener.java
----
package jakarta.batch.api.chunk.listener;
/**
* SkipProcessListener intercepts skippable
* itemProcess exception handling.
*/
public interface SkipProcessListener {
    /**
    * The onSkipProcessItem method receives control when
    * a skippable exception is thrown from an ItemProcess
    * processItem method.
    * This method receives the exception and the item to process
    * as an input.
    * @param item specifies the item passed to the ItemProcessor.
    * @param ex specifies the exception thrown by the
    * ItemProcessor.
    * @throws Exception is thrown if an error occurs.
    */
    public void onSkipProcessItem(Object item, Exception ex) throws
    Exception;
}
----

[[app-listing.SkipWriteListener.java]]
[source,java]
.SkipWriteListener.java
----
package jakarta.batch.api.chunk.listener;
import java.util.List;
/**
* SkipWriteListener intercepts skippable
* itemWriter exception handling.
*/
public interface SkipWriteListener {
    /**
    * The onSkipWriteItems method receives control when a
    * skippable exception is thrown from an ItemWriter
    * writeItems method. This
    * method receives the exception and the items that were
    * skipped as an input.
    * @param items specifies the list of item passed to the
    * item writer.
    * @param ex specifies the exception thrown by the
    * ItemWriter.
    * @throws Exception is thrown if an error occurs.
    */
    public void onSkipWriteItem(List<Object> items, Exception ex)
    throws Exception;
}
----

==== RetryListener Interface

A retry listener can receive control when a retryable exception is
thrown from an item reader, processor, or writer. Three interfaces are
provided to implement these listeners:

[[app-listing.RetryReadListener.java]]
[source,java]
.RetryReadListener.java
----
package jakarta.batch.api.chunk.listener;
/**
* RetryReadListener intercepts retry processing for
* an ItemReader.
*/
public interface RetryReadListener {
    /**
    * The onRetryReadException method receives control
    * when a retryable exception is thrown from an ItemReader
    * readItem method.
    * This method receives the exception as input. This method
    * receives control in the same checkpoint scope as the
    * ItemReader. If this method throws a an exception, the job
    * ends in the FAILED state.
    * @param ex specifies the exception thrown by the item
    * reader.
    * @throws Exception is thrown if an error occurs.
    */
    public void onRetryReadException(Exception ex) throws Exception;
}
----

[[app-listing.RetryProcessListener.java]]
[source,java]
.RetryProcessListener.java
----
package jakarta.batch.api.chunk.listener;
/**
* RetryProcessListener intercepts retry processing for
* an ItemProcessor.
*
*/
public interface RetryProcessListener {
    /**
    * The onRetryProcessException method receives control
    * when a retryable exception is thrown from an ItemProcessor
    * processItem method. This method receives the exception and the item
    * being processed as inputs. This method receives control in same
    * checkpoint scope as the ItemProcessor. If this method
    * throws a an exception, the job ends in the FAILED state.
    * @param item specifies the item passed to the ItemProcessor.
    * @param ex specifies the exception thrown by the ItemProcessor.
    * @throws Exception is thrown if an error occurs.
    */
    public void onRetryProcessException(Object item, Exception ex)
    throws Exception;
}
----


[[app-listing.RetryWriteListener.java]]
[source,java]
.RetryWriteListener.java
----
package jakarta.batch.api.chunk.listener;
import java.util.List;
/**
* RetryWriteListener intercepts retry processing for
* an ItemWriter.
*
*/
public interface RetryWriteListener {
    /**
    * The onRetryWriteException method receives control when a
    * retryable exception is thrown from an ItemWriter writeItems
    * method. This method receives the exception and the list of items
    * being written as inputs.
    * This method receives control in same checkpoint scope as the
    * ItemWriter. If this method throws a an exception, the job ends
    * in the FAILED state.
    * @param items specify the items passed to an item writer.
    * @param ex specifies the exception thrown by an item
    * writer.
    * @throws Exception is thrown if an error occurs.
    */
    public void onRetryWriteException(List<Object> items, Exception ex)
    throws Exception;
}
----

=== Batch Properties

Batch applications need a way to receive parameters when a job is
initiated for execution. Properties can be defined by batch programming
model artifacts, then have values passed to them when a job is
initiated. Batch properties are string values.

Note batch properties are visible only in the scope in which they are
defined (see Section xref:_scope_of_property_definitions_for_batchproperty[9.3.2]). However batch properties values can be
formed from other properties according to Job XML Substitution Rules.
See section xref:_job_xml_substitution[8.8] for further information on substitution.

==== @BatchProperty

The @BatchProperty annotation identifies a class field injection as a
batch property. A batch property has a name (name) and default value.
The @BatchProperty may be used on a class field for any class identified
as a batch programming model artifact -E.g. ItemReader, ItemProcessor,
JobListener, etc..

@BatchProperty must be used with the standard @Inject annotation
(jakarta.inject.Inject). @BatchProperty is used to assign batch artifact
property values from Job XML to the batch artifact itself.

A field annotated with the @BatchProperty annotation must not be static
and must not be final.

Note: the batch runtime must ensure @Inject works with @BatchProperty,
whether or not the execution environment includes an implementation of
JSR 299 or 330. This means the batch properties may always be injected.
Whether or not other injections are supported is dependent upon the
batch runtime implementation.

Syntax:

[[app-listing.batchProperty]]
[source,java]
----
 package: jakarta.batch.api

 @Inject @BatchProperty(name=""<property-name>"") String <field-name>;
----

Where:

[width=""100%"",cols=""<50%,<50%"",]
|=======================================================================
|<property-name> |is the optional name of this batch property. The
default is the Java field name.

|<field-name> |is the field name of the batch property.
|=======================================================================

[[app-listing.BatchProperty.java]]
[source,java]
.BatchProperty.java
----
package jakarta.batch.api;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import jakarta.enterprise.util.Nonbinding;
import jakarta.inject.Qualifier;
/**
* Annotation used by batch artifacts to declare a
* field which is injectable via a JSL-defined value
* (possibly leveraging Job XML substitutions).
*
*/
@Qualifier
@Target({
    ElementType._FIELD_, ElementType._METHOD_,
    ElementType._PARAMETER_
}
)
@Retention(RetentionPolicy._RUNTIME_)
public @interface BatchProperty {
    @Nonbinding
    public String name() default """";
}
----

The value of the annotated field is assigned by the batch runtime if a
corresponding property element with a matching name is specified in the
JSL in the scope that applies to the batch artifact in question. If the
JSL property value resolves to the empty string (either explicitly set
to the empty string literal or resolving to an empty string via property
substitution – see section xref:_job_xml_substitution[8.8]), no assignment is made and the resulting
value is undefined by the batch specification. The resulting value might
simply be the Java default value, however using various dependency
injection technologies may produce different results. The resultant
behavior may be defined by the particular dependency injection
technology used in the runtime environment and so is outside the scope
of this specification.
Example:

[[app-listing.BatchPropertySample]]
[source,java]
----
 import jakarta.inject.Inject;
 import jakarta.batch.api.BatchProperty;
 public class MyItemReaderImpl {

@Inject @BatchProperty String fname;

}
----

Behavior:

When the batch runtime instantiates the batch artifact (item reader in
this example), it assigns the

value of the property with name equal to fname provided in the job XML
to the corresponding @BatchProperty field named fname. If no value is
defined in JSL, the Java default (null) is assigned or some other
default is provided by a particular dependency injection technology.

==== Scope of property definitions for @BatchProperty Injection

The rules governing the definition of properties for injection via
@BatchProperty deserve some extra explanation and an example.

For a given artifact, the only properties that are injectable via
@BatchProperty are those which are defined at the level of the artifact
itself (i.e. as children of the ""properties"" element which is in turn a
child of the very element defining the artifact: batchlet, reader,
listener, etc.).

In particular, just because an artifact definition is contained (at some
level of nesting) within a job element and (for most artifacts) within a
step element as well, it is NOT the case that the job properties and
step properties are themselves injectable into that artifact via
@BatchProperty. This is the case even though these job and step
properties are available for resolving the artifact-level property
definitions via the jobProperties substitution mechanism (see section
8.8.1.2) .

The following example should make this more clear:

[[app-listing.BatchPropertyXML]]
[source,xml]
.Example JSL
----
<job>
 <properties>
 <property name=""x"" value=""xVal""/>
 ...
 <step id=""step1"">
  <batchlet ref=""MyBatchlet"">
   <properties>
    <property name=""y"" value=""#\\{jobProperties['x']}""/>
   </properties>

----

*Example Java (MyBatchlet from JSL above):*

[[app-listing.BadBatchProperty]]
[source,java]
----
 // WONT WORK! - There is no property 'x' in scope for this injection
 @Inject @BatchProperty(name=""x"");

 // WILL WORK – Gets value 'xVal'
 @Inject @BatchProperty(name=""y"");
----

=== Batch Contexts

Context objects are supplied by the batch runtime and provide important
functions to a batch application. Contexts provide information about the
running batch job, provide a place for a batch job to store interim
values, and provide a way for the batch application to communicate
important information back to the batch runtime. Contexts can be
injected into an application as member variables. There is a context for
both job and step. The job context represents the entire job. The step
context represents the current step executing within the job.

==== Batch Contexts
Batch artifact access to batch contexts is by injection using the
standard @Inject annotation (jakarta.inject.Inject). A field into which a
batch context is injected must not be static and must not be final.
E.g.:

 @Inject JobContext _jctxt;

 @Inject StepContext _sctxt;

The batch runtime is responsible to ensure the correct context object is
injected according to the job or step currently executing.

Note: the batch runtime must ensure @Inject works with JobContext and
StepContext, whether or not the execution environment includes an
implementation of JSR 299 or 330. This means the batch contexts may
always be injected. Whether or not other injections are supported is
dependent upon the batch runtime implementation.
 See section 10.9.1 for definition of JobContext class. See section
10.9.2 for definition of StepContext class.

===== Batch Context Lifecycle and Scope

A batch context has thread affinity and is visible only to the batch
artifacts executing on that particular thread. A batch context injected
field may be null when out of scope. Each context type has a distinct
scope and lifecycle as follows:

1.  JobContext +
+
There is one JobContext per job execution. It exists for the life of a
job. There is a distinct JobContext for each sub-thread of a parallel
execution (e.g. partitioned step).

2.  StepContext +
+
There is one StepContext per step execution. It exists for the life of
the step. For a partitioned step, there is one StepContext for the
parent step/thread; there is a distinct StepContext for each sub-thread
and each StepContext has its own distinct persistent user data for each
sub-thread.

=== Parallelization

Batch jobs may be configured to run some of their steps in parallel.
There are two supported parallelization models:

. Partitioned:
+
In the partitioned model, a step is configured to run as multiple
instances across multiple threads. Each thread runs the same step or
flow. This model is logically equivalent to launching multiple instances
of the same step. It is intended that each partition processes a
different range of the input items.
+
The partitioned model includes several optional batch artifacts to
enable finer control over parallel processing:
+
.. PartitionMapper provides a programmatic means for calculating the
number of partitions and unique properties for each.
.. PartitionReducer provides a unit of work demarcation around
partition processing.
.. PartitionCollector provides a means for merging interrim results
from individual partitions.
.. PartitionAnalyzer provides a means to gather interrim and final
results from individual partitions for single point of control
processing and decision making.

. Concurrent:
+
In the concurrent model, the flows defined by a split are configured to
run concurrently on multiple threads, one flow per thread.

==== PartitionMapper Interface
A partition mapper receives control at the start of a partitioned
execution. The partition mapper is responsible to provide unique batch
properties for each partition. The PartitionMapper interface may be used
to implement a PartitionMapper batch artifact:

[[app-listing.PartitionMapper.java]]
[source,java]
.PartitionMapper.java
----
package jakarta.batch.api.partition;
import jakarta.batch.api.partition.PartitionPlan;
/**
* PartitionMapper receives control at the start of a partitioned
* execution. A PartitionMapper is responsible to provide unique
* batch properties for each partition.
*
*/
public interface PartitionMapper {
    /**
    * The mapPartitions method that receives control at the
    * start of partitioned step processing. The method
    * returns a PartitionPlan, which specifies the batch properties
    * for each partition.
    * *@return* partition plan for a partitioned step.
    * @throws Exception is thrown if an error occurs.
    */
    public PartitionPlan mapPartitions( ) throws Exception;
}
----

See section 10.9.4 for details on the PartitionPlan result value type.

The PartitionMapper, when defined, is invoked upon every execution,
including restarted executions. For a full discussion of the behavior on
restart, including how to override particular details of the
PartitionPlan built by the previous execution, see section xref:_batchruntime[10.8.5].

==== PartitionReducer Interface

A partition reducer provides a unit of work demarcation across
partitions. It is not a JTA transaction; no resources are enlisted.
Rather, it provides transactional flow semantics to facilitate
finalizing merge or compensation logic. The PartitionReducer interface
may be used to implement an PartitionReducer batch artifact:

[[app-listing.PartitionReducer.java]]
[source,java]
.PartitionReducer.java
----
package jakarta.batch.api.partition;
/**
* PartitionReducer provides unit of work demarcation across
* partitions. It is not a JTA transaction; no resources are
* enlisted. Rather, it provides transactional flow semantics
* to facilitate finalizing merge or compensation logic.
*
*/
public interface PartitionReducer {
    public *enum* PartitionStatus {
        COMMIT_, _ROLLBACK
    }
    /**
    * The beginPartitionedStep method receives
    * control at the start of partition processing.
    * It receives control before the PartitionMapper
    * is invoked and before any partitions are started.
    * @throws Exception is thrown if an error occurs.
    */
    public void beginPartitionedStep() throws Exception;
    /**
    * The beforePartitionedStepCompletion method
    * receives control at the end of partitioned
    * step processing. It receives control after all
    * partitions have completed. It does not receive
    * control if the PartitionReducer is rolling back.
    * @throws Exception is thrown if an error occurs.
    */
    public void beforePartitionedStepCompletion() throws Exception;
    /**
    * The rollbackPartitionedStep method receives
    * control if the runtime is rolling back a partitioned
    * step. Any partition threads still running are
    * allowed to complete before this method is invoked. This method
    * receives control if any of the following conditions
    * are true:
    * <p>
    * <ol>
    * <li>One or more partitions end with a Batch Status of
    * STOPPED or FAILED.</li>
    * <li>Any of the following partitioned step callbacks
    * throw an exception:</li>
    * <ol>
    * <li>PartitionMapper</li>
    * <li>PartitionReducer</li>
    * <li>PartitionCollector</li>
    * <li>PartitionAnalyzer</li>
    * </ol>
    * <li>A job with partitioned steps is restarted.</li>
    * </ol>
    * @throws Exception is thrown if an error occurs.
    */
    public void rollbackPartitionedStep() throws Exception;
    /**
    * The afterPartitionedStepCompletion method receives control
    * at the end of a partition processing. It receives a status
    * value that identifies the outcome of the partition processing.
    * The status string value is either ""COMMIT"" or ""ROLLBACK"".
    * @param status specifies the outcome of the partitioned step. Values
    * are ""COMMIT"" or ""ROLLBACK"".
    * @throws Exception is thrown if an error occurs.
    */
    public void afterPartitionedStepCompletion(PartitionStatus status)
    throws Exception;
}
----

[[app-listing.AbstractPartitionReducer.java]]
[source,java]
.AbstractPartitionReducer.java
----
package jakarta.batch.api.partition;
/**
* The AbstractPartitionReducer provides default
* implementations of less commonly implemented methods.
*/
public abstract class AbstractPartitionReducer implements
PartitionReducer {
    /**
    * Override this method to take action before
    * partitioned step processing begins.
    *
    * @throws Exception is thrown if an error occurs.
    */
    @Override
    public void beginPartitionedStep() throws Exception {
    }
    /**
    * Override this method to take action before
    * normal partitioned step processing ends.
    *
    * @throws Exception is thrown if an error occurs.
    */
    @Override
    public void beforePartitionedStepCompletion() throws Exception {
    }
    /**
    * Override this method to take action when a
    * partitioned step is rolling back.
    *
    * @throws Exception is thrown if an error occurs.
    */
    @Override
    public void rollbackPartitionedStep() throws Exception {
    }
    /**
    * Override this method to take action after
    * partitioned step processing ends.
    *
    * @param status specifies the outcome of the partitioned step.
    * Values are ""COMMIT"" or ""ROLLBACK"".
    * @throws Exception is thrown if an error occurs.
    */
    @Override
    public void afterPartitionedStepCompletion(PartitionStatus status)
    throws Exception {
    }
}
----

==== PartitionCollector Interface

A partition collector provides a way to send data from individual
partitions to a single point of control running on the parent thread.
The PartitionAnalyzer is used to receive and process this data. See
section xref:_partitionanalyzer_interface[9.5.4] for further information about the PartitionAnalyzer. The
PartitionCollector interface may be used to implement an
PartitionCollector batch artifact:

[[app-listing.PartitionCollector.java]]
[source,java]
.PartitionCollector.java
----
package jakarta.batch.api.partition;
import java.io.Serializable;
/**
* PartitionCollector provides a way to pass data from
* individual partitions to a single point of control running on
* the step's parent thread. The PartitionAnalyzer is used to
* receive and process this data.
*
*/
public interface PartitionCollector {
    /**
    * The collectPartitionData method receives control
    * periodically during partition processing.
    * This method receives control on each thread processing
    * a partition as follows:
    * <p>
    * <ol>
    * <li>for a chunk type step, it receives control after
    * every chunk checkpoint and then one last time at the
    * end of the partition;
    </li>
    * <li>for a batchlet type step, it receives control once
    * at the end of the batchlet.</li>
    * </ol>
    * <p>
    * Note the collector is not called if the partition
    * terminates due to an unhandled exception.
    * <p>
    * *@return* an Serializable object to pass to the
    * PartitionAnalyzer.
    * @throws Exception is thrown if an error occurs.
    */
    public Serializable collectPartitionData() throws Exception;
}
----

==== PartitionAnalyzer Interface

A partition analyzer receives control to process data and final results
from partitions. If a partition collector is configured on the step, the
partition analyzer receives control to process the data and results from
the partition collector. While a separate partition collector instance
is invoked on each thread processing a partition, the partition analyzer
runs on a single, consistent thread each time it is invoked. The
PartitionAnalyzer interface may be used to implement an
PartitionAnalyzer batch artifact:

[[app-listing.PartitionAnalyzer.java]]
[source,java]
.PartitionAnalyzer.java
----
package jakarta.batch.api.partition;
import java.io.Serializable;
import jakarta.batch.runtime.BatchStatus;
/**
* PartitionAnalyzer receives control to process
* data and final results from each partition. If
* a PartitionCollector is configured on the step,
* the PartitionAnalyzer receives control to process
* the data and results from the partition collector.
* While a separate PartitionCollector instance is
* invoked on each thread processing a step partition,
* a single PartitionAnalyzer instance runs on a single,
* consistent thread each time it is invoked.
*
*/
public interface PartitionAnalyzer {
    /**
    * The analyzeCollectorData method receives
    * control each time a Partition collector sends
    * its payload. It receives the
    * Serializable object from the collector as an
    * input.
    * @param data specifies the payload sent by a
    * PartitionCollector.
    * @throws Exception is thrown if an error occurs.
    */
    public void analyzeCollectorData(Serializable data) throws
    Exception;
    /**
    * The analyzeStatus method receives control each time a
    * partition ends. It receives the batch and exit
    * status strings of the partition as inputs.
    * @param batchStatus specifies the batch status of a partition.
    * @param exitStatus specifies the exit status of a partition.
    * @throws Exception is thrown if an error occurs.
    */
    public void analyzeStatus(BatchStatus batchStatus, String
    exitStatus) throws Exception;
}
----

[[app-listing.AbstractPartitionAnalyzer.java]]
[source,java]
.AbstractPartitionAnalyzer.java
----
package jakarta.batch.api.partition;
import java.io.Serializable;
import jakarta.batch.runtime.BatchStatus;
/**
* The AbstractPartitionAnalyzer provides default
* implementations of less commonly implemented methods.
*/
public abstract class AbstractPartitionAnalyzer implements
PartitionAnalyzer {
    /**
    * Override this method to analyze PartitionCollector payloads.
    *
    * @param data specifies the payload sent by the
    * PartitionCollector.
    * @throws Exception is thrown if an error occurs.
    */
    @Override
    public void analyzeCollectorData(Serializable data) throws
    Exception {
    }
    /**
    * Override this method to analyze partition end status.
    * @param batchStatus specifies the batch status of a partition.
    * @param exitStatus specifies the exit status of a partition.
    * @throws Exception is thrown if an error occurs.
    */
    @Override
    public void analyzeStatus(BatchStatus batchStatus, String
    exitStatus)
    throws Exception {
    }
}
----


=== Decider Interface

A decider may be used to determine batch exit status and sequencing
between steps, splits, and flows in a Job XML. The decider returns a
String value which becomes the exit status value on which the decision
chooses the next transition. The Decider interface may be used to
implement an Decider batch artifact:

[[app-listing.Decider.java]]
[source,java]
.Decider.java
----
package jakarta.batch.api;
import jakarta.batch.runtime.StepExecution;
/**
* A Decider receives control as part of a decision element
* in a job. It is used to direct execution flow during job
* processing. It returns an exit status that updates the
* current job execution's exit status. This exit status
* value also directs the execution transition based on
* next, end, stop, fail child elements configured on the
* same decision element as the decider.
*/
public interface Decider {
    /**
    * The decide method sets a new exit status for a job.
    * It receives an array of StepExecution objects as input.
    * These StepExecution objects represent the execution
    * element that transitions to this decider as follows:
    * <p>
    * <ul>
    * <li>Step</li>
    * <p>
    * When the transition is from a step, the decide method
    * receives the StepExecution corresponding
    * to the step as input.
    * <li>Split</li>
    * <p>
    * When the transition is from a split, the decide method
    * receives a StepExecution from each flow defined to the split
    * as input.
    * <li>Flow</li>
    * <p>
    * When the transition is from a flow, the decide method
    * receives a StepExecution corresponding
    * to the last execution element that completed in the flow.
    * This will be a single StepExecution if the last element
    * was a step and multiple StepExecutions if the last element
    * was a split.
    * </ul>
    * @param executions specifies the StepExecution(s) of the preceding
    * element.
    * *@return* updated job exit status
    * @throws Exception is thrown if an error occurs.
    */
    public String decide(StepExecution[] executions) throws Exception;
}
----


=== Transactionality

Chunk type check points are transactional. The batch runtime uses global
transaction mode on the Jakarta EE platform and local transaction mode on
the Java SE platform. Global transaction timeout is configurable at
step-level with a step-level property:

'jakarta.transaction.global.timeout={seconds} - default is 180
seconds'

Example:
[source,xml]
----
 <step id=""MyGlobalStep"">
  <properties>
   <property name=""jakarta.transaction.global.timeout"" value=""600""/>
  </properties>
 </step>
----
",12055,False,2247.906580689265,median
"#include ""source/common/router/router.h""

#include <chrono>
#include <cstdint>
#include <functional>
#include <memory>
#include <string>

#include ""envoy/event/dispatcher.h""
#include ""envoy/event/timer.h""
#include ""envoy/grpc/status.h""
#include ""envoy/http/conn_pool.h""
#include ""envoy/runtime/runtime.h""
#include ""envoy/upstream/cluster_manager.h""
#include ""envoy/upstream/health_check_host_monitor.h""
#include ""envoy/upstream/upstream.h""

#include ""source/common/common/assert.h""
#include ""source/common/common/cleanup.h""
#include ""source/common/common/empty_string.h""
#include ""source/common/common/enum_to_int.h""
#include ""source/common/common/scope_tracker.h""
#include ""source/common/common/utility.h""
#include ""source/common/config/utility.h""
#include ""source/common/grpc/common.h""
#include ""source/common/http/codes.h""
#include ""source/common/http/header_map_impl.h""
#include ""source/common/http/headers.h""
#include ""source/common/http/message_impl.h""
#include ""source/common/http/utility.h""
#include ""source/common/network/application_protocol.h""
#include ""source/common/network/socket_option_factory.h""
#include ""source/common/network/transport_socket_options_impl.h""
#include ""source/common/network/upstream_server_name.h""
#include ""source/common/network/upstream_socket_options_filter_state.h""
#include ""source/common/network/upstream_subject_alt_names.h""
#include ""source/common/router/config_impl.h""
#include ""source/common/router/debug_config.h""
#include ""source/common/router/retry_state_impl.h""
#include ""source/common/router/upstream_request.h""
#include ""source/common/runtime/runtime_features.h""
#include ""source/common/stream_info/uint32_accessor_impl.h""
#include ""source/common/tracing/http_tracer_impl.h""

namespace Envoy {
namespace Router {
namespace {
constexpr char NumInternalRedirectsFilterStateName[] = ""num_internal_redirects"";

uint32_t getLength(const Buffer::Instance* instance) { return instance ? instance->length() : 0; }

bool schemeIsHttp(const Http::RequestHeaderMap& downstream_headers,
                  const Network::Connection& connection) {
  if (downstream_headers.getForwardedProtoValue() == Http::Headers::get().SchemeValues.Http) {
    return true;
  }
  if (!connection.ssl()) {
    return true;
  }
  return false;
}

constexpr uint64_t TimeoutPrecisionFactor = 100;

} // namespace

// Express percentage as [0, TimeoutPrecisionFactor] because stats do not accept floating point
// values, and getting multiple significant figures on the histogram would be nice.
uint64_t FilterUtility::percentageOfTimeout(const std::chrono::milliseconds response_time,
                                            const std::chrono::milliseconds timeout) {
  // Timeouts of 0 are considered infinite. Any portion of an infinite timeout used is still
  // none of it.
  if (timeout.count() == 0) {
    return 0;
  }

  return static_cast<uint64_t>(response_time.count() * TimeoutPrecisionFactor / timeout.count());
}

void FilterUtility::setUpstreamScheme(Http::RequestHeaderMap& headers, bool downstream_secure,
                                      bool upstream_secure) {
  if (Runtime::runtimeFeatureEnabled(""envoy.reloadable_features.preserve_downstream_scheme"")) {
    if (Http::HeaderUtility::schemeIsValid(headers.getSchemeValue())) {
      return;
    }
    if (Http::HeaderUtility::schemeIsValid(headers.getForwardedProtoValue())) {
      headers.setScheme(headers.getForwardedProtoValue());
      return;
    }
  }
  const bool transport_secure =
      Runtime::runtimeFeatureEnabled(""envoy.reloadable_features.preserve_downstream_scheme"")
          ? downstream_secure
          : upstream_secure;

  if (transport_secure) {
    headers.setReferenceScheme(Http::Headers::get().SchemeValues.Https);
  } else {
    headers.setReferenceScheme(Http::Headers::get().SchemeValues.Http);
  }
}

bool FilterUtility::shouldShadow(const ShadowPolicy& policy, Runtime::Loader& runtime,
                                 uint64_t stable_random) {
  if (policy.cluster().empty()) {
    return false;
  }

  if (policy.defaultValue().numerator() > 0) {
    return runtime.snapshot().featureEnabled(policy.runtimeKey(), policy.defaultValue(),
                                             stable_random);
  }

  if (!policy.runtimeKey().empty() &&
      !runtime.snapshot().featureEnabled(policy.runtimeKey(), 0, stable_random, 10000UL)) {
    return false;
  }

  return true;
}

FilterUtility::TimeoutData
FilterUtility::finalTimeout(const RouteEntry& route, Http::RequestHeaderMap& request_headers,
                            bool insert_envoy_expected_request_timeout_ms, bool grpc_request,
                            bool per_try_timeout_hedging_enabled,
                            bool respect_expected_rq_timeout) {
  // See if there is a user supplied timeout in a request header. If there is we take that.
  // Otherwise if the request is gRPC and a maximum gRPC timeout is configured we use the timeout
  // in the gRPC headers (or infinity when gRPC headers have no timeout), but cap that timeout to
  // the configured maximum gRPC timeout (which may also be infinity, represented by a 0 value),
  // or the default from the route config otherwise.
  TimeoutData timeout;
  if (!route.usingNewTimeouts()) {
    if (grpc_request && route.maxGrpcTimeout()) {
      const std::chrono::milliseconds max_grpc_timeout = route.maxGrpcTimeout().value();
      auto header_timeout = Grpc::Common::getGrpcTimeout(request_headers);
      std::chrono::milliseconds grpc_timeout =
          header_timeout ? header_timeout.value() : std::chrono::milliseconds(0);
      if (route.grpcTimeoutOffset()) {
        // We only apply the offset if it won't result in grpc_timeout hitting 0 or below, as
        // setting it to 0 means infinity and a negative timeout makes no sense.
        const auto offset = *route.grpcTimeoutOffset();
        if (offset < grpc_timeout) {
          grpc_timeout -= offset;
        }
      }

      // Cap gRPC timeout to the configured maximum considering that 0 means infinity.
      if (max_grpc_timeout != std::chrono::milliseconds(0) &&
          (grpc_timeout == std::chrono::milliseconds(0) || grpc_timeout > max_grpc_timeout)) {
        grpc_timeout = max_grpc_timeout;
      }
      timeout.global_timeout_ = grpc_timeout;
    } else {
      timeout.global_timeout_ = route.timeout();
    }
  }
  timeout.per_try_timeout_ = route.retryPolicy().perTryTimeout();

  uint64_t header_timeout;

  if (respect_expected_rq_timeout) {
    // Check if there is timeout set by egress Envoy.
    // If present, use that value as route timeout and don't override
    // *x-envoy-expected-rq-timeout-ms* header. At this point *x-envoy-upstream-rq-timeout-ms*
    // header should have been sanitized by egress Envoy.
    const Http::HeaderEntry* header_expected_timeout_entry =
        request_headers.EnvoyExpectedRequestTimeoutMs();
    if (header_expected_timeout_entry) {
      trySetGlobalTimeout(header_expected_timeout_entry, timeout);
    } else {
      const Http::HeaderEntry* header_timeout_entry =
          request_headers.EnvoyUpstreamRequestTimeoutMs();

      if (trySetGlobalTimeout(header_timeout_entry, timeout)) {
        request_headers.removeEnvoyUpstreamRequestTimeoutMs();
      }
    }
  } else {
    const Http::HeaderEntry* header_timeout_entry = request_headers.EnvoyUpstreamRequestTimeoutMs();
    if (trySetGlobalTimeout(header_timeout_entry, timeout)) {
      request_headers.removeEnvoyUpstreamRequestTimeoutMs();
    }
  }

  // See if there is a per try/retry timeout. If it's >= global we just ignore it.
  const absl::string_view per_try_timeout_entry =
      request_headers.getEnvoyUpstreamRequestPerTryTimeoutMsValue();
  if (!per_try_timeout_entry.empty()) {
    if (absl::SimpleAtoi(per_try_timeout_entry, &header_timeout)) {
      timeout.per_try_timeout_ = std::chrono::milliseconds(header_timeout);
    }
    request_headers.removeEnvoyUpstreamRequestPerTryTimeoutMs();
  }

  if (timeout.per_try_timeout_ >= timeout.global_timeout_ && timeout.global_timeout_.count() != 0) {
    timeout.per_try_timeout_ = std::chrono::milliseconds(0);
  }

  // See if there is any timeout to write in the expected timeout header.
  uint64_t expected_timeout = timeout.per_try_timeout_.count();
  // Use the global timeout if no per try timeout was specified or if we're
  // doing hedging when there are per try timeouts. Either of these scenarios
  // mean that the upstream server can use the full global timeout.
  if (per_try_timeout_hedging_enabled || expected_timeout == 0) {
    expected_timeout = timeout.global_timeout_.count();
  }

  if (insert_envoy_expected_request_timeout_ms && expected_timeout > 0) {
    request_headers.setEnvoyExpectedRequestTimeoutMs(expected_timeout);
  }

  // If we've configured max_grpc_timeout, override the grpc-timeout header with
  // the expected timeout. This ensures that the optional per try timeout is reflected
  // in grpc-timeout, ensuring that the upstream gRPC server is aware of the actual timeout.
  // If the expected timeout is 0 set no timeout, as Envoy treats 0 as infinite timeout.
  if (grpc_request && !route.usingNewTimeouts() && route.maxGrpcTimeout() &&
      expected_timeout != 0) {
    Grpc::Common::toGrpcTimeout(std::chrono::milliseconds(expected_timeout), request_headers);
  }

  return timeout;
}

bool FilterUtility::trySetGlobalTimeout(const Http::HeaderEntry* header_timeout_entry,
                                        TimeoutData& timeout) {
  if (header_timeout_entry) {
    uint64_t header_timeout;
    if (absl::SimpleAtoi(header_timeout_entry->value().getStringView(), &header_timeout)) {
      timeout.global_timeout_ = std::chrono::milliseconds(header_timeout);
    }
    return true;
  }
  return false;
}

FilterUtility::HedgingParams
FilterUtility::finalHedgingParams(const RouteEntry& route,
                                  Http::RequestHeaderMap& request_headers) {
  HedgingParams hedging_params;
  hedging_params.hedge_on_per_try_timeout_ = route.hedgePolicy().hedgeOnPerTryTimeout();

  const Http::HeaderEntry* hedge_on_per_try_timeout_entry =
      request_headers.EnvoyHedgeOnPerTryTimeout();
  if (hedge_on_per_try_timeout_entry) {
    if (hedge_on_per_try_timeout_entry->value() == ""true"") {
      hedging_params.hedge_on_per_try_timeout_ = true;
    }
    if (hedge_on_per_try_timeout_entry->value() == ""false"") {
      hedging_params.hedge_on_per_try_timeout_ = false;
    }

    request_headers.removeEnvoyHedgeOnPerTryTimeout();
  }

  return hedging_params;
}

Filter::~Filter() {
  // Upstream resources should already have been cleaned.
  ASSERT(upstream_requests_.empty());
  ASSERT(!retry_state_);
}

const FilterUtility::StrictHeaderChecker::HeaderCheckResult
FilterUtility::StrictHeaderChecker::checkHeader(Http::RequestHeaderMap& headers,
                                                const Http::LowerCaseString& target_header) {
  if (target_header == Http::Headers::get().EnvoyUpstreamRequestTimeoutMs) {
    return isInteger(headers.EnvoyUpstreamRequestTimeoutMs());
  } else if (target_header == Http::Headers::get().EnvoyUpstreamRequestPerTryTimeoutMs) {
    return isInteger(headers.EnvoyUpstreamRequestPerTryTimeoutMs());
  } else if (target_header == Http::Headers::get().EnvoyMaxRetries) {
    return isInteger(headers.EnvoyMaxRetries());
  } else if (target_header == Http::Headers::get().EnvoyRetryOn) {
    return hasValidRetryFields(headers.EnvoyRetryOn(), &Router::RetryStateImpl::parseRetryOn);
  } else if (target_header == Http::Headers::get().EnvoyRetryGrpcOn) {
    return hasValidRetryFields(headers.EnvoyRetryGrpcOn(),
                               &Router::RetryStateImpl::parseRetryGrpcOn);
  }
  // Should only validate headers for which we have implemented a validator.
  NOT_REACHED_GCOVR_EXCL_LINE;
}

Stats::StatName Filter::upstreamZone(Upstream::HostDescriptionConstSharedPtr upstream_host) {
  return upstream_host ? upstream_host->localityZoneStatName() : config_.empty_stat_name_;
}

void Filter::chargeUpstreamCode(uint64_t response_status_code,
                                const Http::ResponseHeaderMap& response_headers,
                                Upstream::HostDescriptionConstSharedPtr upstream_host,
                                bool dropped) {
  // Passing the response_status_code explicitly is an optimization to avoid
  // multiple calls to slow Http::Utility::getResponseStatus.
  ASSERT(response_status_code == Http::Utility::getResponseStatus(response_headers));
  if (config_.emit_dynamic_stats_ && !callbacks_->streamInfo().healthCheck()) {
    const Http::HeaderEntry* upstream_canary_header = response_headers.EnvoyUpstreamCanary();
    const bool is_canary = (upstream_canary_header && upstream_canary_header->value() == ""true"") ||
                           (upstream_host ? upstream_host->canary() : false);
    const bool internal_request = Http::HeaderUtility::isEnvoyInternalRequest(*downstream_headers_);

    Stats::StatName upstream_zone = upstreamZone(upstream_host);
    Http::CodeStats::ResponseStatInfo info{config_.scope_,
                                           cluster_->statsScope(),
                                           config_.empty_stat_name_,
                                           response_status_code,
                                           internal_request,
                                           route_entry_->virtualHost().statName(),
                                           request_vcluster_ ? request_vcluster_->statName()
                                                             : config_.empty_stat_name_,
                                           config_.zone_name_,
                                           upstream_zone,
                                           is_canary};

    Http::CodeStats& code_stats = httpContext().codeStats();
    code_stats.chargeResponseStat(info, exclude_http_code_stats_);

    if (alt_stat_prefix_ != nullptr) {
      Http::CodeStats::ResponseStatInfo alt_info{config_.scope_,
                                                 cluster_->statsScope(),
                                                 alt_stat_prefix_->statName(),
                                                 response_status_code,
                                                 internal_request,
                                                 config_.empty_stat_name_,
                                                 config_.empty_stat_name_,
                                                 config_.zone_name_,
                                                 upstream_zone,
                                                 is_canary};
      code_stats.chargeResponseStat(alt_info, exclude_http_code_stats_);
    }

    if (dropped) {
      cluster_->loadReportStats().upstream_rq_dropped_.inc();
    }
    if (upstream_host && Http::CodeUtility::is5xx(response_status_code)) {
      upstream_host->stats().rq_error_.inc();
    }
  }
}

void Filter::chargeUpstreamCode(Http::Code code,
                                Upstream::HostDescriptionConstSharedPtr upstream_host,
                                bool dropped) {
  const uint64_t response_status_code = enumToInt(code);
  const auto fake_response_headers = Http::createHeaderMap<Http::ResponseHeaderMapImpl>(
      {{Http::Headers::get().Status, std::to_string(response_status_code)}});
  chargeUpstreamCode(response_status_code, *fake_response_headers, upstream_host, dropped);
}

Http::FilterHeadersStatus Filter::decodeHeaders(Http::RequestHeaderMap& headers, bool end_stream) {
  downstream_headers_ = &headers;

  // Extract debug configuration from filter state. This is used further along to determine whether
  // we should append cluster and host headers to the response, and whether to forward the request
  // upstream.
  const StreamInfo::FilterStateSharedPtr& filter_state = callbacks_->streamInfo().filterState();
  const DebugConfig* debug_config =
      filter_state->hasData<DebugConfig>(DebugConfig::key())
          ? &(filter_state->getDataReadOnly<DebugConfig>(DebugConfig::key()))
          : nullptr;

  // TODO: Maybe add a filter API for this.
  grpc_request_ = Grpc::Common::isGrpcRequestHeaders(headers);
  exclude_http_code_stats_ = grpc_request_ && config_.suppress_grpc_request_failure_code_stats_;

  // Only increment rq total stat if we actually decode headers here. This does not count requests
  // that get handled by earlier filters.
  config_.stats_.rq_total_.inc();

  // Initialize the `modify_headers` function as a no-op (so we don't have to remember to check it
  // against nullptr before calling it), and feed it behavior later if/when we have cluster info
  // headers to append.
  std::function<void(Http::ResponseHeaderMap&)> modify_headers = [](Http::ResponseHeaderMap&) {};

  // Determine if there is a route entry or a direct response for the request.
  route_ = callbacks_->route();
  if (!route_) {
    config_.stats_.no_route_.inc();
    ENVOY_STREAM_LOG(debug, ""no cluster match for URL '{}'"", *callbacks_, headers.getPathValue());

    callbacks_->streamInfo().setResponseFlag(StreamInfo::ResponseFlag::NoRouteFound);
    callbacks_->sendLocalReply(Http::Code::NotFound, """", modify_headers, absl::nullopt,
                               StreamInfo::ResponseCodeDetails::get().RouteNotFound);
    return Http::FilterHeadersStatus::StopIteration;
  }

  // Determine if there is a direct response for the request.
  const auto* direct_response = route_->directResponseEntry();
  if (direct_response != nullptr) {
    config_.stats_.rq_direct_response_.inc();
    direct_response->rewritePathHeader(headers, !config_.suppress_envoy_headers_);
    callbacks_->streamInfo().setRouteName(direct_response->routeName());
    callbacks_->sendLocalReply(
        direct_response->responseCode(), direct_response->responseBody(),
        [this, direct_response,
         &request_headers = headers](Http::ResponseHeaderMap& response_headers) -> void {
          std::string new_path;
          if (request_headers.Path()) {
            new_path = direct_response->newPath(request_headers);
          }
          // See https://tools.ietf.org/html/rfc7231#section-7.1.2.
          const auto add_location =
              direct_response->responseCode() == Http::Code::Created ||
              Http::CodeUtility::is3xx(enumToInt(direct_response->responseCode()));
          if (!new_path.empty() && add_location) {
            response_headers.addReferenceKey(Http::Headers::get().Location, new_path);
          }
          direct_response->finalizeResponseHeaders(response_headers, callbacks_->streamInfo());
        },
        absl::nullopt, StreamInfo::ResponseCodeDetails::get().DirectResponse);
    return Http::FilterHeadersStatus::StopIteration;
  }

  // A route entry matches for the request.
  route_entry_ = route_->routeEntry();
  // If there's a route specific limit and it's smaller than general downstream
  // limits, apply the new cap.
  retry_shadow_buffer_limit_ =
      std::min(retry_shadow_buffer_limit_, route_entry_->retryShadowBufferLimit());
  callbacks_->streamInfo().setRouteName(route_entry_->routeName());
  if (debug_config && debug_config->append_cluster_) {
    // The cluster name will be appended to any local or upstream responses from this point.
    modify_headers = [this, debug_config](Http::ResponseHeaderMap& headers) {
      headers.addCopy(debug_config->cluster_header_.value_or(Http::Headers::get().EnvoyCluster),
                      route_entry_->clusterName());
    };
  }
  Upstream::ThreadLocalCluster* cluster =
      config_.cm_.getThreadLocalCluster(route_entry_->clusterName());
  if (!cluster) {
    config_.stats_.no_cluster_.inc();
    ENVOY_STREAM_LOG(debug, ""unknown cluster '{}'"", *callbacks_, route_entry_->clusterName());

    callbacks_->streamInfo().setResponseFlag(StreamInfo::ResponseFlag::NoClusterFound);
    callbacks_->sendLocalReply(route_entry_->clusterNotFoundResponseCode(), """", modify_headers,
                               absl::nullopt,
                               StreamInfo::ResponseCodeDetails::get().ClusterNotFound);
    return Http::FilterHeadersStatus::StopIteration;
  }
  cluster_ = cluster->info();

  // Set up stat prefixes, etc.
  request_vcluster_ = route_entry_->virtualCluster(headers);
  ENVOY_STREAM_LOG(debug, ""cluster '{}' match for URL '{}'"", *callbacks_,
                   route_entry_->clusterName(), headers.getPathValue());

  if (config_.strict_check_headers_ != nullptr) {
    for (const auto& header : *config_.strict_check_headers_) {
      const auto res = FilterUtility::StrictHeaderChecker::checkHeader(headers, header);
      if (!res.valid_) {
        callbacks_->streamInfo().setResponseFlag(
            StreamInfo::ResponseFlag::InvalidEnvoyRequestHeaders);
        const std::string body = fmt::format(""invalid header '{}' with value '{}'"",
                                             std::string(res.entry_->key().getStringView()),
                                             std::string(res.entry_->value().getStringView()));
        const std::string details =
            absl::StrCat(StreamInfo::ResponseCodeDetails::get().InvalidEnvoyRequestHeaders, ""{"",
                         res.entry_->key().getStringView(), ""}"");
        callbacks_->sendLocalReply(Http::Code::BadRequest, body, nullptr, absl::nullopt, details);
        return Http::FilterHeadersStatus::StopIteration;
      }
    }
  }

  const Http::HeaderEntry* request_alt_name = headers.EnvoyUpstreamAltStatName();
  if (request_alt_name) {
    alt_stat_prefix_ = std::make_unique<Stats::StatNameDynamicStorage>(
        request_alt_name->value().getStringView(), config_.scope_.symbolTable());
    headers.removeEnvoyUpstreamAltStatName();
  }

  // See if we are supposed to immediately kill some percentage of this cluster's traffic.
  if (cluster_->maintenanceMode()) {
    callbacks_->streamInfo().setResponseFlag(StreamInfo::ResponseFlag::UpstreamOverflow);
    chargeUpstreamCode(Http::Code::ServiceUnavailable, nullptr, true);
    callbacks_->sendLocalReply(
        Http::Code::ServiceUnavailable, ""maintenance mode"",
        [modify_headers, this](Http::ResponseHeaderMap& headers) {
          if (!config_.suppress_envoy_headers_) {
            headers.addReference(Http::Headers::get().EnvoyOverloaded,
                                 Http::Headers::get().EnvoyOverloadedValues.True);
          }
          // Note: append_cluster_info does not respect suppress_envoy_headers.
          modify_headers(headers);
        },
        absl::nullopt, StreamInfo::ResponseCodeDetails::get().MaintenanceMode);
    cluster_->stats().upstream_rq_maintenance_mode_.inc();
    return Http::FilterHeadersStatus::StopIteration;
  }

  // Fetch a connection pool for the upstream cluster.
  const auto& upstream_http_protocol_options = cluster_->upstreamHttpProtocolOptions();

  if (upstream_http_protocol_options.has_value()) {
    const auto parsed_authority = Http::Utility::parseAuthority(headers.getHostValue());
    if (!parsed_authority.is_ip_address_ && upstream_http_protocol_options.value().auto_sni()) {
      callbacks_->streamInfo().filterState()->setData(
          Network::UpstreamServerName::key(),
          std::make_unique<Network::UpstreamServerName>(parsed_authority.host_),
          StreamInfo::FilterState::StateType::Mutable);
    }

    if (upstream_http_protocol_options.value().auto_san_validation()) {
      callbacks_->streamInfo().filterState()->setData(
          Network::UpstreamSubjectAltNames::key(),
          std::make_unique<Network::UpstreamSubjectAltNames>(
              std::vector<std::string>{std::string(parsed_authority.host_)}),
          StreamInfo::FilterState::StateType::Mutable);
    }
  }

  transport_socket_options_ = Network::TransportSocketOptionsUtility::fromFilterState(
      *callbacks_->streamInfo().filterState());

  auto has_options_from_downstream =
      downstreamConnection() && downstreamConnection()
                                    ->streamInfo()
                                    .filterState()
                                    .hasData<Network::UpstreamSocketOptionsFilterState>(
                                        Network::UpstreamSocketOptionsFilterState::key());

  if (has_options_from_downstream) {
    auto downstream_options = downstreamConnection()
                                  ->streamInfo()
                                  .filterState()
                                  .getDataReadOnly<Network::UpstreamSocketOptionsFilterState>(
                                      Network::UpstreamSocketOptionsFilterState::key())
                                  .value();
    if (!upstream_options_) {
      upstream_options_ = std::make_shared<Network::Socket::Options>();
    }
    Network::Socket::appendOptions(upstream_options_, downstream_options);
  }

  if (upstream_options_ && callbacks_->getUpstreamSocketOptions()) {
    Network::Socket::appendOptions(upstream_options_, callbacks_->getUpstreamSocketOptions());
  }

  std::unique_ptr<GenericConnPool> generic_conn_pool = createConnPool(*cluster);

  if (!generic_conn_pool) {
    sendNoHealthyUpstreamResponse();
    return Http::FilterHeadersStatus::StopIteration;
  }
  Upstream::HostDescriptionConstSharedPtr host = generic_conn_pool->host();

  if (debug_config && debug_config->append_upstream_host_) {
    // The hostname and address will be appended to any local or upstream responses from this point,
    // possibly in addition to the cluster name.
    modify_headers = [modify_headers, debug_config, host](Http::ResponseHeaderMap& headers) {
      modify_headers(headers);
      headers.addCopy(
          debug_config->hostname_header_.value_or(Http::Headers::get().EnvoyUpstreamHostname),
          host->hostname());
      headers.addCopy(debug_config->host_address_header_.value_or(
                          Http::Headers::get().EnvoyUpstreamHostAddress),
                      host->address()->asString());
    };
  }

  // If we've been instructed not to forward the request upstream, send an empty local response.
  if (debug_config && debug_config->do_not_forward_) {
    modify_headers = [modify_headers, debug_config](Http::ResponseHeaderMap& headers) {
      modify_headers(headers);
      headers.addCopy(
          debug_config->not_forwarded_header_.value_or(Http::Headers::get().EnvoyNotForwarded),
          ""true"");
    };
    callbacks_->sendLocalReply(Http::Code::NoContent, """", modify_headers, absl::nullopt, """");
    return Http::FilterHeadersStatus::StopIteration;
  }

  hedging_params_ = FilterUtility::finalHedgingParams(*route_entry_, headers);

  timeout_ = FilterUtility::finalTimeout(*route_entry_, headers, !config_.suppress_envoy_headers_,
                                         grpc_request_, hedging_params_.hedge_on_per_try_timeout_,
                                         config_.respect_expected_rq_timeout_);

  // If this header is set with any value, use an alternate response code on timeout
  if (headers.EnvoyUpstreamRequestTimeoutAltResponse()) {
    timeout_response_code_ = Http::Code::NoContent;
    headers.removeEnvoyUpstreamRequestTimeoutAltResponse();
  }

  include_attempt_count_in_request_ = route_entry_->includeAttemptCountInRequest();
  if (include_attempt_count_in_request_) {
    headers.setEnvoyAttemptCount(attempt_count_);
  }

  // The router has reached a point where it is going to try to send a request upstream,
  // so now modify_headers should attach x-envoy-attempt-count to the downstream response if the
  // config flag is true.
  if (route_entry_->includeAttemptCountInResponse()) {
    modify_headers = [modify_headers, this](Http::ResponseHeaderMap& headers) {
      modify_headers(headers);

      // This header is added without checking for config_.suppress_envoy_headers_ to mirror what is
      // done for upstream requests.
      headers.setEnvoyAttemptCount(attempt_count_);
    };
  }

  // Inject the active span's tracing context into the request headers.
  callbacks_->activeSpan().injectContext(headers);

  route_entry_->finalizeRequestHeaders(headers, callbacks_->streamInfo(),
                                       !config_.suppress_envoy_headers_);
  FilterUtility::setUpstreamScheme(headers,
                                   callbacks_->streamInfo().downstreamSslConnection() != nullptr,
                                   host->transportSocketFactory().implementsSecureTransport());

  // Ensure an http transport scheme is selected before continuing with decoding.
  ASSERT(headers.Scheme());

  retry_state_ = createRetryState(
      route_entry_->retryPolicy(), headers, *cluster_, request_vcluster_, config_.runtime_,
      config_.random_, callbacks_->dispatcher(), config_.timeSource(), route_entry_->priority());

  // Determine which shadow policies to use. It's possible that we don't do any shadowing due to
  // runtime keys.
  for (const auto& shadow_policy : route_entry_->shadowPolicies()) {
    const auto& policy_ref = *shadow_policy;
    if (FilterUtility::shouldShadow(policy_ref, config_.runtime_, callbacks_->streamId())) {
      active_shadow_policies_.push_back(std::cref(policy_ref));
    }
  }

  internal_redirects_with_body_enabled_ =
      Runtime::runtimeFeatureEnabled(""envoy.reloadable_features.internal_redirects_with_body"");

  ENVOY_STREAM_LOG(debug, ""router decoding headers:\\n{}"", *callbacks_, headers);

  // Hang onto the modify_headers function for later use in handling upstream responses.
  modify_headers_ = modify_headers;

  UpstreamRequestPtr upstream_request =
      std::make_unique<UpstreamRequest>(*this, std::move(generic_conn_pool));
  LinkedList::moveIntoList(std::move(upstream_request), upstream_requests_);
  upstream_requests_.front()->encodeHeaders(end_stream);
  if (end_stream) {
    onRequestComplete();
  }

  return Http::FilterHeadersStatus::StopIteration;
}

std::unique_ptr<GenericConnPool>
Filter::createConnPool(Upstream::ThreadLocalCluster& thread_local_cluster) {
  GenericConnPoolFactory* factory = nullptr;
  if (cluster_->upstreamConfig().has_value()) {
    factory = Envoy::Config::Utility::getFactory<GenericConnPoolFactory>(
        cluster_->upstreamConfig().value());
    ENVOY_BUG(factory != nullptr,
              fmt::format(""invalid factory type '{}', failing over to default upstream"",
                          cluster_->upstreamConfig().value().DebugString()));
  }
  if (!factory) {
    factory = &Envoy::Config::Utility::getAndCheckFactoryByName<GenericConnPoolFactory>(
        ""envoy.filters.connection_pools.http.generic"");
  }

  bool should_tcp_proxy = false;

  if (route_entry_->connectConfig().has_value()) {
    auto method = downstream_headers_->getMethodValue();
    should_tcp_proxy = (method == Http::Headers::get().MethodValues.Connect);

    // Allow POST for proxying raw TCP if it is configured.
    if (!should_tcp_proxy && route_entry_->connectConfig().value().allow_post()) {
      should_tcp_proxy = (method == Http::Headers::get().MethodValues.Post);
    }
  }
  return factory->createGenericConnPool(thread_local_cluster, should_tcp_proxy, *route_entry_,
                                        callbacks_->streamInfo().protocol(), this);
}

void Filter::sendNoHealthyUpstreamResponse() {
  callbacks_->streamInfo().setResponseFlag(StreamInfo::ResponseFlag::NoHealthyUpstream);
  chargeUpstreamCode(Http::Code::ServiceUnavailable, nullptr, false);
  callbacks_->sendLocalReply(Http::Code::ServiceUnavailable, ""no healthy upstream"", modify_headers_,
                             absl::nullopt,
                             StreamInfo::ResponseCodeDetails::get().NoHealthyUpstream);
}

Http::FilterDataStatus Filter::decodeData(Buffer::Instance& data, bool end_stream) {
  // upstream_requests_.size() cannot be > 1 because that only happens when a per
  // try timeout occurs with hedge_on_per_try_timeout enabled but the per
  // try timeout timer is not started until onRequestComplete(). It could be zero
  // if the first request attempt has already failed and a retry is waiting for
  // a backoff timer.
  ASSERT(upstream_requests_.size() <= 1);

  bool buffering = (retry_state_ && retry_state_->enabled()) || !active_shadow_policies_.empty() ||
                   (internal_redirects_with_body_enabled_ && route_entry_ &&
                    route_entry_->internalRedirectPolicy().enabled());
  if (buffering &&
      getLength(callbacks_->decodingBuffer()) + data.length() > retry_shadow_buffer_limit_) {
    // The request is larger than we should buffer. Give up on the retry/shadow
    cluster_->stats().retry_or_shadow_abandoned_.inc();
    retry_state_.reset();
    buffering = false;
    active_shadow_policies_.clear();
    request_buffer_overflowed_ = true;

    // If we had to abandon buffering and there's no request in progress, abort the request and
    // clean up. This happens if the initial upstream request failed, and we are currently waiting
    // for a backoff timer before starting the next upstream attempt.
    if (upstream_requests_.empty()) {
      cleanup();
      callbacks_->sendLocalReply(
          Http::Code::InsufficientStorage, ""exceeded request buffer limit while retrying upstream"",
          modify_headers_, absl::nullopt,
          StreamInfo::ResponseCodeDetails::get().RequestPayloadExceededRetryBufferLimit);
      return Http::FilterDataStatus::StopIterationNoBuffer;
    }
  }

  // If we aren't buffering and there is no active request, an abort should have occurred
  // already.
  ASSERT(buffering || !upstream_requests_.empty());

  if (buffering) {
    // If we are going to buffer for retries or shadowing, we need to make a copy before encoding
    // since it's all moves from here on.
    if (!upstream_requests_.empty()) {
      Buffer::OwnedImpl copy(data);
      upstream_requests_.front()->encodeData(copy, end_stream);
    }

    // If we are potentially going to retry or shadow this request we need to buffer.
    // This will not cause the connection manager to 413 because before we hit the
    // buffer limit we give up on retries and buffering. We must buffer using addDecodedData()
    // so that all buffered data is available by the time we do request complete processing and
    // potentially shadow.
    callbacks_->addDecodedData(data, true);
  } else {
    upstream_requests_.front()->encodeData(data, end_stream);
  }

  if (end_stream) {
    onRequestComplete();
  }

  return Http::FilterDataStatus::StopIterationNoBuffer;
}

Http::FilterTrailersStatus Filter::decodeTrailers(Http::RequestTrailerMap& trailers) {
  ENVOY_STREAM_LOG(debug, ""router decoding trailers:\\n{}"", *callbacks_, trailers);

  // upstream_requests_.size() cannot be > 1 because that only happens when a per
  // try timeout occurs with hedge_on_per_try_timeout enabled but the per
  // try timeout timer is not started until onRequestComplete(). It could be zero
  // if the first request attempt has already failed and a retry is waiting for
  // a backoff timer.
  ASSERT(upstream_requests_.size() <= 1);
  downstream_trailers_ = &trailers;
  for (auto& upstream_request : upstream_requests_) {
    upstream_request->encodeTrailers(trailers);
  }
  onRequestComplete();
  return Http::FilterTrailersStatus::StopIteration;
}

Http::FilterMetadataStatus Filter::decodeMetadata(Http::MetadataMap& metadata_map) {
  Http::MetadataMapPtr metadata_map_ptr = std::make_unique<Http::MetadataMap>(metadata_map);
  if (!upstream_requests_.empty()) {
    // TODO(soya3129): Save metadata for retry, redirect and shadowing case.
    upstream_requests_.front()->encodeMetadata(std::move(metadata_map_ptr));
  }
  return Http::FilterMetadataStatus::Continue;
}

void Filter::setDecoderFilterCallbacks(Http::StreamDecoderFilterCallbacks& callbacks) {
  callbacks_ = &callbacks;
  // As the decoder filter only pushes back via watermarks once data has reached
  // it, it can latch the current buffer limit and does not need to update the
  // limit if another filter increases it.
  //
  // The default is ""do not limit"". If there are configured (non-zero) buffer
  // limits, apply them here.
  if (callbacks_->decoderBufferLimit() != 0) {
    retry_shadow_buffer_limit_ = callbacks_->decoderBufferLimit();
  }
}

void Filter::cleanup() {
  // All callers of cleanup() should have cleaned out the upstream_requests_
  // list as appropriate.
  ASSERT(upstream_requests_.empty());

  retry_state_.reset();
  if (response_timeout_) {
    response_timeout_->disableTimer();
    response_timeout_.reset();
  }
}

void Filter::maybeDoShadowing() {
  for (const auto& shadow_policy_wrapper : active_shadow_policies_) {
    const auto& shadow_policy = shadow_policy_wrapper.get();

    ASSERT(!shadow_policy.cluster().empty());
    Http::RequestMessagePtr request(new Http::RequestMessageImpl(
        Http::createHeaderMap<Http::RequestHeaderMapImpl>(*downstream_headers_)));
    if (callbacks_->decodingBuffer()) {
      request->body().add(*callbacks_->decodingBuffer());
    }
    if (downstream_trailers_) {
      request->trailers(Http::createHeaderMap<Http::RequestTrailerMapImpl>(*downstream_trailers_));
    }

    auto options = Http::AsyncClient::RequestOptions()
                       .setTimeout(timeout_.global_timeout_)
                       .setParentSpan(callbacks_->activeSpan())
                       .setChildSpanName(""mirror"")
                       .setSampled(shadow_policy.traceSampled());
    config_.shadowWriter().shadow(shadow_policy.cluster(), std::move(request), options);
  }
}

void Filter::onRequestComplete() {
  // This should be called exactly once, when the downstream request has been received in full.
  ASSERT(!downstream_end_stream_);
  downstream_end_stream_ = true;
  Event::Dispatcher& dispatcher = callbacks_->dispatcher();
  downstream_request_complete_time_ = dispatcher.timeSource().monotonicTime();

  // Possible that we got an immediate reset.
  if (!upstream_requests_.empty()) {
    // Even if we got an immediate reset, we could still shadow, but that is a riskier change and
    // seems unnecessary right now.
    maybeDoShadowing();

    if (timeout_.global_timeout_.count() > 0) {
      response_timeout_ = dispatcher.createTimer([this]() -> void { onResponseTimeout(); });
      response_timeout_->enableTimer(timeout_.global_timeout_);
    }

    for (auto& upstream_request : upstream_requests_) {
      if (upstream_request->createPerTryTimeoutOnRequestComplete()) {
        upstream_request->setupPerTryTimeout();
      }
    }
  }
}

void Filter::onDestroy() {
  // Reset any in-flight upstream requests.
  resetAll();
  cleanup();
}

void Filter::onResponseTimeout() {
  ENVOY_STREAM_LOG(debug, ""upstream timeout"", *callbacks_);

  // If we had an upstream request that got a ""good"" response, save its
  // upstream timing information into the downstream stream info.
  if (final_upstream_request_) {
    callbacks_->streamInfo().setUpstreamTiming(final_upstream_request_->upstreamTiming());
  }

  // Reset any upstream requests that are still in flight.
  while (!upstream_requests_.empty()) {
    UpstreamRequestPtr upstream_request =
        upstream_requests_.back()->removeFromList(upstream_requests_);

    // Don't do work for upstream requests we've already seen headers for.
    if (upstream_request->awaitingHeaders()) {
      cluster_->stats().upstream_rq_timeout_.inc();
      if (request_vcluster_) {
        request_vcluster_->stats().upstream_rq_timeout_.inc();
      }

      if (cluster_->timeoutBudgetStats().has_value()) {
        // Cancel firing per-try timeout information, because the per-try timeout did not come into
        // play when the global timeout was hit.
        upstream_request->recordTimeoutBudget(false);
      }

      if (upstream_request->upstreamHost()) {
        upstream_request->upstreamHost()->stats().rq_timeout_.inc();
      }

      // If this upstream request already hit a ""soft"" timeout, then it
      // already recorded a timeout into outlier detection. Don't do it again.
      if (!upstream_request->outlierDetectionTimeoutRecorded()) {
        updateOutlierDetection(Upstream::Outlier::Result::LocalOriginTimeout, *upstream_request,
                               absl::optional<uint64_t>(enumToInt(timeout_response_code_)));
      }

      chargeUpstreamAbort(timeout_response_code_, false, *upstream_request);
    }
    upstream_request->resetStream();
  }

  onUpstreamTimeoutAbort(StreamInfo::ResponseFlag::UpstreamRequestTimeout,
                         StreamInfo::ResponseCodeDetails::get().UpstreamTimeout);
}

// Called when the per try timeout is hit but we didn't reset the request
// (hedge_on_per_try_timeout enabled).
void Filter::onSoftPerTryTimeout(UpstreamRequest& upstream_request) {
  // Track this as a timeout for outlier detection purposes even though we didn't
  // cancel the request yet and might get a 2xx later.
  updateOutlierDetection(Upstream::Outlier::Result::LocalOriginTimeout, upstream_request,
                         absl::optional<uint64_t>(enumToInt(timeout_response_code_)));
  upstream_request.outlierDetectionTimeoutRecorded(true);

  if (!downstream_response_started_ && retry_state_) {
    RetryStatus retry_status =
        retry_state_->shouldHedgeRetryPerTryTimeout([this]() -> void { doRetry(); });

    if (retry_status == RetryStatus::Yes) {
      pending_retries_++;

      // Don't increment upstream_host->stats().rq_error_ here, we'll do that
      // later if 1) we hit global timeout or 2) we get bad response headers
      // back.
      upstream_request.retried(true);

      // TODO: cluster stat for hedge attempted.
    } else if (retry_status == RetryStatus::NoOverflow) {
      callbacks_->streamInfo().setResponseFlag(StreamInfo::ResponseFlag::UpstreamOverflow);
    } else if (retry_status == RetryStatus::NoRetryLimitExceeded) {
      callbacks_->streamInfo().setResponseFlag(
          StreamInfo::ResponseFlag::UpstreamRetryLimitExceeded);
    }
  }
}

void Filter::onPerTryTimeout(UpstreamRequest& upstream_request) {
  if (hedging_params_.hedge_on_per_try_timeout_) {
    onSoftPerTryTimeout(upstream_request);
    return;
  }

  cluster_->stats().upstream_rq_per_try_timeout_.inc();
  if (upstream_request.upstreamHost()) {
    upstream_request.upstreamHost()->stats().rq_timeout_.inc();
  }

  upstream_request.resetStream();

  updateOutlierDetection(Upstream::Outlier::Result::LocalOriginTimeout, upstream_request,
                         absl::optional<uint64_t>(enumToInt(timeout_response_code_)));

  if (maybeRetryReset(Http::StreamResetReason::LocalReset, upstream_request)) {
    return;
  }

  chargeUpstreamAbort(timeout_response_code_, false, upstream_request);

  // Remove this upstream request from the list now that we're done with it.
  upstream_request.removeFromList(upstream_requests_);
  onUpstreamTimeoutAbort(StreamInfo::ResponseFlag::UpstreamRequestTimeout,
                         StreamInfo::ResponseCodeDetails::get().UpstreamPerTryTimeout);
}

void Filter::onStreamMaxDurationReached(UpstreamRequest& upstream_request) {
  upstream_request.resetStream();

  if (maybeRetryReset(Http::StreamResetReason::LocalReset, upstream_request)) {
    return;
  }

  upstream_request.removeFromList(upstream_requests_);
  cleanup();

  callbacks_->streamInfo().setResponseFlag(
      StreamInfo::ResponseFlag::UpstreamMaxStreamDurationReached);
  // sendLocalReply may instead reset the stream if downstream_response_started_ is true.
  callbacks_->sendLocalReply(
      Http::Code::RequestTimeout, ""upstream max stream duration reached"", modify_headers_,
      absl::nullopt, StreamInfo::ResponseCodeDetails::get().UpstreamMaxStreamDurationReached);
}

void Filter::updateOutlierDetection(Upstream::Outlier::Result result,
                                    UpstreamRequest& upstream_request,
                                    absl::optional<uint64_t> code) {
  if (upstream_request.upstreamHost()) {
    upstream_request.upstreamHost()->outlierDetector().putResult(result, code);
  }
}

void Filter::chargeUpstreamAbort(Http::Code code, bool dropped, UpstreamRequest& upstream_request) {
  if (downstream_response_started_) {
    if (upstream_request.grpcRqSuccessDeferred()) {
      upstream_request.upstreamHost()->stats().rq_error_.inc();
      config_.stats_.rq_reset_after_downstream_response_started_.inc();
    }
  } else {
    Upstream::HostDescriptionConstSharedPtr upstream_host = upstream_request.upstreamHost();

    chargeUpstreamCode(code, upstream_host, dropped);
    // If we had non-5xx but still have been reset by backend or timeout before
    // starting response, we treat this as an error. We only get non-5xx when
    // timeout_response_code_ is used for code above, where this member can
    // assume values such as 204 (NoContent).
    if (upstream_host != nullptr && !Http::CodeUtility::is5xx(enumToInt(code))) {
      upstream_host->stats().rq_error_.inc();
    }
  }
}

void Filter::onUpstreamTimeoutAbort(StreamInfo::ResponseFlag response_flags,
                                    absl::string_view details) {
  Upstream::ClusterTimeoutBudgetStatsOptRef tb_stats = cluster()->timeoutBudgetStats();
  if (tb_stats.has_value()) {
    Event::Dispatcher& dispatcher = callbacks_->dispatcher();
    std::chrono::milliseconds response_time = std::chrono::duration_cast<std::chrono::milliseconds>(
        dispatcher.timeSource().monotonicTime() - downstream_request_complete_time_);

    tb_stats->get().upstream_rq_timeout_budget_percent_used_.recordValue(
        FilterUtility::percentageOfTimeout(response_time, timeout_.global_timeout_));
  }

  const absl::string_view body =
      timeout_response_code_ == Http::Code::GatewayTimeout ? ""upstream request timeout"" : """";
  onUpstreamAbort(timeout_response_code_, response_flags, body, false, details);
}

void Filter::onUpstreamAbort(Http::Code code, StreamInfo::ResponseFlag response_flags,
                             absl::string_view body, bool dropped, absl::string_view details) {
  // If we have not yet sent anything downstream, send a response with an appropriate status code.
  // Otherwise just reset the ongoing response.
  callbacks_->streamInfo().setResponseFlag(response_flags);
  // This will destroy any created retry timers.
  cleanup();
  // sendLocalReply may instead reset the stream if downstream_response_started_ is true.
  callbacks_->sendLocalReply(
      code, body,
      [dropped, this](Http::ResponseHeaderMap& headers) {
        if (dropped && !config_.suppress_envoy_headers_) {
          headers.addReference(Http::Headers::get().EnvoyOverloaded,
                               Http::Headers::get().EnvoyOverloadedValues.True);
        }
        modify_headers_(headers);
      },
      absl::nullopt, details);
}

bool Filter::maybeRetryReset(Http::StreamResetReason reset_reason,
                             UpstreamRequest& upstream_request) {
  // We don't retry if we already started the response, don't have a retry policy defined,
  // or if we've already retried this upstream request (currently only possible if a per
  // try timeout occurred and hedge_on_per_try_timeout is enabled).
  if (downstream_response_started_ || !retry_state_ || upstream_request.retried()) {
    return false;
  }

  const RetryStatus retry_status =
      retry_state_->shouldRetryReset(reset_reason, [this]() -> void { doRetry(); });
  if (retry_status == RetryStatus::Yes) {
    pending_retries_++;

    if (upstream_request.upstreamHost()) {
      upstream_request.upstreamHost()->stats().rq_error_.inc();
    }

    upstream_request.removeFromList(upstream_requests_);
    return true;
  } else if (retry_status == RetryStatus::NoOverflow) {
    callbacks_->streamInfo().setResponseFlag(StreamInfo::ResponseFlag::UpstreamOverflow);
  } else if (retry_status == RetryStatus::NoRetryLimitExceeded) {
    callbacks_->streamInfo().setResponseFlag(StreamInfo::ResponseFlag::UpstreamRetryLimitExceeded);
  }

  return false;
}

void Filter::onUpstreamReset(Http::StreamResetReason reset_reason,
                             absl::string_view transport_failure_reason,
                             UpstreamRequest& upstream_request) {
  ENVOY_STREAM_LOG(debug, ""upstream reset: reset reason: {}, transport failure reason: {}"",
                   *callbacks_, Http::Utility::resetReasonToString(reset_reason),
                   transport_failure_reason);

  // TODO: The reset may also come from upstream over the wire. In this case it should be
  // treated as external origin error and distinguished from local origin error.
  // This matters only when running OutlierDetection with split_external_local_origin_errors
  // config param set to true.
  updateOutlierDetection(Upstream::Outlier::Result::LocalOriginConnectFailed, upstream_request,
                         absl::nullopt);

  if (maybeRetryReset(reset_reason, upstream_request)) {
    return;
  }

  const bool dropped = reset_reason == Http::StreamResetReason::Overflow;
  const Http::Code error_code = (reset_reason == Http::StreamResetReason::ProtocolError)
                                    ? Http::Code::BadGateway
                                    : Http::Code::ServiceUnavailable;
  chargeUpstreamAbort(error_code, dropped, upstream_request);
  upstream_request.removeFromList(upstream_requests_);

  // If there are other in-flight requests that might see an upstream response,
  // don't return anything downstream.
  if (numRequestsAwaitingHeaders() > 0 || pending_retries_ > 0) {
    return;
  }

  const StreamInfo::ResponseFlag response_flags = streamResetReasonToResponseFlag(reset_reason);

  const std::string body =
      absl::StrCat(""upstream connect error or disconnect/reset before headers. reset reason: "",
                   Http::Utility::resetReasonToString(reset_reason),
                   Runtime::runtimeFeatureEnabled(
                       ""envoy.reloadable_features.http_transport_failure_reason_in_body"") &&
                           !transport_failure_reason.empty()
                       ? "", transport failure reason: ""
                       : """",
                   transport_failure_reason);
  callbacks_->streamInfo().setUpstreamTransportFailureReason(transport_failure_reason);
  const std::string& basic_details =
      downstream_response_started_ ? StreamInfo::ResponseCodeDetails::get().LateUpstreamReset
                                   : StreamInfo::ResponseCodeDetails::get().EarlyUpstreamReset;
  const std::string details = absl::StrCat(
      basic_details, ""{"", Http::Utility::resetReasonToString(reset_reason),
      transport_failure_reason.empty() ? """" : absl::StrCat("","", transport_failure_reason), ""}"");
  onUpstreamAbort(error_code, response_flags, body, dropped, details);
}

void Filter::onUpstreamHostSelected(Upstream::HostDescriptionConstSharedPtr host) {
  if (retry_state_ && host) {
    retry_state_->onHostAttempted(host);
  }
}

StreamInfo::ResponseFlag
Filter::streamResetReasonToResponseFlag(Http::StreamResetReason reset_reason) {
  switch (reset_reason) {
  case Http::StreamResetReason::ConnectionFailure:
    return StreamInfo::ResponseFlag::UpstreamConnectionFailure;
  case Http::StreamResetReason::ConnectionTermination:
    return StreamInfo::ResponseFlag::UpstreamConnectionTermination;
  case Http::StreamResetReason::LocalReset:
  case Http::StreamResetReason::LocalRefusedStreamReset:
    return StreamInfo::ResponseFlag::LocalReset;
  case Http::StreamResetReason::Overflow:
    return StreamInfo::ResponseFlag::UpstreamOverflow;
  case Http::StreamResetReason::RemoteReset:
  case Http::StreamResetReason::RemoteRefusedStreamReset:
  case Http::StreamResetReason::ConnectError:
    return StreamInfo::ResponseFlag::UpstreamRemoteReset;
  case Http::StreamResetReason::ProtocolError:
    return StreamInfo::ResponseFlag::UpstreamProtocolError;
  case Http::StreamResetReason::OverloadManager:
    return StreamInfo::ResponseFlag::OverloadManager;
  }

  NOT_REACHED_GCOVR_EXCL_LINE;
}

void Filter::handleNon5xxResponseHeaders(absl::optional<Grpc::Status::GrpcStatus> grpc_status,
                                         UpstreamRequest& upstream_request, bool end_stream,
                                         uint64_t grpc_to_http_status) {
  // We need to defer gRPC success until after we have processed grpc-status in
  // the trailers.
  if (grpc_request_) {
    if (end_stream) {
      if (grpc_status && !Http::CodeUtility::is5xx(grpc_to_http_status)) {
        upstream_request.upstreamHost()->stats().rq_success_.inc();
      } else {
        upstream_request.upstreamHost()->stats().rq_error_.inc();
      }
    } else {
      upstream_request.grpcRqSuccessDeferred(true);
    }
  } else {
    upstream_request.upstreamHost()->stats().rq_success_.inc();
  }
}

void Filter::onUpstream100ContinueHeaders(Http::ResponseHeaderMapPtr&& headers,
                                          UpstreamRequest& upstream_request) {
  chargeUpstreamCode(100, *headers, upstream_request.upstreamHost(), false);
  ENVOY_STREAM_LOG(debug, ""upstream 100 continue"", *callbacks_);

  downstream_response_started_ = true;
  final_upstream_request_ = &upstream_request;
  resetOtherUpstreams(upstream_request);

  // Don't send retries after 100-Continue has been sent on. Arguably we could attempt to do a
  // retry, assume the next upstream would also send an 100-Continue and swallow the second one
  // but it's sketchy (as the subsequent upstream might not send a 100-Continue) and not worth
  // the complexity until someone asks for it.
  retry_state_.reset();

  // We coalesce 100-continue headers here, to prevent encoder filters and HCM from having to worry
  // about this. This is done in the router filter, rather than UpstreamRequest, since we want to
  // potentially coalesce across retries and multiple upstream requests in the future, even though
  // we currently don't support retry after 100.
  // It's plausible that this functionality might need to move to HCM in the future for internal
  // redirects, but we would need to maintain the ""only call encode100ContinueHeaders() once""
  // invariant.
  if (!downstream_100_continue_headers_encoded_) {
    downstream_100_continue_headers_encoded_ = true;
    callbacks_->encode100ContinueHeaders(std::move(headers));
  }
}

void Filter::resetAll() {
  while (!upstream_requests_.empty()) {
    upstream_requests_.back()->removeFromList(upstream_requests_)->resetStream();
  }
}

void Filter::resetOtherUpstreams(UpstreamRequest& upstream_request) {
  // Pop each upstream request on the list and reset it if it's not the one
  // provided. At the end we'll move it back into the list.
  UpstreamRequestPtr final_upstream_request;
  while (!upstream_requests_.empty()) {
    UpstreamRequestPtr upstream_request_tmp =
        upstream_requests_.back()->removeFromList(upstream_requests_);
    if (upstream_request_tmp.get() != &upstream_request) {
      upstream_request_tmp->resetStream();
      // TODO: per-host stat for hedge abandoned.
      // TODO: cluster stat for hedge abandoned.
    } else {
      final_upstream_request = std::move(upstream_request_tmp);
    }
  }

  ASSERT(final_upstream_request);
  // Now put the final request back on this list.
  LinkedList::moveIntoList(std::move(final_upstream_request), upstream_requests_);
}

void Filter::onUpstreamHeaders(uint64_t response_code, Http::ResponseHeaderMapPtr&& headers,
                               UpstreamRequest& upstream_request, bool end_stream) {
  ENVOY_STREAM_LOG(debug, ""upstream headers complete: end_stream={}"", *callbacks_, end_stream);

  modify_headers_(*headers);
  // When grpc-status appears in response headers, convert grpc-status to HTTP status code
  // for outlier detection. This does not currently change any stats or logging and does not
  // handle the case when an error grpc-status is sent as a trailer.
  absl::optional<Grpc::Status::GrpcStatus> grpc_status;
  uint64_t grpc_to_http_status = 0;
  if (grpc_request_) {
    grpc_status = Grpc::Common::getGrpcStatus(*headers);
    if (grpc_status.has_value()) {
      grpc_to_http_status = Grpc::Utility::grpcToHttpStatus(grpc_status.value());
    }
  }

  if (grpc_status.has_value()) {
    upstream_request.upstreamHost()->outlierDetector().putHttpResponseCode(grpc_to_http_status);
  } else {
    upstream_request.upstreamHost()->outlierDetector().putHttpResponseCode(response_code);
  }

  if (headers->EnvoyImmediateHealthCheckFail() != nullptr) {
    upstream_request.upstreamHost()->healthChecker().setUnhealthy(
        Upstream::HealthCheckHostMonitor::UnhealthyType::ImmediateHealthCheckFail);
  }

  bool could_not_retry = false;

  // Check if this upstream request was already retried, for instance after
  // hitting a per try timeout. Don't retry it if we already have.
  if (retry_state_) {
    if (upstream_request.retried()) {
      // We already retried this request (presumably for a per try timeout) so
      // we definitely won't retry it again. Check if we would have retried it
      // if we could.
      could_not_retry = retry_state_->wouldRetryFromHeaders(*headers);
    } else {
      const RetryStatus retry_status =
          retry_state_->shouldRetryHeaders(*headers, [this]() -> void { doRetry(); });
      if (retry_status == RetryStatus::Yes) {
        pending_retries_++;
        upstream_request.upstreamHost()->stats().rq_error_.inc();
        Http::CodeStats& code_stats = httpContext().codeStats();
        code_stats.chargeBasicResponseStat(
            cluster_->statsScope(), config_.stats_.stat_names_.retry_,
            static_cast<Http::Code>(response_code), exclude_http_code_stats_);

        if (!end_stream || !upstream_request.encodeComplete()) {
          upstream_request.resetStream();
        }
        upstream_request.removeFromList(upstream_requests_);

        return;
      } else if (retry_status == RetryStatus::NoOverflow) {
        callbacks_->streamInfo().setResponseFlag(StreamInfo::ResponseFlag::UpstreamOverflow);
        could_not_retry = true;
      } else if (retry_status == RetryStatus::NoRetryLimitExceeded) {
        callbacks_->streamInfo().setResponseFlag(
            StreamInfo::ResponseFlag::UpstreamRetryLimitExceeded);
        could_not_retry = true;
      }
    }
  }

  if (route_entry_->internalRedirectPolicy().enabled() &&
      route_entry_->internalRedirectPolicy().shouldRedirectForResponseCode(
          static_cast<Http::Code>(response_code)) &&
      setupRedirect(*headers, upstream_request)) {
    return;
    // If the redirect could not be handled, fail open and let it pass to the
    // next downstream.
  }

  // Check if we got a ""bad"" response, but there are still upstream requests in
  // flight awaiting headers or scheduled retries. If so, exit to give them a
  // chance to return before returning a response downstream.
  if (could_not_retry && (numRequestsAwaitingHeaders() > 0 || pending_retries_ > 0)) {
    upstream_request.upstreamHost()->stats().rq_error_.inc();

    // Reset the stream because there are other in-flight requests that we'll
    // wait around for and we're not interested in consuming any body/trailers.
    upstream_request.removeFromList(upstream_requests_)->resetStream();
    return;
  }

  // Make sure any retry timers are destroyed since we may not call cleanup() if end_stream is
  // false.
  if (retry_state_) {
    retry_state_.reset();
  }

  // Only send upstream service time if we received the complete request and this is not a
  // premature response.
  if (DateUtil::timePointValid(downstream_request_complete_time_)) {
    Event::Dispatcher& dispatcher = callbacks_->dispatcher();
    MonotonicTime response_received_time = dispatcher.timeSource().monotonicTime();
    std::chrono::milliseconds ms = std::chrono::duration_cast<std::chrono::milliseconds>(
        response_received_time - downstream_request_complete_time_);
    if (!config_.suppress_envoy_headers_) {
      headers->setEnvoyUpstreamServiceTime(ms.count());
    }
  }

  upstream_request.upstreamCanary(
      (headers->EnvoyUpstreamCanary() && headers->EnvoyUpstreamCanary()->value() == ""true"") ||
      upstream_request.upstreamHost()->canary());
  chargeUpstreamCode(response_code, *headers, upstream_request.upstreamHost(), false);
  if (!Http::CodeUtility::is5xx(response_code)) {
    handleNon5xxResponseHeaders(grpc_status, upstream_request, end_stream, grpc_to_http_status);
  }

  // Append routing cookies
  for (const auto& header_value : downstream_set_cookies_) {
    headers->addReferenceKey(Http::Headers::get().SetCookie, header_value);
  }

  // TODO(zuercher): If access to response_headers_to_add (at any level) is ever needed outside
  // Router::Filter we'll need to find a better location for this work. One possibility is to
  // provide finalizeResponseHeaders functions on the Router::Config and VirtualHost interfaces.
  route_entry_->finalizeResponseHeaders(*headers, callbacks_->streamInfo());

  downstream_response_started_ = true;
  final_upstream_request_ = &upstream_request;
  resetOtherUpstreams(upstream_request);
  if (end_stream) {
    onUpstreamComplete(upstream_request);
  }

  callbacks_->encodeHeaders(std::move(headers), end_stream,
                            StreamInfo::ResponseCodeDetails::get().ViaUpstream);
}

void Filter::onUpstreamData(Buffer::Instance& data, UpstreamRequest& upstream_request,
                            bool end_stream) {
  // This should be true because when we saw headers we either reset the stream
  // (hence wouldn't have made it to onUpstreamData) or all other in-flight
  // streams.
  ASSERT(upstream_requests_.size() == 1);
  if (end_stream) {
    // gRPC request termination without trailers is an error.
    if (upstream_request.grpcRqSuccessDeferred()) {
      upstream_request.upstreamHost()->stats().rq_error_.inc();
    }
    onUpstreamComplete(upstream_request);
  }

  callbacks_->encodeData(data, end_stream);
}

void Filter::onUpstreamTrailers(Http::ResponseTrailerMapPtr&& trailers,
                                UpstreamRequest& upstream_request) {
  // This should be true because when we saw headers we either reset the stream
  // (hence wouldn't have made it to onUpstreamTrailers) or all other in-flight
  // streams.
  ASSERT(upstream_requests_.size() == 1);

  if (upstream_request.grpcRqSuccessDeferred()) {
    absl::optional<Grpc::Status::GrpcStatus> grpc_status = Grpc::Common::getGrpcStatus(*trailers);
    if (grpc_status &&
        !Http::CodeUtility::is5xx(Grpc::Utility::grpcToHttpStatus(grpc_status.value()))) {
      upstream_request.upstreamHost()->stats().rq_success_.inc();
    } else {
      upstream_request.upstreamHost()->stats().rq_error_.inc();
    }
  }

  onUpstreamComplete(upstream_request);

  callbacks_->encodeTrailers(std::move(trailers));
}

void Filter::onUpstreamMetadata(Http::MetadataMapPtr&& metadata_map) {
  callbacks_->encodeMetadata(std::move(metadata_map));
}

void Filter::onUpstreamComplete(UpstreamRequest& upstream_request) {
  if (!downstream_end_stream_) {
    upstream_request.resetStream();
  }
  callbacks_->streamInfo().setUpstreamTiming(final_upstream_request_->upstreamTiming());

  Event::Dispatcher& dispatcher = callbacks_->dispatcher();
  std::chrono::milliseconds response_time = std::chrono::duration_cast<std::chrono::milliseconds>(
      dispatcher.timeSource().monotonicTime() - downstream_request_complete_time_);

  Upstream::ClusterTimeoutBudgetStatsOptRef tb_stats = cluster()->timeoutBudgetStats();
  if (tb_stats.has_value()) {
    tb_stats->get().upstream_rq_timeout_budget_percent_used_.recordValue(
        FilterUtility::percentageOfTimeout(response_time, timeout_.global_timeout_));
  }

  if (config_.emit_dynamic_stats_ && !callbacks_->streamInfo().healthCheck() &&
      DateUtil::timePointValid(downstream_request_complete_time_)) {
    upstream_request.upstreamHost()->outlierDetector().putResponseTime(response_time);
    const bool internal_request = Http::HeaderUtility::isEnvoyInternalRequest(*downstream_headers_);

    Http::CodeStats& code_stats = httpContext().codeStats();
    Http::CodeStats::ResponseTimingInfo info{config_.scope_,
                                             cluster_->statsScope(),
                                             config_.empty_stat_name_,
                                             response_time,
                                             upstream_request.upstreamCanary(),
                                             internal_request,
                                             route_entry_->virtualHost().statName(),
                                             request_vcluster_ ? request_vcluster_->statName()
                                                               : config_.empty_stat_name_,
                                             config_.zone_name_,
                                             upstreamZone(upstream_request.upstreamHost())};

    code_stats.chargeResponseTiming(info);

    if (alt_stat_prefix_ != nullptr) {
      Http::CodeStats::ResponseTimingInfo info{config_.scope_,
                                               cluster_->statsScope(),
                                               alt_stat_prefix_->statName(),
                                               response_time,
                                               upstream_request.upstreamCanary(),
                                               internal_request,
                                               config_.empty_stat_name_,
                                               config_.empty_stat_name_,
                                               config_.zone_name_,
                                               upstreamZone(upstream_request.upstreamHost())};

      code_stats.chargeResponseTiming(info);
    }
  }

  upstream_request.removeFromList(upstream_requests_);
  cleanup();
}

bool Filter::setupRedirect(const Http::ResponseHeaderMap& headers,
                           UpstreamRequest& upstream_request) {
  ENVOY_STREAM_LOG(debug, ""attempting internal redirect"", *callbacks_);
  const Http::HeaderEntry* location = headers.Location();

  // If the internal redirect succeeds, callbacks_->recreateStream() will result in the
  // destruction of this filter before the stream is marked as complete, and onDestroy will reset
  // the stream.
  //
  // Normally when a stream is complete we signal this by resetting the upstream but this cannot
  // be done in this case because if recreateStream fails, the ""failure"" path continues to call
  // code in onUpstreamHeaders which requires the upstream *not* be reset. To avoid onDestroy
  // performing a spurious stream reset in the case recreateStream() succeeds, we explicitly track
  // stream completion here and check it in onDestroy. This is annoyingly complicated but is
  // better than needlessly resetting streams.
  attempting_internal_redirect_with_complete_stream_ =
      upstream_request.upstreamTiming().last_upstream_rx_byte_received_ && downstream_end_stream_;

  const uint64_t status_code = Http::Utility::getResponseStatus(headers);

  // Redirects are not supported for streaming requests yet.
  if (downstream_end_stream_ &&
      ((internal_redirects_with_body_enabled_ && !request_buffer_overflowed_) ||
       !callbacks_->decodingBuffer()) &&
      location != nullptr &&
      convertRequestHeadersForInternalRedirect(*downstream_headers_, *location, status_code) &&
      callbacks_->recreateStream(&headers)) {
    cluster_->stats().upstream_internal_redirect_succeeded_total_.inc();
    return true;
  }

  attempting_internal_redirect_with_complete_stream_ = false;

  ENVOY_STREAM_LOG(debug, ""Internal redirect failed"", *callbacks_);
  cluster_->stats().upstream_internal_redirect_failed_total_.inc();
  return false;
}

bool Filter::convertRequestHeadersForInternalRedirect(Http::RequestHeaderMap& downstream_headers,
                                                      const Http::HeaderEntry& internal_redirect,
                                                      uint64_t status_code) {
  if (!downstream_headers.Path()) {
    ENVOY_STREAM_LOG(trace, ""no path in downstream_headers"", *callbacks_);
    return false;
  }

  // Make sure the redirect response contains a URL to redirect to.
  if (internal_redirect.value().getStringView().empty()) {
    config_.stats_.passthrough_internal_redirect_bad_location_.inc();
    return false;
  }
  Http::Utility::Url absolute_url;
  if (!absolute_url.initialize(internal_redirect.value().getStringView(), false)) {
    config_.stats_.passthrough_internal_redirect_bad_location_.inc();
    return false;
  }

  const auto& policy = route_entry_->internalRedirectPolicy();
  // Don't allow serving TLS responses over plaintext unless allowed by policy.
  const bool scheme_is_http = schemeIsHttp(downstream_headers, *callbacks_->connection());
  const bool target_is_http = absolute_url.scheme() == Http::Headers::get().SchemeValues.Http;
  if (!policy.isCrossSchemeRedirectAllowed() && scheme_is_http != target_is_http) {
    config_.stats_.passthrough_internal_redirect_unsafe_scheme_.inc();
    return false;
  }

  const StreamInfo::FilterStateSharedPtr& filter_state = callbacks_->streamInfo().filterState();
  // Make sure that performing the redirect won't result in exceeding the configured number of
  // redirects allowed for this route.
  if (!filter_state->hasData<StreamInfo::UInt32Accessor>(NumInternalRedirectsFilterStateName)) {
    filter_state->setData(
        NumInternalRedirectsFilterStateName, std::make_shared<StreamInfo::UInt32AccessorImpl>(0),
        StreamInfo::FilterState::StateType::Mutable, StreamInfo::FilterState::LifeSpan::Request);
  }
  StreamInfo::UInt32Accessor& num_internal_redirect =
      filter_state->getDataMutable<StreamInfo::UInt32Accessor>(NumInternalRedirectsFilterStateName);

  if (num_internal_redirect.value() >= policy.maxInternalRedirects()) {
    config_.stats_.passthrough_internal_redirect_too_many_redirects_.inc();
    return false;
  }
  // Copy the old values, so they can be restored if the redirect fails.
  const std::string original_host(downstream_headers.getHostValue());
  const std::string original_path(downstream_headers.getPathValue());
  const bool scheme_is_set = (downstream_headers.Scheme() != nullptr);
  Cleanup restore_original_headers(
      [&downstream_headers, original_host, original_path, scheme_is_set, scheme_is_http]() {
        downstream_headers.setHost(original_host);
        downstream_headers.setPath(original_path);
        if (scheme_is_set) {
          downstream_headers.setScheme(scheme_is_http ? Http::Headers::get().SchemeValues.Http
                                                      : Http::Headers::get().SchemeValues.Https);
        }
      });

  // Replace the original host, scheme and path.
  downstream_headers.setScheme(absolute_url.scheme());
  downstream_headers.setHost(absolute_url.hostAndPort());
  downstream_headers.setPath(absolute_url.pathAndQueryParams());

  callbacks_->clearRouteCache();
  const auto route = callbacks_->route();
  // Don't allow a redirect to a non existing route.
  if (!route) {
    config_.stats_.passthrough_internal_redirect_no_route_.inc();
    return false;
  }

  const auto& route_name = route->routeEntry()->routeName();
  for (const auto& predicate : policy.predicates()) {
    if (!predicate->acceptTargetRoute(*filter_state, route_name, !scheme_is_http,
                                      !target_is_http)) {
      config_.stats_.passthrough_internal_redirect_predicate_.inc();
      ENVOY_STREAM_LOG(trace, ""rejecting redirect targeting {}, by {} predicate"", *callbacks_,
                       route_name, predicate->name());
      return false;
    }
  }

  // See https://tools.ietf.org/html/rfc7231#section-6.4.4.
  if (status_code == enumToInt(Http::Code::SeeOther) &&
      downstream_headers.getMethodValue() != Http::Headers::get().MethodValues.Get &&
      downstream_headers.getMethodValue() != Http::Headers::get().MethodValues.Head) {
    downstream_headers.setMethod(Http::Headers::get().MethodValues.Get);
    downstream_headers.remove(Http::Headers::get().ContentLength);
    callbacks_->modifyDecodingBuffer([](Buffer::Instance& data) { data.drain(data.length()); });
  }

  num_internal_redirect.increment();
  restore_original_headers.cancel();
  // Preserve the original request URL for the second pass.
  downstream_headers.setEnvoyOriginalUrl(absl::StrCat(scheme_is_http
                                                          ? Http::Headers::get().SchemeValues.Http
                                                          : Http::Headers::get().SchemeValues.Https,
                                                      ""://"", original_host, original_path));
  return true;
}

void Filter::doRetry() {
  ENVOY_STREAM_LOG(debug, ""performing retry"", *callbacks_);

  is_retry_ = true;
  attempt_count_++;
  ASSERT(pending_retries_ > 0);
  pending_retries_--;

  // Clusters can technically get removed by CDS during a retry. Make sure it still exists.
  const auto cluster = config_.cm_.getThreadLocalCluster(route_entry_->clusterName());
  std::unique_ptr<GenericConnPool> generic_conn_pool;
  if (cluster != nullptr) {
    cluster_ = cluster->info();
    generic_conn_pool = createConnPool(*cluster);
  }

  if (!generic_conn_pool) {
    sendNoHealthyUpstreamResponse();
    cleanup();
    return;
  }
  UpstreamRequestPtr upstream_request =
      std::make_unique<UpstreamRequest>(*this, std::move(generic_conn_pool));

  if (include_attempt_count_in_request_) {
    downstream_headers_->setEnvoyAttemptCount(attempt_count_);
  }

  UpstreamRequest* upstream_request_tmp = upstream_request.get();
  LinkedList::moveIntoList(std::move(upstream_request), upstream_requests_);
  upstream_requests_.front()->encodeHeaders(!callbacks_->decodingBuffer() &&
                                            !downstream_trailers_ && downstream_end_stream_);
  // It's possible we got immediately reset which means the upstream request we just
  // added to the front of the list might have been removed, so we need to check to make
  // sure we don't encodeData on the wrong request.
  if (!upstream_requests_.empty() && (upstream_requests_.front().get() == upstream_request_tmp)) {
    if (callbacks_->decodingBuffer()) {
      // If we are doing a retry we need to make a copy.
      Buffer::OwnedImpl copy(*callbacks_->decodingBuffer());
      upstream_requests_.front()->encodeData(copy, !downstream_trailers_ && downstream_end_stream_);
    }

    if (downstream_trailers_) {
      upstream_requests_.front()->encodeTrailers(*downstream_trailers_);
    }
  }
}

uint32_t Filter::numRequestsAwaitingHeaders() {
  return std::count_if(upstream_requests_.begin(), upstream_requests_.end(),
                       [](const auto& req) -> bool { return req->awaitingHeaders(); });
}

RetryStatePtr ProdFilter::createRetryState(const RetryPolicy& policy,
                                           Http::RequestHeaderMap& request_headers,
                                           const Upstream::ClusterInfo& cluster,
                                           const VirtualCluster* vcluster, Runtime::Loader& runtime,
                                           Random::RandomGenerator& random,
                                           Event::Dispatcher& dispatcher, TimeSource& time_source,
                                           Upstream::ResourcePriority priority) {
  return RetryStateImpl::create(policy, request_headers, cluster, vcluster, runtime, random,
                                dispatcher, time_source, priority);
}

} // namespace Router
} // namespace Envoy
",16189,True,3260.2346672485087,median
"= v1.SecurityContextConstraints
{product-author}
{product-version}
:data-uri:
:icons:
:toc: macro
:toc-title:
:toclevels: 2

toc::[]

== Description
[%hardbreaks]
SecurityContextConstraints governs the ability to make requests that affect the SecurityContext that will be applied to a container. For historical reasons SCC was exposed under the core Kubernetes API group. That exposure is deprecated and will be removed in a future release - users should instead use the security.openshift.io group to manage SecurityContextConstraints.

== Object Schema
Expand or mouse-over a field for more information about it.

++++
<pre>
<div style=""margin-left:13px;""><span title=""(boolean) AllowHostDirVolumePlugin determines if the policy allow containers to use the HostDir volume plugin"">allowHostDirVolumePlugin</span>:
</div><div style=""margin-left:13px;""><span title=""(boolean) AllowHostIPC determines if the policy allows host ipc in the containers."">allowHostIPC</span>:
</div><div style=""margin-left:13px;""><span title=""(boolean) AllowHostNetwork determines if the policy allows the use of HostNetwork in the pod spec."">allowHostNetwork</span>:
</div><div style=""margin-left:13px;""><span title=""(boolean) AllowHostPID determines if the policy allows host pid in the containers."">allowHostPID</span>:
</div><div style=""margin-left:13px;""><span title=""(boolean) AllowHostPorts determines if the policy allows host ports in the containers."">allowHostPorts</span>:
</div><div style=""margin-left:13px;""><span title=""(boolean) AllowPrivilegeEscalation determines if a pod can request to allow privilege escalation. If unspecified, defaults to true."">allowPrivilegeEscalation</span>:
</div><div style=""margin-left:13px;""><span title=""(boolean) AllowPrivilegedContainer determines if a container can request to be run as privileged."">allowPrivilegedContainer</span>:
</div><details><summary><span title=""(array) AllowedCapabilities is a list of capabilities that can be requested to add to the container. Capabilities in this field maybe added at the pod author&#39;s discretion. You must not list a capability in both AllowedCapabilities and RequiredDropCapabilities. To allow all capabilities you may use &#39;*&#39;."">allowedCapabilities</span>:
</summary><div style=""margin-left:13px;"">- <span title=""(string)"">[string]</span>:
</div></details><details><summary><span title=""(array) AllowedFlexVolumes is a whitelist of allowed Flexvolumes.  Empty or nil indicates that all Flexvolumes may be used.  This parameter is effective only when the usage of the Flexvolumes is allowed in the &#34;Volumes&#34; field."">allowedFlexVolumes</span>:
</summary><div style=""margin-left:13px;"">- <span title=""(string) Driver is the name of the Flexvolume driver."">driver</span>:
</div></details><details><summary><span title=""(array) AllowedUnsafeSysctls is a list of explicitly allowed unsafe sysctls, defaults to none. Each entry is either a plain sysctl name or ends in &#34;*&#34; in which case it is considered as a prefix of allowed sysctls. Single * means all unsafe sysctls are allowed. Kubelet has to whitelist all allowed unsafe sysctls explicitly to avoid rejection.

Examples: e.g. &#34;foo/*&#34; allows &#34;foo/bar&#34;, &#34;foo/baz&#34;, etc. e.g. &#34;foo.*&#34; allows &#34;foo.bar&#34;, &#34;foo.baz&#34;, etc."">allowedUnsafeSysctls</span>:
</summary><div style=""margin-left:13px;"">- <span title=""(string)"">[string]</span>:
</div></details><div style=""margin-left:13px;""><span title=""(string) APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources"">apiVersion</span>:
</div><details><summary><span title=""(array) DefaultAddCapabilities is the default set of capabilities that will be added to the container unless the pod spec specifically drops the capability.  You may not list a capabiility in both DefaultAddCapabilities and RequiredDropCapabilities."">defaultAddCapabilities</span>:
</summary><div style=""margin-left:13px;"">- <span title=""(string)"">[string]</span>:
</div></details><div style=""margin-left:13px;""><span title=""(boolean) DefaultAllowPrivilegeEscalation controls the default setting for whether a process can gain more privileges than its parent process."">defaultAllowPrivilegeEscalation</span>:
</div><details><summary><span title=""(array) ForbiddenSysctls is a list of explicitly forbidden sysctls, defaults to none. Each entry is either a plain sysctl name or ends in &#34;*&#34; in which case it is considered as a prefix of forbidden sysctls. Single * means all sysctls are forbidden.

Examples: e.g. &#34;foo/*&#34; forbids &#34;foo/bar&#34;, &#34;foo/baz&#34;, etc. e.g. &#34;foo.*&#34; forbids &#34;foo.bar&#34;, &#34;foo.baz&#34;, etc."">forbiddenSysctls</span>:
</summary><div style=""margin-left:13px;"">- <span title=""(string)"">[string]</span>:
</div></details><details><summary><span title=""(v1.FSGroupStrategyOptions) FSGroup is the strategy that will dictate what fs group is used by the SecurityContext."">fsGroup</span>:
</summary><details><summary>  <span title=""(array) Ranges are the allowed ranges of fs groups.  If you would like to force a single fs group then supply a single range with the same start and end."">ranges</span>:
</summary><div style=""margin-left:13px;"">  - <span title=""(integer) Max is the end of the range, inclusive."">max</span>:
</div><div style=""margin-left:13px;"">    <span title=""(integer) Min is the start of the range, inclusive."">min</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) Type is the strategy that will dictate what FSGroup is used in the SecurityContext."">type</span>:
</div></details><details><summary><span title=""(array) The groups that have permission to use this security context constraints"">groups</span>:
</summary><div style=""margin-left:13px;"">- <span title=""(string)"">[string]</span>:
</div></details><div style=""margin-left:13px;""><span title=""(string) Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds"">kind</span>:
</div><details open><summary><span title=""(v1.ObjectMeta) Standard object&#39;s metadata. More info: http://releases.k8s.io/HEAD/docs/devel/api-conventions.md#metadata"">metadata</span>:
</summary><details><summary>  <span title=""(object) Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations"">annotations</span>:
</summary><div style=""margin-left:13px;"">    <span title=""(string)"">[string]</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) The name of the cluster which the object belongs to. This is used to distinguish resources with same name and namespace in different clusters. This field is not set anywhere right now and apiserver is going to ignore it if set in create or update request."">clusterName</span>:
</div><div style=""margin-left:13px;"">  <span title=""(v1.Time) CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.

Populated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata"">creationTimestamp</span>:
</div><div style=""margin-left:13px;"">  <span title=""(integer) Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only."">deletionGracePeriodSeconds</span>:
</div><div style=""margin-left:13px;"">  <span title=""(v1.Time) DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.

Populated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata"">deletionTimestamp</span>:
</div><details><summary>  <span title=""(array) Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed."">finalizers</span>:
</summary><div style=""margin-left:13px;"">  - <span title=""(string)"">[string]</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.

If this field is specified and the generated name exists, the server will NOT return a 409 - instead, it will either return 201 Created or 500 with Reason ServerTimeout indicating a unique name could not be found in the time allotted, and the client should retry (optionally after the time indicated in the Retry-After header).

Applied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#idempotency"">generateName</span>:
</div><div style=""margin-left:13px;"">  <span title=""(integer) A sequence number representing a specific generation of the desired state. Populated by the system. Read-only."">generation</span>:
</div><details><summary>  <span title=""(v1.Initializers) An initializer is a controller which enforces some system invariant at object creation time. This field is a list of initializers that have not yet acted on this object. If nil or empty, this object has been completely initialized. Otherwise, the object is considered uninitialized and is hidden (in list/watch and get calls) from clients that haven&#39;t explicitly asked to observe uninitialized objects.

When an object is created, the system will populate this list with the current set of initializers. Only privileged users may set or modify this list. Once it is empty, it may not be modified further by any user."">initializers</span>:
</summary><details><summary>    <span title=""(array) Pending is a list of initializers that must execute in order before this object is visible. When the last pending initializer is removed, and no failing result is set, the initializers struct will be set to nil and the object is considered as initialized and visible to all clients."">pending</span>:
</summary><div style=""margin-left:13px;"">    - <span title=""(string) name of the process that is responsible for initializing this object."">name</span>:
</div></details><details><summary>    <span title=""(v1.Status) If result is set with the Failure field, the object will be persisted to storage and then deleted, ensuring that other clients can observe the deletion."">result</span>:
</summary><div style=""margin-left:13px;"">      <span title=""(string) APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources"">apiVersion</span>:
</div><div style=""margin-left:13px;"">      <span title=""(integer) Suggested HTTP return code for this status, 0 if not set."">code</span>:
</div><details><summary>      <span title=""(v1.StatusDetails) Extended data associated with the reason.  Each reason may define its own extended details. This field is optional and the data returned is not guaranteed to conform to any schema except that defined by the reason type."">details</span>:
</summary><details><summary>        <span title=""(array) The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes."">causes</span>:
</summary><div style=""margin-left:13px;"">        - <span title=""(string) The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed.  Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.

Examples:
  &#34;name&#34; - the field &#34;name&#34; on the current resource
  &#34;items[0].name&#34; - the field &#34;name&#34; on the first array entry in &#34;items&#34;"">field</span>:
</div><div style=""margin-left:13px;"">          <span title=""(string) A human-readable description of the cause of the error.  This field may be presented as-is to a reader."">message</span>:
</div><div style=""margin-left:13px;"">          <span title=""(string) A machine-readable description of the cause of the error. If this value is empty there is no information available."">reason</span>:
</div></details><div style=""margin-left:13px;"">        <span title=""(string) The group attribute of the resource associated with the status StatusReason."">group</span>:
</div><div style=""margin-left:13px;"">        <span title=""(string) The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds"">kind</span>:
</div><div style=""margin-left:13px;"">        <span title=""(string) The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described)."">name</span>:
</div><div style=""margin-left:13px;"">        <span title=""(integer) If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action."">retryAfterSeconds</span>:
</div><div style=""margin-left:13px;"">        <span title=""(string) UID of the resource. (when there is a single resource which can be described). More info: http://kubernetes.io/docs/user-guide/identifiers#uids"">uid</span>:
</div></details><div style=""margin-left:13px;"">      <span title=""(string) Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds"">kind</span>:
</div><div style=""margin-left:13px;"">      <span title=""(string) A human-readable description of the status of this operation."">message</span>:
</div><details><summary>      <span title=""(v1.ListMeta) Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds"">metadata</span>:
</summary><div style=""margin-left:13px;"">        <span title=""(string) continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response."">continue</span>:
</div><div style=""margin-left:13px;"">        <span title=""(string) String that identifies the server&#39;s internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#concurrency-control-and-consistency"">resourceVersion</span>:
</div><div style=""margin-left:13px;"">        <span title=""(string) selfLink is a URL representing this object. Populated by the system. Read-only."">selfLink</span>:
</div></details><div style=""margin-left:13px;"">      <span title=""(string) A machine-readable description of why this operation is in the &#34;Failure&#34; status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it."">reason</span>:
</div><div style=""margin-left:13px;"">      <span title=""(string) Status of the operation. One of: &#34;Success&#34; or &#34;Failure&#34;. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#spec-and-status"">status</span>:
</div></details></details><details><summary>  <span title=""(object) Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels"">labels</span>:
</summary><div style=""margin-left:13px;"">    <span title=""(string)"">[string]</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names"">name</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) Namespace defines the space within each name must be unique. An empty namespace is equivalent to the &#34;default&#34; namespace, but &#34;default&#34; is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.

Must be a DNS_LABEL. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces"">namespace</span>:
</div><details><summary>  <span title=""(array) List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller."">ownerReferences</span>:
</summary><div style=""margin-left:13px;"">  - <span title=""(string) API version of the referent."">apiVersion</span>:
</div><div style=""margin-left:13px;"">    <span title=""(boolean) If true, AND if the owner has the &#34;foregroundDeletion&#34; finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. Defaults to false. To set this field, a user needs &#34;delete&#34; permission of the owner, otherwise 422 (Unprocessable Entity) will be returned."">blockOwnerDeletion</span>:
</div><div style=""margin-left:13px;"">    <span title=""(boolean) If true, this reference points to the managing controller."">controller</span>:
</div><div style=""margin-left:13px;"">    <span title=""(string) Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds"">kind</span>:
</div><div style=""margin-left:13px;"">    <span title=""(string) Name of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names"">name</span>:
</div><div style=""margin-left:13px;"">    <span title=""(string) UID of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#uids"">uid</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.

Populated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#concurrency-control-and-consistency"">resourceVersion</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) SelfLink is a URL representing this object. Populated by the system. Read-only."">selfLink</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.

Populated by the system. Read-only. More info: http://kubernetes.io/docs/user-guide/identifiers#uids"">uid</span>:
</div></details><div style=""margin-left:13px;""><span title=""(integer) Priority influences the sort order of SCCs when evaluating which SCCs to try first for a given pod request based on access in the Users and Groups fields.  The higher the int, the higher priority. An unset value is considered a 0 priority. If scores for multiple SCCs are equal they will be sorted from most restrictive to least restrictive. If both priorities and restrictions are equal the SCCs will be sorted by name."">priority</span>:
</div><div style=""margin-left:13px;""><span title=""(boolean) ReadOnlyRootFilesystem when set to true will force containers to run with a read only root file system.  If the container specifically requests to run with a non-read only root file system the SCC should deny the pod. If set to false the container may run with a read only root file system if it wishes but it will not be forced to."">readOnlyRootFilesystem</span>:
</div><details><summary><span title=""(array) RequiredDropCapabilities are the capabilities that will be dropped from the container.  These are required to be dropped and cannot be added."">requiredDropCapabilities</span>:
</summary><div style=""margin-left:13px;"">- <span title=""(string)"">[string]</span>:
</div></details><details><summary><span title=""(v1.RunAsUserStrategyOptions) RunAsUser is the strategy that will dictate what RunAsUser is used in the SecurityContext."">runAsUser</span>:
</summary><div style=""margin-left:13px;"">  <span title=""(string) Type is the strategy that will dictate what RunAsUser is used in the SecurityContext."">type</span>:
</div><div style=""margin-left:13px;"">  <span title=""(integer) UID is the user id that containers must run as.  Required for the MustRunAs strategy if not using namespace/service account allocated uids."">uid</span>:
</div><div style=""margin-left:13px;"">  <span title=""(integer) UIDRangeMax defines the max value for a strategy that allocates by range."">uidRangeMax</span>:
</div><div style=""margin-left:13px;"">  <span title=""(integer) UIDRangeMin defines the min value for a strategy that allocates by range."">uidRangeMin</span>:
</div></details><details><summary><span title=""(v1.SELinuxContextStrategyOptions) SELinuxContext is the strategy that will dictate what labels will be set in the SecurityContext."">seLinuxContext</span>:
</summary><details><summary>  <span title=""(v1.SELinuxOptions) seLinuxOptions required to run as; required for MustRunAs"">seLinuxOptions</span>:
</summary><div style=""margin-left:13px;"">    <span title=""(string) Level is SELinux level label that applies to the container."">level</span>:
</div><div style=""margin-left:13px;"">    <span title=""(string) Role is a SELinux role label that applies to the container."">role</span>:
</div><div style=""margin-left:13px;"">    <span title=""(string) Type is a SELinux type label that applies to the container."">type</span>:
</div><div style=""margin-left:13px;"">    <span title=""(string) User is a SELinux user label that applies to the container."">user</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) Type is the strategy that will dictate what SELinux context is used in the SecurityContext."">type</span>:
</div></details><details><summary><span title=""(array) SeccompProfiles lists the allowed profiles that may be set for the pod or container&#39;s seccomp annotations.  An unset (nil) or empty value means that no profiles may be specifid by the pod or container.	The wildcard &#39;*&#39; may be used to allow all profiles.  When used to generate a value for a pod the first non-wildcard profile will be used as the default."">seccompProfiles</span>:
</summary><div style=""margin-left:13px;"">- <span title=""(string)"">[string]</span>:
</div></details><details><summary><span title=""(v1.SupplementalGroupsStrategyOptions) SupplementalGroups is the strategy that will dictate what supplemental groups are used by the SecurityContext."">supplementalGroups</span>:
</summary><details><summary>  <span title=""(array) Ranges are the allowed ranges of supplemental groups.  If you would like to force a single supplemental group then supply a single range with the same start and end."">ranges</span>:
</summary><div style=""margin-left:13px;"">  - <span title=""(integer) Max is the end of the range, inclusive."">max</span>:
</div><div style=""margin-left:13px;"">    <span title=""(integer) Min is the start of the range, inclusive."">min</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) Type is the strategy that will dictate what supplemental groups is used in the SecurityContext."">type</span>:
</div></details><details><summary><span title=""(array) The users who have permissions to use this security context constraints"">users</span>:
</summary><div style=""margin-left:13px;"">- <span title=""(string)"">[string]</span>:
</div></details><details><summary><span title=""(array) Volumes is a white list of allowed volume plugins.  FSType corresponds directly with the field names of a VolumeSource (azureFile, configMap, emptyDir).  To allow all volumes you may use &#34;*&#34;. To allow no volumes, set to [&#34;none&#34;]."">volumes</span>:
</summary><div style=""margin-left:13px;"">- <span title=""(string)"">[string]</span>:
</div></details>
</pre>
++++

== Operations

[[Post-api-v1-securitycontextconstraints]]
=== Create a SecurityContextConstraints
Create SecurityContextConstraints

==== HTTP request
----
POST /api/v1/securitycontextconstraints HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
Content-Type: application/json'

{
  ""kind"": ""SecurityContextConstraints"",
  ""apiVersion"": ""v1"",
  ...
}

----

==== Curl request
----
$ curl -k \\
    -X POST \\
    -d @- \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    -H 'Content-Type: application/json' \\
    https://$ENDPOINT/api/v1/securitycontextconstraints <<'EOF'
{
  ""kind"": ""SecurityContextConstraints"",
  ""apiVersion"": ""v1"",
  ...
}
EOF
----

==== HTTP body
[cols=""1,5"", options=""header""]
|===
|Parameter|Schema
|body|v1.SecurityContextConstraints
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.SecurityContextConstraints
|201 Created|v1.SecurityContextConstraints
|202 Accepted|v1.SecurityContextConstraints
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Get-api-v1-securitycontextconstraints-name]]
=== Get a SecurityContextConstraints
Read the specified SecurityContextConstraints

==== HTTP request
----
GET /api/v1/securitycontextconstraints/$NAME HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/api/v1/securitycontextconstraints/$NAME
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the SecurityContextConstraints
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|exact|Should the export be exact.  Exact export maintains cluster-specific fields like 'Namespace'.
|export|Should this value be exported.  Export strips fields that a user can not specify.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.SecurityContextConstraints
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Get-api-v1-securitycontextconstraints]]
=== Get all SecurityContextConstraints
List or watch objects of kind SecurityContextConstraints

==== HTTP request
----
GET /api/v1/securitycontextconstraints HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/api/v1/securitycontextconstraints
----

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|continue|The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server the server will respond with a 410 ResourceExpired error indicating the client must restart their list without the continue field. This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
|fieldSelector|A selector to restrict the list of returned objects by their fields. Defaults to everything.
|includeUninitialized|If true, partially initialized resources are included in the response.
|labelSelector|A selector to restrict the list of returned objects by their labels. Defaults to everything.
|limit|limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
|resourceVersion|When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
|timeoutSeconds|Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
|watch|Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.SecurityContextConstraintsList
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf
* application/json;stream=watch
* application/vnd.kubernetes.protobuf;stream=watch


[[Get-api-v1-watch-securitycontextconstraints-name]]
=== Watch a SecurityContextConstraints
Watch changes to an object of kind SecurityContextConstraints

==== HTTP request
----
GET /api/v1/watch/securitycontextconstraints/$NAME HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/api/v1/watch/securitycontextconstraints/$NAME
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the SecurityContextConstraints
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|continue|The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server the server will respond with a 410 ResourceExpired error indicating the client must restart their list without the continue field. This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
|fieldSelector|A selector to restrict the list of returned objects by their fields. Defaults to everything.
|includeUninitialized|If true, partially initialized resources are included in the response.
|labelSelector|A selector to restrict the list of returned objects by their labels. Defaults to everything.
|limit|limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
|pretty|If 'true', then the output is pretty printed.
|resourceVersion|When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
|timeoutSeconds|Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
|watch|Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.WatchEvent
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf
* application/json;stream=watch
* application/vnd.kubernetes.protobuf;stream=watch


[[Get-api-v1-watch-securitycontextconstraints]]
=== Watch all SecurityContextConstraints
Watch individual changes to a list of SecurityContextConstraints

==== HTTP request
----
GET /api/v1/watch/securitycontextconstraints HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/api/v1/watch/securitycontextconstraints
----

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|continue|The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server the server will respond with a 410 ResourceExpired error indicating the client must restart their list without the continue field. This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
|fieldSelector|A selector to restrict the list of returned objects by their fields. Defaults to everything.
|includeUninitialized|If true, partially initialized resources are included in the response.
|labelSelector|A selector to restrict the list of returned objects by their labels. Defaults to everything.
|limit|limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
|pretty|If 'true', then the output is pretty printed.
|resourceVersion|When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
|timeoutSeconds|Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
|watch|Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.WatchEvent
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf
* application/json;stream=watch
* application/vnd.kubernetes.protobuf;stream=watch


[[Put-api-v1-securitycontextconstraints-name]]
=== Update a SecurityContextConstraints
Replace the specified SecurityContextConstraints

==== HTTP request
----
PUT /api/v1/securitycontextconstraints/$NAME HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
Content-Type: application/json'

{
  ""kind"": ""SecurityContextConstraints"",
  ""apiVersion"": ""v1"",
  ...
}

----

==== Curl request
----
$ curl -k \\
    -X PUT \\
    -d @- \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    -H 'Content-Type: application/json' \\
    https://$ENDPOINT/api/v1/securitycontextconstraints/$NAME <<'EOF'
{
  ""kind"": ""SecurityContextConstraints"",
  ""apiVersion"": ""v1"",
  ...
}
EOF
----

==== HTTP body
[cols=""1,5"", options=""header""]
|===
|Parameter|Schema
|body|v1.SecurityContextConstraints
|===

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the SecurityContextConstraints
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.SecurityContextConstraints
|201 Created|v1.SecurityContextConstraints
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Patch-api-v1-securitycontextconstraints-name]]
=== Patch a SecurityContextConstraints
Partially update the specified SecurityContextConstraints

==== HTTP request
----
PATCH /api/v1/securitycontextconstraints/$NAME HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
Content-Type: application/json-patch+json'

{
  ...
}

----

==== Curl request
----
$ curl -k \\
    -X PATCH \\
    -d @- \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    -H 'Content-Type: application/json-patch+json' \\
    https://$ENDPOINT/api/v1/securitycontextconstraints/$NAME <<'EOF'
{
  ...
}
EOF
----

==== HTTP body
[cols=""1,5"", options=""header""]
|===
|Parameter|Schema
|body|v1.Patch
|===

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the SecurityContextConstraints
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.SecurityContextConstraints
|401 Unauthorized|
|===

==== Consumes

* application/json-patch+json
* application/merge-patch+json
* application/strategic-merge-patch+json

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Delete-api-v1-securitycontextconstraints-name]]
=== Delete a SecurityContextConstraints
Delete SecurityContextConstraints

==== HTTP request
----
DELETE /api/v1/securitycontextconstraints/$NAME HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
Content-Type: application/json'

{
  ...
}

----

==== Curl request
----
$ curl -k \\
    -X DELETE \\
    -d @- \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    -H 'Content-Type: application/json' \\
    https://$ENDPOINT/api/v1/securitycontextconstraints/$NAME <<'EOF'
{
  ...
}
EOF
----

==== HTTP body
[cols=""1,5"", options=""header""]
|===
|Parameter|Schema
|body|v1.DeleteOptions
|===

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the SecurityContextConstraints
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|gracePeriodSeconds|The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.
|orphanDependents|Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the ""orphan"" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.
|propagationPolicy|Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.Status
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Delete-api-v1-securitycontextconstraints]]
=== Delete all SecurityContextConstraints
Delete collection of SecurityContextConstraints

==== HTTP request
----
DELETE /api/v1/securitycontextconstraints HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -X DELETE \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/api/v1/securitycontextconstraints
----

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|continue|The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server the server will respond with a 410 ResourceExpired error indicating the client must restart their list without the continue field. This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
|fieldSelector|A selector to restrict the list of returned objects by their fields. Defaults to everything.
|includeUninitialized|If true, partially initialized resources are included in the response.
|labelSelector|A selector to restrict the list of returned objects by their labels. Defaults to everything.
|limit|limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
|resourceVersion|When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
|timeoutSeconds|Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
|watch|Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.Status
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf



",12201,False,2079.2329239112632,median
"// Copyright (c) 2014-2017 The Dash Core developers
// Copyright (c) 2018 FXTC developers
// Copyright (c) 2018-2019 QSTEES developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include <activemasternode.h>
#include <init.h>
#include <netbase.h>
#include <key_io.h>
#include <validation.h>
#include <masternode-payments.h>
#include <masternode-sync.h>
#include <masternodeconfig.h>
#include <masternodeman.h>
#include <infinitynodeman.h>
#include <infinitynodersv.h>
#ifdef ENABLE_WALLET
#include <wallet/coincontrol.h>
#endif // ENABLE_WALLET
#include <rpc/server.h>
#include <util.h>
#include <utilmoneystr.h>
#include <consensus/validation.h>

#include <fstream>
#include <iomanip>
#include <univalue.h>

UniValue masternodelist(const JSONRPCRequest& request);

#ifdef ENABLE_WALLET
void EnsureWalletIsUnlocked();
#endif // ENABLE_WALLET

UniValue masternode(const JSONRPCRequest& request)
{
#ifdef ENABLE_WALLET
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
#endif // ENABLE_WALLET

    std::string strCommand;
    if (request.params.size() >= 1) {
        strCommand = request.params[0].get_str();
    }

#ifdef ENABLE_WALLET
    if (strCommand == ""start-many"")
        throw JSONRPCError(RPC_INVALID_PARAMETER, ""DEPRECATED, please use start-all instead"");
#endif // ENABLE_WALLET

    if (request.fHelp  ||
        (
#ifdef ENABLE_WALLET
            strCommand != ""start-alias"" && strCommand != ""start-all"" && strCommand != ""start-missing"" &&
         strCommand != ""start-disabled"" && strCommand != ""outputs"" &&
#endif // ENABLE_WALLET
         strCommand != ""list"" && strCommand != ""list-conf"" && strCommand != ""count"" &&
         strCommand != ""debug"" && strCommand != ""current"" && strCommand != ""winner"" && strCommand != ""winners"" && strCommand != ""genkey"" &&
         strCommand != ""connect"" && strCommand != ""status"" && strCommand != ""collateral""))
            throw std::runtime_error(
                ""masternode \\""command\\""...\\n""
                ""Set of commands to execute masternode related actions\\n""
                ""\\nArguments:\\n""
                ""1. \\""command\\""        (string or set of strings, required) The command to execute\\n""
                ""\\nAvailable commands:\\n""
                ""  count        - Print number of all known masternodes (optional: 'ps', 'enabled', 'all', 'qualify')\\n""
                ""  current      - Print info on current masternode winner to be paid the next block (calculated locally)\\n""
                ""  genkey       - Generate new masternodeprivkey\\n""
#ifdef ENABLE_WALLET
                ""  outputs      - Print masternode compatible outputs\\n""
                ""  start-alias  - Start single remote masternode by assigned alias configured in masternode.conf\\n""
                ""  start-<mode> - Start remote masternodes configured in masternode.conf (<mode>: 'all', 'missing', 'disabled')\\n""
#endif // ENABLE_WALLET
                ""  status       - Print masternode status information\\n""
                ""  list         - Print list of all known masternodes (see masternodelist for more info)\\n""
                ""  list-conf    - Print masternode.conf in JSON format\\n""
                ""  winner       - Print info on next masternode winner to vote for\\n""
                ""  winners      - Print list of masternode winners\\n""
                );

    if (strCommand == ""list"")
    {
        JSONRPCRequest newRequest;
        newRequest.fHelp = request.fHelp;
        // forward params but skip ""list""
        for (unsigned int i = 1; i < request.params.size(); i++) {
            newRequest.params.push_back(request.params[i]);
        }
        return masternodelist(newRequest);
    }

    if(strCommand == ""connect"")
    {
        if (request.params.size() < 2)
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Masternode address required"");

        std::string strAddress = request.params[1].get_str();

        CService addr;
        if (!Lookup(strAddress.c_str(), addr, 0, false))
            throw JSONRPCError(RPC_INTERNAL_ERROR, strprintf(""Incorrect masternode address %s"", strAddress));

        // TODO: Pass CConnman instance somehow and don't use global variable.
        CNode *pnode = g_connman->OpenNetworkConnection(CAddress(addr, NODE_NETWORK), false, nullptr, NULL, false, false, false, true);
        //
        if(!pnode)
            throw JSONRPCError(RPC_INTERNAL_ERROR, strprintf(""Couldn't connect to masternode %s"", strAddress));

        return ""successfully connected"";
    }

    if (strCommand == ""count"")
    {
        if (request.params.size() > 2)
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Too many parameters"");

        if (request.params.size() == 1)
            return mnodeman.size();

        std::string strMode = request.params[1].get_str();

        if (strMode == ""enabled"")
            return mnodeman.CountEnabled();

        int nCount;
        masternode_info_t mnInfo;
        mnodeman.GetNextMasternodeInQueueForPayment(true, nCount, mnInfo);

        if (strMode == ""qualify"")
            return nCount;

        if (strMode == ""all"")
            return strprintf(""Total: %d (Enabled: %d / Qualify: %d)"",
                mnodeman.size(), mnodeman.CountEnabled(), nCount);
    }

    if (strCommand == ""current"" || strCommand == ""winner"")
    {
        int nCount;
        int nHeight;
        masternode_info_t mnInfo;
        CBlockIndex* pindex = NULL;
        {
            LOCK(cs_main);
            pindex = chainActive.Tip();
        }
        nHeight = pindex->nHeight + (strCommand == ""current"" ? 1 : 10);
        mnodeman.UpdateLastPaid(pindex);

        if(!mnodeman.GetNextMasternodeInQueueForPayment(nHeight, true, nCount, mnInfo))
            return ""unknown"";

        UniValue obj(UniValue::VOBJ);

        obj.push_back(Pair(""height"",        nHeight));
        obj.push_back(Pair(""IP:port"",       mnInfo.addr.ToString()));
        obj.push_back(Pair(""protocol"",      (int64_t)mnInfo.nProtocolVersion));
        obj.push_back(Pair(""outpoint"",      mnInfo.vin.prevout.ToStringShort()));
        obj.push_back(Pair(""payee"",         EncodeDestination(mnInfo.pubKeyCollateralAddress.GetID())));
        obj.push_back(Pair(""lastseen"",      mnInfo.nTimeLastPing));
        obj.push_back(Pair(""activeseconds"", mnInfo.nTimeLastPing - mnInfo.sigTime));
        return obj;
    }

#ifdef ENABLE_WALLET
    if (strCommand == ""start-alias"")
    {
        if (request.params.size() < 2)
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Please specify an alias"");

        {
            LOCK(pwallet->cs_wallet);
            EnsureWalletIsUnlocked(pwallet);
        }

        std::string strAlias = request.params[1].get_str();

        bool fFound = false;

        UniValue statusObj(UniValue::VOBJ);
        statusObj.push_back(Pair(""alias"", strAlias));

        for (CMasternodeConfig::CMasternodeEntry mne : masternodeConfig.getEntries()) {
            if(mne.getAlias() == strAlias) {
                fFound = true;
                std::string strError;
                CMasternodeBroadcast mnb;

                bool fResult = CMasternodeBroadcast::Create(mne.getIp(), mne.getPrivKey(), mne.getTxHash(), mne.getOutputIndex(), mne.getTxHashBurnFund(), mne.getOutputIndexBurnFund(), strError, mnb);

                statusObj.push_back(Pair(""result"", fResult ? ""successful"" : ""failed""));
                if(fResult) {
                    mnodeman.UpdateMasternodeList(mnb, *g_connman);
                    mnb.Relay(*g_connman);
                } else {
                    statusObj.push_back(Pair(""errorMessage"", strError));
                }
                mnodeman.NotifyMasternodeUpdates(*g_connman);
                break;
            }
        }

        if(!fFound) {
            statusObj.push_back(Pair(""result"", ""failed""));
            statusObj.push_back(Pair(""errorMessage"", ""Could not find alias in config. Verify with list-conf.""));
        }

        return statusObj;

    }

    if (strCommand == ""start-all"" || strCommand == ""start-missing"" || strCommand == ""start-disabled"")
    {
        {
            LOCK(pwallet->cs_wallet);
            EnsureWalletIsUnlocked(pwallet);
        }

        if((strCommand == ""start-missing"" || strCommand == ""start-disabled"") && !masternodeSync.IsMasternodeListSynced()) {
            throw JSONRPCError(RPC_CLIENT_IN_INITIAL_DOWNLOAD, ""You can't use this command until masternode list is synced"");
        }

        int nSuccessful = 0;
        int nFailed = 0;

        UniValue resultsObj(UniValue::VOBJ);

        for (CMasternodeConfig::CMasternodeEntry mne : masternodeConfig.getEntries()) {
            std::string strError;

            COutPoint outpoint = COutPoint(uint256S(mne.getTxHash()), uint32_t(atoi(mne.getOutputIndex().c_str())));
            CMasternode mn;
            bool fFound = mnodeman.Get(outpoint, mn);
            CMasternodeBroadcast mnb;

            if(strCommand == ""start-missing"" && fFound) continue;
            if(strCommand == ""start-disabled"" && fFound && mn.IsEnabled()) continue;

            bool fResult = CMasternodeBroadcast::Create(mne.getIp(), mne.getPrivKey(), mne.getTxHash(), mne.getOutputIndex(), mne.getTxHashBurnFund(), mne.getOutputIndexBurnFund(), strError, mnb);

            UniValue statusObj(UniValue::VOBJ);
            statusObj.push_back(Pair(""alias"", mne.getAlias()));
            statusObj.push_back(Pair(""result"", fResult ? ""successful"" : ""failed""));

            if (fResult) {
                nSuccessful++;
                mnodeman.UpdateMasternodeList(mnb, *g_connman);
                mnb.Relay(*g_connman);
            } else {
                nFailed++;
                statusObj.push_back(Pair(""errorMessage"", strError));
            }

            resultsObj.push_back(Pair(""status"", statusObj));
        }
        mnodeman.NotifyMasternodeUpdates(*g_connman);

        UniValue returnObj(UniValue::VOBJ);
        returnObj.push_back(Pair(""overall"", strprintf(""Successfully started %d masternodes, failed to start %d, total %d"", nSuccessful, nFailed, nSuccessful + nFailed)));
        returnObj.push_back(Pair(""detail"", resultsObj));

        return returnObj;
    }
#endif // ENABLE_WALLET

    if (strCommand == ""genkey"")
    {
        CKey secret;
        secret.MakeNewKey(false);

        return EncodeSecret(secret);
    }

    if (strCommand == ""list-conf"")
    {
        UniValue resultObj(UniValue::VOBJ);

        for (CMasternodeConfig::CMasternodeEntry mne : masternodeConfig.getEntries()) {
            COutPoint outpoint = COutPoint(uint256S(mne.getTxHash()), uint32_t(atoi(mne.getOutputIndex().c_str())));
            CMasternode mn;
            bool fFound = mnodeman.Get(outpoint, mn);

            std::string strStatus = fFound ? mn.GetStatus() : ""MISQSTEESG"";

            UniValue mnObj(UniValue::VOBJ);
            mnObj.push_back(Pair(""alias"", mne.getAlias()));
            mnObj.push_back(Pair(""address"", mne.getIp()));
            mnObj.push_back(Pair(""privateKey"", mne.getPrivKey()));
            mnObj.push_back(Pair(""txHash"", mne.getTxHash()));
            mnObj.push_back(Pair(""outputIndex"", mne.getOutputIndex()));
            mnObj.push_back(Pair(""status"", strStatus));
            resultObj.push_back(Pair(""masternode"", mnObj));
        }

        return resultObj;
    }

#ifdef ENABLE_WALLET
    if (strCommand == ""outputs"") {
        // Find possible candidates
        std::vector<COutput> vPossibleCoins;
        LOCK2(cs_main, pwallet->cs_wallet);
        pwallet->AvailableCoins(vPossibleCoins, true, NULL, false, ONLY_MASTERNODE_COLLATERAL);

        UniValue obj(UniValue::VOBJ);
        for (COutput& out : vPossibleCoins) {
            obj.push_back(Pair(out.tx->GetHash().ToString(), strprintf(""%d"", out.i)));
        }

        return obj;
    }
#endif // ENABLE_WALLET

    if (strCommand == ""status"")
    {
        if (!fMasterNode)
            throw JSONRPCError(RPC_INTERNAL_ERROR, ""This is not a masternode"");

        UniValue mnObj(UniValue::VOBJ);

        mnObj.push_back(Pair(""outpoint"", activeMasternode.outpoint.ToStringShort()));
        mnObj.push_back(Pair(""service"", activeMasternode.service.ToString()));

        CMasternode mn;
        if(mnodeman.Get(activeMasternode.outpoint, mn)) {
            mnObj.push_back(Pair(""payee"", EncodeDestination(mn.pubKeyCollateralAddress.GetID())));
        }

        mnObj.push_back(Pair(""status"", activeMasternode.GetStatus()));
        return mnObj;
    }

    if (strCommand == ""winners"")
    {
        int nHeight;
        {
            LOCK(cs_main);
            CBlockIndex* pindex = chainActive.Tip();
            if(!pindex) return NullUniValue;

            nHeight = pindex->nHeight;
        }

        int nLast = 10;
        std::string strFilter = """";

        if (request.params.size() >= 2) {
            nLast = atoi(request.params[1].get_str());
        }

        if (request.params.size() == 3) {
            strFilter = request.params[2].get_str();
        }

        if (request.params.size() > 3)
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Correct usage is 'masternode winners ( \\""count\\"" \\""filter\\"" )'"");

        UniValue obj(UniValue::VOBJ);

        for(int i = nHeight - nLast; i < nHeight + 20; i++) {
            std::string strPayment = GetRequiredPaymentsString(i);
            if (strFilter !="""" && strPayment.find(strFilter) == std::string::npos) continue;
            obj.push_back(Pair(strprintf(""%d"", i), strPayment));
        }

        return obj;
    }

    return NullUniValue;
}

UniValue masternodelist(const JSONRPCRequest& request)
{
    std::string strMode = ""status"";
    std::string strFilter = """";

    if (request.params.size() >= 1) strMode = request.params[0].get_str();
    if (request.params.size() == 2) strFilter = request.params[1].get_str();

    if (request.fHelp || (
                strMode != ""activeseconds"" && strMode != ""addr"" && strMode != ""full"" && strMode != ""info"" &&
                strMode != ""lastseen"" && strMode != ""lastpaidtime"" && strMode != ""lastpaidblock"" &&
                strMode != ""protocol"" && strMode != ""payee"" && strMode != ""pubkey"" &&
                strMode != ""rank"" && strMode != ""status""))
    {
        throw std::runtime_error(
                ""masternodelist ( \\""mode\\"" \\""filter\\"" )\\n""
                ""Get a list of masternodes in different modes\\n""
                ""\\nArguments:\\n""
                ""1. \\""mode\\""      (string, optional/required to use filter, defaults = status) The mode to run list in\\n""
                ""2. \\""filter\\""    (string, optional) Filter results. Partial match by outpoint by default in all modes,\\n""
                ""                                    additional matches in some modes are also available\\n""
                ""\\nAvailable modes:\\n""
                ""  activeseconds  - Print number of seconds masternode recognized by the network as enabled\\n""
                ""                   (since latest issued \\""masternode start/start-many/start-alias\\"")\\n""
                ""  addr           - Print ip address associated with a masternode (can be additionally filtered, partial match)\\n""
                ""  full           - Print info in format 'status protocol payee lastseen activeseconds lastpaidtime lastpaidblock IP'\\n""
                ""                   (can be additionally filtered, partial match)\\n""
                ""  info           - Print info in format 'status protocol payee lastseen activeseconds sentinelversion sentinelstate IP'\\n""
                ""                   (can be additionally filtered, partial match)\\n""
                ""  lastpaidblock  - Print the last block height a node was paid on the network\\n""
                ""  lastpaidtime   - Print the last time a node was paid on the network\\n""
                ""  lastseen       - Print timestamp of when a masternode was last seen on the network\\n""
                ""  payee          - Print Dash address associated with a masternode (can be additionally filtered,\\n""
                ""                   partial match)\\n""
                ""  protocol       - Print protocol of a masternode (can be additionally filtered, exact match)\\n""
                ""  pubkey         - Print the masternode (not collateral) public key\\n""
                ""  rank           - Print rank of a masternode based on current block\\n""
                ""  status         - Print masternode status: PRE_ENABLED / ENABLED / EXPIRED / WATCHDOG_EXPIRED / NEW_START_REQUIRED /\\n""
                ""                   UPDATE_REQUIRED / POSE_BAN / OUTPOINT_SPENT (can be additionally filtered, partial match)\\n""
                );
    }

    if (strMode == ""full"" || strMode == ""lastpaidtime"" || strMode == ""lastpaidblock"") {
        CBlockIndex* pindex = NULL;
        {
            LOCK(cs_main);
            pindex = chainActive.Tip();
        }
        mnodeman.UpdateLastPaid(pindex);
    }

    UniValue obj(UniValue::VOBJ);
    if (strMode == ""rank"") {
        CMasternodeMan::rank_pair_vec_t vMasternodeRanks;
        mnodeman.GetMasternodeRanks(vMasternodeRanks);
        for (std::pair<int, CMasternode>& s : vMasternodeRanks) {
            std::string strOutpoint = s.second.vin.prevout.ToStringShort();
            if (strFilter !="""" && strOutpoint.find(strFilter) == std::string::npos) continue;
            obj.push_back(Pair(strOutpoint, s.first));
        }
    } else {
        std::map<COutPoint, CMasternode> mapMasternodes = mnodeman.GetFullMasternodeMap();
        for (auto& mnpair : mapMasternodes) {
            CMasternode mn = mnpair.second;
            std::string strOutpoint = mnpair.first.ToStringShort();
            if (strMode == ""activeseconds"") {
                if (strFilter !="""" && strOutpoint.find(strFilter) == std::string::npos) continue;
                obj.push_back(Pair(strOutpoint, (int64_t)(mn.lastPing.sigTime - mn.sigTime)));
            } else if (strMode == ""addr"") {
                std::string strAddress = mn.addr.ToString();
                if (strFilter !="""" && strAddress.find(strFilter) == std::string::npos &&
                    strOutpoint.find(strFilter) == std::string::npos) continue;
                obj.push_back(Pair(strOutpoint, strAddress));
            } else if (strMode == ""full"") {
                std::ostringstream streamFull;
                int infinityType = mn.GetQsteesTypeInt();
                int rewardAtHeight = GetMasternodePayment(chainActive.Height(), infinityType) / COIN;
                int burnAmountByType = 0;
                if (infinityType == 1) burnAmountByType = Params().GetConsensus().nMasternodeBurnQSTEESNODE_1;
                if (infinityType == 5) burnAmountByType = Params().GetConsensus().nMasternodeBurnQSTEESNODE_5;
                if (infinityType == 10) burnAmountByType = Params().GetConsensus().nMasternodeBurnQSTEESNODE_10;
                streamFull << std::setw(18) <<
                               mn.GetStatus() << "" "" <<
                               mn.nProtocolVersion << "" "" <<
                               EncodeDestination(mn.pubKeyCollateralAddress.GetID()) << "" "" <<
                               (int64_t)mn.lastPing.sigTime << "" "" << std::setw(8) <<
                               (int64_t)(mn.lastPing.sigTime - mn.sigTime) << "" "" << std::setw(10) <<
                               mn.GetLastPaidTime() << "" ""  << std::setw(6) <<
                               mn.GetLastPaidBlock() << "" "" <<
                               mn.addr.ToString() << "" "" << infinityType << "" "" << rewardAtHeight << "" "" <<burnAmountByType;
                std::string strFull = streamFull.str();
                if (strFilter !="""" && strFull.find(strFilter) == std::string::npos &&
                    strOutpoint.find(strFilter) == std::string::npos) continue;
                obj.push_back(Pair(strOutpoint, strFull));
            } else if (strMode == ""info"") {
                std::ostringstream streamInfo;
                int infinityType = mn.GetQsteesTypeInt();
                int rewardAtHeight = GetMasternodePayment(chainActive.Height(), infinityType) / COIN;
                int burnAmountByType = 0;
                if (infinityType == 1) burnAmountByType = Params().GetConsensus().nMasternodeBurnQSTEESNODE_1;
                if (infinityType == 5) burnAmountByType = Params().GetConsensus().nMasternodeBurnQSTEESNODE_5;
                if (infinityType == 10) burnAmountByType = Params().GetConsensus().nMasternodeBurnQSTEESNODE_10;
                streamInfo << std::setw(18) <<
                               mn.GetStatus() << "" "" <<
                               mn.nProtocolVersion << "" "" <<
                               EncodeDestination(mn.pubKeyCollateralAddress.GetID()) << "" "" <<
                               (int64_t)mn.lastPing.sigTime << "" "" << std::setw(8) <<
                               (int64_t)(mn.lastPing.sigTime - mn.sigTime) << "" "" <<
                               SafeIntVersionToString(mn.lastPing.nSentinelVersion) << "" ""  <<
                               (mn.lastPing.fSentinelIsCurrent ? ""current"" : ""expired"") << "" "" <<
                               mn.addr.ToString() << "" "" << infinityType << "" "" << rewardAtHeight << "" "" <<burnAmountByType << "" "" << mn.GetBurnFundTxInfo();
                std::string strInfo = streamInfo.str();
                if (strFilter !="""" && strInfo.find(strFilter) == std::string::npos &&
                    strOutpoint.find(strFilter) == std::string::npos) continue;
                obj.push_back(Pair(strOutpoint, strInfo));
            } else if (strMode == ""lastpaidblock"") {
                if (strFilter !="""" && strOutpoint.find(strFilter) == std::string::npos) continue;
                obj.push_back(Pair(strOutpoint, mn.GetLastPaidBlock()));
            } else if (strMode == ""lastpaidtime"") {
                if (strFilter !="""" && strOutpoint.find(strFilter) == std::string::npos) continue;
                obj.push_back(Pair(strOutpoint, mn.GetLastPaidTime()));
            } else if (strMode == ""lastseen"") {
                if (strFilter !="""" && strOutpoint.find(strFilter) == std::string::npos) continue;
                obj.push_back(Pair(strOutpoint, (int64_t)mn.lastPing.sigTime));
            } else if (strMode == ""payee"") {
                std::string strPayee = EncodeDestination(mn.pubKeyCollateralAddress.GetID());
                if (strFilter !="""" && strPayee.find(strFilter) == std::string::npos &&
                    strOutpoint.find(strFilter) == std::string::npos) continue;
                obj.push_back(Pair(strOutpoint, strPayee));
            } else if (strMode == ""protocol"") {
                if (strFilter !="""" && strFilter != strprintf(""%d"", mn.nProtocolVersion) &&
                    strOutpoint.find(strFilter) == std::string::npos) continue;
                obj.push_back(Pair(strOutpoint, (int64_t)mn.nProtocolVersion));
            } else if (strMode == ""pubkey"") {
                if (strFilter !="""" && strOutpoint.find(strFilter) == std::string::npos) continue;
                obj.push_back(Pair(strOutpoint, HexStr(mn.pubKeyMasternode)));
            } else if (strMode == ""status"") {
                std::string strStatus = mn.GetStatus();
                if (strFilter !="""" && strStatus.find(strFilter) == std::string::npos &&
                    strOutpoint.find(strFilter) == std::string::npos) continue;
                obj.push_back(Pair(strOutpoint, strStatus));
            }
        }
    }
    return obj;
}

bool DecodeHexVecMnb(std::vector<CMasternodeBroadcast>& vecMnb, std::string strHexMnb) {

    if (!IsHex(strHexMnb))
        return false;

    std::vector<unsigned char> mnbData(ParseHex(strHexMnb));
    CDataStream ssData(mnbData, SER_NETWORK, PROTOCOL_VERSION);
    try {
        ssData >> vecMnb;
    }
    catch (const std::exception&) {
        return false;
    }

    return true;
}

UniValue masternodebroadcast(const JSONRPCRequest& request)
{
#ifdef ENABLE_WALLET
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
#endif // ENABLE_WALLET

    std::string strCommand;
    if (request.params.size() >= 1)
        strCommand = request.params[0].get_str();

    if (request.fHelp  ||
        (
#ifdef ENABLE_WALLET
            strCommand != ""create-alias"" && strCommand != ""create-all"" &&
#endif // ENABLE_WALLET
            strCommand != ""decode"" && strCommand != ""relay""))
        throw std::runtime_error(
                ""masternodebroadcast \\""command\\""...\\n""
                ""Set of commands to create and relay masternode broadcast messages\\n""
                ""\\nArguments:\\n""
                ""1. \\""command\\""        (string or set of strings, required) The command to execute\\n""
                ""\\nAvailable commands:\\n""
#ifdef ENABLE_WALLET
                ""  create-alias  - Create single remote masternode broadcast message by assigned alias configured in masternode.conf\\n""
                ""  create-all    - Create remote masternode broadcast messages for all masternodes configured in masternode.conf\\n""
#endif // ENABLE_WALLET
                ""  decode        - Decode masternode broadcast message\\n""
                ""  relay         - Relay masternode broadcast message to the network\\n""
                );

#ifdef ENABLE_WALLET
    if (strCommand == ""create-alias"")
    {
        // wait for reindex and/or import to finish
        if (fImporting || fReindex)
            throw JSONRPCError(RPC_INTERNAL_ERROR, ""Wait for reindex and/or import to finish"");

        if (request.params.size() < 2)
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Please specify an alias"");

        {
            LOCK(pwallet->cs_wallet);
            EnsureWalletIsUnlocked(pwallet);
        }

        bool fFound = false;
        std::string strAlias = request.params[1].get_str();

        UniValue statusObj(UniValue::VOBJ);
        std::vector<CMasternodeBroadcast> vecMnb;

        statusObj.push_back(Pair(""alias"", strAlias));

        for (CMasternodeConfig::CMasternodeEntry mne : masternodeConfig.getEntries()) {
            if(mne.getAlias() == strAlias) {
                fFound = true;
                std::string strError;
                CMasternodeBroadcast mnb;

                bool fResult = CMasternodeBroadcast::Create(mne.getIp(), mne.getPrivKey(), mne.getTxHash(), mne.getOutputIndex(), mne.getTxHashBurnFund(), mne.getOutputIndexBurnFund(), strError, mnb, true);

                statusObj.push_back(Pair(""result"", fResult ? ""successful"" : ""failed""));
                if(fResult) {
                    vecMnb.push_back(mnb);
                    CDataStream ssVecMnb(SER_NETWORK, PROTOCOL_VERSION);
                    ssVecMnb << vecMnb;
                    statusObj.push_back(Pair(""hex"", HexStr(ssVecMnb.begin(), ssVecMnb.end())));
                } else {
                    statusObj.push_back(Pair(""errorMessage"", strError));
                }
                break;
            }
        }

        if(!fFound) {
            statusObj.push_back(Pair(""result"", ""not found""));
            statusObj.push_back(Pair(""errorMessage"", ""Could not find alias in config. Verify with list-conf.""));
        }

        return statusObj;

    }

    if (strCommand == ""create-all"")
    {
        // wait for reindex and/or import to finish
        if (fImporting || fReindex)
            throw JSONRPCError(RPC_INTERNAL_ERROR, ""Wait for reindex and/or import to finish"");

        {
            LOCK(pwallet->cs_wallet);
            EnsureWalletIsUnlocked(pwallet);
        }

        std::vector<CMasternodeConfig::CMasternodeEntry> mnEntries;
        mnEntries = masternodeConfig.getEntries();

        int nSuccessful = 0;
        int nFailed = 0;

        UniValue resultsObj(UniValue::VOBJ);
        std::vector<CMasternodeBroadcast> vecMnb;

        for (CMasternodeConfig::CMasternodeEntry mne : masternodeConfig.getEntries()) {
            std::string strError;
            CMasternodeBroadcast mnb;

            bool fResult = CMasternodeBroadcast::Create(mne.getIp(), mne.getPrivKey(), mne.getTxHash(), mne.getOutputIndex(), mne.getTxHashBurnFund(), mne.getOutputIndexBurnFund(), strError, mnb, true);

            UniValue statusObj(UniValue::VOBJ);
            statusObj.push_back(Pair(""alias"", mne.getAlias()));
            statusObj.push_back(Pair(""result"", fResult ? ""successful"" : ""failed""));

            if(fResult) {
                nSuccessful++;
                vecMnb.push_back(mnb);
            } else {
                nFailed++;
                statusObj.push_back(Pair(""errorMessage"", strError));
            }

            resultsObj.push_back(Pair(""status"", statusObj));
        }

        CDataStream ssVecMnb(SER_NETWORK, PROTOCOL_VERSION);
        ssVecMnb << vecMnb;
        UniValue returnObj(UniValue::VOBJ);
        returnObj.push_back(Pair(""overall"", strprintf(""Successfully created broadcast messages for %d masternodes, failed to create %d, total %d"", nSuccessful, nFailed, nSuccessful + nFailed)));
        returnObj.push_back(Pair(""detail"", resultsObj));
        returnObj.push_back(Pair(""hex"", HexStr(ssVecMnb.begin(), ssVecMnb.end())));

        return returnObj;
    }
#endif // ENABLE_WALLET

    if (strCommand == ""decode"")
    {
        if (request.params.size() != 2)
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Correct usage is 'masternodebroadcast decode \\""hexstring\\""'"");

        std::vector<CMasternodeBroadcast> vecMnb;

        if (!DecodeHexVecMnb(vecMnb, request.params[1].get_str()))
            throw JSONRPCError(RPC_DESERIALIZATION_ERROR, ""Masternode broadcast message decode failed"");

        int nSuccessful = 0;
        int nFailed = 0;
        int nDos = 0;
        UniValue returnObj(UniValue::VOBJ);

        for (CMasternodeBroadcast& mnb : vecMnb) {
            UniValue resultObj(UniValue::VOBJ);

            if(mnb.CheckSignature(nDos)) {
                nSuccessful++;
                resultObj.push_back(Pair(""outpoint"", mnb.vin.prevout.ToStringShort()));
                resultObj.push_back(Pair(""addr"", mnb.addr.ToString()));
                resultObj.push_back(Pair(""pubKeyCollateralAddress"", EncodeDestination(mnb.pubKeyCollateralAddress.GetID())));
                resultObj.push_back(Pair(""pubKeyMasternode"", EncodeDestination(mnb.pubKeyMasternode.GetID())));
                resultObj.push_back(Pair(""vchSig"", EncodeBase64(&mnb.vchSig[0], mnb.vchSig.size())));
                resultObj.push_back(Pair(""sigTime"", mnb.sigTime));
                resultObj.push_back(Pair(""protocolVersion"", mnb.nProtocolVersion));
                resultObj.push_back(Pair(""nLastDsq"", mnb.nLastDsq));

                UniValue lastPingObj(UniValue::VOBJ);
                lastPingObj.push_back(Pair(""outpoint"", mnb.lastPing.vin.prevout.ToStringShort()));
                lastPingObj.push_back(Pair(""blockHash"", mnb.lastPing.blockHash.ToString()));
                lastPingObj.push_back(Pair(""sigTime"", mnb.lastPing.sigTime));
                lastPingObj.push_back(Pair(""vchSig"", EncodeBase64(&mnb.lastPing.vchSig[0], mnb.lastPing.vchSig.size())));

                resultObj.push_back(Pair(""lastPing"", lastPingObj));
            } else {
                nFailed++;
                resultObj.push_back(Pair(""errorMessage"", ""Masternode broadcast signature verification failed""));
            }

            returnObj.push_back(Pair(mnb.GetHash().ToString(), resultObj));
        }

        returnObj.push_back(Pair(""overall"", strprintf(""Successfully decoded broadcast messages for %d masternodes, failed to decode %d, total %d"", nSuccessful, nFailed, nSuccessful + nFailed)));

        return returnObj;
    }

    if (strCommand == ""relay"")
    {
        if (request.params.size() < 2 || request.params.size() > 3)
            throw JSONRPCError(RPC_INVALID_PARAMETER,   ""masternodebroadcast relay \\""hexstring\\"" ( fast )\\n""
                                                        ""\\nArguments:\\n""
                                                        ""1. \\""hex\\""      (string, required) Broadcast messages hex string\\n""
                                                        ""2. fast       (string, optional) If none, using safe method\\n"");

        std::vector<CMasternodeBroadcast> vecMnb;

        if (!DecodeHexVecMnb(vecMnb, request.params[1].get_str()))
            throw JSONRPCError(RPC_DESERIALIZATION_ERROR, ""Masternode broadcast message decode failed"");

        int nSuccessful = 0;
        int nFailed = 0;
        bool fSafe = request.params.size() == 2;
        UniValue returnObj(UniValue::VOBJ);

        // verify all signatures first, bailout if any of them broken
        for (CMasternodeBroadcast& mnb : vecMnb) {
            UniValue resultObj(UniValue::VOBJ);

            resultObj.push_back(Pair(""outpoint"", mnb.vin.prevout.ToStringShort()));
            resultObj.push_back(Pair(""addr"", mnb.addr.ToString()));

            int nDos = 0;
            bool fResult;
            if (mnb.CheckSignature(nDos)) {
                if (fSafe) {
                    fResult = mnodeman.CheckMnbAndUpdateMasternodeList(NULL, mnb, nDos, *g_connman);
                } else {
                    mnodeman.UpdateMasternodeList(mnb, *g_connman);
                    mnb.Relay(*g_connman);
                    fResult = true;
                }
                mnodeman.NotifyMasternodeUpdates(*g_connman);
            } else fResult = false;

            if(fResult) {
                nSuccessful++;
                resultObj.push_back(Pair(mnb.GetHash().ToString(), ""successful""));
            } else {
                nFailed++;
                resultObj.push_back(Pair(""errorMessage"", ""Masternode broadcast signature verification failed""));
            }

            returnObj.push_back(Pair(mnb.GetHash().ToString(), resultObj));
        }

        returnObj.push_back(Pair(""overall"", strprintf(""Successfully relayed broadcast messages for %d masternodes, failed to relay %d, total %d"", nSuccessful, nFailed, nSuccessful + nFailed)));

        return returnObj;
    }

    return NullUniValue;
}

UniValue sentinelping(const JSONRPCRequest& request)
{
    if (request.fHelp || request.params.size() != 1) {
        throw std::runtime_error(
            ""sentinelping version\\n""
            ""\\nSentinel ping.\\n""
            ""\\nArguments:\\n""
            ""1. version           (string, required) Sentinel version in the form \\""x.x.x\\""\\n""
            ""\\nResult:\\n""
            ""state                (boolean) Ping result\\n""
            ""\\nExamples:\\n""
            + HelpExampleCli(""sentinelping"", ""1.0.2"")
            + HelpExampleRpc(""sentinelping"", ""1.0.2"")
        );
    }

    activeMasternode.UpdateSentinelPing(StringVersionToInt(request.params[0].get_str()));
    return true;
}

UniValue infinitynode(const JSONRPCRequest& request)
{
    std::string strCommand;
    std::string strFilter = """";
    std::string strOption = """";

    if (request.params.size() >= 1) {
        strCommand = request.params[0].get_str();
    }
    if (request.params.size() == 2) strFilter = request.params[1].get_str();
    if (request.params.size() == 3) {
        strFilter = request.params[1].get_str();
        strOption = request.params[2].get_str();
    }
    if (request.params.size() > 3)
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Too many parameters"");

    if (request.fHelp  ||
        (strCommand != ""build-list"" && strCommand != ""show-lastscan"" && strCommand != ""show-infos"" && strCommand != ""stats""
                                    && strCommand != ""show-lastpaid"" && strCommand != ""build-stm"" && strCommand != ""show-stm""
                                    && strCommand != ""show-candidate"" && strCommand != ""show-script"" && strCommand != ""show-proposal""
                                    && strCommand != ""scan-vote"" && strCommand != ""show-proposals""
        ))
            throw std::runtime_error(
                ""infinitynode \\""command\\""...\\n""
                ""Set of commands to execute masternode related actions\\n""
                ""\\nArguments:\\n""
                ""1. \\""command\\""        (string or set of strings, required) The command to execute\\n""
                ""\\nAvailable commands:\\n""
                ""  build-list                  - Build list of all infinitynode from block height 165000 to last block\\n""
                ""  show-infos                  - Show the list of nodes and last information\\n""
                ""  show-lastscan               - Last nHeight when list is updated\\n""
                ""  show-lastpaid               - Last paid of all nodes\\n""
                ""  build-stm                   - Build statement list from genesis parameter\\n""
                ""  show-stm                    - Last statement of each QsteesType\\n""
                ""  show-candidate nHeight      - Last statement of each QsteesType\\n""
                );

    UniValue obj(UniValue::VOBJ);

    if (strCommand == ""build-list"")
    {
        CBlockIndex* pindex = NULL;
        {
                LOCK(cs_main);
                pindex = chainActive.Tip();
        }

        if (request.params.size() == 1)
            return infnodeman.buildInfinitynodeList(pindex->nHeight);

        std::string strMode = request.params[1].get_str();

        if (strMode == ""lastscan"")
            return infnodeman.getLastScan();
    }

    if (strCommand == ""build-stm"")
    {
            return infnodeman.deterministicRewardStatement(10) &&
                   infnodeman.deterministicRewardStatement(5) &&
                   infnodeman.deterministicRewardStatement(1);
    }

    if (strCommand == ""show-stm"")
    {
        return infnodeman.getLastStatementString();
    }

    if (strCommand == ""show-candidate"")
    {
        if (request.params.size() != 2)
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Correct usage is 'infinitynode show-candidate \\""nHeight\\""'"");
        int nextHeight = 10;
        nextHeight = atoi(strFilter);

        if ( nextHeight < Params().GetConsensus().nInfinityNodeGenesisStatement)
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""nHeight must superior than Genesis Statement param"");

        CInfinitynode infBIG, infMID, infLIL;
        infnodeman.deterministicRewardAtHeight(nextHeight, 10, infBIG);
        infnodeman.deterministicRewardAtHeight(nextHeight, 5, infMID);
        infnodeman.deterministicRewardAtHeight(nextHeight, 1, infLIL);

        obj.push_back(Pair(""Candidate BIG: "", infBIG.getCollateralAddress()));
        obj.push_back(Pair(""Candidate MID: "", infMID.getCollateralAddress()));
        obj.push_back(Pair(""Candidate LIL: "", infLIL.getCollateralAddress()));

        return obj;
    }

    if (strCommand == ""show-lastscan"")
    {
            return infnodeman.getLastScan();
    }

    if (strCommand == ""show-lastpaid"")
    {
        std::map<CScript, int>  mapLastPaid = infnodeman.GetFullLastPaidMap();
        for (auto& pair : mapLastPaid) {
            std::string scriptPublicKey = pair.first.ToString();
            obj.push_back(Pair(scriptPublicKey, pair.second));
        }
        return obj;
    }

    if (strCommand == ""show-infos"")
    {
        std::map<COutPoint, CInfinitynode> mapInfinitynodes = infnodeman.GetFullInfinitynodeMap();
        for (auto& infpair : mapInfinitynodes) {
            std::string strOutpoint = infpair.first.ToStringShort();
            CInfinitynode inf = infpair.second;
                std::ostringstream streamInfo;
                streamInfo << std::setw(8) <<
                               inf.getCollateralAddress() << "" "" <<
                               inf.getHeight() << "" "" <<
                               inf.getExpireHeight() << "" "" <<
                               inf.getRoundBurnValue() << "" "" <<
                               inf.getQSTEESType() << "" "" <<
                               inf.getBackupAddress() << "" "" <<
                               inf.getLastRewardHeight() << "" "" <<
                               inf.getRank();
                std::string strInfo = streamInfo.str();
                obj.push_back(Pair(strOutpoint, strInfo));
        }
        return obj;
    }

    if (strCommand == ""show-script"")
    {
        std::map<COutPoint, CInfinitynode> mapInfinitynodes = infnodeman.GetFullInfinitynodeMap();
        for (auto& infpair : mapInfinitynodes) {
            std::string strOutpoint = infpair.first.ToStringShort();
            CInfinitynode inf = infpair.second;
                std::ostringstream streamInfo;
                        std::vector<std::vector<unsigned char>> vSolutions;
                        txnouttype whichType;
                        const CScript& prevScript = inf.getScriptPublicKey();
                        Solver(prevScript, whichType, vSolutions);
                        std::string backupAddresstmp(vSolutions[1].begin(), vSolutions[1].end());
                streamInfo << std::setw(8) <<
                               inf.getCollateralAddress() << "" "" <<
                               backupAddresstmp << "" "" <<
                               inf.getRoundBurnValue();
                std::string strInfo = streamInfo.str();
                obj.push_back(Pair(strOutpoint, strInfo));
        }
        return obj;
    }

    if (strCommand == ""show-proposal"")
    {
        if (request.params.size() < 2)
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Correct usage is 'infinitynode show-proposal \\""ProposalId\\"" \\""(Optional)Mode\\"" '"");

        std::string proposalId  = strFilter;
        std::vector<CVote>* vVote = infnodersv.Find(proposalId);
        obj.push_back(Pair(""ProposalId"", proposalId));
        if(vVote != NULL){
            obj.push_back(Pair(""Votes"", (int)vVote->size()));
        }else{
            obj.push_back(Pair(""Votes"", ""0""));
        }
        int mode = 0;
        if (strOption == ""public""){mode=0;}
        if (strOption == ""node""){mode=1;}
        if (strOption == ""all""){mode=2;}
        obj.push_back(Pair(""Yes"", infnodersv.getResult(proposalId, true, mode)));
        obj.push_back(Pair(""No"", infnodersv.getResult(proposalId, false, mode)));
        for (auto& v : *vVote){
            CTxDestination addressVoter;
            ExtractDestination(v.getVoter(), addressVoter);
            obj.push_back(Pair(EncodeDestination(addressVoter), v.getOpinion()));
        }
        return obj;
    }

    if (strCommand == ""show-proposals"")
    {
        std::map<std::string, std::vector<CVote>> mapCopy = infnodersv.GetFullProposalVotesMap();
        obj.push_back(Pair(""Proposal"", (int)mapCopy.size()));
        for (auto& infpair : mapCopy) {
            obj.push_back(Pair(infpair.first, (int)infpair.second.size()));
        }

        return obj;
    }

    if (strCommand == ""scan-vote"")
    {
        CBlockIndex* pindex = NULL;
        {
                LOCK(cs_main);
                pindex = chainActive.Tip();
        }

        bool result = infnodersv.rsvScan(pindex->nHeight);
        obj.push_back(Pair(""Result"", result));
        obj.push_back(Pair(""Details"", infnodersv.ToString()));
        return obj;
    }
    return NullUniValue;
}

/**
 * @xtdevcoin
 * this function help user burn correctly their funds to run infinity node
 */
static UniValue infinitynodeburnfund(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();

    if (request.fHelp || request.params.size() != 2)
       throw std::runtime_error(
            ""infinitynodeburnfund amount QSTEESBackupAddress""
            ""\\nSend an amount to BurnAddress.\\n""
            ""\\nArguments:\\n""
            ""1. \\""amount\\""             (numeric or string, required) The amount in "" + CURRENCY_UNIT + "" to send. eg 0.1\\n""
            ""2. \\""NodeOwnerBackupAddress\\""  (string, required) The QSTEES address to send to when you make a notification(new feature soon).\\n""
            ""\\nResult:\\n""
            ""\\""BURNtxid\\""                  (string) The Burn transaction id. Need to run infinity node\\n""
            ""\\""CollateralAddress\\""         (string) Address of Collateral. Please send 10000 to this address.\\n""
            ""\\nExamples:\\n""
            + HelpExampleCli(""infinitynodeburnfund"", ""1000000 QSTEESBackupAddress"")
        );

    if(!masternodeSync.IsMasternodeListSynced())
    {
        throw JSONRPCError(RPC_TYPE_ERROR, ""Please wait until InfinityNode data is synced!"");
    }

    LOCK2(cs_main, pwallet->cs_wallet);
    EnsureWalletIsUnlocked(pwallet);
    // Make sure the results are valid at least up to the most recent block
    // the user could have gotten from another RPC command prior to now
    pwallet->BlockUntilSyncedToCurrentChain();

    std::string strError;
    std::vector<COutput> vPossibleCoins;
    pwallet->AvailableCoins(vPossibleCoins, true, NULL, false, ALL_COINS);

    UniValue results(UniValue::VARR);
    // Amount
    CAmount nAmount = AmountFromValue(request.params[0]);
    if (nAmount != Params().GetConsensus().nMasternodeBurnQSTEESNODE_1 * COIN &&
        nAmount != Params().GetConsensus().nMasternodeBurnQSTEESNODE_5 * COIN &&
        nAmount != Params().GetConsensus().nMasternodeBurnQSTEESNODE_10 * COIN)
    {
        throw JSONRPCError(RPC_TYPE_ERROR, ""Invalid amount to burn and run Infinitynode"");
    }

    CTxDestination BKaddress = DecodeDestination(request.params[1].get_str());
    if (!IsValidDestination(BKaddress))
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid QSTEES address for Backup"");

    std::map<COutPoint, CInfinitynode> mapInfinitynodes = infnodeman.GetFullInfinitynodeMap();
    int totalNode = 0, totalBIG = 0, totalMID = 0, totalLIL = 0, totalUnknown = 0;
    for (auto& infpair : mapInfinitynodes) {
        ++totalNode;
        CInfinitynode inf = infpair.second;
        int qsinbsteestype = inf.getQSTEESType();
        if (qsinbsteestype == 10) ++totalBIG;
        else if (qsinbsteestype == 5) ++totalMID;
        else if (qsinbsteestype == 1) ++totalLIL;
        else ++totalUnknown;
    }

    // BurnAddress
    CTxDestination dest = DecodeDestination(Params().GetConsensus().cBurnAddress);
    CScript scriptPubKeyBurnAddress = GetScriptForDestination(dest);
    std::vector<std::vector<unsigned char> > vSolutions;
    txnouttype whichType;
    if (!Solver(scriptPubKeyBurnAddress, whichType, vSolutions))
        return false;
    CKeyID keyid = CKeyID(uint160(vSolutions[0]));

    // Wallet comments
    std::set<CTxDestination> destinations;
    LOCK(pwallet->cs_wallet);
    for (COutput& out : vPossibleCoins) {
        CTxDestination address;
        const CScript& scriptPubKey = out.tx->tx->vout[out.i].scriptPubKey;
        bool fValidAddress = ExtractDestination(scriptPubKey, address);

        if (destinations.size() && (!fValidAddress || !destinations.count(address)))
            continue;

        UniValue entry(UniValue::VOBJ);
        entry.pushKV(""txid"", out.tx->GetHash().GetHex());
        entry.pushKV(""vout"", out.i);

        if (fValidAddress) {
            entry.pushKV(""address"", EncodeDestination(address));

            auto i = pwallet->mapAddressBook.find(address);
            if (i != pwallet->mapAddressBook.end()) {
                entry.pushKV(""label"", i->second.name);
                if (IsDeprecatedRPCEnabled(""accounts"")) {
                    entry.pushKV(""account"", i->second.name);
                }
            }

            if (scriptPubKey.IsPayToScriptHash()) {
                const CScriptID& hash = boost::get<CScriptID>(address);
                CScript redeemScript;
                if (pwallet->GetCScript(hash, redeemScript)) {
                    entry.pushKV(""redeemScript"", HexStr(redeemScript.begin(), redeemScript.end()));
                }
            }
        }

        entry.pushKV(""scriptPubKey"", HexStr(scriptPubKey.begin(), scriptPubKey.end()));
        entry.pushKV(""amount"", ValueFromAmount(out.tx->tx->vout[out.i].nValue));
        entry.pushKV(""spendable"", out.fSpendable);
        entry.pushKV(""solvable"", out.fSolvable);
        entry.pushKV(""safe"", out.fSafe);
        if (out.tx->tx->vout[out.i].nValue >= nAmount && out.nDepth >= 2) {
            /*check address is unique*/
            for (auto& infpair : mapInfinitynodes) {
                CInfinitynode inf = infpair.second;
                if(inf.getCollateralAddress() == EncodeDestination(address)){
                    strError = strprintf(""Error: Address %s exist in list. Please use another address to make sure it is unique."", EncodeDestination(address));
                    throw JSONRPCError(RPC_TYPE_ERROR, strError);
                }
            }
            // Wallet comments
            mapValue_t mapValue;
            bool fSubtractFeeFromAmount = true;
            bool fUseInstantSend=false;
            CCoinControl coin_control;
            coin_control.Select(COutPoint(out.tx->GetHash(), out.i));

            CScript script;
            script = GetScriptForBurn(keyid, request.params[1].get_str());

            CReserveKey reservekey(pwallet);
            CAmount nFeeRequired;
            CAmount curBalance = pwallet->GetBalance();
            
            std::vector<CRecipient> vecSend;
            int nChangePosRet = -1;
            CRecipient recipient = {script, nAmount, fSubtractFeeFromAmount};
            vecSend.push_back(recipient);
            CTransactionRef tx;
            if (!pwallet->CreateTransaction(vecSend, tx, reservekey, nFeeRequired, nChangePosRet, strError, coin_control, true, ALL_COINS, fUseInstantSend)) {
                if (!fSubtractFeeFromAmount && nAmount + nFeeRequired > curBalance)
                    strError = strprintf(""Error: This transaction requires a transaction fee of at least %s"", FormatMoney(nFeeRequired));
                throw JSONRPCError(RPC_WALLET_ERROR, strError);
            }
            CValidationState state;
            if (!pwallet->CommitTransaction(tx, std::move(mapValue), {} /* orderForm */, {}/*fromAccount*/, reservekey, g_connman.get(),
                            state, fUseInstantSend ? NetMsgType::TXLOCKREQUEST : NetMsgType::TX)) {
                strError = strprintf(""Error: The transaction was rejected! Reason given: %s"", FormatStateMessage(state));
                throw JSONRPCError(RPC_WALLET_ERROR, strError);
            }
            entry.pushKV(""BURNADDRESS"", EncodeDestination(dest));
            entry.pushKV(""BURNPUBLICKEY"", HexStr(keyid.begin(), keyid.end()));
            entry.pushKV(""BURNSCRIPT"", HexStr(scriptPubKeyBurnAddress.begin(), scriptPubKeyBurnAddress.end()));
            entry.pushKV(""BURNTX"", tx->GetHash().GetHex());
            entry.pushKV(""OWNER_ADDRESS"",EncodeDestination(address));
            entry.pushKV(""BACKUP_ADDRESS"",EncodeDestination(BKaddress));
            //coins is good to burn
            results.push_back(entry);
            break; //immediat
        }
    }
    return results;
}


static UniValue infinitynodeupdatemeta(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();

    if (request.fHelp || request.params.size() != 3)
       throw std::runtime_error(
            ""infinitynodeupdatemeta INFAddress UpdateInfo""
            ""\\nSend update info.\\n""
            ""\\nArguments:\\n""
            ""1. \\""OwnerAddress\\""  (string, required) Address of node OWNER which funds are burnt.\\n""
            ""2. \\""NodeAddress\\""   (string, required) Address of node which will be used for valide Reward, FlashSend...\\n""
            ""3. \\""IP\\""            (string, required) IP of node.\\n""
            ""\\nResult:\\n""
            ""\\""UpdateInfo upadted message\\""   (string) The Burn transaction id. Need to run infinity node\\n""
            ""\\nExamples:\\n""
            + HelpExampleCli(""infinitynodeupdatemeta"", ""OwnerAddress NodeAddress IP"")
        );
    UniValue results(UniValue::VOBJ);

    std::string strOwnerAddress = request.params[0].get_str();
    CTxDestination INFAddress = DecodeDestination(strOwnerAddress);
    if (!IsValidDestination(INFAddress)) {
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid QSTEES address: OwnerAddress"");
    }

    std::string strNodeAddress = request.params[1].get_str();
    CTxDestination NodeAddress = DecodeDestination(strNodeAddress);
    if (!IsValidDestination(NodeAddress)) {
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid QSTEES address: NodeAddress"");
    }

    std::string strService = request.params[2].get_str();
    CService service;
    if (!Lookup(strService.c_str(), service, 0, false)){
           throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""IP address is not valide"");
    }

    LOCK2(cs_main, pwallet->cs_wallet);
    EnsureWalletIsUnlocked(pwallet);
    // Make sure the results are valid at least up to the most recent block
    // the user could have gotten from another RPC command prior to now
    pwallet->BlockUntilSyncedToCurrentChain();

    std::string strError;
    std::vector<COutput> vPossibleCoins;
    pwallet->AvailableCoins(vPossibleCoins, true, NULL, false, ALL_COINS);

    // cMetadataAddress
    CTxDestination dest = DecodeDestination(Params().GetConsensus().cMetadataAddress);
    CScript scriptPubKeyMetaAddress = GetScriptForDestination(dest);
    std::vector<std::vector<unsigned char> > vSolutions;
    txnouttype whichType;
    if (!Solver(scriptPubKeyMetaAddress, whichType, vSolutions))
            return false;
    CKeyID keyid = CKeyID(uint160(vSolutions[0]));

    std::ostringstream streamInfo;

    for (COutput& out : vPossibleCoins) {
        CTxDestination address;
        const CScript& scriptPubKey = out.tx->tx->vout[out.i].scriptPubKey;
        bool fValidAddress = ExtractDestination(scriptPubKey, address);

        if (!fValidAddress) continue;
        if (EncodeDestination(INFAddress) != EncodeDestination(address)) continue;
        //use coin with limit value
        if (out.tx->tx->vout[out.i].nValue / COIN >= Params().GetConsensus().nInfinityNodeUpdateMeta
            && out.tx->tx->vout[out.i].nValue / COIN < Params().GetConsensus().nInfinityNodeUpdateMeta*100
            && out.nDepth >= 2) {
            CAmount nAmount = Params().GetConsensus().nInfinityNodeUpdateMeta*COIN;
            mapValue_t mapValue;
            bool fSubtractFeeFromAmount = true;
            bool fUseInstantSend=false;
            CCoinControl coin_control;
            coin_control.Select(COutPoint(out.tx->GetHash(), out.i));

            streamInfo << strNodeAddress << "";"" << strService;
            std::string strInfo = streamInfo.str();
            CScript script;
            script = GetScriptForBurn(keyid, streamInfo.str());

            CReserveKey reservekey(pwallet);
            CAmount nFeeRequired;
            CAmount curBalance = pwallet->GetBalance();
            
            std::vector<CRecipient> vecSend;
            int nChangePosRet = -1;
            CRecipient recipient = {script, nAmount, fSubtractFeeFromAmount};
            vecSend.push_back(recipient);

            results.push_back(Pair(""Metadata"",streamInfo.str()));


            CTransactionRef tx;
            if (!pwallet->CreateTransaction(vecSend, tx, reservekey, nFeeRequired, nChangePosRet, strError, coin_control, true, ALL_COINS, fUseInstantSend)) {
                if (!fSubtractFeeFromAmount && nAmount + nFeeRequired > curBalance)
                    strError = strprintf(""Error: This transaction requires a transaction fee of at least %s"", FormatMoney(nFeeRequired));
                throw JSONRPCError(RPC_WALLET_ERROR, strError);
            }
            CValidationState state;

            if (!pwallet->CommitTransaction(tx, std::move(mapValue), {}, {}, reservekey, g_connman.get(),
                            state, fUseInstantSend ? NetMsgType::TXLOCKREQUEST : NetMsgType::TX)) {
                strError = strprintf(""Error: The transaction was rejected! Reason given: %s"", FormatStateMessage(state));
                throw JSONRPCError(RPC_WALLET_ERROR, strError);
            }

            break; //immediat
        }
    }

    return results;
}


static UniValue infinitynodevote(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();

    if (request.fHelp || request.params.size() != 3)
       throw std::runtime_error(
            ""infinitynodevote AddressVote ProposalId [yes/no]""
            ""\\nSend update info.\\n""
            ""\\nArguments:\\n""
            ""1. \\""AddressVote\\""  (string, required) Address of vote.\\n""
            ""2. \\""ProposalId\\""   (string, required) Vote for proposalId\\n""
            ""3. \\""[yes/no]\\""            (string, required) opinion.\\n""
            ""\\nResult:\\n""
            ""\\""Vote information\\""   (string) result of vote\\n""
            ""\\nExamples:\\n""
            + HelpExampleCli(""infinitynodevote"", ""AddressVote ProposalId [yes/no]"")
        );
    UniValue results(UniValue::VOBJ);
    std::string strError = """";

    std::string strOwnerAddress = request.params[0].get_str();
    CTxDestination INFAddress = DecodeDestination(strOwnerAddress);
    if (!IsValidDestination(INFAddress)) {
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid QSTEES address: OwnerAddress"");
    }

    std::string ProposalId = request.params[1].get_str();
    bool has_only_digits = (ProposalId.find_first_not_of( ""0123456789"" ) == string::npos);
    //if (!has_only_digits || ProposalId.size() != 8){
    if (!has_only_digits || ProposalId != ""10000000""){//it will be update at hardfork
        strError = strprintf(""ProposalID %s must be in format xxxxxxxx (8 digits) number."", ProposalId);
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, strError);
    }

    std::string opinion = request.params[2].get_str();
    transform(opinion.begin(), opinion.end(), opinion.begin(), ::toupper);
    std::string vote = ""0"";
    if (opinion != ""YES"" && opinion != ""NO""){
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Please give your opinion yes or no."");
    }
    if (opinion == ""YES"") {vote = ""1"";}

    LOCK2(cs_main, pwallet->cs_wallet);
    EnsureWalletIsUnlocked(pwallet);
    // Make sure the results are valid at least up to the most recent block
    // the user could have gotten from another RPC command prior to now
    pwallet->BlockUntilSyncedToCurrentChain();

    std::vector<COutput> vPossibleCoins;
    pwallet->AvailableCoins(vPossibleCoins, true, NULL, false, ALL_COINS);

    // cBurnAddress
    CTxDestination dest = DecodeDestination(Params().GetConsensus().cGovernanceAddress);
    CScript scriptPubKeyBurnAddress = GetScriptForDestination(dest);
    std::vector<std::vector<unsigned char> > vSolutions;
    txnouttype whichType;
    if (!Solver(scriptPubKeyBurnAddress, whichType, vSolutions))
        return false;
    CKeyID keyid = CKeyID(uint160(vSolutions[0]));

    std::ostringstream streamInfo;

    for (COutput& out : vPossibleCoins) {
        CTxDestination address;
        const CScript& scriptPubKey = out.tx->tx->vout[out.i].scriptPubKey;
        bool fValidAddress = ExtractDestination(scriptPubKey, address);

        if (!fValidAddress) continue;
        if (EncodeDestination(INFAddress) != EncodeDestination(address)) continue;
        //use coin with limit value 10k QSTEES
        if (out.tx->tx->vout[out.i].nValue / COIN >= Params().GetConsensus().nInfinityNodeVoteValue
            && out.tx->tx->vout[out.i].nValue / COIN < Params().GetConsensus().nInfinityNodeVoteValue*1000
            && out.nDepth >= 2) {
            CAmount nAmount = Params().GetConsensus().nInfinityNodeVoteValue*COIN;
            mapValue_t mapValue;
            bool fSubtractFeeFromAmount = false;
            bool fUseInstantSend=false;
            CCoinControl coin_control;
            coin_control.Select(COutPoint(out.tx->GetHash(), out.i));
            coin_control.destChange = INFAddress;

            streamInfo << ProposalId << vote;
            std::string strInfo = streamInfo.str();
            CScript script;
            script = GetScriptForBurn(keyid, streamInfo.str());

            CReserveKey reservekey(pwallet);
            CAmount nFeeRequired;
            CAmount curBalance = pwallet->GetBalance();

            std::vector<CRecipient> vecSend;
            int nChangePosRet = -1;
            CRecipient recipient = {script, nAmount, fSubtractFeeFromAmount};
            vecSend.push_back(recipient);

            results.push_back(Pair(""Vote"",streamInfo.str()));

            CTransactionRef tx;
            if (!pwallet->CreateTransaction(vecSend, tx, reservekey, nFeeRequired, nChangePosRet, strError, coin_control, true, ALL_COINS, fUseInstantSend)) {
                if (!fSubtractFeeFromAmount && nAmount + nFeeRequired > curBalance)
                    strError = strprintf(""Error: This transaction requires a transaction fee of at least %s"", FormatMoney(nFeeRequired));
                throw JSONRPCError(RPC_WALLET_ERROR, strError);
            }
            CValidationState state;

            if (!pwallet->CommitTransaction(tx, std::move(mapValue), {}, {}, reservekey, g_connman.get(),
                            state, fUseInstantSend ? NetMsgType::TXLOCKREQUEST : NetMsgType::TX)) {
                strError = strprintf(""Error: The transaction was rejected! Reason given: %s"", FormatStateMessage(state));
                throw JSONRPCError(RPC_WALLET_ERROR, strError);
            }

            break; //immediat
        }
    }

    return results;
}

UniValue mnsetup(const JSONRPCRequest& request)
{
    if (request.fHelp || request.params.size() < 1)
        throw std::runtime_error(
            ""mnsetup <vps-ip>\\n""
            ""\\nAutomatically configure masternode."");

    std::string vpsip;
    if (request.params.size() >= 1) {
        vpsip = request.params[0].get_str();
    }

    //////////////////////////////////////////////////////////////////////////////////////////////////

    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();

    // generate masternode key
    CKey secret;
    secret.MakeNewKey(false);

    // find suitable collateral outputs
    std::vector<COutput> vPossibleCoins;
    LOCK2(cs_main, pwallet->cs_wallet);
    pwallet->AvailableCoins(vPossibleCoins, true, NULL, false, ONLY_MASTERNODE_COLLATERAL);

    int nCollatVout;
    char nCollatHash[65];
    bool foundCollat = false;
    for (COutput& out : vPossibleCoins) {
      if (!foundCollat) {
        strcpy(nCollatHash, out.tx->GetHash().ToString().c_str());
        nCollatVout = out.i;
        foundCollat = true;
      }
    }

    // find suitable burntx
    int burnVout;
    char burnTxid[65];
    bool foundBurn = false;

    for (map<uint256, CWalletTx>::const_iterator it = pwallet->mapWallet.begin(); it != pwallet->mapWallet.end(); ++it) {
      const uint256* txid = &(*it).first;
      const CWalletTx* pcoin = &(*it).second;
      for (unsigned int i = 0; i < pcoin->tx->vout.size(); i++) {
        if ((strstr(pcoin->tx->vout[i].scriptPubKey.ToString().c_str(),Params().GetConsensus().cBurnAddressPubKey)!=NULL) &&
          (pcoin->tx->vout[i].nValue == Params().GetConsensus().nMasternodeBurnQSTEESNODE_1 * COIN ||
           pcoin->tx->vout[i].nValue == Params().GetConsensus().nMasternodeBurnQSTEESNODE_5 * COIN ||
           pcoin->tx->vout[i].nValue == Params().GetConsensus().nMasternodeBurnQSTEESNODE_10 * COIN)) {
           if (!foundBurn) {
             strcpy(burnTxid, txid->ToString().c_str());
             burnVout = i;
             foundBurn = true;
           }
        }
      }
    }

    if (foundCollat && foundBurn) {

       char mnconfig[224];
       memset(mnconfig,'\\0',224);
       sprintf(mnconfig,""mn01 %s:%d %s %s %d %s %d\\n"", vpsip.c_str(), Params().GetDefaultPort(), EncodeSecret(secret).c_str(), nCollatHash, nCollatVout, burnTxid, burnVout);

       // parts taken from phore's masternode tool (https://github.com/phoreproject/Phore/pull/128)
       boost::filesystem::path pathMasternodeConfigFile = GetMasternodeConfigFile();
       boost::filesystem::ifstream streamConfig(pathMasternodeConfigFile);
       FILE* configFile = fopen(pathMasternodeConfigFile.string().c_str(), ""w"");
       std::string strHeader = ""# Masternode config file\\n""
                               ""# Format: alias IP:port masternodeprivkey collateral_output_txid collateral_output_index burnfund_output_txid burnfund_output_index\\n""
                               ""# mn01 127.0.0.1:20980 7RVuQhi45vfazyVtskTRLBgNuSrYGecS5zj2xERaooFVnWKKjhS b7ed8c1396cf57ac78d756186b6022d3023fd2f1c338b7fbae42d342fdd7070a 0 563d9434e816b3e8ffc5347c6b8db07509de6068f6759f21a16be5d92b7e3111 1\\n"";
       fwrite(strHeader.c_str(), std::strlen(strHeader.c_str()), 1, configFile);
       fwrite(mnconfig, strlen(mnconfig), 1, configFile);
       fclose(configFile);
    }

    //////////////////////////////////////////////////////////////////////////////////////////////////

    return ""AUTOMNSETUP."";
}

// Dash
static const CRPCCommand commands[] =
{ //  category              name                      actor (function)         argNames
  //  --------------------- ------------------------  -----------------------  ----------
    { ""QSTEES"",                ""masternode"",             &masternode,             {""command""}  },
    { ""dash"",               ""masternodelist"",         &masternodelist,         {""mode"", ""filter""}  },
    { ""dash"",               ""masternodebroadcast"",    &masternodebroadcast,    {""command""}  },
    { ""QSTEES"",                ""mnsetup"",                &mnsetup,                {}  },
    { ""QSTEES"",                ""infinitynodeburnfund"",   &infinitynodeburnfund,   {""amount""} },
    { ""QSTEES"",                ""infinitynodeupdatemeta"", &infinitynodeupdatemeta, {""owner_address"",""node_address"",""IP""} },
    { ""QSTEES"",                ""infinitynode"",           &infinitynode,           {""command""}  },
    { ""QSTEES"",                ""infinitynodevote"",       &infinitynodevote,       {""owner_address"",""proposalid"",""opinion""} }
};

void RegisterDashMasternodeRPCCommands(CRPCTable &t)
{
    for (unsigned int vcidx = 0; vcidx < ARRAYLEN(commands); vcidx++)
        t.appendCommand(commands[vcidx].name, &commands[vcidx]);
}
//
",16145,True,2803.299869807459,median
"---
title: Бүлэг 18. Аюулгүй байдлын үйл явцад аудит хийх нь 
part: хэсэг III. Системийн Удирдлага
prev: books/handbook/mac
next: books/handbook/disks
showBookMenu: true
weight: 22
path: ""/books/handbook/""
---

[[audit]]
= Аюулгүй байдлын үйл явцад аудит хийх нь 
:doctype: book
:toc: macro
:toclevels: 1
:icons: font
:sectnums:
:sectnumlevels: 6
:sectnumoffset: 18
:partnums:
:source-highlighter: rouge
:experimental:
:images-path: books/handbook/audit/

ifdef::env-beastie[]
ifdef::backend-html5[]
:imagesdir: ../../../../images/{images-path}
endif::[]
ifndef::book[]
include::shared/authors.adoc[]
include::shared/mirrors.adoc[]
include::shared/releases.adoc[]
include::shared/attributes/attributes-{{% lang %}}.adoc[]
include::shared/{{% lang %}}/teams.adoc[]
include::shared/{{% lang %}}/mailing-lists.adoc[]
include::shared/{{% lang %}}/urls.adoc[]
toc::[]
endif::[]
ifdef::backend-pdf,backend-epub3[]
include::../../../../../shared/asciidoctor.adoc[]
endif::[]
endif::[]

ifndef::env-beastie[]
toc::[]
include::../../../../../shared/asciidoctor.adoc[]
endif::[]

[[audit-synopsis]]
== Ерөнхий агуулга

FreeBSD үйлдлийн системд нягт-боловсруулсан, аюулгүй байдлын үйл явцад аудит хийх дэмжлэг орсон байгаа. Үйл явцад аудит хийх нь нэвтрэн оролтууд, тохиргооны өөрчлөлтүүд, болон файл болон сүлжээний хандалт зэрэг төрөл бүрийн аюулгүй байдлын холбогдолтой системийн үйл явцуудын хянаж бүртгэсэн бичлэгийг найдвартай, нягт-боловсруулсан, ба тохируулах боломжтойгоор хийх боломжийг бүрдүүлдэг. Эдгээр хянаж бүртгэсэн бичлэгүүд нь системийг шууд хянах, халдлага илрүүлэх, болон халдлагын дараах анализ хийхэд үнэлж баршгүй байж болох юм. FreeBSD Sun(TM)-ий гаргасан BSM API болон файлын хэлбэрийг шийдлээ болгосон бөгөөд Sun(TM)-ий Solaris болон Apple(R)-ийн Mac OS(R) X-ийн аудит шийдлүүдтэй харилцан ажиллах боломжтой.

Энэ бүлэг нь үйл явцыг аудит хийхийг тохируулах болон суулгах тал дээр анхаарна. Энд аудитийн бодлогуудын талаар тайлбарлах бөгөөд аудитийн тохиргооны жишээг бас харж болно.

Энэ бүлгийг уншсаны дараа, та дараах зүйлсийг мэдэх болно:

* Үйл явцыг аудит хийх гэж юу вэ болон яаж ажилладаг талаар.
* Хэрэглэгчид болон процессуудын үйл явцыг аудит хийхийг FreeBSD дээр яаж тохируулах талаар.
* Аудитийн мөрийг аудит багасгах болон хянах хэрэгслүүдээр хэрхэн шалгах талаар.

Энэ бүлгийг уншихаасаа өмнө, та дараах зүйлсийг мэдэх шаардлагатай:

* UNIX(R) болон FreeBSD-ийн үндсийг ойлгох (crossref:basics[basics,Юниксийн үндэс]).
* Цөмийг тохируулах/хөрвүүлэх үндэстэй танилцах (crossref:kernelconfig[kernelconfig,FreeBSD цөмийг тохируулах нь]).
* Аюулгүй байдлын талаар болон түүний FreeBSD -тэй хэрхэн холбогддог талаар ойлголттой байх (crossref:security[security,Аюулгүй байдал]).

[WARNING]
====

Аудит хэрэгсэл нь зарим нэг хязгаарлагдмал боломжуудтай бөгөөд тэдгээрээс дурдвал бүх аюулгүй байдлын холбогдолтой системийн үйл явцуудыг аудит хийх боломжгүй, X11 дээр үндэслэгдсэн дэлгэцийн менежерүүд болон гуравдагч дэмонууд зэрэг зарим нэвтрэх механизмууд хэрэглэгчийн нэвтрэх сессийг аудит хийх тохиргоог буруу хийдэг зэрэг болно.

Аюулгүй байдлын үйл явцыг аудит хийх хэрэгсэл нь системийн ажиллагааны маш дэлгэрэнгүй бичлэгүүдийг үүсгэх чадвартай: нарийвчилсан тохиргоо хийгдсэн завгүй системд мөр бичлэгийн файлын өгөгдөл тохиргооноос хамааран зарим тохиолдолд гигабайтаас ч илүү асар их болох боломжтой. Администраторууд их хэмжээний аудит хийх тохиргоотой холбоотой дискний хэмжээний шаардлагыг тооцох ёстой. Жишээ нь, аудит бичиж байгаа файлын систем дүүрэх нөхцөлд өөр бусад файлын системүүдэд хамааралгүйгээр файлын системийг [.filename]#/var/audit# модонд зориулах нь магадгүй зохимжтой байж болох юм.
====

[[audit-inline-glossary]]
== Энэ бүлгийн түлхүүр ухагдахуунууд

Энэ бүлгийг уншихаас өмнө аудиттай холбоотой цөөн түлхүүр ухагдахуунуудыг тайлбарлах шаардлагатай:

* _үйл явц_: Аудит хийх боломжтой үйл явц гэдэг нь аудит дэд системийн тусламжтайгаар хянаж бүртгэх боломжтой дурын үйл явцыг хэлнэ. Аюулгүй байдалтай холбоотой үйл явцуудын жишээнүүдэд файлын үүсгэлт, сүлжээний холболтыг босгох, эсвэл хэрэглэгчийн нэвтрэлтийг дурдаж болно. Үйл явцууд нь нэг бол жинхэнэ хэрэглэгч хүртэл мөрдөн гаргаж болох ""шинж чанарлаг"", эсвэл тэгж болохооргүй ""шинж чанарлаг бус "" байна. ""Шинж чанарлаг бус"" үйл явцуудын жишээнүүд гэвэл нууц үгийн буруу оролдлогууд гэх мэт нэвтрэн орох процессийн жинхэнэ эсэхийг шалгахаас өмнөх үеийн дурын үйл явцуудыг хэлж болно.
* _ангилал_: Үйл явцын ангиллууд гэдэг нь холбоотой үйл явцууд бүхий хэсэг бүлгүүдийн нэр бөгөөд эдгээр нь сонголтын илэрхийллүүдэд хэрэглэгддэг. Энгийн ашиглагддаг үйл явцуудын ангиллуудад ""файл үүсгэлт"" (fc), ""ажиллуулах"" (ex) мөн ""нэвтрэх_гарах"" (lo) зэрэг орно.
* _бичлэг_: Бичлэг гэдэг нь аюулгүй байдлын үйл явцыг тайлбарласан аудитийн хянан бүртгэсэн оруулга юм. Бичлэгүүд нь үйл явцын төрлийн бичлэг, субьектийн (хэрэглэгч) үйлдэл хийж байгаа тухай мэдээлэл, огноо болон цагийн мэдээлэл, дурын нэмэлт өгөгдлүүд болон обьектуудын мэдээлэл, амжилт эсвэл уналтын нөхцөлүүдийг агуулдаг.
* _мөр_: Аудитийн мөр буюу хянан бүртгэлийн файл нь аюулгүй байдлын үйл явцуудыг тайлбарласан аудит бичлэгүүдийн сериэс тогтоно. Ерөнхийдөө мөрүүд нь үйл явцуудын биелж дууссан цагийн дагуу он цагийн дарааллаар байрладаг. Зөвхөн жинхэнэ процессууд аудитийн мөрд бичлэг нэмэх эрхтэй байдаг.
* _сонголтын илэрхийлэл_: Сонголтын илэрхийлэл нь угтваруудын жагсаалт болон үйл явцтай тохирох аудитийн үйл явцын ангиллын нэрсээс тогтох мөр юм.
* _урьдчилсан сонголт_: Энэ нь администраторын сонирхох боломж бүхий үйл явцууд, сонирхлыг татахгүй байгаа үйл явц зэргийг тайлбарласан аудитийн бичлэгүүдийг үүсгэхээс зайлсхийх зорилготойгоор ялгасан системийн процесс юм. Урьдчилсан тохиргоо нь аль хэрэглэгчийн хувьд үйл явцуудын аль ангиллуудыг таних болон жинхэнэ болон жинхэнэ биш процессуудад хамаарах глобал тохиргоонуудын сонголтын илэрхийллүүдийн серийг ашигладаг.
* _хураангуйлалт_: Энэ нь байгаа аудитийн мөрнүүдээс аль бичлэгүүдийг хадгалалт, хэвлэлт болон анализ хийхээр сонгосон процесс юм. Үүний нэгэн адил аудит мөрөөс хэрэггүй аудит бичлэгүүдийг устгах процесс бас хамаарна. Хураангуйлалтыг ашиглаад администраторууд аудит өгөгдлийн хадгалалтын бодлогуудыг боловсруулах боломжтой юм. Жишээ нь, дэлгэрэнгүй аудитийн мөрнүүд нэг сарын хугацаанд хадгалагдаад дараагаар нь тэдгээр мөрнүүдийг архивын зорилгоор зөвхөн нэвтрэлтийн мэдээллийг үлдээн багасгаж болох юм.

[[audit-install]]
== Аудит хийх дэмжлэг суулгах нь

Үйл явцыг Аудит хийх хэрэглэгчийн талбарын дэмжлэг үндсэн FreeBSD үйлдлийн системд орсон байгаа. Үйл явцыг Аудит хийх дэмжлэг анхдагчаар эмхэтгэгдэн орсон боловч яг энэ боломжийг дэмжихийн тулд дараах мөрийг цөмд оруулан хөрвүүлсэн байх шаардлагатай:

[.programlisting]
....
options	AUDIT
....

crossref:kernelconfig[kernelconfig,FreeBSD цөмийг тохируулах нь] -д тайлбарласан ердийн процессийн дагуу цөмийг дахин хөрвүүлж суулгана.

Аудит идэвхжсэн цөм бүтээгдэж суулгагдаад систем дахин ачаалсны дараа дараах мөрийг man:rc.conf[5] -д нэмж аудит дэмонг идэвхжүүлнэ:

[.programlisting]
....
auditd_enable=""YES""
....

Тэгээд системийг дахин ачаалах замаар эсвэл гараар аудит дэмонг ажиллуулах замаар аудит дэмжлэгийг эхлүүлэх ёстой:

[.programlisting]
....
service auditd start
....

[[audit-config]]
== Аудитийн тохиргоо

Аюулгүй байдлын аудитийн тохиргооны бүх файлуудыг [.filename]#/etc/security# дотроос олж болно. Дараах файлууд аудит дэмон эхлэхээс өмнө байх ёстой:

* [.filename]#audit_class# - Аудитийн ангиллуудын тодорхойлолтуудыг агуулна.
* [.filename]#audit_control# - Анхдагч аудитийн ангиллууд, аудитийн хянан бүртгэлтийн эзлэхүүнд үлдээх хамгийн бага дискний зай, хамгийн их аудитийн мөрийн хэмжээ гэх зэрэг аудит дэд системийн шинж чанарыг хянана.
* [.filename]#audit_event# - Системийн аудит үйл явцуудын тайлбарууд, нэрс болон үйл явц болгон аль ангилалд хамаарах жагсаалт.
* [.filename]#audit_user# - Нэвтрэн орох үеийн глобал анхдагчуудаас бүрдсэн зөвхөн хэрэглэгчид хамааралтай аудитийн шаардлагууд
* [.filename]#audit_warn# - Аудитийн бичлэгүүдийн зай хангалтгүй болох эсвэл аудитийн мөрийн файл дахин эргэсэн зэрэг зайлшгүй шаардлагатай тохиолдолд анхааруулах мэдээллүүдийг үүсгэдэг өөрчлөх боломж бүхий auditd-ийн ашигладаг бүрхүүлийн скрипт.

[WARNING]
====

Тохиргоон дахь алдаанууд үйл явцуудын буруу хянан бүртгэлд хүргэж болзошгүй тул аудитийн тохиргооны файлуудыг засварлах болон ажиллагааг хангахдаа заавал болгоомжтой байх шаардлагатай.
====

=== Үйл явц сонголтын илэрхийллүүд

Сонголтын илэрхийллүүд нь аль үйл явцуудыг аудит хийх ёстойг тодорхойлох аудитийн тохиргооны хэд хэдэн газар ашиглагддаг. Илэрхийллүүд нь тохирох үйл явцын ангиллуудын жагсаалтаас бүрдэх ба эдгээр тус бүр нь тохирох бичлэгүүдийг хүлээн авах ёстой юу эсвэл орхих ёстой юу гэдгийг харуулсан угтвартайгаас гадна оруулга нь амжилттай эсвэл амжилтгүй үйлдлүүдтэй тохирох ёстойг харуулах боломж бас байна. Сонголтын илэрхийллүүд нь зүүнээс баруун тийш биелэгддэг бөгөөд хоёр илэрхийллийг нэг дээр нь нөгөөг нь нэмж нийлүүлдэг.

Дараах жагсаалт нь [.filename]#audit_class#-д байгаа анхдагч үйл явцын ангиллуудаас тогтоно:

* `all` - _all_ - Бүх үйл явцын ангиллуудыг тааруулах(match).
* `ad` - _administrative_ - Удирдлагын үйлдлүүд систем дээр бүхэлдээ гүйцэтгэгдэнэ.
* `ap` - _application_ - Програмын тодорхойлсон үйлдэл.
* `cl` - _file close_ - `close` системийн дуудлагыг аудит хийх.
* `ex` - _exec_ - Програмын ажиллагааг аудит хийх. Тушаалын мөрийн нэмэлт өгөгдлүүд болон орчны хувьсагчуудыг `argv` ба `envv` параметрүүдийг ашиглан `policy` тохиргоонд тохиргоо хийн man:audit_control[5] -ийн тусламжтайгаар хянадаг.
* `fa` - _file attribute access_ - man:stat[1], man:pathconf[2] болон бусад адил үйл явцуудын обьектийн шинж чанаруудад хандсан хандалтыг аудит хийх.
* `fc` - _file create_ - Үр дүнд нь файл үүсдэг үйл явцуудыг аудит хийх.
* `fd` - _file delete_ - Файлыг устгадаг үйл явцуудыг аудит хийх.
* `fm` - _file attribute modify_ - man:chown[8], man:chflags[1], man:flock[2] зэрэг файлын шинж чанарын өөрчлөлт гарч байгаа үйл явцуудыг аудит хийх.
* `fr` - _file read_ - Өгөгдөл уншигдаж байгаа, мөн файлуудыг уншихаар нээсэн зэрэг үйл явцуудыг аудит хийх.
* `fw` - _file write_ - Өгөгдөл бичигдэж байгаа, мөн файлд бичсэн эсвэл файл өөрчлөгдсөн зэрэг үйл явцуудыг аудит хийх.
* `io` - _ioctl_ - man:ioctl[2] системийн дуудлагын хэрэглээг аудит хийх.
* `ip` - _ipc_ - POSIX хоолойнууд болон System V IPC үйлдлүүд зэрэг Процесс-Хоорондох Холбооны төрөл бүрийн хэлбэрүүдийг аудит хийх.
* `lo` - _login_logout_ - Систем дээр болж байгаа man:login[1] ба man:logout[1] үйл явцуудыг аудит хийх.
* `na` - _non attributable_ - Шинж чанаргүй үйл явцуудыг аудит хийх.
* `no` - _invalid class_ - Аудит бус үйл явцуудыг тааруулах(match).
* `nt` - _network_ - man:connect[2] ба man:accept[2] зэрэг сүлжээний үйлдлүүдтэй холбоотой үйл явцуудыг аудит хийх.
* `ot` - _other_ - Бусад үйл явцуудыг аудит хийх.
* `pc` - _process_ - man:exec[3] ба man:exit[3] зэрэг процессийн үйлдлүүдийг аудит хийх.

Эдгээр аудит үйл явцын ангиллуудыг [.filename]#audit_class# болон [.filename]#audit_event# тохиргооны файлуудыг өөрчилснөөр өөрчилж болно.

Жагсаалтад байгаа аудитийн ангилал бүр амжилттай/амжилтгүй үйлдлүүдийг таарсан эсэхийг болон ангилал ба төрлийн хувьд таарч байгааг нэмж байгаа эсвэл устгаж байгааг харуулсан угтвартай байна.

* (none) Үйл явцын амжилттай болон амжилтгүйг аудит хийх.
* `+` Энэ ангилал дахь амжилттай үйл явцуудыг аудит хийх.
* `-` Энэ ангилал дахь амжилтгүй үйл явцуудыг аудит хийх.
* `^` Энэ ангилал дахь амжилттай, амжилтгүй аль нь ч биш үйл явцуудыг аудит хийх.
* `^+` Энэ ангилал дахь амжилттай үйл явцуудыг аудит хийхгүй.
* `^-` Энэ ангилал дахь амжилтгүй үйл явцуудыг аудит хийхгүй.

Дараах сонголтын мөр амжилттай ба амжилтгүй нэвтрэлт/гаралтын үйл явцуудаас гадна зөвхөн амжилттай ажиллуулсныг сонгож байна:

[.programlisting]
....
lo,+ex
....

=== Тохиргооны файлууд

Аудит системийг тохируулахдаа ихэнх тохиолдолд администраторууд зөвхөн хоёр файлыг өөрчлөх хэрэгтэй: [.filename]#audit_control# болон [.filename]#audit_user#. Эхнийх нь системийн дагуух аудит өмчүүд болон бодлогуудыг хянадаг; хоёр дахь нь хэрэглэгчийн аудитийг нарийн тохируулахад ашиглагддаг.

[[audit-auditcontrol]]
==== [.filename]#audit_control# файл

[.filename]#audit_control# файл нь аудит дэд системийн хувьд анхдагч утгуудын тоог тодорхойлно. Энэ файлын дотор бид дараах зүйлсийг харна:

[.programlisting]
....
dir:/var/audit
flags:lo
minfree:20
naflags:lo
policy:cnt
filesz:0
....

`dir` тохиргоо нь аудит бүртгэлүүдийг хадгалах нэг болон хэд хэдэн санг заахад хэрэглэгдэнэ. Хэрэв нэгээс их сан байгаа бол бичигдсэн дарааллаараа ашиглагдана. Файлын систем дүүрсэн тохиолдолд аудит дэд систем болон бусад дэд системүүд бие биедээ нөлөөлж болзошгүй учир аудит бүртгэлүүдийг тусгайлан зориулсан файлын систем дээр хадгалахаар аудит системийг ихэвчлэн тохируулдаг.

`flags` талбар нь системийн дагуух шинж чанар бүхий үйл явцуудад зориулсан анхдагч урьдчилан сонголтын багийг тодорхойлдог. Дээрх жишээн дээр бүх хэрэглэгчийн хувьд амжилттай болон амжилтгүй нэвтрэлт болон гаралтын үйл явцууд аудит хийгдэж байна.

`minfree` тохиргоо нь аудит мөр хадгалагдах файлын системийн хувьд хамгийн бага чөлөөт зайны хувийг тодорхойлдог. Энэ тогтоосон хэмжээнээс илүү гарахад анхааруулга үүсгэгддэг. Дээрх жишээ хамгийн бага чөлөөт зайг 20 хувиар тогтоожээ.

`naflags` тохиргоо нь нэвтрэн оролтын процесс болон системийн дэмонууд зэрэг шинж чанаргүй үйл явцуудыг аудит хийх аудитийн ангиллуудыг тодорхойлдог.

`policy` тохиргоо нь таслалаар тусгаарлагдсан, аудитийн зан авирын төрөл бүрийн шинж чанарыг хянах бодлогын тугуудын жагсаалтыг тодорхойлдог. Анхдагч `cnt` туг нь аудит амжилтгүй болсон ч гэсэн систем ажиллагаагаа үргэлжлүүлэхийг заадаг (энэ туг зайлшгүй шаардлагатай). Өөр нэг байнга ашиглагддаг туг бол `argv` бөгөөд энэ нь man:execve[2] системийн дуудлагад орж байгаа тушаалын мөрийн нэмэлт өгөгдлүүдийг тушаалын ажиллагааг аудит хийхийн хэсэг болох боломж олгодог.

`filesz` тохиргоо нь мөрийн файл автоматаар төгсөх болон эргэхээс өмнөх аудит мөрийн файлын хамгийн их хэмжээг байтаар тодорхойлдог. Анхдагч утга нь 0 байх ба автоматаар эргүүлэхийг хориглосон байна. Хэрэв хүссэн файлын хэмжээ тэгээс ялгаатай ба 512k -аас бага бол түүнийг орхиж бүртгэлийн мэдээлэл үүсгэнэ.

[[audit-audituser]]
==== [.filename]#audit_user# файл

[.filename]#audit_user# файл нь зарим нэг хэрэглэгчдэд зориулсан аудитийн шаардлагуудыг администраторууд тодорхойлохыг зөвшөөрдөг. Мөр болгон хэрэглэгчид зориулсан аудитийг хийхийг хоёр талбараар тохируулдаг: нэг дэх нь хэрэглэгчийн хувьд үргэлж аудит хийх шаардлагатай нэг хэсэг үйл явцуудыг тодорхойлдог `alwaysaudit` талбар ба хоёр дахь нь `neveraudit` талбар бөгөөд хэрэглэгчийн хувьд хэзээ ч аудит хийх шаардлагагүй нэг хэсэг үйл явцуудыг тодорхойлдог.

Дараах жишээн дээр [.filename]#audit_user# файл нь нэвтрэлт/гаралтын үйл явцууд, `root` хэрэглэгчийн амжилттай тушаалын ажиллагаа, файл үүсгэлт ба `www` хэрэглэгчийн амжилттай тушаалын ажиллагааг аудит хийж байна. Хэрэв дээрх жишээ [.filename]#audit_control# файлтай цуг ашиглагдвал `root`-ийн `lo` оруулга нь давхардах бөгөөд `www` хэрэглэгчийн нэвтрэлт/гаралтын үйл явцууд бас аудит хийгдэнэ.

[.programlisting]
....
root:lo,+ex:no
www:fc,+ex:no
....

[[audit-administration]]
== Аудит дэд системийг удирдах нь

=== Аудит мөрүүдийг харах нь

Аудит мөрүүд нь BSM хоёртын хэлбэрээр хадгалагддаг бөгөөд өөрчлөх болон текст уруу хөрвүүлэхэд тусгай хэрэгслүүд ашиглах шаардлагатай. man:praudit[1] тушаал нь мөрийн файлуудыг хялбар текст хэлбэрт хөрвүүлдэг; man:auditreduce[1] тушаал нь аудит мөрийн файлыг шинжлэх, архивлах эсвэл хэвлэх зорилгоор багасгахад ашиглагддаг. `auditreduce` нь үйл явцын төрөл, үйл явцын ангилал, үйл явцын хэрэглэгч, огноо эсвэл цаг, файлын зам эсвэл обьектийн үйлдэл үзүүлсэн зэрэг төрөл бүрийн сонголтын параметрүүдийг дэмждэг.

Жишээ нь `praudit` хэрэгсэл нь заасан аудит бүртгэлийн бүх агуулгыг жирийн текстээр харуулна:

[source,shell]
....
# praudit /var/audit/AUDITFILE
....

[.filename]#AUDITFILE# нь харуулах аудит бүртгэл юм.

Аудит мөрүүд нь токенуудаас бүтэх аудит бичлэгүүдийн цувралаас тогтох бөгөөд `praudit` нь мөр болгонд нэгийг дараалуулан хэвлэнэ. Токен бүр аудит бичлэгийн толгойг агуулсан `header` эсвэл нэрийн хайлтаас гарсан файлын замыг агуулсан `path` зэрэг тусгай төрлийн байна. Дараах жишээ нь `execve` үйл явцыг харуулж байна:

[.programlisting]
....
header,133,10,execve(2),0,Mon Sep 25 15:58:03 2006, + 384 msec
exec arg,finger,doug
path,/usr/bin/finger
attribute,555,root,wheel,90,24918,104944
subject,robert,root,wheel,root,wheel,38439,38032,42086,128.232.9.100
return,success,0
trailer,133
....

Энэхүү аудит нь амжилттай `execve` дуудлагыг илэрхийлж байгаа бөгөөд түүнд `finger doug` тушаал ажиллажээ. Нэмэлт өгөгдлийн токен нь цөм уруу бүрхүүлээс гарч боловсруулагдсан тушаалын мөрийг агуулна. `path` буюу замын токен нь цөмийн хайсан ажиллах файлын замыг агуулна. `attribute` буюу шинж чанарын токен нь хоёртын файлыг тайлбарлах ба тухайлбал програм setuid эсэхийг тодорхойлоход ашиглагдах файлын горимыг агуулна. `subject` буюу субьект токен нь субьект процессийг тайлбарлах бөгөөд аудит хэрэглэгчийн ID, идэвхитэй хэрэглэгчийн ID ба бүлгийн ID, жинхэнэ хэрэглэгчийн ID ба бүлгийн ID, процессийн ID, сессийн ID, портын ID болон нэвтрэлтийн хаяг гэсэн дарааллаар хадгална. Аудит хэрэглэгчийн ID ба жинхэнэ хэрэглэгчийн ID нь ялгаатайг анхаарах хэрэгтэй: `robert` гэдэг хэрэглэгч энэ тушаалыг ажиллуулахаасаа өмнө `root` бүртгэл уруу шилжсэн бөгөөд энэ нь эхний шалгуулсан хэрэглэгчийг ашиглан аудит хийгдсэн байна. Төгсгөлд нь `return` буюу буцах токен нь амжилттай ажиллагааг харуулж `trailer` нь бичлэгийг төгсгөнө.

`praudit` нь бас XML гаралтын хэлбэрийг дэмждэг бөгөөд үүнийг `-x` нэмэлт өгөгдлийг ашиглан сонгож болдог.

=== Аудитийн мөрүүдийг багасгах нь

Аудит бүртгэлүүд нь маш их байж болно, администратор зарим хэрэглэгчтэй холбоотой бичлэгүүд зэрэг хэсэг бичлэгүүдийг ашиглахын тулд шилж сонгохыг магадгүй хүснэ:

[source,shell]
....
# auditreduce -u trhodes /var/audit/AUDITFILE | praudit
....

Энэ нь [.filename]#AUDITFILE# файлд хадгалагдсан `trhodes` хэрэглэгчийн бүх аудитийн бичлэгүүдийг сонгож байна.

=== Аудит хянах эрхүүдийг томилох нь

`audit` бүлгийн гишүүд [.filename]#/var/audit# дахь аудит мөрүүдийг унших эрхтэй; анхандаа энэ бүлэг нь хоосон байх бөгөөд тэгэхээр зөвхөн `root` хэрэглэгч аудит мөрүүдийг уншиж чадна. Аудит хянах эрхүүдийг хэрэглэгчдэд томилохын тулд хэрэглэгчдийг `audit` бүлэгт нэмж болно. Аудитийн бүртгэлийн агуулгыг хянах чадвар нь хэрэглэгчид болон процессуудын үйл хөдлөлийн дотоод уруу нэлээн гүнзгий ханддаг учир аудит хянах эрхүүдийг томилохдоо болгоомжтой хийхийг зөвлөж байна.

=== Аудит хоолойнуудыг шууд монитор хийх нь

Аудит хоолойнууд нь төхөөрөмжийн файлын систем дахь клон хийгдсэн псевдо төхөөрөмжүүд бөгөөд програмыг шууд явж байгаа аудит бичлэгийн урсгалд холбох боломж олгоно. Энэ нь голчлон халдлага илрүүлэх болон систем монитор хийх програмуудын зохиогчдын сонирхлыг татдаг. Гэхдээ администраторуудын хувьд аудитийн хоолойны төхөөрөмж нь аудитийн мөрийн файлын эзэмшил эсвэл үйл явцын урсгалыг зогсоох, бүртгэл эргүүлэх зэрэг асуудлуудтай холбогдолгүйгээр шууд монитор хийх эвтэйхэн боломжийг бүрдүүлдэг. Шууд явж байгаа аудитийн үйл явцын урсгалыг хянахдаа дараах тушаалын мөрийг ашиглана:

[source,shell]
....
# praudit /dev/auditpipe
....

Анхандаа аудитийн хоолойны төхөөрөмжийн цэгүүдэд зөвхөн `root` хэрэглэгч хандах эрхтэй байдаг. `audit` бүлгийн хэрэглэгчид хандах боломжтой болгохын тулд `devfs` дүрмийг [.filename]#devfs.rules# -д нэмнэ:

[.programlisting]
....
add path 'auditpipe*' mode 0440 group audit
....

devfs файлын системийг тохируулах талаар дэлгэрэнгүй мэдээллийг man:devfs.rules[5] -ээс харна уу.

[WARNING]
====

Аудитийн үйл явцын буцааж өгөх давталтуудыг үүсгэх нь хялбар бөгөөд аудит үйл явц бүрийн үзэлт нь олон аудитийн үйл явцуудыг үүсгэхэд хүргэнэ. Жишээ нь, хэрэв сүлжээний бүх I/O аудит хийгдсэн бөгөөд man:praudit[1] нь SSH сессээс ажилласан бол үйл явц бүр хэвлэгдэхэд өөр үйл явцыг бас үүсгэх учраас үргэлжилсэн аудитийн үйл явцууд их хэмжээгээр үүсэх болно. Энэ асуудлыг бий болгохгүйн тулд нарийн тохируулаагүй I/O аудит хийх сессээс `praudit`-ийг аудитийн хоолойны төхөөрөмж дээр ажиллуулахыг зөвлөж байна.
====

=== Аудит мөрийн файлуудыг эргүүлэх нь

Аудит мөрүүд нь зөвхөн цөмөөр бичигдэх бөгөөд auditd аудит дэмоноор удирдагддаг. Администраторууд аудит бүртгэлүүдийг шууд эргүүлэхдээ man:newsyslog.conf[5] эсвэл бусад хэрэгслүүдийг ашиглан хийх ёсгүй юм. Харин `audit` удирдах хэрэгслийг ашиглан аудитийг унтраах, аудит системийг дахин тохируулах, болон бүртгэлийг эргүүлэх үйлдлүүдийг хийх боломжтой байдаг. Дараах тушаал аудит дэмонг шинэ аудит бүртгэл үүсгэж цөмийг шинэ бүртгэл уруу шилжихийг дохино. Хуучин бүртгэл нь төгсөж нэр нь өөрчлөгдөх бөгөөд дараагаар түүнтэй администратор ажиллах боломж бүрдэнэ.

[source,shell]
....
# audit -n
....

[WARNING]
====

Хэрэв auditd дэмон ажиллахгүй байгаа бол энэ тушаал нь амжилтгүй болох бөгөөд алдааны мэдээлэл үүсгэнэ.
====

Дараах мөрийг [.filename]#/etc/crontab# -д нэмснээр man:cron[8] -оос арван хоёр цаг тутам эргүүлэх болно:

[.programlisting]
....
0     */12       *       *       *       root    /usr/sbin/audit -n
....

Шинэ [.filename]#/etc/crontab# -ийг хадгалсны дараа өөрчлөлт үйлчилж эхлэх болно.

Файлын хэмжээн дээр тулгуурласан аудитийн мөрийн файлыг автоматаар эргүүлэх нь man:audit_control[5] дахь `filesz` тохиргоогоор хийгдэх боломжтой бөгөөд гарын авлагын энэ бүлгийн тохиргооны файлуудын хэсэгт тайлбарласан болно.

=== Аудит мөрүүдийг шахах нь

Аудит мөрийн файлууд асар их болох тусам мөрүүдийг аудит дэмоноор хаалгасны дараа шахах эсвэл архивлах нь зүйтэй юм. [.filename]#audit_warn# скрипт нь аудитийн мөрүүдийг эргүүлэх үеийн цэвэр төгсгөл зэрэг төрөл бүрийн аудиттай холбоотой үйл явцуудад зориулан өөрчилсөн үйлдлүүдийг гүйцэтгэхэд ашиглагдана. Жишээ нь хаагдах үед аудит мөрүүдийг шахах дараах кодыг [.filename]#audit_warn# скриптэд нэмж болно:

[.programlisting]
....
#
# Compress audit trail files on close.
#
if [ ""$1"" = closefile ]; then
        gzip -9 $2
fi
....

Бусад архивлах идэвхүүдэд мөрийн файлуудыг төв сервер уруу хуулах, хуучин мөрийн файлуудыг устгах эсвэл хэрэггүй бичлэгүүдийг хасч аудит мөрийг багасгах зэрэг орж болно. Аудит мөрийн файлууд цэвэрхэн дууссан тохиолдолд скрипт ажиллана, тэгэхээр буруу унтраасны дараа дуусаагүй мөрүүд дээр ажиллахгүй.
",12459,True,2672.8368874831976,median
"/*
  Copyright 2013 Larry Gritz and the other authors and contributors.
  All Rights Reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are
  met:
  * Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.
  * Redistributions in binary form must reproduce the above copyright
    notice, this list of conditions and the following disclaimer in the
    documentation and/or other materials provided with the distribution.
  * Neither the name of the software's owners nor the names of its
    contributors may be used to endorse or promote products derived from
    this software without specific prior written permission.
  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

  (This is the Modified BSD License)
*/

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <iostream>
#include <iterator>
#include <limits>
#include <sstream>
#include <memory>

#include <boost/version.hpp>

#include <OpenEXR/ImathMatrix.h>
#include <OpenEXR/half.h>

#include <OpenImageIO/argparse.h>
#include <OpenImageIO/dassert.h>
#include <OpenImageIO/filesystem.h>
#include <OpenImageIO/fmath.h>
#include <OpenImageIO/strutil.h>
#include <OpenImageIO/sysutil.h>
#include <OpenImageIO/timer.h>
#include <OpenImageIO/imageio.h>
#include <OpenImageIO/imagebuf.h>
#include <OpenImageIO/imagebufalgo.h>
#include <OpenImageIO/imagebufalgo_util.h>
#include <OpenImageIO/thread.h>
#include <OpenImageIO/filter.h>

#ifdef USE_BOOST_REGEX
# include <boost/regex.hpp>
  using boost::regex;
  using boost::regex_replace;
#else
# include <regex>
  using std::regex;
  using std::regex_replace;
#endif

using namespace OIIO;


static spin_mutex maketx_mutex;   // for anything that needs locking



static Filter2D *
setup_filter (const ImageSpec &dstspec, const ImageSpec &srcspec,
              std::string filtername = std::string())
{
    // Resize ratio
    float wratio = float(dstspec.full_width) / float(srcspec.full_width);
    float hratio = float(dstspec.full_height) / float(srcspec.full_height);
    float w = std::max (1.0f, wratio);
    float h = std::max (1.0f, hratio);

    // Default filter, if none supplied
    if (filtername.empty()) {
        // No filter name supplied -- pick a good default
        if (wratio > 1.0f || hratio > 1.0f)
            filtername = ""blackman-harris"";
        else
            filtername = ""lanczos3"";
    }

    // Figure out the recommended filter width for the named filter
    for (int i = 0, e = Filter2D::num_filters();  i < e;  ++i) {
        FilterDesc d;
        Filter2D::get_filterdesc (i, &d);
        if (filtername == d.name)
            return Filter2D::create (filtername, w*d.width, h*d.width);
    }

    return NULL;  // couldn't find a matching name
}



static TypeDesc
set_prman_options(TypeDesc out_dataformat, ImageSpec &configspec)
{
    // Force separate planar image handling, and also emit prman metadata
    configspec.attribute (""planarconfig"", ""separate"");
    configspec.attribute (""maketx:prman_metadata"", 1);

    // 8-bit : 64x64
    if (out_dataformat == TypeDesc::UINT8 || out_dataformat == TypeDesc::INT8) {
        configspec.tile_width = 64;
        configspec.tile_height = 64;
    }

    // 16-bit : 64x32
    // Force u16 -> s16
    // In prman's txmake (last tested in 15.0)
    // specifying -short creates a signed int representation
    if (out_dataformat == TypeDesc::UINT16)
        out_dataformat = TypeDesc::INT16;

    if (out_dataformat == TypeDesc::INT16) {
        configspec.tile_width = 64;
        configspec.tile_height = 32;
    }

    // Float: 32x32
    // In prman's txmake (last tested in 15.0)
    // specifying -half or -float make 32x32 tile size
    if (out_dataformat == TypeDesc::DOUBLE)
        out_dataformat = TypeDesc::FLOAT;
    if (out_dataformat == TypeDesc::HALF || out_dataformat == TypeDesc::FLOAT) {
        configspec.tile_width = 32;
        configspec.tile_height = 32;
    }

    return out_dataformat;
}



static TypeDesc
set_oiio_options(TypeDesc out_dataformat, ImageSpec &configspec)
{
    // Interleaved channels are faster to read
    configspec.attribute (""planarconfig"", ""contig"");
    
    // Force fixed tile-size across the board
    configspec.tile_width = 64;
    configspec.tile_height = 64;
    
    return out_dataformat;
}



static std::string
datestring (time_t t)
{
    struct tm mytm;
    Sysutil::get_local_time (&t, &mytm);
    return Strutil::format (""%4d:%02d:%02d %02d:%02d:%02d"",
                            mytm.tm_year+1900, mytm.tm_mon+1, mytm.tm_mday,
                            mytm.tm_hour, mytm.tm_min, mytm.tm_sec);
}



template<class SRCTYPE>
static void
interppixel_NDC_clamped (const ImageBuf &buf, float x, float y, float *pixel,
                         bool envlatlmode)
{
    int fx = buf.spec().full_x;
    int fy = buf.spec().full_y;
    int fw = buf.spec().full_width;
    int fh = buf.spec().full_height;
    x = static_cast<float>(fx) + x * static_cast<float>(fw);
    y = static_cast<float>(fy) + y * static_cast<float>(fh);

    int n = buf.spec().nchannels;
    float *p0 = ALLOCA(float, 4*n), *p1 = p0+n, *p2 = p1+n, *p3 = p2+n;

    x -= 0.5f;
    y -= 0.5f;
    int xtexel, ytexel;
    float xfrac, yfrac;
    xfrac = floorfrac (x, &xtexel);
    yfrac = floorfrac (y, &ytexel);

    // Get the four texels
    ImageBuf::ConstIterator<SRCTYPE> it (buf, ROI(xtexel, xtexel+2, ytexel, ytexel+2), ImageBuf::WrapClamp);
    for (int c = 0; c < n; ++c) p0[c] = it[c];
    ++it;
    for (int c = 0; c < n; ++c) p1[c] = it[c];
    ++it;
    for (int c = 0; c < n; ++c) p2[c] = it[c];
    ++it;
    for (int c = 0; c < n; ++c) p3[c] = it[c];

    if (envlatlmode) {
        // For latlong environment maps, in order to conserve energy, we
        // must weight the pixels by sin(t*PI) because pixels closer to
        // the pole are actually less area on the sphere. Doing this
        // wrong will tend to over-represent the high latitudes in
        // low-res MIP levels.  We fold the area weighting into our
        // linear interpolation by adjusting yfrac.
        int ynext = Imath::clamp (ytexel+1, buf.ymin(), buf.ymax());
        ytexel = Imath::clamp (ytexel, buf.ymin(), buf.ymax());
        float w0 = (1.0f - yfrac) * sinf ((float)M_PI * (ytexel+0.5f)/(float)fh);
        float w1 = yfrac * sinf ((float)M_PI * (ynext+0.5f)/(float)fh);
        yfrac = w1 / (w0 + w1);
    }

    // Bilinearly interpolate
    bilerp (p0, p1, p2, p3, xfrac, yfrac, n, pixel);
}



// Resize src into dst, relying on the linear interpolation of
// interppixel_NDC_full or interppixel_NDC_clamped, for the pixel range.
template<class SRCTYPE>
static bool
resize_block_ (ImageBuf &dst, const ImageBuf &src, ROI roi, bool envlatlmode)
{
    int x0 = roi.xbegin, x1 = roi.xend, y0 = roi.ybegin, y1 = roi.yend;
    const ImageSpec &srcspec (src.spec());
    bool src_is_crop = (srcspec.x > srcspec.full_x ||
                        srcspec.y > srcspec.full_y ||
                        srcspec.z > srcspec.full_z ||
                        srcspec.x+srcspec.width < srcspec.full_x+srcspec.full_width ||
                        srcspec.y+srcspec.height < srcspec.full_y+srcspec.full_height ||
                        srcspec.z+srcspec.depth < srcspec.full_z+srcspec.full_depth);

    const ImageSpec &dstspec (dst.spec());
    float *pel = ALLOCA (float, dstspec.nchannels);
    float xoffset = (float) dstspec.full_x;
    float yoffset = (float) dstspec.full_y;
    float xscale = 1.0f / (float)dstspec.full_width;
    float yscale = 1.0f / (float)dstspec.full_height;
    int nchannels = dst.nchannels();
    ASSERT (dst.spec().format == TypeDesc::TypeFloat);
    ImageBuf::Iterator<float> d (dst, roi);
    for (int y = y0;  y < y1;  ++y) {
        float t = (y+0.5f)*yscale + yoffset;
        for (int x = x0;  x < x1;  ++x, ++d) {
            float s = (x+0.5f)*xscale + xoffset;
            if (src_is_crop)
                src.interppixel_NDC_full (s, t, pel);
            else
                interppixel_NDC_clamped<SRCTYPE> (src, s, t, pel, envlatlmode);
            for (int c = 0; c < nchannels; ++c)
                d[c] = pel[c];
        }
    }
    return true;
}


// Helper function to compute the first bilerp pass into a scanline buffer
template<class SRCTYPE>
static void
halve_scanline(const SRCTYPE *s, const int nchannels, size_t sw, float *dst)
{
    for (size_t i = 0; i < sw; i += 2, s += nchannels) {
        for (int j = 0; j < nchannels; ++j, ++dst, ++s)
            *dst = 0.5f * (float) (*s + *(s + nchannels));
    }
}



// Bilinear resize performed as a 2-pass filter.
// Optimized to assume that the images are contiguous.
template<class SRCTYPE>
static bool
resize_block_2pass (ImageBuf &dst, const ImageBuf &src, ROI roi, bool allow_shift)
{
    // Two-pass filtering introduces a half-pixel shift for odd resolutions.
    // Revert to correct bilerp sampling unless shift is explicitly allowed.
    if (!allow_shift && (src.spec().width % 2 || src.spec().height % 2))
        return resize_block_<SRCTYPE>(dst, src, roi, false);
    
    DASSERT(roi.ybegin + roi.height() <= dst.spec().height);

    // Allocate two scanline buffers to hold the result of the first pass
    const int nchannels = dst.nchannels();
    const size_t row_elem = roi.width() * nchannels;    // # floats in scanline
    std::unique_ptr<float[]> S0 (new float [row_elem]);
    std::unique_ptr<float[]> S1 (new float [row_elem]);
    
    // We know that the buffers created for mipmapping are all contiguous,
    // so we can skip the iterators for a bilerp resize entirely along with
    // any NDC -> pixel math, and just directly traverse pixels.
    const SRCTYPE *s = (const SRCTYPE *)src.localpixels();
    SRCTYPE *d = (SRCTYPE *)dst.localpixels();
    ASSERT(s && d);                                     // Assume contig bufs
    d += roi.ybegin * dst.spec().width * nchannels;     // Top of dst ROI
    const size_t ystride = src.spec().width * nchannels;// Scanline offset
    s += 2 * roi.ybegin * ystride;                      // Top of src ROI
    
    // Run through destination rows, doing the two-pass bilerp filter
    const size_t dw = roi.width(), dh = roi.height();   // Loop invariants
    const size_t sw = dw * 2;                           // Handle odd res
    for (size_t y = 0; y < dh; ++y) {                   // For each dst ROI row
        halve_scanline<SRCTYPE>(s, nchannels, sw, &S0[0]);
        s += ystride;
        halve_scanline<SRCTYPE>(s, nchannels, sw, &S1[0]);
        s += ystride;
        const float *s0 = &S0[0], *s1 = &S1[0];
        for (size_t x = 0; x < dw; ++x) {               // For each dst ROI col
            for (int i = 0; i < nchannels; ++i, ++s0, ++s1, ++d)
                *d = (SRCTYPE) (0.5f * (*s0 + *s1));   // Average vertically
        }
    }
    
    return true;
}



static bool
resize_block (ImageBuf &dst, const ImageBuf &src, ROI roi, bool envlatlmode,
              bool allow_shift)
{
    const ImageSpec &srcspec (src.spec());
    const ImageSpec &dstspec (dst.spec());
    DASSERT (dstspec.nchannels == srcspec.nchannels);
    DASSERT (dst.localpixels());
    bool ok;
    if (src.localpixels() &&                      // Not a cached image
        !envlatlmode &&                           // not latlong wrap mode
        roi.xbegin == 0 &&                        // Region x at origin
        dstspec.width == roi.width() &&           // Full width ROI
        dstspec.width == (srcspec.width / 2) &&   // Src is 2x resize
        dstspec.format == srcspec.format &&       // Same formats
        dstspec.x == 0 && dstspec.y == 0 &&       // Not a crop or overscan
        srcspec.x == 0 && srcspec.y == 0) {
        // If all these conditions are met, we have a special case that
        // can be more highly optimized.
        OIIO_DISPATCH_TYPES (ok, ""resize_block_2pass"", resize_block_2pass,
                             srcspec.format, dst, src, roi, allow_shift);
    } else {
        ASSERT (dst.spec().format == TypeDesc::TypeFloat);
        OIIO_DISPATCH_TYPES (ok, ""resize_block"", resize_block_, srcspec.format,
                             dst, src, roi, envlatlmode);
    }
    return ok;
}



// Copy src into dst, but only for the range [x0,x1) x [y0,y1).
static void
check_nan_block (const ImageBuf &src, ROI roi, int &found_nonfinite)
{
    int x0 = roi.xbegin, x1 = roi.xend, y0 = roi.ybegin, y1 = roi.yend;
    const ImageSpec &spec (src.spec());
    float *pel = ALLOCA (float, spec.nchannels);
    for (int y = y0;  y < y1;  ++y) {
        for (int x = x0;  x < x1;  ++x) {
            src.getpixel (x, y, pel);
            for (int c = 0;  c < spec.nchannels;  ++c) {
                if (! isfinite(pel[c])) {
                    spin_lock lock (maketx_mutex);
                    if (found_nonfinite < 3)
                        std::cerr << ""maketx ERROR: Found "" << pel[c]
                                  << "" at (x="" << x << "", y="" << y << "")\\n"";
                    ++found_nonfinite;
                    break;  // skip other channels, there's no point
                }
            }
        }
    }
}



inline Imath::V3f
latlong_to_dir (float s, float t, bool y_is_up=true)
{
    float theta = 2.0f*M_PI * s;
    float phi = t * M_PI;
    float sinphi, cosphi;
    sincos (phi, &sinphi, &cosphi);
    if (y_is_up)
        return Imath::V3f (sinphi*sinf(theta), cosphi, -sinphi*cosf(theta));
    else
        return Imath::V3f (-sinphi*cosf(theta), -sinphi*sinf(theta), cosphi);
}



static bool
lightprobe_to_envlatl (ImageBuf &dst, const ImageBuf &src, bool y_is_up,
                       ROI roi=ROI::All(), int nthreads=0)
{
    ASSERT (dst.initialized() && src.nchannels() == dst.nchannels());
    if (! roi.defined())
        roi = get_roi (dst.spec());
    roi.chend = std::min (roi.chend, dst.nchannels());

    ImageBufAlgo::parallel_image (roi, nthreads, [&](ROI roi){
        const ImageSpec &dstspec (dst.spec());
        int nchannels = dstspec.nchannels;
        ASSERT (dstspec.format == TypeDesc::FLOAT);

        float *pixel = ALLOCA (float, nchannels);
        float dw = dstspec.width, dh = dstspec.height;
        for (ImageBuf::Iterator<float> d (dst, roi);  ! d.done();  ++d) {
            Imath::V3f V = latlong_to_dir ((d.x()+0.5f)/dw, (dh-1.0f-d.y()+0.5f)/dh, y_is_up);
            float r = M_1_PI*acosf(V[2]) / hypotf(V[0],V[1]);
            float u = (V[0]*r + 1.0f) * 0.5f;
            float v = (V[1]*r + 1.0f) * 0.5f;
            interppixel_NDC_clamped<float> (src, float(u), float(v), pixel, false);
            for (int c = roi.chbegin;  c < roi.chend;  ++c)
                d[c] = pixel[c];
        }
    });

    return true;
}



static void
fix_latl_edges (ImageBuf &buf)
{
    int n = buf.nchannels();
    float *left = ALLOCA (float, n);
    float *right = ALLOCA (float, n);

    // Make the whole first and last row be solid, since they are exactly
    // on the pole
    float wscale = 1.0f / (buf.spec().width);
    for (int j = 0;  j <= 1;  ++j) {
        int y = (j==0) ? buf.ybegin() : buf.yend()-1;
        // use left for the sum, right for each new pixel
        for (int c = 0;  c < n;  ++c)
            left[c] = 0.0f;
        for (int x = buf.xbegin();  x < buf.xend();  ++x) {
            buf.getpixel (x, y, right);
            for (int c = 0;  c < n;  ++c)
                left[c] += right[c];
        }
        for (int c = 0;  c < n;  ++c)
            left[c] *= wscale;
        for (int x = buf.xbegin();  x < buf.xend();  ++x)
            buf.setpixel (x, y, left);
    }

    // Make the left and right match, since they are both right on the
    // prime meridian.
    for (int y = buf.ybegin();  y < buf.yend();  ++y) {
        buf.getpixel (buf.xbegin(), y, left);
        buf.getpixel (buf.xend()-1, y, right);
        for (int c = 0;  c < n;  ++c)
            left[c] = 0.5f * left[c] + 0.5f * right[c];
        buf.setpixel (buf.xbegin(), y, left);
        buf.setpixel (buf.xend()-1, y, left);
    }
}



static std::string
formatres (const ImageSpec &spec, bool extended=false)
{
    std::string s;
    s = Strutil::format(""%dx%d"", spec.width, spec.height);
    if (extended) {
        if (spec.x || spec.y)
            s += Strutil::format(""%+d%+d"", spec.x, spec.y);
        if (spec.width != spec.full_width || spec.height != spec.full_height ||
            spec.x != spec.full_x || spec.y != spec.full_y) {
            s += "" (full/display window is "";
            s += Strutil::format(""%dx%d"", spec.full_width, spec.full_height);
            if (spec.full_x || spec.full_y)
                s += Strutil::format(""%+d%+d"", spec.full_x, spec.full_y);
            s += "")"";
        }
    }
    return s;
}



static void
maketx_merge_spec (ImageSpec &dstspec, const ImageSpec &srcspec)
{
    for (size_t i = 0, e = srcspec.extra_attribs.size(); i < e; ++i) {
        const ParamValue &p (srcspec.extra_attribs[i]);
        ustring name = p.name();
        if (Strutil::istarts_with (name.string(), ""maketx:"")) {
            // Special instruction -- don't copy it to the destination spec
        } else {
            // just an attribute that should be set upon output
            dstspec.attribute (name.string(), p.type(), p.data());
        }
    }
}



static bool
write_mipmap (ImageBufAlgo::MakeTextureMode mode,
              std::shared_ptr<ImageBuf> &img,
              const ImageSpec &outspec_template,
              std::string outputfilename, ImageOutput *out,
              TypeDesc outputdatatype, bool mipmap,
              string_view filtername, const ImageSpec &configspec,
              std::ostream &outstream,
              double &stat_writetime, double &stat_miptime,
              size_t &peak_mem)
{
    bool envlatlmode = (mode == ImageBufAlgo::MakeTxEnvLatl);
    bool orig_was_overscan =
        (img->spec().x || img->spec().y || img->spec().z ||
         img->spec().full_x || img->spec().full_y || img->spec().full_z);
    ImageSpec outspec = outspec_template;
    outspec.set_format (outputdatatype);

    if (mipmap && !out->supports (""multiimage"") && !out->supports (""mipmap"")) {
        outstream << ""maketx ERROR: \\"""" << outputfilename
                  << ""\\"" format does not support multires images\\n"";
        return false;
    }

    if (! mipmap && ! strcmp (out->format_name(), ""openexr"")) {
        // Send hint to OpenEXR driver that we won't specify a MIPmap
        outspec.attribute (""openexr:levelmode"", 0 /* ONE_LEVEL */);
    }

    if (mipmap && ! strcmp (out->format_name(), ""openexr"")) {
        outspec.attribute (""openexr:roundingmode"", 0 /* ROUND_DOWN */);
    }

    // OpenEXR always uses border sampling for environment maps
    bool src_samples_border = false;
    if (envlatlmode && !strcmp(out->format_name(), ""openexr"")) {
        src_samples_border = true;
        outspec.attribute (""oiio:updirection"", ""y"");
        outspec.attribute (""oiio:sampleborder"", 1);
    }
    if (envlatlmode && src_samples_border)
        fix_latl_edges (*img);

    bool do_highlight_compensation = configspec.get_int_attribute (""maketx:highlightcomp"", 0);
    float sharpen = configspec.get_float_attribute (""maketx:sharpen"", 0.0f);
    string_view sharpenfilt = ""gaussian"";
    bool sharpen_first = true;
    if (Strutil::istarts_with (filtername, ""post-"")) {
        sharpen_first = false;
        filtername.remove_prefix (5);
    }
    if (Strutil::istarts_with (filtername, ""unsharp-"")) {
        filtername.remove_prefix (8);
        sharpenfilt = filtername;
        filtername = ""lanczos3"";
    }

    Timer writetimer;
    if (! out->open (outputfilename.c_str(), outspec)) {
        outstream << ""maketx ERROR: Could not open \\"""" << outputfilename
                  << ""\\"" : "" << out->geterror() << ""\\n"";
        return false;
    }

    // Write out the image
    bool verbose = configspec.get_int_attribute (""maketx:verbose"") != 0;
    if (verbose) {
        outstream << ""  Writing file: "" << outputfilename << std::endl;
        outstream << ""  Filter \\"""" << filtername << ""\\""\\n"";
        outstream << ""  Top level is "" << formatres(outspec) << std::endl;
    }

    if (! img->write (out)) {
        // ImageBuf::write transfers any errors from the ImageOutput to
        // the ImageBuf.
        outstream << ""maketx ERROR: Write failed \\"" : "" << img->geterror() << ""\\n"";
        out->close ();
        return false;
    }

    stat_writetime += writetimer();

    if (mipmap) {  // Mipmap levels:
        if (verbose)
            outstream << ""  Mipmapping...\\n"" << std::flush;
        std::vector<std::string> mipimages;
        std::string mipimages_unsplit = configspec.get_string_attribute (""maketx:mipimages"");
        if (mipimages_unsplit.length())
            Strutil::split (mipimages_unsplit, mipimages, "";"");
        bool allow_shift = configspec.get_int_attribute(""maketx:allow_pixel_shift"") != 0;
        
        std::shared_ptr<ImageBuf> small (new ImageBuf);
        while (outspec.width > 1 || outspec.height > 1) {
            Timer miptimer;
            ImageSpec smallspec;

            if (mipimages.size()) {
                // Special case -- the user specified a custom MIP level
                small->reset (mipimages[0]);
                small->read (0, 0, true, TypeDesc::FLOAT);
                smallspec = small->spec();
                if (smallspec.nchannels != outspec.nchannels) {
                    outstream << ""WARNING: Custom mip level \\"""" << mipimages[0]
                              << "" had the wrong number of channels.\\n"";
                    std::shared_ptr<ImageBuf> t (new ImageBuf (smallspec));
                    ImageBufAlgo::channels(*t, *small, outspec.nchannels,
                                           NULL, NULL, NULL, true);
                    std::swap (t, small);
                }
                smallspec.tile_width = outspec.tile_width;
                smallspec.tile_height = outspec.tile_height;
                smallspec.tile_depth = outspec.tile_depth;
                mipimages.erase (mipimages.begin());
            } else {
                // Resize a factor of two smaller
                smallspec = outspec;
                smallspec.width = img->spec().width;
                smallspec.height = img->spec().height;
                smallspec.depth = img->spec().depth;
                if (smallspec.width > 1)
                    smallspec.width /= 2;
                if (smallspec.height > 1)
                    smallspec.height /= 2;
                smallspec.full_width = smallspec.width;
                smallspec.full_height = smallspec.height;
                smallspec.full_depth = smallspec.depth;
                if (!allow_shift ||
                    configspec.get_int_attribute(""maketx:forcefloat"", 1))
                    smallspec.set_format (TypeDesc::FLOAT);

                // Trick: to get the resize working properly, we reset
                // both display and pixel windows to match, and have 0
                // offset, AND doctor the big image to have its display
                // and pixel windows match.  Don't worry, the texture
                // engine doesn't care what the upper MIP levels have
                // for the window sizes, it uses level 0 to determine
                // the relatinship between texture 0-1 space (display
                // window) and the pixels.
                smallspec.x = 0;
                smallspec.y = 0;
                smallspec.full_x = 0;
                smallspec.full_y = 0;
                small->reset (smallspec);  // Realocate with new size
                img->set_full (img->xbegin(), img->xend(), img->ybegin(),
                               img->yend(), img->zbegin(), img->zend());

                if (filtername == ""box"" && !orig_was_overscan && sharpen <= 0.0f) {
                    ImageBufAlgo::parallel_image (get_roi(small->spec()),
                                                  std::bind(resize_block, std::ref(*small), std::cref(*img), _1, envlatlmode, allow_shift));
                } else {
                    Filter2D *filter = setup_filter (small->spec(), img->spec(), filtername);
                    if (! filter) {
                        outstream << ""maketx ERROR: could not make filter \\"""" << filtername << ""\\""\\n"";
                        return false;
                    }
                    if (verbose) {
                        outstream << ""  Downsampling filter \\"""" << filter->name() 
                                  << ""\\"" width = "" << filter->width();
                        if (sharpen > 0.0f) {
                            outstream << "", sharpening "" << sharpen << "" with ""
                                      << sharpenfilt << "" unsharp mask ""
                                      << (sharpen_first ? ""before"" : ""after"")
                                      << "" the resize"";
                        }
                        outstream << ""\\n"";
                    }
                    if (do_highlight_compensation)
                        ImageBufAlgo::rangecompress (*img, *img);
                    if (sharpen > 0.0f && sharpen_first) {
                        std::shared_ptr<ImageBuf> sharp (new ImageBuf);
                        bool uok = ImageBufAlgo::unsharp_mask (*sharp, *img,
                                                    sharpenfilt, 3.0, sharpen, 0.0f);
                        if (! uok)
                            outstream << ""maketx ERROR: "" << sharp->geterror() << ""\\n"";
                        std::swap (img, sharp);
                    }
                    ImageBufAlgo::resize (*small, *img, filter);
                    if (sharpen > 0.0f && ! sharpen_first) {
                        std::shared_ptr<ImageBuf> sharp (new ImageBuf);
                        bool uok = ImageBufAlgo::unsharp_mask (*sharp, *small,
                                                    sharpenfilt, 3.0, sharpen, 0.0f);
                        if (! uok)
                            outstream << ""maketx ERROR: "" << sharp->geterror() << ""\\n"";
                        std::swap (small, sharp);
                    }
                    if (do_highlight_compensation) {
                        ImageBufAlgo::rangeexpand (*small, *small);
                        ImageBufAlgo::clamp (*small, *small, 0.0f,
                                    std::numeric_limits<float>::max(), true);
                    }
                    Filter2D::destroy (filter);
                }
            }

            stat_miptime += miptimer();
            outspec = smallspec;
            outspec.set_format (outputdatatype);
            if (envlatlmode && src_samples_border)
                fix_latl_edges (*small);

            Timer writetimer;
            // If the format explicitly supports MIP-maps, use that,
            // otherwise try to simulate MIP-mapping with multi-image.
            ImageOutput::OpenMode mode = out->supports (""mipmap"") ?
                ImageOutput::AppendMIPLevel : ImageOutput::AppendSubimage;
            if (! out->open (outputfilename.c_str(), outspec, mode)) {
                outstream << ""maketx ERROR: Could not append \\"""" << outputfilename
                          << ""\\"" : "" << out->geterror() << ""\\n"";
                return false;
            }
            if (! small->write (out)) {
                // ImageBuf::write transfers any errors from the
                // ImageOutput to the ImageBuf.
                outstream << ""maketx ERROR writing \\"""" << outputfilename
                          << ""\\"" : "" << small->geterror() << ""\\n"";
                out->close ();
                return false;
            }
            stat_writetime += writetimer();
            if (verbose) {
                size_t mem = Sysutil::memory_used(true);
                peak_mem = std::max (peak_mem, mem);
                outstream << Strutil::format (""    %-15s (%s)"", 
                                              formatres(smallspec),
                                              Strutil::memformat(mem))
                          << std::endl;
            }
            std::swap (img, small);
        }
    }

    if (verbose)
        outstream << ""  Wrote file: "" << outputfilename << ""  (""
                  << Strutil::memformat(Sysutil::memory_used(true)) << "")\\n"";
    writetimer.reset ();
    writetimer.start ();
    if (! out->close ()) {
        outstream << ""maketx ERROR writing \\"""" << outputfilename
                  << ""\\"" : "" << out->geterror() << ""\\n"";
        return false;
    }
    stat_writetime += writetimer ();
    return true;
}



static bool
make_texture_impl (ImageBufAlgo::MakeTextureMode mode,
                   const ImageBuf *input,
                   std::string filename,
                   std::string outputfilename,
                   const ImageSpec &_configspec,
                   std::ostream *outstream_ptr)
{
    ASSERT (mode >= 0 && mode < ImageBufAlgo::_MakeTxLast);
    double stat_readtime = 0;
    double stat_writetime = 0;
    double stat_resizetime = 0;
    double stat_miptime = 0;
    double stat_colorconverttime = 0;
    size_t peak_mem = 0;
    Timer alltime;

#define STATUS(task,timer)                                              \\
    {                                                                   \\
        size_t mem = Sysutil::memory_used(true);                        \\
        peak_mem = std::max (peak_mem, mem);                            \\
        if (verbose)                                                    \\
            outstream << Strutil::format (""  %-25s %s   (%s)\\n"", task,  \\
                                  Strutil::timeintervalformat(timer,2), \\
                                  Strutil::memformat(mem));             \\
    }

    ImageSpec configspec = _configspec;
    std::stringstream localstream; // catch output when user doesn't want it
    std::ostream &outstream (outstream_ptr ? *outstream_ptr : localstream);

    bool from_filename = (input == NULL);

    if (from_filename && ! Filesystem::exists (filename)) {
        outstream << ""maketx ERROR: \\"""" << filename << ""\\"" does not exist\\n"";
        return false;
    }

    std::shared_ptr<ImageBuf> src;
    if (input == NULL) {
        // No buffer supplied -- create one to read the file
        src.reset (new ImageBuf(filename));
        src->init_spec (filename, 0, 0); // force it to get the spec, not read
    } else if (input->cachedpixels()) {
        // Image buffer supplied that's backed by ImageCache -- create a
        // copy (very light weight, just another cache reference)
        src.reset (new ImageBuf(*input));
    } else {
        // Image buffer supplied that has pixels -- wrap it
        src.reset (new ImageBuf(input->name(), input->spec(),
                                (void *)input->localpixels()));
    }
    ASSERT (src.get());

    if (! outputfilename.length()) {
        std::string fn = src->name();
        if (fn.length()) {
            if (Filesystem::extension(fn).length() > 1)
                outputfilename = Filesystem::replace_extension (fn, "".tx"");
            else
                outputfilename = outputfilename + "".tx"";
        } else {
            outstream << ""maketx: no output filename supplied\\n"";
            return false;
        }
    }

    // Write the texture to a temp file first, then rename it to the final
    // destination (same directory). This improves robustness. There is less
    // chance a crash during texture conversion will leave behind a
    // partially formed tx with incomplete mipmaps levels which happesn to
    // be extremely slow to use in a raytracer.
    // We also force a unique filename to protect against multiple maketx
    // processes running at the same time on the same file.
    std::string extension = Filesystem::extension(outputfilename);
    std::string tmpfilename = Filesystem::replace_extension (outputfilename, "".%%%%%%%%.temp""+extension);
    tmpfilename = Filesystem::unique_path(tmpfilename);

    // When was the input file last modified?
    // This is only used when we're reading from a filename
    std::time_t in_time;
    if (from_filename)
        in_time = Filesystem::last_write_time (src->name());
    else
        time (&in_time);  // make it look initialized

    // When in update mode, skip making the texture if the output already
    // exists and has the same file modification time as the input file and
    // was created with identical command line arguments.
    bool updatemode = configspec.get_int_attribute (""maketx:updatemode"");
    if (updatemode && from_filename && Filesystem::exists(outputfilename) &&
        in_time == Filesystem::last_write_time (outputfilename)) {
        std::string lastcmdline;
        if (ImageInput *in = ImageInput::open (outputfilename)) {
            lastcmdline = in->spec().get_string_attribute (""Software"");
            ImageInput::destroy (in);
        }
        std::string newcmdline = configspec.get_string_attribute(""maketx:full_command_line"");
        if (lastcmdline.size() && lastcmdline == newcmdline) {
            outstream << ""maketx: no update required for \\"""" 
                      << outputfilename << ""\\""\\n"";
            return true;
        }
    }

    bool shadowmode = (mode == ImageBufAlgo::MakeTxShadow);
    bool envlatlmode = (mode == ImageBufAlgo::MakeTxEnvLatl || 
                        mode == ImageBufAlgo::MakeTxEnvLatlFromLightProbe);

    // Find an ImageIO plugin that can open the output file, and open it
    std::string outformat = configspec.get_string_attribute (""maketx:fileformatname"",
                                                             outputfilename);
    ImageOutput *out = ImageOutput::create (outformat.c_str());
    if (! out) {
        outstream 
            << ""maketx ERROR: Could not find an ImageIO plugin to write "" 
            << outformat << "" files:"" << geterror() << ""\\n"";
        return false;
    }
    if (! out->supports (""tiles"")) {
        outstream << ""maketx ERROR: \\"""" << outputfilename
                  << ""\\"" format does not support tiled images\\n"";
        return false;
    }

    // The cache might mess with the apparent data format, so make sure
    // it's the nativespec that we consult for data format of the file.
    TypeDesc out_dataformat = src->nativespec().format;

    if (configspec.format != TypeDesc::UNKNOWN)
        out_dataformat = configspec.format;
    
    // We cannot compute the prman / oiio options until after out_dataformat
    // has been determined, as it's required (and can potentially change 
    // out_dataformat too!)
    if (configspec.get_int_attribute(""maketx:prman_options""))
        out_dataformat = set_prman_options (out_dataformat, configspec);
    else if (configspec.get_int_attribute(""maketx:oiio_options""))
        out_dataformat = set_oiio_options (out_dataformat, configspec);

    // Read the full file locally if it's less than 1 GB, otherwise
    // allow the ImageBuf to use ImageCache to manage memory.
    int local_mb_thresh = configspec.get_int_attribute(""maketx:read_local_MB"",
                                                    1024);
    bool read_local = (src->spec().image_bytes() < imagesize_t(local_mb_thresh * 1024*1024));

    bool verbose = configspec.get_int_attribute (""maketx:verbose"") != 0;
    double misc_time_1 = alltime.lap();
    STATUS (""prep"", misc_time_1);
    if (from_filename) {
        if (verbose)
            outstream << ""Reading file: "" << src->name() << std::endl;
        if (! src->read (0, 0, read_local)) {
            outstream  << ""maketx ERROR: Could not read \\"""" 
                       << src->name() << ""\\"" : "" << src->geterror() << ""\\n"";
            return false;
        }
    }
    stat_readtime += alltime.lap();
    STATUS (Strutil::format(""read \\""%s\\"""", src->name()), stat_readtime);
    
    if (mode == ImageBufAlgo::MakeTxEnvLatlFromLightProbe) {
        ImageSpec newspec = src->spec();
        newspec.width = newspec.full_width = src->spec().width;
        newspec.height = newspec.full_height = src->spec().height/2;
        newspec.tile_width = newspec.tile_height = 0;
        newspec.format = TypeDesc::FLOAT;
        std::shared_ptr<ImageBuf> latlong (new ImageBuf(newspec));
        // Now lightprobe holds the original lightprobe, src is a blank
        // image that will be the unwrapped latlong version of it.
        lightprobe_to_envlatl (*latlong, *src, true);
        // Carry on with the lat-long environment map from here on out
        mode = ImageBufAlgo::MakeTxEnvLatl;
        src = latlong;
    }

    // Some things require knowing a bunch about the pixel statistics.
    bool constant_color_detect = configspec.get_int_attribute(""maketx:constant_color_detect"");
    bool opaque_detect = configspec.get_int_attribute(""maketx:opaque_detect"");
    bool compute_average_color = configspec.get_int_attribute(""maketx:compute_average"", 1);
    ImageBufAlgo::PixelStats pixel_stats;
    bool compute_stats = (constant_color_detect || opaque_detect || compute_average_color);
    if (compute_stats)
        ImageBufAlgo::computePixelStats (pixel_stats, *src);

    // If requested - and we're a constant color - make a tiny texture instead
    // Only safe if the full/display window is the same as the data window.
    // Also note that this could affect the appearance when using ""black""
    // wrap mode at runtime.
    std::vector<float> constantColor(src->nchannels());
    bool isConstantColor = false;
    if (compute_stats &&
        src->spec().x == 0 && src->spec().y == 0 && src->spec().z == 0 &&
        src->spec().full_x == 0 && src->spec().full_y == 0 &&
        src->spec().full_z == 0 && src->spec().full_width == src->spec().width &&
        src->spec().full_height == src->spec().height &&
        src->spec().full_depth == src->spec().depth) {
        isConstantColor = (pixel_stats.min == pixel_stats.max);
        if (isConstantColor)
            constantColor = pixel_stats.min;
        if (isConstantColor && constant_color_detect) {
            // Reset the image, to a new image, at the tile size
            ImageSpec newspec = src->spec();
            newspec.width  = std::min (configspec.tile_width, src->spec().width);
            newspec.height = std::min (configspec.tile_height, src->spec().height);
            newspec.depth  = std::min (configspec.tile_depth, src->spec().depth);
            newspec.full_width  = newspec.width;
            newspec.full_height = newspec.height;
            newspec.full_depth  = newspec.depth;
            std::string name = std::string(src->name()) + "".constant_color"";
            src->reset(name, newspec);
            ImageBufAlgo::fill (*src, &constantColor[0]);
            if (verbose) {
                outstream << ""  Constant color image detected. "";
                outstream << ""Creating "" << newspec.width << ""x"" << newspec.height << "" texture instead.\\n"";
            }
        }
    }
    
    int nchannels = configspec.get_int_attribute (""maketx:nchannels"", -1);

    // If requested -- and alpha is 1.0 everywhere -- drop it.
    if (opaque_detect &&
          src->spec().alpha_channel == src->nchannels()-1 &&
          nchannels <= 0 &&
          pixel_stats.min[src->spec().alpha_channel] == 1.0f &&
          pixel_stats.max[src->spec().alpha_channel] == 1.0f) {
        if (verbose)
            outstream << ""  Alpha==1 image detected. Dropping the alpha channel.\\n"";
        std::shared_ptr<ImageBuf> newsrc (new ImageBuf(src->spec()));
        ImageBufAlgo::channels (*newsrc, *src, src->nchannels()-1,
                                NULL, NULL, NULL, true);
        std::swap (src, newsrc);   // N.B. the old src will delete
    }

    // If requested - and we're a monochrome image - drop the extra channels
    if (configspec.get_int_attribute(""maketx:monochrome_detect"") &&
          nchannels <= 0 &&
          src->nchannels() == 3 && src->spec().alpha_channel < 0 &&  // RGB only
          ImageBufAlgo::isMonochrome(*src)) {
        if (verbose)
            outstream << ""  Monochrome image detected. Converting to single channel texture.\\n"";
        std::shared_ptr<ImageBuf> newsrc (new ImageBuf(src->spec()));
        ImageBufAlgo::channels (*newsrc, *src, 1, NULL, NULL, NULL, true);
        std::swap (src, newsrc);
    }

    // If we've otherwise explicitly requested to write out a
    // specific number of channels, do it.
    if ((nchannels > 0) && (nchannels != src->nchannels())) {
        if (verbose)
            outstream << ""  Overriding number of channels to "" << nchannels << ""\\n"";
        std::shared_ptr<ImageBuf> newsrc (new ImageBuf(src->spec()));
        ImageBufAlgo::channels (*newsrc, *src, nchannels, NULL, NULL, NULL, true);
        std::swap (src, newsrc);
    }

    std::string channelnames = configspec.get_string_attribute (""maketx:channelnames"");
    if (channelnames.size()) {
        std::vector<std::string> newchannelnames;
        Strutil::split (channelnames, newchannelnames, "","");
        ImageSpec &spec (src->specmod());  // writeable version
        for (int c = 0; c < spec.nchannels; ++c) {
            if (c < (int)newchannelnames.size() &&
                newchannelnames[c].size()) {
                std::string name = newchannelnames[c];
                spec.channelnames[c] = name;
                if (Strutil::iequals(name,""A"") ||
                    Strutil::iends_with(name,"".A"") ||
                    Strutil::iequals(name,""Alpha"") ||
                    Strutil::iends_with(name,"".Alpha""))
                    spec.alpha_channel = c;
                if (Strutil::iequals(name,""Z"") ||
                    Strutil::iends_with(name,"".Z"") ||
                    Strutil::iequals(name,""Depth"") ||
                    Strutil::iends_with(name,"".Depth""))
                    spec.z_channel = c;
            }
        }
    }

    if (shadowmode) {
        // Some special checks for shadow maps
        if (src->spec().nchannels != 1) {
            outstream << ""maketx ERROR: shadow maps require 1-channel images,\\n""
                      << ""\\t\\"""" << src->name() << ""\\"" is "" 
                      << src->spec().nchannels << "" channels\\n"";
            return false;
        }
        // Shadow maps only make sense for floating-point data.
        if (out_dataformat != TypeDesc::FLOAT &&
              out_dataformat != TypeDesc::HALF &&
              out_dataformat != TypeDesc::DOUBLE)
            out_dataformat = TypeDesc::FLOAT;
    }

    if (configspec.get_int_attribute(""maketx:set_full_to_pixels"")) {
        // User requested that we treat the image as uncropped or not
        // overscan
        ImageSpec &spec (src->specmod());
        spec.full_x = spec.x = 0;
        spec.full_y = spec.y = 0;
        spec.full_z = spec.z = 0;
        spec.full_width = spec.width;
        spec.full_height = spec.height;
        spec.full_depth = spec.depth;
    }

    // Copy the input spec
    ImageSpec srcspec = src->spec();
    ImageSpec dstspec = srcspec;

    bool do_resize = false;
    // If the pixel window is not a superset of the display window, pad it
    // with black.
    ROI roi = get_roi(dstspec);
    ROI roi_full = get_roi_full(dstspec);
    roi.xbegin = std::min (roi.xbegin, roi_full.xbegin);
    roi.ybegin = std::min (roi.ybegin, roi_full.ybegin);
    roi.zbegin = std::min (roi.zbegin, roi_full.zbegin);
    roi.xend = std::max (roi.xend, roi_full.xend);
    roi.yend = std::max (roi.yend, roi_full.yend);
    roi.zend = std::max (roi.zend, roi_full.zend);
    if (roi != get_roi(srcspec)) {
        do_resize = true;   // do the resize if we were a cropped image
        set_roi (dstspec, roi);
    }

    bool orig_was_overscan = (roi != roi_full);
    if (orig_was_overscan) {
        configspec.attribute (""wrapmodes"", ""black,black"");
    }

    if ((dstspec.x < 0 || dstspec.y < 0 || dstspec.z < 0) &&
        (out && !out->supports(""negativeorigin""))) {
        // User passed negative origin but the output format doesn't
        // support it.  Try to salvage the situation by shifting the
        // image into the positive range.
        if (dstspec.x < 0) {
            dstspec.full_x -= dstspec.x;
            dstspec.x = 0;
        }
        if (dstspec.y < 0) {
            dstspec.full_y -= dstspec.y;
            dstspec.y = 0;
        }
        if (dstspec.z < 0) {
            dstspec.full_z -= dstspec.z;
            dstspec.z = 0;
        }
    }

    // Make the output tiled, regardless of input
    dstspec.tile_width  = configspec.tile_width  ? configspec.tile_width  : 64;
    dstspec.tile_height = configspec.tile_height ? configspec.tile_height : 64;
    dstspec.tile_depth  = configspec.tile_depth  ? configspec.tile_depth  : 1;

    // Try to force zip (still can be overriden by configspec
    dstspec.attribute (""compression"", ""zip"");
    // Always prefer contiguous channels, unless overridden by configspec
    dstspec.attribute (""planarconfig"", ""contig"");
    // Default to black wrap mode, unless overridden by configspec
    dstspec.attribute (""wrapmodes"", ""black,black"");

    if (configspec.get_int_attribute (""maketx:ignore_unassoc""))
        dstspec.erase_attribute (""oiio:UnassociatedAlpha"");

    // Put a DateTime in the out file, either now, or matching the date
    // stamp of the input file (if update mode).
    time_t date;
    if (updatemode && from_filename)
        date = in_time;  // update mode: use the time stamp of the input
    else
        time (&date);    // not update: get the time now
    dstspec.attribute (""DateTime"", datestring(date));

    std::string cmdline = configspec.get_string_attribute (""maketx:full_command_line"");
    if (! cmdline.empty()) {
        // Append command to image history
        std::string history = dstspec.get_string_attribute (""Exif:ImageHistory"");
        if (history.length() && ! Strutil::iends_with (history, ""\\n""))
            history += std::string(""\\n"");
        history += cmdline;
        dstspec.attribute (""Exif:ImageHistory"", history);
    }

    bool prman_metadata = configspec.get_int_attribute (""maketx:prman_metadata"") != 0;
    if (shadowmode) {
        dstspec.attribute (""textureformat"", ""Shadow"");
        if (prman_metadata)
            dstspec.attribute (""PixarTextureFormat"", ""Shadow"");
    } else if (envlatlmode) {
        dstspec.attribute (""textureformat"", ""LatLong Environment"");
        configspec.attribute (""wrapmodes"", ""periodic,clamp"");
        if (prman_metadata)
            dstspec.attribute (""PixarTextureFormat"", ""LatLong Environment"");
    } else {
        dstspec.attribute (""textureformat"", ""Plain Texture"");
        if (prman_metadata)
            dstspec.attribute (""PixarTextureFormat"", ""Plain Texture"");
    }
    if (prman_metadata) {
        // Suppress writing of exif directory in the TIFF file to not
        // confuse the older libtiff that PRMan uses.
        dstspec.attribute (""tiff:write_exif"", 0);
    }

    // FIXME -- should we allow tile sizes to reduce if the image is
    // smaller than the tile size?  And when we do, should we also try
    // to make it bigger in the other direction to make the total tile
    // size more constant?

    // Fix nans/infs (if requested)
    std::string fixnan = configspec.get_string_attribute(""maketx:fixnan"");
    ImageBufAlgo::NonFiniteFixMode fixmode = ImageBufAlgo::NONFINITE_NONE;
    if (fixnan.empty() || fixnan == ""none"") { }
    else if (fixnan == ""black"") { fixmode = ImageBufAlgo::NONFINITE_BLACK; }
    else if (fixnan == ""box3"") { fixmode = ImageBufAlgo::NONFINITE_BOX3; }
    else {
        outstream << ""maketx ERROR: Unknown --fixnan mode "" << "" fixnan\\n"";
        return false;
    }
    int pixelsFixed = 0;
    if (fixmode != ImageBufAlgo::NONFINITE_NONE &&
        (srcspec.format.basetype == TypeDesc::FLOAT ||
         srcspec.format.basetype == TypeDesc::HALF ||
         srcspec.format.basetype == TypeDesc::DOUBLE) &&
        ! ImageBufAlgo::fixNonFinite (*src, *src, fixmode, &pixelsFixed)) {
        outstream << ""maketx ERROR: Error fixing nans/infs.\\n"";
        return false;
    }
    if (verbose && pixelsFixed)
        outstream << ""  Warning: "" << pixelsFixed << "" nan/inf pixels fixed.\\n"";

    // If --checknan was used and it's a floating point image, check for
    // nonfinite (NaN or Inf) values and abort if they are found.
    if (configspec.get_int_attribute(""maketx:checknan"") &&
                    (srcspec.format.basetype == TypeDesc::FLOAT ||
                     srcspec.format.basetype == TypeDesc::HALF ||
                     srcspec.format.basetype == TypeDesc::DOUBLE)) {
        int found_nonfinite = 0;
        ImageBufAlgo::parallel_image (get_roi(srcspec),
                                      std::bind(check_nan_block, std::ref(*src), _1, std::ref(found_nonfinite)));
        if (found_nonfinite) {
            if (found_nonfinite > 3)
                outstream << ""maketx ERROR: ...and Nan/Inf at ""
                          << (found_nonfinite-3) << "" other pixels\\n"";
            return false;
        }
    }

    double misc_time_2 = alltime.lap();
    STATUS (""misc2"", misc_time_2);

    // Color convert the pixels, if needed, in place.  If a color
    // conversion is required we will promote the src to floating point
    // (or there wont be enough precision potentially).  Also,
    // independently color convert the constant color metadata
    std::string colorconfigname = configspec.get_string_attribute (""maketx:colorconfig"");
    std::string incolorspace = configspec.get_string_attribute (""maketx:incolorspace"");
    std::string outcolorspace = configspec.get_string_attribute (""maketx:outcolorspace"");
    if (!incolorspace.empty() && !outcolorspace.empty() && incolorspace != outcolorspace) {
        if (verbose)
            outstream << ""  Converting from colorspace "" << incolorspace 
                      << "" to colorspace "" << outcolorspace << std::endl;

        // Buffer for the color-corrected version. Start by making it just
        // another pointer to the original source.
        std::shared_ptr<ImageBuf> ccSrc (src);  // color-corrected buffer

        if (src->spec().format != TypeDesc::FLOAT) {
            // If the original src buffer isn't float, make a scratch space
            // that is float.
            ImageSpec floatSpec = src->spec();
            floatSpec.set_format (TypeDesc::FLOAT);
            ccSrc.reset (new ImageBuf (floatSpec));
        }

        ColorConfig colorconfig (colorconfigname);
        if (colorconfig.error()) {
            outstream << ""Error Creating ColorConfig\\n"";
            outstream << colorconfig.geterror() << std::endl;
            return false;
        }
        
        ColorProcessor * processor = colorconfig.createColorProcessor (
            incolorspace.c_str(), outcolorspace.c_str());
        if (!processor || colorconfig.error()) {
            outstream << ""Error Creating Color Processor."" << std::endl;
            outstream << colorconfig.geterror() << std::endl;
            return false;
        }
        
        bool unpremult = configspec.get_int_attribute (""maketx:unpremult"") != 0;
        if (unpremult && verbose)
            outstream << ""  Unpremulting image..."" << std::endl;
        
        if (!ImageBufAlgo::colorconvert (*ccSrc, *src, processor, unpremult)) {
            outstream << ""Error applying color conversion to image.\\n"";
            return false;
        }
        
        if (isConstantColor) {
            if (!ImageBufAlgo::colorconvert (&constantColor[0],
                static_cast<int>(constantColor.size()), processor, unpremult)) {
                outstream << ""Error applying color conversion to constant color.\\n"";
                return false;
            }
        }

        if (compute_average_color) {
            if (!ImageBufAlgo::colorconvert (&pixel_stats.avg[0],
                static_cast<int>(pixel_stats.avg.size()), processor, unpremult)) {
                outstream << ""Error applying color conversion to average color.\\n"";
                return false;
            }
        }

        ColorConfig::deleteColorProcessor(processor);
        processor = NULL;

        // swap the color-converted buffer and src (making src be the
        // working master that's color converted).
        std::swap (src, ccSrc);
        // N.B. at this point, ccSrc will go out of scope, freeing it if
        // it was a scratch buffer.
        stat_colorconverttime += alltime.lap();
        STATUS (""color convert"", stat_colorconverttime);
    }

    // Force float for the sake of the ImageBuf math.
    // Also force float if we do not allow for the pixel shift,
    // since resize_block_ requires floating point buffers.
    const int allow_shift = configspec.get_int_attribute(""maketx:allow_pixel_shift"");
    if (configspec.get_int_attribute(""maketx:forcefloat"", 1) || !allow_shift)
        dstspec.set_format (TypeDesc::FLOAT);

    // Handle resize to power of two, if called for
    if (configspec.get_int_attribute(""maketx:resize"")  &&  ! shadowmode) {
        dstspec.width = pow2roundup (dstspec.width);
        dstspec.height = pow2roundup (dstspec.height);
        dstspec.full_width = dstspec.width;
        dstspec.full_height = dstspec.height;
    }

    // Resize if we're up-resing for pow2
    if (dstspec.width != srcspec.width || dstspec.height != srcspec.height ||
          dstspec.full_depth != srcspec.full_depth)
        do_resize = true;
    // resize if we're converting from non-border sampling to border sampling
    // (converting TO an OpenEXR environment map).
    if (envlatlmode && 
        (Strutil::iequals(configspec.get_string_attribute(""maketx:fileformatname""),""openexr"") ||
         Strutil::iends_with(outputfilename,"".exr"")))
        do_resize = true;

    if (do_resize && orig_was_overscan &&
        out && !out->supports(""displaywindow"")) {
        outstream << ""maketx ERROR: format "" << out->format_name()
                  << "" does not support separate display windows,\\n""
                  << ""              which is necessary when combining resizing""
                  << "" and an input image with overscan."";
        return false;
    }
    std::string filtername = configspec.get_string_attribute (""maketx:filtername"", ""box"");

    double misc_time_3 = alltime.lap(); 
    STATUS (""misc3"", misc_time_3);

    std::shared_ptr<ImageBuf> toplevel;  // Ptr to top level of mipmap
    if (! do_resize && dstspec.format == src->spec().format) {
        // No resize needed, no format conversion needed -- just stick to
        // the image we've already got
        toplevel = src;
    } else  if (! do_resize) {
        // Need format conversion, but no resize -- just copy the pixels
        toplevel.reset (new ImageBuf (dstspec));
        toplevel->copy_pixels (*src);
    } else {
        // Resize
        if (verbose)
            outstream << ""  Resizing image to "" << dstspec.width 
                      << "" x "" << dstspec.height << std::endl;
        string_view resize_filter (filtername);
        if (Strutil::istarts_with (resize_filter, ""unsharp-""))
            resize_filter = ""lanczos3"";
        toplevel.reset (new ImageBuf (dstspec));
        if ((resize_filter == ""box"" || resize_filter == ""triangle"")
            && !orig_was_overscan) {
            ImageBufAlgo::parallel_image (get_roi(dstspec),
                                          std::bind(resize_block, std::ref(*toplevel), std::cref(*src), _1, envlatlmode, allow_shift != 0));
        } else {
            Filter2D *filter = setup_filter (toplevel->spec(), src->spec(), resize_filter);
            if (! filter) {
                outstream << ""maketx ERROR: could not make filter \\"""" << resize_filter << ""\\""\\n"";
                return false;
            }
            ImageBufAlgo::resize (*toplevel, *src, filter);
            Filter2D::destroy (filter);
        }
    }
    stat_resizetime += alltime.lap();
    STATUS (""resize & data convert"", stat_resizetime);

    // toplevel now holds the color converted, format converted, resized
    // master copy.  We can release src.
    src.reset ();


    // Update the toplevel ImageDescription with the sha1 pixel hash and
    // constant color
    std::string desc = dstspec.get_string_attribute (""ImageDescription"");
    bool updatedDesc = false;
    
    // Eliminate any SHA-1 or ConstantColor hints in the ImageDescription.
    if (desc.size()) {
        desc = regex_replace (desc, regex(""SHA-1=[[:xdigit:]]*[ ]*""), """");
        static const char *fp_number_pattern =
            ""([+-]?((?:(?:[[:digit:]]*\\\\.)?[[:digit:]]+(?:[eE][+-]?[[:digit:]]+)?)))"";
        const std::string constcolor_pattern =
            std::string (""ConstantColor=(\\\\[?"") + fp_number_pattern + "",?)+\\\\]?[ ]*"";
        const std::string average_pattern =
            std::string (""AverageColor=(\\\\[?"") + fp_number_pattern + "",?)+\\\\]?[ ]*"";
        desc = regex_replace (desc, regex(constcolor_pattern), """");
        desc = regex_replace (desc, regex(average_pattern), """");
        updatedDesc = true;
    }
    
    // The hash is only computed for the top mipmap level of pixel data.
    // Thus, any additional information that will affect the lower levels
    // (such as filtering information) needs to be manually added into the
    // hash.
    std::ostringstream addlHashData;
    addlHashData << filtername << "" "";
    float sharpen = configspec.get_float_attribute (""maketx:sharpen"", 0.0f);
    if (sharpen != 0.0f) {
        addlHashData << ""sharpen_A="" << sharpen << "" "";
        // NB if we change the sharpening algorithm, change the letter!
    }
    if (configspec.get_int_attribute (""maketx:highlightcomp"", 0))
        addlHashData << ""highlightcomp=1 "";

    const int sha1_blocksize = 256;
    std::string hash_digest = configspec.get_int_attribute(""maketx:hash"", 1) ?
        ImageBufAlgo::computePixelHashSHA1 (*toplevel, addlHashData.str(),
                                            ROI::All(), sha1_blocksize) : """";
    if (hash_digest.length()) {
        if (out->supports(""arbitrary_metadata"")) {
            dstspec.attribute (""oiio:SHA-1"", hash_digest);
        } else {
            if (desc.length())
                desc += "" "";
            desc += ""oiio:SHA-1="";
            desc += hash_digest;
            updatedDesc = true;
        }
        if (verbose)
            outstream << ""  SHA-1: "" << hash_digest << std::endl;
    }
    double stat_hashtime = alltime.lap();
    STATUS (""SHA-1 hash"", stat_hashtime);
  
    if (isConstantColor) {
        std::ostringstream os; // Emulate a JSON array
        for (int i = 0; i < dstspec.nchannels; ++i) {
            if (i!=0) os << "","";
            os << (i<(int)constantColor.size() ? constantColor[i] : 0.0f);
        }
        if (out->supports(""arbitrary_metadata"")) {
            dstspec.attribute (""oiio:ConstantColor"", os.str());
        } else {
            if (desc.length())
                desc += "" "";
            desc += ""oiio:ConstantColor="";
            desc += os.str();
            updatedDesc = true;
        }
        if (verbose)
            outstream << ""  ConstantColor: "" << os.str() << std::endl;
    }
    
    if (compute_average_color) {
        std::ostringstream os; // Emulate a JSON array
        for (int i = 0; i < dstspec.nchannels; ++i) {
            if (i!=0) os << "","";
            os << (i<(int)pixel_stats.avg.size() ? pixel_stats.avg[i] : 0.0f);
        }
        if (out->supports(""arbitrary_metadata"")) {
            dstspec.attribute (""oiio:AverageColor"", os.str());
        } else {
            // if arbitrary metadata is not supported, cram it into the
            // ImageDescription.
            if (desc.length())
                desc += "" "";
            desc += ""oiio:AverageColor="";
            desc += os.str();
            updatedDesc = true;
        }
        if (verbose)
            outstream << ""  AverageColor: "" << os.str() << std::endl;
    }

    if (updatedDesc) {
        dstspec.attribute (""ImageDescription"", desc);
    }

    if (configspec.get_float_attribute(""fovcot"") == 0.0f) {
        configspec.attribute(""fovcot"", float(srcspec.full_width) / 
                                       float(srcspec.full_height));
    }

    maketx_merge_spec (dstspec, configspec);

    double misc_time_4 = alltime.lap();
    STATUS (""misc4"", misc_time_4);

    // Write out, and compute, the mipmap levels for the speicifed image
    bool nomipmap = configspec.get_int_attribute (""maketx:nomipmap"") != 0;
    bool ok = write_mipmap (mode, toplevel, dstspec, tmpfilename,
                            out, out_dataformat, !shadowmode && !nomipmap,
                            filtername, configspec, outstream,
                            stat_writetime, stat_miptime, peak_mem);
    delete out;  // don't need it any more

    // If using update mode, stamp the output file with a modification time
    // matching that of the input file.
    if (ok && updatemode && from_filename)
        Filesystem::last_write_time (tmpfilename, in_time);

    // Since we wrote the texture to a temp file first, now we rename it to
    // the final destination.
    if (ok) {
        std::string err;
        ok = Filesystem::rename (tmpfilename, outputfilename, err);
        if (! ok)
            outstream << ""maketx ERROR: could not rename file: "" << err << ""\\n"";
    }
    if (! ok)
        Filesystem::remove (tmpfilename);

    if (verbose || configspec.get_int_attribute(""maketx:runstats"")
                || configspec.get_int_attribute(""maketx:stats"")) {
        double all = alltime();
        outstream << Strutil::format (""maketx run time (seconds): %5.2f\\n"", all);;

        outstream << Strutil::format (""  file read:       %5.2f\\n"", stat_readtime);
        outstream << Strutil::format (""  file write:      %5.2f\\n"", stat_writetime);
        outstream << Strutil::format (""  initial resize:  %5.2f\\n"", stat_resizetime);
        outstream << Strutil::format (""  hash:            %5.2f\\n"", stat_hashtime);
        outstream << Strutil::format (""  mip computation: %5.2f\\n"", stat_miptime);
        outstream << Strutil::format (""  color convert:   %5.2f\\n"", stat_colorconverttime);
        outstream << Strutil::format (""  unaccounted:     %5.2f  (%5.2f %5.2f %5.2f %5.2f)\\n"",
                                      all-stat_readtime-stat_writetime-stat_resizetime-stat_hashtime-stat_miptime,
                                      misc_time_1, misc_time_2, misc_time_3, misc_time_4);
        outstream << Strutil::format (""maketx peak memory used: %s\\n"",
                                      Strutil::memformat(peak_mem));
    }

#undef STATUS
    return ok;
}



bool
ImageBufAlgo::make_texture (ImageBufAlgo::MakeTextureMode mode,
                            string_view filename,
                            string_view outputfilename,
                            const ImageSpec &configspec,
                            std::ostream *outstream)
{
    return make_texture_impl (mode, NULL, filename, outputfilename,
                              configspec, outstream);
}



bool
ImageBufAlgo::make_texture (ImageBufAlgo::MakeTextureMode mode,
                            const std::vector<std::string> &filenames,
                            string_view outputfilename,
                            const ImageSpec &configspec,
                            std::ostream *outstream_ptr)
{
    return make_texture_impl (mode, NULL, filenames[0], outputfilename,
                              configspec, outstream_ptr);
}



bool
ImageBufAlgo::make_texture (ImageBufAlgo::MakeTextureMode mode,
                            const ImageBuf &input,
                            string_view outputfilename,
                            const ImageSpec &configspec,
                            std::ostream *outstream)
{
    return make_texture_impl (mode, &input, """", outputfilename,
                              configspec, outstream);
}
",16256,True,3135.3590142269627,median
"
[[springSpringBoot]]


=== Spring Boot

Spring Boot is an application framework which, according to link:$$http://projects.spring.io/spring-boot/$$[its website], _makes it easy to create stand-alone, production-grade Spring based Applications that you can ""just run"". It takes an opinionated view of the Spring platform and third-party libraries so you can get started with minimum fuss. Most Spring Boot applications need very little Spring configuration_.

For more information on Spring Boot, see link:$$http://projects.spring.io/spring-boot/$$[http://projects.spring.io/spring-boot/]

The Spring Boot - Flowable integration has been developed together with Spring committers. 

==== Compatibility

Flowable supports both Spring Boot 2.0 and 1.5 with the same starters. The base support is for Spring Boot 2.0, which means that the actuator endpoints are only supported on 2.0.
The Flowable starters are also puling spring boot starter transitively, which means that users will have to define the 1.5 version of the spring boot starters in their own build files.

[[springSpringBootGettingStarted]]
==== Getting started

Spring Boot is all about convention over configuration.
To get started, you would need to create a Spring Boot project.
The easiest way to do this would be to create a project via link:$$https://start.spring.io/$$[start.spring.io].
For example create a project with web and h2 dependencies.
Then in the created project simply add the _flowable-spring-boot-starter_ or _flowable-spring-boot-starter-rest_ dependency.
In case you don't need all the engines see the other <<springBootFlowableStarter, Flowable starters>>.
For example for Maven:


[source,xml,linenums]
----
<dependency>
    <groupId>org.flowable</groupId>
    <artifactId>flowable-spring-boot-starter</artifactId>
    <version>${flowable.version}</version>
</dependency>
----

That's all that's needed. This dependency will transitively add the correct Flowable dependencies to the classpath.
You can now run your Spring Boot application:

[source,java,,linenums]
----
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication(proxyBeanMethods = false)
public class MyApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }

}
----


You will see an output like this:

----
  .   ____          _            __ _ _
 /\\\\ / ___'_ __ _ _(_)_ __  __ _ \\ \\ \\ \\
( ( )\\___ | '_ | '_| | '_ \\/ _` | \\ \\ \\ \\
 \\\\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v2.0.0.RELEASE)

MyApplication                            : Starting MyApplication on ...
MyApplication                            : No active profile set, falling back to default profiles: default
ConfigServletWebServerApplicationContext : Refreshing org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext@4fdfa676: startup date [Wed Mar 28 12:04:00 CEST 2018]; root of context hierarchy
o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8080 (http)
o.apache.catalina.core.StandardService   : Starting service [Tomcat]
org.apache.catalina.core.StandardEngine  : Starting Servlet Engine: Apache Tomcat/8.5.28
o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
o.s.web.context.ContextLoader            : Root WebApplicationContext: initialization completed in 3085 ms
o.s.b.w.servlet.ServletRegistrationBean  : Servlet dispatcherServlet mapped to [/]
o.s.b.w.servlet.ServletRegistrationBean  : Servlet Flowable IDM Rest API mapped to [/idm-api/*]
o.s.b.w.servlet.ServletRegistrationBean  : Servlet Flowable Form Rest API mapped to [/form-api/*]
o.s.b.w.servlet.ServletRegistrationBean  : Servlet Flowable DMN Rest API mapped to [/dmn-api/*]
o.s.b.w.servlet.ServletRegistrationBean  : Servlet Flowable Content Rest API mapped to [/content-api/*]
o.s.b.w.servlet.ServletRegistrationBean  : Servlet Flowable CMMN Rest API mapped to [/cmmn-api/*]
o.s.b.w.servlet.ServletRegistrationBean  : Servlet Flowable BPMN Rest API mapped to [/process-api/*]
o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: 'characterEncodingFilter' to: [/*]
o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: 'hiddenHttpMethodFilter' to: [/*]
o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: 'httpPutFormContentFilter' to: [/*]
o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: 'requestContextFilter' to: [/*]
uration$$EnhancerBySpringCGLIB$$3d0c70ac : No deployment resources were found for autodeployment
uration$$EnhancerBySpringCGLIB$$8131eb1a : No deployment resources were found for autodeployment
o.f.e.i.c.ProcessEngineConfigurationImpl : Found 5 Engine Configurators in total:
o.f.e.i.c.ProcessEngineConfigurationImpl : class org.flowable.idm.spring.configurator.SpringIdmEngineConfigurator (priority:100000)
o.f.e.i.c.ProcessEngineConfigurationImpl : class org.flowable.dmn.spring.configurator.SpringDmnEngineConfigurator (priority:200000)
o.f.e.i.c.ProcessEngineConfigurationImpl : class org.flowable.form.spring.configurator.SpringFormEngineConfigurator (priority:300000)
o.f.e.i.c.ProcessEngineConfigurationImpl : class org.flowable.content.spring.configurator.SpringContentEngineConfigurator (priority:400000)
o.f.e.i.c.ProcessEngineConfigurationImpl : class org.flowable.cmmn.spring.configurator.SpringCmmnEngineConfigurator (priority:500000)
o.f.e.i.c.ProcessEngineConfigurationImpl : Executing beforeInit() of class org.flowable.idm.spring.configurator.SpringIdmEngineConfigurator (priority:100000)
o.f.e.i.c.ProcessEngineConfigurationImpl : Executing beforeInit() of class org.flowable.dmn.spring.configurator.SpringDmnEngineConfigurator (priority:200000)
o.f.e.i.c.ProcessEngineConfigurationImpl : Executing beforeInit() of class org.flowable.form.spring.configurator.SpringFormEngineConfigurator (priority:300000)
o.f.e.i.c.ProcessEngineConfigurationImpl : Executing beforeInit() of class org.flowable.content.spring.configurator.SpringContentEngineConfigurator (priority:400000)
o.f.e.i.c.ProcessEngineConfigurationImpl : Executing beforeInit() of class org.flowable.cmmn.spring.configurator.SpringCmmnEngineConfigurator (priority:500000)
com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Starting...
com.zaxxer.hikari.HikariDataSource       : HikariPool-1 - Start completed.
o.f.e.i.c.ProcessEngineConfigurationImpl : Executing configure() of class org.flowable.idm.spring.configurator.SpringIdmEngineConfigurator (priority:100000)
.d.AbstractSqlScriptBasedDbSchemaManager : performing create on identity with resource org/flowable/idm/db/create/flowable.h2.create.identity.sql
o.f.idm.engine.impl.IdmEngineImpl        : IdmEngine default created
o.f.e.i.c.ProcessEngineConfigurationImpl : Executing configure() of class org.flowable.dmn.spring.configurator.SpringDmnEngineConfigurator (priority:200000)
o.f.dmn.engine.impl.DmnEngineImpl        : DmnEngine default created
o.f.e.i.c.ProcessEngineConfigurationImpl : Executing configure() of class org.flowable.form.spring.configurator.SpringFormEngineConfigurator (priority:300000)
o.f.form.engine.impl.FormEngineImpl      : FormEngine default created
o.f.e.i.c.ProcessEngineConfigurationImpl : Executing configure() of class org.flowable.content.spring.configurator.SpringContentEngineConfigurator (priority:400000)
o.f.c.engine.ContentEngineConfiguration  : Content file system root : ...
o.f.c.engine.impl.ContentEngineImpl      : ContentEngine default created
o.f.e.i.c.ProcessEngineConfigurationImpl : Executing configure() of class org.flowable.cmmn.spring.configurator.SpringCmmnEngineConfigurator (priority:500000)
o.f.cmmn.engine.CmmnEngineConfiguration  : Found 1 Engine Configurators in total:
o.f.cmmn.engine.CmmnEngineConfiguration  : class org.flowable.idm.engine.configurator.IdmEngineConfigurator (priority:100000)
o.f.cmmn.engine.CmmnEngineConfiguration  : Executing beforeInit() of class org.flowable.idm.engine.configurator.IdmEngineConfigurator (priority:100000)
o.f.cmmn.engine.CmmnEngineConfiguration  : Executing configure() of class org.flowable.idm.engine.configurator.IdmEngineConfigurator (priority:100000)
o.f.idm.engine.impl.IdmEngineImpl        : IdmEngine default created
o.f.cmmn.engine.impl.CmmnEngineImpl      : CmmnEngine default created
o.f.engine.impl.ProcessEngineImpl        : ProcessEngine default created
o.f.j.s.i.a.AbstractAsyncExecutor        : Starting up the async job executor [org.flowable.spring.job.service.SpringAsyncExecutor].
o.f.j.s.i.a.AcquireAsyncJobsDueRunnable  : starting to acquire async jobs due
o.f.j.s.i.a.AcquireTimerJobsRunnable     : starting to acquire async jobs due
o.f.j.s.i.a.ResetExpiredJobsRunnable     : starting to reset expired jobs
o.f.e.impl.cmd.ValidateV5EntitiesCmd     : Total of v5 deployments found: 0
s.w.s.m.m.a.RequestMappingHandlerAdapter : Looking for @ControllerAdvice: org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext@4fdfa676: startup date [Wed Mar 28 12:04:00 CEST 2018]; root of context hierarchy
s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped ""{[/error]}"" onto public org.springframework.http.ResponseEntity<java.util.Map<java.lang.String, java.lang.Object>> org.springframework.boot.autoconfigure.web.servlet.error.BasicErrorController.error(javax.servlet.http.HttpServletRequest)
s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped ""{[/error],produces=[text/html]}"" onto public org.springframework.web.servlet.ModelAndView org.springframework.boot.autoconfigure.web.servlet.error.BasicErrorController.errorHtml(javax.servlet.http.HttpServletRequest,javax.servlet.http.HttpServletResponse)
o.s.w.s.handler.SimpleUrlHandlerMapping  : Mapped URL path [/webjars/**] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
o.s.w.s.handler.SimpleUrlHandlerMapping  : Mapped URL path [/**] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
o.s.w.s.handler.SimpleUrlHandlerMapping  : Mapped URL path [/**/favicon.ico] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
o.s.j.e.a.AnnotationMBeanExporter        : Registering beans for JMX exposure on startup
o.s.j.e.a.AnnotationMBeanExporter        : Bean with name 'dataSource' has been autodetected for JMX exposure
o.s.j.e.a.AnnotationMBeanExporter        : Located MBean 'dataSource': registering with JMX server as MBean [com.zaxxer.hikari:name=dataSource,type=HikariDataSource]
o.s.c.support.DefaultLifecycleProcessor  : Starting beans in phase -20
o.s.c.support.DefaultLifecycleProcessor  : Starting beans in phase 0
o.s.c.support.DefaultLifecycleProcessor  : Starting beans in phase 20
o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
flowable.Application                     : Started Application in 18.235 seconds (JVM running for 19.661)
----

So, by just adding the dependency to the classpath and using the _@SpringBootAplication_ annotation a lot has happened behind the scenes:

* An in-memory datasource is created automatically (because the H2 driver is on the classpath) and passed to the Flowable process engine configuration
* A Flowable ProcessEngine, CmmnEngine, DmnEngine, FormEngine, ContentEngine and IdmEngine beans have been created and exposed
* All the Flowable services are exposed as Spring beans
* The Spring Job Executor is created

Also:

* Any BPMN 2.0 process definitions in the _processes_ folder will be automatically deployed. Create a folder _processes_ and add a dummy process definition (named _one-task-process.bpmn20.xml_) to this folder. The content of this file is shown below.
* Any CMMN 1.1 case definitions in the _cases_ folder will be automatically deployed.
* Any DMN 1.1 dmn definitions in the _dmn_ folder will be automatically deployed.
* Any Form definitions in the _forms_ folder will be automatically deployed.

The XML content of the process definition is shown below. Notice that, for the moment, we are hard-coding an assignee called ""kermit"" to the user task. We'll come back to this later.

[source,xml,linenums]
----
<?xml version=""1.0"" encoding=""UTF-8""?>
<definitions
        xmlns=""http://www.omg.org/spec/BPMN/20100524/MODEL""
        xmlns:flowable=""http://flowable.org/bpmn""
        targetNamespace=""Examples"">

    <process id=""oneTaskProcess"" name=""The One Task Process"">
        <startEvent id=""theStart"" />
        <sequenceFlow id=""flow1"" sourceRef=""theStart"" targetRef=""theTask"" />
        <userTask id=""theTask"" name=""my task"" flowable:assignee=""kermit"" />
        <sequenceFlow id=""flow2"" sourceRef=""theTask"" targetRef=""theEnd"" />
        <endEvent id=""theEnd"" />
    </process>

</definitions>
----

Also, add following code lines to test if the deployment actually worked. The _CommandLineRunner_ is a special kind of Spring bean that is executed when the application boots:

[source,java,linenums]
----
@SpringBootApplication(proxyBeanMethods = false)
public class MyApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }

    @Bean
    public CommandLineRunner init(final RepositoryService repositoryService,
                                  final RuntimeService runtimeService,
                                  final TaskService taskService) {

        return new CommandLineRunner() {
            @Override
            public void run(String... strings) throws Exception {
                System.out.println(""Number of process definitions : "" 
                	+ repositoryService.createProcessDefinitionQuery().count());
                System.out.println(""Number of tasks : "" + taskService.createTaskQuery().count());
                runtimeService.startProcessInstanceByKey(""oneTaskProcess"");
                System.out.println(""Number of tasks after process start: "" 
                    + taskService.createTaskQuery().count());
            }
        };
    }
}
----

The output expected will be:

----
Number of process definitions : 1
Number of tasks : 0
Number of tasks after process start : 1
----


==== Changing the database and connection pool

As stated above, Spring Boot is about convention over configuration. By default, by having only H2 on the classpath, it created an in-memory datasource and passed that to the Flowable process engine configuration.

To change the datasource, simply add the database driver dependencies and provide the URL to the database.
For example, to switch to a MySQL database:

[source,linenums]
----
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/flowable-spring-boot?characterEncoding=UTF-8
spring.datasource.username=flowable
spring.datasource.password=flowable
----

Remove H2 from the Maven dependencies and add the MySQL driver to the classpath:

[source,xml,linenums]
----
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.45</version>
</dependency>
----

When the app is now booted up, you'll see it uses MySQL as database (and the HikariCP connection pooling framework):

----
org.flowable.engine.impl.db.DbSqlSession   : performing create on engine with resource org/flowable/db/create/flowable.mysql.create.engine.sql
org.flowable.engine.impl.db.DbSqlSession   : performing create on history with resource org/flowable/db/create/flowable.mysql.create.history.sql
org.flowable.engine.impl.db.DbSqlSession   : performing create on identity with resource org/flowable/db/create/flowable.mysql.create.identity.sql
----

When you reboot the application multiple times, you'll see the number of tasks go up (the H2 in-memory database does not survive a shutdown, MySQL does).

For more information about how to configure the datasource have a look in link:$$https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-sql.html#boot-features-configure-datasource$$[Configure a DataSource] in the Spring Boot reference guide.

==== REST support

Often, a REST API is used on top of the embedded Flowable engine (interacting with the different services in a company). Spring Boot makes this really easy. Add following dependency to the classpath:

[source,xml,linenums]
----
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>${spring.boot.version}</version>
</dependency>
----

Create a new class, a Spring service and create two methods: one to start our process and one to get a task list for a given assignee. We simply wrap Flowable calls here, but in real-life scenarios this will be more complex.

[source,java,linenums]
----
@Service
public class MyService {

    @Autowired
    private RuntimeService runtimeService;

    @Autowired
    private TaskService taskService;

    @Transactional
    public void startProcess() {
        runtimeService.startProcessInstanceByKey(""oneTaskProcess"");
    }

    @Transactional
    public List<Task> getTasks(String assignee) {
        return taskService.createTaskQuery().taskAssignee(assignee).list();
    }

}
----

We can now create a REST endpoint by annotating a class with _@RestController_. Here, we simply delegate to the service defined above.

[source,java,linenums]
----
@RestController
public class MyRestController {

    @Autowired
    private MyService myService;

    @PostMapping(value=""/process"")
    public void startProcessInstance() {
        myService.startProcess();
    }

    @RequestMapping(value=""/tasks"", method= RequestMethod.GET, produces=MediaType.APPLICATION_JSON_VALUE)
    public List<TaskRepresentation> getTasks(@RequestParam String assignee) {
        List<Task> tasks = myService.getTasks(assignee);
        List<TaskRepresentation> dtos = new ArrayList<TaskRepresentation>();
        for (Task task : tasks) {
            dtos.add(new TaskRepresentation(task.getId(), task.getName()));
        }
        return dtos;
    }

    static class TaskRepresentation {

        private String id;
        private String name;

        public TaskRepresentation(String id, String name) {
            this.id = id;
            this.name = name;
        }
        
        public String getId() {
            return id;
        }
        public void setId(String id) {
            this.id = id;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }

    }

}
----

Both the _@Service_ and the _@RestController_ will be found by the automatic component scan for a Spring Boot application.
Run the application class again. We can now interact with the REST API, for example, by using cURL:

----
curl http://localhost:8080/tasks?assignee=kermit
[]

curl -X POST  http://localhost:8080/process
curl http://localhost:8080/tasks?assignee=kermit
[{""id"":""10004"",""name"":""my task""}]
----

As can be seen, we are referring to the assignee, ""kermit"", which was hard-coded into the process definition XML earlier. We'll change this later on to allow the assignee to be set when the workflow instance is started.

==== JPA support

To add JPA support for Flowable in Spring Boot, add following dependency:

[source,xml,linenums]
----
<dependency>
    <groupId>org.flowable</groupId>
    <artifactId>flowable-spring-boot-starter</artifactId>
    <version>${flowable.version}</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
    <version>${spring-boot.version}</version>
</dependency>
----

This will add in the Spring configuration and beans for using JPA. By default, the JPA provider will be Hibernate.

Let's create a simple Entity class:

[source,java,linenums]
----
@Entity
class Person {

    @Id
    @GeneratedValue
    private Long id;

    private String username;

    private String firstName;

    private String lastName;

    private Date birthDate;

    public Person() {
    }

    public Person(String username, String firstName, String lastName, Date birthDate) {
        this.username = username;
        this.firstName = firstName;
        this.lastName = lastName;
        this.birthDate = birthDate;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public Date getBirthDate() {
        return birthDate;
    }

    public void setBirthDate(Date birthDate) {
        this.birthDate = birthDate;
    }
}
----

By default, when not using an in-memory database, the tables won't be created automatically. Create a file _application.properties_ on the classpath and add following property:

----
spring.jpa.hibernate.ddl-auto=update
----

Add following class:

[source,java,linenums]
----
@Repository
public interface PersonRepository extends JpaRepository<Person, Long> {

    Person findByUsername(String username);
}
----

This is a Spring repository, which offers CRUD out of the box. We add the method to find a Person by username. Spring will automatically implement this based on conventions (typically, the property names used).

We now enhance our service further:

* by adding _@Transactional_ to the class. Note that by adding the JPA dependency above, the DataSourceTransactionManager which we were using before is now automatically swapped out by a JpaTransactionManager. 
* The _startProcess_ now gets an assignee username passed in, which is used to look up the Person, and put the Person JPA object as a process variable in the process instance.
* A method to create Dummy users is added. This is used in the CommandLineRunner to populate the database.

[source,java,linenums]
----
@Service
@Transactional
public class MyService {

    @Autowired
    private RuntimeService runtimeService;

    @Autowired
    private TaskService taskService;

    @Autowired
    private PersonRepository personRepository;

    public void startProcess(String assignee) {

        Person person = personRepository.findByUsername(assignee);

        Map<String, Object> variables = new HashMap<String, Object>();
        variables.put(""person"", person);
        runtimeService.startProcessInstanceByKey(""oneTaskProcess"", variables);
    }

    public List<Task> getTasks(String assignee) {
        return taskService.createTaskQuery().taskAssignee(assignee).list();
    }

    public void createDemoUsers() {
        if (personRepository.findAll().size() == 0) {
            personRepository.save(new Person(""jbarrez"", ""Joram"", ""Barrez"", new Date()));
            personRepository.save(new Person(""trademakers"", ""Tijs"", ""Rademakers"", new Date()));
        }
    }

}
----

The CommandLineRunner now looks like:

[source,java,linenums]
----
@Bean
public CommandLineRunner init(final MyService myService) {

    return new CommandLineRunner() {
    	public void run(String... strings) throws Exception {
        	myService.createDemoUsers();
        }
    };
}
----

The RestController is also modified slightly to incorporate the changes above (only showing new methods) and the HTTP POST now has a body that contains the assignee username:

----
@RestController
public class MyRestController {

    @Autowired
    private MyService myService;

    @PostMapping(value=""/process"")
    public void startProcessInstance(@RequestBody StartProcessRepresentation startProcessRepresentation) {
        myService.startProcess(startProcessRepresentation.getAssignee());
    }

   ...

    static class StartProcessRepresentation {

        private String assignee;

        public String getAssignee() {
            return assignee;
        }

        public void setAssignee(String assignee) {
            this.assignee = assignee;
        }
    }
----

And finally, to try out the Spring-JPA-Flowable integration, we assign the task using the ID of the Person JPA object in the process definition:

[source,xml,linenums]
----
<userTask id=""theTask"" name=""my task"" flowable:assignee=""${person.id}""/>
----

This replaces the hard-coded recipient, ""kermit"", which we had initially set.

We can now start a new process instance, providing the user name in the POST body:

----
curl -H ""Content-Type: application/json"" -d '{""assignee"" : ""jbarrez""}' http://localhost:8080/process
----

And the task list is now fetched using the person ID:

----
curl http://localhost:8080/tasks?assignee=1

[{""id"":""12505"",""name"":""my task""}]
----

[[springBootActuatorEndpoint]]
==== Flowable Actuator Endpoints

Flowable provides a Spring Boot Actuator Endpoint that exposes information for the Processes that are running.
By default the `flowable` endpoint is mapped to `/actuator/flowable`.
Spring Boot by default only exposes the `info` and `health` endpoints. In order to enable the `flowable` endpoint you need to add `management.endpoint.flowable.enabled=true` to your `application.properties`.

In order to make enable Actuator endpoints you need to add a dependency on Actuator, e.g. by using {sc-flowable-starter}/flowable-spring-boot-starter-actuator/pom.xml[flowable-spring-boot-starter-actuator].

`curl http://localhost:8080/actuator/flowable`

[source,json]
----

{
  ""completedTaskCountToday"": 0,
  ""deployedProcessDefinitions"": [
    ""oneTaskProcess (v1)""
  ],
  ""processDefinitionCount"": 1,
  ""cachedProcessDefinitionCount"": 0,
  ""runningProcessInstanceCount"": {
    ""oneTaskProcess (v1)"": 0
  },
  ""completedTaskCount"": 2,
  ""completedActivities"": 3,
  ""completedProcessInstanceCount"": {
    ""oneTaskProcess (v1)"": 0
  },
  ""openTaskCount"": 0
}
----

For more information about Spring Boot Actuator see link:$$https://docs.spring.io/spring-boot/docs/current/reference/html/production-ready-endpoints.html$$[Production Ready Endpoint] in the Spring Boot reference documentation.

[[springBootInfoContributor]]
==== Flowable Info Contributor

Flowable also provides a Spring Boot `InfoContributor` which looks like:

`curl http://localhost:8080/actuator/info`

[source,json]
----
{
  ""flowable"": {
    ""version"": ""6.5.0.event-SNAPSHOT""
  }
}
----

[[springBootFlowableProperties]]
==== Flowable Application Properties

The Flowable auto configuration is leveraging the Spring Boot properties and configuration mechanism.
See link:$$https://docs.spring.io/spring-boot/docs/current/reference/html/howto-properties-and-configuration.html$$[Properties and Configuration] in the Spring Boot reference guide.

Here is a list of configuration properties that the Flowable Spring Boot support consumes.

[source,properties,indent=0,subs=""verbatim,attributes,macros""]
----

# ===================================================================
# Common Flowable Spring Boot Properties
#
# This sample file is provided as a guideline. Do NOT copy it in its
# entirety to your own application.	           ^^^
# ===================================================================

# Core (Process) {sc-flowable-boot}/FlowableProperties.java[FlowableProperties]
flowable.check-process-definitions=true # Whether process definitions need to be auto deployed.
flowable.custom-mybatis-mappers= # The FQN of custom Mybatis mappers that need to be added to the engine.
flowable.custom-mybatis-x-m-l-mappers= # The location of the custom Mybatis XML Mappers that need to be added to the engine.
flowable.database-schema= # In some situations you want to set the schema to use for table checks / generation if the database metadata doesn't return that correctly.
flowable.database-schema-update=true # The strategy that should be used for the database schema.
flowable.db-history-used=true # Whether db history should be used.
flowable.deployment-name=SpringBootAutoDeployment # The name of the auto deployment.
flowable.history-level=audit # The history level that needs to be used.
flowable.process-definition-location-prefix=classpath*:/processes/ # The folder in which processes need to be searched for auto deployment.
flowable.process-definition-location-suffixes=**.bpmn20.xml,**.bpmn # The suffixes (extensions) of the files that needs to be deployed from the 'processDefinitionLocationPrefix' location.

# Process {sc-flowable-boot}/process/FlowableProcessProperties.java[FlowableProcessProperties]
flowable.process.definition-cache-limit=-1 # The maximum amount of process definitions available in the process definition cache. Per default it is -1 (all process definitions).
flowable.process.enable-safe-xml=true # Enables extra checks on the BPMN xml that is parsed. See https://www.flowable.org/docs/userguide/index.html#advanced.safe.bpmn.xml. Unfortunately, this feature is not available on some platforms (JDK 6, JBoss), hence you need to disable if your platform does not allow the use of StaxSource during XML parsing.
flowable.process.servlet.load-on-startup=-1 # Load on startup of the Process dispatcher servlet.
flowable.process.servlet.name=Flowable BPMN Rest API # The name of the Process servlet.
flowable.process.servlet.path=/process-api # The context path for the Process rest servlet.

# Process Async Executor
flowable.process.async-executor-activate=true # Whether the async executor should be activated.
flowable.process.async.executor.async-job-lock-time-in-millis=300000 # The amount of time (in milliseconds) an async job is locked when acquired by the async executor. During this period of time, no other async executor will try to acquire and lock this job.
flowable.process.async.executor.default-async-job-acquire-wait-time-in-millis=10000 # The time (in milliseconds) the async job acquisition thread will wait to execute the next acquirement query. This happens when no new async jobs were found or when less async jobs have been fetched. Default value = 10 seconds.
flowable.process.async.executor.default-queue-size-full-wait-time-in-millis=0 # The time (in milliseconds) the async job (both timer and async continuations) acquisition thread will wait when the queue is full to execute the next query. By default set to 0 (for backwards compatibility)
flowable.process.async.executor.default-timer-job-acquire-wait-time-in-millis=10000 # The time (in milliseconds) the timer job acquisition thread will wait to execute the next acquirement query. This happens when no new timer jobs were found or when less async jobs have been fetched. Default value = 10 seconds.
flowable.process.async.executor.max-async-jobs-due-per-acquisition=1 # ???
flowable.process.async.executor.retry-wait-time-in-millis=500 # ???
flowable.process.async.executor.timer-lock-time-in-millis=300000 # The amount of time (in milliseconds) a timer job is locked when acquired by the async executor. During this period of time, no other async executor will try to acquire and lock this job.


# CMMN {sc-flowable-boot}/cmmn/FlowableCmmnProperties.java[FlowableCmmnProperties]
flowable.cmmn.deploy-resources=true # Whether to perform deployment of resources, default is 'true'.
flowable.cmmn.deployment-name=SpringBootAutoDeployment # The name of the deployment for the CMMN resources.
flowable.cmmn.enable-safe-xml=true # Enables extra checks on the DMN xml that is parsed. See https://www.flowable.org/docs/userguide/index.html#advanced.safe.bpmn.xml. Unfortunately, this feature is not available on some platforms (JDK 6, JBoss), hence you need to disable if your platform does not allow the use of StaxSource during XML parsing.
flowable.cmmn.enabled=true # Whether the CMMN engine needs to be started.
flowable.cmmn.resource-location=classpath*:/cases/ # The location where the CMMN resources are located.
flowable.cmmn.resource-suffixes=**.cmmn,**.cmmn11,**.cmmn.xml,**.cmmn11.xml # The suffixes for the resources that need to be scanned.
flowable.cmmn.servlet.load-on-startup=-1 # Load on startup of the CMMN dispatcher servlet.
flowable.cmmn.servlet.name=Flowable CMMN Rest API # The name of the CMMN servlet.
flowable.cmmn.servlet.path=/cmmn-api # The context path for the CMMN rest servlet.

# CMMN Async Executor
flowable.cmmn.async-executor-activate=true # Whether the async executor should be activated.
flowable.cmmn.async.executor.async-job-lock-time-in-millis=300000 # The amount of time (in milliseconds) an async job is locked when acquired by the async executor. During this period of time, no other async executor will try to acquire and lock this job.
flowable.cmmn.async.executor.default-async-job-acquire-wait-time-in-millis=10000 # The time (in milliseconds) the async job acquisition thread will wait to execute the next acquirement query. This happens when no new async jobs were found or when less async jobs have been fetched. Default value = 10 seconds.
flowable.cmmn.async.executor.default-queue-size-full-wait-time-in-millis=0 # The time (in milliseconds) the async job (both timer and async continuations) acquisition thread will wait when the queue is full to execute the next query. By default set to 0 (for backwards compatibility)
flowable.cmmn.async.executor.default-timer-job-acquire-wait-time-in-millis=10000 # The time (in milliseconds) the timer job acquisition thread will wait to execute the next acquirement query. This happens when no new timer jobs were found or when less async jobs have been fetched. Default value = 10 seconds.
flowable.cmmn.async.executor.max-async-jobs-due-per-acquisition=1 # ???
flowable.cmmn.async.executor.retry-wait-time-in-millis=500 # ???
flowable.cmmn.async.executor.timer-lock-time-in-millis=300000 # The amount of time (in milliseconds) a timer job is locked when acquired by the async executor. During this period of time, no other async executor will try to acquire and lock this job.

# Content {sc-flowable-boot}/content/FlowableContentProperties.java[FlowableContentProperties]
flowable.content.enabled=true # Whether the content engine needs to be started.
flowable.content.servlet.load-on-startup=-1 # Load on startup of the Content dispatcher servlet.
flowable.content.servlet.name=Flowable Content Rest API # The name of the Content servlet.
flowable.content.servlet.path=/content-api # The context path for the Content rest servlet.
flowable.content.storage.create-root=true # If the root folder doesn't exist, should it be created?
flowable.content.storage.root-folder= # Root folder location where content files will be stored, for example, task attachments or form file uploads.

# DMN {sc-flowable-boot}/dmn/FlowableDmnProperties.java[FlowableDmnProperties]
flowable.dmn.deploy-resources=true # Whether to perform deployment of resources, default is 'true'.
flowable.dmn.deployment-name=SpringBootAutoDeployment # The name of the deployment for the dmn resources.
flowable.dmn.enable-safe-xml=true # Enables extra checks on the DMN xml that is parsed. See https://www.flowable.org/docs/userguide/index.html#advanced.safe.bpmn.xml. Unfortunately, this feature is not available on some platforms (JDK 6, JBoss), hence you need to disable if your platform does not allow the use of StaxSource during XML parsing.
flowable.dmn.enabled=true # Whether the dmn engine needs to be started.
flowable.dmn.history-enabled=true # Whether the history for the DMN engine should be enabled.
flowable.dmn.resource-location=classpath*:/dmn/ # The location where the dmn resources are located.
flowable.dmn.resource-suffixes=**.dmn,**.dmn.xml,**.dmn11,**.dmn11.xml # The suffixes for the resources that need to be scanned.
flowable.dmn.servlet.load-on-startup=-1 # Load on startup of the DMN dispatcher servlet.
flowable.dmn.servlet.name=Flowable DMN Rest API # The name of the DMN servlet.
flowable.dmn.servlet.path=/dmn-api # The context path for the DMN rest servlet.
flowable.dmn.strict-mode=true # Set this to false if you want to ignore the decision table hit policy validity checks to result in an failed decision table state. A result is that intermediate results created up to the point the validation error occurs are returned.

# Form {sc-flowable-boot}/form/FlowableFormProperties.java[FlowableFormProperties]
flowable.form.deploy-resources=true # Whether to perform deployment of resources, default is true.
flowable.form.deployment-name=SpringBootAutoDeployment # The name of the deployment for the form resources.
flowable.form.enabled=true # Whether the form engine needs to be started.
flowable.form.resource-location=classpath*:/forms/ # The location where the form resources are located.
flowable.form.resource-suffixes=**.form # The suffixes for the resources that need to be scanned.
flowable.form.servlet.load-on-startup=-1 # Load on startup of the Form dispatcher servlet.
flowable.form.servlet.name=Flowable Form Rest API # The name of the Form servlet.
flowable.form.servlet.path=/form-api # The context path for the Form rest servlet.

# IDM {sc-flowable-boot}/idm/FlowableIdmProperties.java[FlowableIdmProperties]
flowable.idm.enabled=true # Whether the idm engine needs to be started.
flowable.idm.password-encoder= # The type of the password encoder that needs to be used.
flowable.idm.servlet.load-on-startup=-1 # Load on startup of the IDM dispatcher servlet.
flowable.idm.servlet.name=Flowable IDM Rest API # The name of the IDM servlet.
flowable.idm.servlet.path=/idm-api # The context path for the IDM rest servlet.

# IDM Ldap {sc-flowable-boot}/ldap/FlowableLdapProperties.java[FlowableLdapProperties]
flowable.idm.ldap.attribute.email= # Name of the attribute that matches the user email.
flowable.idm.ldap.attribute.first-name= # Name of the attribute that matches the user first name.
flowable.idm.ldap.attribute.group-id= # Name of the attribute that matches the group id.
flowable.idm.ldap.attribute.group-name= # Name of the attribute that matches the group name.
flowable.idm.ldap.attribute.group-type= # Name of the attribute that matches the group type.
flowable.idm.ldap.attribute.last-name= # Name of the attribute that matches the user last name.
flowable.idm.ldap.attribute.user-id= # Name of the attribute that matches the user id.
flowable.idm.ldap.base-dn= # The base 'distinguished name' (DN) from which the searches for users and groups are started.
flowable.idm.ldap.cache.group-size=-1 # Allows to set the size of the {@link org.flowable.ldap.LDAPGroupCache}. This is an LRU cache that caches groups for users and thus avoids hitting the LDAP system each time the groups of a user needs to be known.
flowable.idm.ldap.custom-connection-parameters= # Allows to set all LDAP connection parameters which do not have a dedicated setter. See for example http://docs.oracle.com/javase/tutorial/jndi/ldap/jndi.html for custom properties. Such properties are for example to configure connection pooling, specific security settings, etc.
flowable.idm.ldap.enabled=false # Whether to enable LDAP IDM Service.
flowable.idm.ldap.group-base-dn= # The base 'distinguished name' (DN) from which the searches for groups are started.
flowable.idm.ldap.initial-context-factory=com.sun.jndi.ldap.LdapCtxFactory # The class name for the initial context factory.
flowable.idm.ldap.password= # The password that is used to connect to the LDAP system.
flowable.idm.ldap.port=-1 # The port on which the LDAP system is running.
flowable.idm.ldap.query.all-groups= # The query that is executed when searching for all groups.
flowable.idm.ldap.query.all-users= # The query that is executed when searching for all users.
flowable.idm.ldap.query.groups-for-user= # The query that is executed when searching for the groups of a specific user.
flowable.idm.ldap.query.user-by-full-name-like= # The query that is executed when searching for a user by full name.
flowable.idm.ldap.query.user-by-id= # The query that is executed when searching for a user by userId.
flowable.idm.ldap.query.group-by-id= # The query that is executed when searching for a specific group by groupId.
flowable.idm.ldap.search-time-limit=0 # The timeout (in milliseconds) that is used when doing a search in LDAP. By default set to '0', which means 'wait forever'.
flowable.idm.ldap.security-authentication=simple # The value that is used for the 'java.naming.security.authentication' property used to connect to the LDAP system.
flowable.idm.ldap.server= # The server host on which the LDAP system can be reached. For example 'ldap://localhost'.
flowable.idm.ldap.user= # The user id that is used to connect to the LDAP system.
flowable.idm.ldap.user-base-dn= # The base 'distinguished name' (DN) from which the searches for users are started.

# Flowable Mail {sc-flowable-boot}/FlowableMailProperties.java[FlowableMailProperties]
flowable.mail.server.default-from=flowable@localhost # The default from address that needs to be used when sending emails.
flowable.mail.server.force-to= # The force to address(es) that would be used when sending out emails. IMPORTANT: If this is set then all emails will be send to defined address(es) instead of the address configured in the MailActivity.
flowable.mail.server.host=localhost # The host of the mail server.
flowable.mail.server.password= # The password for the mail server authentication.
flowable.mail.server.port=1025 # The port of the mail server.
flowable.mail.server.ssl-port=1465 # The SSL port of the mail server.
flowable.mail.server.use-ssl=false # Sets whether SSL/TLS encryption should be enabled for the SMTP transport upon connection (SMTPS/POPS).
flowable.mail.server.use-tls=false # Set or disable the STARTTLS encryption.
flowable.mail.server.username= # The username that needs to be used for the mail server authentication. If empty no authentication would be used.

# Flowable Http {sc-flowable-boot}/FlowableHttpProperties.java[FlowableHttpProperties]
flowable.http.user-system-properties=false # Whether to use system properties (e.g. http.proxyPort).
flowable.http.connect-timeout=5s # Connect timeout for the http client
flowable.http.socket-timeout=5s # Socket timeout for the http client
flowable.http.connection-request-timeout=5s # Connection Request Timeout for the http client
flowable.http.request-retry-limit=3 # Request retry limit for the http client
flowable.http.disable-cert-verify=false # Whether to disable certificate validation for the http client

# Flowable REST
flowable.rest.app.cors.enabled=true # Whether to enable CORS requests at all. If false, the other properties have no effect
flowable.rest.app.cors.allow-credentials=true # Whether to include credentials in a CORS request
flowable.rest.app.cors.allowed-origins=* # Comma-separated URLs to accept CORS requests from
flowable.rest.app.cors.allowed-headers=* # Comma-separated HTTP headers to allow in a CORS request
flowable.rest.app.cors.allowed-methods=DELETE,GET,PATCH,POST,PUT # Comma-separated HTTP verbs to allow in a CORS request
flowable.rest.app.cors.exposed-headers=* # Comma-separated list of headers to expose in CORS response

# Actuator
management.endpoint.flowable.cache.time-to-live=0ms # Maximum time that a response can be cached.
management.endpoint.flowable.enabled=true # Whether to enable the flowable endpoint.

----

.Deprecated properties
[cols=""4*"",options=""header""]
|===============
|Property name
|Old Property
|Default value
|Description

|flowable.process.servlet.name
|flowable.rest-api-servlet-name
|Flowable BPMN Rest API
|The name of the Process servlet.

|flowable.process.servlet.path
|flowable.rest-api-mapping
|/process-api
|The context path for the Process rest servlet.

|flowable.mail.server.host
|flowable.mail-server-host
|localhost
|The host of the mail server.

|flowable.mail.server.password
|flowable.mail-server-password
|-
|The password for the mail server authentication.

|flowable.mail.server.port
|flowable.mail-server-port
|1025
|The port of the mail server.

|flowable.mail.server.ssl-port
|flowable.mail-server-ssl-port
|1465
|The SSL port of the mail server.

|flowable.mail.server.use-ssl
|flowable.mail-server-use-ssl
|false
|Sets whether SSL/TLS encryption should be enabled for the SMTP transport upon connection (SMTPS/POPS).

|flowable.mail.server.use-tls
|flowable.mail-server-use-tls
|false
|Set or disable the STARTTLS encryption.

|flowable.mail.server.username
|flowable.mail-server-user-name
|-
|The username that needs to be used for the mail server authentication.
If empty no authentication would be used.

|flowable.process.definition-cache-limit
|flowable.process-definitions.cache.max
|-1
|The maximum amount of process definitions available in the process definition cache.
 Per default it is -1 (all process definitions)
|===============

[[springBootFlowableAutoConfiguration]]
==== Flowable Auto-configuration classes

Here is a list of all auto-configuration classes provided by Flowable, with links to documentation and source code.
Remember to also look at the conditions report in your application for more details of which features are switched on.
(To do so, start the app with --debug or -Ddebug or, in an Actuator application, use the conditions endpoint).

[cols=*,options=""header""]
|===
|Configuration Class

|{sc-flowable-boot}/content/ContentEngineAutoConfiguration.java[ContentEngineAutoConfiguration]
|{sc-flowable-boot}/content/ContentEngineServicesAutoConfiguration.java[ContentEngineServicesAutoConfiguration]
|{sc-flowable-boot}/cmmn/CmmnEngineAutoConfiguration.java[CmmnEngineAutoConfiguration]
|{sc-flowable-boot}/cmmn/CmmnEngineServicesAutoConfiguration.java[CmmnEngineServicesAutoConfiguration]
|{sc-flowable-boot}/dmn/DmnEngineAutoConfiguration.java[DmnEngineAutoConfiguration]
|{sc-flowable-boot}/dmn/DmnEngineServicesAutoConfiguration.java[DmnEngineServicesAutoConfiguration]
|{sc-flowable-boot}/EndpointAutoConfiguration.java[EndpointAutoConfiguration]
|{sc-flowable-boot}/actuate/info/FlowableInfoAutoConfiguration.java[FlowableInfoAutoConfiguration]
|{sc-flowable-boot}/ldap/FlowableLdapAutoConfiguration.java[FlowableLdapAutoConfiguration]
|{sc-flowable-boot}/FlowableTransactionAutoConfiguration.java[FlowableTransactionAutoConfiguration]
|{sc-flowable-boot}/form/FormEngineAutoConfiguration.java[FormEngineAutoConfiguration]
|{sc-flowable-boot}/form/FormEngineServicesAutoConfiguration.java[FormEngineServicesAutoConfiguration]
|{sc-flowable-boot}/idm/IdmEngineAutoConfiguration.java[IdmEngineAutoConfiguration]
|{sc-flowable-boot}/idm/IdmEngineServicesAutoConfiguration.java[IdmEngineServicesAutoConfiguration]
|{sc-flowable-boot}/ProcessEngineAutoConfiguration.java[ProcessEngineAutoConfiguration]
|{sc-flowable-boot}/RestApiAutoConfiguration.java[RestApiAutoConfiguration]
|{sc-flowable-boot}/SecurityAutoConfiguration.java[SecurityAutoConfiguration]

|===

[[springBootFlowableStarter]]
==== Flowable Starters

Here is a list of the flowable spring boot starters.

[cols=2*,options=""header""]
|===
|Starter
|Description

|{sc-flowable-starter}/flowable-spring-boot-starter-cmmn/pom.xml[flowable-spring-boot-starter-cmmn]
|Contains the dependencies for booting the CMMN Engine in Standalone mode

|{sc-flowable-starter}/flowable-spring-boot-starter-cmmn-rest/pom.xml[flowable-spring-boot-starter-cmmn-rest]
|Contains the dependencies for booting the CMMN Engine in Standalone mode and starts its REST API

|{sc-flowable-starter}/flowable-spring-boot-starter-dmn/pom.xml[flowable-spring-boot-starter-dmn]
|Contains the dependencies for booting the DMN Engine in Standalone mode

|{sc-flowable-starter}/flowable-spring-boot-starter-dmn-rest/pom.xml[flowable-spring-boot-starter-dmn-rest]
|Contains the dependencies for booting the DMN Engine in Standalone mode and starts its REST API

|{sc-flowable-starter}/flowable-spring-boot-starter-process/pom.xml[flowable-spring-boot-starter-process]
|Contains the dependencies for booting the Process Engine in Standalone mode

|{sc-flowable-starter}/flowable-spring-boot-starter-process-rest/pom.xml[flowable-spring-boot-starter-process-rest]
|Contains the dependencies for booting the Process Engine in Standalone mode and starts its REST API

|{sc-flowable-starter}/flowable-spring-boot-starter/pom.xml[flowable-spring-boot-starter]
|Contains the dependencies for booting all Flowable Engines (Process, CMMN, DMN, Form, Content and IDM)

|{sc-flowable-starter}/flowable-spring-boot-starter-rest/pom.xml[flowable-spring-boot-starter-rest]
|Contains the dependencies for booting all Flowable Engines and their respective REST API

|{sc-flowable-starter}/flowable-spring-boot-starter-actuator/pom.xml[flowable-spring-boot-starter-actuator]
|Contains the required dependencies for Spring Boot

|===

==== Using Liquibase

The Flowable engines are using Liquibase to manage the versioning of it's tables.
This means that the `LiquibaseAutoConfiguration` from Spring Boot would automatically kick in.
However, if you are not using Liquibase then the application will not start and would throw an exception.
For this reason Flowable is setting `spring.liquibase.enabled` to `false`, which means that if you need to use Liquibase you have to explicitly enable it.

==== Further Reading

Obviously, there is a lot about Spring Boot that hasn't been touched upon yet, like very easy JTA integration or building a WAR file that can be run on major application servers. And there is a lot more to the Spring Boot integration: 

* Actuator support
* Spring Integration support
* Rest API integration: boot up the Flowable Rest API embedded within the Spring application
* Spring Security support

==== Advanced Configuration

===== Customizing Engine Configuration

It's possible to get a hold of the engine configuration by implementing the _org.flowable.spring.boot.EngineConfigurationConfigurer<T>_ interface.
Where _T_ is the Spring Type of the particular Engine Configuration.
This can be useful for advanced configuration settings or simply because a property has not been exposed (yet).
For example:

[source, java, linenums]
----
public class MyConfigurer implements EngineConfigurationConfigurer<SpringProcessEngineConfiguration> {

    public void configure(SpringProcessEngineConfiguration processEngineConfiguration) {
        // advanced configuration
    }
    
}
----

By exposing an instance of this class as an _@Bean_ in the Spring Boot configuration, the instance will be called before the process engine is fully created.

[TIP]
====
You can provide a custom implementation of a Flowable Service by using this. See {sc-flowable-boot}/ldap/FlowableLdapAutoConfiguration.java[FlowableLdapAutoConfiguration]
====

===== Combining starters

In case you need only a combination of the engines then you can add only the required dependencies.
For example to use the Process, CMMN, Form and IDM engine and use LDAP you need to add the following dependencies:

[source,xml,linenums]
----
<dependency>
    <groupId>org.flowable</groupId>
    <artifactId>flowable-spring-boot-starter-process</artifactId>
    <version>${flowable.version}</version>
</dependency>
<dependency>
    <groupId>org.flowable</groupId>
    <artifactId>flowable-spring-boot-starter-cmmn</artifactId>
    <version>${flowable.version}</version>
</dependency>
<dependency>
    <groupId>org.flowable</groupId>
    <artifactId>flowable-content-spring-configurator</artifactId>
    <version>${flowable.version}</version>
</dependency>
<dependency>
    <groupId>org.flowable</groupId>
    <artifactId>flowable-form-spring-configurator</artifactId>
    <version>${flowable.version}</version>
</dependency>
<dependency>
    <groupId>org.flowable</groupId>
    <artifactId>flowable-ldap</artifactId>
    <version>${flowable.version}</version>
</dependency>
----

===== Configuring Async Executors

The Process and CMMN engines have dedicated `AsyncExecutor`(s) and they can be configured with the `flowable.{engine}.async.executor` property group.
Where `engine` is either `process` or `cmmn`.

The `AsyncExecutor`(s) per default share the same Spring `TaskExecutor` and `SpringRejectedJobsHandler`.
In case you want to provide a dedicated executor for each of the engines you need define a qualified bean with `@Process` and `@Cmmn`.

You can configure custom executors in the following way:

[source,java,linenums]
----
@Configuration
public class MyConfiguration {

    @Process <1>
    @Bean
    public TaskExecutor processTaskExecutor() {
        return new SimpleAsyncTaskExecutor();
    }

    @Cmmn <2>
    @Bean
    public TaskExecutor cmmnTaskExecutor() {
        return new SyncTaskExecutor();
    }
}
----
<1> The Async Executor for the Process Engine would use a `SimpleAsyncTaskExecutor`
<2> The Async Executor for the CMMN Engine would use a `SyncTaskExecutor`

[IMPORTANT]
======
If you define a custom `TaskExecutor` bean the Flowable creation of the bean is not triggered.
Which means that if you define a bean qualified with `@Process` you have to define one with `@Cmmn` or `@Primary`, otherwise the Cmmn Async Executor will use the one for the Process
======

",12255,False,1852.632102747232,median
"//   GAMBIT: Global and Modular BSM Inference Tool
//   *********************************************
///  \\file
///
///  Functor base class definitions.
///
///  *********************************************
///
///  Authors (add name and date if you modify):
///
///  \\author Pat Scott
///          (patscott@physics.mcgill.ca)
///  \\date 2013 Apr-July, Dec
///  \\date 2014 Jan, Mar-May, Sep
///  \\date 2015 Apr
///
///  \\author Anders Kvellestad
///          (anders.kvellestad@fys.uio.no)
///   \\date 2013 Apr, Nov
///
///  \\author Christoph Weniger
///          (c.weniger@uva.nl)
///  \\date 2013 May, June, July
///
///  \\author Ben Farmer
///          (benjamin.farmer@monash.edu.au)
///  \\date 2013 July, Sep
///  \\date 2014 Jan
///  \\date 2015 Nov
///
///  \\author Lars A. Dal
///          (l.a.dal@fys.uio.no)
///  \\date 2015 Jan
///
///  *********************************************

#include <chrono>

#include ""gambit/Elements/functors.hpp""
#include ""gambit/Elements/functor_definitions.hpp""
#include ""gambit/Elements/type_equivalency.hpp""
#include ""gambit/Utils/standalone_error_handlers.hpp""
#include ""gambit/Models/models.hpp""
#include ""gambit/Logs/logger.hpp""
#include ""gambit/Logs/logging.hpp""

#include <boost/preprocessor/seq/for_each.hpp>
#include <boost/io/ios_state.hpp>

namespace Gambit
{
  using namespace LogTags;

  // Functor class methods

    /// Constructor
    functor::functor (str func_name,
                      str func_capability,
                      str result_type,
                      str origin_name,
                      Models::ModelFunctorClaw &claw) :
     myName          (func_name),
     myCapability    (func_capability),
     myType          (Utils::fix_type(result_type)),
     myOrigin        (origin_name),
     myClaw          (&claw),
     myLabel         (""#""+func_capability+"" @""+origin_name+""::""+func_name),
     myTimingLabel   (""Runtime(ns) for ""+myLabel),
     myStatus        (0),
     myVertexID      (-1),       // (Note: myVertexID = -1 is intended to mean that no vertexID has been assigned)
     myTimingVertexID(-1),       // Not actually a graph vertex; ID assigned by ""get_main_param_id"" function.
     verbose         (false)     // For debugging.
    {}

    /// Virtual calculate(); needs to be redefined in daughters.
    void functor::calculate() {}

    /// Interfaces for runtime optimization
    /// Need to be implemented by daughters
    /// @{
    double functor::getRuntimeAverage() { return 0; }
    double functor::getInvalidationRate() { return 0; }
    void functor::setFadeRate(double) {}
    void functor::notifyOfInvalidation(const str&) {}
    void functor::reset() {}
    void functor::reset(int) {}
    /// @}

    /// Reset-then-recalculate method
    void functor::reset_and_calculate() { this->reset(omp_get_thread_num()); this->calculate(); }

    /// Setter for purpose (relevant only for next-to-output functors)
    void functor::setPurpose(str purpose) { myPurpose = purpose; }

    /// Setter for vertex ID (used in printer system)
    void functor::setVertexID(int ID) { myVertexID = ID; }

    /// Acquire ID for timing 'vertex' (used in printer system)
    void functor::setTimingVertexID(int ID) { myTimingVertexID = ID; }

    /// Setter for status: -4 = required backend absent (backend ini functions)
    ///                    -3 = required classes absent
    ///                    -2 = function absent
    ///                    -1 = origin absent
    ///                     0 = model incompatibility (default)
    ///                     1 = available
    ///                     2 = active
    void functor::setStatus(int stat)
    {
      myStatus = stat;
      setInUse(myStatus == 2);
    }

    /// Getter for the wrapped function's name
    str functor::name()        const { return myName; }
    /// Getter for the wrapped function's reported capability
    str functor::capability()  const { return myCapability; }
    /// Getter for the wrapped function's reported return type
    str functor::type()        const { return myType; }
    /// Getter for the wrapped function's origin (module or backend name)
    str functor::origin()      const { return myOrigin; }
    /// Getter for the version of the wrapped function's origin (module or backend)
    str functor::version()     const { return myVersion; }
    /// Getter for the 'safe' incarnation of the version of the wrapped function's origin (module or backend)
    str functor::safe_version()const { utils_error().raise(LOCAL_INFO,""The safe_version method is only defined for backend functors.""); return """"; }
    /// Getter for the wrapped function current status:
    ///                    -4 = required backend absent (backend ini functions)
    ///                    -3 = required classes absent
    ///                    -2 = function absent
    ///                    -1 = origin absent
    ///                     0 = model incompatibility (default)
    ///                     1 = available
    ///                     2 = active
    int functor::status()      const { return myStatus; }
    /// Getter for the  overall quantity provided by the wrapped function (capability-type pair)
    sspair functor::quantity() const { return std::make_pair(myCapability, myType); }
    /// Getter for purpose (relevant for output nodes, aka helper structures for the dep. resolution)
    str functor::purpose()     const { return myPurpose; }
    /// Getter for vertex ID
    int functor::vertexID()    const { return myVertexID; }
    /// Getter for timing vertex ID
    int functor::timingVertexID() const { return myTimingVertexID; }
    /// Getter indicating if the wrapped function's result should to be printed
    bool functor::requiresPrinting() const { return false; }
    /// Getter indicating if the timing data for this function's execution should be printed
    bool functor::requiresTimingPrinting() const { return false; }
    /// Getter for the printer label
    str functor::label()       const { return myLabel; }
    /// Getter for the printer timing label
    str functor::timingLabel() const { return myTimingLabel; }

    /// Setter for indicating if the wrapped function's result should to be printed
    void functor::setPrintRequirement(bool flag)
    {
      if (flag)
      {
        utils_error().raise(LOCAL_INFO,""The setPrintRequirement method has not been defined in this class."");
      }
    }

    /// Setter for indicating if the timing data for this functor should be printed
    void functor::setTimingPrintRequirement(bool flag)
    {
      if (flag)
      {
        utils_error().raise(LOCAL_INFO,""The setTimingPrintRequirement method has not been defined in this class."");
      }
    }

    /// Set the ordered list of pointers to other functors that should run nested in a loop managed by this one
    void functor::setNestedList (std::vector<functor*>&)
    {
      utils_error().raise(LOCAL_INFO,""The setNestedList method has not been defined in this class."");
    }

    /// Set the iteration number in a loop in which this functor runs
    void functor::setIteration (long long)
    {
      utils_error().raise(LOCAL_INFO,""The setIteration method has not been defined in this class."");
    }

    /// Getter for revealing whether this is permitted to be a manager functor
    bool functor::canBeLoopManager()
    {
      utils_error().raise(LOCAL_INFO,""The canBeLoopManager method has not been defined in this class."");
      return false;
    }

    /// Getter for revealing the required capability of the wrapped function's loop manager
    str functor::loopManagerCapability()
    {
      utils_error().raise(LOCAL_INFO,""The loopManagerCapability method has not been defined in this class."");
      return ""none"";
    }

    /// Getter for revealing the name of the wrapped function's assigned loop manager
    str functor::loopManagerName()
    {
      utils_error().raise(LOCAL_INFO,""The loopManagerName method has not been defined in this class."");
      return ""none"";
    }

    /// Getter for revealing the module of the wrapped function's assigned loop manager
    str functor::loopManagerOrigin()
    {
      utils_error().raise(LOCAL_INFO,""The loopManagerOrigin method has not been defined in this class."");
      return ""none"";
    }

    /// Getter for listing currently activated dependencies
    std::set<sspair> functor::dependencies()
    {
      utils_error().raise(LOCAL_INFO,""The dependencies method has not been defined in this class."");
      std::set<sspair> empty;
      return empty;
    }
    /// Getter for listing backend requirement groups
    std::set<str> functor::backendgroups()
    {
      utils_error().raise(LOCAL_INFO,""The backendgroups method has not been defined in this class."");
      std::set<str> empty;
      return empty;
    }
    /// Getter for listing all backend requirements
    std::set<sspair> functor::backendreqs()
    {
      utils_error().raise(LOCAL_INFO,""The backendreqs method has not been defined in this class."");
      std::set<sspair> empty;
      return empty;
    }
    /// Getter for listing backend requirements from a specific group
    std::set<sspair> functor::backendreqs(str)
    {
      utils_error().raise(LOCAL_INFO,""The backendreqs method has not been defined in this class."");
      std::set<sspair> empty;
      return empty;
    }
    /// Getter for listing permitted backends
    std::set<sspair> functor::backendspermitted(sspair)
    {
      utils_error().raise(LOCAL_INFO,""The backendspermitted method has not been defined in this class."");
      std::set<sspair> empty;
      return empty;
    }
    /// Getter for listing tags associated with backend requirements
    std::set<str> functor::backendreq_tags(sspair)
    {
      utils_error().raise(LOCAL_INFO,""The backendreq_tags method has not been defined in this class."");
      std::set<str> empty;
      return empty;
    }
    /// Getter for listing backend requirements that must be resolved from the same backend
    std::set<sspair> functor::forcematchingbackend(str)
    {
      utils_error().raise(LOCAL_INFO,""The forcematchingbackend method has not been defined in this class."");
      std::set<sspair> empty;
      return empty;
    }

    /// Getter for listing backend-specific conditional dependencies (4-string version)
    std::set<sspair> functor::backend_conditional_dependencies (str, str, str, str)
    {
      utils_error().raise(LOCAL_INFO,""The backend_conditional_dependencies method has not been defined in this class."");
      std::set<sspair> empty;
      return empty;
    }

    /// Tell the functor that the loop it manages should break now.
    void functor::breakLoop()
    {
      utils_error().raise(LOCAL_INFO,""The breakLoop method has not been defined in this class."");
    }

    /// Getter for backend-specific conditional dependencies (3-string version)
    std::set<sspair> functor::backend_conditional_dependencies (str req, str type, str be)
    {
      return backend_conditional_dependencies(req, type, be, ""any"");
    }

    /// Getter for backend-specific conditional dependencies (backend functor pointer version)
    std::set<sspair> functor::backend_conditional_dependencies (functor* be_functor)
    {
      return backend_conditional_dependencies (be_functor->capability(), be_functor->type(),
       be_functor->origin(), be_functor->version());
    }

    /// Getter for listing model-specific conditional dependencies
    std::set<sspair> functor::model_conditional_dependencies (str)
    {
      utils_error().raise(LOCAL_INFO,""The model_conditional_dependencies method has not been defined in this class."");
      std::set<sspair> empty;
      return empty;
    }

    /// Getter for listing model-specific conditional backend requirements
    std::set<sspair> functor::model_conditional_backend_reqs (str)
    {
      utils_error().raise(LOCAL_INFO,""The model_conditional_backend_reqs method has not been defined in this class."");
      std::set<sspair> empty;
      return empty;
    }

    /// Resolve a dependency using a pointer to another functor object
    void functor::resolveDependency (functor*)
    {
      utils_error().raise(LOCAL_INFO,""The resolveDependency method has not been defined in this class."");
    }

    // Set this functor's loop manager (if it has one)
    void functor::resolveLoopManager (functor*)
    {
      utils_error().raise(LOCAL_INFO,""The resolveLoopManager method has not been defined in this class."");
    }

    /// Resolve a backend requirement using a pointer to another functor object
    void functor::resolveBackendReq (functor*)
    {
      utils_error().raise(LOCAL_INFO,""The resolveBackendReq method has not been defined in this class."");
    }

    /// Notify the functor that a certain model is being scanned, so that it can activate its dependencies accordingly.
    void functor::notifyOfModel(str)
    {
      utils_error().raise(LOCAL_INFO,""The notifyOfModel method has not been defined in this class."");
    }

    /// Indicate to the functor which backends are actually loaded and working
    void functor::notifyOfBackends(std::map<str, std::set<str> >)
    {
      utils_error().raise(LOCAL_INFO,""The notifyOfBackends method has not been defined in this class."");
    }

    #ifndef NO_PRINTERS
      /// Print function
      void functor::print(Printers::BasePrinter*, const int, int)
      {
        str warn_msg = ""This is the functor base class print function! This should not\\n"";
        warn_msg += ""be used; the print function should be redefined in daughter\\n""
                    ""functor classes. If this is running there is a problem somewhere.\\n""
                    ""Currently only functors derived from module_functor_common<!=void>\\n""
                    ""are allowed to try to print themselves; i.e. backend and void\\n""
                    ""functors may not do this (they inherit this default message)."";
        utils_warning().raise(LOCAL_INFO,warn_msg);
      }

      /// Printer function (no-thread-index short-circuit)
      void functor::print(Printers::BasePrinter* printer, const int pointID)
      {
        print(printer,pointID,0);
      }
    #endif

    /// Notify the functor about an instance of the options class that contains
    /// information from its corresponding ini-file entry in the auxiliaries or
    /// observables section.
    void functor::notifyOfIniOptions(const Options& opt)
    {
      myOptions = opt;
    }

    /// Return a safe pointer to the options that this functor is supposed to run with (e.g. from the ini file).
    safe_ptr<Options> functor::getOptions()
    {
      return safe_ptr<Options>(&myOptions);
    }

    /// Test whether the functor is allowed (either explicitly or implicitly) to be used with a given model
    bool functor::modelAllowed(str model)
    {
      if (allowedModels.empty() and allowedGroupCombos.empty()) return true;
      if (allowed_parent_or_friend_exists(model)) return true;
      return false;
    }

    /// Test whether the functor has been explictly allowed to be used with a given model
    bool functor::modelExplicitlyAllowed(str model)
    {
      if (allowedModels.find(model) != allowedModels.end()) return true;
      return false;
    }

    /// Test whether the functor is allowed to be used with all models
    bool functor::allModelsAllowed()
    {
      return allowedModels.empty() and allowedGroupCombos.empty();
    }

    /// Add a model to the internal list of models for which this functor is allowed to be used.
    void functor::setAllowedModel(str model) { allowedModels.insert(model); }

    /// Test whether the functor is allowed (either explicitly or implicitly) to be used with a given combination of models
    bool functor::modelComboAllowed(std::set<str> combo)
    {
     // If any model in the combo is always allowed, then give the combo a thumbs up.
      for(std::set<str>::const_iterator model = combo.begin(); model != combo.end(); model++)
      {
        if (modelAllowed(*model)) return true;
      }
      // Loop over the allowed combinations, and check if the passed combo matches any of them
      for(std::set<std::set<str> >::const_iterator group_combo = allowedGroupCombos.begin(); group_combo != allowedGroupCombos.end(); group_combo++)
      {
        bool matches = true;
        //Loop over each group in the allowed group combination, and check if one of the entries in the passed model combination matches it somehow.
        for(std::set<str>::const_iterator group = group_combo->begin(); group != group_combo->end(); group++)
        {
          matches = matches and contains_anything_interpretable_as_member_of(combo, *group);
          if (not matches) break;
        }
        //Return true immediately if all entries in the allowed group combination have been matched.
        if (matches) return true;
      }
      return false;
    }

    /// Test whether the functor has been explictly allowed to be used with a given combination of models
    bool functor::modelComboExplicitlyAllowed(std::set<str> combo)
    {
      // If any model in the combo is always explicitly allowed, then give the combo a thumbs up.
      for(std::set<str>::const_iterator model = combo.begin(); model != combo.end(); model++)
      {
        if (modelExplicitlyAllowed(*model)) return true;
      }
      // Loop over the allowed combinations, and check if the passed combo matches any of them
      for(std::set<std::set<str> >::const_iterator group_combo = allowedGroupCombos.begin(); group_combo != allowedGroupCombos.end(); group_combo++)
      {
        bool matches = true;
        //Loop over each group in the allowed group combination, and check if one of the entries in the passed model combination matches it explicitly.
        for(std::set<str>::const_iterator group = group_combo->begin(); group != group_combo->end(); group++)
        {
          matches = matches and has_common_elements(combo, *group);
          if (not matches) break;
        }
        //Return true immediately if all entries in the allowed group combination have been matched.
        if (matches) return true;
      }
      return false;
    }

    /// Add a model group definition to the internal list of model groups.
    void functor::setModelGroup(str group, str contents)
    {
      //Strip the group contents of its parentheses, then split it, turn it into a set and save it in the map
      Utils::strip_parentheses(contents);
      std::vector<str> v = Utils::delimiterSplit(contents, "","");
      std::set<str> combo(v.begin(), v.end());
      modelGroups[group] = combo;
    }

    /// Add a model group combination to the internal list of combinations for which this functor is allowed to be used.
    void functor::setAllowedModelGroupCombo(str groups)
    {
      //Strip the group combo of its parentheses and whitespace, then split it and save it in the vector of allowed combos
      Utils::strip_parentheses(groups);
      Utils::strip_whitespace_except_after_const(groups);
      std::vector<str> v = Utils::delimiterSplit(groups, "","");
      std::set<str> group_combo(v.begin(), v.end());
      allowedGroupCombos.insert(group_combo);
    }

    /// Attempt to retrieve a dependency or model parameter that has not been resolved
    void functor::failBigTime(str method)
    {
      str error_msg = ""Attempted to use a functor method from a null pointer."";
      error_msg  += ""\\nProbably you tried to use a conditional dependency that has""
                    ""\\nnot been activated, or a model parameter that is not defined""
                    ""\\nin the model for which this function has been invoked.""
                    ""\\nPlease check your module function source code.""
                    ""\\nMethod invoked: "" + method + ""."";
      utils_error().raise(LOCAL_INFO,error_msg);
    }

    /// Test if there is a model in the functor's allowedModels list as which this model can be interpreted
    inline bool functor::allowed_parent_or_friend_exists(str model)
    {
      for (std::set<str>::reverse_iterator it = allowedModels.rbegin() ; it != allowedModels.rend(); ++it)
      {
        if (myClaw->model_exists(*it))
        {
          if (myClaw->downstream_of(model, *it)) return true;
        }
      }
      return false;
    }

    /// Check that a model is actually part of a combination that is allowed to be used with this functor.
    inline bool functor::in_allowed_combo(str model)
    {
      // If the model is allowed on its own, just give the thumbs up immediately.
      if (modelAllowed(model)) return true;
      // Loop over the allowed combinations, and check if the passed model matches anything in any of them
      for(std::set<std::set<str> >::const_iterator group_combo = allowedGroupCombos.begin(); group_combo != allowedGroupCombos.end(); group_combo++)
      {
        //Loop over each group in the allowed group combination, and check if the model is interpretable as a model in the group.
        for(std::set<str>::const_iterator group = group_combo->begin(); group != group_combo->end(); group++)
        {
          // Work through the members of the model group
          std::set<str> models = modelGroups.at(*group);
          for (std::set<str>::reverse_iterator it = models.rbegin() ; it != models.rend(); ++it)
          {
            if (myClaw->model_exists(*it))
            {
              if (myClaw->downstream_of(model, *it)) return true;
            }
          }
        }
      }
      return false;
    }

    /// Test whether any of the entries in a given model group is a valid interpretation of any members in a given combination
    inline bool functor::contains_anything_interpretable_as_member_of(std::set<str> combo, str group)
    {
      // Work through the members of the model group
      std::set<str> models = modelGroups.at(group);
      for (std::set<str>::const_iterator it = models.begin() ; it != models.end(); ++it)
      {
        if (myClaw->model_exists(*it))
        {
          // Work through the members of the combination
          for (std::set<str>::const_iterator jt = combo.begin() ; jt != combo.end(); ++jt)
          {
            if (myClaw->model_exists(*jt))
            {
              if (myClaw->downstream_of(*jt, *it)) return true;
            }
          }
        }
      }
      return false;
    }

    /// Work out whether a given combination of models and a model group have any elements in common
    inline bool functor::has_common_elements(std::set<str> combo, str group)
    {
      // Work through the members of the model group
      std::set<str> models = modelGroups.at(group);
      for (std::set<str>::reverse_iterator it = models.rbegin() ; it != models.rend(); ++it)
      {
        if ( std::find(combo.begin(), combo.end(), *it) == combo.end() ) return true;
      }
      return false;
    }

    /// Try to find a parent or friend model in some user-supplied map from models to sspair vectors
    /// Preferentially returns the 'least removed' parent or friend, i.e. less steps back in the model lineage.
    str functor::find_friend_or_parent_model_in_map(str model, std::map< str, std::set<sspair> > karta)
    {
      std::vector<str> candidates;
      for (std::map< str, std::set<sspair> >::reverse_iterator it = karta.rbegin() ; it != karta.rend(); ++it)
      {
        if (myClaw->model_exists(it->first))
        {
          if (myClaw->downstream_of(model, it->first)) candidates.push_back(it->first);
        }
      }
      // If found no candidates, return the empty string.
      if (candidates.empty()) return """";
      // If found just one, return it with no further questions.
      if (candidates.size() == 1) return candidates[0];
      // If found more than one, choose the one closest to the model passed in.
      str result = candidates.front();
      for (std::vector<str>::iterator it = candidates.begin()+1; it != candidates.end(); ++it)
      {
        if (myClaw->downstream_of(*it, result)) result = *it;
      }
      return result;
    }

    /// Retrieve the previously saved exception generated when this functor invalidated the current point in model space.
    invalid_point_exception* functor::retrieve_invalid_point_exception() { return NULL; }


    // Module_functor_common class methods

    /// Constructor
    module_functor_common::module_functor_common(str func_name,
                                                 str func_capability,
                                                 str result_type,
                                                 str origin_name,
                                                 Models::ModelFunctorClaw &claw)
    : functor                  (func_name, func_capability, result_type, origin_name, claw),
      myTimingPrintFlag        (false),
      start                    (NULL),
      end                      (NULL),
      point_exception_raised   (false),
      runtime_average          (FUNCTORS_RUNTIME_INIT),           // default 1 micro second
      fadeRate                 (FUNCTORS_FADE_RATE),              // can be set individually for each functor
      pInvalidation            (FUNCTORS_BASE_INVALIDATION_RATE),
      needs_recalculating      (NULL),
      already_printed          (NULL),
      already_printed_timing   (NULL),
      iCanManageLoops          (false),
      iRunNested               (false),
      myLoopManagerCapability  (""none""),
      myLoopManager            (NULL),
      myCurrentIteration       (NULL),
      globlMaxThreads          (omp_get_max_threads()),
      myLogTag                 (-1)
    {
      if (globlMaxThreads == 0) utils_error().raise(LOCAL_INFO,""Cannot determine number of hardware threads available on this system."");
      // Determine LogTag number
      myLogTag = Logging::str2tag(myOrigin);
      if (not claw.model_exists(origin_name)) check_missing_LogTag();
    }

    /// Destructor
    module_functor_common::~module_functor_common()
    {
      if (start != NULL)                  delete [] start;
      if (end != NULL)                    delete [] end;
      if (needs_recalculating != NULL)    delete [] needs_recalculating;
      if (already_printed != NULL)        delete [] already_printed;
      if (already_printed_timing != NULL) delete [] already_printed_timing;
      if (myCurrentIteration != NULL)     delete [] myCurrentIteration;
    }

    /// Check if an appropriate LogTag for this functor is missing from the logging system.
    void module_functor_common::check_missing_LogTag()
    {
      if(myLogTag==-1)
      {
        std::ostringstream ss;
        ss << ""Cannot retrieve LogTag number; no match for module name in tag2str map."" << endl
           << ""Module: "" << myOrigin << endl
           << ""Function:   "" << myName << endl
           << ""This is probably because there is no log specified for "" << myOrigin << "" in your yaml file."";
        utils_warning().raise(LOCAL_INFO,ss.str());
      }
    }

    /// Getter for averaged runtime
    double module_functor_common::getRuntimeAverage()
    {
      return runtime_average;
    }

    /// Setter for indicating if the timing data for this function's execution should be printed
    void module_functor_common::setTimingPrintRequirement(bool flag)
    {
      myTimingPrintFlag = flag;
    }

    /// Getter indicating if the timing data for this function's execution should be printed
    bool module_functor_common::requiresTimingPrinting() const
    {
      return myTimingPrintFlag;
    }

    /// Reset functor for all threads
    void module_functor_common::reset()
    {
      init_memory();
      int n = (iRunNested ? globlMaxThreads : 1);
      std::fill(needs_recalculating, needs_recalculating+n, true);
      std::fill(already_printed, already_printed+n, false);
      std::fill(already_printed_timing, already_printed_timing+n, false);
      if (iCanManageLoops) resetLoop();
      point_exception_raised = false;
    }

    /// Reset functor for one thread only
    void module_functor_common::reset(int thread_num)
    {
      init_memory();
      needs_recalculating[thread_num] = true;
      already_printed[thread_num] = false;
      already_printed_timing[thread_num] = false;
      if (iCanManageLoops) resetLoop();
    }

    /// Tell the functor that it invalidated the current point in model space, pass a message explaining why, and throw an exception.
    void module_functor_common::notifyOfInvalidation(const str& msg)
    {
      acknowledgeInvalidation(invalid_point());
      retrieve_invalid_point_exception()->raise(msg);
    }

    /// Acknowledge that this functor invalidated the current point in model space.
    void module_functor_common::acknowledgeInvalidation(invalid_point_exception& e, functor* f)
    {
      #pragma omp atomic
      pInvalidation += fadeRate*(1-FUNCTORS_BASE_INVALIDATION_RATE);
      if (f==NULL) f = this;
      #pragma omp critical (raised_point_exception)
      {
        e.set_thrower(f);
        raised_point_exception = e;
        point_exception_raised = true;
      }
      if (omp_get_level()!=0) breakLoop();
    }

    /// Retrieve the previously saved exception generated when this functor invalidated the current point in model space.
    invalid_point_exception* module_functor_common::retrieve_invalid_point_exception()
    {
      if (point_exception_raised) return &raised_point_exception;
      for (auto f = myNestedFunctorList.begin(); f != myNestedFunctorList.end(); ++f)
      {
        invalid_point_exception* e = (*f)->retrieve_invalid_point_exception();
        if (e != NULL) return e;
      }
      return NULL;
    }

    /// Getter for invalidation rate
    double module_functor_common::getInvalidationRate()
    {
      return pInvalidation;
    }

    /// Setter for the fade rate
    void module_functor_common::setFadeRate(double new_rate)
    {
      fadeRate = new_rate;
    }

    /// Indicate whether or not a known model is activated or not.
    bool module_functor_common::getActiveModelFlag(str model)
    {
      if (activeModelFlags.find(model) == activeModelFlags.end())
      {
        std::ostringstream ss;
        ss << ""Problem with ModelInUse(\\"""" << model << ""\\"")."" << endl
           << ""This model is not known by "" << myOrigin << ""::"" << myName << ""."" << endl
           << ""Please make sure that it has been mentioned in some context in the"" << endl
           << ""rollcall header declaration of this function."";
        model_error().raise(LOCAL_INFO,ss.str());
      }
      return activeModelFlags.at(model);
    }

    /// Return a safe pointer to a string indicating which backend requirement has been activated for a given backend group.
    safe_ptr<str> module_functor_common::getChosenReqFromGroup(str group)
    {
      chosenReqsFromGroups[group] = ""none"";
      return safe_ptr<str>(&chosenReqsFromGroups[group]);
    }

    /// Execute a single iteration in the loop managed by this functor.
    void module_functor_common::iterate(long long iteration)
    {
      if (not myNestedFunctorList.empty())
      {
        for (std::vector<functor*>::iterator it = myNestedFunctorList.begin();
         it != myNestedFunctorList.end(); ++it)
        {
          (*it)->setIteration(iteration);     // Tell the nested functor what iteration this is.
          try
          {
            (*it)->reset_and_calculate();     // Reset the nested functor so that it recalculates, then set it off
          }
          catch (invalid_point_exception& e)
          {
            acknowledgeInvalidation(e,*it);
            if (omp_get_level()==0) throw(e); // If not in an OpenMP parallel block, inform of invalidation and throw onwards
          }
        }
      }
    }

    // Initialise the array holding the current iteration(s) of this functor.
    void module_functor_common::init_myCurrentIteration_if_NULL()
    {
      if(myCurrentIteration==NULL)
      {
        #pragma omp critical(module_functor_init_myCurrentIteration_if_NULL)
        {
          if(myCurrentIteration==NULL)  // Check again in case two threads managed to get this far in sequence.
          {
            // Set the number of slots to the max number of threads allowed iff this functor can run in parallel
            int nslots = (iRunNested ? globlMaxThreads : 1);
            // Reserve enough space to hold as many iteration numbers as there are slots (threads) allowed
            myCurrentIteration = new long long[nslots];
            // Zero them to start off
            std::fill(myCurrentIteration, myCurrentIteration+nslots, 0);
          }
        }
      }
    }

    /// Tell the manager of the loop in which this functor runs that it is time to break the loop.
    void module_functor_common::breakLoopFromManagedFunctor()
    {
      if (myLoopManager == NULL)
      {
        str errmsg = ""Problem whilst attempting to break out of loop:"";
        errmsg +=  ""\\n Loop Manager not properly defined.""
                   ""\\n This is "" + this->name() + "" in "" + this->origin() + ""."";
        utils_error().raise(LOCAL_INFO,errmsg);
      }
      else
      {
        myLoopManager->breakLoop();
      }
    }

    /// Tell the functor that the loop it manages should break now.
    void module_functor_common::breakLoop()
    {
      #pragma omp critical (myLoopIsDone)
      {
        myLoopIsDone = true;
      }
    }

    /// Return a safe pointer to the flag indicating that a loop managed by this functor should break now.
    safe_ptr<bool> module_functor_common::loopIsDone()
    {
      return safe_ptr<bool>(&myLoopIsDone);
    }

    /// Provide a way to reset the flag indicating that a loop managed by this functor should break.
    void module_functor_common::resetLoop()
    {
      #pragma omp critical (myLoopIsDone)
      {
        myLoopIsDone = false;
      }
    }

    /// Setter for setting the iteration number in the loop in which this functor runs
    void module_functor_common::setIteration (long long iteration)
    {
      init_myCurrentIteration_if_NULL(); // Init memory if this is the first run through.
      myCurrentIteration[omp_get_thread_num()] = iteration;
    }

    /// Return a safe pointer to the iteration number in the loop in which this functor runs.
    omp_safe_ptr<long long> module_functor_common::iterationPtr()
    {
      init_myCurrentIteration_if_NULL();  // Init memory if this is the first run through.
      return omp_safe_ptr<long long>(myCurrentIteration);
    }

    /// Setter for specifying whether this is permitted to be a manager functor, which runs other functors nested in a loop.
    void module_functor_common::setCanBeLoopManager (bool canManage) { iCanManageLoops = canManage; }
    /// Getter for revealing whether this is permitted to be a manager functor
    bool module_functor_common::canBeLoopManager() { return iCanManageLoops; }

    /// Setter for specifying the capability required of a manager functor, if it is to run this functor nested in a loop.
    void module_functor_common::setLoopManagerCapability (str cap) { iRunNested = true; myLoopManagerCapability = cap; }
    /// Getter for revealing the required capability of the wrapped function's loop manager
    str module_functor_common::loopManagerCapability() { return myLoopManagerCapability; }
    /// Getter for revealing the name of the wrapped function's assigned loop manager
    str module_functor_common::loopManagerName() { return (myLoopManager == NULL ? ""none"" : myLoopManager->name()); }
    /// Getter for revealing the module of the wrapped function's assigned loop manager
    str module_functor_common::loopManagerOrigin() { return (myLoopManager == NULL ? ""none"" : myLoopManager->origin()); }

    /// Getter for listing currently activated dependencies
    std::set<sspair> module_functor_common::dependencies() { return myDependencies; }
    /// Getter for listing backend requirement groups
    std::set<str> module_functor_common::backendgroups() { return myGroups; }
    /// Getter for listing all backend requirements
    std::set<sspair> module_functor_common::backendreqs() { return myResolvableBackendReqs; }
    /// Getter for listing backend requirements from a specific group
    std::set<sspair> module_functor_common::backendreqs(str group)
    {
      if (myGroupedBackendReqs.find(group) != myGroupedBackendReqs.end())
      {
        return myGroupedBackendReqs[group];
      }
      else
      {
        std::set<sspair> empty;
        return empty;
      }
    }
    /// Getter for listing permitted backends
    std::set<sspair> module_functor_common::backendspermitted(sspair quant)
    {
      if (permitted_map.find(quant) != permitted_map.end())
      {
        return permitted_map[quant];
      }
      else
      {
        std::set<sspair> empty;
        return empty;
      }
    }
    /// Getter for listing tags associated with backend requirements
    std::set<str> module_functor_common::backendreq_tags(sspair quant)
    {
      if (backendreq_tagmap.find(quant) != backendreq_tagmap.end())
      {
        return backendreq_tagmap[quant];
      }
      else
      {
        std::set<str> empty;
        return empty;
      }
    }
    /// Getter for listing backend requirements that must be resolved from the same backend
    std::set<sspair> module_functor_common::forcematchingbackend(str tag)
    {
      if (myForcedMatches.find(tag) != myForcedMatches.end())
      {
        return myForcedMatches[tag];
      }
      else
      {
        std::set<sspair> empty;
        return empty;
      }
    }

    /// Getter for listing backend-specific conditional dependencies (4-string version)
    std::set<sspair> module_functor_common::backend_conditional_dependencies (str req, str type, str be, str ver)
    {
      std::set<sspair> generic_deps, specific_deps, total_deps;
      std::vector<str> quad;
      quad.push_back(req);
      quad.push_back(type);
      quad.push_back(be);
      quad.push_back(ver);
      //Check first what conditional dependencies exist for all versions of this backend
      if (ver != ""any"")
      {
        generic_deps = backend_conditional_dependencies(req, type, be, ""any"");
      }
      //Now see if there are any for this specific version
      if (myBackendConditionalDependencies.find(quad) != myBackendConditionalDependencies.end())
      {
        specific_deps = myBackendConditionalDependencies[quad];
      }
      //Now put them together
      total_deps.insert(generic_deps.begin(), generic_deps.end());
      total_deps.insert(specific_deps.begin(), specific_deps.end());
      return total_deps;
    }

    /// Getter for backend-specific conditional dependencies (3-string version)
    std::set<sspair> module_functor_common::backend_conditional_dependencies (str req, str type, str be)
    {
      return backend_conditional_dependencies(req, type, be, ""any"");
    }

    /// Getter for backend-specific conditional dependencies (backend functor pointer version)
    std::set<sspair> module_functor_common::backend_conditional_dependencies (functor* be_functor)
    {
      return backend_conditional_dependencies (be_functor->capability(), be_functor->type(),
       be_functor->origin(), be_functor->version());
    }

    /// Getter for listing model-specific conditional dependencies
    std::set<sspair> module_functor_common::model_conditional_dependencies (str model)
    {
      str parent = find_friend_or_parent_model_in_map(model,myModelConditionalDependencies);
      if (parent != """") return myModelConditionalDependencies[parent];
      std::set<sspair> empty;
      return empty;
    }

    /// Getter for listing model-specific conditional backend requirements
    std::set<sspair> module_functor_common::model_conditional_backend_reqs (str model)
    {
      str parent = find_friend_or_parent_model_in_map(model,myModelConditionalBackendReqs);
      if (parent != """") return myModelConditionalBackendReqs[parent];
      std::set<sspair> empty;
      return empty;
    }

    /// Add and activate unconditional dependencies.
    void module_functor_common::setDependency(str dep, str type, void(*resolver)(functor*, module_functor_common*), str purpose)
    {
      sspair key (dep, Utils::fix_type(type));
      myDependencies.insert(key);
      dependency_map[key] = resolver;
      this->myPurpose = purpose; // only relevant for output nodes
    }

    /// Add a backend conditional dependency for multiple backend versions
    void module_functor_common::setBackendConditionalDependency
     (str req, str be, str ver, str dep, str dep_type, void(*resolver)(functor*, module_functor_common*))
    {
      // Split the version string and send each version to be registered
      std::vector<str> versions = Utils::delimiterSplit(ver, "","");
      for (std::vector<str>::iterator it = versions.begin() ; it != versions.end(); ++it)
      {
        setBackendConditionalDependencySingular(req, be, *it, dep, dep_type, resolver);
      }
    }

    /// Add a backend conditional dependency for a single backend version
    void module_functor_common::setBackendConditionalDependencySingular
     (str req, str be, str ver, str dep, str dep_type, void(*resolver)(functor*, module_functor_common*))
    {
      sspair key (dep, Utils::fix_type(dep_type));
      std::vector<str> quad;
      if (backendreq_types.find(req) != backendreq_types.end())
      {
        quad.push_back(req);
        quad.push_back(backendreq_types[req]);
        quad.push_back(be);
        quad.push_back(ver);
      }
      else
      {
        str errmsg = ""Problem whilst attempting to set backend-conditional dependency:"";
        errmsg +=  ""\\nThe type of the backend requirement "" + req + ""on which the""
                   ""\\ndependency "" + dep + "" is conditional has not been set.  This""
                   ""\\nis "" + this->name() + "" in "" + this->origin() + ""."";
        utils_error().raise(LOCAL_INFO,errmsg);
      }
      if (myBackendConditionalDependencies.find(quad) == myBackendConditionalDependencies.end())
      {
        std::set<sspair> newvec;
        myBackendConditionalDependencies[quad] = newvec;
      }
      myBackendConditionalDependencies[quad].insert(key);
      dependency_map[key] = resolver;
    }

    /// Add a model conditional dependency for multiple models
    void module_functor_common::setModelConditionalDependency
     (str model, str dep, str dep_type, void(*resolver)(functor*, module_functor_common*))
    {
      // Split the model string and send each model to be registered
      std::vector<str> models = Utils::delimiterSplit(model, "","");
      for (std::vector<str>::iterator it = models.begin() ; it != models.end(); ++it)
      {
        setModelConditionalDependencySingular(*it, dep, dep_type, resolver);
      }
    }

    /// Add a model conditional dependency for a single model
    void module_functor_common::setModelConditionalDependencySingular
     (str model, str dep, str dep_type, void(*resolver)(functor*, module_functor_common*))
    {
      sspair key (dep, Utils::fix_type(dep_type));
      if (myModelConditionalDependencies.find(model) == myModelConditionalDependencies.end())
      {
        std::set<sspair> newvec;
        myModelConditionalDependencies[model] = newvec;
      }
      myModelConditionalDependencies[model].insert(key);
      dependency_map[key] = resolver;
    }

    /// Add an unconditional backend requirement
    /// The info gets updated later if this turns out to be conditional on a model.
    void module_functor_common::setBackendReq(str group, str req, str tags, str type, void(*resolver)(functor*))
    {
      type = Utils::fix_type(type);
      sspair key (req, type);
      backendreq_types[req] = type;
      myBackendReqs.insert(key);
      myResolvableBackendReqs.insert(key);
      if ( std::find(myGroups.begin(), myGroups.end(), group) == myGroups.end() )
      {
        myGroups.insert(group);
        std::set<sspair> empty;
        myGroupedBackendReqs[group] = empty;
      }
      myGroupedBackendReqs[group].insert(key);
      backendreq_map[key] = resolver;
      Utils::strip_parentheses(tags);
      std::vector<str> v = Utils::delimiterSplit(tags, "","");
      backendreq_tagmap[key] = std::set<str>(v.begin(), v.end());
      backendreq_groups[key] = group;
    }

    /// Add a rule for activating backend requirements according to the model being scanned.
    void module_functor_common::makeBackendRuleForModel(str model, str tag)
    {
      //Strip the tag and model strings of their parentheses
      Utils::strip_parentheses(tag);
      Utils::strip_parentheses(model);

      //Split the tag string and sort it.
      std::vector<str> v = Utils::delimiterSplit(tag, "","");
      std::set<str> tags(v.begin(), v.end());

      //Find all declared backend requirements that fit one of the tags within the passed tag set.
      for (std::set<sspair>::iterator it = myBackendReqs.begin(); it != myBackendReqs.end(); ++it)
      {
        std::set<str> tagset = backendreq_tagmap[*it];
        if (not Utils::is_disjoint(tags, tagset))
        {
          // Make each of the matching backend requirements conditional on the models passed in.
          setModelConditionalBackendReq(model,it->first,it->second);
        }
      }

    }

    /// Add a model conditional backend requirement for multiple models
    void module_functor_common::setModelConditionalBackendReq
     (str model, str req, str type)
    {
      // Split the model string and send each model to be registered
      std::vector<str> models = Utils::delimiterSplit(model, "","");
      for (std::vector<str>::iterator it = models.begin() ; it != models.end(); ++it)
      {
        setModelConditionalBackendReqSingular(*it, req, type);
      }
    }

    /// Add a model conditional backend requirement for a single model
    void module_functor_common::setModelConditionalBackendReqSingular
     (str model, str req, str type)
    {
      sspair key (req, Utils::fix_type(type));

      // Remove the entry from the resolvable backend reqs list...
      myResolvableBackendReqs.erase(key);

      // Check that the model is not already in the conditional backend reqs list, then add it
      if (myModelConditionalBackendReqs.find(model) == myModelConditionalBackendReqs.end())
      {
        std::set<sspair> newvec;
        myModelConditionalBackendReqs[model] = newvec;
      }
      myModelConditionalBackendReqs[model].insert(key);
    }

    /// Add a rule for dictating which backends can be used to fulfill which backend requirements.
    void module_functor_common::makeBackendOptionRule(str be_and_ver, str tag)
    {
      //Strip the tag and be-ver strings of their parentheses, then split them
      Utils::strip_parentheses(tag);
      Utils::strip_parentheses(be_and_ver);
      std::vector<str> v = Utils::delimiterSplit(tag, "","");
      std::set<str> tags(v.begin(), v.end());
      std::vector<str> be_plus_versions = Utils::delimiterSplit(be_and_ver, "","");

      //Die if no backend and/or no tags were given.
      if (tags.empty() or be_plus_versions.empty())
      {
        str errmsg = ""Error whilst attempting to set permitted backends:"";
        errmsg +=  ""\\nA BACKEND_OPTION must include a backend name and at least one tag.""
                   ""\\nThis is "" + this->name() + "" in "" + this->origin() + ""."";
        utils_error().raise(LOCAL_INFO,errmsg);
      }

      //Seperate the backend from the versions
      str be = be_plus_versions.at(0);
      std::vector<str> versions(be_plus_versions.begin()+1,be_plus_versions.end());
      if (versions.empty()) versions.push_back(""any"");

      //Find all declared backend requirements that fit one of the tags within the passed tag set.
      for (std::set<sspair>::iterator it = myBackendReqs.begin(); it != myBackendReqs.end(); ++it)
      {
        std::set<str> tagset = backendreq_tagmap[*it];
        if (not Utils::is_disjoint(tags, tagset))
        {
          // For each of the matching backend requirements, set the chosen backend-version pairs as permitted
          for (std::vector<str>::iterator vit = versions.begin() ; vit != versions.end(); ++vit)
          {
            setPermittedBackend(it->first, be, *vit);
          }
        }
      }

    }

    /// Add a single permitted backend version
    void module_functor_common::setPermittedBackend(str req, str be, str ver)
    {
      sspair key;
      if (backendreq_types.find(req) != backendreq_types.end())
      {
        key = std::make_pair(req, backendreq_types[req]);
      }
      else
      {
        str errmsg = ""Error whilst attempting to set permitted backend:"";
        errmsg += ""\\nThe return type of the backend requirement "" + req + ""is not set.""
                  ""\\nThis probably means the backend requirement has not been declared.""
                  ""\\nThis is "" + this->name() + "" in "" + this->origin() + ""."";
        utils_error().raise(LOCAL_INFO,errmsg);
      }
      sspair vector_entry (be,  ver);
      if (permitted_map.find(key) == permitted_map.end())
      {
        std::set<sspair> newvec;
        permitted_map[key] = newvec;
      }
      permitted_map[key].insert(vector_entry);
    }

    /// Add one or more rules that force backends reqs with the same tag to always be resolved from the same backend.
    void module_functor_common::makeBackendMatchingRule(str tag)
    {
      //Strip the tag string of any parentheses, then split it
      Utils::strip_parentheses(tag);
      std::vector<str> tags = Utils::delimiterSplit(tag, "","");

      //Die if no tags were given.
      if (tags.empty())
      {
        str errmsg = ""Problem whilst attempting to set backend-matching rule:"";
        errmsg +=  ""\\nA call to FORCE_SAME_BACKEND must include at least one tag!""
                   ""\\nThis is "" + this->name() + "" in "" + this->origin() + ""."";
        utils_error().raise(LOCAL_INFO,errmsg);
      }

      //Work with one tag at a time
      for (std::vector<str>::iterator tagit = tags.begin(); tagit != tags.end(); ++tagit)
      {
        std::set<sspair> matches;
        //Find all declared backend requirements that fit the current tag
        for (std::set<sspair>::iterator it = myBackendReqs.begin(); it != myBackendReqs.end(); ++it)
        {
          //Test if the current tag is amongst the tags listed for the current backend requirement
          std::set<str> its_tags = backendreq_tagmap[*it];
          if ( std::find(its_tags.begin(), its_tags.end(), *tagit) != its_tags.end() )
          {
            //It is; now place the current backend requirement into the set of matches
            matches.insert(*it);
          }
        }
        //Save the matched set of backend requirements as needing to be filled using the same backend.
        myForcedMatches[*tagit] = matches;
      }

      //Note that overlapping sets are explicitly left unmerged, as the common elements
      //may or may not be activated in a given scan, making the disjointedness of the
      //different sets determinable only at resolution time, not initialisation time.

    }

    /// Add a rule indicating that classes from a given backend must be available
    void module_functor_common::setRequiredClassloader(str be, str ver, str safe_ver)
    {
      // Add the rule.
      required_classloading_backends[be].insert(ver);
      // Add a dependency on the backend's initialisation function.
      sspair be_ini_quantity(be + ""_"" + safe_ver + ""_init"", ""void"");
      if (std::find(myDependencies.begin(), myDependencies.end(), be_ini_quantity) == myDependencies.end())
      {
        myDependencies.insert(be_ini_quantity);
      }
    }

    /// Indicate to the functor which backends are actually loaded and working
    void module_functor_common::notifyOfBackends(std::map<str, std::set<str> > be_ver_map)
    {
      missing_backends.clear();
      // Loop over all the backends that are needed for this functor to work.
      for (auto it = required_classloading_backends.begin(); it != required_classloading_backends.end(); ++it)
      {
        // Check to make sure some version of the backend in question is connected.
        if (be_ver_map.find(it->first) == be_ver_map.end())
        {
          this->myStatus = -3;
          missing_backends.push_back(it->first);
        }
        else
        {  // Loop over all the versions of the backend that are needed for this functor to work.
          for (auto jt = it->second.begin(); jt != it->second.end(); ++jt)
          {
            std::set<str> versions = be_ver_map.at(it->first);
            // Check that the specific version needed is connected.
            if (versions.find(*jt) == versions.end())
            {
              this->myStatus = -3;
              missing_backends.push_back(it->first + "", v"" + *jt);
            }
          }
        }
      }
    }

    /// Set the ordered list of pointers to other functors that should run nested in a loop managed by this one
    void module_functor_common::setNestedList (std::vector<functor*> &newNestedList)
    {
      if (iCanManageLoops)
      {
        myNestedFunctorList = newNestedList;
      }
      else
      {
        str errmsg = ""This module functor is not permitted to manage"";
        errmsg +=  ""\\nloops, so you cannot set its nested functor list.""
                   ""\\nThis is "" + this->name() + "" in "" + this->origin() + ""."";
        utils_error().raise(LOCAL_INFO,errmsg);
      }
    }

    /// Resolve a dependency using a pointer to another functor object
    void module_functor_common::resolveDependency (functor* dep_functor)
    {
      sspair key (dep_functor->quantity());
      if (std::find(myDependencies.begin(), myDependencies.end(), key) == myDependencies.end())
      {
        str errmsg = ""Cannot resolve dependency:"";
        errmsg +=  ""\\nFunction "" + myName + "" in "" + myOrigin + "" does not depend on""
                   ""\\ncapability "" + key.first + "" with type = "" + key.second + ""."";
        utils_error().raise(LOCAL_INFO,errmsg);
      }
      else
      {
        if (dependency_map.find(key) != dependency_map.end()) (*dependency_map[key])(dep_functor,this);
        // propagate purpose from next to next-to-output nodes
        dep_functor->setPurpose(this->myPurpose);
      }
    }

    // Set this functor's loop manager (if it has one)
    void module_functor_common::resolveLoopManager (functor* dep_functor)
    {
      if (dep_functor->capability() != myLoopManagerCapability or not dep_functor->canBeLoopManager())
      {
        sspair key (dep_functor->quantity());
        str errmsg = ""Cannot set loop manager for nested functor:"";
        errmsg +=  ""\\nFunction "" + myName + "" in "" + myOrigin + "" does not need a loop manager with""
                   ""\\ncapability "" + key.first + ""."";
        utils_error().raise(LOCAL_INFO,errmsg);
      }
      myLoopManager = dep_functor;
    }

    /// Resolve a backend requirement using a pointer to another functor object
    void module_functor_common::resolveBackendReq (functor* be_functor)
    {

      sspair key (be_functor->quantity());

      //First make sure that the proposed backend function fulfills a known requirement of the module function.
      if (backendreq_map.find(key) != backendreq_map.end())
      {

        sspair proposal (be_functor->origin(), be_functor->version());  //Proposed backend-version pair
        sspair generic_proposal (be_functor->origin(), ""any"");          //Proposed backend, any version

        if ( //Check for a condition under which the proposed backend function is an acceptable fit for this requirement.
         //Check whether there are have been any permitted backends stated for this requirement (if not, anything goes).
         (permitted_map.find(key) == permitted_map.end()) ||
         //Iterate over the vector of backend-version pairs for this requirement to see if all versions of the
         //proposed backend have been explicitly permitted.
         (std::find(permitted_map[key].begin(), permitted_map[key].end(), generic_proposal) != permitted_map[key].end()) ||
         //Iterate over the vector of backend-version pairs again to see if the specific backend version
         //proposed had been explicitly permitted.
         (std::find(permitted_map[key].begin(), permitted_map[key].end(), proposal) != permitted_map[key].end()) )
        {

          //One of the conditions was met, so do the resolution.
          (*backendreq_map[key])(be_functor);

          //Set this backend functor's status to active.
          be_functor->setStatus(2);

          //If this is also the condition under which any backend-conditional dependencies should be activated, do it.
          std::set<sspair> deps_to_activate = backend_conditional_dependencies(be_functor);
          for (std::set<sspair>::iterator it = deps_to_activate.begin() ; it != deps_to_activate.end(); ++it)
          {
            myDependencies.insert(*it);
          }

          // Add a dependency on the initialisation function of the backend that this backend function hails from (if not done already).
          sspair be_ini_quantity(be_functor->origin() + ""_"" + be_functor->safe_version() + ""_init"", ""void"");
          if (std::find(myDependencies.begin(), myDependencies.end(), be_ini_quantity) == myDependencies.end())
          {
            myDependencies.insert(be_ini_quantity);
          }

          //Check if this backend requirement is part of a group.
          str group = backendreq_groups[key];
          if (group != ""none"")
          {
            //If it is part of a group, make sure that group has actually been declared.
            if (chosenReqsFromGroups.find(group) != chosenReqsFromGroups.end() )
            {
              //If it is part of a group, make sure another backend requirement from the same group has not already been activated.
              if (chosenReqsFromGroups[group] == ""none"")
              {
                //If not, then this this specific backend requirement is now the active one within its group.
                chosenReqsFromGroups[group] = key.first;
              }
              else //This backend requirement is not the first from its group to be resolved.
              {
                str errmsg = ""Cannot resolve backend requirement in group "" + group + "":"";
                errmsg +=  ""\\nFunction "" + myName + "" in "" + myOrigin + "" has already had backend ""
                           ""\\nrequirement "" + chosenReqsFromGroups[group] + "" from the same group filled."";
                utils_error().raise(LOCAL_INFO,errmsg);
              }
            }
            else //This backend requirement is part of group that was not declared.
            {
              str errmsg = ""Cannot resolve backend requirement in group "" + group + "":"";
              errmsg +=  ""\\nThis group has not been declared.  Please add""
                         ""\\n BACKEND_GROUP(""+group+"")""
                         ""\\nTo the rollcall declaration of "" + myName + "" in "" + myOrigin + ""."";
              utils_error().raise(LOCAL_INFO,errmsg);
            }
          }

        }

        else //The proposed backend function is not an acceptable fit for this requirement.
        {
          str errmsg = ""Cannot resolve backend requirement:"";
          errmsg +=  ""\\nBackend capability "" + key.first + "" with type "" + key.second +
                     ""\\nrequired by function "" + myName + "" in "" + myOrigin + "" is not permitted""
                     ""\\nto use "" + proposal.first + "", version "" + proposal.second + ""."";
          utils_error().raise(LOCAL_INFO,errmsg);
        }

      }

      else //The proposed backend function does not fulfill any known requirement of the module function.
      {
        str errmsg = ""Cannot resolve backend requirement:"";
        errmsg +=  ""\\nFunction "" + myName + "" in "" + myOrigin + "" does not require""
                   ""\\nbackend capability "" + key.first + "" with type "" + key.second + ""."";
        utils_error().raise(LOCAL_INFO,errmsg);
      }

    }

    /// Construct the list of known models only if it doesn't yet exist
    void module_functor_common::fill_activeModelFlags()
    {
      // Construct the list of known models only if it doesn't yet exist
      if (activeModelFlags.empty())
      {
        // First get all the explicitly allowed models.
        for (auto it = allowedModels.begin(); it != allowedModels.end(); ++it) { activeModelFlags[*it] = false; }
        // Next get all the models in groups
        for (auto it = modelGroups.begin(); it != modelGroups.end(); ++it)
        { for (auto jt = it->second.begin(); jt != it->second.end(); ++jt) { activeModelFlags[*jt] = false; } }
        // Next get all the models mentioned in conditional dependencies and backend reqs
        for (auto it = myModelConditionalDependencies.begin(); it != myModelConditionalDependencies.end(); ++it) { activeModelFlags[it->first] = false; }
        for (auto it = myModelConditionalBackendReqs.begin();  it != myModelConditionalBackendReqs.end();  ++it) { activeModelFlags[it->first] = false; }
      }
    }

    /// Notify the functor that a certain model is being scanned, so that it can activate its dependencies and backend reqs accordingly.
    void module_functor_common::notifyOfModel(str model)
    {
      // If activeModels hasn't been populated yet, make sure it is.
      fill_activeModelFlags();

      // Now activate the flags for the models that are being used.
      for (auto it = activeModelFlags.begin(); it != activeModelFlags.end(); ++it)
      {
        str activation_candidate = it->first;
        if (myClaw->model_exists(activation_candidate))
        {
          if (myClaw->downstream_of(model, activation_candidate))
          {
            // Found an activation candidate that the model being scanned can be cast to.
            // Assume for now that the candidate will indeed be activated.
            it->second = true;
            // Compare with models that have already been activated, to avoid activating multiple models of the same lineage.
            for (auto jt = activeModelFlags.begin(); jt != activeModelFlags.end(); ++jt)
            {
              str active_model = jt->first;
              if (activation_candidate != active_model and myClaw->model_exists(active_model) and jt->second)
              {
                // If the already active model can be upcast to the activation candidate, abort the activiation of the candidate.
                if (myClaw->downstream_of(active_model, activation_candidate)) it->second = false;
                // If the candidate can be upcast to the already active model, activate the candidate instead of the already active model.
                if (myClaw->downstream_of(activation_candidate, active_model)) jt->second = false;
                if (verbose)
                {
                  cout << ""model: "" << model << "" "" << ""model to be activated: "" << activation_candidate << ""("" << it->second << "") active model: "" << active_model << ""("" << jt->second << "")"" << endl;
                  cout << ""active model lives below:"" << myClaw->downstream_of(active_model, activation_candidate) << endl;
                  cout << ""activation candidate lives below:"" << myClaw->downstream_of(activation_candidate, active_model) << endl;
                }
              }
            }
            if (verbose) cout << ""Activate candidate "" << activation_candidate << ""?"" << it->second << endl;
          }
        }
      }

      // If this model fits any conditional dependencies (or descended from one that can be interpreted as one that fits any), then activate them.
      std::set<sspair> deps_to_activate = model_conditional_dependencies(model);
      for (std::set<sspair>::iterator it = deps_to_activate.begin() ; it != deps_to_activate.end(); ++it)
      {
        myDependencies.insert(*it);
      }
      // If this model fits any conditional backend requirements (or descended from one that can be interpreted as one that fits any), then activate them.
      std::set<sspair> backend_reqs_to_activate = model_conditional_backend_reqs(model);
      if (verbose) cout << ""model: "" << model << endl;
      for (std::set<sspair>::iterator it = backend_reqs_to_activate.begin() ; it != backend_reqs_to_activate.end(); ++it)
      {
        if (verbose) cout << ""req: "" << it->first << "" "" << it->second << endl;
        myResolvableBackendReqs.insert(*it);
        myGroupedBackendReqs[backendreq_groups[*it]].insert(*it);
      }
    }

    // Initialise the memory of this functor.
    void module_functor_common::init_memory()
    {
      int n = (iRunNested ? globlMaxThreads : 1);
      // Reserve enough space to hold as many timing points and recalculation flags as there are slots (threads) allowed
      if(start==NULL)
      {
        #pragma omp critical(module_functor_common_init_memory_start)
        {
          if(start==NULL) start = new std::chrono::time_point<std::chrono::system_clock>[n];
        }
      }
      if(end==NULL)
      {
        #pragma omp critical(module_functor_common_init_memory_end)
        {
          if(end==NULL) end = new std::chrono::time_point<std::chrono::system_clock>[n];
        }
      }
      if(needs_recalculating==NULL)
      {
        #pragma omp critical(module_functor_common_init_memory_needs_recalculating)
        {
          if(needs_recalculating==NULL)
          {
            needs_recalculating = new bool[n];
            std::fill(needs_recalculating, needs_recalculating+n, true);
          }
        }
      }
      if(already_printed==NULL)
      {
        #pragma omp critical(module_functor_common_init_memory_already_printed)
        {
          if(already_printed==NULL)
          {
            already_printed = new bool[n];
            std::fill(already_printed, already_printed+n, false);
          }
        }
      }
      if(already_printed_timing==NULL)
      {
        #pragma omp critical(module_functor_common_init_memory_already_printed_timing)
        {
          if(already_printed_timing==NULL)
          {
            already_printed_timing = new bool[n];
            std::fill(already_printed_timing, already_printed_timing+n, false);
          }
        }
      }
    }

    /// Do pre-calculate timing things
    void module_functor_common::startTiming(int thread_num)
    {
      start[thread_num] = std::chrono::system_clock::now();
    }

    /// Do post-calculate timing things
    void module_functor_common::finishTiming(int thread_num)
    {
      end[thread_num] = std::chrono::system_clock::now();
      std::chrono::duration<double> runtime = end[thread_num] - start[thread_num];
      #pragma omp critical(module_functor_common_finishTiming)
      {
        runtime_average = runtime_average*(1-fadeRate) + fadeRate*runtime.count();
        pInvalidation = pInvalidation*(1-fadeRate) + fadeRate*FUNCTORS_BASE_INVALIDATION_RATE;
      }
      needs_recalculating[thread_num] = false;
    }

  /// Class methods for actual module functors for TYPE=void.

    /// Constructor
    module_functor<void>::module_functor(void (*inputFunction)(),
                                         str func_name,
                                         str func_capability,
                                         str result_type,
                                         str origin_name,
                                         Models::ModelFunctorClaw &claw)
    : module_functor_common(func_name, func_capability, result_type, origin_name, claw),
      myFunction (inputFunction) {}

    /// Calculate method
    /// The ""void"" specialisation can potentially manage loops,
    /// so there are some extra switches in here to let the signal
    /// handler know that it needs to run in threadsafe mode during
    /// execution of this functor.
    void module_functor<void>::calculate()
    {
      if (myStatus == -3)                          // Do an explicit status check to hold standalone writers' hands
      {
        std::ostringstream ss;
        ss << ""Sorry, the function "" << origin() << ""::"" << name()
         << "" cannot be used"" << endl << ""because it requires classes from a backend that you do not have installed.""
         << endl << ""Missing backends: "";
        for (auto it = missing_backends.begin(); it != missing_backends.end(); ++it) ss << endl << ""  "" << *it;
        backend_error().raise(LOCAL_INFO, ss.str());
      }
      else if (myStatus == -4)
      {
        std::ostringstream ss;
        ss << ""Sorry, the backend initialisation function "" << name()
        << "" cannot be used"" << endl << ""because it initialises a backend that you do not have installed!"";
        backend_error().raise(LOCAL_INFO, ss.str());
      }
      boost::io::ios_flags_saver ifs(cout);        // Don't allow module functions to change the output precision of cout
      int thread_num = omp_get_thread_num();
      fill_activeModelFlags();                     // If activeModels hasn't been populated yet, make sure it is.
      init_memory();                               // Init memory if this is the first run through.
      if (needs_recalculating[thread_num])
      {
        entering_multithreaded_region();

        logger().entering_module(myLogTag);
        this->startTiming(thread_num);
        try
        {
          this->myFunction();
        }
        catch (invalid_point_exception& e)
        {
          if (not point_exception_raised) acknowledgeInvalidation(e);
          if (omp_get_level()==0)                  // If not in an OpenMP parallel block, throw onwards
          {
            this->finishTiming(thread_num);
            leaving_multithreaded_region();
            throw(e);
          }
        }
        this->finishTiming(thread_num);
        logger().leaving_module();
        leaving_multithreaded_region();
      }
    }

    /// Blank print methods
    #ifndef NO_PRINTERS
      void module_functor<void>::print(Printers::BasePrinter*, const int, int) {}
      void module_functor<void>::print(Printers::BasePrinter*, const int) {}
    #endif

    /// @{ Model functor class method definitions

    /// Constructor
    model_functor::model_functor(void (*inputFunction)(ModelParameters &),
                                 str func_name,
                                 str func_capability,
                                 str result_type,
                                 str origin_name,
                                 Models::ModelFunctorClaw &claw)
    : module_functor<ModelParameters>(inputFunction, func_name, func_capability, result_type, origin_name, claw)
    {
      init_memory();
    }

    /// Function for adding a new parameter to the map inside the ModelParameters object
    void model_functor::addParameter(str parname)
    {
      myValue->_definePar(parname);
    }

    /// Function for handing over parameter identities to another model_functor
    void model_functor::donateParameters(model_functor &receiver)
    {
      for(std::map<std::string,double>::const_iterator it = myValue->begin();
          it != myValue->end();
          it++)
      {
        receiver.addParameter(it->first);
      }
    }

    /// @}

    /// @{ Primary model functor class method definitions

    /// Constructor
    primary_model_functor::primary_model_functor(void (*inputFunction)(ModelParameters &),
                                                 str func_name,
                                                 str func_capability,
                                                 str result_type,
                                                 str origin_name,
                                                 Models::ModelFunctorClaw &claw)
    : model_functor(inputFunction, func_name, func_capability, result_type, origin_name, claw) {}

    /// Functor contents raw pointer ""get"" function
    /// Returns a raw pointer to myValue, so that the contents may be
    /// modified (intended for setting parameter values in primary
    /// ModelParameters objects)
    ModelParameters* primary_model_functor::getcontentsPtr()
    {
      return myValue;
    }

    /// @}

}
",16138,True,3133.215607104524,median
"/**
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

#include <algorithm>
#include <assert.h>
#include <exception>
#include <fcntl.h>
#include <fstream>
#include <functional>
#include <list>
#include <memory>
#include <stdlib.h>
#include <sys/stat.h>
#include <unordered_set>

#ifdef _MSC_VER
// TODO: Rewrite open/write/close with C/C++ standards. But it works for now.
#include <io.h>
#define open _open
#define write _write
#define close _close
#define fstat _fstat64i32
#define stat _stat64i32
#define O_CREAT _O_CREAT
#define O_TRUNC _O_TRUNC
#define O_WRONLY _O_WRONLY
#endif

#include ""Debug.h""
#include ""DexClass.h""
#include ""DexOutput.h""
#include ""DexUtil.h""
#include ""IRCode.h""
#include ""Pass.h""
#include ""Resolver.h""
#include ""Sha1.h""
#include ""Trace.h""
#include ""Walkers.h""
#include ""WorkQueue.h""

/*
 * For adler32...
 */
#include <zlib.h>

template<class T, class U>
class CustomSort {
  private:
    const std::unordered_map<const T*, unsigned int>& m_map;
    U m_cmp;

  public:
    CustomSort(const std::unordered_map<const T*, unsigned int>& input_map, U cmp)
    : m_map(input_map) {
      m_cmp = cmp;
    }

    bool operator()(const T* a, const T* b) const {
      bool a_in = m_map.count(a);
      bool b_in = m_map.count(b);
      if (!a_in && !b_in) {
        return m_cmp(a,b);
      } else if (a_in && b_in) {
        auto const a_idx = m_map.at(a);
        auto const b_idx = m_map.at(b);
        if (a_idx != b_idx) {
          return a_idx < b_idx;
        } else {
          return m_cmp(a,b);
        }
      } else if (a_in) {
        return true;
      } else {
        return false;
      }
    }
};

GatheredTypes::GatheredTypes(DexClasses* classes)
  : m_classes(classes)
{
  // ensure that the string id table contains the empty string, which is used
  // for the DexPosition mapping
  m_lstring.push_back(DexString::make_string(""""));

  // build maps for the different custom sorting options
  build_cls_load_map();
  build_cls_map();
  build_method_map();

  gather_components();
}

std::unordered_set<DexString*> GatheredTypes::index_type_names() {
  std::unordered_set<DexString*> type_names;
  for (auto it = m_ltype.begin(); it != m_ltype.end(); ++it) {
    type_names.insert((*it)->get_name());
  }
  return type_names;
}

std::vector<DexString*> GatheredTypes::get_cls_order_dexstring_emitlist() {
  return get_dexstring_emitlist(CustomSort<DexString, cmp_dstring>(
        m_cls_load_strings,
        compare_dexstrings));
}

std::vector<DexString*> GatheredTypes::keep_cls_strings_together_emitlist() {
  return get_dexstring_emitlist(CustomSort<DexString, cmp_dstring>(
        m_cls_strings,
        compare_dexstrings));
}

std::vector<DexMethod*> GatheredTypes::get_dexmethod_emitlist() {
  std::vector<DexMethod*> methlist;
  for (auto cls : *m_classes) {
    TRACE(OPUT, 3, ""[dexmethod_emitlist][class] %s\\n"", cls->c_str());
    auto const& dmethods = cls->get_dmethods();
    auto const& vmethods = cls->get_vmethods();
    if (traceEnabled(OPUT, 3)) {
      for (const auto &dmeth : dmethods) {
        TRACE(OPUT, 3, ""  [dexmethod_emitlist][dmethod] %s\\n"", dmeth->c_str());
      }
      for (const auto &vmeth : vmethods) {
        TRACE(OPUT, 3, ""  [dexmethod_emitlist][dmethod] %s\\n"", vmeth->c_str());
      }
    }
    methlist.insert(methlist.end(), dmethods.begin(), dmethods.end());
    methlist.insert(methlist.end(), vmethods.begin(), vmethods.end());
  }
  return methlist;
}

void GatheredTypes::sort_dexmethod_emitlist_default_order(
    std::vector<DexMethod*>& lmeth) {
  std::stable_sort(lmeth.begin(), lmeth.end(), compare_dexmethods);
}

void GatheredTypes::sort_dexmethod_emitlist_cls_order(
    std::vector<DexMethod*>& lmeth) {
  std::stable_sort(lmeth.begin(), lmeth.end(),
                   CustomSort<DexMethod, cmp_dmethod>(m_methods_in_cls_order,
                                                      compare_dexmethods));
}

void GatheredTypes::sort_dexmethod_emitlist_profiled_order(
    std::vector<DexMethod*>& lmeth) {
  std::stable_sort(lmeth.begin(),
                   lmeth.end(),
                   dexmethods_profiled_comparator(&m_method_to_weight));
}

void GatheredTypes::sort_dexmethod_emitlist_clinit_order(
    std::vector<DexMethod*>& lmeth) {
  std::stable_sort(lmeth.begin(), lmeth.end(),
                   [](const DexMethod* a, const DexMethod* b) {
                     if (is_clinit(a) && !is_clinit(b)) {
                       return true;
                     } else {
                       return false;
                     }
                   });
}

DexOutputIdx* GatheredTypes::get_dodx(const uint8_t* base) {
  /*
   * These are symbol table indices.  Symbols which are used
   * should be bunched together.  We will pass a different
   * sort routine here to optimize.  Doing so does violate
   * the dex spec.  However, that aspect of the spec is only
   * used in certain scenarios.  For strings, types, and protos
   * that aspect of the spec has no runtime dependency.  For
   * methods and fields, only dexes with annotations have a
   * dependency on ordering.
   */
  dexstring_to_idx* string = get_string_index();
  dextype_to_idx* type = get_type_index();
  dexproto_to_idx* proto = get_proto_index();
  dexfield_to_idx* field = get_field_index();
  dexmethod_to_idx* method = get_method_index();
  return new DexOutputIdx(string, type, proto, field, method, base);
}

dexstring_to_idx* GatheredTypes::get_string_index(cmp_dstring cmp) {
  std::sort(m_lstring.begin(), m_lstring.end(), cmp);
  dexstring_to_idx* sidx = new dexstring_to_idx();
  uint32_t idx = 0;
  for (auto it = m_lstring.begin(); it != m_lstring.end(); it++) {
    sidx->insert(std::make_pair(*it, idx++));
  }
  return sidx;
}

dextype_to_idx* GatheredTypes::get_type_index(cmp_dtype cmp) {
  std::sort(m_ltype.begin(), m_ltype.end(), cmp);
  dextype_to_idx* sidx = new dextype_to_idx();
  uint32_t idx = 0;
  for (auto it = m_ltype.begin(); it != m_ltype.end(); it++) {
    sidx->insert(std::make_pair(*it, idx++));
  }
  return sidx;
}

dexfield_to_idx* GatheredTypes::get_field_index(cmp_dfield cmp) {
  std::sort(m_lfield.begin(), m_lfield.end(), cmp);
  dexfield_to_idx* sidx = new dexfield_to_idx();
  uint32_t idx = 0;
  for (auto it = m_lfield.begin(); it != m_lfield.end(); it++) {
    sidx->insert(std::make_pair(*it, idx++));
  }
  return sidx;
}

dexmethod_to_idx* GatheredTypes::get_method_index(cmp_dmethod cmp) {
  std::sort(m_lmethod.begin(), m_lmethod.end(), cmp);
  dexmethod_to_idx* sidx = new dexmethod_to_idx();
  uint32_t idx = 0;
  for (auto it = m_lmethod.begin(); it != m_lmethod.end(); it++) {
    sidx->insert(std::make_pair(*it, idx++));
  }
  return sidx;
}

dexproto_to_idx* GatheredTypes::get_proto_index(cmp_dproto cmp) {
  std::vector<DexProto*> protos;
  for (auto const& m : m_lmethod) {
    protos.push_back(m->get_proto());
  }
  std::sort(protos.begin(), protos.end());
  protos.erase(std::unique(protos.begin(), protos.end()), protos.end());
  std::sort(protos.begin(), protos.end(), cmp);
  dexproto_to_idx* sidx = new dexproto_to_idx();
  uint32_t idx = 0;
  for (auto const& proto : protos) {
    sidx->insert(std::make_pair(proto, idx++));
  }
  return sidx;
}

void GatheredTypes::build_cls_load_map() {
  unsigned int index = 0;
  int type_strings = 0;
  int init_strings = 0;
  int total_strings = 0;
  for (const auto& cls : *m_classes) {
    // gather type first, assuming class load will check all components of a class first
    std::vector<DexType*> cls_types;
    cls->gather_types(cls_types);
    for (const auto& t : cls_types) {
      if (!m_cls_load_strings.count(t->get_name())) {
        m_cls_load_strings[t->get_name()] = index;
        index++;
        type_strings++;
      }
    }
    // now add in any strings found in <clinit>
    // since they are likely to be accessed during class load
    for (const auto& m: cls->get_dmethods()) {
      if (is_clinit(m)) {
        std::vector<DexString*> method_strings;
        m->gather_strings(method_strings);
        for (const auto& s : method_strings) {
          if (!m_cls_load_strings.count(s)) {
            m_cls_load_strings[s] = index;
            index++;
            init_strings++;
          }
        }
      }
    }
  }
  total_strings += type_strings + init_strings;
  for (const auto& cls : *m_classes) {
    // now add all other strings in class order. This way we get some
    // locality if a random class in a dex is loaded and then executes some methods
    std::vector<const DexClass*> v;
    v.push_back(cls);
    walk::methods(v, [&](DexMethod* m) {
      std::vector<DexString*> method_strings;
      m->gather_strings(method_strings);
      for (const auto& s : method_strings) {
        if (!m_cls_load_strings.count(s)) {
          m_cls_load_strings[s] = index;
          index++;
          total_strings++;
        }
      }
    });
  }
  TRACE(CUSTOMSORT, 1, ""found %d strings from types, %d from strings in init methods, %d total strings\\n"",
      type_strings,
      init_strings,
      total_strings);
}

void GatheredTypes::build_cls_map() {
  int index = 0;
  for (const auto& cls : *m_classes) {
      if (!m_cls_strings.count(cls->get_name())) {
        m_cls_strings[cls->get_name()] = index++;
      }
  }
}

void GatheredTypes::build_method_map() {
  unsigned int index = 0;
  for (const auto& cls : *m_classes) {
    for (const auto& m : cls->get_dmethods()) {
      if (!m_methods_in_cls_order.count(m)) {
        m_methods_in_cls_order[m] = index;
      }
    }
    for (const auto& m : cls->get_vmethods()) {
      if (!m_methods_in_cls_order.count(m)) {
        m_methods_in_cls_order[m] = index;
      }
    }
    index++;
  }
}

void GatheredTypes::gather_components() {
  // Gather references reachable from each class.
  for (auto const& cls : *m_classes) {
    cls->gather_strings(m_lstring);
    cls->gather_types(m_ltype);
    cls->gather_fields(m_lfield);
    cls->gather_methods(m_lmethod);
  }

  // Remove duplicates to speed up the later loops.
  sort_unique(m_lstring);
  sort_unique(m_ltype);

  // Gather types and strings needed for field and method refs.
  sort_unique(m_lmethod);
  for (auto meth : m_lmethod) {
    meth->gather_types_shallow(m_ltype);
    meth->gather_strings_shallow(m_lstring);
  }

  sort_unique(m_lfield);
  for (auto field : m_lfield) {
    field->gather_types_shallow(m_ltype);
    field->gather_strings_shallow(m_lstring);
  }

  // Gather strings needed for each type.
  sort_unique(m_ltype);
  for (auto type : m_ltype) {
    if (type) m_lstring.push_back(type->get_name());
  }

  sort_unique(m_lstring);
}

constexpr uint32_t k_max_dex_size = 16 * 1024 * 1024;
typedef std::map<DexAnnotation*, uint32_t> annomap_t;
typedef std::map<DexAnnotationSet*, uint32_t> asetmap_t;
typedef std::map<ParamAnnotations*, uint32_t> xrefmap_t;
typedef std::map<DexAnnotationDirectory*, uint32_t> adirmap_t;

class DexOutput {
public:
  dex_stats_t m_stats;
 private:
  DexClasses* m_classes;
  DexOutputIdx* dodx;
  GatheredTypes* m_gtypes;
  uint8_t* m_output;
  uint32_t m_offset;
  const char* m_filename;
  size_t m_store_number;
  size_t m_dex_number;
  bool m_emit_debug_line_info;
  PositionMapper* m_pos_mapper;
  std::string m_method_mapping_filename;
  std::string m_class_mapping_filename;
  std::string m_pg_mapping_filename;
  std::string m_bytecode_offset_filename;
  std::unordered_map<DexTypeList*, uint32_t> m_tl_emit_offsets;
  std::vector<std::pair<DexCode*, dex_code_item*>> m_code_item_emits;
  std::unordered_map<DexMethod*, uint64_t>* m_method_to_id;
  std::unordered_map<DexCode*, std::vector<DebugLineItem>>* m_code_debug_lines;
  std::vector<std::pair<std::string, uint32_t>> m_method_bytecode_offsets;
  std::unordered_map<DexClass*, uint32_t> m_cdi_offsets;
  std::unordered_map<DexClass*, uint32_t> m_static_values;
  dex_header hdr;
  std::vector<dex_map_item> m_map_items;
  LocatorIndex* m_locator_index;
  bool m_emit_name_based_locators;
  const ConfigFiles& m_config_files;

  void insert_map_item(uint16_t typeidx, uint32_t size, uint32_t offset);
  void generate_string_data(SortMode mode = SortMode::DEFAULT);
  void generate_type_data();
  void generate_proto_data();
  void generate_field_data();
  void generate_method_data();
  void generate_class_data();
  void generate_class_data_items();

  // Sort code according to a sequence of sorting modes, ordered by precedence.
  // e.g. passing {SortMode::CLINIT_FIRST, SortMode::CLASS_ORDER} means that
  // clinit methods come before all other methods, and remaining methods are sorted
  // by class.
  void generate_code_items(const std::vector<SortMode>& modes);
  void generate_static_values();
  void unique_annotations(annomap_t& annomap,
                          std::vector<DexAnnotation*>& annolist);
  void unique_asets(annomap_t& annomap,
                    asetmap_t& asetmap,
                    std::vector<DexAnnotationSet*>& asetlist);
  void unique_xrefs(asetmap_t& asetmap,
                    xrefmap_t& xrefmap,
                    std::vector<ParamAnnotations*>& xreflist);
  void unique_adirs(asetmap_t& asetmap,
                    xrefmap_t& xrefmap,
                    adirmap_t& adirmap,
                    std::vector<DexAnnotationDirectory*>& adirlist);
  void generate_annotations();
  void generate_debug_items();
  void generate_typelist_data();
  void generate_map();
  void finalize_header();
  void init_header_offsets();
  void write_symbol_files();
  void align_output() { m_offset = (m_offset + 3) & ~3; }
  void emit_locator(Locator locator);
  void emit_name_based_locators();
  std::unique_ptr<Locator> locator_for_descriptor(
      const std::unordered_set<DexString*>& type_names, DexString* descriptor);

 public:
  DexOutput(const char* path,
            DexClasses* classes,
            LocatorIndex* locator_index,
            bool emit_name_based_locators,
            size_t store_number,
            size_t dex_number,
            bool emit_debug_line_info,
            const ConfigFiles& config_files,
            PositionMapper* pos_mapper,
            std::unordered_map<DexMethod*, uint64_t>* method_to_id,
            std::unordered_map<DexCode*, std::vector<DebugLineItem>>*
                code_debug_lines,
            const std::string& method_mapping_path,
            const std::string& class_mapping_path,
            const std::string& pg_mapping_path,
            const std::string& bytecode_offset_path);
  ~DexOutput();
  void prepare(SortMode string_mode,
               const std::vector<SortMode>& code_mode,
               const ConfigFiles& cfg);
  void write();
};

DexOutput::DexOutput(
    const char* path,
    DexClasses* classes,
    LocatorIndex* locator_index,
    bool emit_name_based_locators,
    size_t store_number,
    size_t dex_number,
    bool emit_debug_line_info,
    const ConfigFiles& config_files,
    PositionMapper* pos_mapper,
    std::unordered_map<DexMethod*, uint64_t>* method_to_id,
    std::unordered_map<DexCode*, std::vector<DebugLineItem>>* code_debug_lines,
    const std::string& method_mapping_filename,
    const std::string& class_mapping_filename,
    const std::string& pg_mapping_filename,
    const std::string& bytecode_offset_filename)
    : m_config_files(config_files) {
  m_classes = classes;
  m_output = (uint8_t*)malloc(k_max_dex_size);
  memset(m_output, 0, k_max_dex_size);
  m_offset = 0;
  m_gtypes = new GatheredTypes(classes);
  dodx = m_gtypes->get_dodx(m_output);
  m_filename = path;
  m_pos_mapper = pos_mapper;
  m_method_to_id = method_to_id;
  m_code_debug_lines = code_debug_lines;
  m_method_mapping_filename = method_mapping_filename;
  m_class_mapping_filename = class_mapping_filename;
  m_pg_mapping_filename = pg_mapping_filename;
  m_bytecode_offset_filename = bytecode_offset_filename;
  m_store_number = store_number;
  m_dex_number = dex_number;
  m_locator_index = locator_index;
  m_emit_name_based_locators = emit_name_based_locators;
  m_emit_debug_line_info = emit_debug_line_info;
}

DexOutput::~DexOutput() {
  delete m_gtypes;
  delete dodx;
  free(m_output);
}

void DexOutput::insert_map_item(uint16_t maptype,
                                uint32_t size,
                                uint32_t offset) {
  if (size == 0) return;
  dex_map_item item{};
  item.type = maptype;
  item.size = size;
  item.offset = offset;
  m_map_items.emplace_back(item);
}

void DexOutput::emit_locator(Locator locator) {
  char buf[Locator::encoded_max];
  size_t locator_length = locator.encode(buf);
  write_uleb128(m_output + m_offset, (uint32_t) locator_length);
  m_offset += uleb128_encoding_size((uint32_t) locator_length);
  memcpy(m_output + m_offset, buf, locator_length + 1);
  m_offset += locator_length + 1;
}

std::unique_ptr<Locator>
DexOutput::locator_for_descriptor(
  const std::unordered_set<DexString*>& type_names,
  DexString* descriptor)
{
  LocatorIndex* locator_index = m_locator_index;
  if (locator_index != nullptr) {
    auto locator_it = locator_index->find(descriptor);
    if (locator_it != locator_index->end()) {
      // This string is the name of a type we define in one of our
      // dex files.
      return std::unique_ptr<Locator>(new Locator(locator_it->second));
    }

    if (type_names.count(descriptor)) {
      // If we're emitting an array name, see whether the element
      // type is one of ours; if so, emit a locator for that type.
      const char* s = descriptor->c_str();
      if (s[0] == '[') {
        while (*s == '[') ++s;
        DexString* elementDescriptor = DexString::get_string(s);
        if (elementDescriptor != nullptr) {
          locator_it = locator_index->find(elementDescriptor);
          if (locator_it != locator_index->end()) {
            return std::unique_ptr<Locator>(new Locator(locator_it->second));
          }
        }
      }

      // We have the name of a type, but it's not a type we define.
      // Emit the special locator that indicates we should look in the
      // system classloader.
      return std::unique_ptr<Locator>(new Locator(Locator::make(0, 0, 0)));
    }
  }

  return nullptr;
}

void DexOutput::generate_string_data(SortMode mode) {
  /*
   * This is a index to position within the string data.  There
   * is no specific ordering specified here for the dex spec.
   * The optimized sort here would be different than the one
   * for the symbol table.  The symbol table should be packed
   * for strings that are used by the opcode const-string.  Whereas
   * this should be ordered by access for page-cache efficiency.
   */
  std::vector<DexString*> string_order;
  if (mode == SortMode::CLASS_ORDER) {
    TRACE(CUSTOMSORT, 2, ""using class order for string pool sorting\\n"");
    string_order = m_gtypes->get_cls_order_dexstring_emitlist();
  } else if (mode == SortMode::CLASS_STRINGS) {
    TRACE(CUSTOMSORT, 2, ""using class names pack for string pool sorting\\n"");
    string_order = m_gtypes->keep_cls_strings_together_emitlist();
  } else {
    TRACE(CUSTOMSORT, 2, ""using default string pool sorting\\n"");
    string_order = m_gtypes->get_dexstring_emitlist();
  }
  dex_string_id* stringids = (dex_string_id*)(m_output + hdr.string_ids_off);

  std::unordered_set<DexString*> type_names = m_gtypes->index_type_names();
  unsigned locator_size = 0;

  // If we're generating locator strings, we need to include them in
  // the total count of strings in this section.
  size_t locators = 0;
  for (DexString* str : string_order) {
    if (locator_for_descriptor(type_names, str)) {
      ++locators;
    }
  }

  if (m_emit_name_based_locators) {
    locators += 2;
    always_assert(dodx->stringidx(DexString::make_string("""")) == 0);
  }

  size_t nrstr = string_order.size() + locators;

  insert_map_item(TYPE_STRING_DATA_ITEM, (uint32_t)nrstr, m_offset);
  for (DexString* str : string_order) {
    // Emit lookup acceleration string if requested
    std::unique_ptr<Locator> locator = locator_for_descriptor(type_names, str);
    if (locator) {
      unsigned orig_offset = m_offset;
      emit_locator(*locator);
      locator_size += m_offset - orig_offset;
    }

    // Emit name-based lookup acceleration information for string with index 0
    // if requested
    uint32_t idx = dodx->stringidx(str);
    if (idx == 0 && m_emit_name_based_locators) {
      always_assert(!locator);
      unsigned orig_offset = m_offset;
      emit_name_based_locators();
      locator_size += m_offset - orig_offset;
    }

    // Emit the string itself
    TRACE(CUSTOMSORT, 3, ""str emit %s\\n"", SHOW(str));
    stringids[idx].offset = m_offset;
    str->encode(m_output + m_offset);
    m_offset += str->get_entry_size();
    m_stats.num_strings++;
  }

  if (m_locator_index != nullptr || m_emit_name_based_locators) {
    TRACE(LOC, 2, ""Used %u bytes for %u locator strings\\n"", locator_size,
          locators);
  }
}

void DexOutput::emit_name_based_locators() {
  uint global_class_indices_first = Locator::invalid_global_class_index;
  uint global_class_indices_last = Locator::invalid_global_class_index;

  // We decode all class names --- to find the first and last renamed one,
  // and also check that all renamed names are indeed in the right place.
  dex_class_def* cdefs = (dex_class_def*)(m_output + hdr.class_defs_off);
  for (uint32_t i = 0; i < hdr.class_defs_size; i++) {
    DexClass* clz = m_classes->at(i);
    const char* str = clz->get_name()->c_str();
    uint32_t global_clsnr = Locator::decodeGlobalClassIndex(str);
    TRACE(LOC, 3, ""Class %s has global class index %u\\n"", str, global_clsnr);
    if (global_clsnr != Locator::invalid_global_class_index) {
      global_class_indices_last = global_clsnr;
      if (global_class_indices_first == Locator::invalid_global_class_index) {
        // First time we come across a properly renamed class - let's store the
        // global_class_indices_first.
        // Note that the first class in this dex might not actually be a renamed
        // class. But we want our class loaders to be able to determine a the
        // actual class table index of a class by simply subtracting a number.
        // So we set global_class_indices_first to be the global class index of
        // the actual first class the dex, which was the class i iterations
        // earlier.
        global_class_indices_first = global_clsnr - i;
      } else {
        always_assert_log(
            global_clsnr == global_class_indices_first + i,
            ""Out of order global class index: got %u, expected %u\\n"",
            global_clsnr, global_class_indices_first + i);
      }
    }
  }

  TRACE(LOC, 2,
        ""Global class indices for store %u, dex %u: first %u, last %u\\n"",
        m_store_number, m_dex_number, global_class_indices_first,
        global_class_indices_last);

  if (global_class_indices_first != Locator::invalid_global_class_index) {
    // Emit two strings:

    // 1. Locator for the last renamed class in this Dex
    emit_locator(
        Locator(m_store_number, m_dex_number + 1, global_class_indices_last));

    // 2. Locator for what would be the first class in this Dex
    //    (see comment for computation of global_class_indices_first above)
    emit_locator(
        Locator(m_store_number, m_dex_number + 1, global_class_indices_first));
  } else {
    // Dummy locators
    emit_locator(Locator(0, 0, 0));
    emit_locator(Locator(0, 0, 0));
  }
}

void DexOutput::generate_type_data() {
  // Check that we don't have more than 2 ^ 15 type refs in one dex.
  //
  // NOTE: This is required because of a bug found in Android up to 7.
  constexpr const size_t kMaxTypeRefs = 1 << 15;
  always_assert_log(
      dodx->type_to_idx().size() < kMaxTypeRefs,
      ""Trying to encode too many type refs in dex %lu: %lu (limit: %lu).\\n""
      ""NOTE: Please check InterDexPass config flags and set: ""
      ""`type_refs_limit: 32768`"",
      m_dex_number,
      dodx->type_to_idx().size(),
      kMaxTypeRefs);

  dex_type_id* typeids = (dex_type_id*)(m_output + hdr.type_ids_off);
  for (auto& p : dodx->type_to_idx()) {
    auto t = p.first;
    auto idx = p.second;
    typeids[idx].string_idx = dodx->stringidx(t->get_name());
    m_stats.num_types++;
  }
}

void DexOutput::generate_typelist_data() {
  std::vector<DexTypeList*> typel;
  for (auto& it : dodx->proto_to_idx()) {
    auto proto = it.first;
    typel.push_back(proto->get_args());
  }
  for (uint32_t i = 0; i < hdr.class_defs_size; i++) {
    DexClass* clz = m_classes->at(i);
    typel.push_back(clz->get_interfaces());
  }
  sort_unique(typel, compare_dextypelists);
  align_output();
  uint32_t tl_start = m_offset;
  size_t num_tls = 0;
  for (DexTypeList* tl : typel) {
    if (tl->get_type_list().size() == 0) {
      m_tl_emit_offsets[tl] = 0;
      continue;
    }
    ++num_tls;
    align_output();
    m_tl_emit_offsets[tl] = m_offset;
    int size = tl->encode(dodx, (uint32_t*)(m_output + m_offset));
    m_offset += size;
    m_stats.num_type_lists++;
  }
  insert_map_item(TYPE_TYPE_LIST, (uint32_t) num_tls, tl_start);
}

void DexOutput::generate_proto_data() {
  auto protoids = (dex_proto_id*)(m_output + hdr.proto_ids_off);

  for (auto& it : dodx->proto_to_idx()) {
    auto proto = it.first;
    auto idx = it.second;
    protoids[idx].shortyidx = dodx->stringidx(proto->get_shorty());
    protoids[idx].rtypeidx = dodx->typeidx(proto->get_rtype());
    protoids[idx].param_off = m_tl_emit_offsets.at(proto->get_args());
    m_stats.num_protos++;
  }
}

void DexOutput::generate_field_data() {
  auto fieldids = (dex_field_id*)(m_output + hdr.field_ids_off);
  for (auto& it : dodx->field_to_idx()) {
    auto field = it.first;
    auto idx = it.second;
    fieldids[idx].classidx = dodx->typeidx(field->get_class());
    fieldids[idx].typeidx = dodx->typeidx(field->get_type());
    fieldids[idx].nameidx = dodx->stringidx(field->get_name());
    m_stats.num_field_refs++;

  }
}

void DexOutput::generate_method_data() {
  constexpr size_t kMaxMethodRefs = 64 * 1024;
  constexpr size_t kMaxFieldRefs = 64 * 1024;
  always_assert_log(
      dodx->method_to_idx().size() <= kMaxMethodRefs,
      ""Trying to encode too many method refs in dex %lu: %lu (limit: %lu)"",
      m_dex_number,
      dodx->method_to_idx().size(),
      kMaxMethodRefs);
  always_assert_log(
      dodx->field_to_idx().size() <= kMaxFieldRefs,
      ""Trying to encode too many field refs in dex %lu: %lu (limit: %lu)"",
      m_dex_number,
      dodx->field_to_idx().size(),
      kMaxFieldRefs);
  auto methodids = (dex_method_id*)(m_output + hdr.method_ids_off);
  for (auto& it : dodx->method_to_idx()) {
    auto method = it.first;
    auto idx = it.second;
    methodids[idx].classidx = dodx->typeidx(method->get_class());
    methodids[idx].protoidx = dodx->protoidx(method->get_proto());
    methodids[idx].nameidx = dodx->stringidx(method->get_name());
    m_stats.num_method_refs++;
  }
}

void DexOutput::generate_class_data() {
  dex_class_def* cdefs = (dex_class_def*)(m_output + hdr.class_defs_off);
  for (uint32_t i = 0; i < hdr.class_defs_size; i++) {
    m_stats.num_classes++;
    DexClass* clz = m_classes->at(i);
    cdefs[i].typeidx = dodx->typeidx(clz->get_type());
    cdefs[i].access_flags = clz->get_access();
    cdefs[i].super_idx = dodx->typeidx(clz->get_super_class());
    cdefs[i].interfaces_off = 0;
    cdefs[i].annotations_off = 0;
    cdefs[i].interfaces_off = m_tl_emit_offsets[clz->get_interfaces()];
    auto source_file = m_pos_mapper->get_source_file(clz);
    if (source_file != nullptr) {
      cdefs[i].source_file_idx = dodx->stringidx(source_file);
    } else {
      cdefs[i].source_file_idx = DEX_NO_INDEX;
    }
    if (m_cdi_offsets.count(clz)) {
      cdefs[i].class_data_offset = m_cdi_offsets[clz];
    } else {
      cdefs[i].class_data_offset = 0;
      always_assert_log(
          clz->get_dmethods().size() == 0 &&
          clz->get_vmethods().size() == 0 &&
          clz->get_ifields().size() == 0 &&
          clz->get_sfields().size() == 0,
          ""DexClass %s has member but no class data!\\n"",
          SHOW(clz->get_type()));
    }
    if (m_static_values.count(clz)) {
      cdefs[i].static_values_off = m_static_values[clz];
    } else {
      cdefs[i].static_values_off = 0;
    }
    m_stats.num_fields +=
        clz->get_ifields().size() + clz->get_sfields().size();
    m_stats.num_methods +=
        clz->get_vmethods().size() + clz->get_dmethods().size();
  }
}

void DexOutput::generate_class_data_items() {
  /*
   * First generate a dexcode_to_offset needed for the encoding
   * of class_data_items
   */
  dexcode_to_offset dco;
  uint32_t cdi_start = m_offset;
  for (auto& it : m_code_item_emits) {
    uint32_t offset = (uint32_t) (((uint8_t*)it.second) - m_output);
    dco[it.first] = offset;
  }
  for (uint32_t i = 0; i < hdr.class_defs_size; i++) {
    DexClass* clz = m_classes->at(i);
    if (!clz->has_class_data()) continue;
    /* No alignment constraints for this data */
    int size = clz->encode(dodx, dco, m_output + m_offset);
    m_cdi_offsets[clz] = m_offset;
    m_offset += size;
  }
  insert_map_item(TYPE_CLASS_DATA_ITEM, (uint32_t) m_cdi_offsets.size(), cdi_start);
}

static void sync_all(const Scope& scope) {
  constexpr bool serial = false; // for debugging
  auto wq = workqueue_foreach<DexMethod*>([](DexMethod* m){m->sync();});
  walk::code(scope,
            [](DexMethod*) { return true; },
            [&](DexMethod* m, IRCode&) {
              if (serial) {
                TRACE(MTRANS, 2, ""Syncing %s\\n"", SHOW(m));
                m->sync();
              } else {
                wq.add_item(m);
              }
            });
  wq.run_all();
}

void DexOutput::generate_code_items(const std::vector<SortMode>& mode) {
  TRACE(MAIN, 2, ""generate_code_items\\n"");
  /*
   * Optimization note:  We should pass a sort routine to the
   * emitlist to optimize pagecache efficiency.
   */
  align_output();
  uint32_t ci_start = m_offset;
  sync_all(*m_classes);

  // Get all methods.
  std::vector<DexMethod*> lmeth = m_gtypes->get_dexmethod_emitlist();

  // Repeatedly perform stable sorts starting with the last (least important)
  // sorting method specified.
  for (auto it = mode.rbegin(); it != mode.rend(); ++it) {
    switch (*it) {
      case SortMode::CLASS_ORDER:
        TRACE(CUSTOMSORT, 2, ""using class order for bytecode sorting\\n"");
        m_gtypes->sort_dexmethod_emitlist_cls_order(lmeth);
        break;
      case SortMode::METHOD_PROFILED_ORDER:
        TRACE(CUSTOMSORT, 2,
              ""using method profiled order for bytecode sorting\\n"");
        m_gtypes->sort_dexmethod_emitlist_profiled_order(lmeth);
        break;
      case SortMode::CLINIT_FIRST:
        TRACE(CUSTOMSORT, 2,
              ""sorting <clinit> sections before all other bytecode"");
        m_gtypes->sort_dexmethod_emitlist_clinit_order(lmeth);
        break;

      case SortMode::CLASS_STRINGS:
        TRACE(CUSTOMSORT, 2,
              ""Unsupport bytecode sorting method SortMode::CLASS_STRINGS\\n"");
        break;
      case SortMode::DEFAULT:
        TRACE(CUSTOMSORT, 2, ""using default sorting order\\n"");
        m_gtypes->sort_dexmethod_emitlist_default_order(lmeth);
        break;
      }
  }
  for (DexMethod* meth : lmeth) {
    if (meth->get_access() & (ACC_ABSTRACT | ACC_NATIVE)) {
      // There is no code item for ABSTRACT or NATIVE methods.
      continue;
    }
    TRACE(CUSTOMSORT, 3, ""method emit %s %s\\n"", SHOW(meth->get_class()), SHOW(meth));
    DexCode* code = meth->get_dex_code();
    always_assert_log(
        meth->is_concrete() && code != nullptr,
        ""Undefined method in generate_code_items()\\n\\t prototype: %s\\n"", SHOW(meth));
    align_output();
    int size = code->encode(dodx, (uint32_t*)(m_output + m_offset));
    m_method_bytecode_offsets.emplace_back(meth->get_name()->c_str(), m_offset);
    m_code_item_emits.emplace_back(code, (dex_code_item*)(m_output + m_offset));
    m_offset += size;
    m_stats.num_instructions += code->get_instructions().size();
  }
  insert_map_item(TYPE_CODE_ITEM, (uint32_t) m_code_item_emits.size(), ci_start);
}

void DexOutput::generate_static_values() {
  uint32_t sv_start = m_offset;
  std::unordered_map<DexEncodedValueArray,
                     uint32_t,
                     boost::hash<DexEncodedValueArray>>
      enc_arrays;
  for (uint32_t i = 0; i < hdr.class_defs_size; i++) {
    DexClass* clz = m_classes->at(i);
    // Fields need to be sorted otherwise static values may end up out of order
    auto& sfields = clz->get_sfields();
    std::sort(sfields.begin(), sfields.end(), compare_dexfields);
    auto& ifields = clz->get_ifields();
    std::sort(ifields.begin(), ifields.end(), compare_dexfields);
    std::unique_ptr<DexEncodedValueArray> deva(clz->get_static_values());
    if (!deva) continue;
    if (enc_arrays.count(*deva)) {
      m_static_values[clz] = enc_arrays.at(*deva);
    } else {
      uint8_t* output = m_output + m_offset;
      uint8_t* outputsv = output;
      /* No alignment requirements */
      deva->encode(dodx, output);
      enc_arrays.emplace(std::move(*deva.release()), m_offset);
      m_static_values[clz] = m_offset;
      m_offset += output - outputsv;
      m_stats.num_static_values++;
    }
  }
  if (m_static_values.size()) {
    insert_map_item(TYPE_ENCODED_ARRAY_ITEM, (uint32_t) enc_arrays.size(), sv_start);
  }
}

static bool annotation_cmp(const DexAnnotationDirectory* a,
                           const DexAnnotationDirectory* b) {
  return (a->viz_score() < b->viz_score());
}

void DexOutput::unique_annotations(annomap_t& annomap,
                                   std::vector<DexAnnotation*>& annolist) {
  int annocnt = 0;
  uint32_t mentry_offset = m_offset;
  std::map<std::vector<uint8_t>, uint32_t> annotation_byte_offsets;
  for (auto anno : annolist) {
    if (annomap.count(anno)) continue;
    std::vector<uint8_t> annotation_bytes;
    anno->vencode(dodx, annotation_bytes);
    if (annotation_byte_offsets.count(annotation_bytes)) {
      annomap[anno] = annotation_byte_offsets[annotation_bytes];
      continue;
    }
    /* Insert new annotation in tracking structs */
    annotation_byte_offsets[annotation_bytes] = m_offset;
    annomap[anno] = m_offset;
    /* Not a dupe, encode... */
    uint8_t* annoout = (uint8_t*)(m_output + m_offset);
    memcpy(annoout, &annotation_bytes[0], annotation_bytes.size());
    m_offset += annotation_bytes.size();
    annocnt++;
  }
  if (annocnt) {
    insert_map_item(TYPE_ANNOTATION_ITEM, annocnt, mentry_offset);
  }
  m_stats.num_annotations += annocnt;
}

void DexOutput::unique_asets(annomap_t& annomap,
                             asetmap_t& asetmap,
                             std::vector<DexAnnotationSet*>& asetlist) {
  int asetcnt = 0;
  uint32_t mentry_offset = m_offset;
  std::map<std::vector<uint32_t>, uint32_t> aset_offsets;
  for (auto aset : asetlist) {
    if (asetmap.count(aset)) continue;
    std::vector<uint32_t> aset_bytes;
    aset->vencode(dodx, aset_bytes, annomap);
    if (aset_offsets.count(aset_bytes)) {
      asetmap[aset] = aset_offsets[aset_bytes];
      continue;
    }
    /* Insert new aset in tracking structs */
    aset_offsets[aset_bytes] = m_offset;
    asetmap[aset] = m_offset;
    /* Not a dupe, encode... */
    uint8_t* asetout = (uint8_t*)(m_output + m_offset);
    memcpy(asetout, &aset_bytes[0], aset_bytes.size() * sizeof(uint32_t));
    m_offset += aset_bytes.size() * sizeof(uint32_t);
    asetcnt++;
  }
  if (asetcnt) {
    insert_map_item(TYPE_ANNOTATION_SET_ITEM, asetcnt, mentry_offset);
  }
}

void DexOutput::unique_xrefs(asetmap_t& asetmap,
                             xrefmap_t& xrefmap,
                             std::vector<ParamAnnotations*>& xreflist) {
  int xrefcnt = 0;
  uint32_t mentry_offset = m_offset;
  std::map<std::vector<uint32_t>, uint32_t> xref_offsets;
  for (auto xref : xreflist) {
    if (xrefmap.count(xref)) continue;
    std::vector<uint32_t> xref_bytes;
    xref_bytes.push_back((unsigned int) xref->size());
    for (auto param : *xref) {
      DexAnnotationSet* das = param.second;
      always_assert_log(asetmap.count(das) != 0,
                        ""Uninitialized aset %p '%s'"", das, SHOW(das));
      xref_bytes.push_back(asetmap[das]);
    }
    if (xref_offsets.count(xref_bytes)) {
      xrefmap[xref] = xref_offsets[xref_bytes];
      continue;
    }
    /* Insert new xref in tracking structs */
    xref_offsets[xref_bytes] = m_offset;
    xrefmap[xref] = m_offset;
    /* Not a dupe, encode... */
    uint8_t* xrefout = (uint8_t*)(m_output + m_offset);
    memcpy(xrefout, &xref_bytes[0], xref_bytes.size() * sizeof(uint32_t));
    m_offset += xref_bytes.size() * sizeof(uint32_t);
    xrefcnt++;
  }
  if (xrefcnt) {
    insert_map_item(TYPE_ANNOTATION_SET_REF_LIST, xrefcnt, mentry_offset);
  }
}

void DexOutput::unique_adirs(asetmap_t& asetmap,
                             xrefmap_t& xrefmap,
                             adirmap_t& adirmap,
                             std::vector<DexAnnotationDirectory*>& adirlist) {
  int adircnt = 0;
  uint32_t mentry_offset = m_offset;
  std::map<std::vector<uint32_t>, uint32_t> adir_offsets;
  for (auto adir : adirlist) {
    if (adirmap.count(adir)) continue;
    std::vector<uint32_t> adir_bytes;
    adir->vencode(dodx, adir_bytes, xrefmap, asetmap);
    if (adir_offsets.count(adir_bytes)) {
      adirmap[adir] = adir_offsets[adir_bytes];
      continue;
    }
    /* Insert new adir in tracking structs */
    adir_offsets[adir_bytes] = m_offset;
    adirmap[adir] = m_offset;
    /* Not a dupe, encode... */
    uint8_t* adirout = (uint8_t*)(m_output + m_offset);
    memcpy(adirout, &adir_bytes[0], adir_bytes.size() * sizeof(uint32_t));
    m_offset += adir_bytes.size() * sizeof(uint32_t);
    adircnt++;
  }
  if (adircnt) {
    insert_map_item(TYPE_ANNOTATIONS_DIR_ITEM, adircnt, mentry_offset);
  }
}

void DexOutput::generate_annotations() {
  /*
   * There are five phases to generating annotations:
   * 1) Emit annotations
   * 2) Emit annotation_sets
   * 3) Emit annotation xref lists for method params
   * 4) Emit annotation_directories
   * 5) Attach annotation_directories to the classdefs
   */
  std::vector<DexAnnotationDirectory*> lad;
  int xrefsize = 0;
  int annodirsize = 0;
  int xrefcnt = 0;
  std::map<DexAnnotationDirectory*, int> ad_to_classnum;
  annomap_t annomap;
  asetmap_t asetmap;
  xrefmap_t xrefmap;
  adirmap_t adirmap;

  for (uint32_t i = 0; i < hdr.class_defs_size; i++) {
    DexClass* clz = m_classes->at(i);
    DexAnnotationDirectory* ad = clz->get_annotation_directory();
    if (ad) {
      xrefsize += ad->xref_size();
      annodirsize += ad->annodir_size();
      xrefcnt += ad->xref_count();
      lad.push_back(ad);
      ad_to_classnum[ad] = i;
    }
  }
  std::sort(lad.begin(), lad.end(), annotation_cmp);
  std::vector<DexAnnotation*> annolist;
  std::vector<DexAnnotationSet*> asetlist;
  std::vector<ParamAnnotations*> xreflist;
  for (auto ad : lad) {
    ad->gather_asets(asetlist);
    ad->gather_annotations(annolist);
    ad->gather_xrefs(xreflist);
  }
  unique_annotations(annomap, annolist);
  align_output();
  unique_asets(annomap, asetmap, asetlist);
  unique_xrefs(asetmap, xrefmap, xreflist);
  unique_adirs(asetmap, xrefmap, adirmap, lad);
  for (auto ad : lad) {
    int class_num = ad_to_classnum[ad];
    dex_class_def* cdefs = (dex_class_def*)(m_output + hdr.class_defs_off);
    cdefs[class_num].annotations_off = adirmap[ad];
    delete ad;
  }
}

void DexOutput::generate_debug_items() {
  uint32_t dbg_start = m_offset;
  int dbgcount = 0;
  for (auto& it : m_code_item_emits) {
    DexCode* dc = it.first;
    dex_code_item* dci = it.second;
    auto dbg = dc->get_debug_item();
    if (dbg == nullptr) continue;
    dbgcount++;
    // No align requirement for debug items.
    std::vector<DebugLineItem> debug_line_info;
    uint32_t line_start{0};
    auto dbgops = generate_debug_instructions(dbg, dodx, m_pos_mapper,
                                              &line_start, &debug_line_info);
    if (m_emit_debug_line_info) {
      int size = dbg->encode(dodx, m_pos_mapper, m_output + m_offset,
                             line_start, dbgops);
      dci->debug_info_off = m_offset;
      m_offset += size;
    }
    if (m_code_debug_lines != nullptr) {
      (*m_code_debug_lines)[dc] = debug_line_info;
    }
  }
  if (m_emit_debug_line_info) {
    insert_map_item(TYPE_DEBUG_INFO_ITEM, dbgcount, dbg_start);
  }
}

void DexOutput::generate_map() {
  align_output();
  uint32_t* mapout = (uint32_t*)(m_output + m_offset);
  hdr.map_off = m_offset;
  insert_map_item(TYPE_MAP_LIST, 1, m_offset);
  *mapout = (uint32_t) m_map_items.size();
  dex_map_item* map = (dex_map_item*)(mapout + 1);
  for (auto const& mit : m_map_items) {
    *map++ = mit;
  }
  m_offset += ((uint8_t*)map) - ((uint8_t*)mapout);
}

/**
 * When things move around in redex, we might find ourselves in a situation
 * where a regular OPCODE_CONST_STRING is now referring to a jumbo string,
 * or vice versea. This fixup ensures that all const string opcodes agree
 * with the jumbo-ness of their stridx.
 */
static void fix_method_jumbos(DexMethod* method, const DexOutputIdx* dodx) {
  auto code = method->get_code();
  if (!code) return; // nothing to do for native methods

  for (auto& mie : *code) {
    if (mie.type != MFLOW_DEX_OPCODE) {
      continue;
    }
    auto insn = mie.dex_insn;
    auto op = insn->opcode();
    if (op != DOPCODE_CONST_STRING && op != DOPCODE_CONST_STRING_JUMBO) {
      continue;
    }

    auto str = static_cast<DexOpcodeString*>(insn)->get_string();
    uint32_t stridx = dodx->stringidx(str);
    bool jumbo = ((stridx >> 16) != 0);

    if (jumbo) {
      insn->set_opcode(DOPCODE_CONST_STRING_JUMBO);
    } else if (!jumbo) {
      insn->set_opcode(DOPCODE_CONST_STRING);
    }
  }
}

static void fix_jumbos(DexClasses* classes, DexOutputIdx* dodx) {
  walk::methods(*classes, [&](DexMethod* m) { fix_method_jumbos(m, dodx); });
}

void DexOutput::init_header_offsets() {
  memcpy(hdr.magic, DEX_HEADER_DEXMAGIC, sizeof(hdr.magic));
  insert_map_item(TYPE_HEADER_ITEM, 1, 0);

  m_offset = hdr.header_size = sizeof(dex_header);
  hdr.endian_tag = ENDIAN_CONSTANT;
  /* Link section was never used */
  hdr.link_size = hdr.link_off = 0;
  hdr.string_ids_size = (uint32_t) dodx->stringsize();
  hdr.string_ids_off = hdr.string_ids_size ? m_offset : 0;
  insert_map_item(TYPE_STRING_ID_ITEM, (uint32_t) dodx->stringsize(), m_offset);

  m_offset += dodx->stringsize() * sizeof(dex_string_id);
  hdr.type_ids_size = (uint32_t) dodx->typesize();
  hdr.type_ids_off = hdr.type_ids_size ? m_offset : 0;
  insert_map_item(TYPE_TYPE_ID_ITEM, (uint32_t) dodx->typesize(), m_offset);

  m_offset += dodx->typesize() * sizeof(dex_type_id);
  hdr.proto_ids_size = (uint32_t) dodx->protosize();
  hdr.proto_ids_off = hdr.proto_ids_size ? m_offset : 0;
  insert_map_item(TYPE_PROTO_ID_ITEM, (uint32_t) dodx->protosize(), m_offset);

  m_offset += dodx->protosize() * sizeof(dex_proto_id);
  hdr.field_ids_size = (uint32_t) dodx->fieldsize();
  hdr.field_ids_off = hdr.field_ids_size ? m_offset : 0;
  insert_map_item(TYPE_FIELD_ID_ITEM, (uint32_t) dodx->fieldsize(), m_offset);

  m_offset += dodx->fieldsize() * sizeof(dex_field_id);
  hdr.method_ids_size = (uint32_t) dodx->methodsize();
  hdr.method_ids_off = hdr.method_ids_size ? m_offset : 0;
  insert_map_item(TYPE_METHOD_ID_ITEM, (uint32_t) dodx->methodsize(), m_offset);

  m_offset += dodx->methodsize() * sizeof(dex_method_id);
  hdr.class_defs_size = (uint32_t) m_classes->size();
  hdr.class_defs_off = hdr.class_defs_size ? m_offset : 0;
  insert_map_item(TYPE_CLASS_DEF_ITEM, (uint32_t) m_classes->size(), m_offset);

  m_offset += m_classes->size() * sizeof(dex_class_def);
  hdr.data_off = m_offset;
  /* Todo... */
  hdr.map_off = 0;
  hdr.data_size = 0;
  hdr.file_size = 0;
}

void DexOutput::finalize_header() {
  hdr.data_size = m_offset - hdr.data_off;
  hdr.file_size = m_offset;
  int skip;
  skip = sizeof(hdr.magic) + sizeof(hdr.checksum) + sizeof(hdr.signature);
  memcpy(m_output, &hdr, sizeof(hdr));
  Sha1Context context;
  sha1_init(&context);
  sha1_update(&context, m_output + skip, hdr.file_size - skip);
  sha1_final(hdr.signature, &context);
  memcpy(m_output, &hdr, sizeof(hdr));
  uint32_t adler = (uint32_t)adler32(0L, Z_NULL, 0);
  skip = sizeof(hdr.magic) + sizeof(hdr.checksum);
  adler = (uint32_t) adler32(adler, (const Bytef*)(m_output + skip), hdr.file_size - skip);
  hdr.checksum = adler;
  memcpy(m_output, &hdr, sizeof(hdr));
}

namespace {

void write_method_mapping(
  const std::string& filename,
  const DexOutputIdx* dodx,
  const DexClasses* classes,
  uint8_t* dex_signature,
  std::unordered_map<DexMethod*, uint64_t>* method_to_id
) {
  if (filename.empty()) return;
  FILE* fd = fopen(filename.c_str(), ""a"");
  assert_log(fd, ""Can't open method mapping file %s: %s\\n"",
             filename.c_str(),
             strerror(errno));
  std::unordered_set<DexClass*> classes_in_dex(classes->begin(), classes->end());
  for (auto& it : dodx->method_to_idx()) {
    auto method = it.first;
    auto idx = it.second;

    // Types (and methods) internal to our app have a cached deobfuscated name
    // that comes from the proguard map.  If we don't have one, it's a
    // system/framework class, so we can just return the name.
    auto const& typecls = method->get_class();
    auto const& cls = type_class(typecls);
    if (classes_in_dex.count(cls) == 0) {
      // We only want to emit IDs for the methods that are defined in this dex,
      // and not for references to methods in other dexes.
      continue;
    }
    auto deobf_class = [&] {
      if (cls) {
        auto deobname = cls->get_deobfuscated_name();
        if (!deobname.empty()) return deobname;
      }
      return show(typecls);
    }();

    // Some method refs aren't ""concrete"" (e.g., referring to a method defined
    // by a superclass via a subclass).  We only know how to deobfuscate
    // concrete names, so resolve this ref to an actual definition.
    auto resolved_method = [&]() -> DexMethodRef* {
      if (cls) {
        auto resm = resolve_method(method,
            is_interface(cls) ? MethodSearch::Interface : MethodSearch::Any);
        if (resm) return resm;
      }
      return method;
    }();

    // Consult the cached method names, or just give it back verbatim.
    auto deobf_method = [&] {
      if (resolved_method->is_def()) {
        auto deobfname =
            static_cast<DexMethod*>(resolved_method)->get_deobfuscated_name();
        if (!deobfname.empty()) return deobfname;
      }
      return show(resolved_method);
    }();

    // Format is <cls>.<name>:(<args>)<ret>
    // We only want the name here.
    auto begin = deobf_method.find('.') + 1;
    auto end = deobf_method.rfind(':');
    auto deobf_method_name = deobf_method.substr(begin, end-begin);

    //
    // Turns out, the checksum can change on-device. (damn you dexopt)
    // The signature, however, is never recomputed. Let's log the top 4 bytes,
    // in little-endian (since that's faster to compute on-device).
    //
    uint32_t signature = *reinterpret_cast<uint32_t*>(dex_signature);

    if (method_to_id != nullptr) {
      if (resolved_method == method) {
        // Not recording it if method reference is not referring to
        // concrete method, otherwise will have key overlapped.
        auto dexmethod = static_cast<DexMethod*>(resolved_method);
        (*method_to_id)[dexmethod] =
            ((uint64_t)idx << 32) | (uint64_t)signature;
      }
    }

    fprintf(fd, ""%u %u %s %s\\n"",
            idx,
            signature,
            deobf_method_name.c_str(),
            deobf_class.c_str());
  }
  fclose(fd);
}

void write_class_mapping(
  const std::string& filename,
  DexClasses* classes,
  const size_t class_defs_size,
  uint8_t* dex_signature
) {
  if (filename.empty()) return;
  FILE* fd = fopen(filename.c_str(), ""a"");

  for (uint32_t idx = 0; idx < class_defs_size; idx++) {

    DexClass* cls = classes->at(idx);
    auto deobf_class = [&] {
      if (cls) {
        auto deobname = cls->get_deobfuscated_name();
        if (!deobname.empty()) return deobname;
      }
      return show(cls);
    }();

    //
    // See write_method_mapping above for why checksum is insufficient.
    //
    uint32_t signature = *reinterpret_cast<uint32_t*>(dex_signature);
    fprintf(fd, ""%u %u %s\\n"", idx, signature, deobf_class.c_str());
  }

  fclose(fd);
}

const char* deobf_primitive(char type) {
  switch (type) {
    case 'B':
      return ""byte"";
    case 'C':
      return ""char"";
    case 'D':
      return ""double"";
    case 'F':
      return ""float"";
    case 'I':
      return ""int"";
    case 'J':
      return ""long"";
    case 'S':
      return ""short"";
    case 'Z':
      return ""boolean"";
    case 'V':
      return ""void"";
    default:
      always_assert_log(false, ""Illegal type: %c"", type);
      not_reached();
  }
}

void write_pg_mapping(const std::string& filename, DexClasses* classes) {
  if (filename.empty()) return;

  auto deobf_class = [&](DexClass* cls) {
    if (cls) {
      auto deobname = cls->get_deobfuscated_name();
      if (!deobname.empty()) return deobname;
    }
    return show(cls);
  };

  auto deobf_type = [&](DexType* type) {
    if (type) {
      if (is_array(type)) {
        auto* type_str = type->c_str();
        int dim = 0;
        while (type_str[dim] == '[') {
          dim++;
        }
        DexType* inner_type = DexType::get_type(&type_str[dim]);
        DexClass* inner_cls = inner_type ? type_class(inner_type) : nullptr;
        std::string result;
        if (inner_cls) {
          result = JavaNameUtil::internal_to_external(deobf_class(inner_cls));
        } else if (inner_type && is_primitive(inner_type)) {
          result = deobf_primitive(type_str[dim]);
        } else {
          result = JavaNameUtil::internal_to_external(&type_str[dim]);
        }
        for (int i = 0 ; i < dim ; ++i) {
          result = result + ""[]"";
        }
        return result;
      } else {
        DexClass* cls = type_class(type);
        if (cls) {
          return JavaNameUtil::internal_to_external(deobf_class(cls));
        } else if (is_primitive(type)) {
          return std::string(deobf_primitive(type->c_str()[0]));
        } else {
          return JavaNameUtil::internal_to_external(type->c_str());
        }
      }
    }
    return show(type);
  };

  auto deobf_meth = [&](DexMethod* method) {
    if (method) {
      // Example: 672:672:boolean customShouldDelayInitMessage(android.os.Handler,android.os.Message)
      auto* proto = method->get_proto();
      std::ostringstream ss;
      auto* code = method->get_dex_code();
      auto* dbg = code ? code->get_debug_item() : nullptr;
      if (dbg) {
        uint32_t line_start = code->get_debug_item()->get_line_start();
        uint32_t line_end = line_start;
        for (auto& entry : dbg->get_entries()) {
          if (entry.type == DexDebugEntryType::Position) {
            if (entry.pos->line > line_end) {
              line_end = entry.pos->line;
            }
          }
        }
        // Treat anything bigger than 2^31 as 0
        if (line_start > static_cast<uint32_t>(std::numeric_limits<int32_t>::max())) {
          line_start = 0;
        }
        if (line_end > static_cast<uint32_t>(std::numeric_limits<int32_t>::max())) {
          line_end = 0;
        }
        ss << line_start << "":"" << line_end << "":"";
      }
      auto* rtype = proto->get_rtype();
      auto rtype_str = deobf_type(rtype);
      ss << rtype_str;
      ss << "" "" << method->get_simple_deobfuscated_name() << ""("";
      auto args = proto->get_args()->get_type_list();
      for (auto iter = args.begin() ; iter != args.end() ; ++iter) {
        auto* atype = *iter;
        auto atype_str = deobf_type(atype);
        ss << atype_str;
        if (iter + 1 != args.end()) {
          ss << "","";
        }
      }
      ss << "")"";
      return ss.str();
    }
    return show(method);
  };

  auto deobf_field = [&](DexField* field) {
    if (field) {
      std::ostringstream ss;
      ss << deobf_type(field->get_type())
      << "" ""
      << field->get_simple_deobfuscated_name();
      return ss.str();
    }
    return show(field);
  };

  std::ofstream ofs(filename.c_str(), std::ofstream::out | std::ofstream::app);

  for (auto cls : *classes) {
    auto deobf_cls = deobf_class(cls);
    ofs << JavaNameUtil::internal_to_external(deobf_cls) << "" -> ""
        << JavaNameUtil::internal_to_external(cls->get_type()->c_str())
        << "":"" << std::endl;
    for (auto field : cls->get_ifields()) {
      auto deobf = deobf_field(field);
      ofs << ""    "" << deobf << "" -> "" << field->c_str() << std::endl;
    }
    for (auto field : cls->get_sfields()) {
      auto deobf = deobf_field(field);
      ofs << ""    "" << deobf << "" -> "" << field->c_str() << std::endl;
    }
    for (auto meth : cls->get_dmethods()) {
      auto deobf = deobf_meth(meth);
      ofs << ""    "" << deobf << "" -> "" << meth->c_str() << std::endl;
    }
    for (auto meth : cls->get_vmethods()) {
      auto deobf = deobf_meth(meth);
      ofs << ""    "" << deobf << "" -> "" << meth->c_str() << std::endl;
    }
  }
}

void write_bytecode_offset_mapping(
  const std::string& filename,
  const std::vector<std::pair<std::string, uint32_t>>& method_offsets
) {
  if (filename.empty()) { return; }

  auto fd = fopen(filename.c_str(), ""a"");
  assert_log(fd, ""Can't open bytecode offset file %s: %s\\n"",
             filename.c_str(),
             strerror(errno));

  for (const auto& item : method_offsets) {
    fprintf(fd, ""%u %s\\n"", item.second, item.first.c_str());
  }

  fclose(fd);
}

} // namespace

void DexOutput::write_symbol_files() {
  write_method_mapping(
    m_method_mapping_filename,
    dodx,
    m_classes,
    hdr.signature,
    m_method_to_id
  );
  write_class_mapping(
    m_class_mapping_filename,
    m_classes,
    hdr.class_defs_size,
    hdr.signature
  );
  write_pg_mapping(
    m_pg_mapping_filename,
    m_classes
  );
  write_bytecode_offset_mapping(m_bytecode_offset_filename,
                                m_method_bytecode_offsets);
}

void GatheredTypes::set_method_to_weight(
    const std::unordered_map<std::string, unsigned int>& method_to_weight) {
  m_method_to_weight = method_to_weight;
}

void DexOutput::prepare(SortMode string_mode,
                        const std::vector<SortMode>& code_mode,
                        const ConfigFiles& cfg) {

  if (std::find(code_mode.begin(), code_mode.end(),
                SortMode::METHOD_PROFILED_ORDER) != code_mode.end()) {
    m_gtypes->set_method_to_weight(cfg.get_method_to_weight());
  }

  fix_jumbos(m_classes, dodx);
  init_header_offsets();
  generate_static_values();
  generate_typelist_data();
  generate_string_data(string_mode);
  generate_code_items(code_mode);
  generate_class_data_items();
  generate_type_data();
  generate_proto_data();
  generate_field_data();
  generate_method_data();
  generate_class_data();
  generate_annotations();
  generate_debug_items();
  generate_map();
  align_output();
  finalize_header();
}

void DexOutput::write() {
  struct stat st;
  int fd = open(m_filename, O_CREAT | O_TRUNC | O_WRONLY, 0660);
  if (fd == -1) {
    perror(""Error writing dex"");
    return;
  }
  ::write(fd, m_output, m_offset);
  if (0 == fstat(fd, &st)) {
    m_stats.num_bytes = st.st_size;
  }
  close(fd);

  write_symbol_files();
}

static SortMode make_sort_bytecode(const std::string& sort_bytecode) {
  if (sort_bytecode == ""class_order"") {
    return SortMode::CLASS_ORDER;
  } else if (sort_bytecode == ""clinit_order"") {
    return SortMode::CLINIT_FIRST;
  } else if (sort_bytecode == ""method_profiled_order"") {
    return SortMode::METHOD_PROFILED_ORDER;
  } else {
    return SortMode::DEFAULT;
  }
}

dex_stats_t write_classes_to_dex(
    std::string filename,
    DexClasses* classes,
    LocatorIndex* locator_index,
    bool emit_name_based_locators,
    size_t store_number,
    size_t dex_number,
    const ConfigFiles& cfg,
    PositionMapper* pos_mapper,
    std::unordered_map<DexMethod*, uint64_t>* method_to_id,
    std::unordered_map<DexCode*, std::vector<DebugLineItem>>*
        code_debug_lines) {
  const JsonWrapper& json_cfg = cfg.get_json_config();
  auto method_mapping_filename =
      cfg.metafile(json_cfg.get(""method_mapping"", std::string()));
  auto class_mapping_filename =
      cfg.metafile(json_cfg.get(""class_mapping"", std::string()));
  auto pg_mapping_filename =
      cfg.metafile(json_cfg.get(""proguard_map_output"", std::string()));
  auto bytecode_offset_filename =
      cfg.metafile(json_cfg.get(""bytecode_offset_map"", std::string()));
  auto sort_strings = json_cfg.get(""string_sort_mode"", std::string());
  auto emit_debug_line_info = json_cfg.get(""emit_debug_line_info"", true);
  SortMode string_sort_mode = SortMode::DEFAULT;
  if (sort_strings == ""class_strings"") {
    string_sort_mode = SortMode::CLASS_STRINGS;
  } else if (sort_strings == ""class_order"") {
    string_sort_mode = SortMode::CLASS_ORDER;
  }

  auto sort_bytecode_cfg = json_cfg.get(""bytecode_sort_mode"", Json::Value());
  std::vector<SortMode> code_sort_mode;

  if (sort_bytecode_cfg.isString()) {
    code_sort_mode.push_back(make_sort_bytecode(sort_bytecode_cfg.asString()));
  } else if (sort_bytecode_cfg.isArray()) {
    for (auto val : sort_bytecode_cfg) {
      code_sort_mode.push_back(make_sort_bytecode(val.asString()));
    }
  }
  if (code_sort_mode.empty()) {
    code_sort_mode.push_back(SortMode::DEFAULT);
  }

  TRACE(OPUT, 3, ""[write_classes_to_dex][filename] %s\\n"", filename.c_str());

  DexOutput dout = DexOutput(filename.c_str(),
                             classes,
                             locator_index,
                             emit_name_based_locators,
                             store_number,
                             dex_number,
                             emit_debug_line_info,
                             cfg,
                             pos_mapper,
                             method_to_id,
                             code_debug_lines,
                             method_mapping_filename,
                             class_mapping_filename,
                             pg_mapping_filename,
                             bytecode_offset_filename);

  dout.prepare(string_sort_mode, code_sort_mode, cfg);
  dout.write();
  return dout.m_stats;
}

LocatorIndex make_locator_index(DexStoresVector& stores,
                                bool emit_name_based_locators) {
  LocatorIndex index;

  for (uint32_t strnr = 0; strnr < stores.size(); strnr++) {
    DexClassesVector& dexen = stores[strnr].get_dexen();
    uint32_t dexnr = 1; // Zero is reserved for Android classes
    for (auto dexit = dexen.begin(); dexit != dexen.end(); ++dexit, ++dexnr) {
      const DexClasses& classes = *dexit;
      uint32_t clsnr = 0;
      for (auto clsit = classes.begin(); clsit != classes.end();
           ++clsit, ++clsnr) {
        DexString* clsname = (*clsit)->get_type()->get_name();
        if (emit_name_based_locators) {
          const auto cstr = clsname->c_str();
          uint32_t global_clsnr = Locator::decodeGlobalClassIndex(cstr);
          if (global_clsnr != Locator::invalid_global_class_index) {
            TRACE(LOC, 3,
                  ""%s (%u, %u, %u) needs no locator; global class index=%u\\n"",
                  cstr, strnr, dexnr, clsnr, global_clsnr);
            // This prefix is followed by the global class index; this case
            // doesn't need a locator since emit_name_based_locators is enabled.
            continue;
          }
        }

        bool inserted = index
                            .insert(std::make_pair(
                                clsname, Locator::make(strnr, dexnr, clsnr)))
                            .second;
        // We shouldn't see the same class defined in two dexen
        always_assert_log(inserted, ""This was already inserted %s\\n"",
                          (*clsit)->get_deobfuscated_name().c_str());
        (void) inserted; // Shut up compiler when defined(NDEBUG)
      }
    }
  }

  return index;
}
",16248,True,2727.322955313005,median
"[[_auth_spi]]
== Authentication SPI

{project_name} includes a range of different authentication mechanisms: kerberos, password, otp and others.
These mechanisms may not meet all of your requirements and you may want to plug in your own custom ones.
{project_name} provides an authentication SPI that you can use to write new plugins.
The admin console supports applying, ordering, and configuring these new mechanisms.

{project_name} also supports a simple registration form.
Different aspects of this form can be enabled and disabled i.e.
Recaptcha support can be turned off and on.
The same authentication SPI can be used to add another page to the registration flow or reimplement it entirely.
There's also an additional fine-grained SPI you can use to add specific validations and user extensions to the built in registration form.

A required action in {project_name} is an action that a user has to perform after he authenticates.
After the action is performed successfully, the user doesn't have to perform the action again.
{project_name} comes with some built in required actions like ""reset password"".  This action forces the user to change their password after they have logged in.
You can write and plug in your own required actions.

WARNING: If your authenticator or required action implementation is using some user attributes as the metadata attributes for linking/establishing the user identity,
then please make sure that users are not able to edit the attributes and the corresponding attributes are read-only. See the details in the link:{adminguide_link}#_read_only_user_attributes[Threat model mitigation chapter].

=== Terms

To first learn about the Authentication SPI, let's go over some of the terms used to describe it.

Authentication Flow::
  A flow is a container for all authentications that must happen during login or registration.
  If you go to the admin console authentication page, you can view all the defined flows in the system and what authenticators they are made up of.
  Flows can contain other flows.
  You can also bind a new different flow for browser login, direct grant access, and registration.

Authenticator::
  An authenticator is a pluggable component that hold the logic for performing the authentication or action within a flow.
  It is usually a singleton.

Execution::
  An execution is an object that binds the authenticator to the flow and the authenticator to the configuration of the authenticator.
  Flows contain execution entries.

Execution Requirement::
  Each execution defines how an authenticator behaves in a flow.
  The requirement defines whether the authenticator is enabled, disabled, conditional, required, or an alternative.
  An alternative requirement means that the authenticator is enough to validate the flow it's in, but isn't necessary.
  For example, in the built-in browser flow, cookie authentication, the Identity Provider Redirector, and the set of all authenticators in the
  forms subflow are all alternative. As they are executed in a sequential top-to-bottom order, if one of them is successful, the flow is
  successful, and any following execution in the flow (or sub-flow) is not evaluated.

Authenticator Config::
  This object defines the configuration for the Authenticator for a specific execution within an authentication flow.
  Each execution can have a different config.

Required Action::
  After authentication completes, the user might have one or more one-time actions he must complete before he is allowed to login.
  The user might be required to set up an OTP token generator or reset an expired password or even accept a Terms and Conditions document.

=== Algorithm Overview

Let's talk about how this all works for browser login.
Let's assume the following flows, executions and sub flows.
[source]
----

Cookie - ALTERNATIVE
Kerberos - ALTERNATIVE
Forms subflow - ALTERNATIVE
           Username/Password Form - REQUIRED
           Conditional OTP subflow - CONDITIONAL
                      Condition - User Configured - REQUIRED
                      OTP Form - REQUIRED
----

In the top level of the form we have 3 executions of which all are alternatively required.
This means that if any of these are successful, then the others do not have to execute.
The Username/Password form is not executed if there is an SSO Cookie set or a successful Kerberos login.
Let's walk through the steps from when a client first redirects to keycloak to authenticate the user.

. The OpenID Connect or SAML protocol provider unpacks relevant data, verifies the client and any signatures.
  It creates an AuthenticationSessionModel.
  It looks up what the browser flow should be, then starts executing the flow.
. The flow looks at the cookie execution and sees that it is an alternative.
  It loads the cookie provider.
  It checks to see if the cookie provider requires that a user already be associated with the authentication session.
  Cookie provider does not require a user.
  If it did, the flow would abort and the user would see an error screen.
  Cookie provider then executes.
  Its purpose is to see if there is an SSO cookie set.
  If there is one set, it is validated and the UserSessionModel is verified and associated with the AuthenticationSessionModel.
  The Cookie provider returns a success() status if the SSO cookie exists and is validated.
  Since the cookie provider returned success and each execution at this level of the flow is ALTERNATIVE, no other execution is executed and this results in a successful login.
  If there is no SSO cookie, the cookie provider returns with a status of attempted().  This means there was no error condition, but no success either.
  The provider tried, but the request just wasn't set up to handle this authenticator.
. Next the flow looks at the Kerberos execution.
  This is also an alternative.
  The kerberos provider also does not require a user to be already set up and associated with the AuthenticationSessionModel so this provider is executed.
  Kerberos uses the SPNEGO browser protocol.
  This requires a series of challenge/responses between the server and client exchanging negotiation headers.
  The kerberos provider does not see any negotiate header, so it assumes that this is the first interaction between the server and client.
  It therefore creates an HTTP challenge response to the client and sets a forceChallenge() status.
  A forceChallenge() means that this HTTP response cannot be ignored by the flow and must be returned to the client.
  If instead the provider returned a challenge() status, the flow would hold the challenge response until all other alternatives are attempted.
  So, in this initial phase, the flow would stop and the challenge response would be sent back to the browser.
  If the browser then responds with a successful negotiate header, the provider associates the user with the AuthenticationSession and the flow ends because the rest of the executions on this level of the flow are all alternatives.
  Otherwise, again, the kerberos provider sets an attempted() status and the flow continues.
. The next execution is a subflow called Forms.
  The executions for this subflow are loaded and the same processing logic occurs.
. The first execution in the Forms subflow is the UsernamePassword provider.
  This provider also does not require for a user to already be associated with the flow.
  This provider creates a challenge HTTP response and sets its status to challenge(). This execution is required, so the flow honors this challenge and sends the HTTP response back to the browser.
  This response is a rendering of the Username/Password HTML page.
  The user enters in their username and password and clicks submit.
  This HTTP request is directed to the UsernamePassword provider.
  If the user entered an invalid username or password, a new challenge response is created and a status of failureChallenge() is set for this execution.
  A failureChallenge() means that there is a challenge, but that the flow should log this as an error in the error log.
  This error log can be used to lock accounts or IP Addresses that have had too many login failures.
  If the username and password is valid, the provider associated the UserModel with the AuthenticationSessionModel and returns a status of success().
. The next execution is a subflow called Conditional OTP. The executions for this subflow are loaded and the same processing logic occurs. Its Requirement is
  Conditional. This means that the flow will first evaluate all conditional executors that it contains. Conditional executors are authenticators that
  implement `ConditionalAuthenticator`, and must implement the method `boolean matchCondition(AuthenticationFlowContext context)`. A conditional subflow will
  call the `matchCondition` method of all conditional executions it contains, and if all of them evaluate to true, it will act as if it was a required subflow. If
  not, it will act as if it was a disabled subflow. Conditional authenticators are only used for this purpose, and are not used as authenticators.
  This means that even if the conditional authenticator evaluates to ""true"", then this will not mark a flow or subflow as successful. For example,
  a flow containing only a Conditional subflow with only a conditional authenticator will never allow a user to log in.
. The first execution of the Conditional OTP subflow is the Condition - User Configured.
  This provider requires that a user has been associated with the flow.
  This requirement is satisfied because the UsernamePassword provider already associated the user with the flow.
  This provider's `matchCondition` method will evaluate the `configuredFor` method for all other Authenticators in its current subflow. If the subflow contains
  executors with their Requirement set to required, then the `matchCondition` method will only evaluate to true if all the required authenticators' `configuredFor`
  method evaluate to true. Otherwise, the `matchCondition` method will evaluate to true if any alternative authenticator evaluates to true.
. The next execution is the OTP Form.
  This provider also requires that a user has been associated with the flow.
  This requirement is satisfied because the UsernamePassword provider already associated the user with the flow.
  Since a user is required for this provider, the provider is also asked if the user is configured to use this provider.
  If user is not configured, then the flow will then set up a required action that the user must perform after authentication is complete.
  For OTP, this means the OTP setup page. If the user is configured, he will be asked to enter his otp code. In our scenario, because of the conditional
  sub-flow, the user will never see the OTP login page, unless the Conditional OTP subflow is set to Required.
. After the flow is complete, the authentication processor creates a UserSessionModel and associates it with the AuthenticationSessionModel.
  It then checks to see if the user is required to complete any required actions before logging in.
. First, each required action's evaluateTriggers() method is called.
  This allows the required action provider to figure out if there is some state that might trigger the action to be fired.
  For example, if your realm has a password expiration policy, it might be triggered by this method.
. Each required action associated with the user that has its requiredActionChallenge() method called.
  Here the provider sets up an HTTP response which renders the page for the required action.
  This is done by setting a challenge status.
. If the required action is ultimately successful, then the required action is removed from the user's required actions list.
. After all required actions have been resolved, the user is finally logged in.

[[_auth_spi_walkthrough]]
=== Authenticator SPI Walk Through

In this section, we'll take a look at the Authenticator interface.
For this, we are going to implement an authenticator that requires that a user enter in the answer to a secret question like ""What is your mother's maiden name?"".
This example is fully implemented and contained in the examples/providers/authenticator directory of the demo distribution of {project_name}.

To create an authenticator, you must at minimum implement the org.keycloak.authentication.AuthenticatorFactory and Authenticator interfaces.
The Authenticator interface defines the logic. The AuthenticatorFactory is responsible for creating instances of an Authenticator.
They both extend a more generic Provider and ProviderFactory set of interfaces that other {project_name} components like User Federation do.

Some authenticators, like the CookieAuthenticator don't rely on a Credential that the user has or knows to authenticate the user. 
However, some authenticators, such as the PasswordForm authenticator or the OTPFormAuthenticator rely on the user inputting some
information and verifying that information against some information in the
database. For the PasswordForm for example, the authenticator will verify the hash of the password against a hash stored in the database, while the
OTPFormAuthenticator will verify the OTP received against the one generated from the shared secret stored in the database.

These types of authenticators are called CredentialValidators, and will require you to implement a few more classes:

* A class that extends org.keycloak.credential.CredentialModel, and that can generate the correct format of the credential in the database
* A class implementing the org.keycloak.credential.CredentialProvider and interface, and a class implementing its CredentialProviderFactory factory interface.

The SecretQuestionAuthenticator we'll see in this walk through is a CredentialValidator, so we'll see how to implement all these classes.

==== Packaging Classes and Deployment

You will package your classes within a single jar.
This jar must contain a file named  `org.keycloak.authentication.AuthenticatorFactory` and must be contained in the `META-INF/services/` directory of your jar.
This file must list the fully qualified class name of each AuthenticatorFactory implementation you have in the jar.
For example:

[source,java]
----
org.keycloak.examples.authenticator.SecretQuestionAuthenticatorFactory
org.keycloak.examples.authenticator.AnotherProviderFactory
----

This services/ file is used by {project_name} to scan the providers it has to load into the system.

To deploy this jar, just copy it to the providers directory.

==== Extending the CredentialModel class

In {project_name}, credentials are stored in the database in the Credentials table. It has the following structure:

----
-----------------------------
| ID                        |
-----------------------------
| user_ID                   |
-----------------------------
| credential_type           |
-----------------------------
| created_date              |
-----------------------------
| user_label                |
-----------------------------
| secret_data               |
-----------------------------
| credential_data           |
-----------------------------
| priority                  |
-----------------------------
----

Where:

* `ID` is the primary key of the credential.
* `user_ID` is the foreign key linking the credential to a user.
* `credential_type` is a string set during the creation that must reference an existing credential type.
* `created_date` is the creation timestamp (in long format) of the credential.
* `user_label` is the editable name of the credential by the user
* `secret_data` contains a static json with the information that cannot be transmitted outside of {project_name}
* `credential_data` contains a json with the static information of the credential that can be shared in the admin console or via the REST API.
* `priority` defines how ""preferred"" a credential is for a user, to determine which credential to present when a user has multiple choices.

As the secret_data and credential_data fields are designed to contain json, it is up to you to determine how to structure, read and write into
these fields, allowing you a lot of flexibility.

For this example, we are going to use a very simple credential data, containing only the question asked to the user:

[source]
----
{
  ""question"":""aQuestion""
}
----

with an equally simple secret data, containing only the secret answer:

[source]
----
{
  ""answer"":""anAnswer""
}
----

Here the answer will be kept in plain text in the database for the sake of simplicity, but it would also be possible to have a salted hash for the answer,
as is the case for passwords in {project_name}. In this case, the secret data would also have to contain a field for the salt, and the credential data information
about the algorithm such as the type of algorithm used and the number of iterations used. For more details you can consult the implementation of the
`org.keycloak.models.credential.PasswordCredentialModel` class.

In our case we create the class `SecretQuestionCredentialModel`:


[source,java]
----
public class SecretQuestionCredentialModel extends CredentialModel {
    public static final String TYPE = ""SECRET_QUESTION"";

    private final SecretQuestionCredentialData credentialData;
    private final SecretQuestionSecretData secretData;
----

Where `TYPE` is the credential_type we write in the database. For consistency, we make sure that this String is always the one referenced when
getting the type for this credential. The classes `SecretQuestionCredentialData` and `SecretQuestionSecretData` are used to marshal and unmarshal the json:

[source,java]
----
public class SecretQuestionCredentialData {

    private final String question;

    @JsonCreator
    public SecretQuestionCredentialData(@JsonProperty(""question"") String question) {
        this.question = question;
    }

    public String getQuestion() {
        return question;
    }
}
----

[source,java]
----
public class SecretQuestionSecretData {

     private final String answer;

    @JsonCreator
     public SecretQuestionSecretData(@JsonProperty(""answer"") String answer) {
         this.answer = answer;
     }

    public String getAnswer() {
        return answer;
    }
}
----

To be fully usable, the `SecretQuestionCredentialModel` objects must both contain the raw json data from its parent class,
and the unmarshalled objects in its own attributes. This leads us to create a method which reads from a simple CredentialModel,
such as is created when reading from the database, to make a `SecretQuestionCredentialModel`:

[source,java]
----
private SecretQuestionCredentialModel(SecretQuestionCredentialData credentialData, SecretQuestionSecretData secretData) {
    this.credentialData = credentialData;
    this.secretData = secretData;
}

public static SecretQuestionCredentialModel createFromCredentialModel(CredentialModel credentialModel){
    try {
        SecretQuestionCredentialData credentialData = JsonSerialization.readValue(credentialModel.getCredentialData(), SecretQuestionCredentialData.class);
        SecretQuestionSecretData secretData = JsonSerialization.readValue(credentialModel.getSecretData(), SecretQuestionSecretData.class);

        SecretQuestionCredentialModel secretQuestionCredentialModel = new SecretQuestionCredentialModel(credentialData, secretData);
        secretQuestionCredentialModel.setUserLabel(credentialModel.getUserLabel());
        secretQuestionCredentialModel.setCreatedDate(credentialModel.getCreatedDate());
        secretQuestionCredentialModel.setType(TYPE);
        secretQuestionCredentialModel.setId(credentialModel.getId());
        secretQuestionCredentialModel.setSecretData(credentialModel.getSecretData());
        secretQuestionCredentialModel.setCredentialData(credentialModel.getCredentialData());
        return secretQuestionCredentialModel;
    } catch (IOException e){
        throw new RuntimeException(e);
    }
}
----

And a method to create a `SecretQuestionCredentialModel` from the question and answer:

[source,java]
----
private SecretQuestionCredentialModel(String question, String answer) {
    credentialData = new SecretQuestionCredentialData(question);
    secretData = new SecretQuestionSecretData(answer);
}

public static SecretQuestionCredentialModel createSecretQuestion(String question, String answer) {
    SecretQuestionCredentialModel credentialModel = new SecretQuestionCredentialModel(question, answer);
    credentialModel.fillCredentialModelFields();
    return credentialModel;
}

private void fillCredentialModelFields(){
    try {
        setCredentialData(JsonSerialization.writeValueAsString(credentialData));
        setSecretData(JsonSerialization.writeValueAsString(secretData));
        setType(TYPE);
        setCreatedDate(Time.currentTimeMillis());
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}
----

==== Implementing a CredentialProvider

As with all Providers, to allow {project_name} to generate the CredentialProvider, we require a CredentialProviderFactory. For this requirement we create
the SecretQuestionCredentialProviderFactory, whose `create` method will be called when a SecretQuestionCredentialProvider is asked for:

[source,java]
----
public class SecretQuestionCredentialProviderFactory implements CredentialProviderFactory<SecretQuestionCredentialProvider> {

    public static final String PROVIDER_ID =  ""secret-question"";

    @Override
    public String getId() {
        return PROVIDER_ID;
    }

    @Override
    public CredentialProvider create(KeycloakSession session) {
        return new SecretQuestionCredentialProvider(session);
    }
}
----

The CredentialProvider interface takes a generic parameter that extends a CredentialModel. In our case we to use the SecretQuestionCredentialModel we created:

[source,java]
----
public class SecretQuestionCredentialProvider implements CredentialProvider<SecretQuestionCredentialModel>, CredentialInputValidator {
    private static final Logger logger = Logger.getLogger(SecretQuestionCredentialProvider.class);

    protected KeycloakSession session;

    public SecretQuestionCredentialProvider(KeycloakSession session) {
        this.session = session;
    }

    private UserCredentialStore getCredentialStore() {
        return session.userCredentialManager();
    }
----

We also want to implement the CredentialInputValidator interface, as this allows {project_name} to know that this provider can also be used to validate a
credential for an Authenticator. For the CredentialProvider interface, the first method that needs to be implemented is the `getType()` method. This will simply
return the `SecretQuestionCredentialModel`'s TYPE String:

[source,java]
----
@Override
public String getType() {
    return SecretQuestionCredentialModel.TYPE;
}
----

The second method is to create a `SecretQuestionCredentialModel` from a `CredentialModel`. For this method we simply call the existing static method
from `SecretQuestionCredentialModel`:

[source,java]
----
@Override
public SecretQuestionCredentialModel getCredentialFromModel(CredentialModel model) {
    return SecretQuestionCredentialModel.createFromCredentialModel(model);
}
----

Finally, we have the methods to create a credential and delete a credential. These methods call the KeycloakSession's `userCredentialManager`, which
is responsible for knowing where to read or write the credential, for example local storage or federated storage.

[source,java]
----
@Override
public CredentialModel createCredential(RealmModel realm, UserModel user, SecretQuestionCredentialModel credentialModel) {
    if (credentialModel.getCreatedDate() == null) {
        credentialModel.setCreatedDate(Time.currentTimeMillis());
    }
    return getCredentialStore().createCredential(realm, user, credentialModel);
}

@Override
public boolean deleteCredential(RealmModel realm, UserModel user, String credentialId) {
    return getCredentialStore().removeStoredCredential(realm, user, credentialId);
}
----

For the CredentialInputValidator, the main method to implement is the `isValid`, which tests whether a credential is valid for a
given user in a given realm. This is the method that is called by the Authenticator when it seeks to validate the user's input. Here we
simply need to check that the input String is the one recorded in the Credential:

[source,java]
----
@Override
public boolean isValid(RealmModel realm, UserModel user, CredentialInput input) {
    if (!(input instanceof UserCredentialModel)) {
        logger.debug(""Expected instance of UserCredentialModel for CredentialInput"");
        return false;
    }
    if (!input.getType().equals(getType())) {
        return false;
    }
    String challengeResponse = input.getChallengeResponse();
    if (challengeResponse == null) {
        return false;
    }
    CredentialModel credentialModel = getCredentialStore().getStoredCredentialById(realm, user, input.getCredentialId());
    SecretQuestionCredentialModel sqcm = getCredentialFromModel(credentialModel);
    return sqcm.getSecretQuestionSecretData().getAnswer().equals(challengeResponse);
}
----

The other two methods to implement are a test if the CredentialProvider supports the given credential type and a test to check
if the credential type is configured for a given user. For our case, the latter test simply means checking if the user has a credential
of the SECRET_QUESTION type:

[source,java]
----
@Override
public boolean supportsCredentialType(String credentialType) {
    return getType().equals(credentialType);
}

@Override
public boolean isConfiguredFor(RealmModel realm, UserModel user, String credentialType) {
    if (!supportsCredentialType(credentialType)) return false;
    return !getCredentialStore().getStoredCredentialsByType(realm, user, credentialType).isEmpty();
}
----

==== Implementing an Authenticator

When implementing an authenticator that uses Credentials to authenticate a user, you should have the authenticator implement
the CredentialValidator interface. This interfaces takes a class extending a CredentialProvider as a parameter, and will
allow {project_name} to directly call the methods from the CredentialProvider. The only method that needs to be implemented is
`getCredentialProvider` method, which in our example allows the SecretQuestionAuthenticator to retrieve the SecretQuestionCredentialProvider:

[source,java]
----
public SecretQuestionCredentialProvider getCredentialProvider(KeycloakSession session) {
    return (SecretQuestionCredentialProvider)session.getProvider(CredentialProvider.class, SecretQuestionCredentialProviderFactory.PROVIDER_ID);
}
----

When implementing the Authenticator interface, the first method that needs to be implemented is the requiresUser() method.
For our example, this method must return true as we need to validate the secret question associated with the user.
A provider like kerberos would return false from this method as it can resolve a user from the negotiate header.
This example, however, is validating a specific credential of a specific user.

The next method to implement is the configuredFor() method.
This method is responsible for determining if the user is configured for this particular authenticator. In our case,
we can just call the method implemented in the SecretQuestionCredentialProvider

[source,java]
----
@Override
public boolean configuredFor(KeycloakSession session, RealmModel realm, UserModel user) {
    return getCredentialProvider(session).isConfiguredFor(realm, user, getType(session));
}
----

The next method to implement on the Authenticator is setRequiredActions(). If configuredFor() returns false and our example authenticator
is required within the flow, this method will be called, but only if the associated AuthenticatorFactory's `isUserSetupAllowed` method returns true.
The setRequiredActions() method is responsible for registering any required actions that must be performed by the user.
In our example, we need to register a required action that will force the user to set up the answer to the secret question.
We will implement this required action provider later in this chapter.
Here is the implementation of the setRequiredActions() method.

[source,java]
----
    @Override
    public void setRequiredActions(KeycloakSession session, RealmModel realm, UserModel user) {
        user.addRequiredAction(""SECRET_QUESTION_CONFIG"");
    }
----

Now we are getting into the meat of the Authenticator implementation.
The next method to implement is authenticate().  This is the initial method the flow invokes when the execution is first visited.
What we want is that if a user has answered the secret question already on their browser's machine, then the user doesn't
have to answer the question again, making that machine ""trusted"".  The authenticate() method isn't responsible for processing the secret question form.
Its sole purpose is to render the page or to continue the flow.

[source,java]
----
@Override
public void authenticate(AuthenticationFlowContext context) {
    if (hasCookie(context)) {
        context.success();
        return;
    }
    Response challenge = context.form()
            .createForm(""secret-question.ftl"");
    context.challenge(challenge);
}

protected boolean hasCookie(AuthenticationFlowContext context) {
    Cookie cookie = context.getHttpRequest().getHttpHeaders().getCookies().get(""SECRET_QUESTION_ANSWERED"");
    boolean result = cookie != null;
    if (result) {
        System.out.println(""Bypassing secret question because cookie is set"");
    }
    return result;
}
----

The hasCookie() method checks to see if there is already a cookie set on the browser which indicates that the secret question has already been answered.
If that returns true, we just mark this execution's status as SUCCESS using the AuthenticationFlowContext.success() method and returning from the authentication() method.

If the hasCookie() method returns false, we must return a response that renders the secret question HTML form.
AuthenticationFlowContext has a form() method that initializes a Freemarker page builder with appropriate base information needed to build the form.
This page builder is called `org.keycloak.login.LoginFormsProvider`. The LoginFormsProvider.createForm() method loads a Freemarker template file from your login theme.
Additionally you can call the LoginFormsProvider.setAttribute() method if you want to pass additional information to the Freemarker template.
We'll go over this later.

Calling LoginFormsProvider.createForm() returns a JAX-RS Response object.
We then call AuthenticationFlowContext.challenge() passing in this response.
This sets the status of the execution as CHALLENGE and if the execution is Required, this JAX-RS Response object will be sent to the browser.

So, the HTML page asking for the answer to a secret question is displayed to the user and the user enters in the answer and clicks submit.
The action URL of the HTML form will send an HTTP request to the flow.
The flow will end up invoking the action() method of our Authenticator implementation.

[source,java]
----
@Override
public void action(AuthenticationFlowContext context) {
    boolean validated = validateAnswer(context);
    if (!validated) {
        Response challenge =  context.form()
                .setError(""badSecret"")
                .createForm(""secret-question.ftl"");
        context.failureChallenge(AuthenticationFlowError.INVALID_CREDENTIALS, challenge);
        return;
    }
    setCookie(context);
    context.success();
}
----

If the answer is not valid, we rebuild the HTML Form with an additional error message.
We then call AuthenticationFlowContext.failureChallenge() passing in the reason for the value and the JAX-RS response.
failureChallenge() works the same as challenge(), but it also records the failure so it can be analyzed by any attack detection service.

If validation is successful, then we set a cookie to remember that the secret question has been answered and we call AuthenticationFlowContext.success().

The validation itself gets the data that was received from the form, and calls the isValid method from the SecretQuestionCredentialProvider. You'll notice
that there's a section of the code concerning getting the credential Id. This is because if {project_name} is configured to allow multiple types of alternative
authenticators, or if the user could record multiple credentials of the SECRET_QUESTION type (for example if we allowed to choose from several questions,
and we allowed the user to have answers for more than one of those questions), then {project_name} needs to know which credential is being used to log the user.
In case there is more than one credential, {project_name} allows the user to choose during the login which credential is being used, and the information is transmitted by
the form to the Authenticator.
In case the form doesn't present this information, credential id used is given by the CredentialProvider's `default getDefaultCredential` method, which will
return the ""most preferred"" credential of the correct type of the user,

[source,java]
----
protected boolean validateAnswer(AuthenticationFlowContext context) {
    MultivaluedMap<String, String> formData = context.getHttpRequest().getDecodedFormParameters();
    String secret = formData.getFirst(""secret_answer"");
    String credentialId = formData.getFirst(""credentialId"");
    if (credentialId == null || credentialId.isEmpty()) {
        credentialId = getCredentialProvider(context.getSession())
                .getDefaultCredential(context.getSession(), context.getRealm(), context.getUser()).getId();
    }

    UserCredentialModel input = new UserCredentialModel(credentialId, getType(context.getSession()), secret);
    return getCredentialProvider(context.getSession()).isValid(context.getRealm(), context.getUser(), input);
}
----

Next method is the setCookie().
This is an example of providing configuration for the Authenticator.
In this case we want the max age of the cookie to be configurable.

[source,java]
----
protected void setCookie(AuthenticationFlowContext context) {
    AuthenticatorConfigModel config = context.getAuthenticatorConfig();
    int maxCookieAge = 60 * 60 * 24 * 30; // 30 days
    if (config != null) {
        maxCookieAge = Integer.valueOf(config.getConfig().get(""cookie.max.age""));

    }
    URI uri = context.getUriInfo().getBaseUriBuilder().path(""realms"").path(context.getRealm().getName()).build();
    addCookie(context, ""SECRET_QUESTION_ANSWERED"", ""true"",
            uri.getRawPath(),
            null, null,
            maxCookieAge,
            false, true);
}
----

We obtain an AuthenticatorConfigModel from the AuthenticationFlowContext.getAuthenticatorConfig() method.
If configuration exists we pull the max age config out of it.
We will see how we can define what should be configured when we talk about the AuthenticatorFactory implementation.
The config values can be defined within the admin console if you set up config definitions in your AuthenticatorFactory implementation.

[source,java]
----
@Override
    public CredentialTypeMetadata getCredentialTypeMetadata(CredentialTypeMetadataContext metadataContext) {
        return CredentialTypeMetadata.builder()
                .type(getType())
                .category(CredentialTypeMetadata.Category.TWO_FACTOR)
                .displayName(SecretQuestionCredentialProviderFactory.PROVIDER_ID)
                .helpText(""secret-question-text"")
                .createAction(SecretQuestionAuthenticatorFactory.PROVIDER_ID)
                .removeable(false)
                .build(session);
    }
----

The last method to implement in the SecretQuestionCredentialProvider class is getCredentialTypeMetadata(CredentialTypeMetadataContext metadataContext), which is an abstract method of the CredentialProvider interface. Each Credential provider has to provide and implement this method. The method returns an instance of CredentialTypeMetadata,
which should at least include type and category of authenticator, displayName and removable item. In this example, the builder
takes type of authenticator from method getType(), category is Two Factor (the authenticator can be used as second factor of authentication)
and removable, which is set up to false (user can't remove some previously registered credentials).

Other items of builder are helpText (will be shown to the user on various screens), createAction (the providerID of the required action,
which can be used by the user to create new credential) or updateAction (same as createAction, but instead of creating the new credential, it will update the credential).

==== Implementing an AuthenticatorFactory

The next step in this process is to implement an AuthenticatorFactory.
This factory is responsible for instantiating an Authenticator.
It also provides deployment and configuration metadata about the Authenticator.

The getId() method is just the unique name of the component.
The create() method is called by the runtime to allocate and process the Authenticator.

[source,java]
----

public class SecretQuestionAuthenticatorFactory implements AuthenticatorFactory, ConfigurableAuthenticatorFactory {

    public static final String PROVIDER_ID = ""secret-question-authenticator"";
    private static final SecretQuestionAuthenticator SINGLETON = new SecretQuestionAuthenticator();

    @Override
    public String getId() {
        return PROVIDER_ID;
    }

    @Override
    public Authenticator create(KeycloakSession session) {
        return SINGLETON;
    }
----

The next thing the factory is responsible for is to specify the allowed requirement switches.
While there are four different requirement types:  ALTERNATIVE, REQUIRED, CONDITIONAL, DISABLED, AuthenticatorFactory implementations can limit which
requirement options are shown in the admin console when defining a flow. CONDITIONAL should only always be used for subflows, and unless there's a good
reason for doing otherwise, the requirement on a authenticator should be REQUIRED, ALTERNATIVE and DISABLED:

[source,java]
----

    private static AuthenticationExecutionModel.Requirement[] REQUIREMENT_CHOICES = {
            AuthenticationExecutionModel.Requirement.REQUIRED,
            AuthenticationExecutionModel.Requirement.ALTERNATIVE,
            AuthenticationExecutionModel.Requirement.DISABLED
    };
    @Override
    public AuthenticationExecutionModel.Requirement[] getRequirementChoices() {
        return REQUIREMENT_CHOICES;
    }
----

The AuthenticatorFactory.isUserSetupAllowed() is a flag that tells the flow manager whether or not Authenticator.setRequiredActions() method will be called.
If an Authenticator is not configured for a user, the flow manager checks isUserSetupAllowed().  If it is false, then the flow aborts with an error.
If it returns true, then the flow manager will invoke Authenticator.setRequiredActions().

[source,java]
----

    @Override
    public boolean isUserSetupAllowed() {
        return true;
    }
----

The next few methods define how the Authenticator can be configured.
The isConfigurable() method is a flag which specifies to the admin console on whether the Authenticator can be configured within a flow.
The getConfigProperties() method returns a list of ProviderConfigProperty objects.
These objects define a specific configuration attribute.

[source,java]
----

    @Override
    public List<ProviderConfigProperty> getConfigProperties() {
        return configProperties;
    }

    private static final List<ProviderConfigProperty> configProperties = new ArrayList<ProviderConfigProperty>();

    static {
        ProviderConfigProperty property;
        property = new ProviderConfigProperty();
        property.setName(""cookie.max.age"");
        property.setLabel(""Cookie Max Age"");
        property.setType(ProviderConfigProperty.STRING_TYPE);
        property.setHelpText(""Max age in seconds of the SECRET_QUESTION_COOKIE."");
        configProperties.add(property);
    }
----

Each ProviderConfigProperty defines the name of the config property.
This is the key used in the config map stored in AuthenticatorConfigModel.
The label defines how the config option will be displayed in the admin console.
The type defines if it is a String, Boolean, or other type.
The admin console will display different UI inputs depending on the type.
The help text is what will be shown in the tooltip for the config attribute in the admin console.
Read the javadoc of ProviderConfigProperty for more detail.

The rest of the methods are for the admin console.
getHelpText() is the tooltip text that will be shown when you are picking the Authenticator you want to bind to an execution.
getDisplayType() is the text that will be shown in the admin console when listing the Authenticator.
getReferenceCategory() is just a category the Authenticator belongs to.

==== Adding Authenticator Form

{project_name} comes with a Freemarker <<_themes,theme and template engine>>.
The createForm() method you called within authenticate() of your Authenticator class, builds an HTML page from a file within your login theme: `secret-question.ftl`.
This file should be added to the `theme-resources/templates` in your JAR, see <<_theme_resource,Theme Resource Provider>> for more details.

Let's take a bigger look at secret-question.ftl  Here's a small code snippet:

[source,java]
----

        <form id=""kc-totp-login-form"" class=""${properties.kcFormClass!}"" action=""${url.loginAction}"" method=""post"">
            <div class=""${properties.kcFormGroupClass!}"">
                <div class=""${properties.kcLabelWrapperClass!}"">
                    <label for=""totp"" class=""${properties.kcLabelClass!}"">${msg(""loginSecretQuestion"")}</label>
                </div>

                <div class=""${properties.kcInputWrapperClass!}"">
                    <input id=""totp"" name=""secret_answer"" type=""text"" class=""${properties.kcInputClass!}"" />
                </div>
            </div>
        </form>
----

Any piece of text enclosed in `${}` corresponds to an attribute or template funtion.
If you see the form's action, you see it points to `${url.loginAction}`.
This value is automatically generated when you invoke the AuthenticationFlowContext.form() method.
You can also obtain this value by calling the AuthenticationFlowContext.getActionURL() method in Java code.

You'll also see `${properties.someValue}`.
These correspond to properties defined in your theme.properties file of our theme.
 `${msg(""someValue"")}` corresponds to the internationalized message bundles (.properties files) included with the login theme messages/ directory.
If you're just using english, you can just add the value of the `loginSecretQuestion`.
This should be the question you want to ask the user.

When you call AuthenticationFlowContext.form() this gives you a LoginFormsProvider  instance.
If you called, `LoginFormsProvider.setAttribute(""foo"", ""bar"")`, the value of ""foo"" would be available for reference in your form as `${foo}`.
The value of an attribute can be any Java bean as well.

If you look at the top of the file, you'll see that we are importing a template:

[source,java]
----
<#import ""select.ftl"" as layout>
----

Importing this template, instead of the standard `template.ftl` allows {project_name} to display a dropdown box that allows the user to select
a different credential or execution.

[[_adding_authenticator]]
==== Adding Authenticator to a Flow

Adding an Authenticator to a flow must be done in the admin console.
If you go to the Authentication menu item and go to the Flow tab, you will be able to view the currently defined flows.
You cannot modify built in flows, so, to add the Authenticator we've created you have to copy an existing flow or create your own.
Our hope is that the user interface is sufficiently clear so that you can determine how to create a flow and add the Authenticator. For
more details, see the `Authentication Flows` chapter in link:{adminguide_link}[{adminguide_name}] .

After you've created your flow, you have to bind it to the login action you want to bind it to.
If you go to the Authentication menu and go  to the Bindings tab you will see options to bind a flow to the browser, registration, or direct grant flow.

=== Required Action Walkthrough

In this section we will discuss how to define a required action.
In the Authenticator section you may have wondered, ""How will we get the user's answer to the secret question entered into the system?"".  As we showed in the example, if the answer is not set up, a required action will be triggered.
This section discusses how to implement the required action for the Secret Question Authenticator.

==== Packaging Classes and Deployment

You will package your classes within a single jar.
This jar does not have to be separate from other provider classes but it must contain a file named  `org.keycloak.authentication.RequiredActionFactory`                and must be contained in the `META-INF/services/` directory of your jar.
This file must list the fully qualified classname of each RequiredActionFactory implementation you have in the jar.
For example:

[source,java]
----
org.keycloak.examples.authenticator.SecretQuestionRequiredActionFactory
----

This services/ file is used by {project_name} to scan the providers it has to load into the system.

To deploy this jar, just copy it to the `standalone/deployments` directory.

==== Implement the RequiredActionProvider

Required actions must first implement the RequiredActionProvider interface.
The RequiredActionProvider.requiredActionChallenge() is the initial call by the flow manager into the required action.
This method is responsible for rendering the HTML form that will drive the required action.

[source,java]
----

    @Override
    public void requiredActionChallenge(RequiredActionContext context) {
        Response challenge = context.form().createForm(""secret_question_config.ftl"");
        context.challenge(challenge);

    }
----

You see that RequiredActionContext has similar methods to AuthenticationFlowContext.
The form() method allows you to render the page from a Freemarker template.
The action URL is preset by the call to this form() method.
You just need to reference it within your HTML form.
I'll show you this later.

The challenge() method notifies the flow manager that a required action must be executed.

The next method is responsible for processing input from the HTML form of the required action.
The action URL of the form will be routed to the RequiredActionProvider.processAction() method

[source,java]
----

    @Override
    public void processAction(RequiredActionContext context) {
        String answer = (context.getHttpRequest().getDecodedFormParameters().getFirst(""answer""));
        UserCredentialValueModel model = new UserCredentialValueModel();
        model.setValue(answer);
        model.setType(SecretQuestionAuthenticator.CREDENTIAL_TYPE);
        context.getUser().updateCredentialDirectly(model);
        context.success();
    }
----

The answer is pulled out of the form post.
A UserCredentialValueModel is created and the type and value of the credential are set.
Then UserModel.updateCredentialDirectly() is invoked.
Finally, RequiredActionContext.success() notifies the container that the required action was successful.

==== Implement the RequiredActionFactory

This class is really simple.
It is just responsible for creating the required action provider instance.

[source,java]
----

public class SecretQuestionRequiredActionFactory implements RequiredActionFactory {

    private static final SecretQuestionRequiredAction SINGLETON = new SecretQuestionRequiredAction();

    @Override
    public RequiredActionProvider create(KeycloakSession session) {
        return SINGLETON;
    }


    @Override
    public String getId() {
        return SecretQuestionRequiredAction.PROVIDER_ID;
    }

    @Override
    public String getDisplayText() {
        return ""Secret Question"";
    }
----

The getDisplayText() method is just for the admin console when it wants to display a friendly name for the required action.

==== Enable Required Action

The final thing you have to do is go into the admin console.
Click on the Authentication left menu.
Click on the Required Actions tab.
Click on the Register button and choose your new Required Action.
Your new required action should now be displayed and enabled in the required actions list.

=== Modifying/Extending the Registration Form

It is entirely possible for you to implement your own flow with a set of Authenticators to totally change how registration is done in {project_name}.
But what you'll usually want to do is just add a little bit of validation to the out of the box registration page.
An additional SPI was created to be able to do this.
It basically allows you to add validation of form elements on the page as well as to initialize UserModel attributes and data after the user has been registered.
We'll look at both the implementation of the user profile registration processing as well as the registration Google Recaptcha plugin.

==== Implementation FormAction Interface

The core interface you have to implement is the FormAction interface.
A FormAction is responsible for rendering and processing a portion of the page.
Rendering is done in the buildPage() method, validation is done in the validate() method, post validation operations are done in success().  Let's first take a look at buildPage() method of the Recaptcha plugin.

[source,java]
----

    @Override
    public void buildPage(FormContext context, LoginFormsProvider form) {
        AuthenticatorConfigModel captchaConfig = context.getAuthenticatorConfig();
        if (captchaConfig == null || captchaConfig.getConfig() == null
                || captchaConfig.getConfig().get(SITE_KEY) == null
                || captchaConfig.getConfig().get(SITE_SECRET) == null
                ) {
            form.addError(new FormMessage(null, Messages.RECAPTCHA_NOT_CONFIGURED));
            return;
        }
        String siteKey = captchaConfig.getConfig().get(SITE_KEY);
        form.setAttribute(""recaptchaRequired"", true);
        form.setAttribute(""recaptchaSiteKey"", siteKey);
        form.addScript(""https://www.google.com/recaptcha/api.js"");
    }
----

The Recaptcha buildPage() method is a callback by the form flow to help render the page.
It receives a form parameter which is a LoginFormsProvider.
You can add additional attributes to the form provider so that they can be displayed in the HTML page generated by the registration Freemarker template.

The code above is from the registration recaptcha plugin.
Recaptcha requires some specific settings that must be obtained from configuration.
FormActions are configured in the exact same as Authenticators are.
In this example, we pull the Google Recaptcha site key from configuration and add it as an attribute to the form provider.
Our registration template file can read this attribute now.

Recaptcha also has the requirement of loading a JavaScript script.
You can do this by calling LoginFormsProvider.addScript() passing in the URL.

For user profile processing, there is no additional information that it needs to add to the form, so its buildPage() method is empty.

The next meaty part of this interface is the validate() method.
This is called immediately upon receiving a form post.
Let's look at the Recaptcha's plugin first.

[source,java]
----

    @Override
    public void validate(ValidationContext context) {
        MultivaluedMap<String, String> formData = context.getHttpRequest().getDecodedFormParameters();
        List<FormMessage> errors = new ArrayList<>();
        boolean success = false;

        String captcha = formData.getFirst(G_RECAPTCHA_RESPONSE);
        if (!Validation.isBlank(captcha)) {
            AuthenticatorConfigModel captchaConfig = context.getAuthenticatorConfig();
            String secret = captchaConfig.getConfig().get(SITE_SECRET);

            success = validateRecaptcha(context, success, captcha, secret);
        }
        if (success) {
            context.success();
        } else {
            errors.add(new FormMessage(null, Messages.RECAPTCHA_FAILED));
            formData.remove(G_RECAPTCHA_RESPONSE);
            context.validationError(formData, errors);
            return;


        }
    }
----

Here we obtain the form data that the Recaptcha widget adds to the form.
We obtain the Recaptcha secret key from configuration.
We then validate the recaptcha.
If successful, ValidationContext.success() is called.
If not, we invoke ValidationContext.validationError() passing in the formData (so the user doesn't have to re-enter data), we also specify an error message we want displayed.
The error message must point to a message bundle property in the internationalized message bundles.
For other registration extensions validate() might be validating the format of a form element, i.e.
an alternative email attribute.

Let's also look at the user profile plugin that is used to validate email address and other user information when registering.

[source,java]
----

    @Override
    public void validate(ValidationContext context) {
        MultivaluedMap<String, String> formData = context.getHttpRequest().getDecodedFormParameters();
        List<FormMessage> errors = new ArrayList<>();

        String eventError = Errors.INVALID_REGISTRATION;

        if (Validation.isBlank(formData.getFirst((RegistrationPage.FIELD_FIRST_NAME)))) {
            errors.add(new FormMessage(RegistrationPage.FIELD_FIRST_NAME, Messages.MISSING_FIRST_NAME));
        }

        if (Validation.isBlank(formData.getFirst((RegistrationPage.FIELD_LAST_NAME)))) {
            errors.add(new FormMessage(RegistrationPage.FIELD_LAST_NAME, Messages.MISSING_LAST_NAME));
        }

        String email = formData.getFirst(Validation.FIELD_EMAIL);
        if (Validation.isBlank(email)) {
            errors.add(new FormMessage(RegistrationPage.FIELD_EMAIL, Messages.MISSING_EMAIL));
        } else if (!Validation.isEmailValid(email)) {
            formData.remove(Validation.FIELD_EMAIL);
            errors.add(new FormMessage(RegistrationPage.FIELD_EMAIL, Messages.INVALID_EMAIL));
        }

        if (context.getSession().users().getUserByEmail(email, context.getRealm()) != null) {
            formData.remove(Validation.FIELD_EMAIL);
            errors.add(new FormMessage(RegistrationPage.FIELD_EMAIL, Messages.EMAIL_EXISTS));
        }

        if (errors.size() > 0) {
            context.validationError(formData, errors);
            return;

        } else {
            context.success();
        }
    }
----

As you can see, this validate() method of user profile processing makes sure that the email, first, and last name are filled in the form.
It also makes sure that email is in the right format.
If any of these validations fail, an error message is queued up for rendering.
Any fields in error are removed from the form data.
Error messages are represented by the FormMessage class.
The first parameter of the constructor of this class takes the HTML element id.
The input in error will be highlighted when the form is re-rendered.
The second parameter is a message reference id.
This id must correspond to a property in one of the localized message bundle files.
in the theme.

After all validations have been processed then, the form flow then invokes the FormAction.success() method.
For recaptcha this is a no-op, so we won't go over it.
For user profile processing, this method fills in values in the registered user.

[source,java]
----

    @Override
    public void success(FormContext context) {
        UserModel user = context.getUser();
        MultivaluedMap<String, String> formData = context.getHttpRequest().getDecodedFormParameters();
        user.setFirstName(formData.getFirst(RegistrationPage.FIELD_FIRST_NAME));
        user.setLastName(formData.getFirst(RegistrationPage.FIELD_LAST_NAME));
        user.setEmail(formData.getFirst(RegistrationPage.FIELD_EMAIL));
    }
----

Pretty simple implementation.
The UserModel of the newly registered user is obtained from the FormContext.
The appropriate methods are called to initialize UserModel data.

Finally, you are also required to define a FormActionFactory class.
This class is implemented similarly to AuthenticatorFactory, so we won't go over it.

==== Packaging the Action

You will package your classes within a single jar.
This jar must contain a file named  `org.keycloak.authentication.FormActionFactory`                and must be contained in the `META-INF/services/` directory of your jar.
This file must list the fully qualified class name of each FormActionFactory implementation you have in the jar.
For example:

[source]
----

org.keycloak.authentication.forms.RegistrationProfile
org.keycloak.authentication.forms.RegistrationRecaptcha
----

This services/ file is used by {project_name} to scan the providers it has to load into the system.

To deploy this jar, just copy it to the `standalone/deployments` directory.

==== Adding FormAction to the Registration Flow

Adding a FormAction to a registration page flow must be done in the admin console.
If you go to the Authentication menu item and go to the Flow tab, you will be able to view the currently defined flows.
You cannot modify built in flows, so, to add the Authenticator we've created you have to copy an existing flow or create your own.
I'm hoping the UI is intuitive enough so that you can figure out for yourself how to create a flow and add the FormAction.

Basically you'll have to copy the registration flow.
Then click Actions menu to the right of the Registration Form, and pick ""Add execution"" to add a new execution.
You'll pick the FormAction from the selection list.
Make sure your FormAction comes after ""Registration User Creation"" by using the down buttons to move it if your FormAction isn't already listed after ""Registration User Creation"".  You want your FormAction to come after user creation because the success() method of Registration User Creation is responsible for creating the new UserModel.

After you've created your flow, you have to bind it to registration.
If you go to the Authentication menu and go  to the Bindings tab you will see options to bind a flow to the browser, registration, or direct grant flow.

=== Modifying Forgot Password/Credential Flow

{project_name} also has a specific authentication flow for forgot password, or rather credential reset initiated by a user.
If you go to the admin console flows page, there is a ""reset credentials"" flow.
By default, {project_name} asks for the email or username of the user and sends an email to them.
If the user clicks on the link, then they are able to reset both their password and OTP (if an OTP has been set up).  You can disable automatic OTP reset by disabling the ""Reset OTP"" authenticator in the flow.

You can add additional functionality to this flow as well.
For example, many deployments would like for the user to answer one or more secret questions in additional to sending an email with a link.
You could expand on the secret question example that comes with the distro and incorporate it into the reset credential flow.

One thing to note if you are extending the reset credentials flow.
The first ""authenticator"" is just a page to obtain the username or email.
If the username or email exists, then the AuthenticationFlowContext.getUser() will return the located user.
Otherwise this will be null.
This form *WILL NOT* re-ask the user to enter in an email or username if the previous email or username did not exist.
You need to prevent attackers from being able to guess valid users.
So, if AuthenticationFlowContext.getUser() returns null, you should proceed with the flow to make it look like a valid user was selected.
I suggest that if you want to add secret questions to this flow, you should ask these questions after the email is sent.
In other words, add your custom authenticator after the ""Send Reset Email"" authenticator.

=== Modifying First Broker Login Flow

First Broker Login flow is used during first login with some identity provider.
Term `First Login` means that there is not yet existing {project_name} account linked with the particular authenticated identity provider account.
For more details about this flow see the `Identity Brokering` chapter in link:{adminguide_link}[{adminguide_name}] .

[[_client_authentication]]
=== Authentication of clients

{project_name} actually supports pluggable authentication for https://openid.net/specs/openid-connect-core-1_0.html[OpenID Connect] client applications.
Authentication of client (application) is used under the hood by the {project_name} adapter during sending any backchannel requests
to the {project_name} server (like the request for exchange code to access token after successful authentication or request to refresh token).
But the client authentication can be also used directly by you during `Direct Access grants` (represented by OAuth2 `Resource Owner Password Credentials Flow`)
or during `Service account` authentication (represented by OAuth2 `Client Credentials Flow`).

For more details about {project_name} adapter and OAuth2 flows see link:{adapterguide_link}[{adapterguide_name}].

==== Default implementations

Actually {project_name} has 2 default implementations of client authentication:

Traditional authentication with client_id and client_secret::
  This is default mechanism mentioned in the https://openid.net/specs/openid-connect-core-1_0.html[OpenID Connect]                                or https://datatracker.ietf.org/doc/html/rfc6749[OAuth2] specification and {project_name} supports it since it's early days.
  The public client needs to include `client_id` parameter with its ID in the POST request (so it's defacto not authenticated) and the confidential client needs to include `Authorization: Basic` header with the clientId and clientSecret used as username and password.

Authentication with signed JWT::
  This is based on the https://datatracker.ietf.org/doc/html/rfc7523[JWT Bearer Token Profiles for OAuth 2.0] specification.
  The client/adapter generates the https://datatracker.ietf.org/doc/html/rfc7519[JWT] and signs it with his private key.
  The {project_name} then verifies the signed JWT with the client's public key and authenticates client based on it.

See the demo example and especially the `examples/preconfigured-demo/product-app` for the example application showing
the application using client authentication with signed JWT.

==== Implement your own client authenticator

For plug your own client authenticator, you need to implement few interfaces on both client (adapter) and server side.

Client side::
Here you need to implement `org.keycloak.adapters.authentication.ClientCredentialsProvider` and put the implementation either to:

* your WAR file into WEB-INF/classes . But in this case, the implementation can be used just for this single WAR application
* Some JAR file, which will be added into WEB-INF/lib of your WAR
  * Some JAR file, which will be used as jboss module and configured in jboss-deployment-structure.xml of your WAR.                                In all cases, you also need to create the file `META-INF/services/org.keycloak.adapters.authentication.ClientCredentialsProvider`                                either in the WAR or in your JAR.

Server side::
  Here you need to implement `org.keycloak.authentication.ClientAuthenticatorFactory` and `org.keycloak.authentication.ClientAuthenticator` . You also need to add the file `META-INF/services/org.keycloak.authentication.ClientAuthenticatorFactory` with the name of the implementation classes.
  See <<_auth_spi_walkthrough,authenticators>> for more details.
",12505,False,2028.9804982705814,median
"---
title: ""FreeBSD/i386 5.5-RELEASE Release Notes""
sidenav: download
---

++++


<h3 class=""CORPAUTHOR"">The FreeBSD Project</h3>

<p class=""COPYRIGHT"">Copyright &copy; 2000, 2001, 2002, 2003, 2004, 2005, 2006 The
FreeBSD Documentation Project</p>

<p class=""PUBDATE"">$FreeBSD: src/release/doc/en_US.ISO8859-1/relnotes/common/new.sgml,v
1.761.2.59.2.2 2006/05/22 17:05:47 bmah Exp $<br />
</p>

<div class=""LEGALNOTICE""><a id=""TRADEMARKS"" name=""TRADEMARKS""></a>
<p>FreeBSD is a registered trademark of the FreeBSD Foundation.</p>

<p>IBM, AIX, EtherJet, Netfinity, OS/2, PowerPC, PS/2, S/390, and ThinkPad are trademarks
of International Business Machines Corporation in the United States, other countries, or
both.</p>

<p>IEEE, POSIX, and 802 are registered trademarks of Institute of Electrical and
Electronics Engineers, Inc. in the United States.</p>

<p>Intel, Celeron, EtherExpress, i386, i486, Itanium, Pentium, and Xeon are trademarks or
registered trademarks of Intel Corporation or its subsidiaries in the United States and
other countries.</p>

<p>Sparc, Sparc64, SPARCEngine, and UltraSPARC are trademarks of SPARC International, Inc
in the United States and other countries. Products bearing SPARC trademarks are based
upon architecture developed by Sun Microsystems, Inc.</p>

<p>Many of the designations used by manufacturers and sellers to distinguish their
products are claimed as trademarks. Where those designations appear in this document, and
the FreeBSD Project was aware of the trademark claim, the designations have been followed
by the ``&trade;'' or the ``&reg;'' symbol.</p>
</div>

<div>
<div class=""ABSTRACT""><a id=""AEN24"" name=""AEN24""></a>
<p>The release notes for FreeBSD 5.5-RELEASE contain a summary of the changes made to the
FreeBSD base system since 5.4-RELEASE. This document lists applicable security advisories
that were issued since the last release, as well as significant changes to the FreeBSD
kernel and userland. Some brief remarks on upgrading are also presented.</p>
</div>
</div>

<hr />
</div>

<div class=""TOC"">
<dl>
<dt><b>Table of Contents</b></dt>

<dt>1 <a href=""#INTRO"">Introduction</a></dt>

<dt>2 <a href=""#NEW"">What's New</a></dt>

<dd>
<dl>
<dt>2.1 <a href=""#SECURITY"">Security Advisories</a></dt>

<dt>2.2 <a href=""#KERNEL"">Kernel Changes</a></dt>

<dd>
<dl>
<dt>2.2.1 <a href=""#BOOT"">Boot Loader Changes</a></dt>

<dt>2.2.2 <a href=""#PROC"">Hardware Support</a></dt>

<dt>2.2.3 <a href=""#NET-PROTO"">Network Protocols</a></dt>

<dt>2.2.4 <a href=""#DISKS"">Disks and Storage</a></dt>

<dt>2.2.5 <a href=""#FS"">File Systems</a></dt>

<dt>2.2.6 <a href=""#AEN229"">Contributed Software</a></dt>
</dl>
</dd>

<dt>2.3 <a href=""#USERLAND"">Userland Changes</a></dt>

<dd>
<dl>
<dt>2.3.1 <a href=""#RC-SCRIPTS""><tt class=""FILENAME"">/etc/rc.d</tt> Scripts</a></dt>
</dl>
</dd>

<dt>2.4 <a href=""#CONTRIB"">Contributed Software</a></dt>

<dt>2.5 <a href=""#PORTS"">Ports/Packages Collection Infrastructure</a></dt>

<dt>2.6 <a href=""#RELENG"">Release Engineering and Integration</a></dt>

<dt>2.7 <a href=""#DOC"">Documentation</a></dt>
</dl>
</dd>

<dt>3 <a href=""#UPGRADE"">Upgrading from previous releases of FreeBSD</a></dt>
</dl>
</div>

<div class=""SECT1"">
<h2 class=""SECT1""><a id=""INTRO"" name=""INTRO"">1 Introduction</a></h2>

<p>This document contains the release notes for FreeBSD 5.5-RELEASE on the i386 hardware
platform. It describes recently added, changed, or deleted features of FreeBSD. It also
provides some notes on upgrading from previous versions of FreeBSD.</p>

<p>This distribution of FreeBSD 5.5-RELEASE is a release distribution. It can be found at
<a href=""ftp://ftp.FreeBSD.org/"" target=""_top"">ftp://ftp.FreeBSD.org/</a> or any of its
mirrors. More information on obtaining this (or other) release distributions of FreeBSD
can be found in the <a
href=""http://www.FreeBSD.org/doc/en_US.ISO8859-1/books/handbook/mirrors.html""
target=""_top"">``Obtaining FreeBSD'' appendix</a> to the <a
href=""http://www.FreeBSD.org/doc/en_US.ISO8859-1/books/handbook/"" target=""_top"">FreeBSD
Handbook</a>.</p>

<p>All users are encouraged to consult the release errata before installing FreeBSD. The
errata document is updated with ``late-breaking'' information discovered late in the
release cycle or after the release. Typically, it contains information on known bugs,
security advisories, and corrections to documentation. An up-to-date copy of the errata
for FreeBSD 5.5-RELEASE can be found on the FreeBSD Web site.</p>

<p>FreeBSD 5.5-RELEASE is the last planned release on the 5.5-STABLE branch. The FreeBSD
development community is currently focusing its efforts on the 6-STABLE and CURRENT
codelines. No new major features are planned for the 5.5-STABLE branch, although minor
updates and bugfixes may be merged at the discretion of individual developers. The
FreeBSD security team will support the 5.5-RELEASE-based security branch with advisories
and security patches until the end-of-life date documented at <a
href=""http://security.freebsd.org/"" target=""_top"">http://security.freebsd.org/</a> (as of
this writing, 31 May 2008).</p>
</div>

<div class=""SECT1"">
<hr />
<h2 class=""SECT1""><a id=""NEW"" name=""NEW"">2 What's New</a></h2>

<p>This section describes the most user-visible new or changed features in FreeBSD since
5.4-RELEASE.</p>

<p>Typical release note items document recent security advisories issued after
5.4-RELEASE, new drivers or hardware support, new commands or options, major bug fixes,
or contributed software upgrades. They may also list changes to major ports/packages or
release engineering practices. Clearly the release notes cannot list every single change
made to FreeBSD between releases; this document focuses primarily on security advisories,
user-visible changes, and major architectural improvements.</p>

<div class=""SECT2"">
<hr />
<h3 class=""SECT2""><a id=""SECURITY"" name=""SECURITY"">2.1 Security Advisories</a></h3>

<p>Because of an information disclosure vulnerability on processors using Hyper-Threading
Technology (HTT), the <code class=""VARNAME"">machdep.hyperthreading_allowed</code> sysctl
variable has been added. It defaults to <tt class=""LITERAL"">1</tt> (HTT enabled) on
FreeBSD CURRENT, and <tt class=""LITERAL"">0</tt> (HTT disabled) on the 4-STABLE and
5-STABLE development branches and supported security fix branches. More information can
be found in security advisory <a
href=""ftp://ftp.FreeBSD.org/pub/FreeBSD/CERT/advisories/FreeBSD-SA-05:09.htt.asc""
target=""_top"">FreeBSD-SA-05:09.htt</a>.</p>

<p>A bug in the <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=tcpdump&amp;sektion=1&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">tcpdump</span>(1)</span></a>
utility which allows a malicious remote user to cause a denial-of-service by using
specially crafted packets, has been fixed. For more information, see security advisory <a
href=""ftp://ftp.FreeBSD.org/pub/FreeBSD/CERT/advisories/FreeBSD-SA-05:10.tcpdump.asc""
target=""_top"">FreeBSD-SA-05:10.tcpdump</a>.</p>

<p>Two problems in the <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=gzip&amp;sektion=1&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">gzip</span>(1)</span></a> utility
have been fixed. These may allow a local user to modify permissions of arbitrary files
and overwrite arbitrary local files when uncompressing a file. For more information, see
security advisory <a
href=""ftp://ftp.FreeBSD.org/pub/FreeBSD/CERT/advisories/FreeBSD-SA-05:11.gzip.asc""
target=""_top"">FreeBSD-SA-05:11.gzip</a>.</p>

<p>A bug has been fixed in <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=ipfw&amp;sektion=4&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">ipfw</span>(4)</span></a> that
could cause packets to be matched incorrectly against a lookup table. This bug only
affects SMP machines or UP machines that have the <tt class=""LITERAL"">PREEMPTION</tt>
kernel option enabled. More information is contained in security advisory <a
href=""ftp://ftp.FreeBSD.org/pub/FreeBSD/CERT/advisories/FreeBSD-SA-05:13.ipfw.asc""
target=""_top"">FreeBSD-SA-05:13.ipfw</a>.</p>

<p>Two security-related problems have been fixed in <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=bzip2&amp;sektion=1&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">bzip2</span>(1)</span></a>. These
include a potential denial of service and unauthorized manipulation of file permissions.
For more information, see security advisory <a
href=""ftp://ftp.FreeBSD.org/pub/FreeBSD/CERT/advisories/FreeBSD-SA-05:14.bzip2.asc""
target=""_top"">FreeBSD-SA-05:14.bzip2</a>.</p>

<p>Two problems in FreeBSD's TCP stack have been fixed. They could allow attackers to
stall existing TCP connections, creating a denial-of-service situation. More information
is contained in security advisory <a
href=""ftp://ftp.FreeBSD.org/pub/FreeBSD/CERT/advisories/FreeBSD-SA-05:15.tcp.asc""
target=""_top"">FreeBSD-SA-05:15.tcp</a>.</p>

<p>Two buffer overflows in the zlib library has been corrected. More information can be
found in security advisory <a
href=""ftp://ftp.FreeBSD.org/pub/FreeBSD/CERT/advisories/FreeBSD-SA-05:16.zlib.asc""
target=""_top"">FreeBSD-SA-05:16.zlib</a> and <a
href=""ftp://ftp.FreeBSD.org/pub/FreeBSD/CERT/advisories/FreeBSD-SA-05:18.zlib.asc""
target=""_top"">FreeBSD-SA-05:18.zlib</a>.</p>

<p>A security vulnerability that could allow processes running inside a <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=jail&amp;sektion=2&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">jail</span>(2)</span></a> to gain
access to hidden <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=devfs&amp;sektion=5&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">devfs</span>(5)</span></a> file
nodes has been corrected, as described in security advisory <a
href=""ftp://ftp.FreeBSD.org/pub/FreeBSD/CERT/advisories/FreeBSD-SA-05:17.devfs.asc""
target=""_top"">FreeBSD-SA-05:17.devfs</a>.</p>

<p>A programming error in the <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=ipsec&amp;sektion=4&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">ipsec</span>(4)</span></a>
implementation, which resulted in AES-XCBC-MAC authentication using a constant key, has
been corrected. More details are in security advisory <a
href=""ftp://ftp.FreeBSD.org/pub/FreeBSD/CERT/advisories/FreeBSD-SA-05:19.ipsec.asc""
target=""_top"">FreeBSD-SA-05:19.ipsec</a>.</p>

<p>A temporary file vulnerability in <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=cvsbug&amp;sektion=8&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">cvsbug</span>(8)</span></a>, which
could allow an attacker to modify or overwrite files with the permissions of a user
running the <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=cvsbug&amp;sektion=8&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">cvsbug</span>(8)</span></a>
utility, has been fixed. More details can be found in security advisory <a
href=""ftp://ftp.FreeBSD.org/pub/FreeBSD/CERT/advisories/FreeBSD-SA-05:20.cvsbug.asc""
target=""_top"">FreeBSD-SA-05:20.cvsbug</a>.</p>

<p>A bug in OpenSSL that could allow an attacker to force an use older version of the SSL
(with known weakensses) has been corrected. Details can be found in security advisory <a
href=""ftp://ftp.FreeBSD.org/pub/FreeBSD/CERT/advisories/FreeBSD-SA-05:21.openssl.asc""
target=""_top"">FreeBSD-SA-05:21.openssl</a>.</p>

<p>A temporary file vulnerability in <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=texindex&amp;sektion=1&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">texindex</span>(1)</span></a>,
which could allow a local attacker to overwrite files in the context of a user running
the <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=texindex&amp;sektion=1&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">texindex</span>(1)</span></a>
utility, has been fixed. For more details see security advisory <a
href=""ftp://ftp.FreeBSD.org/pub/FreeBSD/CERT/advisories/FreeBSD-SA-06:01.texindex.asc""
target=""_top"">FreeBSD-SA-06:01.texindex</a>.</p>

<p>A temporary file vulnerability in the <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=ee&amp;sektion=1&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">ee</span>(1)</span></a> text
editor, which could allow a local attacker to overwrite files in the context of a user
running <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=ee&amp;sektion=1&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">ee</span>(1)</span></a>, has been
fixed. For more details see security advisory <a
href=""ftp://ftp.FreeBSD.org/pub/FreeBSD/CERT/advisories/FreeBSD-SA-06:02.ee.asc""
target=""_top"">FreeBSD-SA-06:02.ee</a>.</p>

<p>Several vulnerabilities in the <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=cpio&amp;sektion=1&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">cpio</span>(1)</span></a> utility
have been corrected. For more details see security advisory <a
href=""ftp://ftp.FreeBSD.org/pub/FreeBSD/CERT/advisories/FreeBSD-SA-06:03.cpio.asc""
target=""_top"">FreeBSD-SA-06:03.cpio</a>.</p>

<p>Two instances in which portions of kernel memory could be disclosed to users have been
fixed. For more details see security advisory <a
href=""ftp://ftp.FreeBSD.org/pub/FreeBSD/CERT/advisories/FreeBSD-SA-06:06.kmem.asc""
target=""_top"">FreeBSD-SA-06:06.kmem</a>.</p>

<p>A logic bug in the IP fragment handling in <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=pf&amp;sektion=4&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">pf</span>(4)</span></a>, which
could cause a crash under certain circumstances, has been fixed. For more details see
security advisory <a
href=""ftp://ftp.FreeBSD.org/pub/FreeBSD/CERT/advisories/FreeBSD-SA-06:07.pf.asc""
target=""_top"">FreeBSD-SA-06:07.pf</a>.</p>

<p>An error in Selective Acknowledgement (SACK) support in the TCP/IP stack, which could
cause an infinite loop upon reception of a particular series of packets, has been
corrected. More details are contained in security advisory <a
href=""ftp://ftp.FreeBSD.org/pub/FreeBSD/CERT/advisories/FreeBSD-SA-06:08.sack.asc""
target=""_top"">FreeBSD-SA-06:08.sack</a>.</p>

<p>A logic bug in the OpenSSH performs internal accounting, which could cause the master
decides that it is overloaded and stops accepting client connections, has been fixed. For
more details see security advisory <a
href=""ftp://ftp.FreeBSD.org/pub/FreeBSD/CERT/advisories/FreeBSD-SA-06:09.openssh.asc""
target=""_top"">FreeBSD-SA-06:09.openssh</a>.</p>

<p>A logic bug in the NFS server code, which could cause a crash when the server received
a message with a zero-length payload, has been fixed. For more details see security
advisory <a
href=""ftp://ftp.FreeBSD.org/pub/FreeBSD/CERT/advisories/FreeBSD-SA-06:10.nfs.asc""
target=""_top"">FreeBSD-SA-06:10.nfs</a>.</p>

<p>A programming error in the <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=fast_ipsec&amp;sektion=4&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">fast_ipsec</span>(4)</span></a>
implementation results in the sequence number associated with a Security Association not
being updated, allowing packets to unconditionally pass sequence number verification
checks, has been fixed. For more details see security advisory <a
href=""ftp://ftp.FreeBSD.org/pub/FreeBSD/CERT/advisories/FreeBSD-SA-06:11.ipsec.asc""
target=""_top"">FreeBSD-SA-06:11.ipsec</a>.</p>

<p>A logic bug that could cause <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=opiepasswd&amp;sektion=1&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">opiepasswd</span>(1)</span></a> to
allow an unprivileged user to configure OPIE authentication for the root user under
certain circumstances, has been fixed. For more details see security advisory <a
href=""ftp://ftp.FreeBSD.org/pub/FreeBSD/CERT/advisories/FreeBSD-SA-06:12.opie.asc""
target=""_top"">FreeBSD-SA-06:12.opie</a>.</p>

<p>An asynchronous signal handling vulnerability in <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=sendmail&amp;sektion=8&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">sendmail</span>(8)</span></a>,
which could allow a remote attacker to execute arbitrary code with the privileges of the
user running sendmail, typically root, has been fixed. For more details see security
advisory <a
href=""ftp://ftp.FreeBSD.org/pub/FreeBSD/CERT/advisories/FreeBSD-SA-06:13.sendmail.asc""
target=""_top"">FreeBSD-SA-06:13.sendmail</a>.</p>

<p>An information disclosure issue found in FreeBSD kernel running on 7th and 8th
generation of AMD processors has been fixed. For more details see security advisory <a
href=""ftp://ftp.FreeBSD.org/pub/FreeBSD/CERT/advisories/FreeBSD-SA-06:14.fpu.asc""
target=""_top"">FreeBSD-SA-06:14.fpu</a>.</p>
</div>

<div class=""SECT2"">
<hr />
<h3 class=""SECT2""><a id=""KERNEL"" name=""KERNEL"">2.2 Kernel Changes</a></h3>

<div class=""SECT3"">
<hr />
<h4 class=""SECT3""><a id=""BOOT"" name=""BOOT"">2.2.1 Boot Loader Changes</a></h4>

<p>The <tt class=""COMMAND"">autoboot</tt> command will now prevent the user from
interrupting the boot process at all if the <code class=""VARNAME"">autoboot_delay</code>
variable is set to <tt class=""LITERAL"">-1</tt>.</p>
</div>

<div class=""SECT3"">
<hr />
<h4 class=""SECT3""><a id=""PROC"" name=""PROC"">2.2.2 Hardware Support</a></h4>

<p>The <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=ce&amp;sektion=4&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">ce</span>(4)</span></a> driver has
been added to support Cronyx Tau32-PCI adapters.</p>

<p>Dual-core processors (such as the Intel Core Duo) now have both cores available for
use by default in SMP-enabled kernels.</p>

<div class=""SECT4"">
<hr />
<h5 class=""SECT4""><a id=""MM"" name=""MM"">2.2.2.1 Multimedia Support</a></h5>

<p>The <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=uaudio&amp;sektion=4&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">uaudio</span>(4)</span></a> driver
now has some added functionality, including volume control on more inputs and recording
capability on some devices.</p>
</div>

<div class=""SECT4"">
<hr />
<h5 class=""SECT4""><a id=""NET-IF"" name=""NET-IF"">2.2.2.2 Network Interface Support</a></h5>

<p>The <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=bge&amp;sektion=4&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">bge</span>(4)</span></a> driver
now supports the BCM5714 and 5789 chips.</p>

<p>The <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=ixgb&amp;sektion=4&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">ixgb</span>(4)</span></a> driver
is now MPSAFE.</p>

<p>Drivers using the <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=ndis&amp;sektion=4&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">ndis</span>(4)</span></a> device
driver wrapper mechanism are now built and loaded differently. The <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=ndis&amp;sektion=4&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">ndis</span>(4)</span></a> driver
can now be pre-built as module or statically compiled into a kernel. Individual drivers
can now be built with the <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=ndisgen&amp;sektion=8&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">ndisgen</span>(8)</span></a>
utility; the result is a kernel module that can be loaded into a running kernel using <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=kldload&amp;sektion=8&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">kldload</span>(8)</span></a>.</p>

<p>Many (but not all) changes to the <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=ndis&amp;sektion=4&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">ndis</span>(4)</span></a> system
were merged from HEAD.</p>

<p>The <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=xl&amp;sektion=4&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">xl</span>(4)</span></a> driver now
supports <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=polling&amp;sektion=4&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">polling</span>(4)</span></a>.</p>
</div>
</div>

<div class=""SECT3"">
<hr />
<h4 class=""SECT3""><a id=""NET-PROTO"" name=""NET-PROTO"">2.2.3 Network Protocols</a></h4>

<p>The <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=if_bridge&amp;sektion=4&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">if_bridge</span>(4)</span></a>
network bridging implementation, originally from NetBSD, has been added. It supports the
IEEE 802.1D Spanning Tree Protocol, individual interface devices for each bridge,
filtering of bridged packets, and span ports (which transmit a copy of every frame
received by the bridge). The <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=ifconfig&amp;sektion=8&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">ifconfig</span>(8)</span></a>
utility now supports configuration of <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=if_bridge&amp;sektion=4&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span
class=""REFENTRYTITLE"">if_bridge</span>(4)</span></a>.</p>
</div>

<div class=""SECT3"">
<hr />
<h4 class=""SECT3""><a id=""DISKS"" name=""DISKS"">2.2.4 Disks and Storage</a></h4>

<p>The <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=twa&amp;sektion=4&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">twa</span>(4)</span></a> driver
has been updated to the 9.3.0.1 release on the 3ware Web site.</p>
</div>

<div class=""SECT3"">
<hr />
<h4 class=""SECT3""><a id=""FS"" name=""FS"">2.2.5 File Systems</a></h4>
</div>

<div class=""SECT3"">
<hr />
<h4 class=""SECT3""><a id=""AEN229"" name=""AEN229"">2.2.6 Contributed Software</a></h4>
</div>
</div>

<div class=""SECT2"">
<hr />
<h3 class=""SECT2""><a id=""USERLAND"" name=""USERLAND"">2.3 Userland Changes</a></h3>

<p>The <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=bsdiff&amp;sektion=1&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">bsdiff</span>(1)</span></a> and <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=bspatch&amp;sektion=1&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">bspatch</span>(1)</span></a>
utilities have been added. These are tools for constructing and applying binary
patches.</p>

<p>The <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=cmp&amp;sektion=1&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">cmp</span>(1)</span></a> utility
now supports an <code class=""OPTION"">-h</code> flag to compare the symbolic link itself
rather than the file that the link points to.</p>

<p>The <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=gethostbyname&amp;sektion=3&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span
class=""REFENTRYTITLE"">gethostbyname</span>(3)</span></a>, <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=gethostbyname2&amp;sektion=3&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span
class=""REFENTRYTITLE"">gethostbyname2</span>(3)</span></a>, and <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=gethostbyaddr&amp;sektion=3&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">gethostbyaddr</span>(3)</span></a>
functions are now thread-safe.</p>

<p>The <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=getnetent&amp;sektion=3&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">getnetent</span>(3)</span></a>, <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=getnetbyname&amp;sektion=3&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">getnetbyname</span>(3)</span></a>,
and <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=getnetbyaddr&amp;sektion=3&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">getnetbyaddr</span>(3)</span></a>
functions are now thread-safe.</p>

<p>The <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=getprotoent&amp;sektion=3&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">getprotoent</span>(3)</span></a>,
<a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=getprotobyname&amp;sektion=3&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span
class=""REFENTRYTITLE"">getprotobyname</span>(3)</span></a>, and <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=getprotobynumber&amp;sektion=3&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span
class=""REFENTRYTITLE"">getprotobynumber</span>(3)</span></a> functions are now
thread-safe.</p>

<p>The <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=getservent&amp;sektion=3&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">getservent</span>(3)</span></a>,
<a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=getservbyname&amp;sektion=3&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span
class=""REFENTRYTITLE"">getservbyname</span>(3)</span></a>, and <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=getservbyport&amp;sektion=3&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">getservbyport</span>(3)</span></a>
functions are now thread-safe.</p>

<p>The <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=kdump&amp;sektion=1&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">kdump</span>(1)</span></a> program
now supports a <code class=""OPTION"">-s</code> flag to suppress the display of I/O
data.</p>

<p>The <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=kldstat&amp;sektion=8&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">kldstat</span>(8)</span></a>
utility now supports a <code class=""OPTION"">-m</code> option to return the status of a
specific kernel module.</p>

<p>The default stack sizes in <tt class=""FILENAME"">libpthread</tt>, <tt
class=""FILENAME"">libthr</tt>, and <tt class=""FILENAME"">libc_r</tt> have been increased.
On 32-bit platforms, the main thread receives a 2MB stack size by default, with other
threads receiving a 1MB stack size by default. On 64-bit platforms, the default stack
sizes are 4MB and 2MB respectively.</p>

<p>The <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=netstat&amp;sektion=1&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">netstat</span>(1)</span></a>
utility now supports an <code class=""OPTION"">-h</code> flag for interface stats mode,
which prints all interface statistics in human readable form.</p>

<p>The <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=ping&amp;sektion=8&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">ping</span>(8)</span></a> utility
now supports a ``sweeping ping'' in which <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=icmp&amp;sektion=4&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">icmp</span>(4)</span></a> payload
of packets being sent is increased with given step. This is useful for testing
problematic channels, MTU issues or traffic policing functions in networks.</p>

<p>The <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=powerd&amp;sektion=8&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">powerd</span>(8)</span></a>
program for managing power consumption has been added.</p>

<p>The <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=rfcomm_sppd&amp;sektion=1&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">rfcomm_sppd</span>(1)</span></a>
program now supports service names in addition to <code class=""OPTION"">-c</code> option
with channel number. The supported names are: DUN (Dial-Up Networking), FAX (Fax), LAN
(LAN Access Using PPP), and SP (Serial Port).</p>

<p>The <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=rm&amp;sektion=1&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">rm</span>(1)</span></a> utility
now supports an <code class=""OPTION"">-I</code> option that asks for confirmation (once)
if recursively removing directories or if more than 3 files are listed in the command
line.</p>

<p><a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=sed&amp;sektion=1&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">sed</span>(1)</span></a> now
supports a <code class=""OPTION"">-l</code> option to make its output line-buffered.</p>

<p>The <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=sh&amp;sektion=1&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">sh</span>(1)</span></a> utility
now supports the <tt class=""LITERAL"">times</tt> built-in command.</p>

<p>The <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=snapinfo&amp;sektion=8&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">snapinfo</span>(8)</span></a>
utility, which shows snapshot locations on UFS filesystems, has been added.</p>

<div class=""SECT3"">
<hr />
<h4 class=""SECT3""><a id=""RC-SCRIPTS"" name=""RC-SCRIPTS"">2.3.1 <tt
class=""FILENAME"">/etc/rc.d</tt> Scripts</a></h4>

<p>The <tt class=""FILENAME"">bluetooth</tt> script has been added. This script will be
called from <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=devd&amp;sektion=8&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">devd</span>(8)</span></a> in
response to device attachment/detachment events and to stop/start particular device
without unplugging it by hand. The configuration parameters are in <tt
class=""FILENAME"">/etc/defaults/bluetooth.device.conf</tt>, and can be overridden by using
<tt class=""FILENAME"">/etc/bluetooth/<tt class=""REPLACEABLE""><i>$device</i></tt>.conf</tt>
(where <tt class=""REPLACEABLE""><i>$device</i></tt> is <tt class=""DEVICENAME"">ubt0</tt>,
<tt class=""DEVICENAME"">btcc0</tt>, and so on.) For more details, see <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=bluetooth.conf&amp;sektion=5&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span
class=""REFENTRYTITLE"">bluetooth.conf</span>(5)</span></a>.</p>

<p>The <tt class=""FILENAME"">rc.d/jail</tt> startup script now supports <code
class=""VARNAME"">jail_<tt class=""REPLACEABLE""><i>name</i></tt>_flags</code> variable which
allows to specify <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=jail&amp;sektion=8&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">jail</span>(8)</span></a>
flags.</p>
</div>
</div>

<div class=""SECT2"">
<hr />
<h3 class=""SECT2""><a id=""CONTRIB"" name=""CONTRIB"">2.4 Contributed Software</a></h3>

<p><b class=""APPLICATION"">BIND</b> has been updated from 9.3.1 to 9.3.2.</p>

<p><b class=""APPLICATION"">sendmail</b> has been updated from version 8.13.3 to version
8.13.6.</p>

<p>The timezone database has been updated from the <b class=""APPLICATION"">tzdata2005g</b>
release to the <b class=""APPLICATION"">tzdata2006g</b> release.</p>
</div>

<div class=""SECT2"">
<hr />
<h3 class=""SECT2""><a id=""PORTS"" name=""PORTS"">2.5 Ports/Packages Collection
Infrastructure</a></h3>

<p>The <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=pkg_add&amp;sektion=1&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">pkg_add</span>(1)</span></a>
program now supports an <code class=""OPTION"">-P</code> flag, which is the same as the
<code class=""OPTION"">-p</code> flag except that the given prefix is also used recursively
for the dependency packages if any.</p>

<p>The <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=pkg_add&amp;sektion=1&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">pkg_add</span>(1)</span></a> and
<a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=pkg_create&amp;sektion=1&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">pkg_create</span>(1)</span></a>
utilities now support a <code class=""OPTION"">-K</code> flag to save packages to the
current directory (or <code class=""VARNAME"">PKGDIR</code> if defined) by default.</p>

<p>The <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=pkg_create&amp;sektion=1&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">pkg_create</span>(1)</span></a>
program now supports an <code class=""OPTION"">-x</code> flag to support basic regular
expressions for package name, an <code class=""OPTION"">-E</code> flag for extended regular
expressions, and a <code class=""OPTION"">-G</code> for exact matching.</p>

<p>The <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=pkg_version&amp;sektion=1&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">pkg_version</span>(1)</span></a>
utility now supports a <code class=""OPTION"">-I</code> flag, which causes only the <tt
class=""FILENAME"">INDEX</tt> file to be used for determining if a package is out of
date.</p>

<p>The <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=pkg_version&amp;sektion=1&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">pkg_version</span>(1)</span></a>
utility now supports an <code class=""OPTION"">-o</code> flag to show the origin recorded
on package generation instead of the package name, and an <code class=""OPTION"">-O</code>
flag to list packages whose registered origin is origin only.</p>

<p>The <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=portsnap&amp;sektion=8&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">portsnap</span>(8)</span></a>
utility (<tt class=""FILENAME"">sysutils/portsnap</tt>) has been added into the FreeBSD
base system. This is a secure, easy to use, fast, lightweight, and generally good way for
users to keep their ports trees up to date.</p>

<p>The suffix of startup scripts from the Ports Collection has been removed. This means
<tt class=""FILENAME"">foo.sh</tt> is renamed to <tt class=""FILENAME"">foo</tt>, and now
scripts whose name is something like <tt class=""FILENAME"">foo.ORG</tt> will also be
invoked. You are recommended to reinstall packages which install such scripts and remove
extra files in the <code class=""VARNAME"">local_startup</code> directory.</p>

<p>New <tt class=""FILENAME"">rc.conf</tt> variables, <code
class=""VARNAME"">ldconfig_local_dirs</code> and <code
class=""VARNAME"">ldconfig_local32_dirs</code> have been added. These hold lists of local
<a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=ldconfig&amp;sektion=8&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">ldconfig</span>(8)</span></a>
directories.</p>

<p>The <tt class=""COMMAND"">@cwd</tt> command in <tt class=""FILENAME"">pkg-plist</tt> now
allows no directory argument. If no directory argument is given, it will set current
working directory to the first prefix given by the <tt class=""COMMAND"">@cwd</tt>
command.</p>
</div>

<div class=""SECT2"">
<hr />
<h3 class=""SECT2""><a id=""RELENG"" name=""RELENG"">2.6 Release Engineering and
Integration</a></h3>

<p>The supported version of the <b class=""APPLICATION"">GNOME</b> desktop environment (<a
href=""http://www.FreeBSD.org/cgi/url.cgi?ports/x11/gnome2/pkg-descr""><tt
class=""FILENAME"">x11/gnome2</tt></a>) has been updated from 2.10.2 to 2.12.3.</p>

<p>The supported version of the <b class=""APPLICATION"">KDE</b> desktop environment (<a
href=""http://www.FreeBSD.org/cgi/url.cgi?ports/x11/kde3/pkg-descr""><tt
class=""FILENAME"">x11/kde3</tt></a>) has been updated from 3.4.2 to 3.5.1.</p>

<p>The supported version of the <b class=""APPLICATION"">Perl</b> interpreter (<a
href=""http://www.FreeBSD.org/cgi/url.cgi?ports/lang/perl5.8/pkg-descr""><tt
class=""FILENAME"">lang/perl5.8</tt></a>) has been updated from 5.8.7 to 5.8.8.</p>

<p>The supported version of the <b class=""APPLICATION"">Xorg</b> windowing system (<a
href=""http://www.FreeBSD.org/cgi/url.cgi?ports/x11/xorg/pkg-descr""><tt
class=""FILENAME"">x11/xorg</tt></a>) has been updated from 6.8.2 to 6.9.0.</p>
</div>

<div class=""SECT2"">
<hr />
<h3 class=""SECT2""><a id=""DOC"" name=""DOC"">2.7 Documentation</a></h3>
</div>
</div>

<div class=""SECT1"">
<hr />
<h2 class=""SECT1""><a id=""UPGRADE"" name=""UPGRADE"">3 Upgrading from previous releases of
FreeBSD</a></h2>

<p>If you're upgrading from a previous release of FreeBSD, you generally will have three
options:</p>

<ul>
<li>
<p>Using the binary upgrade option of <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=sysinstall&amp;sektion=8&amp;manpath=FreeBSD+5.5-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">sysinstall</span>(8)</span></a>.
This option is perhaps the quickest, although it presumes that your installation of
FreeBSD uses no special compilation options.</p>
</li>

<li>
<p>Performing a complete reinstall of FreeBSD. Technically, this is not an upgrading
method, and in any case is usually less convenient than a binary upgrade, in that it
requires you to manually backup and restore the contents of <tt
class=""FILENAME"">/etc</tt>. However, it may be useful in cases where you want (or need)
to change the partitioning of your disks.</p>
</li>

<li>
<p>From source code in <tt class=""FILENAME"">/usr/src</tt>. This route is more flexible,
but requires more disk space, time, and technical expertise. More information can be
found in the <a
href=""http://www.FreeBSD.org/doc/en_US.ISO8859-1/books/handbook/makeworld.html""
target=""_top"">``Using <tt class=""COMMAND"">make world</tt>''</a> section of the <a
href=""http://www.FreeBSD.org/doc/en_US.ISO8859-1/books/handbook/"" target=""_top"">FreeBSD
Handbook</a>. Upgrading from very old versions of FreeBSD may be problematic; in cases
like this, it is usually more effective to perform a binary upgrade or a complete
reinstall.</p>
</li>
</ul>

<br />
<br />
<p>Please read the <tt class=""FILENAME"">INSTALL.TXT</tt> file for more information,
preferably <span class=""emphasis""><i class=""EMPHASIS"">before</i></span> beginning an
upgrade. If you are upgrading from source, please be sure to read <tt
class=""FILENAME"">/usr/src/UPDATING</tt> as well.</p>

<p>Finally, if you want to use one of various means to track the -STABLE or -CURRENT
branches of FreeBSD, please be sure to consult the <a
href=""http://www.FreeBSD.org/doc/en_US.ISO8859-1/books/handbook/current-stable.html""
target=""_top"">``-CURRENT vs. -STABLE''</a> section of the <a
href=""http://www.FreeBSD.org/doc/en_US.ISO8859-1/books/handbook/"" target=""_top"">FreeBSD
Handbook</a>.</p>

<div class=""IMPORTANT"">
<blockquote class=""IMPORTANT"">
<p><b>Important:</b> Upgrading FreeBSD should, of course, only be attempted after backing
up <span class=""emphasis""><i class=""EMPHASIS"">all</i></span> data and configuration
files.</p>
</blockquote>
</div>
</div>
</div>

<hr />
<p align=""center""><small>This file, and other release-related documents, can be
downloaded from <a href=""ftp://ftp.FreeBSD.org/"">ftp://ftp.FreeBSD.org/</a>.</small></p>

<p align=""center""><small>For questions about FreeBSD, read the <a
href=""http://www.FreeBSD.org/docs.html"">documentation</a> before contacting &#60;<a
href=""mailto:questions@FreeBSD.org"">questions@FreeBSD.org</a>&#62;.</small></p>

<p align=""center""><small>For questions about this documentation, e-mail &#60;<a
href=""mailto:doc@FreeBSD.org"">doc@FreeBSD.org</a>&#62;.</small></p>
++++


",12260,True,2700.440555972166,median
"//===--- Expr.cpp - Swift Language Expression ASTs ------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
//
//  This file implements the Expr class and subclasses.
//
//===----------------------------------------------------------------------===//

#include ""swift/AST/Expr.h""
#include ""swift/Basic/Unicode.h""
#include ""swift/AST/ASTVisitor.h""
#include ""swift/AST/Decl.h"" // FIXME: Bad dependency
#include ""swift/AST/Stmt.h""
#include ""swift/AST/AST.h""
#include ""swift/AST/ASTWalker.h""
#include ""swift/AST/AvailabilitySpec.h""
#include ""swift/AST/PrettyStackTrace.h""
#include ""swift/AST/TypeLoc.h""
#include ""llvm/ADT/APFloat.h""
#include ""llvm/ADT/PointerUnion.h""
#include ""llvm/ADT/SetVector.h""
#include ""llvm/ADT/Twine.h""
using namespace swift;

StringRef swift::getFunctionRefKindStr(FunctionRefKind refKind) {
  switch (refKind) {
  case FunctionRefKind::Unapplied:
    return ""unapplied"";
  case FunctionRefKind::SingleApply:
    return ""single"";
  case FunctionRefKind::DoubleApply:
    return ""double"";
  case FunctionRefKind::Compound:
    return ""compound"";
  }
}

//===----------------------------------------------------------------------===//
// Expr methods.
//===----------------------------------------------------------------------===//

// Only allow allocation of Stmts using the allocator in ASTContext.
void *Expr::operator new(size_t Bytes, ASTContext &C,
                         unsigned Alignment) {
  return C.Allocate(Bytes, Alignment);
}

StringRef Expr::getKindName(ExprKind K) {
  switch (K) {
#define EXPR(Id, Parent) case ExprKind::Id: return #Id;
#include ""swift/AST/ExprNodes.def""
  }
  llvm_unreachable(""bad ExprKind"");
}

template <class T> static SourceLoc getStartLocImpl(const T *E);
template <class T> static SourceLoc getEndLocImpl(const T *E);
template <class T> static SourceLoc getLocImpl(const T *E);

// Helper functions to check statically whether a method has been
// overridden from its implementation in Expr.  The sort of thing you
// need when you're avoiding v-tables.
namespace {
  template <typename ReturnType, typename Class>
  constexpr bool isOverriddenFromExpr(ReturnType (Class::*)() const) {
    return true;
  }
  template <typename ReturnType>
  constexpr bool isOverriddenFromExpr(ReturnType (Expr::*)() const) {
    return false;
  }

  template <bool IsOverridden> struct Dispatch;

  /// Dispatch down to a concrete override.
  template <> struct Dispatch<true> {
    template <class T> static SourceLoc getStartLoc(const T *E) {
      return E->getStartLoc();
    }
    template <class T> static SourceLoc getEndLoc(const T *E) {
      return E->getEndLoc();
    }
    template <class T> static SourceLoc getLoc(const T *E) {
      return E->getLoc();
    }
    template <class T> static SourceRange getSourceRange(const T *E) {
      return E->getSourceRange();
    }
  };

  /// Default implementations for when a method isn't overridden.
  template <> struct Dispatch<false> {
    template <class T> static SourceLoc getStartLoc(const T *E) {
      return E->getSourceRange().Start;
    }
    template <class T> static SourceLoc getEndLoc(const T *E) {
      return E->getSourceRange().End;
    }
    template <class T> static SourceLoc getLoc(const T *E) {
      return getStartLocImpl(E);
    }
    template <class T> static SourceRange getSourceRange(const T *E) {
      return { E->getStartLoc(), E->getEndLoc() };
    }
  };
}

template <class T> static SourceRange getSourceRangeImpl(const T *E) {
  static_assert(isOverriddenFromExpr(&T::getSourceRange) ||
                (isOverriddenFromExpr(&T::getStartLoc) &&
                 isOverriddenFromExpr(&T::getEndLoc)),
                ""Expr subclass must implement either getSourceRange() ""
                ""or getStartLoc()/getEndLoc()"");
  return Dispatch<isOverriddenFromExpr(&T::getSourceRange)>::getSourceRange(E);
}

SourceRange Expr::getSourceRange() const {
  switch (getKind()) {
#define EXPR(ID, PARENT)                                           \\
  case ExprKind::ID: return getSourceRangeImpl(cast<ID##Expr>(this));
#include ""swift/AST/ExprNodes.def""
  }
  
  llvm_unreachable(""expression type not handled!"");
}

template <class T> static SourceLoc getStartLocImpl(const T *E) {
  return Dispatch<isOverriddenFromExpr(&T::getStartLoc)>::getStartLoc(E);
}
SourceLoc Expr::getStartLoc() const {
  switch (getKind()) {
#define EXPR(ID, PARENT)                                           \\
  case ExprKind::ID: return getStartLocImpl(cast<ID##Expr>(this));
#include ""swift/AST/ExprNodes.def""
  }

  llvm_unreachable(""expression type not handled!"");
}

template <class T> static SourceLoc getEndLocImpl(const T *E) {
  return Dispatch<isOverriddenFromExpr(&T::getEndLoc)>::getEndLoc(E);
}
SourceLoc Expr::getEndLoc() const {
  switch (getKind()) {
#define EXPR(ID, PARENT)                                           \\
  case ExprKind::ID: return getEndLocImpl(cast<ID##Expr>(this));
#include ""swift/AST/ExprNodes.def""
  }

  llvm_unreachable(""expression type not handled!"");
}

template <class T> static SourceLoc getLocImpl(const T *E) {
  return Dispatch<isOverriddenFromExpr(&T::getLoc)>::getLoc(E);
}
SourceLoc Expr::getLoc() const {
  switch (getKind()) {
#define EXPR(ID, PARENT)                                           \\
  case ExprKind::ID: return getLocImpl(cast<ID##Expr>(this));
#include ""swift/AST/ExprNodes.def""
  }

  llvm_unreachable(""expression type not handled!"");
}

Expr *Expr::getSemanticsProvidingExpr() {
  if (IdentityExpr *IE = dyn_cast<IdentityExpr>(this))
    return IE->getSubExpr()->getSemanticsProvidingExpr();

  if (TryExpr *TE = dyn_cast<TryExpr>(this))
    return TE->getSubExpr()->getSemanticsProvidingExpr();

  return this;
}

Expr *Expr::getValueProvidingExpr() {
  Expr *E = getSemanticsProvidingExpr();

  if (auto TE = dyn_cast<ForceTryExpr>(this))
    return TE->getSubExpr()->getValueProvidingExpr();

  // TODO:
  //   - tuple literal projection, which may become interestingly idiomatic

  return E;
}

DeclRefExpr *Expr::getMemberOperatorRef() {
  auto expr = this;
  if (!expr->isImplicit()) return nullptr;

  auto dotSyntax = dyn_cast<DotSyntaxCallExpr>(expr);
  if (!dotSyntax) return nullptr;

  auto operatorRef = dyn_cast<DeclRefExpr>(dotSyntax->getFn());
  if (!operatorRef) return nullptr;

  auto func = dyn_cast<FuncDecl>(operatorRef->getDecl());
  if (!func) return nullptr;

  if (!func->isOperator()) return nullptr;

  return operatorRef;
}

/// Propagate l-value use information to children.
void Expr::propagateLValueAccessKind(AccessKind accessKind,
                                     bool allowOverwrite) {
  /// A visitor class which walks an entire l-value expression.
  class PropagateAccessKind
       : public ExprVisitor<PropagateAccessKind, void, AccessKind> {
#ifndef NDEBUG
    bool AllowOverwrite;
#endif
  public:
    PropagateAccessKind(bool allowOverwrite)
#ifndef NDEBUG
      : AllowOverwrite(allowOverwrite)
#endif
    {}

    void visit(Expr *E, AccessKind kind) {
      assert((AllowOverwrite || !E->hasLValueAccessKind()) &&
             ""l-value access kind has already been set"");

      assert(E->getType()->isAssignableType() &&
             ""setting access kind on non-l-value"");
      E->setLValueAccessKind(kind);

      // Propagate this to sub-expressions.
      ASTVisitor::visit(E, kind);
    }

#define NON_LVALUE_EXPR(KIND)                                           \\
    void visit##KIND##Expr(KIND##Expr *, AccessKind accessKind) {       \\
      llvm_unreachable(""not an l-value"");                               \\
    }
#define LEAF_LVALUE_EXPR(KIND)                                          \\
    void visit##KIND##Expr(KIND##Expr *E, AccessKind accessKind) {}
#define COMPLETE_PHYSICAL_LVALUE_EXPR(KIND, ACCESSOR)                   \\
    void visit##KIND##Expr(KIND##Expr *E, AccessKind accessKind) {      \\
      visit(E->ACCESSOR, accessKind);                                   \\
    }
#define PARTIAL_PHYSICAL_LVALUE_EXPR(KIND, ACCESSOR)                    \\
    void visit##KIND##Expr(KIND##Expr *E, AccessKind accessKind) {      \\
      visit(E->ACCESSOR, getPartialAccessKind(accessKind));             \\
    }

    void visitMemberRefExpr(MemberRefExpr *E, AccessKind accessKind) {
      if (!E->getBase()->getType()->isLValueType()) return;
      visit(E->getBase(), getBaseAccessKind(E->getMember(), accessKind));
    }
    void visitSubscriptExpr(SubscriptExpr *E, AccessKind accessKind) {
      if (!E->getBase()->getType()->isLValueType()) return;
      visit(E->getBase(), getBaseAccessKind(E->getDecl(), accessKind));
    }

    static AccessKind getPartialAccessKind(AccessKind accessKind) {
      return (accessKind == AccessKind::Read
                ? accessKind : AccessKind::ReadWrite);
    }

    static AccessKind getBaseAccessKind(ConcreteDeclRef member,
                                        AccessKind accessKind) {
      // We assume writes are partial writes, so the result is always
      // either Read or ReadWrite.
      auto memberDecl = cast<AbstractStorageDecl>(member.getDecl());

      // If we're reading and the getter is mutating, or we're writing
      // and the setter is mutating, this is readwrite.
      if ((accessKind != AccessKind::Write &&
           memberDecl->isGetterMutating()) ||
          (accessKind != AccessKind::Read &&
           !memberDecl->isSetterNonMutating())) {
        return AccessKind::ReadWrite;
      }

      return AccessKind::Read;
    }

    void visitTupleExpr(TupleExpr *E, AccessKind accessKind) {
      for (auto elt : E->getElements()) {
        visit(elt, accessKind);
      }
    }

    void visitOpenExistentialExpr(OpenExistentialExpr *E,
                                  AccessKind accessKind) {
      bool opaqueValueHadAK = E->getOpaqueValue()->hasLValueAccessKind();
      AccessKind oldOpaqueValueAK =
        (opaqueValueHadAK ? E->getOpaqueValue()->getLValueAccessKind()
                          : AccessKind::Read);

      visit(E->getSubExpr(), accessKind);

      // Propagate the new access kind from the OVE to the original existential
      // if we just set or changed it on the OVE.
      if (E->getOpaqueValue()->hasLValueAccessKind()) {
        auto newOpaqueValueAK = E->getOpaqueValue()->getLValueAccessKind();
        if (!opaqueValueHadAK || newOpaqueValueAK != oldOpaqueValueAK)
          visit(E->getExistentialValue(), newOpaqueValueAK);
      }
    }

    LEAF_LVALUE_EXPR(DeclRef)
    LEAF_LVALUE_EXPR(DiscardAssignment)
    LEAF_LVALUE_EXPR(DynamicLookup)
    LEAF_LVALUE_EXPR(OpaqueValue)
    LEAF_LVALUE_EXPR(EditorPlaceholder)

    COMPLETE_PHYSICAL_LVALUE_EXPR(AnyTry, getSubExpr())
    PARTIAL_PHYSICAL_LVALUE_EXPR(BindOptional, getSubExpr())
    COMPLETE_PHYSICAL_LVALUE_EXPR(DotSyntaxBaseIgnored, getRHS());
    PARTIAL_PHYSICAL_LVALUE_EXPR(ForceValue, getSubExpr())
    COMPLETE_PHYSICAL_LVALUE_EXPR(Identity, getSubExpr())
    PARTIAL_PHYSICAL_LVALUE_EXPR(TupleElement, getBase())

    NON_LVALUE_EXPR(Error)
    NON_LVALUE_EXPR(Literal)
    NON_LVALUE_EXPR(SuperRef)
    NON_LVALUE_EXPR(Type)
    NON_LVALUE_EXPR(OtherConstructorDeclRef)
    NON_LVALUE_EXPR(Collection)
    NON_LVALUE_EXPR(CaptureList)
    NON_LVALUE_EXPR(AbstractClosure)
    NON_LVALUE_EXPR(InOut)
    NON_LVALUE_EXPR(DynamicType)
    NON_LVALUE_EXPR(RebindSelfInConstructor)
    NON_LVALUE_EXPR(Apply)
    NON_LVALUE_EXPR(ImplicitConversion)
    NON_LVALUE_EXPR(ExplicitCast)
    NON_LVALUE_EXPR(OptionalEvaluation)
    NON_LVALUE_EXPR(If)
    NON_LVALUE_EXPR(Assign)
    NON_LVALUE_EXPR(CodeCompletion)
    NON_LVALUE_EXPR(ObjCSelector)
    NON_LVALUE_EXPR(ObjCKeyPath)
    NON_LVALUE_EXPR(EnumIsCase)

#define UNCHECKED_EXPR(KIND, BASE) \\
    NON_LVALUE_EXPR(KIND)
#include ""swift/AST/ExprNodes.def""

#undef PHYSICAL_LVALUE_EXPR
#undef LEAF_LVALUE_EXPR
#undef NON_LVALUE_EXPR
  };

  PropagateAccessKind(allowOverwrite).visit(this, accessKind);
}

ConcreteDeclRef Expr::getReferencedDecl() const {
  switch (getKind()) {
  // No declaration reference.
  #define NO_REFERENCE(Id) case ExprKind::Id: return ConcreteDeclRef()
  #define SIMPLE_REFERENCE(Id, Getter)          \\
    case ExprKind::Id:                          \\
      return cast<Id##Expr>(this)->Getter()
  #define PASS_THROUGH_REFERENCE(Id, GetSubExpr)                      \\
    case ExprKind::Id:                                                \\
      return cast<Id##Expr>(this)->GetSubExpr()->getReferencedDecl()

  NO_REFERENCE(Error);
  NO_REFERENCE(NilLiteral);
  NO_REFERENCE(IntegerLiteral);
  NO_REFERENCE(FloatLiteral);
  NO_REFERENCE(BooleanLiteral);
  NO_REFERENCE(StringLiteral);
  NO_REFERENCE(InterpolatedStringLiteral);
  NO_REFERENCE(ObjectLiteral);
  NO_REFERENCE(MagicIdentifierLiteral);
  NO_REFERENCE(DiscardAssignment);

  SIMPLE_REFERENCE(DeclRef, getDeclRef);
  SIMPLE_REFERENCE(SuperRef, getSelf);

  case ExprKind::Type: {
    auto typeRepr = cast<TypeExpr>(this)->getTypeRepr();
    if (!typeRepr) return ConcreteDeclRef();
    auto ident = dyn_cast<IdentTypeRepr>(typeRepr);
    if (!ident) return ConcreteDeclRef();
    return ident->getComponentRange().back()->getBoundDecl();
  }

  SIMPLE_REFERENCE(OtherConstructorDeclRef, getDeclRef);

  PASS_THROUGH_REFERENCE(DotSyntaxBaseIgnored, getRHS);

  // FIXME: Return multiple results?
  case ExprKind::OverloadedDeclRef:
    return ConcreteDeclRef();

  NO_REFERENCE(UnresolvedDeclRef);

  SIMPLE_REFERENCE(MemberRef, getMember);
  SIMPLE_REFERENCE(DynamicMemberRef, getMember);
  SIMPLE_REFERENCE(DynamicSubscript, getMember);

  PASS_THROUGH_REFERENCE(UnresolvedSpecialize, getSubExpr);

  NO_REFERENCE(UnresolvedMember);
  NO_REFERENCE(UnresolvedDot);
  NO_REFERENCE(Sequence);
  PASS_THROUGH_REFERENCE(Paren, getSubExpr);
  PASS_THROUGH_REFERENCE(DotSelf, getSubExpr);
  PASS_THROUGH_REFERENCE(Try, getSubExpr);
  PASS_THROUGH_REFERENCE(ForceTry, getSubExpr);
  PASS_THROUGH_REFERENCE(OptionalTry, getSubExpr);

  NO_REFERENCE(Tuple);
  NO_REFERENCE(Array);
  NO_REFERENCE(Dictionary);

  case ExprKind::Subscript: {
    auto subscript = cast<SubscriptExpr>(this);
    if (subscript->hasDecl()) return subscript->getDecl();
    return ConcreteDeclRef();
  }

  NO_REFERENCE(TupleElement);
  NO_REFERENCE(CaptureList);
  NO_REFERENCE(Closure);

  PASS_THROUGH_REFERENCE(AutoClosure, getSingleExpressionBody);
  PASS_THROUGH_REFERENCE(InOut, getSubExpr);

  NO_REFERENCE(DynamicType);

  PASS_THROUGH_REFERENCE(RebindSelfInConstructor, getSubExpr);

  NO_REFERENCE(OpaqueValue);
  PASS_THROUGH_REFERENCE(BindOptional, getSubExpr);
  PASS_THROUGH_REFERENCE(OptionalEvaluation, getSubExpr);
  PASS_THROUGH_REFERENCE(ForceValue, getSubExpr);
  PASS_THROUGH_REFERENCE(OpenExistential, getSubExpr);

  NO_REFERENCE(Call);
  NO_REFERENCE(PrefixUnary);
  NO_REFERENCE(PostfixUnary);
  NO_REFERENCE(Binary);
  NO_REFERENCE(DotSyntaxCall);

  PASS_THROUGH_REFERENCE(ConstructorRefCall, getFn);
  PASS_THROUGH_REFERENCE(Load, getSubExpr);
  NO_REFERENCE(TupleShuffle);
  NO_REFERENCE(UnresolvedTypeConversion);
  PASS_THROUGH_REFERENCE(FunctionConversion, getSubExpr);
  PASS_THROUGH_REFERENCE(CovariantFunctionConversion, getSubExpr);
  PASS_THROUGH_REFERENCE(CovariantReturnConversion, getSubExpr);
  PASS_THROUGH_REFERENCE(MetatypeConversion, getSubExpr);
  PASS_THROUGH_REFERENCE(CollectionUpcastConversion, getSubExpr);
  PASS_THROUGH_REFERENCE(Erasure, getSubExpr);
  PASS_THROUGH_REFERENCE(AnyHashableErasure, getSubExpr);
  PASS_THROUGH_REFERENCE(DerivedToBase, getSubExpr);
  PASS_THROUGH_REFERENCE(ArchetypeToSuper, getSubExpr);
  PASS_THROUGH_REFERENCE(InjectIntoOptional, getSubExpr);
  PASS_THROUGH_REFERENCE(ClassMetatypeToObject, getSubExpr);
  PASS_THROUGH_REFERENCE(ExistentialMetatypeToObject, getSubExpr);
  PASS_THROUGH_REFERENCE(ProtocolMetatypeToObject, getSubExpr);
  PASS_THROUGH_REFERENCE(InOutToPointer, getSubExpr);
  PASS_THROUGH_REFERENCE(ArrayToPointer, getSubExpr);
  PASS_THROUGH_REFERENCE(StringToPointer, getSubExpr);
  PASS_THROUGH_REFERENCE(PointerToPointer, getSubExpr);
  PASS_THROUGH_REFERENCE(LValueToPointer, getSubExpr);
  PASS_THROUGH_REFERENCE(ForeignObjectConversion, getSubExpr);
  PASS_THROUGH_REFERENCE(UnevaluatedInstance, getSubExpr);
  NO_REFERENCE(Coerce);
  NO_REFERENCE(ForcedCheckedCast);
  NO_REFERENCE(ConditionalCheckedCast);
  NO_REFERENCE(Is);

  NO_REFERENCE(Arrow);
  NO_REFERENCE(If);
  NO_REFERENCE(EnumIsCase);
  NO_REFERENCE(Assign);
  NO_REFERENCE(CodeCompletion);
  NO_REFERENCE(UnresolvedPattern);
  NO_REFERENCE(EditorPlaceholder);
  NO_REFERENCE(ObjCSelector);
  NO_REFERENCE(ObjCKeyPath);

#undef SIMPLE_REFERENCE
#undef NO_REFERENCE
#undef PASS_THROUGH_REFERENCE
  }

  return ConcreteDeclRef();
}

/// Enumerate each immediate child expression of this node, invoking the
/// specific functor on it.  This ignores statements and other non-expression
/// children.
void Expr::
forEachImmediateChildExpr(const std::function<Expr*(Expr*)> &callback) {
  struct ChildWalker : ASTWalker {
    const std::function<Expr*(Expr*)> &callback;
    Expr *ThisNode;
    
    ChildWalker(const std::function<Expr*(Expr*)> &callback, Expr *ThisNode)
      : callback(callback), ThisNode(ThisNode) {}
    
    std::pair<bool, Expr *> walkToExprPre(Expr *E) override {
      // When looking at the current node, of course we want to enter it.  We
      // also don't want to enumerate it.
      if (E == ThisNode)
        return { true, E };

      // Otherwise we must be a child of our expression, enumerate it!
      return { false, callback(E) };
    }
    
    std::pair<bool, Stmt *> walkToStmtPre(Stmt *S) override {
      return { false, S };
    }

    std::pair<bool, Pattern*> walkToPatternPre(Pattern *P) override {
      return { false, P };
    }
    bool walkToDeclPre(Decl *D) override { return false; }
    bool walkToTypeReprPre(TypeRepr *T) override { return false; }
    bool walkToTypeLocPre(TypeLoc &TL) override { return false; }
  };
  
  this->walk(ChildWalker(callback, this));
}

/// Enumerate each immediate child expression of this node, invoking the
/// specific functor on it.  This ignores statements and other non-expression
/// children.
void Expr::forEachChildExpr(const std::function<Expr*(Expr*)> &callback) {
  struct ChildWalker : ASTWalker {
    const std::function<Expr*(Expr*)> &callback;

    ChildWalker(const std::function<Expr*(Expr*)> &callback)
    : callback(callback) {}

    std::pair<bool, Expr *> walkToExprPre(Expr *E) override {
      // Enumerate the node!
      return { true, callback(E) };
    }

    std::pair<bool, Stmt *> walkToStmtPre(Stmt *S) override {
      return { false, S };
    }

    std::pair<bool, Pattern*> walkToPatternPre(Pattern *P) override {
      return { false, P };
    }
    bool walkToDeclPre(Decl *D) override { return false; }
    bool walkToTypeReprPre(TypeRepr *T) override { return false; }
    bool walkToTypeLocPre(TypeLoc &TL) override { return false; }
  };

  this->walk(ChildWalker(callback));
}

bool Expr::isTypeReference() const {
  // If the result isn't a metatype, there's nothing else to do.
  if (!getType()->is<AnyMetatypeType>())
    return false;
  
  const Expr *expr = this;
  do {
    // Skip syntax.
    expr = expr->getSemanticsProvidingExpr();

    // Direct reference to a type.
    if (auto declRef = dyn_cast<DeclRefExpr>(expr))
      if (isa<TypeDecl>(declRef->getDecl()))
        return true;
    if (isa<TypeExpr>(expr))
      return true;

    // A ""."" expression that refers to a member.
    if (auto memberRef = dyn_cast<MemberRefExpr>(expr))
      return isa<TypeDecl>(memberRef->getMember().getDecl());

    // When the base of a ""."" expression is ignored, look at the member.
    if (auto ignoredDot = dyn_cast<DotSyntaxBaseIgnoredExpr>(expr)) {
      expr = ignoredDot->getRHS();
      continue;
    }

    // Anything else is not statically derived.
    return false;
  } while (true);

}

bool Expr::isStaticallyDerivedMetatype() const {
  // The type must first be a type reference.
  if (!isTypeReference())
    return false;

  // Archetypes are never statically derived.
  return !getType()->getAs<AnyMetatypeType>()->getInstanceType()
    ->is<ArchetypeType>();
}

bool Expr::isSuperExpr() const {
  const Expr *expr = this;
  do {
    expr = expr->getSemanticsProvidingExpr();

    if (isa<SuperRefExpr>(expr))
      return true;

    if (auto derivedToBase = dyn_cast<DerivedToBaseExpr>(expr)) {
      expr = derivedToBase->getSubExpr();
      continue;
    }
    if (auto metatypeConversion = dyn_cast<MetatypeConversionExpr>(expr)) {
      expr = metatypeConversion->getSubExpr();
      continue;
    }

    return false;
  } while (true);
}

bool Expr::canAppendCallParentheses() const {
  switch (getKind()) {
  case ExprKind::Error:
  case ExprKind::CodeCompletion:
    return false;

  case ExprKind::NilLiteral:
  case ExprKind::IntegerLiteral:
  case ExprKind::FloatLiteral:
  case ExprKind::BooleanLiteral:
  case ExprKind::StringLiteral:
  case ExprKind::InterpolatedStringLiteral:
  case ExprKind::MagicIdentifierLiteral:
  case ExprKind::ObjCSelector:
  case ExprKind::ObjCKeyPath:
    return true;

  case ExprKind::ObjectLiteral:
    return true;

  case ExprKind::DiscardAssignment:
    // Legal but pointless.
    return true;

  case ExprKind::DeclRef:
    return !cast<DeclRefExpr>(this)->getDecl()->getName().isOperator();

  case ExprKind::SuperRef:
  case ExprKind::Type:
  case ExprKind::OtherConstructorDeclRef:
  case ExprKind::DotSyntaxBaseIgnored:
    return true;

  case ExprKind::OverloadedDeclRef: {
    auto *overloadedExpr = cast<OverloadedDeclRefExpr>(this);
    if (overloadedExpr->getDecls().empty())
      return false;
    return !overloadedExpr->getDecls().front()->getName().isOperator();
  }

  case ExprKind::UnresolvedDeclRef:
    return cast<UnresolvedDeclRefExpr>(this)->getName().isOperator();

  case ExprKind::MemberRef:
  case ExprKind::DynamicMemberRef:
  case ExprKind::DynamicSubscript:
  case ExprKind::UnresolvedSpecialize:
  case ExprKind::UnresolvedMember:
  case ExprKind::UnresolvedDot:
    return true;

  case ExprKind::Sequence:
    return false;

  case ExprKind::Paren:
  case ExprKind::DotSelf:
  case ExprKind::Tuple:
  case ExprKind::Array:
  case ExprKind::Dictionary:
  case ExprKind::Subscript:
  case ExprKind::TupleElement:
    return true;

  case ExprKind::CaptureList:
  case ExprKind::Closure:
  case ExprKind::AutoClosure:
    return false;

  case ExprKind::DynamicType:
    return true;

  case ExprKind::Try:
  case ExprKind::ForceTry:
  case ExprKind::OptionalTry:
  case ExprKind::InOut:
    return false;

  case ExprKind::RebindSelfInConstructor:
  case ExprKind::OpaqueValue:
  case ExprKind::BindOptional:
  case ExprKind::OptionalEvaluation:
    return false;

  case ExprKind::ForceValue:
    return true;

  case ExprKind::OpenExistential:
    return false;

  case ExprKind::Call:
  case ExprKind::PostfixUnary:
  case ExprKind::DotSyntaxCall:
  case ExprKind::ConstructorRefCall:
    return true;

  case ExprKind::PrefixUnary:
  case ExprKind::Binary:
    return false;

  case ExprKind::Load:
  case ExprKind::TupleShuffle:
  case ExprKind::UnresolvedTypeConversion:
  case ExprKind::FunctionConversion:
  case ExprKind::CovariantFunctionConversion:
  case ExprKind::CovariantReturnConversion:
  case ExprKind::MetatypeConversion:
  case ExprKind::CollectionUpcastConversion:
  case ExprKind::Erasure:
  case ExprKind::AnyHashableErasure:
  case ExprKind::DerivedToBase:
  case ExprKind::ArchetypeToSuper:
  case ExprKind::InjectIntoOptional:
  case ExprKind::ClassMetatypeToObject:
  case ExprKind::ExistentialMetatypeToObject:
  case ExprKind::ProtocolMetatypeToObject:
  case ExprKind::InOutToPointer:
  case ExprKind::ArrayToPointer:
  case ExprKind::StringToPointer:
  case ExprKind::PointerToPointer:
  case ExprKind::LValueToPointer:
  case ExprKind::ForeignObjectConversion:
  case ExprKind::UnevaluatedInstance:
  case ExprKind::EnumIsCase:
    // Implicit conversion nodes have no syntax of their own; defer to the
    // subexpression.
    return cast<ImplicitConversionExpr>(this)->getSubExpr()
      ->canAppendCallParentheses();

  case ExprKind::ForcedCheckedCast:
  case ExprKind::ConditionalCheckedCast:
  case ExprKind::Is:
  case ExprKind::Coerce:
    return false;

  case ExprKind::Arrow:
  case ExprKind::If:
  case ExprKind::Assign:
  case ExprKind::UnresolvedPattern:
  case ExprKind::EditorPlaceholder:
    return false;
  }
}

llvm::DenseMap<Expr *, Expr *> Expr::getParentMap() {
  class RecordingTraversal : public ASTWalker {
  public:
    llvm::DenseMap<Expr *, Expr *> &ParentMap;

    explicit RecordingTraversal(llvm::DenseMap<Expr *, Expr *> &parentMap)
      : ParentMap(parentMap) { }

    virtual std::pair<bool, Expr *> walkToExprPre(Expr *E) {
      if (auto parent = Parent.getAsExpr())
        ParentMap[E] = parent;

      return { true, E };
    }
  };

  llvm::DenseMap<Expr *, Expr *> parentMap;
  RecordingTraversal traversal(parentMap);
  walk(traversal);
  return parentMap;
}

llvm::DenseMap<Expr *, unsigned> Expr::getDepthMap() {
  class RecordingTraversal : public ASTWalker {
  public:
    llvm::DenseMap<Expr *, unsigned> &DepthMap;
    unsigned Depth = 0;

    explicit RecordingTraversal(llvm::DenseMap<Expr *, unsigned> &depthMap)
      : DepthMap(depthMap) { }

    virtual std::pair<bool, Expr *> walkToExprPre(Expr *E) {
      DepthMap[E] = Depth;
      Depth++;
      return { true, E };
    }

    virtual Expr *walkToExprPost(Expr *E) {
      Depth--;
      return E;
    }
  };

  llvm::DenseMap<Expr *, unsigned> depthMap;
  RecordingTraversal traversal(depthMap);
  walk(traversal);
  return depthMap;
}

llvm::DenseMap<Expr *, unsigned> Expr::getPreorderIndexMap() {
  class RecordingTraversal : public ASTWalker {
  public:
    llvm::DenseMap<Expr *, unsigned> &IndexMap;
    unsigned Index = 0;

    explicit RecordingTraversal(llvm::DenseMap<Expr *, unsigned> &indexMap)
      : IndexMap(indexMap) { }

    virtual std::pair<bool, Expr *> walkToExprPre(Expr *E) {
      IndexMap[E] = Index;
      Index++;
      return { true, E };
    }
  };

  llvm::DenseMap<Expr *, unsigned> indexMap;
  RecordingTraversal traversal(indexMap);
  walk(traversal);
  return indexMap;
}

//===----------------------------------------------------------------------===//
// Support methods for Exprs.
//===----------------------------------------------------------------------===//

static LiteralExpr *shallowCloneImpl(const NilLiteralExpr *E, ASTContext &Ctx) {
  return new (Ctx) NilLiteralExpr(E->getLoc());
}

static LiteralExpr *
shallowCloneImpl(const IntegerLiteralExpr *E, ASTContext &Ctx) {
  auto res = new (Ctx) IntegerLiteralExpr(E->getDigitsText(),
                                          E->getSourceRange().End);
  if (E->isNegative())
    res->setNegative(E->getSourceRange().Start);
  return res;
}

static LiteralExpr *shallowCloneImpl(const FloatLiteralExpr *E, ASTContext &Ctx) {
  auto res = new (Ctx) FloatLiteralExpr(E->getDigitsText(),
                                        E->getSourceRange().End);
  if (E->isNegative())
    res->setNegative(E->getSourceRange().Start);
  return res;
}
static LiteralExpr *
shallowCloneImpl(const BooleanLiteralExpr *E, ASTContext &Ctx) {
  return new (Ctx) BooleanLiteralExpr(E->getValue(), E->getLoc());
}
static LiteralExpr *shallowCloneImpl(const StringLiteralExpr *E, ASTContext &Ctx) {
  auto res = new (Ctx) StringLiteralExpr(E->getValue(), E->getSourceRange());
  res->setEncoding(E->getEncoding());
  return res;
}

static LiteralExpr *
shallowCloneImpl(const InterpolatedStringLiteralExpr *E, ASTContext &Ctx) {
  auto res = new (Ctx) InterpolatedStringLiteralExpr(E->getLoc(),
                const_cast<InterpolatedStringLiteralExpr*>(E)->getSegments());
  res->setSemanticExpr(E->getSemanticExpr());
  return res;
}


static LiteralExpr *
shallowCloneImpl(const MagicIdentifierLiteralExpr *E, ASTContext &Ctx) {
  auto res = new (Ctx) MagicIdentifierLiteralExpr(E->getKind(),
                                                  E->getSourceRange().End);
  if (res->isString())
    res->setStringEncoding(E->getStringEncoding());
  return res;
}

static LiteralExpr *
shallowCloneImpl(const ObjectLiteralExpr *E, ASTContext &Ctx) {
  auto res = ObjectLiteralExpr::create(Ctx, E->getStartLoc(),
                                       E->getLiteralKind(),
                                       E->getArg(), E->isImplicit());
  res->setSemanticExpr(E->getSemanticExpr());
  return res;
}

// Make an exact copy of this AST node.
LiteralExpr *LiteralExpr::shallowClone(ASTContext &Ctx) const {
  LiteralExpr *Result = nullptr;
  switch (getKind()) {
  default: llvm_unreachable(""Unknown literal type!"");
#define DISPATCH_CLONE(KIND) \\
  case ExprKind::KIND: \\
    Result = shallowCloneImpl(cast<KIND##Expr>(this), Ctx); \\
    break;

  DISPATCH_CLONE(NilLiteral)
  DISPATCH_CLONE(IntegerLiteral)
  DISPATCH_CLONE(FloatLiteral)
  DISPATCH_CLONE(BooleanLiteral)
  DISPATCH_CLONE(StringLiteral)
  DISPATCH_CLONE(InterpolatedStringLiteral)
  DISPATCH_CLONE(ObjectLiteral)
  DISPATCH_CLONE(MagicIdentifierLiteral)
#undef DISPATCH_CLONE
  }
  
  Result->setType(getType());
  Result->setImplicit(isImplicit());
  return Result;
}




static APInt getIntegerLiteralValue(bool IsNegative, StringRef Text,
                                    unsigned BitWidth) {
  llvm::APInt Value(BitWidth, 0);
  // swift encodes octal differently from C
  bool IsCOctal = Text.size() > 1 && Text[0] == '0' && isdigit(Text[1]);
  bool Error = Text.getAsInteger(IsCOctal ? 10 : 0, Value);
  assert(!Error && ""Invalid IntegerLiteral formed""); (void)Error;
  if (IsNegative)
    Value = -Value;
  if (Value.getBitWidth() != BitWidth)
    Value = Value.sextOrTrunc(BitWidth);
  return Value;
}

APInt IntegerLiteralExpr::getValue(StringRef Text, unsigned BitWidth) {
  return getIntegerLiteralValue(/*IsNegative=*/false, Text, BitWidth);
}

APInt IntegerLiteralExpr::getValue() const {
  assert(!getType().isNull() && ""Semantic analysis has not completed"");
  assert(!getType()->hasError() && ""Should have a valid type"");
  return getIntegerLiteralValue(
      isNegative(), getDigitsText(),
      getType()->castTo<BuiltinIntegerType>()->getGreatestWidth());
}

static APFloat getFloatLiteralValue(bool IsNegative, StringRef Text,
                                    const llvm::fltSemantics &Semantics) {
  APFloat Val(Semantics);
  APFloat::opStatus Res =
    Val.convertFromString(Text, llvm::APFloat::rmNearestTiesToEven);
  assert(Res != APFloat::opInvalidOp && ""Sema didn't reject invalid number"");
  (void)Res;
  if (IsNegative) {
    auto NegVal = APFloat::getZero(Semantics, /*negative*/ true);
    Res = NegVal.subtract(Val, llvm::APFloat::rmNearestTiesToEven);
    assert(Res != APFloat::opInvalidOp && ""Sema didn't reject invalid number"");
    (void)Res;
    return NegVal;
  }
  return Val;
}

APFloat FloatLiteralExpr::getValue(StringRef Text,
                                   const llvm::fltSemantics &Semantics) {
  return getFloatLiteralValue(/*IsNegative*/false, Text, Semantics);
}

llvm::APFloat FloatLiteralExpr::getValue() const {
  assert(!getType().isNull() && ""Semantic analysis has not completed"");
  assert(!getType()->hasError() && ""Should have a valid type"");

  return getFloatLiteralValue(isNegative(), getDigitsText(),
                  getType()->castTo<BuiltinFloatType>()->getAPFloatSemantics());
}

StringLiteralExpr::StringLiteralExpr(StringRef Val, SourceRange Range,
                                     bool Implicit)
    : LiteralExpr(ExprKind::StringLiteral, Implicit), Val(Val),
      Range(Range) {
  StringLiteralExprBits.Encoding = static_cast<unsigned>(UTF8);
  StringLiteralExprBits.IsSingleUnicodeScalar =
      unicode::isSingleUnicodeScalar(Val);
  StringLiteralExprBits.IsSingleExtendedGraphemeCluster =
      unicode::isSingleExtendedGraphemeCluster(Val);
}

static ArrayRef<Identifier>
getArgumentLabelsFromArgument(Expr *arg, SmallVectorImpl<Identifier> &scratch,
                              SmallVectorImpl<SourceLoc> *sourceLocs = nullptr,
                              bool *hasTrailingClosure = nullptr){
  if (sourceLocs) sourceLocs->clear();
  if (hasTrailingClosure) *hasTrailingClosure = false;

  // A parenthesized expression is a single, unlabeled argument.
  if (auto paren = dyn_cast<ParenExpr>(arg)) {
    scratch.clear();
    scratch.push_back(Identifier());
    if (hasTrailingClosure) *hasTrailingClosure = paren->hasTrailingClosure();
    return scratch;
  }

  // A tuple expression stores its element names, if they exist.
  if (auto tuple = dyn_cast<TupleExpr>(arg)) {
    if (sourceLocs && tuple->hasElementNameLocs()) {
      sourceLocs->append(tuple->getElementNameLocs().begin(),
                         tuple->getElementNameLocs().end());
    }

    if (hasTrailingClosure) *hasTrailingClosure = tuple->hasTrailingClosure();

    if (tuple->hasElementNames()) {
      assert(tuple->getElementNames().size() == tuple->getNumElements());
      return tuple->getElementNames();
    }

    scratch.assign(tuple->getNumElements(), Identifier());
    return scratch;
  }

  // Otherwise, use the type information.
  auto type = arg->getType();
  if (isa<ParenType>(type.getPointer())) {
    scratch.clear();
    scratch.push_back(Identifier());
    return scratch;    
  }

  // FIXME: Should be a dyn_cast.
  if (auto tupleTy = type->getAs<TupleType>()) {
    scratch.clear();
    for (const auto &elt : tupleTy->getElements())
      scratch.push_back(elt.getName());
    return scratch;
  }

  // FIXME: Shouldn't get here.
  scratch.clear();
  scratch.push_back(Identifier());
  return scratch;    
}

/// Compute the type of an argument to a call (or call-like) AST
static void computeSingleArgumentType(ASTContext &ctx, Expr *arg,
                                      bool implicit) {
  // Propagate 'implicit' to the argument.
  if (implicit)
    arg->setImplicit(true);

  // Handle parenthesized expressions.
  if (auto paren = dyn_cast<ParenExpr>(arg)) {
    if (auto type = paren->getSubExpr()->getType()) {
      arg->setType(ParenType::get(ctx, type));
    }
    return;
  }

  // Handle tuples.
  auto tuple = dyn_cast<TupleExpr>(arg);
  SmallVector<TupleTypeElt, 4> typeElements;
  for (unsigned i = 0, n = tuple->getNumElements(); i != n; ++i) {
    auto type = tuple->getElement(i)->getType();
    if (!type) return;

    typeElements.push_back(TupleTypeElt(type, tuple->getElementName(i)));
  }
  arg->setType(TupleType::get(typeElements, ctx));
}

/// Pack the argument information into a single argument, to match the
/// representation expected by the AST.
///
/// \\param argLabels The argument labels, which might be updated by this
/// function.
///
/// \\param argLabelLocs The argument label locations, which might be updated by
/// this function.
static Expr *packSingleArgument(
    ASTContext &ctx,
    SourceLoc lParenLoc,
    ArrayRef<Expr *> args,
    ArrayRef<Identifier> &argLabels,
    ArrayRef<SourceLoc> &argLabelLocs,
    SourceLoc rParenLoc,
    Expr *trailingClosure,
    bool implicit,
    SmallVectorImpl<Identifier> &argLabelsScratch,
    SmallVectorImpl<SourceLoc> &argLabelLocsScratch) {
  // Clear out our scratch space.
  argLabelsScratch.clear();
  argLabelLocsScratch.clear();

  // Construct a TupleExpr or ParenExpr, as appropriate, for the argument.
  if (!trailingClosure) {
    // Do we have a single, unlabeled argument?
    if (args.size() == 1 && (argLabels.empty() || argLabels[0].empty())) {
      auto arg = new (ctx) ParenExpr(lParenLoc, args[0], rParenLoc,
                                     /*hasTrailingClosure=*/false);
      computeSingleArgumentType(ctx, arg, implicit);
      argLabelsScratch.push_back(Identifier());
      argLabels = argLabelsScratch;
      argLabelLocs = { };
      return arg;
    }

    // Make sure we have argument labels.
    if (argLabels.empty()) {
      argLabelsScratch.assign(args.size(), Identifier());
      argLabels = argLabelsScratch;
    }

    // Construct the argument tuple.
    if (argLabels.empty() && !args.empty()) {
      argLabelsScratch.assign(args.size(), Identifier());
      argLabels = argLabelsScratch;
    }
      
    auto arg = TupleExpr::create(ctx, lParenLoc, args, argLabels, argLabelLocs,
                                 rParenLoc, /*hasTrailingClosure=*/false,
                                 /*implicit=*/false);
    computeSingleArgumentType(ctx, arg, implicit);
    return arg;
  }

  // If we have no other arguments, represent the trailing closure as a
  // parenthesized expression.
  if (args.size() == 0) {
    auto arg = new (ctx) ParenExpr(lParenLoc, trailingClosure, rParenLoc,
                                   /*hasTrailingClosure=*/true);
    computeSingleArgumentType(ctx, arg, implicit);
    argLabelsScratch.push_back(Identifier());
    argLabels = argLabelsScratch;
    argLabelLocs = { };
    return arg;
  }

  assert(argLabels.empty() || args.size() == argLabels.size());

  // Form a tuple, including the trailing closure.
  SmallVector<Expr *, 4> argsScratch;
  argsScratch.reserve(args.size() + 1);
  argsScratch.append(args.begin(), args.end());
  argsScratch.push_back(trailingClosure);
  args = argsScratch;

  argLabelsScratch.reserve(args.size());
  if (argLabels.empty()) {
    argLabelsScratch.assign(args.size(), Identifier());
  } else {
    argLabelsScratch.append(argLabels.begin(), argLabels.end());
    argLabelsScratch.push_back(Identifier());
  }
  argLabels = argLabelsScratch;

  if (!argLabelLocs.empty()) {
    argLabelLocsScratch.reserve(argLabelLocs.size() + 1);
    argLabelLocsScratch.append(argLabelLocs.begin(), argLabelLocs.end());
    argLabelLocsScratch.push_back(SourceLoc());
    argLabelLocs = argLabelLocsScratch;
  }

  auto arg = TupleExpr::create(ctx, lParenLoc, args, argLabels,
                               argLabelLocs, rParenLoc,
                               /*hasTrailingClosure=*/true,
                               /*implicit=*/false);
  computeSingleArgumentType(ctx, arg, implicit);

  return arg;
}

ObjectLiteralExpr::ObjectLiteralExpr(SourceLoc PoundLoc, LiteralKind LitKind,
                                     Expr *Arg,
                                     ArrayRef<Identifier> argLabels,
                                     ArrayRef<SourceLoc> argLabelLocs,
                                     bool hasTrailingClosure,
                                     bool implicit)
    : LiteralExpr(ExprKind::ObjectLiteral, implicit), 
      Arg(Arg), SemanticExpr(nullptr), PoundLoc(PoundLoc) {
  ObjectLiteralExprBits.LitKind = static_cast<unsigned>(LitKind);
  assert(getLiteralKind() == LitKind);
  ObjectLiteralExprBits.NumArgLabels = argLabels.size();
  ObjectLiteralExprBits.HasArgLabelLocs = !argLabelLocs.empty();
  ObjectLiteralExprBits.HasTrailingClosure = hasTrailingClosure;
  initializeCallArguments(argLabels, argLabelLocs, hasTrailingClosure);  
}

ObjectLiteralExpr *ObjectLiteralExpr::create(ASTContext &ctx,
                                             SourceLoc poundLoc,
                                             LiteralKind kind,
                                             Expr *arg,
                                             bool implicit) {
  // Inspect the argument to dig out the argument labels, their location, and
  // whether there is a trailing closure.
  SmallVector<Identifier, 4> argLabelsScratch;
  SmallVector<SourceLoc, 4> argLabelLocs;
  bool hasTrailingClosure = false;
  auto argLabels = getArgumentLabelsFromArgument(arg, argLabelsScratch,
                                                 &argLabelLocs,
                                                 &hasTrailingClosure);

  size_t size = totalSizeToAlloc(argLabels, argLabelLocs, hasTrailingClosure);

  void *memory = ctx.Allocate(size, alignof(ObjectLiteralExpr));
  return new (memory) ObjectLiteralExpr(poundLoc, kind, arg, argLabels,
                                        argLabelLocs, hasTrailingClosure,
                                        implicit);
}

ObjectLiteralExpr *ObjectLiteralExpr::create(ASTContext &ctx,
                                             SourceLoc poundLoc,
                                             LiteralKind kind,
                                             SourceLoc lParenLoc,
                                             ArrayRef<Expr *> args,
                                             ArrayRef<Identifier> argLabels,
                                             ArrayRef<SourceLoc> argLabelLocs,
                                             SourceLoc rParenLoc,
                                             Expr *trailingClosure,
                                             bool implicit) {
  SmallVector<Identifier, 4> argLabelsScratch;
  SmallVector<SourceLoc, 4> argLabelLocsScratch;
  Expr *arg = packSingleArgument(ctx, lParenLoc, args, argLabels, argLabelLocs,
                                 rParenLoc, trailingClosure, implicit,
                                 argLabelsScratch, argLabelLocsScratch);

  size_t size = totalSizeToAlloc(argLabels, argLabelLocs,
                                 trailingClosure != nullptr);

  void *memory = ctx.Allocate(size, alignof(ObjectLiteralExpr));
  return new (memory) ObjectLiteralExpr(poundLoc, kind, arg, argLabels,
                                        argLabelLocs,
                                        trailingClosure != nullptr, implicit);
}

StringRef ObjectLiteralExpr::getLiteralKindRawName() const {
  switch (getLiteralKind()) {
#define POUND_OBJECT_LITERAL(Name, Desc, Proto) case Name: return #Name;
#include ""swift/Parse/Tokens.def""    
  }
  llvm_unreachable(""unspecified literal"");
}

StringRef ObjectLiteralExpr::getLiteralKindPlainName() const {
  switch (getLiteralKind()) {
#define POUND_OBJECT_LITERAL(Name, Desc, Proto) case Name: return Desc;
#include ""swift/Parse/Tokens.def""    
  }
  llvm_unreachable(""unspecified literal"");
}

void DeclRefExpr::setSpecialized() {
  if (isSpecialized())
    return;

  ConcreteDeclRef ref = getDeclRef();
  void *Mem = ref.getDecl()->getASTContext().Allocate(sizeof(SpecializeInfo),
                                                      alignof(SpecializeInfo));
  auto Spec = new (Mem) SpecializeInfo;
  Spec->D = ref;
  DOrSpecialized = Spec;
}

void DeclRefExpr::setGenericArgs(ArrayRef<TypeRepr*> GenericArgs) {
  ValueDecl *D = getDecl();
  assert(D);
  setSpecialized();
  getSpecInfo()->GenericArgs = D->getASTContext().AllocateCopy(GenericArgs);
}

ConstructorDecl *OtherConstructorDeclRefExpr::getDecl() const {
  return cast_or_null<ConstructorDecl>(Ctor.getDecl());
}

MemberRefExpr::MemberRefExpr(Expr *base, SourceLoc dotLoc,
                             ConcreteDeclRef member, DeclNameLoc nameLoc,
                             bool Implicit, AccessSemantics semantics)
  : Expr(ExprKind::MemberRef, Implicit), Base(base),
    Member(member), DotLoc(dotLoc), NameLoc(nameLoc) {
   
  MemberRefExprBits.Semantics = (unsigned) semantics;
  MemberRefExprBits.IsSuper = false;
}

Type OverloadSetRefExpr::getBaseType() const {
  if (isa<OverloadedDeclRefExpr>(this))
    return Type();
  
  llvm_unreachable(""Unhandled overloaded set reference expression"");
}

bool OverloadSetRefExpr::hasBaseObject() const {
  if (Type BaseTy = getBaseType())
    return !BaseTy->is<AnyMetatypeType>();

  return false;
}

SequenceExpr *SequenceExpr::create(ASTContext &ctx, ArrayRef<Expr*> elements) {
  assert(elements.size() & 1 && ""even number of elements in sequence"");
  void *Buffer = ctx.Allocate(sizeof(SequenceExpr) +
                              elements.size() * sizeof(Expr*),
                              alignof(SequenceExpr));
  return ::new(Buffer) SequenceExpr(elements);
}

SourceLoc TupleExpr::getStartLoc() const {
  if (LParenLoc.isValid()) return LParenLoc;
  if (getNumElements() == 0) return SourceLoc();
  return getElement(0)->getStartLoc();
}

SourceLoc TupleExpr::getEndLoc() const {
  if (hasTrailingClosure() || RParenLoc.isInvalid()) {
    if (getNumElements() == 0) return SourceLoc();
    return getElements().back()->getEndLoc();
  }
  return RParenLoc;
}

TupleExpr::TupleExpr(SourceLoc LParenLoc, ArrayRef<Expr *> SubExprs,
                     ArrayRef<Identifier> ElementNames, 
                     ArrayRef<SourceLoc> ElementNameLocs,
                     SourceLoc RParenLoc, bool HasTrailingClosure, 
                     bool Implicit, Type Ty)
  : Expr(ExprKind::Tuple, Implicit, Ty),
    LParenLoc(LParenLoc), RParenLoc(RParenLoc),
    NumElements(SubExprs.size())
{
  TupleExprBits.HasTrailingClosure = HasTrailingClosure;
  TupleExprBits.HasElementNames = !ElementNames.empty();
  TupleExprBits.HasElementNameLocations = !ElementNameLocs.empty();
  
  assert(LParenLoc.isValid() == RParenLoc.isValid() &&
         ""Mismatched parenthesis location information validity"");
  assert(ElementNames.empty() || ElementNames.size() == SubExprs.size());
  assert(ElementNameLocs.empty() || 
         ElementNames.size() == ElementNameLocs.size());

  // Copy elements.
  std::uninitialized_copy(SubExprs.begin(), SubExprs.end(),
                          getTrailingObjects<Expr *>());

  // Copy element names, if provided.
  if (hasElementNames()) {
    std::uninitialized_copy(ElementNames.begin(), ElementNames.end(),
                            getTrailingObjects<Identifier>());
  }

  // Copy element name locations, if provided.
  if (hasElementNameLocs()) {
    std::uninitialized_copy(ElementNameLocs.begin(), ElementNameLocs.end(),
                            getTrailingObjects<SourceLoc>());
  }
}

TupleExpr *TupleExpr::create(ASTContext &ctx,
                             SourceLoc LParenLoc, 
                             ArrayRef<Expr *> SubExprs,
                             ArrayRef<Identifier> ElementNames, 
                             ArrayRef<SourceLoc> ElementNameLocs,
                             SourceLoc RParenLoc, bool HasTrailingClosure, 
                             bool Implicit, Type Ty) {
  size_t size =
      totalSizeToAlloc<Expr *, Identifier, SourceLoc>(SubExprs.size(),
                                                      ElementNames.size(),
                                                      ElementNameLocs.size());
  void *mem = ctx.Allocate(size, alignof(TupleExpr));
  return new (mem) TupleExpr(LParenLoc, SubExprs, ElementNames, ElementNameLocs,
                             RParenLoc, HasTrailingClosure, Implicit, Ty);
}

TupleExpr *TupleExpr::createEmpty(ASTContext &ctx, SourceLoc LParenLoc, 
                                  SourceLoc RParenLoc, bool Implicit) {
  return create(ctx, LParenLoc, { }, { }, { }, RParenLoc, 
                /*HasTrailingClosure=*/false, Implicit, 
                TupleType::getEmpty(ctx));
}

TupleExpr *TupleExpr::createImplicit(ASTContext &ctx, ArrayRef<Expr *> SubExprs,
                                     ArrayRef<Identifier> ElementNames) {
  return create(ctx, SourceLoc(), SubExprs, ElementNames, { }, SourceLoc(),
                /*HasTrailingClosure=*/false, /*Implicit=*/true, Type());
}


ArrayExpr *ArrayExpr::create(ASTContext &C, SourceLoc LBracketLoc,
                             ArrayRef<Expr*> Elements,
                             ArrayRef<SourceLoc> CommaLocs,
                             SourceLoc RBracketLoc, Type Ty) {
  // Copy the element list into the ASTContext.
  auto NewElements = C.AllocateCopy(Elements);
  auto NewCommas = C.AllocateCopy(CommaLocs);
  return new (C) ArrayExpr(LBracketLoc, NewElements, NewCommas, RBracketLoc,Ty);
}

DictionaryExpr *DictionaryExpr::create(ASTContext &C, SourceLoc LBracketLoc,
                             ArrayRef<Expr*> Elements, SourceLoc RBracketLoc,
                             Type Ty) {
  // Copy the element list into the ASTContext.
  auto NewElements = C.AllocateCopy(Elements);
  return new (C) DictionaryExpr(LBracketLoc, NewElements, RBracketLoc, Ty);
}

static ValueDecl *getCalledValue(Expr *E) {
  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E))
    return DRE->getDecl();

  Expr *E2 = E->getValueProvidingExpr();
  if (E != E2) return getCalledValue(E2);
  return nullptr;
}

ValueDecl *ApplyExpr::getCalledValue() const {
  return ::getCalledValue(Fn);
}

SubscriptExpr::SubscriptExpr(Expr *base, Expr *index,
                             ArrayRef<Identifier> argLabels,
                             ArrayRef<SourceLoc> argLabelLocs,
                             bool hasTrailingClosure,
                             ConcreteDeclRef decl,
                             bool implicit, AccessSemantics semantics)
    : Expr(ExprKind::Subscript, implicit, Type()),
      TheDecl(decl), Base(base), Index(index) {
  SubscriptExprBits.Semantics = (unsigned) semantics;
  SubscriptExprBits.IsSuper = false;
  SubscriptExprBits.NumArgLabels = argLabels.size();
  SubscriptExprBits.HasArgLabelLocs = !argLabelLocs.empty();
  SubscriptExprBits.HasTrailingClosure = hasTrailingClosure;
  initializeCallArguments(argLabels, argLabelLocs, hasTrailingClosure);
}

SubscriptExpr *SubscriptExpr::create(ASTContext &ctx, Expr *base, Expr *index,
                                     ConcreteDeclRef decl, bool implicit,
                                     AccessSemantics semantics) {
  // Inspect the argument to dig out the argument labels, their location, and
  // whether there is a trailing closure.
  SmallVector<Identifier, 4> argLabelsScratch;
  SmallVector<SourceLoc, 4> argLabelLocs;
  bool hasTrailingClosure = false;
  auto argLabels = getArgumentLabelsFromArgument(index, argLabelsScratch,
                                                 &argLabelLocs,
                                                 &hasTrailingClosure);

  size_t size = totalSizeToAlloc(argLabels, argLabelLocs, hasTrailingClosure);

  void *memory = ctx.Allocate(size, alignof(SubscriptExpr));
  return new (memory) SubscriptExpr(base, index, argLabels, argLabelLocs,
                                    hasTrailingClosure, decl, implicit,
                                    semantics);
}

SubscriptExpr *SubscriptExpr::create(ASTContext &ctx, Expr *base,
                                     SourceLoc lSquareLoc,
                                     ArrayRef<Expr *> indexArgs,
                                     ArrayRef<Identifier> indexArgLabels,
                                     ArrayRef<SourceLoc> indexArgLabelLocs,
                                     SourceLoc rSquareLoc,
                                     Expr *trailingClosure,
                                     ConcreteDeclRef decl,
                                     bool implicit,
                                     AccessSemantics semantics) {
  SmallVector<Identifier, 4> indexArgLabelsScratch;
  SmallVector<SourceLoc, 4> indexArgLabelLocsScratch;
  Expr *index = packSingleArgument(ctx, lSquareLoc, indexArgs, indexArgLabels,
                                   indexArgLabelLocs, rSquareLoc,
                                   trailingClosure, implicit,
                                   indexArgLabelsScratch,
                                   indexArgLabelLocsScratch);

  size_t size = totalSizeToAlloc(indexArgLabels, indexArgLabelLocs,
                                 trailingClosure != nullptr);

  void *memory = ctx.Allocate(size, alignof(SubscriptExpr));
  return new (memory) SubscriptExpr(base, index, indexArgLabels,
                                    indexArgLabelLocs,
                                    trailingClosure != nullptr,
                                    decl, implicit, semantics);
}

DynamicSubscriptExpr::DynamicSubscriptExpr(Expr *base, Expr *index,
                                           ArrayRef<Identifier> argLabels,
                                           ArrayRef<SourceLoc> argLabelLocs,
                                           bool hasTrailingClosure,
                                           ConcreteDeclRef member,
                                           bool implicit)
    : DynamicLookupExpr(ExprKind::DynamicSubscript),
      Base(base), Index(index), Member(member) {
  DynamicSubscriptExprBits.NumArgLabels = argLabels.size();
  DynamicSubscriptExprBits.HasArgLabelLocs = !argLabelLocs.empty();
  DynamicSubscriptExprBits.HasTrailingClosure = hasTrailingClosure;
  initializeCallArguments(argLabels, argLabelLocs, hasTrailingClosure);
  if (implicit) setImplicit(implicit);
}

DynamicSubscriptExpr *
DynamicSubscriptExpr::create(ASTContext &ctx, Expr *base, Expr *index,
                             ConcreteDeclRef decl, bool implicit) {
  // Inspect the argument to dig out the argument labels, their location, and
  // whether there is a trailing closure.
  SmallVector<Identifier, 4> argLabelsScratch;
  SmallVector<SourceLoc, 4> argLabelLocs;
  bool hasTrailingClosure = false;
  auto argLabels = getArgumentLabelsFromArgument(index, argLabelsScratch,
                                                 &argLabelLocs,
                                                 &hasTrailingClosure);

  size_t size = totalSizeToAlloc(argLabels, argLabelLocs, hasTrailingClosure);

  void *memory = ctx.Allocate(size, alignof(DynamicSubscriptExpr));
  return new (memory) DynamicSubscriptExpr(base, index, argLabels, argLabelLocs,
                                           hasTrailingClosure, decl, implicit);
}

DynamicSubscriptExpr *
DynamicSubscriptExpr::create(ASTContext &ctx, Expr *base, SourceLoc lSquareLoc,
                             ArrayRef<Expr *> indexArgs,
                             ArrayRef<Identifier> indexArgLabels,
                             ArrayRef<SourceLoc> indexArgLabelLocs,
                             SourceLoc rSquareLoc,
                             Expr *trailingClosure,
                             ConcreteDeclRef decl,
                             bool implicit) {
  SmallVector<Identifier, 4> indexArgLabelsScratch;
  SmallVector<SourceLoc, 4> indexArgLabelLocsScratch;
  Expr *index = packSingleArgument(ctx, lSquareLoc, indexArgs, indexArgLabels,
                                   indexArgLabelLocs, rSquareLoc,
                                   trailingClosure, implicit,
                                   indexArgLabelsScratch,
                                   indexArgLabelLocsScratch);

  size_t size = totalSizeToAlloc(indexArgLabels, indexArgLabelLocs,
                                 trailingClosure != nullptr);

  void *memory = ctx.Allocate(size, alignof(DynamicSubscriptExpr));
  return new (memory) DynamicSubscriptExpr(base, index, indexArgLabels,
                                           indexArgLabelLocs,
                                           trailingClosure != nullptr,
                                           decl, implicit);
}

UnresolvedMemberExpr::UnresolvedMemberExpr(SourceLoc dotLoc,
                                           DeclNameLoc nameLoc,
                                           DeclName name, Expr *argument,
                                           ArrayRef<Identifier> argLabels,
                                           ArrayRef<SourceLoc> argLabelLocs,
                                           bool hasTrailingClosure,
                                           bool implicit)
  : Expr(ExprKind::UnresolvedMember, implicit),
    DotLoc(dotLoc), NameLoc(nameLoc), Name(name), Argument(argument) {
  UnresolvedMemberExprBits.HasArguments = (argument != nullptr);
  UnresolvedMemberExprBits.NumArgLabels = argLabels.size();
  UnresolvedMemberExprBits.HasArgLabelLocs = !argLabelLocs.empty();
  UnresolvedMemberExprBits.HasTrailingClosure = hasTrailingClosure;
  initializeCallArguments(argLabels, argLabelLocs, hasTrailingClosure);
}

UnresolvedMemberExpr *UnresolvedMemberExpr::create(ASTContext &ctx,
                                                   SourceLoc dotLoc,
                                                   DeclNameLoc nameLoc,
                                                   DeclName name,
                                                   bool implicit) {
  size_t size = totalSizeToAlloc({ }, { }, /*hasTrailingClosure=*/false);

  void *memory = ctx.Allocate(size, alignof(UnresolvedMemberExpr));
  return new (memory) UnresolvedMemberExpr(dotLoc, nameLoc, name, nullptr,
                                           { }, { },
                                           /*hasTrailingClosure=*/false,
                                           implicit);
}

UnresolvedMemberExpr *
UnresolvedMemberExpr::create(ASTContext &ctx, SourceLoc dotLoc,
                             DeclNameLoc nameLoc, DeclName name,
                             SourceLoc lParenLoc,
                             ArrayRef<Expr *> args,
                             ArrayRef<Identifier> argLabels,
                             ArrayRef<SourceLoc> argLabelLocs,
                             SourceLoc rParenLoc,
                             Expr *trailingClosure,
                             bool implicit) {
  SmallVector<Identifier, 4> argLabelsScratch;
  SmallVector<SourceLoc, 4> argLabelLocsScratch;
  Expr *arg = packSingleArgument(ctx, lParenLoc, args, argLabels,
                                 argLabelLocs, rParenLoc,
                                 trailingClosure, implicit,
                                 argLabelsScratch,
                                 argLabelLocsScratch);

  size_t size = totalSizeToAlloc(argLabels, argLabelLocs,
                                 trailingClosure != nullptr);

  void *memory = ctx.Allocate(size, alignof(UnresolvedMemberExpr));
  return new (memory) UnresolvedMemberExpr(dotLoc, nameLoc, name, arg,
                                           argLabels, argLabelLocs,
                                           trailingClosure != nullptr,
                                           implicit);
}

ArrayRef<Identifier> ApplyExpr::getArgumentLabels(
    SmallVectorImpl<Identifier> &scratch) const {
  // Unary operators and 'self' applications have a single, unlabeled argument.
  if (isa<PrefixUnaryExpr>(this) || isa<PostfixUnaryExpr>(this) ||
      isa<SelfApplyExpr>(this)) {
    scratch.clear();
    scratch.push_back(Identifier());
    return scratch;
  }

  // Binary operators have two unlabeled arguments.
  if (isa<BinaryExpr>(this)) {
    scratch.clear();
    scratch.reserve(2);
    scratch.push_back(Identifier());
    scratch.push_back(Identifier());
    return scratch;    
  }

  // For calls, get the argument labels directly.
  auto call = cast<CallExpr>(this);
  return call->getArgumentLabels();
}

bool ApplyExpr::hasTrailingClosure() const {
  if (auto call = dyn_cast<CallExpr>(this))
    return call->hasTrailingClosure();

  return false;
}

CallExpr::CallExpr(Expr *fn, Expr *arg, bool Implicit,
                   ArrayRef<Identifier> argLabels,
                   ArrayRef<SourceLoc> argLabelLocs,
                   bool hasTrailingClosure,
                   Type ty)
    : ApplyExpr(ExprKind::Call, fn, arg, Implicit, ty)
{
  CallExprBits.NumArgLabels = argLabels.size();
  CallExprBits.HasArgLabelLocs = !argLabelLocs.empty();
  CallExprBits.HasTrailingClosure = hasTrailingClosure;
  initializeCallArguments(argLabels, argLabelLocs, hasTrailingClosure);
}

CallExpr *CallExpr::create(ASTContext &ctx, Expr *fn, Expr *arg,
                           ArrayRef<Identifier> argLabels,
                           ArrayRef<SourceLoc> argLabelLocs,
                           bool hasTrailingClosure,
                           bool implicit, Type type) {
  SmallVector<Identifier, 4> argLabelsScratch;
  SmallVector<SourceLoc, 4> argLabelLocsScratch;
  if (argLabels.empty()) {
    // Inspect the argument to dig out the argument labels, their location, and
    // whether there is a trailing closure.
    argLabels = getArgumentLabelsFromArgument(arg, argLabelsScratch,
                                              &argLabelLocsScratch,
                                              &hasTrailingClosure);
    argLabelLocs = argLabelLocsScratch;
  }

  size_t size = totalSizeToAlloc(argLabels, argLabelLocs, hasTrailingClosure);

  void *memory = ctx.Allocate(size, alignof(CallExpr));
  return new (memory) CallExpr(fn, arg, implicit, argLabels, argLabelLocs,
                               hasTrailingClosure, type);
}

CallExpr *CallExpr::create(ASTContext &ctx, Expr *fn,
                           SourceLoc lParenLoc,
                           ArrayRef<Expr *> args,
                           ArrayRef<Identifier> argLabels,
                           ArrayRef<SourceLoc> argLabelLocs,
                           SourceLoc rParenLoc,
                           Expr *trailingClosure,
                           bool implicit) {
  SmallVector<Identifier, 4> argLabelsScratch;
  SmallVector<SourceLoc, 4> argLabelLocsScratch;
  Expr *arg = packSingleArgument(ctx, lParenLoc, args, argLabels, argLabelLocs,
                                 rParenLoc, trailingClosure, implicit,
                                 argLabelsScratch, argLabelLocsScratch);

  size_t size = totalSizeToAlloc(argLabels, argLabelLocs,
                                 trailingClosure != nullptr);

  void *memory = ctx.Allocate(size, alignof(CallExpr));
  return new (memory) CallExpr(fn, arg, implicit, argLabels, argLabelLocs,
                               trailingClosure != nullptr, Type());
}

Expr *CallExpr::getDirectCallee() const {
  auto fn = getFn();
  while (true) {
    fn = fn->getSemanticsProvidingExpr();

    if (auto force = dyn_cast<ForceValueExpr>(fn)) {
      fn = force->getSubExpr();
      continue;
    }

    if (auto bind = dyn_cast<BindOptionalExpr>(fn)) {
      fn = bind->getSubExpr();
      continue;
    }

    return fn;
  }
}

RebindSelfInConstructorExpr::RebindSelfInConstructorExpr(Expr *SubExpr,
                                                         VarDecl *Self)
  : Expr(ExprKind::RebindSelfInConstructor, /*Implicit=*/true,
         TupleType::getEmpty(Self->getASTContext())),
    SubExpr(SubExpr), Self(Self)
{}

OtherConstructorDeclRefExpr *
RebindSelfInConstructorExpr::getCalledConstructor(bool &isChainToSuper) const {
  // Dig out the OtherConstructorRefExpr. Note that this is the reverse
  // of what we do in pre-checking.
  Expr *candidate = getSubExpr();
  while (true) {
    // Look through identity expressions.
    if (auto identity = dyn_cast<IdentityExpr>(candidate)) {
      candidate = identity->getSubExpr();
      continue;
    }

    // Look through force-value expressions.
    if (auto force = dyn_cast<ForceValueExpr>(candidate)) {
      candidate = force->getSubExpr();
      continue;
    }

    // Look through all try expressions.
    if (auto tryExpr = dyn_cast<AnyTryExpr>(candidate)) {
      candidate = tryExpr->getSubExpr();
      continue;
    }

    break;
  }

  // We hit an application, find the constructor reference.
  OtherConstructorDeclRefExpr *otherCtorRef;
  const ApplyExpr *apply;
  do {
    apply = cast<ApplyExpr>(candidate);
    candidate = apply->getFn();
    auto candidateUnwrapped = candidate->getSemanticsProvidingExpr();
    otherCtorRef = dyn_cast<OtherConstructorDeclRefExpr>(candidateUnwrapped);
  } while (!otherCtorRef);

  isChainToSuper = apply->getArg()->isSuperExpr();
  return otherCtorRef;
}

void AbstractClosureExpr::setParameterList(ParameterList *P) {
  parameterList = P;
  // Change the DeclContext of any parameters to be this closure.
  if (P)
    P->setDeclContextOfParamDecls(this);
}


Type AbstractClosureExpr::getResultType() const {
  if (getType()->hasError())
    return getType();

  return getType()->castTo<FunctionType>()->getResult();
}

bool AbstractClosureExpr::isBodyThrowing() const {
  if (getType()->hasError())
    return false;

  return getType()->castTo<FunctionType>()->getExtInfo().throws();
}

bool AbstractClosureExpr::hasSingleExpressionBody() const {
  if (auto closure = dyn_cast<ClosureExpr>(this))
    return closure->hasSingleExpressionBody();

  return true;
}

#define FORWARD_SOURCE_LOCS_TO(CLASS, NODE) \\
  SourceRange CLASS::getSourceRange() const {     \\
    return (NODE)->getSourceRange();              \\
  }                                               \\
  SourceLoc CLASS::getStartLoc() const {          \\
    return (NODE)->getStartLoc();                 \\
  }                                               \\
  SourceLoc CLASS::getEndLoc() const {            \\
    return (NODE)->getEndLoc();                   \\
  }                                               \\
  SourceLoc CLASS::getLoc() const {               \\
    return (NODE)->getStartLoc();                 \\
  }

FORWARD_SOURCE_LOCS_TO(ClosureExpr, Body.getPointer())

Expr *ClosureExpr::getSingleExpressionBody() const {
  assert(hasSingleExpressionBody() && ""Not a single-expression body"");
  auto body = getBody()->getElement(0);
  if (body.is<Stmt *>())
    return cast<ReturnStmt>(body.get<Stmt *>())->getResult();
  return body.get<Expr *>();
}

void ClosureExpr::setSingleExpressionBody(Expr *NewBody) {
  assert(hasSingleExpressionBody() && ""Not a single-expression body"");
  auto body = getBody()->getElement(0);
  if (body.is<Stmt *>()) {
    cast<ReturnStmt>(body.get<Stmt *>())->setResult(NewBody);
    return;
  }
  getBody()->setElement(0, NewBody);
}

FORWARD_SOURCE_LOCS_TO(AutoClosureExpr, Body)

void AutoClosureExpr::setBody(Expr *E) {
  auto &Context = getASTContext();
  auto *RS = new (Context) ReturnStmt(SourceLoc(), E);
  Body = BraceStmt::create(Context, E->getStartLoc(), { RS }, E->getEndLoc());
}

Expr *AutoClosureExpr::getSingleExpressionBody() const {
  return cast<ReturnStmt>(Body->getElement(0).get<Stmt *>())->getResult();
}

FORWARD_SOURCE_LOCS_TO(UnresolvedPatternExpr, subPattern)

TypeExpr::TypeExpr(TypeLoc TyLoc)
  : Expr(ExprKind::Type, /*implicit*/false), Info(TyLoc) {
  Type Ty = TyLoc.getType();
  if (Ty && Ty->hasCanonicalTypeComputed())
    setType(MetatypeType::get(Ty, Ty->getASTContext()));
}

TypeExpr::TypeExpr(Type Ty)
  : Expr(ExprKind::Type, /*implicit*/true), Info(TypeLoc::withoutLoc(Ty)) {
  if (Ty->hasCanonicalTypeComputed())
    setType(MetatypeType::get(Ty, Ty->getASTContext()));
}

// The type of a TypeExpr is always a metatype type.  Return the instance
// type or null if not set yet.
Type TypeExpr::getInstanceType() const {
  if (!getType())
    return Type();

  if (auto metaType = getType()->getAs<MetatypeType>())
    return metaType->getInstanceType();

  return ErrorType::get(getType()->getASTContext());
}


/// Return a TypeExpr for a simple identifier and the specified location.
TypeExpr *TypeExpr::createForDecl(SourceLoc Loc, TypeDecl *Decl,
                                  bool isImplicit) {
  ASTContext &C = Decl->getASTContext();
  assert(Loc.isValid());
  auto *Repr = new (C) SimpleIdentTypeRepr(Loc, Decl->getName());
  Repr->setValue(Decl);
  auto result = new (C) TypeExpr(TypeLoc(Repr, Type()));
  if (isImplicit)
    result->setImplicit();
  return result;
}

TypeExpr *TypeExpr::createForSpecializedDecl(SourceLoc Loc, TypeDecl *D,
                                             ArrayRef<TypeRepr*> args,
                                             SourceRange AngleLocs) {
  ASTContext &C = D->getASTContext();
  assert(Loc.isValid());
  auto *Repr = new (C) GenericIdentTypeRepr(Loc, D->getName(),
                                            args, AngleLocs);
  Repr->setValue(D);
  return new (C) TypeExpr(TypeLoc(Repr, Type()));
}


// Create an implicit TypeExpr, with location information even though it
// shouldn't have one.  This is presently used to work around other location
// processing bugs.  If you have an implicit location, use createImplicit.
TypeExpr *TypeExpr::createImplicitHack(SourceLoc Loc, Type Ty, ASTContext &C) {
  // FIXME: This is horrible.
  if (Loc.isInvalid()) return createImplicit(Ty, C);
  auto *Repr = new (C) FixedTypeRepr(Ty, Loc);
  auto *Res = new (C) TypeExpr(TypeLoc(Repr, Ty));
  Res->setImplicit();
  Res->setType(MetatypeType::get(Ty, C));
  return Res;
}


ArchetypeType *OpenExistentialExpr::getOpenedArchetype() const {
  auto type = getOpaqueValue()->getType()->getRValueType();
  while (auto metaTy = type->getAs<MetatypeType>())
    type = metaTy->getInstanceType();
  return type->castTo<ArchetypeType>();
}

ObjCKeyPathExpr::ObjCKeyPathExpr(SourceLoc keywordLoc, SourceLoc lParenLoc,
                         ArrayRef<Identifier> names,
                         ArrayRef<SourceLoc> nameLocs,
                         SourceLoc rParenLoc)
  : Expr(ExprKind::ObjCKeyPath, /*Implicit=*/nameLocs.empty()),
    KeywordLoc(keywordLoc), LParenLoc(lParenLoc), RParenLoc(rParenLoc)
{
  // Copy components (which are all names).
  ObjCKeyPathExprBits.NumComponents = names.size();
  for (auto idx : indices(names))
    getComponentsMutable()[idx] = names[idx];

  assert(nameLocs.empty() || nameLocs.size() == names.size());
  ObjCKeyPathExprBits.HaveSourceLocations = !nameLocs.empty();
  if (ObjCKeyPathExprBits.HaveSourceLocations) {
    memcpy(getNameLocsMutable().data(), nameLocs.data(),
           nameLocs.size() * sizeof(SourceLoc));
  }
}

Identifier ObjCKeyPathExpr::getComponentName(unsigned i) const {
  if (auto decl = getComponentDecl(i))
    return decl->getFullName().getBaseName();

  return getComponents()[i].get<Identifier>();
}

ObjCKeyPathExpr *ObjCKeyPathExpr::create(ASTContext &ctx,
                                 SourceLoc keywordLoc, SourceLoc lParenLoc,
                                 ArrayRef<Identifier> names,
                                 ArrayRef<SourceLoc> nameLocs,
                                 SourceLoc rParenLoc) {
  unsigned size = sizeof(ObjCKeyPathExpr)
    + names.size() * sizeof(Identifier)
    + nameLocs.size() * sizeof(SourceLoc);
  void *mem = ctx.Allocate(size, alignof(ObjCKeyPathExpr));
  return new (mem) ObjCKeyPathExpr(keywordLoc, lParenLoc, names, nameLocs,
                                   rParenLoc);
}
",16337,True,2526.555434980536,median
"/*
 * Copyright (c) 2018 Bitshares Foundation, and contributors.
 *
 * The MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the ""Software""), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#include <vector>
#include <boost/test/unit_test.hpp>


#include <graphene/chain/database.hpp>
#include <graphene/chain/hardfork.hpp>

#include <graphene/chain/balance_object.hpp>
#include <graphene/chain/budget_record_object.hpp>
#include <graphene/chain/committee_member_object.hpp>
#include <graphene/chain/market_object.hpp>
#include <graphene/chain/withdraw_permission_object.hpp>
#include <graphene/chain/witness_object.hpp>
#include <graphene/chain/worker_object.hpp>
#include <graphene/chain/asset_evaluator.hpp>

#include <graphene/utilities/tempdir.hpp>

#include <fc/crypto/digest.hpp>
#include <fc/log/log_message.hpp>

#include ""../common/database_fixture.hpp""

using namespace graphene::chain;
using namespace graphene::chain::test;

BOOST_FIXTURE_TEST_SUITE( bitasset_tests, database_fixture )

/*****
 * @brief helper method to change a backing asset to a new one
 * @param fixture the database_fixture
 * @param signing_key the signer
 * @param asset_id_to_update asset to update
 * @param new_backing_asset_id the new backing asset
 */
void change_backing_asset(database_fixture& fixture, const fc::ecc::private_key& signing_key,
      asset_id_type asset_id_to_update, asset_id_type new_backing_asset_id)
{
   try
   {
      asset_update_bitasset_operation ba_op;
      const asset_object& asset_to_update = asset_id_to_update(fixture.db);
      ba_op.asset_to_update = asset_id_to_update;
      ba_op.issuer = asset_to_update.issuer;
      ba_op.new_options.short_backing_asset = new_backing_asset_id;
      fixture.trx.operations.push_back(ba_op);
      fixture.sign(fixture.trx, signing_key);
      PUSH_TX(fixture.db, fixture.trx, ~0);
      fixture.generate_block();
      fixture.trx.clear();
   }
   catch (fc::exception& ex)
   {
      BOOST_FAIL( ""Exception thrown in chainge_backing_asset. Exception was: "" +
            ex.to_string(fc::log_level(fc::log_level::all)) );
   }
}

/******
 * @brief helper method to turn witness_fed_asset on and off
 * @param fixture the database_fixture
 * @param new_issuer optionally change the issuer
 * @param signing_key signer
 * @param asset_id asset we want to change
 * @param witness_fed true if you want this to be a witness fed asset
 */
void change_asset_options(database_fixture& fixture, const optional<account_id_type>& new_issuer,
      const fc::ecc::private_key& signing_key,
      asset_id_type asset_id, bool witness_fed)
{
   asset_update_operation op;
   const asset_object& obj = asset_id(fixture.db);
   op.asset_to_update = asset_id;
   op.issuer = obj.issuer;
   if (new_issuer)
      op.new_issuer = new_issuer;
   op.new_options = obj.options;
   if (witness_fed)
   {
      op.new_options.flags |= witness_fed_asset;
      op.new_options.flags &= ~committee_fed_asset;
   }
   else
   {
      op.new_options.flags &= ~witness_fed_asset; // we don't care about the committee flag here
   }
   fixture.trx.operations.push_back(op);
   fixture.sign( fixture.trx, signing_key );
   PUSH_TX( fixture.db, fixture.trx, ~0 );
   fixture.generate_block();
   fixture.trx.clear();

}

/*********
 * @brief helper method to create a coin backed by a bitasset
 * @param fixture the database_fixture
 * @param index added to name of the coin
 * @param backing the backing asset
 * @param signing_key the signing key
 */
const graphene::chain::asset_object& create_bitasset_backed(graphene::chain::database_fixture& fixture,
      int index, graphene::chain::asset_id_type backing, const fc::ecc::private_key& signing_key)
{
   // create the coin
   std::string name = ""COIN"" + std::to_string(index + 1) + ""TEST"";
   const graphene::chain::asset_object& obj = fixture.create_bitasset(name);
   asset_id_type asset_id = obj.get_id();
   // adjust the backing asset
   change_backing_asset(fixture, signing_key, asset_id, backing);
   fixture.trx.set_expiration(fixture.db.get_dynamic_global_properties().next_maintenance_time);
   return obj;
}


/*********
 * @brief make sure feeds still work after changing backing asset on a witness-fed asset
 */
BOOST_AUTO_TEST_CASE( reset_backing_asset_on_witness_asset )
{
   ACTORS((nathan));

   /*
       // do a maintenance block
      generate_blocks(db.get_dynamic_global_properties().next_maintenance_time);
      // generate blocks until close to hard fork
      generate_blocks( HARDFORK_CORE_868_890_TIME - fc::hours(1) );
    */

   BOOST_TEST_MESSAGE(""Advance to near hard fork"");
   auto maint_interval = db.get_global_properties().parameters.maintenance_interval;
   generate_blocks( HARDFORK_CORE_868_890_TIME - maint_interval);
   trx.set_expiration(HARDFORK_CORE_868_890_TIME - fc::seconds(1));

   BOOST_TEST_MESSAGE(""Create USDBIT"");
   asset_id_type bit_usd_id = create_bitasset(""USDBIT"").id;
   asset_id_type core_id = bit_usd_id(db).bitasset_data(db).options.short_backing_asset;

   {
      BOOST_TEST_MESSAGE(""Update the USDBIT asset options"");
      change_asset_options(*this, nathan_id, nathan_private_key, bit_usd_id, false );
   }

   BOOST_TEST_MESSAGE(""Create JMJBIT based on USDBIT."");
   asset_id_type bit_jmj_id = create_bitasset(""JMJBIT"").id;
   {
      BOOST_TEST_MESSAGE(""Update the JMJBIT asset options"");
      change_asset_options(*this, nathan_id, nathan_private_key, bit_jmj_id, true );
   }

   {
      BOOST_TEST_MESSAGE(""Update the JMJBIT bitasset options"");
      asset_update_bitasset_operation ba_op;
      const asset_object& obj = bit_jmj_id(db);
      ba_op.asset_to_update = obj.get_id();
      ba_op.issuer = obj.issuer;
      ba_op.new_options.short_backing_asset = bit_usd_id;
      ba_op.new_options.minimum_feeds = 1;
      trx.operations.push_back(ba_op);
      sign(trx, nathan_private_key);
      PUSH_TX(db, trx, ~0);
      generate_block();
      trx.clear();
   }

   BOOST_TEST_MESSAGE(""Grab active witnesses"");
   auto& global_props = db.get_global_properties();
   std::vector<account_id_type> active_witnesses;
   for(const witness_id_type& wit_id : global_props.active_witnesses)
      active_witnesses.push_back(wit_id(db).witness_account);
   BOOST_REQUIRE_EQUAL(active_witnesses.size(), 10lu);

   {
      BOOST_TEST_MESSAGE(""Adding price feed 1"");
      publish_feed(active_witnesses[0], bit_usd_id, 1, bit_jmj_id, 300, core_id);

      const asset_bitasset_data_object& bitasset = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 300.0);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);
   }
   {
      BOOST_TEST_MESSAGE(""Adding price feed 2"");
      publish_feed(active_witnesses[1], bit_usd_id, 1, bit_jmj_id, 100, core_id);

      const asset_bitasset_data_object& bitasset = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 300.0);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);
   }
   {
      BOOST_TEST_MESSAGE(""Adding price feed 3"");
      publish_feed(active_witnesses[2], bit_usd_id, 1, bit_jmj_id, 1, core_id);

      const asset_bitasset_data_object& bitasset = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 100.0);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);
   }
   {
      BOOST_TEST_MESSAGE(""Change underlying asset of bit_jmj from bit_usd to core"");
      change_backing_asset(*this, nathan_private_key, bit_jmj_id, core_id);

      BOOST_TEST_MESSAGE(""Verify feed producers have not been reset"");
      const asset_bitasset_data_object& jmj_obj = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(jmj_obj.feeds.size(), 3ul);
   }
   {
      BOOST_TEST_MESSAGE(""With underlying bitasset changed from one to another, price feeds should still be publish-able"");
      BOOST_TEST_MESSAGE(""Re-Adding Witness 1 price feed"");
      publish_feed(active_witnesses[0], core_id, 1, bit_jmj_id, 30, core_id);

      const asset_bitasset_data_object& bitasset = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 1);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);

      BOOST_CHECK(bitasset.current_feed.core_exchange_rate.base.asset_id != bitasset.current_feed.core_exchange_rate.quote.asset_id);
   }
   {
      BOOST_TEST_MESSAGE(""Re-Adding Witness 2 price feed"");
      publish_feed(active_witnesses[1], core_id, 1, bit_jmj_id, 100, core_id);

      const asset_bitasset_data_object& bitasset = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 100);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);
   }
   {
      BOOST_TEST_MESSAGE(""Advance to after hard fork"");
      generate_blocks( HARDFORK_CORE_868_890_TIME + fc::seconds(1));
      trx.set_expiration(HARDFORK_CORE_868_890_TIME + fc::hours(2));

      BOOST_TEST_MESSAGE(""After hardfork, 1 feed should have been erased"");
      const asset_bitasset_data_object& jmj_obj = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(jmj_obj.feeds.size(), 2ul);
   }
   {
      BOOST_TEST_MESSAGE(""After hardfork, change underlying asset of bit_jmj from core to bit_usd"");
      change_backing_asset(*this, nathan_private_key, bit_jmj_id, bit_usd_id);

      BOOST_TEST_MESSAGE(""Verify feed producers have been reset"");
      const asset_bitasset_data_object& jmj_obj = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(jmj_obj.feeds.size(), 0ul);
   }
   {
      BOOST_TEST_MESSAGE(""With underlying bitasset changed from one to another, price feeds should still be publish-able"");
      BOOST_TEST_MESSAGE(""Re-Adding Witness 1 price feed"");
      publish_feed(active_witnesses[0], bit_usd_id, 1, bit_jmj_id, 30, core_id);

      const asset_bitasset_data_object& bitasset = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 30);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);

      BOOST_CHECK(bitasset.current_feed.core_exchange_rate.base.asset_id != bitasset.current_feed.core_exchange_rate.quote.asset_id);
   }
}

/****
 * @brief make sure feeds work correctly after changing the backing asset on a non-witness-fed asset
 */
BOOST_AUTO_TEST_CASE( reset_backing_asset_on_non_witness_asset )
{
   ACTORS((nathan)(dan)(ben)(vikram));

   BOOST_TEST_MESSAGE(""Advance to near hard fork"");
   auto maint_interval = db.get_global_properties().parameters.maintenance_interval;
   generate_blocks( HARDFORK_CORE_868_890_TIME - maint_interval);
   trx.set_expiration(HARDFORK_CORE_868_890_TIME - fc::seconds(1));


   BOOST_TEST_MESSAGE(""Create USDBIT"");
   asset_id_type bit_usd_id = create_bitasset(""USDBIT"").id;
   asset_id_type core_id = bit_usd_id(db).bitasset_data(db).options.short_backing_asset;

   {
      BOOST_TEST_MESSAGE(""Update the USDBIT asset options"");
      change_asset_options(*this, nathan_id, nathan_private_key, bit_usd_id, false );
   }

   BOOST_TEST_MESSAGE(""Create JMJBIT based on USDBIT."");
   asset_id_type bit_jmj_id = create_bitasset(""JMJBIT"").id;
   {
      BOOST_TEST_MESSAGE(""Update the JMJBIT asset options"");
      change_asset_options(*this, nathan_id, nathan_private_key, bit_jmj_id, false );
   }
   {
      BOOST_TEST_MESSAGE(""Update the JMJBIT bitasset options"");
      asset_update_bitasset_operation ba_op;
      const asset_object& obj = bit_jmj_id(db);
      ba_op.asset_to_update = obj.get_id();
      ba_op.issuer = obj.issuer;
      ba_op.new_options.short_backing_asset = bit_usd_id;
      ba_op.new_options.minimum_feeds = 1;
      trx.operations.push_back(ba_op);
      sign(trx, nathan_private_key);
      PUSH_TX(db, trx, ~0);
      generate_block();
      trx.clear();
   }
   {
      BOOST_TEST_MESSAGE(""Set feed producers for JMJBIT"");
      asset_update_feed_producers_operation op;
      op.asset_to_update = bit_jmj_id;
      op.issuer = nathan_id;
      op.new_feed_producers = {dan_id, ben_id, vikram_id};
      trx.operations.push_back(op);
      sign( trx, nathan_private_key );
      PUSH_TX( db, trx, ~0 );
      generate_block();
      trx.clear();
   }

   {
      BOOST_TEST_MESSAGE(""Verify feed producers are registered for JMJBIT"");
      const asset_bitasset_data_object& obj = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(obj.feeds.size(), 3ul);
      BOOST_CHECK(obj.current_feed == price_feed());

      BOOST_CHECK( bit_usd_id == obj.options.short_backing_asset );
   }
   {
      BOOST_TEST_MESSAGE(""Adding Vikram's price feed"");
      publish_feed(vikram_id, bit_usd_id, 1, bit_jmj_id, 300, core_id);

      const asset_bitasset_data_object& bitasset = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 300.0);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);
   }
   {
      BOOST_TEST_MESSAGE(""Adding Ben's pricing to JMJBIT"");
      publish_feed(ben_id, bit_usd_id, 1, bit_jmj_id, 100, core_id);

      const asset_bitasset_data_object& bitasset = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 300);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);
   }
   {
      BOOST_TEST_MESSAGE(""Adding Dan's pricing to JMJBIT"");
      publish_feed(dan_id, bit_usd_id, 1, bit_jmj_id, 1, core_id);

      const asset_bitasset_data_object& bitasset = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 100);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);
      generate_block();
      trx.clear();

      BOOST_CHECK(bitasset.current_feed.core_exchange_rate.base.asset_id != bitasset.current_feed.core_exchange_rate.quote.asset_id);
   }
   {
      BOOST_TEST_MESSAGE(""Change underlying asset of bit_jmj from bit_usd to core"");
      change_backing_asset(*this, nathan_private_key, bit_jmj_id, core_id);

      BOOST_TEST_MESSAGE(""Verify feed producers have not been reset"");
      const asset_bitasset_data_object& jmj_obj = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(jmj_obj.feeds.size(), 3ul);
      for(const auto& feed : jmj_obj.feeds) {
         BOOST_CHECK(!feed.second.second.settlement_price.is_null());
      }
   }
   {
      BOOST_TEST_MESSAGE(""Add a new (and correct) feed price for 1 feed producer"");
      publish_feed(vikram_id, core_id, 1, bit_jmj_id, 300, core_id);
   }
   {
      BOOST_TEST_MESSAGE(""Advance to past hard fork"");
      generate_blocks( HARDFORK_CORE_868_890_TIME + maint_interval);
      trx.set_expiration(HARDFORK_CORE_868_890_TIME + fc::hours(48));

      BOOST_TEST_MESSAGE(""Verify that the incorrect feeds have been corrected"");
      const asset_bitasset_data_object& jmj_obj = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(jmj_obj.feeds.size(), 3ul);
      int nan_count = 0;
      for(const auto& feed : jmj_obj.feeds)
      {
         if (feed.second.second.settlement_price.is_null())
            nan_count++;
      }
      BOOST_CHECK_EQUAL(nan_count, 2);
      // the settlement price will be NaN until 50% of price feeds are valid
      //BOOST_CHECK_EQUAL(jmj_obj.current_feed.settlement_price.to_real(), 300);
   }
   {
      BOOST_TEST_MESSAGE(""After hardfork, change underlying asset of bit_jmj from core to bit_usd"");
      change_backing_asset(*this, nathan_private_key, bit_jmj_id, bit_usd_id);

      BOOST_TEST_MESSAGE(""Verify feed producers have been reset"");
      const asset_bitasset_data_object& jmj_obj = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(jmj_obj.feeds.size(), 3ul);
      for(const auto& feed : jmj_obj.feeds)
      {
         BOOST_CHECK(feed.second.second.settlement_price.is_null());
      }
   }
   {
      BOOST_TEST_MESSAGE(""With underlying bitasset changed from one to another, price feeds should still be publish-able"");
      BOOST_TEST_MESSAGE(""Adding Vikram's price feed"");
      publish_feed(vikram_id, bit_usd_id, 1, bit_jmj_id, 30, core_id);

      const asset_bitasset_data_object& bitasset = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 30);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);

      BOOST_TEST_MESSAGE(""Adding Ben's pricing to JMJBIT"");
      publish_feed(ben_id, bit_usd_id, 1, bit_jmj_id, 25, core_id);

      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 30);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);

      BOOST_TEST_MESSAGE(""Adding Dan's pricing to JMJBIT"");
      publish_feed(dan_id, bit_usd_id, 1, bit_jmj_id, 10, core_id);

      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 25);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);
      generate_block();
      trx.clear();

      BOOST_CHECK(bitasset.current_feed.core_exchange_rate.base.asset_id != bitasset.current_feed.core_exchange_rate.quote.asset_id);
   }
}

/*********
 * @brief Update median feeds after feed_lifetime_sec changed
 */
BOOST_AUTO_TEST_CASE( hf_890_test )
{
   uint32_t skip = database::skip_witness_signature
                 | database::skip_transaction_signatures
                 | database::skip_transaction_dupe_check
                 | database::skip_block_size_check
                 | database::skip_tapos_check
                 | database::skip_merkle_check
                 ;
   generate_blocks(HARDFORK_615_TIME, true, skip); // get around Graphene issue #615 feed expiration bug
   generate_blocks(db.get_dynamic_global_properties().next_maintenance_time, true, skip);

   auto hf_time = HARDFORK_CORE_868_890_TIME;
   if(hf1270)
      hf_time = HARDFORK_CORE_1270_TIME;

   for( int i=0; i<2; ++i )
   {
      int blocks = 0;
      auto mi = db.get_global_properties().parameters.maintenance_interval;

      if( i == 1 ) // go beyond hard fork
      {
         blocks += generate_blocks(hf_time - mi, true, skip);
         blocks += generate_blocks(db.get_dynamic_global_properties().next_maintenance_time, true, skip);
      }
      set_expiration( db, trx );

      ACTORS((buyer)(seller)(borrower)(feedproducer));

      int64_t init_balance(1000000);

      transfer(committee_account, buyer_id, asset(init_balance));
      transfer(committee_account, borrower_id, asset(init_balance));

      const auto& bitusd = create_bitasset(""USDBIT"", feedproducer_id);
      asset_id_type usd_id = bitusd.id;

      {
         // change feed lifetime
         const asset_object& asset_to_update = usd_id(db);
         asset_update_bitasset_operation ba_op;
         ba_op.asset_to_update = usd_id;
         ba_op.issuer = asset_to_update.issuer;
         ba_op.new_options = asset_to_update.bitasset_data(db).options;
         ba_op.new_options.feed_lifetime_sec = 600;
         trx.operations.push_back(ba_op);
         PUSH_TX(db, trx, ~0);
         trx.clear();
      }

      // prepare feed data
      price_feed current_feed;
      current_feed.maintenance_collateral_ratio = 1750;
      current_feed.maximum_short_squeeze_ratio = 1100;

      // set price feed
      update_feed_producers( usd_id(db), {feedproducer_id} );
      current_feed.settlement_price = asset(100, usd_id) / asset(5);
      publish_feed( usd_id, feedproducer_id, current_feed );

      // Place some collateralized orders
      // start out with 300% collateral, call price is 15/175 CORE/USD = 60/700
      borrow( borrower_id, asset(100, usd_id), asset(15) );

      transfer( borrower_id, seller_id, asset(100, usd_id) );

      // Adjust price feed to get call order into margin call territory
      current_feed.settlement_price = asset(100, usd_id) / asset(10);
      publish_feed( usd_id, feedproducer_id, current_feed );
      // settlement price = 100 USD / 10 CORE, mssp = 100/11 USD/CORE

      // let the feed expire
      blocks += generate_blocks( db.head_block_time() + 1200, true, skip );
      set_expiration( db, trx );

      // check: median feed should be null
      BOOST_CHECK( usd_id(db).bitasset_data(db).current_feed.settlement_price.is_null() );

      // place a sell order, it won't be matched with the call order
      limit_order_id_type sell_id = create_sell_order(seller_id, asset(10, usd_id), asset(1))->id;

      {
         // change feed lifetime to longer
         const asset_object& asset_to_update = usd_id(db);
         asset_update_bitasset_operation ba_op;
         ba_op.asset_to_update = usd_id;
         ba_op.issuer = asset_to_update.issuer;
         ba_op.new_options = asset_to_update.bitasset_data(db).options;
         ba_op.new_options.feed_lifetime_sec = hf_time.sec_since_epoch()
                                             - db.head_block_time().sec_since_epoch()
                                             + mi
                                             + 1800;
         trx.operations.push_back(ba_op);
         PUSH_TX(db, trx, ~0);
         trx.clear();
      }

      // check
      if( i == 0 ) // before hard fork, median feed is still null, and limit order is still there
      {
         BOOST_CHECK( usd_id(db).bitasset_data(db).current_feed.settlement_price.is_null() );
         BOOST_CHECK( db.find<limit_order_object>( sell_id ) );

         // go beyond hard fork
         blocks += generate_blocks(hf_time - mi, true, skip);
         blocks += generate_blocks(db.get_dynamic_global_properties().next_maintenance_time, true, skip);
      }

      // after hard fork, median feed should become valid, and the limit order should be filled
      {
         BOOST_CHECK( usd_id(db).bitasset_data(db).current_feed.settlement_price == current_feed.settlement_price );
         BOOST_CHECK( !db.find<limit_order_object>( sell_id ) );
      }

      // undo above tx's and reset
      generate_block( skip );
      ++blocks;
      while( blocks > 0 )
      {
         db.pop_block();
         --blocks;
      }
   }
}

class bitasset_evaluator_wrapper : public asset_update_bitasset_evaluator
{
public:
   void set_db(database& db)
   {
      this->trx_state = new transaction_evaluation_state(&db);
   }
};

struct assets_922_931
{
   asset_id_type bit_usd;
   asset_id_type bit_usdbacked;
   asset_id_type bit_usdbacked2;
   asset_id_type bit_child_bitasset;
   asset_id_type bit_parent;
   asset_id_type user_issued;
   asset_id_type six_precision;
   asset_id_type prediction;
};

assets_922_931 create_assets_922_931(database_fixture* fixture)
{
   assets_922_931 asset_objs;
   BOOST_TEST_MESSAGE( ""Create USDBIT"" );
   asset_objs.bit_usd = fixture->create_bitasset( ""USDBIT"", GRAPHENE_COMMITTEE_ACCOUNT ).get_id();

   BOOST_TEST_MESSAGE( ""Create USDBACKED"" );
   asset_objs.bit_usdbacked = fixture->create_bitasset( ""USDBACKED"", GRAPHENE_COMMITTEE_ACCOUNT,
         100, charge_market_fee, 2, asset_objs.bit_usd ).get_id();

   BOOST_TEST_MESSAGE( ""Create USDBACKEDII"" );
   asset_objs.bit_usdbacked2 = fixture->create_bitasset( ""USDBACKEDII"", GRAPHENE_WITNESS_ACCOUNT,
         100, charge_market_fee, 2, asset_objs.bit_usd ).get_id();

   BOOST_TEST_MESSAGE( ""Create PARENT"" );
   asset_objs.bit_parent = fixture->create_bitasset( ""PARENT"", GRAPHENE_WITNESS_ACCOUNT).get_id();

   BOOST_TEST_MESSAGE( ""Create CHILDUSER"" );
   asset_objs.bit_child_bitasset = fixture->create_bitasset( ""CHILDUSER"", GRAPHENE_WITNESS_ACCOUNT,
         100, charge_market_fee, 2, asset_objs.bit_parent ).get_id();

   BOOST_TEST_MESSAGE( ""Create user issued USERISSUED"" );
   asset_objs.user_issued = fixture->create_user_issued_asset( ""USERISSUED"",
         GRAPHENE_WITNESS_ACCOUNT(fixture->db), charge_market_fee ).get_id();

   BOOST_TEST_MESSAGE( ""Create a user-issued asset with a precision of 6"" );
   asset_objs.six_precision = fixture->create_user_issued_asset( ""SIXPRECISION"", GRAPHENE_WITNESS_ACCOUNT(fixture->db),
         charge_market_fee, price(asset(1, asset_id_type(1)), asset(1)), 6 ).get_id();

   BOOST_TEST_MESSAGE( ""Create Prediction market with precision of 6, backed by SIXPRECISION"" );
   asset_objs.prediction = fixture->create_prediction_market( ""PREDICTION"", GRAPHENE_WITNESS_ACCOUNT,
         100, charge_market_fee, 6, asset_objs.six_precision ).get_id();

   return asset_objs;
}
/******
 * @brief Test various bitasset asserts within the asset_evaluator before the HF 922 / 931
 */
BOOST_AUTO_TEST_CASE( bitasset_evaluator_test_before_922_931 )
{
   BOOST_TEST_MESSAGE(""Advance to near hard fork 922 / 931"");
   auto global_params = db.get_global_properties().parameters;
   generate_blocks( HARDFORK_CORE_922_931_TIME - global_params.maintenance_interval );
   trx.set_expiration( HARDFORK_CORE_922_931_TIME - global_params.maintenance_interval + global_params.maximum_time_until_expiration );

   ACTORS( (nathan) (john) );

   assets_922_931 asset_objs = create_assets_922_931( this );
   const asset_id_type bit_usd_id = asset_objs.bit_usd;

   // make a generic operation
   bitasset_evaluator_wrapper evaluator;
   evaluator.set_db(db);
   asset_update_bitasset_operation op;
   op.asset_to_update = bit_usd_id;
   op.issuer = asset_objs.bit_usd(db).issuer;
   op.new_options = asset_objs.bit_usd(db).bitasset_data(db).options;

   // this should pass
   BOOST_TEST_MESSAGE( ""Evaluating a good operation"" );
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );

   // test with a market issued asset
   BOOST_TEST_MESSAGE( ""Sending a non-bitasset."" );
   op.asset_to_update = asset_objs.user_issued;
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""on a non-BitAsset."" );
   op.asset_to_update = bit_usd_id;

   // test changing issuer
   BOOST_TEST_MESSAGE( ""Test changing issuer."" );
   account_id_type original_issuer = op.issuer;
   op.issuer = john_id;
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""Only asset issuer can update"" );
   op.issuer = original_issuer;

   // bad backing_asset
   BOOST_TEST_MESSAGE( ""Non-existent backing asset."" );
   asset_id_type correct_asset_id = op.new_options.short_backing_asset;
   op.new_options.short_backing_asset = asset_id_type();
   op.new_options.short_backing_asset.instance = 123;
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""Unable to find Object"" );
   op.new_options.short_backing_asset = correct_asset_id;

   // now check the things that are wrong, but still pass before HF 922 / 931
   BOOST_TEST_MESSAGE( ""Now check the things that are wrong, but still pass before HF 922 / 931"" );

   // back by self
   BOOST_TEST_MESSAGE( ""Message should contain: op.new_options.short_backing_asset == asset_obj.get_id()"" );
   op.new_options.short_backing_asset = bit_usd_id;
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
   op.new_options.short_backing_asset = correct_asset_id;

   // prediction market with different precision
   BOOST_TEST_MESSAGE( ""Message should contain: for a PM, asset_obj.precision != new_backing_asset.precision"" );
   op.asset_to_update = asset_objs.prediction;
   op.issuer = asset_objs.prediction(db).issuer;
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
   op.asset_to_update = bit_usd_id;
   op.issuer = asset_objs.bit_usd(db).issuer;

   // checking old backing asset instead of new backing asset
   BOOST_TEST_MESSAGE( ""Message should contain: to be backed by an asset which is not market issued asset nor CORE"" );
   op.new_options.short_backing_asset = asset_objs.six_precision;
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
   BOOST_TEST_MESSAGE( ""Message should contain: modified a blockchain-controlled market asset to be backed by an asset ""
         ""which is not backed by CORE"" );
   op.new_options.short_backing_asset = asset_objs.prediction;
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
   op.new_options.short_backing_asset = correct_asset_id;

   // CHILDUSER is a non-committee asset backed by PARENT which is backed by CORE
   // Cannot change PARENT's backing asset from CORE to something that is not [CORE | UIA]
   // because that will make CHILD be backed by an asset that is not itself backed by CORE or a UIA.
   BOOST_TEST_MESSAGE( ""Message should contain: but this asset is a backing asset for another MPA, which would cause MPA ""
         ""backed by MPA backed by MPA."" );
   op.asset_to_update = asset_objs.bit_parent;
   op.issuer = asset_objs.bit_parent(db).issuer;
   op.new_options.short_backing_asset = asset_objs.bit_usdbacked;
   // this should generate a warning in the log, but not fail.
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
   // changing the backing asset to a UIA should work
   BOOST_TEST_MESSAGE( ""Switching to a backing asset that is a UIA should work. No warning should be produced."" );
   op.new_options.short_backing_asset = asset_objs.user_issued;
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
   // A -> B -> C, change B to be backed by A (circular backing)
   BOOST_TEST_MESSAGE( ""Message should contain: A cannot be backed by B which is backed by A."" );
   op.new_options.short_backing_asset = asset_objs.bit_child_bitasset;
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
   op.new_options.short_backing_asset = asset_objs.user_issued;
   BOOST_TEST_MESSAGE( ""Message should contain: but this asset is a backing asset for a committee-issued asset."" );
   // CHILDCOMMITTEE is a committee asset backed by PARENT which is backed by CORE
   // Cannot change PARENT's backing asset from CORE to something else because that will make CHILD be backed by
   // an asset that is not itself backed by CORE
   create_bitasset( ""CHILDCOMMITTEE"", GRAPHENE_COMMITTEE_ACCOUNT, 100, charge_market_fee, 2,
         asset_objs.bit_parent );
   // it should again work, generating 2 warnings in the log. 1 for the above, and 1 new one.
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
   op.asset_to_update = asset_objs.bit_usd;
   op.issuer = asset_objs.bit_usd(db).issuer;
   op.new_options.short_backing_asset = correct_asset_id;

   // USDBACKED is backed by USDBIT (which is backed by CORE)
   // USDBACKEDII is backed by USDBIT
   // We should not be able to make USDBACKEDII be backed by USDBACKED
   // because that would be a MPA backed by MPA backed by MPA.
   BOOST_TEST_MESSAGE( ""Message should contain: a BitAsset cannot be backed by a BitAsset that ""
         ""itself is backed by a BitAsset."" );
   op.asset_to_update = asset_objs.bit_usdbacked2;
   op.issuer = asset_objs.bit_usdbacked2(db).issuer;
   op.new_options.short_backing_asset = asset_objs.bit_usdbacked;
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
   // set everything to a more normal state
   op.asset_to_update = asset_objs.bit_usdbacked;
   op.issuer = asset_objs.bit_usd(db).issuer;
   op.new_options.short_backing_asset = asset_id_type();

   // Feed lifetime must exceed block interval
   BOOST_TEST_MESSAGE( ""Message should contain: op.new_options.feed_lifetime_sec <= chain_parameters.block_interval"" );
   const auto good_feed_lifetime = op.new_options.feed_lifetime_sec;
   op.new_options.feed_lifetime_sec = db.get_global_properties().parameters.block_interval;
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
   BOOST_TEST_MESSAGE( ""Message should contain: op.new_options.feed_lifetime_sec <= chain_parameters.block_interval"" );
   op.new_options.feed_lifetime_sec = db.get_global_properties().parameters.block_interval - 1; // default interval > 1
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
   op.new_options.feed_lifetime_sec = good_feed_lifetime;

   // Force settlement delay must exceed block interval.
   BOOST_TEST_MESSAGE( ""Message should contain: op.new_options.force_settlement_delay_sec <= chain_parameters.block_interval"" );
   const auto good_force_settlement_delay_sec = op.new_options.force_settlement_delay_sec;
   op.new_options.force_settlement_delay_sec = db.get_global_properties().parameters.block_interval;
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
   BOOST_TEST_MESSAGE( ""Message should contain: op.new_options.force_settlement_delay_sec <= chain_parameters.block_interval"" );
   op.new_options.force_settlement_delay_sec = db.get_global_properties().parameters.block_interval - 1; // default interval > 1
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
   op.new_options.force_settlement_delay_sec = good_force_settlement_delay_sec;

   // this should pass
   BOOST_TEST_MESSAGE( ""We should be all good again."" );
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
}

/******
 * @brief Test various bitasset asserts within the asset_evaluator before the HF 922 / 931
 */
BOOST_AUTO_TEST_CASE( bitasset_evaluator_test_after_922_931 )
{
   BOOST_TEST_MESSAGE(""Advance to after hard fork 922 / 931"");
   auto global_params = db.get_global_properties().parameters;
   generate_blocks( HARDFORK_CORE_922_931_TIME + global_params.maintenance_interval );
   trx.set_expiration( HARDFORK_CORE_922_931_TIME + global_params.maintenance_interval + global_params.maximum_time_until_expiration );

   ACTORS( (nathan) (john) );

   assets_922_931 asset_objs = create_assets_922_931( this );
   const asset_id_type& bit_usd_id = asset_objs.bit_usd;

   // make a generic operation
   bitasset_evaluator_wrapper evaluator;
   evaluator.set_db( db );
   asset_update_bitasset_operation op;
   op.asset_to_update = bit_usd_id;
   op.issuer = asset_objs.bit_usd(db).issuer;
   op.new_options = asset_objs.bit_usd(db).bitasset_data(db).options;

   // this should pass
   BOOST_TEST_MESSAGE( ""Evaluating a good operation"" );
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );

   // test with a market issued asset
   BOOST_TEST_MESSAGE( ""Sending a non-bitasset."" );
   op.asset_to_update = asset_objs.user_issued;
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""Cannot update BitAsset-specific settings on a non-BitAsset"" );
   op.asset_to_update = bit_usd_id;

   // test changing issuer
   BOOST_TEST_MESSAGE( ""Test changing issuer."" );
   account_id_type original_issuer = op.issuer;
   op.issuer = john_id;
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""Only asset issuer can update"" );
   op.issuer = original_issuer;

   // bad backing_asset
   BOOST_TEST_MESSAGE( ""Non-existent backing asset."" );
   asset_id_type correct_asset_id = op.new_options.short_backing_asset;
   op.new_options.short_backing_asset = asset_id_type();
   op.new_options.short_backing_asset.instance = 123;
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""Unable to find"" );
   op.new_options.short_backing_asset = correct_asset_id;

   // now check the things that are wrong and won't pass after HF 922 / 931
   BOOST_TEST_MESSAGE( ""Now check the things that are wrong and won't pass after HF 922 / 931"" );

   // back by self
   BOOST_TEST_MESSAGE( ""Back by itself"" );
   op.new_options.short_backing_asset = bit_usd_id;
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""Cannot update an asset to be backed by itself"" );
   op.new_options.short_backing_asset = correct_asset_id;

   // prediction market with different precision
   BOOST_TEST_MESSAGE( ""Prediction market with different precision"" );
   op.asset_to_update = asset_objs.prediction;
   op.issuer = asset_objs.prediction(db).issuer;
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""The precision of the asset and backing asset must"" );
   op.asset_to_update = bit_usd_id;
   op.issuer = asset_objs.bit_usd(db).issuer;

   // checking old backing asset instead of new backing asset
   BOOST_TEST_MESSAGE( ""Correctly checking new backing asset rather than old backing asset"" );
   op.new_options.short_backing_asset = asset_objs.six_precision;
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""which is not market issued asset nor CORE."" );
   op.new_options.short_backing_asset = asset_objs.prediction;
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""which is not backed by CORE"" );
   op.new_options.short_backing_asset = correct_asset_id;

   // CHILD is a non-committee asset backed by PARENT which is backed by CORE
   // Cannot change PARENT's backing asset from CORE to something that is not [CORE | UIA]
   // because that will make CHILD be backed by an asset that is not itself backed by CORE or a UIA.
   BOOST_TEST_MESSAGE( ""Attempting to change PARENT to be backed by a non-core and non-user-issued asset"" );
   op.asset_to_update = asset_objs.bit_parent;
   op.issuer = asset_objs.bit_parent(db).issuer;
   op.new_options.short_backing_asset = asset_objs.bit_usdbacked;
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""A non-blockchain controlled BitAsset would be invalidated"" );
   // changing the backing asset to a UIA should work
   BOOST_TEST_MESSAGE( ""Switching to a backing asset that is a UIA should work."" );
   op.new_options.short_backing_asset = asset_objs.user_issued;
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
   // A -> B -> C, change B to be backed by A (circular backing)
   BOOST_TEST_MESSAGE( ""Check for circular backing. This should generate an exception"" );
   op.new_options.short_backing_asset = asset_objs.bit_child_bitasset;
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""'A' backed by 'B' backed by 'A'"" );
   op.new_options.short_backing_asset = asset_objs.user_issued;
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
   BOOST_TEST_MESSAGE( ""Creating CHILDCOMMITTEE"" );
   // CHILDCOMMITTEE is a committee asset backed by PARENT which is backed by CORE
   // Cannot change PARENT's backing asset from CORE to something else because that will make CHILDCOMMITTEE
   // be backed by an asset that is not itself backed by CORE
   create_bitasset( ""CHILDCOMMITTEE"", GRAPHENE_COMMITTEE_ACCOUNT, 100, charge_market_fee, 2,
         asset_objs.bit_parent );
   // it should again not work
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""A blockchain-controlled market asset would be invalidated"" );
   op.asset_to_update = asset_objs.bit_usd;
   op.issuer = asset_objs.bit_usd(db).issuer;
   op.new_options.short_backing_asset = correct_asset_id;

   // USDBACKED is backed by USDBIT (which is backed by CORE)
   // USDBACKEDII is backed by USDBIT
   // We should not be able to make USDBACKEDII be backed by USDBACKED
   // because that would be a MPA backed by MPA backed by MPA.
   BOOST_TEST_MESSAGE( ""MPA -> MPA -> MPA not allowed"" );
   op.asset_to_update = asset_objs.bit_usdbacked2;
   op.issuer = asset_objs.bit_usdbacked2(db).issuer;
   op.new_options.short_backing_asset = asset_objs.bit_usdbacked;
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op),
         ""A BitAsset cannot be backed by a BitAsset that itself is backed by a BitAsset"" );
   // set everything to a more normal state
   op.asset_to_update = asset_objs.bit_usdbacked;
   op.issuer = asset_objs.bit_usd(db).issuer;
   op.new_options.short_backing_asset = asset_id_type();

   // Feed lifetime must exceed block interval
   BOOST_TEST_MESSAGE( ""Feed lifetime less than or equal to block interval"" );
   const auto good_feed_lifetime = op.new_options.feed_lifetime_sec;
   op.new_options.feed_lifetime_sec = db.get_global_properties().parameters.block_interval;
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""Feed lifetime must exceed block"" );
   op.new_options.feed_lifetime_sec = db.get_global_properties().parameters.block_interval - 1; // default interval > 1
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""Feed lifetime must exceed block"" );
   op.new_options.feed_lifetime_sec = good_feed_lifetime;

   // Force settlement delay must exceed block interval.
   BOOST_TEST_MESSAGE( ""Force settlement delay less than or equal to block interval"" );
   const auto good_force_settlement_delay_sec = op.new_options.force_settlement_delay_sec;
   op.new_options.force_settlement_delay_sec = db.get_global_properties().parameters.block_interval;
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""Force settlement delay must"" );
   op.new_options.force_settlement_delay_sec = db.get_global_properties().parameters.block_interval - 1; // default interval > 1
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""Force settlement delay must"" );
   op.new_options.force_settlement_delay_sec = good_force_settlement_delay_sec;

   // this should pass
   BOOST_TEST_MESSAGE( ""We should be all good again."" );
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );

}

/*********
 * @brief Call check_call_orders after current_feed changed but not only settlement_price changed.
 */
BOOST_AUTO_TEST_CASE( hf_935_test )
{ try {
   uint32_t skip = database::skip_witness_signature
                 | database::skip_transaction_signatures
                 | database::skip_transaction_dupe_check
                 | database::skip_block_size_check
                 | database::skip_tapos_check
                 | database::skip_merkle_check
                 ;
   generate_blocks( HARDFORK_615_TIME, true, skip ); // get around Graphene issue #615 feed expiration bug
   generate_blocks( db.get_dynamic_global_properties().next_maintenance_time, true, skip );
   generate_block( skip );

   for( int i = 0; i < 8; ++i )
   {
      idump( (i) );
      int blocks = 0;
      auto mi = db.get_global_properties().parameters.maintenance_interval;

      if( i == 2 ) // go beyond hard fork 890
      {
         generate_blocks( HARDFORK_CORE_868_890_TIME - mi, true, skip );
         generate_blocks( db.get_dynamic_global_properties().next_maintenance_time, true, skip );
      }
      else if( i == 4 ) // go beyond hard fork 935
      {
         generate_blocks( HARDFORK_CORE_935_TIME - mi, true, skip );
         generate_blocks( db.get_dynamic_global_properties().next_maintenance_time, true, skip );
      }
      else if( i == 6 ) // go beyond hard fork 1270
      {
         generate_blocks( HARDFORK_CORE_1270_TIME - mi, true, skip );
         generate_blocks( db.get_dynamic_global_properties().next_maintenance_time, true, skip );
      }
      set_expiration( db, trx );

      ACTORS( (seller)(borrower)(feedproducer)(feedproducer2)(feedproducer3) );

      int64_t init_balance( 1000000 );

      transfer( committee_account, borrower_id, asset(init_balance) );

      const auto& bitusd = create_bitasset( ""USDBIT"", feedproducer_id );
      asset_id_type usd_id = bitusd.id;

      {
         // set a short feed lifetime
         const asset_object& asset_to_update = usd_id(db);
         asset_update_bitasset_operation ba_op;
         ba_op.asset_to_update = usd_id;
         ba_op.issuer = asset_to_update.issuer;
         ba_op.new_options = asset_to_update.bitasset_data(db).options;
         ba_op.new_options.feed_lifetime_sec = 300;
         trx.operations.push_back(ba_op);
         PUSH_TX(db, trx, ~0);
         trx.clear();
      }

      // set feed producers
      flat_set<account_id_type> producers;
      producers.insert( feedproducer_id );
      producers.insert( feedproducer2_id );
      producers.insert( feedproducer3_id );
      update_feed_producers( usd_id(db), producers );

      // prepare feed data
      price_feed current_feed;
      if( i % 2 == 0 ) // MCR test
      {
         current_feed.maintenance_collateral_ratio = 3500;
         current_feed.maximum_short_squeeze_ratio = 1100;
         current_feed.settlement_price = asset(100, usd_id) / asset(5);
      }
      else // MSSR test
      {
         current_feed.maintenance_collateral_ratio = 1750;
         current_feed.maximum_short_squeeze_ratio = 1250;
         current_feed.settlement_price = asset(100, usd_id) / asset(10);
         // mssp = 1000/125
      }

      // set 2 price feeds which should call some later
      publish_feed( usd_id, feedproducer_id, current_feed );
      publish_feed( usd_id, feedproducer2_id, current_feed );

      // check median
      BOOST_CHECK( usd_id(db).bitasset_data(db).current_feed.settlement_price == current_feed.settlement_price );
      if( i % 2 == 0 ) // MCR test, MCR should be 350%
         BOOST_CHECK_EQUAL( usd_id(db).bitasset_data(db).current_feed.maintenance_collateral_ratio, 3500 );
      else // MSSR test, MSSR should be 125%
         BOOST_CHECK_EQUAL( usd_id(db).bitasset_data(db).current_feed.maximum_short_squeeze_ratio, 1250 );

      // generate some blocks, let the feeds expire
      blocks += generate_blocks( db.head_block_time() + 360, true, skip );
      set_expiration( db, trx );

      // check median, should be null
      BOOST_CHECK( usd_id(db).bitasset_data(db).current_feed.settlement_price.is_null() );

      // publish a new feed with 175% MCR and 110% MSSR
      current_feed.settlement_price = asset(100, usd_id) / asset(5);
      current_feed.maintenance_collateral_ratio = 1750;
      current_feed.maximum_short_squeeze_ratio = 1100;
      publish_feed( usd_id, feedproducer3_id, current_feed );

      // check median, MCR would be 175%, MSSR would be 110%
      BOOST_CHECK( usd_id(db).bitasset_data(db).current_feed.settlement_price == current_feed.settlement_price );
      BOOST_CHECK_EQUAL( usd_id(db).bitasset_data(db).current_feed.maintenance_collateral_ratio, 1750 );
      BOOST_CHECK_EQUAL( usd_id(db).bitasset_data(db).current_feed.maximum_short_squeeze_ratio, 1100 );

      // Place some collateralized orders
      // start out with 300% collateral, call price is 15/175 CORE/USD = 60/700
      borrow( borrower_id, asset(100, usd_id), asset(15) );

      transfer( borrower_id, seller_id, asset(100, usd_id) );

      if( i % 2 == 1) // MSSR test
      {
         // publish a new feed to put the call order into margin call territory
         current_feed.settlement_price = asset(100, usd_id) / asset(10);
         current_feed.maintenance_collateral_ratio = 1750;
         current_feed.maximum_short_squeeze_ratio = 1100;
         publish_feed( usd_id, feedproducer3_id, current_feed );
         // mssp = 100/11
      }

      // place a sell order, it won't be matched with the call order now.
      // For MCR test, the sell order is at feed price (100/5),
      //   when median MCR changed to 350%, the call order with 300% collateral will be in margin call territory,
      //   then this limit order should be filled
      // For MSSR test, the sell order is above 110% of feed price (100/10) but below 125% of feed price,
      //   when median MSSR changed to 125%, the call order will be matched,
      //   then this limit order should be filled
      limit_order_id_type sell_id = ( i % 2 == 0 ) ?
                                    create_sell_order( seller_id, asset(20, usd_id), asset(1) )->id : // for MCR test
                                    create_sell_order( seller_id, asset(8, usd_id), asset(1) )->id;  // for MSSR test

      {
         // change feed lifetime to longer, let all 3 feeds be valid
         const asset_object& asset_to_update = usd_id(db);
         asset_update_bitasset_operation ba_op;
         ba_op.asset_to_update = usd_id;
         ba_op.issuer = asset_to_update.issuer;
         ba_op.new_options = asset_to_update.bitasset_data(db).options;
         ba_op.new_options.feed_lifetime_sec = HARDFORK_CORE_1270_TIME.sec_since_epoch()
                                             + mi * 3 + 86400 * 2
                                             - db.head_block_time().sec_since_epoch();
         trx.operations.push_back(ba_op);
         PUSH_TX(db, trx, ~0);
         trx.clear();
      }

      bool affected_by_hf_343 = false;

      // check
      if( i / 2 == 0 ) // before hard fork 890
      {
         // median feed won't change (issue 890)
         BOOST_CHECK( usd_id(db).bitasset_data(db).current_feed.settlement_price == current_feed.settlement_price );
         BOOST_CHECK_EQUAL( usd_id(db).bitasset_data(db).current_feed.maintenance_collateral_ratio, 1750 );
         BOOST_CHECK_EQUAL( usd_id(db).bitasset_data(db).current_feed.maximum_short_squeeze_ratio, 1100 );
         // limit order is still there
         BOOST_CHECK( db.find<limit_order_object>( sell_id ) );

         // go beyond hard fork 890
         blocks += generate_blocks( HARDFORK_CORE_868_890_TIME - mi, true, skip );
         bool was_before_hf_343 = ( db.get_dynamic_global_properties().next_maintenance_time <= HARDFORK_CORE_343_TIME );

         blocks += generate_blocks( db.get_dynamic_global_properties().next_maintenance_time, true, skip );
         bool now_after_hf_343 = ( db.get_dynamic_global_properties().next_maintenance_time > HARDFORK_CORE_343_TIME );

         if( was_before_hf_343 && now_after_hf_343 ) // if hf 343 executed at same maintenance interval, actually after hf 890
            affected_by_hf_343 = true;
      }

      // after hard fork 890, if it's before hard fork 935
      if( db.get_dynamic_global_properties().next_maintenance_time <= HARDFORK_CORE_935_TIME )
      {
         // median should have changed
         BOOST_CHECK( usd_id(db).bitasset_data(db).current_feed.settlement_price == current_feed.settlement_price );
         if( i % 2 == 0 ) // MCR test, MCR should be 350%
            BOOST_CHECK_EQUAL( usd_id(db).bitasset_data(db).current_feed.maintenance_collateral_ratio, 3500 );
         else // MSSR test, MSSR should be 125%
            BOOST_CHECK_EQUAL( usd_id(db).bitasset_data(db).current_feed.maximum_short_squeeze_ratio, 1250 );

         if( affected_by_hf_343 ) // if updated bitasset before hf 890, and hf 343 executed after hf 890
            // the limit order should have been filled
            BOOST_CHECK( !db.find<limit_order_object>( sell_id ) );
         else // if not affected by hf 343
            // the limit order should be still there, because `check_call_order` was incorrectly skipped
            BOOST_CHECK( db.find<limit_order_object>( sell_id ) );

         // go beyond hard fork 935
         blocks += generate_blocks(HARDFORK_CORE_935_TIME - mi, true, skip);
         blocks += generate_blocks(db.get_dynamic_global_properties().next_maintenance_time, true, skip);
      }

      // after hard fork 935, the limit order is filled only for the MSSR test
      if( db.get_dynamic_global_properties().next_maintenance_time > HARDFORK_CORE_935_TIME &&
          db.get_dynamic_global_properties().next_maintenance_time <= HARDFORK_CORE_1270_TIME)
      {
         // check median
         BOOST_CHECK( usd_id(db).bitasset_data(db).current_feed.settlement_price == current_feed.settlement_price );
         if( i % 2 == 0) { // MCR test, median MCR should be 350% and order will not be filled except when i = 0
            BOOST_CHECK_EQUAL(usd_id(db).bitasset_data(db).current_feed.maintenance_collateral_ratio, 3500);
            if( affected_by_hf_343 )
               BOOST_CHECK(!db.find<limit_order_object>(sell_id));
            else
               BOOST_CHECK(db.find<limit_order_object>(sell_id)); // MCR bug, order still there
         }
         else { // MSSR test, MSSR should be 125% and order is filled
            BOOST_CHECK_EQUAL(usd_id(db).bitasset_data(db).current_feed.maximum_short_squeeze_ratio, 1250);
            BOOST_CHECK(!db.find<limit_order_object>(sell_id)); // order filled
         }

         // go beyond hard fork 1270
         blocks += generate_blocks(HARDFORK_CORE_1270_TIME - mi, true, skip);
         blocks += generate_blocks(db.get_dynamic_global_properties().next_maintenance_time, true, skip);
      }

      // after hard fork 1270, the limit order should be filled for MCR test
      if( db.get_dynamic_global_properties().next_maintenance_time > HARDFORK_CORE_1270_TIME)
      {
         // check median
         BOOST_CHECK( usd_id(db).bitasset_data(db).current_feed.settlement_price == current_feed.settlement_price );
         if( i % 2 == 0 ) { // MCR test, order filled
            BOOST_CHECK_EQUAL(usd_id(db).bitasset_data(db).current_feed.maintenance_collateral_ratio, 3500);
            BOOST_CHECK(!db.find<limit_order_object>(sell_id));
         }
      }

      // undo above tx's and reset
      generate_block( skip );
      ++blocks;
      while( blocks > 0 )
      {
         db.pop_block();
         --blocks;
      }
   }
} FC_LOG_AND_RETHROW() }

BOOST_AUTO_TEST_CASE( bitasset_secondary_index )
{
   ACTORS( (nathan) );

   graphene::chain::asset_id_type core_id;
   BOOST_TEST_MESSAGE( ""Running test bitasset_secondary_index"" );
   BOOST_TEST_MESSAGE( ""Core asset id: "" + fc::json::to_pretty_string( core_id ) );
   BOOST_TEST_MESSAGE(""Create coins"");
   try
   {
      // make 5 coins (backed by core)
      for(int i = 0; i < 5; i++)
      {
         create_bitasset_backed(*this, i, core_id, nathan_private_key);
      }
      // make the next 5 (10-14) be backed by COIN1
      graphene::chain::asset_id_type coin1_id = get_asset(""COIN1TEST"").get_id();
      for(int i = 5; i < 10; i++)
      {
         create_bitasset_backed(*this, i, coin1_id, nathan_private_key);
      }
      // make the next 5 (15-19) be backed by COIN2
      graphene::chain::asset_id_type coin2_id = get_asset(""COIN2TEST"").get_id();
      for(int i = 10; i < 15; i++)
      {
         create_bitasset_backed(*this, i, coin2_id, nathan_private_key);
      }
      // make the last 5 be backed by core
      for(int i = 15; i < 20; i++)
      {
         create_bitasset_backed(*this, i, core_id, nathan_private_key);
      }

      BOOST_TEST_MESSAGE(""Searching for all coins backed by CORE"");
      const auto& idx = db.get_index_type<graphene::chain::asset_bitasset_data_index>().indices().get<graphene::chain::by_short_backing_asset>();
      auto core_itr = idx.equal_range( core_id );
      BOOST_TEST_MESSAGE(""Searching for all coins backed by COIN1"");
      auto coin1_itr = idx.equal_range( coin1_id );
      BOOST_TEST_MESSAGE(""Searching for all coins backed by COIN2"");
      auto coin2_itr = idx.equal_range( coin2_id );

      int core_count = 0, coin1_count = 0, coin2_count = 0;

      BOOST_TEST_MESSAGE(""Counting coins in each category"");

      for( auto itr = core_itr.first ; itr != core_itr.second; ++itr)
      {
         BOOST_CHECK(itr->options.short_backing_asset == core_id);
         BOOST_TEST_MESSAGE( fc::json::to_pretty_string(itr->asset_id) + "" is backed by CORE"" );
         core_count++;
      }
      for( auto itr = coin1_itr.first ; itr != coin1_itr.second; ++itr )
      {
         BOOST_CHECK(itr->options.short_backing_asset == coin1_id);
         BOOST_TEST_MESSAGE( fc::json::to_pretty_string( itr->asset_id) + "" is backed by COIN1TEST"" );
         coin1_count++;
      }
      for( auto itr = coin2_itr.first; itr != coin2_itr.second; ++itr )
      {
         BOOST_CHECK(itr->options.short_backing_asset == coin2_id);
         BOOST_TEST_MESSAGE( fc::json::to_pretty_string( itr->asset_id) + "" is backed by COIN2TEST"" );
         coin2_count++;
      }

      BOOST_CHECK( core_count >= 10 );
      BOOST_CHECK_EQUAL( coin1_count, 5 );
      BOOST_CHECK_EQUAL( coin2_count, 5 );
   }
   catch (fc::exception& ex)
   {
      BOOST_FAIL(ex.to_string(fc::log_level(fc::log_level::all)));
   }
}


/*****
 * @brief make sure feeds work correctly after changing from non-witness-fed to witness-fed before the 868 fork
 * NOTE: This test case is a different issue than what is currently being worked on, and fails. Hopefully it
 * will help when the fix for that issue is being coded.
 */
/*
BOOST_AUTO_TEST_CASE( reset_backing_asset_switching_to_witness_fed )
{
   ACTORS((nathan)(dan)(ben)(vikram));

   BOOST_TEST_MESSAGE(""Advance to near hard fork"");
   auto maint_interval = db.get_global_properties().parameters.maintenance_interval;
   generate_blocks( HARDFORK_CORE_868_890_TIME - maint_interval);
   trx.set_expiration(HARDFORK_CORE_868_890_TIME - fc::seconds(1));


   BOOST_TEST_MESSAGE(""Create USDBIT"");
   asset_id_type bit_usd_id = create_bitasset(""USDBIT"").id;
   asset_id_type core_id = bit_usd_id(db).bitasset_data(db).options.short_backing_asset;

   {
      BOOST_TEST_MESSAGE(""Update the USDBIT asset options"");
      change_asset_options(*this, nathan_id, nathan_private_key, bit_usd_id, false );
   }

   BOOST_TEST_MESSAGE(""Create JMJBIT based on USDBIT."");
   asset_id_type bit_jmj_id = create_bitasset(""JMJBIT"").id;
   {
      BOOST_TEST_MESSAGE(""Update the JMJBIT asset options"");
      change_asset_options(*this, nathan_id, nathan_private_key, bit_jmj_id, false );
   }
   {
      BOOST_TEST_MESSAGE(""Update the JMJBIT bitasset options"");
      asset_update_bitasset_operation ba_op;
      const asset_object& obj = bit_jmj_id(db);
      ba_op.asset_to_update = obj.get_id();
      ba_op.issuer = obj.issuer;
      ba_op.new_options.short_backing_asset = bit_usd_id;
      ba_op.new_options.minimum_feeds = 1;
      trx.operations.push_back(ba_op);
      sign(trx, nathan_private_key);
      PUSH_TX(db, trx, ~0);
      generate_block();
      trx.clear();
   }
   {
      BOOST_TEST_MESSAGE(""Set feed producers for JMJBIT"");
      asset_update_feed_producers_operation op;
      op.asset_to_update = bit_jmj_id;
      op.issuer = nathan_id;
      op.new_feed_producers = {dan_id, ben_id, vikram_id};
      trx.operations.push_back(op);
      sign( trx, nathan_private_key );
      PUSH_TX( db, trx, ~0 );
      generate_block();
      trx.clear();
   }
   {
      BOOST_TEST_MESSAGE(""Verify feed producers are registered for JMJBIT"");
      const asset_bitasset_data_object& obj = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(obj.feeds.size(), 3ul);
      BOOST_CHECK(obj.current_feed == price_feed());


      BOOST_CHECK_EQUAL(""1"", std::to_string(obj.options.short_backing_asset.space_id));
      BOOST_CHECK_EQUAL(""3"", std::to_string(obj.options.short_backing_asset.type_id));
      BOOST_CHECK_EQUAL(""1"", std::to_string(obj.options.short_backing_asset.instance.value));

      BOOST_CHECK_EQUAL(""1"", std::to_string(bit_jmj_id.space_id));
      BOOST_CHECK_EQUAL(""3"", std::to_string(bit_jmj_id.type_id));
      BOOST_CHECK_EQUAL(""2"", std::to_string(bit_jmj_id.instance.value));
   }
   {
      BOOST_TEST_MESSAGE(""Adding Vikram's price feed"");
      add_price_feed(*this, vikram_id, bit_usd_id, 1, bit_jmj_id, 300, core_id);

      const asset_bitasset_data_object& bitasset = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 300.0);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);
   }
   {
      BOOST_TEST_MESSAGE(""Change JMJBIT to be witness_fed"");
      optional<account_id_type> noone;
      change_asset_options(*this, noone, nathan_private_key, bit_jmj_id, true );
   }
   {
      BOOST_TEST_MESSAGE(""Change underlying asset of bit_jmj from bit_usd to core"");
      change_backing_asset(*this, nathan_private_key, bit_jmj_id, core_id);

      BOOST_TEST_MESSAGE(""Verify feed producers have not been reset"");
      const asset_bitasset_data_object& jmj_obj = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(jmj_obj.feeds.size(), 3ul);
      int nan_count = 0;
      for(const auto& feed : jmj_obj.feeds) {
         if(feed.second.second.settlement_price.is_null())
            ++nan_count;
      }
      BOOST_CHECK_EQUAL(nan_count, 2);
   }
   {
      BOOST_TEST_MESSAGE(""Add a new (and correct) feed price from a witness"");
      auto& global_props = db.get_global_properties();
      std::vector<account_id_type> active_witnesses;
      const witness_id_type& first_witness_id = (*global_props.active_witnesses.begin());
      const account_id_type witness_account_id = first_witness_id(db).witness_account;
      add_price_feed(*this, witness_account_id, core_id, 1, bit_jmj_id, 300, core_id);

      // we should have 2 feeds nan, 1 old feed with wrong asset, and 1 witness feed
      const asset_bitasset_data_object& jmj_obj = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(jmj_obj.feeds.size(), 4ul);
      int nan_count = 0;
      for(const auto& feed : jmj_obj.feeds) {
         if ( feed.second.second.settlement_price.is_null() )
            ++nan_count;
      }
      BOOST_CHECK_EQUAL(nan_count, 2);
   }
   {
      BOOST_TEST_MESSAGE(""Advance to past hard fork"");
      generate_blocks( HARDFORK_CORE_868_890_TIME + maint_interval);
      trx.set_expiration(HARDFORK_CORE_868_890_TIME + fc::hours(48));

      BOOST_TEST_MESSAGE(""Verify that the incorrect feeds have been removed"");
      const asset_bitasset_data_object& jmj_obj = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(jmj_obj.feeds.size(), 1ul);
      BOOST_CHECK( ! (*jmj_obj.feeds.begin()).second.second.settlement_price.is_null() );
      // the settlement price will be NaN until 50% of price feeds are valid
      //BOOST_CHECK_EQUAL(jmj_obj.current_feed.settlement_price.to_real(), 300);
   }
   {
      BOOST_TEST_MESSAGE(""After hardfork, change underlying asset of bit_jmj from core to bit_usd"");
      change_backing_asset(*this, nathan_private_key, bit_jmj_id, bit_usd_id);

      BOOST_TEST_MESSAGE(""Verify feed producers have been reset"");
      const asset_bitasset_data_object& jmj_obj = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(jmj_obj.feeds.size(), 0ul);
   }
   {
      BOOST_TEST_MESSAGE(""With underlying bitasset changed from one to another, price feeds should still be publish-able"");
      auto& global_props = db.get_global_properties();
      std::vector<account_id_type> active_witnesses;
      for(const auto& witness_id : global_props.active_witnesses)
      {
         active_witnesses.push_back(witness_id(db).witness_account);
      }
      BOOST_TEST_MESSAGE(""Adding Witness 0's price feed"");
      add_price_feed(*this, active_witnesses[0], bit_usd_id, 1, bit_jmj_id, 30, core_id);

      const asset_bitasset_data_object& bitasset = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 30);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);

      BOOST_TEST_MESSAGE(""Adding Witness 1's pricing to JMJBIT"");
      add_price_feed(*this, active_witnesses[0], bit_usd_id, 1, bit_jmj_id, 25, core_id);

      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 30);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);

      BOOST_TEST_MESSAGE(""Adding Witness 2's pricing to JMJBIT"");
      add_price_feed(*this, active_witnesses[2], bit_usd_id, 1, bit_jmj_id, 10, core_id);

      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 25);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);
      generate_block();
      trx.clear();

      BOOST_CHECK(bitasset.current_feed.core_exchange_rate.base.asset_id != bitasset.current_feed.core_exchange_rate.quote.asset_id);
   }
}
*/
BOOST_AUTO_TEST_CASE(hf_890_test_hf1270)
{ try {
   hf1270 = true;
   INVOKE(hf_890_test);

} FC_LOG_AND_RETHROW() }

BOOST_AUTO_TEST_SUITE_END()
",16289,True,3400.0460057349233,median
"// pbrt is Copyright(c) 1998-2020 Matt Pharr, Wenzel Jakob, and Greg Humphreys.
// The pbrt source code is licensed under the Apache License, Version 2.0.
// SPDX: Apache-2.0

#include <pbrt/shapes.h>

#include <pbrt/interaction.h>
#include <pbrt/options.h>
#include <pbrt/paramdict.h>
#include <pbrt/util/check.h>
#include <pbrt/util/error.h>
#include <pbrt/util/file.h>
#include <pbrt/util/float.h>
#include <pbrt/util/image.h>
#include <pbrt/util/loopsubdiv.h>
#include <pbrt/util/lowdiscrepancy.h>
#include <pbrt/util/math.h>
#include <pbrt/util/memory.h>
#include <pbrt/util/print.h>
#include <pbrt/util/sampling.h>
#include <pbrt/util/splines.h>
#include <pbrt/util/stats.h>

#if defined(PBRT_BUILD_GPU_RENDERER)
#include <cuda.h>
#endif

namespace pbrt {

// Sphere Method Definitions
Bounds3f Sphere::Bounds() const {
    return (*renderFromObject)(
        Bounds3f(Point3f(-radius, -radius, zMin), Point3f(radius, radius, zMax)));
}

pstd::optional<ShapeSample> Sphere::Sample(const Point2f &u) const {
    Point3f pObj = Point3f(0, 0, 0) + radius * SampleUniformSphere(u);
    // Reproject _pObj_ to sphere surface and compute _pObjError_
    pObj *= radius / Distance(pObj, Point3f(0, 0, 0));
    Vector3f pObjError = gamma(5) * Abs((Vector3f)pObj);

    // Compute surface normal for sphere sample and return _ShapeSample_
    Normal3f n = Normalize((*renderFromObject)(Normal3f(pObj.x, pObj.y, pObj.z)));
    if (reverseOrientation)
        n *= -1;
    Point3fi pi = (*renderFromObject)(Point3fi(pObj, pObjError));
    return ShapeSample{Interaction(pi, n), 1 / Area()};
}

std::string Sphere::ToString() const {
    return StringPrintf(""[ Sphere renderFromObject: %s ""
                        ""objectFromRender: %s reverseOrientation: %s ""
                        ""transformSwapsHandedness: %s radius: %f zMin: %f ""
                        ""zMax: %f thetaMin: %f ""
                        ""thetaMax: %f phiMax: %f ]"",
                        *renderFromObject, *objectFromRender, reverseOrientation,
                        transformSwapsHandedness, radius, zMin, zMax, thetaZMin,
                        thetaZMax, phiMax);
}

Sphere *Sphere::Create(const Transform *renderFromObject,
                       const Transform *objectFromRender, bool reverseOrientation,
                       const ParameterDictionary &parameters, const FileLoc *loc,
                       Allocator alloc) {
    Float radius = parameters.GetOneFloat(""radius"", 1.f);
    Float zmin = parameters.GetOneFloat(""zmin"", -radius);
    Float zmax = parameters.GetOneFloat(""zmax"", radius);
    Float phimax = parameters.GetOneFloat(""phimax"", 360.f);
    return alloc.new_object<Sphere>(renderFromObject, objectFromRender,
                                    reverseOrientation, radius, zmin, zmax, phimax);
}

// Disk Method Definitions
Bounds3f Disk::Bounds() const {
    return (*renderFromObject)(
        Bounds3f(Point3f(-radius, -radius, height), Point3f(radius, radius, height)));
}

DirectionCone Disk::NormalBounds() const {
    Normal3f n = (*renderFromObject)(Normal3f(0, 0, 1));
    if (reverseOrientation)
        n = -n;
    return DirectionCone(Vector3f(n));
}

std::string Disk::ToString() const {
    return StringPrintf(
        ""[ Disk renderFromObject: %s objectFromRender: %s ""
        ""reverseOrientation: %s ""
        ""transformSwapsHandedness: %s height: %f radius: %f innerRadius: %f ""
        ""phiMax: %f ]"",
        *renderFromObject, *objectFromRender, reverseOrientation,
        transformSwapsHandedness, height, radius, innerRadius, phiMax);
}

Disk *Disk::Create(const Transform *renderFromObject, const Transform *objectFromRender,
                   bool reverseOrientation, const ParameterDictionary &parameters,
                   const FileLoc *loc, Allocator alloc) {
    Float height = parameters.GetOneFloat(""height"", 0.);
    Float radius = parameters.GetOneFloat(""radius"", 1);
    Float innerRadius = parameters.GetOneFloat(""innerradius"", 0);
    Float phimax = parameters.GetOneFloat(""phimax"", 360);
    return alloc.new_object<Disk>(renderFromObject, objectFromRender, reverseOrientation,
                                  height, radius, innerRadius, phimax);
}

// Cylinder Method Definitions
Bounds3f Cylinder::Bounds() const {
    return (*renderFromObject)(
        Bounds3f(Point3f(-radius, -radius, zMin), Point3f(radius, radius, zMax)));
}

std::string Cylinder::ToString() const {
    return StringPrintf(""[ Cylinder renderFromObject: %s objectFromRender: %s ""
                        ""reverseOrientation: %s ""
                        ""transformSwapsHandedness: %s radius: %f zMin: %f zMax: %f ""
                        ""phiMax: %f ]"",
                        *renderFromObject, *objectFromRender, reverseOrientation,
                        transformSwapsHandedness, radius, zMin, zMax, phiMax);
}

Cylinder *Cylinder::Create(const Transform *renderFromObject,
                           const Transform *objectFromRender, bool reverseOrientation,
                           const ParameterDictionary &parameters, const FileLoc *loc,
                           Allocator alloc) {
    Float radius = parameters.GetOneFloat(""radius"", 1);
    Float zmin = parameters.GetOneFloat(""zmin"", -1);
    Float zmax = parameters.GetOneFloat(""zmax"", 1);
    Float phimax = parameters.GetOneFloat(""phimax"", 360);
    return alloc.new_object<Cylinder>(renderFromObject, objectFromRender,
                                      reverseOrientation, radius, zmin, zmax, phimax);
}

STAT_PIXEL_RATIO(""Intersections/Ray-Triangle intersection tests"", nTriHits, nTriTests);

std::string TriangleIntersection::ToString() const {
    return StringPrintf(""[ TriangleIntersection b0: %f b1: %f b2: %f t: %f ]"", b0, b1, b2,
                        t);
}

pstd::vector<const TriangleMesh *> *Triangle::allMeshes;
#if defined(PBRT_BUILD_GPU_RENDERER)
PBRT_GPU pstd::vector<const TriangleMesh *> *allTriangleMeshesGPU;
#endif

void Triangle::Init(Allocator alloc) {
    allMeshes = alloc.new_object<pstd::vector<const TriangleMesh *>>(alloc);
#if defined(PBRT_BUILD_GPU_RENDERER)
    if (Options->useGPU)
        CUDA_CHECK(
            cudaMemcpyToSymbol(allTriangleMeshesGPU, &allMeshes, sizeof(allMeshes)));
#endif
}

STAT_MEMORY_COUNTER(""Memory/Triangles"", triangleBytes);

// Triangle Functions
pstd::optional<TriangleIntersection> IntersectTriangle(const Ray &ray, Float tMax,
                                                       const Point3f &p0,
                                                       const Point3f &p1,
                                                       const Point3f &p2) {
    // Return no intersection if triangle is degenerate
    if (LengthSquared(Cross(p2 - p0, p1 - p0)) == 0)
        return {};

    // Transform triangle vertices to ray coordinate space
    // Translate vertices based on ray origin
    Point3f p0t = p0 - Vector3f(ray.o);
    Point3f p1t = p1 - Vector3f(ray.o);
    Point3f p2t = p2 - Vector3f(ray.o);

    // Permute components of triangle vertices and ray direction
    int kz = MaxComponentIndex(Abs(ray.d));
    int kx = kz + 1;
    if (kx == 3)
        kx = 0;
    int ky = kx + 1;
    if (ky == 3)
        ky = 0;
    Vector3f d = Permute(ray.d, {kx, ky, kz});
    p0t = Permute(p0t, {kx, ky, kz});
    p1t = Permute(p1t, {kx, ky, kz});
    p2t = Permute(p2t, {kx, ky, kz});

    // Apply shear transformation to translated vertex positions
    Float Sx = -d.x / d.z;
    Float Sy = -d.y / d.z;
    Float Sz = 1.f / d.z;
    p0t.x += Sx * p0t.z;
    p0t.y += Sy * p0t.z;
    p1t.x += Sx * p1t.z;
    p1t.y += Sy * p1t.z;
    p2t.x += Sx * p2t.z;
    p2t.y += Sy * p2t.z;

    // Compute edge function coefficients _e0_, _e1_, and _e2_
    Float e0 = DifferenceOfProducts(p1t.x, p2t.y, p1t.y, p2t.x);
    Float e1 = DifferenceOfProducts(p2t.x, p0t.y, p2t.y, p0t.x);
    Float e2 = DifferenceOfProducts(p0t.x, p1t.y, p0t.y, p1t.x);

    // Fall back to double precision test at triangle edges
    if (sizeof(Float) == sizeof(float) && (e0 == 0.0f || e1 == 0.0f || e2 == 0.0f)) {
        double p2txp1ty = (double)p2t.x * (double)p1t.y;
        double p2typ1tx = (double)p2t.y * (double)p1t.x;
        e0 = (float)(p2typ1tx - p2txp1ty);
        double p0txp2ty = (double)p0t.x * (double)p2t.y;
        double p0typ2tx = (double)p0t.y * (double)p2t.x;
        e1 = (float)(p0typ2tx - p0txp2ty);
        double p1txp0ty = (double)p1t.x * (double)p0t.y;
        double p1typ0tx = (double)p1t.y * (double)p0t.x;
        e2 = (float)(p1typ0tx - p1txp0ty);
    }

    // Perform triangle edge and determinant tests
    if ((e0 < 0 || e1 < 0 || e2 < 0) && (e0 > 0 || e1 > 0 || e2 > 0))
        return {};
    Float det = e0 + e1 + e2;
    if (det == 0)
        return {};

    // Compute scaled hit distance to triangle and test against ray $t$ range
    p0t.z *= Sz;
    p1t.z *= Sz;
    p2t.z *= Sz;
    Float tScaled = e0 * p0t.z + e1 * p1t.z + e2 * p2t.z;
    if (det < 0 && (tScaled >= 0 || tScaled < tMax * det))
        return {};
    else if (det > 0 && (tScaled <= 0 || tScaled > tMax * det))
        return {};

    // Compute barycentric coordinates and $t$ value for triangle intersection
    Float invDet = 1 / det;
    Float b0 = e0 * invDet, b1 = e1 * invDet, b2 = e2 * invDet;
    Float t = tScaled * invDet;
    DCHECK(!IsNaN(t));

    // Ensure that computed triangle $t$ is conservatively greater than zero
    // Compute $\\delta_z$ term for triangle $t$ error bounds
    Float maxZt = MaxComponentValue(Abs(Vector3f(p0t.z, p1t.z, p2t.z)));
    Float deltaZ = gamma(3) * maxZt;

    // Compute $\\delta_x$ and $\\delta_y$ terms for triangle $t$ error bounds
    Float maxXt = MaxComponentValue(Abs(Vector3f(p0t.x, p1t.x, p2t.x)));
    Float maxYt = MaxComponentValue(Abs(Vector3f(p0t.y, p1t.y, p2t.y)));
    Float deltaX = gamma(5) * (maxXt + maxZt);
    Float deltaY = gamma(5) * (maxYt + maxZt);

    // Compute $\\delta_e$ term for triangle $t$ error bounds
    Float deltaE = 2 * (gamma(2) * maxXt * maxYt + deltaY * maxXt + deltaX * maxYt);

    // Compute $\\delta_t$ term for triangle $t$ error bounds and check _t_
    Float maxE = MaxComponentValue(Abs(Vector3f(e0, e1, e2)));
    Float deltaT =
        3 * (gamma(3) * maxE * maxZt + deltaE * maxZt + deltaZ * maxE) * std::abs(invDet);
    if (t <= deltaT)
        return {};

    // Return _TriangleIntersection_ for intersection
    return TriangleIntersection{b0, b1, b2, t};
}

// Triangle Method Definitions
pstd::vector<ShapeHandle> Triangle::CreateTriangles(const TriangleMesh *mesh,
                                                    Allocator alloc) {
    static std::mutex allMeshesLock;
    allMeshesLock.lock();
    CHECK_LT(allMeshes->size(), 1 << 31);
    int meshIndex = int(allMeshes->size());
    allMeshes->push_back(mesh);
    allMeshesLock.unlock();

    pstd::vector<ShapeHandle> tris(mesh->nTriangles, alloc);
    Triangle *t = alloc.allocate_object<Triangle>(mesh->nTriangles);
    for (int i = 0; i < mesh->nTriangles; ++i) {
        alloc.construct(&t[i], meshIndex, i);
        tris[i] = &t[i];
    }
    triangleBytes += mesh->nTriangles * sizeof(Triangle);
    return tris;
}

Bounds3f Triangle::Bounds() const {
    // Get triangle vertices in _p0_, _p1_, and _p2_
    const TriangleMesh *mesh = GetMesh();
    const int *v = &mesh->vertexIndices[3 * triIndex];
    Point3f p0 = mesh->p[v[0]], p1 = mesh->p[v[1]], p2 = mesh->p[v[2]];

    return Union(Bounds3f(p0, p1), p2);
}

DirectionCone Triangle::NormalBounds() const {
    // Get triangle vertices in _p0_, _p1_, and _p2_
    const TriangleMesh *mesh = GetMesh();
    const int *v = &mesh->vertexIndices[3 * triIndex];
    Point3f p0 = mesh->p[v[0]], p1 = mesh->p[v[1]], p2 = mesh->p[v[2]];

    Normal3f n = Normalize(Normal3f(Cross(p1 - p0, p2 - p0)));
    // Ensure correct orientation of geometric normal for normal bounds
    if (mesh->n != nullptr) {
        Normal3f ns(mesh->n[v[0]] + mesh->n[v[1]] + mesh->n[v[2]]);
        n = FaceForward(n, ns);
    } else if (mesh->reverseOrientation ^ mesh->transformSwapsHandedness)
        n *= -1;

    return DirectionCone(Vector3f(n));
}

pstd::optional<ShapeIntersection> Triangle::Intersect(const Ray &ray, Float tMax) const {
#ifndef PBRT_IS_GPU_CODE
    ++nTriTests;
#endif
    // Get triangle vertices in _p0_, _p1_, and _p2_
    const TriangleMesh *mesh = GetMesh();
    const int *v = &mesh->vertexIndices[3 * triIndex];
    Point3f p0 = mesh->p[v[0]], p1 = mesh->p[v[1]], p2 = mesh->p[v[2]];

    pstd::optional<TriangleIntersection> triIsect =
        IntersectTriangle(ray, tMax, p0, p1, p2);
    if (!triIsect)
        return {};

    SurfaceInteraction intr =
        InteractionFromIntersection(mesh, triIndex, *triIsect, ray.time, -ray.d);
#ifndef PBRT_IS_GPU_CODE
    ++nTriHits;
#endif
    return ShapeIntersection{intr, triIsect->t};
}

bool Triangle::IntersectP(const Ray &ray, Float tMax) const {
#ifndef PBRT_IS_GPU_CODE
    ++nTriTests;
#endif
    // Get triangle vertices in _p0_, _p1_, and _p2_
    const TriangleMesh *mesh = GetMesh();
    const int *v = &mesh->vertexIndices[3 * triIndex];
    Point3f p0 = mesh->p[v[0]], p1 = mesh->p[v[1]], p2 = mesh->p[v[2]];

    pstd::optional<TriangleIntersection> isect = IntersectTriangle(ray, tMax, p0, p1, p2);
    if (isect) {
#ifndef PBRT_IS_GPU_CODE
        ++nTriHits;
#endif
        return true;
    } else
        return false;
}

std::string Triangle::ToString() const {
    // Get triangle vertices in _p0_, _p1_, and _p2_
    auto mesh = GetMesh();
    const int *v = &mesh->vertexIndices[3 * triIndex];
    const Point3f &p0 = mesh->p[v[0]];
    const Point3f &p1 = mesh->p[v[1]];
    const Point3f &p2 = mesh->p[v[2]];

    return StringPrintf(""[ Triangle meshIndex: %d triIndex: %d -> p [ %s %s %s ] ]"",
                        meshIndex, triIndex, p0, p1, p2);
}

TriangleMesh *Triangle::CreateMesh(const Transform *renderFromObject,
                                   bool reverseOrientation,
                                   const ParameterDictionary &parameters,
                                   const FileLoc *loc, Allocator alloc) {
    std::vector<int> vi = parameters.GetIntArray(""indices"");
    std::vector<Point3f> P = parameters.GetPoint3fArray(""P"");
    std::vector<Point2f> uvs = parameters.GetPoint2fArray(""uv"");

    if (vi.empty()) {
        if (P.size() == 3)
            vi = {0, 1, 2};
        else {
            Error(loc, ""Vertex indices \\""indices\\"" must be provided with ""
                       ""triangle mesh."");
            return {};
        }
    } else if ((vi.size() % 3) != 0u) {
        Error(loc,
              ""Number of vertex indices %d not a multiple of 3. Discarding %d ""
              ""excess."",
              int(vi.size()), int(vi.size() % 3));
        while ((vi.size() % 3) != 0u)
            vi.pop_back();
    }

    if (P.empty()) {
        Error(loc, ""Vertex positions \\""P\\"" must be provided with triangle mesh."");
        return {};
    }

    if (!uvs.empty() && uvs.size() != P.size()) {
        Error(loc, ""Number of \\""uv\\""s for triangle mesh must match \\""P\\""s. ""
                   ""Discarding uvs."");
        uvs = {};
    }

    std::vector<Vector3f> S = parameters.GetVector3fArray(""S"");
    if (!S.empty() && S.size() != P.size()) {
        Error(loc, ""Number of \\""S\\""s for triangle mesh must match \\""P\\""s. ""
                   ""Discarding \\""S\\""s."");
        S = {};
    }
    std::vector<Normal3f> N = parameters.GetNormal3fArray(""N"");
    if (!N.empty() && N.size() != P.size()) {
        Error(loc, ""Number of \\""N\\""s for triangle mesh must match \\""P\\""s. ""
                   ""Discarding \\""N\\""s."");
        N = {};
    }

    for (size_t i = 0; i < vi.size(); ++i)
        if (vi[i] >= P.size()) {
            Error(loc,
                  ""trianglemesh has out of-bounds vertex index %d (%d \\""P\\"" ""
                  ""values were given. Discarding this mesh."",
                  vi[i], (int)P.size());
            return {};
        }

    std::vector<int> faceIndices = parameters.GetIntArray(""faceIndices"");
    if (!faceIndices.empty() && faceIndices.size() != vi.size() / 3) {
        Error(loc,
              ""Number of face indices %d does not match number of triangles %d. ""
              ""Discarding face indices."",
              int(faceIndices.size()), int(vi.size() / 3));
        faceIndices = {};
    }

    return alloc.new_object<TriangleMesh>(
        *renderFromObject, reverseOrientation, std::move(vi), std::move(P), std::move(S),
        std::move(N), std::move(uvs), std::move(faceIndices));
}

STAT_MEMORY_COUNTER(""Memory/Curves"", curveBytes);
STAT_PERCENT(""Intersections/Ray-curve intersection tests"", nCurveHits, nCurveTests);
STAT_COUNTER(""Geometry/Curves"", nCurves);
STAT_COUNTER(""Geometry/Split curves"", nSplitCurves);

std::string ToString(CurveType type) {
    switch (type) {
    case CurveType::Flat:
        return ""Flat"";
    case CurveType::Cylinder:
        return ""Cylinder"";
    case CurveType::Ribbon:
        return ""Ribbon"";
    default:
        LOG_FATAL(""Unhandled case"");
        return """";
    }
}

// CurveCommon Method Definitions
CurveCommon::CurveCommon(pstd::span<const Point3f> c, Float width0, Float width1,
                         CurveType type, pstd::span<const Normal3f> norm,
                         const Transform *renderFromObject,
                         const Transform *objectFromRender, bool reverseOrientation)
    : type(type),
      renderFromObject(renderFromObject),
      objectFromRender(objectFromRender),
      reverseOrientation(reverseOrientation),
      transformSwapsHandedness(renderFromObject->SwapsHandedness()) {
    width[0] = width0;
    width[1] = width1;
    CHECK_EQ(c.size(), 4);
    for (int i = 0; i < 4; ++i)
        cpObj[i] = c[i];
    if (norm.size() == 2) {
        n[0] = Normalize(norm[0]);
        n[1] = Normalize(norm[1]);
        normalAngle = AngleBetween(n[0], n[1]);
        invSinNormalAngle = 1 / std::sin(normalAngle);
    }
    ++nCurves;
}

std::string CurveCommon::ToString() const {
    return StringPrintf(
        ""[ CurveCommon type: %s cpObj: %s width: %s n: %s normalAngle: %f ""
        ""invSinNormalAngle: %f renderFromObject: %s ""
        ""objectFromRender: %s ""
        ""reverseOrientation: %s transformSwapsHandedness: %s ]"",
        type, pstd::MakeSpan(cpObj), pstd::MakeSpan(width), pstd::MakeSpan(n),
        normalAngle, invSinNormalAngle, *renderFromObject, *objectFromRender,
        reverseOrientation, transformSwapsHandedness);
}

pstd::vector<ShapeHandle> CreateCurve(const Transform *renderFromObject,
                                      const Transform *objectFromRender,
                                      bool reverseOrientation,
                                      pstd::span<const Point3f> c, Float w0, Float w1,
                                      CurveType type, pstd::span<const Normal3f> norm,
                                      int splitDepth, Allocator alloc) {
    CurveCommon *common = alloc.new_object<CurveCommon>(
        c, w0, w1, type, norm, renderFromObject, objectFromRender, reverseOrientation);

    const int nSegments = 1 << splitDepth;
    pstd::vector<ShapeHandle> segments(nSegments, alloc);
    Curve *curves = alloc.allocate_object<Curve>(nSegments);
    for (int i = 0; i < nSegments; ++i) {
        Float uMin = i / (Float)nSegments;
        Float uMax = (i + 1) / (Float)nSegments;
        alloc.construct(&curves[i], common, uMin, uMax);
        segments[i] = &curves[i];
        ++nSplitCurves;
    }

    curveBytes += sizeof(CurveCommon) + nSegments * sizeof(Curve);
    return segments;
}

// Curve Method Definitions
Bounds3f Curve::Bounds() const {
    pstd::span<const Point3f> cpSpan(common->cpObj);
    Bounds3f objBounds = BoundCubicBezier(cpSpan, uMin, uMax);
    // Expand _objBounds_ by maximum curve width over $u$ range
    Float width[2] = {Lerp(uMin, common->width[0], common->width[1]),
                      Lerp(uMax, common->width[0], common->width[1])};
    objBounds = Expand(objBounds, std::max(width[0], width[1]) * 0.5f);

    return (*common->renderFromObject)(objBounds);
}

Float Curve::Area() const {
    pstd::array<Point3f, 4> cpObj =
        CubicBezierControlPoints(pstd::MakeConstSpan(common->cpObj), uMin, uMax);
    Float width0 = Lerp(uMin, common->width[0], common->width[1]);
    Float width1 = Lerp(uMax, common->width[0], common->width[1]);
    Float avgWidth = (width0 + width1) * 0.5f;
    Float approxLength = 0.f;
    for (int i = 0; i < 3; ++i)
        approxLength += Distance(cpObj[i], cpObj[i + 1]);
    return approxLength * avgWidth;
}

pstd::optional<ShapeIntersection> Curve::Intersect(const Ray &ray, Float tMax) const {
    pstd::optional<ShapeIntersection> si;
    IntersectRay(ray, tMax, &si);
    return si;
}

bool Curve::IntersectP(const Ray &ray, Float tMax) const {
    return IntersectRay(ray, tMax, nullptr);
}

bool Curve::IntersectRay(const Ray &r, Float tMax,
                         pstd::optional<ShapeIntersection> *si) const {
#ifndef PBRT_IS_GPU_CODE
    ++nCurveTests;
#endif
    // Transform _Ray_ to curve's object space
    Ray ray = (*common->objectFromRender)(r);

    // Get object-space control points for curve segment, _cpObj_
    pstd::array<Point3f, 4> cpObj =
        CubicBezierControlPoints(pstd::span<const Point3f>(common->cpObj), uMin, uMax);

    // Project curve control points to plane perpendicular to ray
    Vector3f dx = Cross(ray.d, cpObj[3] - cpObj[0]);
    if (LengthSquared(dx) == 0) {
        Vector3f dy;
        CoordinateSystem(ray.d, &dx, &dy);
    }
    Transform rayFromObject = LookAt(ray.o, ray.o + ray.d, dx);
    pstd::array<Point3f, 4> cp = {rayFromObject(cpObj[0]), rayFromObject(cpObj[1]),
                                  rayFromObject(cpObj[2]), rayFromObject(cpObj[3])};

    // Test ray against bound of projected control points
    Float maxWidth = std::max(Lerp(uMin, common->width[0], common->width[1]),
                              Lerp(uMax, common->width[0], common->width[1]));
    Bounds3f curveBounds = Union(Bounds3f(cp[0], cp[1]), Bounds3f(cp[2], cp[3]));
    curveBounds = Expand(curveBounds, 0.5f * maxWidth);
    Bounds3f rayBounds(Point3f(0, 0, 0), Point3f(0, 0, Length(ray.d) * tMax));
    if (!Overlaps(rayBounds, curveBounds))
        return false;

    // Compute refinement depth for curve, _maxDepth_
    Float L0 = 0;
    for (int i = 0; i < 2; ++i)
        L0 = std::max(
            L0, std::max(std::max(std::abs(cp[i].x - 2 * cp[i + 1].x + cp[i + 2].x),
                                  std::abs(cp[i].y - 2 * cp[i + 1].y + cp[i + 2].y)),
                         std::abs(cp[i].z - 2 * cp[i + 1].z + cp[i + 2].z)));
    int maxDepth = 0;
    if (L0 > 0) {
        Float eps = std::max(common->width[0], common->width[1]) * .05f;  // width / 20
        // Compute log base 4 by dividing log2 in half.
        int r0 = Log2Int(1.41421356237f * 6.f * L0 / (8.f * eps)) / 2;
        maxDepth = Clamp(r0, 0, 10);
    }

    // Recursively test for ray--curve intersection
    pstd::span<const Point3f> cpSpan(cp);
    return RecursiveIntersect(ray, tMax, cpSpan, Inverse(rayFromObject), uMin, uMax,
                              maxDepth, si);
}

bool Curve::RecursiveIntersect(const Ray &ray, Float tMax, pstd::span<const Point3f> cp,
                               const Transform &ObjectFromRay, Float u0, Float u1,
                               int depth, pstd::optional<ShapeIntersection> *si) const {
    Float rayLength = Length(ray.d);
    if (depth > 0) {
        // Split curve segment into sub-segments and test for intersection
        pstd::array<Point3f, 7> cpSplit = SubdivideCubicBezier(cp);
        Float u[3] = {u0, (u0 + u1) / 2, u1};
        for (int seg = 0; seg < 2; ++seg) {
            // Check ray against curve segment's bounding box
            Float maxWidth =
                std::max(Lerp(u[seg], common->width[0], common->width[1]),
                         Lerp(u[seg + 1], common->width[0], common->width[1]));
            pstd::span<const Point3f> cps = pstd::MakeConstSpan(&cpSplit[3 * seg], 4);
            Bounds3f curveBounds =
                Union(Bounds3f(cps[0], cps[1]), Bounds3f(cps[2], cps[3]));
            curveBounds = Expand(curveBounds, 0.5f * maxWidth);
            Bounds3f rayBounds(Point3f(0, 0, 0), Point3f(0, 0, Length(ray.d) * tMax));
            if (!Overlaps(rayBounds, curveBounds))
                continue;

            // Recursively test ray-segment intersection
            bool hit = RecursiveIntersect(ray, tMax, cps, ObjectFromRay, u[seg],
                                          u[seg + 1], depth - 1, si);
            if (hit && si == nullptr)
                return true;
        }
        return si ? si->has_value() : false;

    } else {
        // Intersect ray with curve segment
        // Test ray against segment endpoint boundaries
        // Test sample point against tangent perpendicular at curve start
        Float edge = (cp[1].y - cp[0].y) * -cp[0].y + cp[0].x * (cp[0].x - cp[1].x);
        if (edge < 0)
            return false;

        // Test sample point against tangent perpendicular at curve end
        edge = (cp[2].y - cp[3].y) * -cp[3].y + cp[3].x * (cp[3].x - cp[2].x);
        if (edge < 0)
            return false;

        // Find line $w$ that gives minimum distance to sample point
        Vector2f segmentDir = Point2f(cp[3].x, cp[3].y) - Point2f(cp[0].x, cp[0].y);
        Float denom = LengthSquared(segmentDir);
        if (denom == 0)
            return false;
        Float w = Dot(-Vector2f(cp[0].x, cp[0].y), segmentDir) / denom;

        // Compute $u$ coordinate of curve intersection point and _hitWidth_
        Float u = Clamp(Lerp(w, u0, u1), u0, u1);
        Float hitWidth = Lerp(u, common->width[0], common->width[1]);
        Normal3f nHit;
        if (common->type == CurveType::Ribbon) {
            // Scale _hitWidth_ based on ribbon orientation
            if (common->normalAngle == 0)
                nHit = common->n[0];
            else {
                Float sin0 =
                    std::sin((1 - u) * common->normalAngle) * common->invSinNormalAngle;
                Float sin1 =
                    std::sin(u * common->normalAngle) * common->invSinNormalAngle;
                nHit = sin0 * common->n[0] + sin1 * common->n[1];
            }
            hitWidth *= AbsDot(nHit, ray.d) / rayLength;
        }

        // Test intersection point against curve width
        Vector3f dpcdw;
        Point3f pc =
            EvaluateCubicBezier(pstd::span<const Point3f>(cp), Clamp(w, 0, 1), &dpcdw);
        Float ptCurveDist2 = pc.x * pc.x + pc.y * pc.y;
        if (ptCurveDist2 > hitWidth * hitWidth * .25f)
            return false;
        if (pc.z < 0 || pc.z > rayLength * tMax)
            return false;

        if (si != nullptr) {
            // Initialize _ShapeIntersection_ for curve intersection
            // Compute _tHit_ for curve intersection
            // FIXME: this tHit isn't quite right for ribbons...
            Float tHit = pc.z / rayLength;
            if (si->has_value() && tHit > si->value().tHit)
                return false;

            // Initialize _SurfaceInteraction_ _intr_ for curve intersection
            // Compute $v$ coordinate of curve intersection point
            Float ptCurveDist = std::sqrt(ptCurveDist2);
            Float edgeFunc = dpcdw.x * -pc.y + pc.x * dpcdw.y;
            Float v = (edgeFunc > 0) ? 0.5f + ptCurveDist / hitWidth
                                     : 0.5f - ptCurveDist / hitWidth;

            // Compute $\\dpdu$ and $\\dpdv$ for curve intersection
            Vector3f dpdu, dpdv;
            EvaluateCubicBezier(pstd::MakeConstSpan(common->cpObj), u, &dpdu);
            CHECK_NE(Vector3f(0, 0, 0), dpdu);
            if (common->type == CurveType::Ribbon)
                dpdv = Normalize(Cross(nHit, dpdu)) * hitWidth;
            else {
                // Compute curve $\\dpdv$ for flat and cylinder curves
                Vector3f dpduPlane = ObjectFromRay.ApplyInverse(dpdu);
                Vector3f dpdvPlane =
                    Normalize(Vector3f(-dpduPlane.y, dpduPlane.x, 0)) * hitWidth;
                if (common->type == CurveType::Cylinder) {
                    // Rotate _dpdvPlane_ to give cylindrical appearance
                    Float theta = Lerp(v, -90., 90.);
                    Transform rot = Rotate(-theta, dpduPlane);
                    dpdvPlane = rot(dpdvPlane);
                }
                dpdv = ObjectFromRay(dpdvPlane);
            }

            // Compute error bounds for curve intersection
            Vector3f pError(2 * hitWidth, 2 * hitWidth, 2 * hitWidth);

            bool flipNormal =
                common->reverseOrientation ^ common->transformSwapsHandedness;
            Point3fi pi(ray(tHit), pError);
            SurfaceInteraction intr(pi, {u, v}, -ray.d, dpdu, dpdv, Normal3f(),
                                    Normal3f(), ray.time, flipNormal);
            intr = (*common->renderFromObject)(intr);

            *si = ShapeIntersection{intr, tHit};
        }
#ifndef PBRT_IS_GPU_CODE
        ++nCurveHits;
#endif
        return true;
    }
}

pstd::optional<ShapeSample> Curve::Sample(const Point2f &u) const {
    LOG_FATAL(""Curve::Sample not implemented."");
    return {};
}

Float Curve::PDF(const Interaction &) const {
    LOG_FATAL(""Curve::PDF not implemented."");
    return {};
}

pstd::optional<ShapeSample> Curve::Sample(const ShapeSampleContext &ctx,
                                          const Point2f &u) const {
    LOG_FATAL(""Curve::Sample not implemented."");
    return {};
}

Float Curve::PDF(const ShapeSampleContext &ctx, const Vector3f &wi) const {
    LOG_FATAL(""Curve::PDF not implemented."");
    return {};
}

std::string Curve::ToString() const {
    return StringPrintf(""[ Curve common: %s uMin: %f uMax: %f ]"", *common, uMin, uMax);
}

pstd::vector<ShapeHandle> Curve::Create(const Transform *renderFromObject,
                                        const Transform *objectFromRender,
                                        bool reverseOrientation,
                                        const ParameterDictionary &parameters,
                                        const FileLoc *loc, Allocator alloc) {
    Float width = parameters.GetOneFloat(""width"", 1.f);
    Float width0 = parameters.GetOneFloat(""width0"", width);
    Float width1 = parameters.GetOneFloat(""width1"", width);

    int degree = parameters.GetOneInt(""degree"", 3);
    if (degree != 2 && degree != 3) {
        Error(loc, ""Invalid degree %d: only degree 2 and 3 curves are supported."",
              degree);
        return {};
    }

    std::string basis = parameters.GetOneString(""basis"", ""bezier"");
    if (basis != ""bezier"" && basis != ""bspline"") {
        Error(loc,
              ""Invalid basis \\""%s\\"": only \\""bezier\\"" and \\""bspline\\"" are ""
              ""supported."",
              basis);
        return {};
    }

    int nSegments;
    std::vector<Point3f> cp = parameters.GetPoint3fArray(""P"");
    if (basis == ""bezier"") {
        // After the first segment, which uses degree+1 control points,
        // subsequent segments reuse the last control point of the previous
        // one and then use degree more control points.
        if (((cp.size() - 1 - degree) % degree) != 0) {
            Error(loc,
                  ""Invalid number of control points %d: for the degree %d ""
                  ""Bezier basis %d + n * %d are required, for n >= 0."",
                  (int)cp.size(), degree, degree + 1, degree);
            return {};
        }
        nSegments = (cp.size() - 1) / degree;
    } else {
        if (cp.size() < degree + 1) {
            Error(loc,
                  ""Invalid number of control points %d: for the degree %d ""
                  ""b-spline basis, must have >= %d."",
                  int(cp.size()), degree, degree + 1);
            return {};
        }
        nSegments = cp.size() - degree;
    }

    CurveType type;
    std::string curveType = parameters.GetOneString(""type"", ""flat"");
    if (curveType == ""flat"")
        type = CurveType::Flat;
    else if (curveType == ""ribbon"")
        type = CurveType::Ribbon;
    else if (curveType == ""cylinder"")
        type = CurveType::Cylinder;
    else {
        Error(loc, R""(Unknown curve type ""%s"".  Using ""cylinder"".)"", curveType);
        type = CurveType::Cylinder;
    }

    std::vector<Normal3f> n = parameters.GetNormal3fArray(""N"");
    if (!n.empty()) {
        if (type != CurveType::Ribbon) {
            Warning(""Curve normals are only used with \\""ribbon\\"" type curves."");
            n = {};
        } else if (n.size() != nSegments + 1) {
            Error(loc,
                  ""Invalid number of normals %d: must provide %d normals for ""
                  ""ribbon ""
                  ""curves with %d segments."",
                  int(n.size()), nSegments + 1, nSegments);
            return {};
        }
    } else if (type == CurveType::Ribbon) {
        Error(loc, ""Must provide normals \\""N\\"" at curve endpoints with ribbon ""
                   ""curves."");
        return {};
    }

    int sd = parameters.GetOneInt(""splitdepth"", 3);

    if (type == CurveType::Ribbon && n.empty()) {
        Error(loc, ""Must provide normals \\""N\\"" at curve endpoints with ribbon ""
                   ""curves."");
        return {};
    }

    pstd::vector<ShapeHandle> curves(alloc);
    // Pointer to the first control point for the current segment. This is
    // updated after each loop iteration depending on the current basis.
    int cpOffset = 0;
    for (int seg = 0; seg < nSegments; ++seg) {
        pstd::array<Point3f, 4> segCpBezier;

        // First, compute the cubic Bezier control points for the current
        // segment and store them in segCpBezier. (It is admittedly
        // wasteful storage-wise to turn b-splines into Bezier segments and
        // wasteful computationally to turn quadratic curves into cubics,
        // but yolo.)
        if (basis == ""bezier"") {
            if (degree == 2) {
                // Elevate to degree 3.
                segCpBezier = ElevateQuadraticBezierToCubic(
                    pstd::MakeConstSpan(cp).subspan(cpOffset, 3));
            } else {
                // All set.
                for (int i = 0; i < 4; ++i)
                    segCpBezier[i] = cp[cpOffset + i];
            }
            cpOffset += degree;
        } else {
            // Uniform b-spline.
            if (degree == 2) {
                pstd::array<Point3f, 3> bezCp = QuadraticBSplineToBezier(
                    pstd::MakeConstSpan(cp).subspan(cpOffset, 3));
                segCpBezier = ElevateQuadraticBezierToCubic(pstd::MakeConstSpan(bezCp));
            } else {
                segCpBezier =
                    CubicBSplineToBezier(pstd::MakeConstSpan(cp).subspan(cpOffset, 4));
            }
            ++cpOffset;
        }

        pstd::span<const Normal3f> nspan;
        if (!n.empty())
            nspan = pstd::MakeSpan(&n[seg], 2);
        auto c =
            CreateCurve(renderFromObject, objectFromRender, reverseOrientation,
                        segCpBezier, Lerp(Float(seg) / Float(nSegments), width0, width1),
                        Lerp(Float(seg + 1) / Float(nSegments), width0, width1), type,
                        nspan, sd, alloc);
        curves.insert(curves.end(), c.begin(), c.end());
    }
    return curves;
}

STAT_PIXEL_RATIO(""Intersections/Ray-bilinear patch intersection tests"", nBLPHits,
                 nBLPTests);

// BilinearPatch Method Definitions
std::string BilinearIntersection::ToString() const {
    return StringPrintf(""[ BilinearIntersection uv: %s t: %f"", uv, t);
}

BilinearPatchMesh *BilinearPatch::CreateMesh(const Transform *renderFromObject,
                                             bool reverseOrientation,
                                             const ParameterDictionary &parameters,
                                             const FileLoc *loc, Allocator alloc) {
    std::vector<int> vertexIndices = parameters.GetIntArray(""indices"");
    std::vector<Point3f> P = parameters.GetPoint3fArray(""P"");
    std::vector<Point2f> uv = parameters.GetPoint2fArray(""uv"");

    if (vertexIndices.empty()) {
        if (P.size() == 4)
            // single patch
            vertexIndices = {0, 1, 2, 3};
        else {
            Error(loc, ""Vertex indices \\""indices\\"" must be provided with ""
                       ""bilinear patch mesh shape."");
            return {};
        }
    } else if ((vertexIndices.size() % 4) != 0u) {
        Error(loc,
              ""Number of vertex indices %d not a multiple of 4. Discarding %d ""
              ""excess."",
              int(vertexIndices.size()), int(vertexIndices.size() % 4));
        while ((vertexIndices.size() % 4) != 0u)
            vertexIndices.pop_back();
    }

    if (P.empty()) {
        Error(loc, ""Vertex positions \\""P\\"" must be provided with bilinear ""
                   ""patch mesh shape."");
        return {};
    }

    if (!uv.empty() && uv.size() != P.size()) {
        Error(loc, ""Number of \\""uv\\""s for bilinear patch mesh must match \\""P\\""s. ""
                   ""Discarding uvs."");
        uv = {};
    }

    std::vector<Normal3f> N = parameters.GetNormal3fArray(""N"");
    if (!N.empty() && N.size() != P.size()) {
        Error(loc, ""Number of \\""N\\""s for bilinear patch mesh must match \\""P\\""s. ""
                   ""Discarding \\""N\\""s."");
        N = {};
    }

    for (size_t i = 0; i < vertexIndices.size(); ++i)
        if (vertexIndices[i] >= P.size()) {
            Error(loc,
                  ""Bilinear patch mesh has out of-bounds vertex index %d (%d ""
                  ""\\""P\\"" ""
                  ""values were given. Discarding this mesh."",
                  vertexIndices[i], (int)P.size());
            return {};
        }

    std::vector<int> faceIndices = parameters.GetIntArray(""faceIndices"");
    if (!faceIndices.empty() && faceIndices.size() != vertexIndices.size() / 4) {
        Error(loc,
              ""Number of face indices %d does not match number of bilinear ""
              ""patches %d. ""
              ""Discarding face indices."",
              int(faceIndices.size()), int(vertexIndices.size() / 4));
        faceIndices = {};
    }

    // Grab this before the vertexIndices are std::moved...
    size_t nBlps = vertexIndices.size() / 4;

    std::string filename =
        ResolveFilename(parameters.GetOneString(""emissionfilename"", """"));
    PiecewiseConstant2D *imageDist = nullptr;
    if (!filename.empty()) {
        ImageAndMetadata im = Image::Read(filename, alloc);
        Bounds2f domain = Bounds2f(Point2f(0, 0), Point2f(1, 1));
        Array2D<Float> d = im.image.GetSamplingDistribution();
        imageDist = alloc.new_object<PiecewiseConstant2D>(d, domain, alloc);
    }

    return alloc.new_object<BilinearPatchMesh>(
        *renderFromObject, reverseOrientation, std::move(vertexIndices), std::move(P),
        std::move(N), std::move(uv), std::move(faceIndices), imageDist);
}

pstd::vector<ShapeHandle> BilinearPatch::CreatePatches(const BilinearPatchMesh *mesh,
                                                       Allocator alloc) {
    static std::mutex allMeshesLock;
    allMeshesLock.lock();
    CHECK_LT(allMeshes->size(), 1 << 31);
    int meshIndex = int(allMeshes->size());
    allMeshes->push_back(mesh);
    allMeshesLock.unlock();

    pstd::vector<ShapeHandle> blps(mesh->nPatches, alloc);
    BilinearPatch *patches = alloc.allocate_object<BilinearPatch>(mesh->nPatches);
    for (int i = 0; i < mesh->nPatches; ++i) {
        alloc.construct(&patches[i], mesh, meshIndex, i);
        blps[i] = &patches[i];
    }

    return blps;
}

pstd::vector<const BilinearPatchMesh *> *BilinearPatch::allMeshes;
#if defined(PBRT_BUILD_GPU_RENDERER)
PBRT_GPU pstd::vector<const BilinearPatchMesh *> *allBilinearMeshesGPU;
#endif

void BilinearPatch::Init(Allocator alloc) {
    allMeshes = alloc.new_object<pstd::vector<const BilinearPatchMesh *>>(alloc);
#if defined(PBRT_BUILD_GPU_RENDERER)
    if (Options->useGPU)
        CUDA_CHECK(
            cudaMemcpyToSymbol(allBilinearMeshesGPU, &allMeshes, sizeof(allMeshes)));
#endif
}

STAT_MEMORY_COUNTER(""Memory/Bilinear patches"", blpBytes);

// BilinearPatch Method Definitions
BilinearPatch::BilinearPatch(const BilinearPatchMesh *mesh, int meshIndex, int blpIndex)
    : meshIndex(meshIndex), blpIndex(blpIndex) {
    blpBytes += sizeof(*this);
    // Store area of bilinear patch in _area_
    const int *v = &mesh->vertexIndices[4 * blpIndex];
    const Point3f &p00 = mesh->p[v[0]], &p10 = mesh->p[v[1]];
    const Point3f &p01 = mesh->p[v[2]], &p11 = mesh->p[v[3]];
    if (IsRectangle(mesh))
        area = Distance(p00, p01) * Distance(p00, p10);
    else {
        // Compute approximate area of bilinear patch
        // FIXME: it would be good to skip this for flat patches, or to
        // be adaptive based on curvature in some manner
        constexpr int na = 3;
        Point3f p[na + 1][na + 1];
        for (int i = 0; i <= na; ++i) {
            Float u = Float(i) / Float(na);
            for (int j = 0; j <= na; ++j) {
                Float v = Float(j) / Float(na);
                p[i][j] = Lerp(u, Lerp(v, p00, p01), Lerp(v, p10, p11));
            }
        }
        area = 0;
        for (int i = 0; i < na; ++i)
            for (int j = 0; j < na; ++j)
                area += 0.5f * Length(Cross(p[i + 1][j + 1] - p[i][j],
                                            p[i + 1][j] - p[i][j + 1]));
    }
}

Bounds3f BilinearPatch::Bounds() const {
    // Get bilinear patch vertices in _p00_, _p01_, _p10_, and _p11_
    const BilinearPatchMesh *mesh = GetMesh();
    const int *v = &mesh->vertexIndices[4 * blpIndex];
    const Point3f &p00 = mesh->p[v[0]], &p10 = mesh->p[v[1]];
    const Point3f &p01 = mesh->p[v[2]], &p11 = mesh->p[v[3]];

    return Union(Bounds3f(p00, p01), Bounds3f(p10, p11));
}

DirectionCone BilinearPatch::NormalBounds() const {
    // Get bilinear patch vertices in _p00_, _p01_, _p10_, and _p11_
    const BilinearPatchMesh *mesh = GetMesh();
    const int *v = &mesh->vertexIndices[4 * blpIndex];
    const Point3f &p00 = mesh->p[v[0]], &p10 = mesh->p[v[1]];
    const Point3f &p01 = mesh->p[v[2]], &p11 = mesh->p[v[3]];

    // If patch is a triangle, return bounds for single surface normal
    if (p00 == p10 || p10 == p11 || p11 == p01 || p01 == p00) {
        Vector3f dpdu = Lerp(0.5f, p10, p11) - Lerp(0.5f, p00, p01);
        Vector3f dpdv = Lerp(0.5f, p01, p11) - Lerp(0.5f, p00, p10);
        Vector3f n = Normalize(Cross(dpdu, dpdv));
        if (mesh->n != nullptr) {
            Normal3f ns =
                (mesh->n[v[0]] + mesh->n[v[1]] + mesh->n[v[2]] + mesh->n[v[3]]) / 4;
            n = FaceForward(n, ns);
        } else if (mesh->reverseOrientation ^ mesh->transformSwapsHandedness)
            n = -n;
        return DirectionCone(n);
    }

    // Compute bilinear patch normal _n00_ at $(0,0)$
    Vector3f n00 = Normalize(Cross(p10 - p00, p01 - p00));
    if (mesh->n != nullptr)
        n00 = FaceForward(n00, mesh->n[v[0]]);
    else if (mesh->reverseOrientation ^ mesh->transformSwapsHandedness)
        n00 = -n00;

    // Compute bilinear patch normals _n10_, _n01_, and _n11_
    Vector3f n10 = Normalize(Cross(p11 - p10, p00 - p10));
    Vector3f n01 = Normalize(Cross(p00 - p01, p11 - p01));
    Vector3f n11 = Normalize(Cross(p01 - p11, p10 - p11));
    if (mesh->n != nullptr) {
        n10 = FaceForward(n10, mesh->n[v[1]]);
        n01 = FaceForward(n01, mesh->n[v[2]]);
        n11 = FaceForward(n11, mesh->n[v[3]]);
    } else if (mesh->reverseOrientation ^ mesh->transformSwapsHandedness) {
        n10 = -n10;
        n01 = -n01;
        n11 = -n11;
    }

    // Compute average normal and return normal bounds for patch
    Vector3f n = Normalize(n00 + n10 + n01 + n11);
    Float cosTheta = std::min({Dot(n, n00), Dot(n, n01), Dot(n, n10), Dot(n, n11)});
    return DirectionCone(n, Clamp(cosTheta, -1, 1));
}

pstd::optional<ShapeIntersection> BilinearPatch::Intersect(const Ray &ray,
                                                           Float tMax) const {
    // Get bilinear patch vertices in _p00_, _p01_, _p10_, and _p11_
    const BilinearPatchMesh *mesh = GetMesh();
    const int *v = &mesh->vertexIndices[4 * blpIndex];
    const Point3f &p00 = mesh->p[v[0]], &p10 = mesh->p[v[1]];
    const Point3f &p01 = mesh->p[v[2]], &p11 = mesh->p[v[3]];

    pstd::optional<BilinearIntersection> blpIsect =
        IntersectBilinearPatch(ray, tMax, p00, p10, p01, p11);
    if (!blpIsect)
        return {};
    SurfaceInteraction intr =
        InteractionFromIntersection(mesh, blpIndex, blpIsect->uv, ray.time, -ray.d);
    return ShapeIntersection{intr, blpIsect->t};
}

bool BilinearPatch::IntersectP(const Ray &ray, Float tMax) const {
    // Get bilinear patch vertices in _p00_, _p01_, _p10_, and _p11_
    const BilinearPatchMesh *mesh = GetMesh();
    const int *v = &mesh->vertexIndices[4 * blpIndex];
    const Point3f &p00 = mesh->p[v[0]], &p10 = mesh->p[v[1]];
    const Point3f &p01 = mesh->p[v[2]], &p11 = mesh->p[v[3]];

    return IntersectBilinearPatch(ray, tMax, p00, p10, p01, p11).has_value();
}

pstd::optional<ShapeSample> BilinearPatch::Sample(Point2f u) const {
    // Get bilinear patch vertices in _p00_, _p01_, _p10_, and _p11_
    const BilinearPatchMesh *mesh = GetMesh();
    const int *v = &mesh->vertexIndices[4 * blpIndex];
    const Point3f &p00 = mesh->p[v[0]], &p10 = mesh->p[v[1]];
    const Point3f &p01 = mesh->p[v[2]], &p11 = mesh->p[v[3]];

    // Sample bilinear patch parametric $(u,v)$ coordinates
    Float pdf = 1;
    Point2f uv;
    if (mesh->imageDistribution) {
        uv = mesh->imageDistribution->Sample(u, &pdf);
        uv[1] = 1 - uv[1];
    } else if (!IsRectangle(mesh)) {
        // Sample patch $(u,v)$ with approximate uniform area sampling
        // Initialize _w_ array with differential area at bilinear patch corners
        pstd::array<Float, 4> w = {
            Length(Cross(p10 - p00, p01 - p00)), Length(Cross(p10 - p00, p11 - p10)),
            Length(Cross(p01 - p00, p11 - p01)), Length(Cross(p11 - p10, p11 - p01))};

        uv = SampleBilinear(u, w);
        pdf = BilinearPDF(uv, w);

    } else
        uv = u;

    // Compute position, $\\dpdu$, and $\\dpdv$ for sampled bilinear patch $(u,v)$
    Point3f pu0 = Lerp(uv[1], p00, p01), pu1 = Lerp(uv[1], p10, p11);
    Point3f p = Lerp(uv[0], pu0, pu1);
    Vector3f dpdu = pu1 - pu0;
    Vector3f dpdv = Lerp(uv[0], p01, p11) - Lerp(uv[0], p00, p10);
    if (LengthSquared(dpdu) == 0 || LengthSquared(dpdv) == 0)
        return {};

    // Compute surface normal for sampled bilinear patch $(u,v)$
    Normal3f n = Normal3f(Normalize(Cross(dpdu, dpdv)));
    if (mesh->reverseOrientation ^ mesh->transformSwapsHandedness)
        n = -n;

    // Compute _pError_ for sampled bilinear patch $(u,v)$
    Vector3f pError =
        gamma(4) * Vector3f(Max(Max(Abs(p00), Abs(p10)), Max(Abs(p01), Abs(p11))));

    // Return _ShapeSample_ for sampled bilinear patch point
    return ShapeSample{Interaction(Point3fi(p, pError), n, uv),
                       pdf / Length(Cross(dpdu, dpdv))};
}

Float BilinearPatch::PDF(const Interaction &intr) const {
    // Get bilinear patch vertices in _p00_, _p01_, _p10_, and _p11_
    const BilinearPatchMesh *mesh = GetMesh();
    const int *v = &mesh->vertexIndices[4 * blpIndex];
    const Point3f &p00 = mesh->p[v[0]], &p10 = mesh->p[v[1]];
    const Point3f &p01 = mesh->p[v[2]], &p11 = mesh->p[v[3]];

    // Compute PDF for sampling the $(u,v)$ coordinates given by _intr.uv_
    Float pdf;
    if (mesh->imageDistribution)
        pdf = mesh->imageDistribution->PDF(Point2f(intr.uv[0], 1 - intr.uv[1]));
    else if (!IsRectangle(mesh)) {
        // Initialize _w_ array with differential area at bilinear patch corners
        pstd::array<Float, 4> w = {
            Length(Cross(p10 - p00, p01 - p00)), Length(Cross(p10 - p00, p11 - p10)),
            Length(Cross(p01 - p00, p11 - p01)), Length(Cross(p11 - p10, p11 - p01))};

        pdf = BilinearPDF(intr.uv, w);
    } else
        pdf = 1;

    // Find $\\dpdu$ and $\\dpdv$ at bilinear patch $(u,v)$
    CHECK(!intr.uv.HasNaN());
    Point3f pu0 = Lerp(intr.uv[1], p00, p01), pu1 = Lerp(intr.uv[1], p10, p11);
    Vector3f dpdu = pu1 - pu0;
    Vector3f dpdv = Lerp(intr.uv[0], p01, p11) - Lerp(intr.uv[0], p00, p10);

    // Return final bilinear patch area sampling PDF
    return pdf / Length(Cross(dpdu, dpdv));
}

pstd::optional<ShapeSample> BilinearPatch::Sample(const ShapeSampleContext &ctx,
                                                  Point2f u) const {
    // Get bilinear patch vertices in _p00_, _p01_, _p10_, and _p11_
    const BilinearPatchMesh *mesh = GetMesh();
    const int *v = &mesh->vertexIndices[4 * blpIndex];
    const Point3f &p00 = mesh->p[v[0]], &p10 = mesh->p[v[1]];
    const Point3f &p01 = mesh->p[v[2]], &p11 = mesh->p[v[3]];

    // Find normalized vectors to corners of bilinear patch
    Vector3f v00 = Normalize(p00 - ctx.p()), v10 = Normalize(p10 - ctx.p());
    Vector3f v01 = Normalize(p01 - ctx.p()), v11 = Normalize(p11 - ctx.p());

    if (IsRectangle(mesh) && !mesh->imageDistribution &&
        SphericalQuadArea(v00, v10, v11, v01) > MinSphericalSampleArea) {
        // Sample direction to rectanglular bilinear patch
        Float pdf = 1;
        if (ctx.ns != Normal3f(0, 0, 0)) {
            // Warp uniform sample _u_ to account for incident $\\cos \\theta$ factor
            // Compute $\\cos \\theta$ weights for rectangle seen from _ctx.p()_
            Point3f rp = ctx.p();
            pstd::array<Float, 4> w = pstd::array<Float, 4>{
                std::max<Float>(0.01, AbsDot(Normalize(p00 - rp), ctx.ns)),
                std::max<Float>(0.01, AbsDot(Normalize(p10 - rp), ctx.ns)),
                std::max<Float>(0.01, AbsDot(Normalize(p01 - rp), ctx.ns)),
                std::max<Float>(0.01, AbsDot(Normalize(p11 - rp), ctx.ns))};

            u = SampleBilinear(u, w);
            pdf *= BilinearPDF(u, w);
        }
        // Sample spherical rectangle at reference point $\\pt{}$
        Float quadPDF;
        Point3f p =
            SampleSphericalRectangle(ctx.p(), p00, p10 - p00, p01 - p00, u, &quadPDF);
        pdf *= quadPDF;

        // Compute surface normal and $(u,v)$ for sampled point on rectangle
        Normal3f n = Normal3f(Normalize(Cross(p10 - p00, p01 - p00)));
        if (mesh->reverseOrientation ^ mesh->transformSwapsHandedness)
            n *= -1;
        Point2f uv(Dot(p - p00, p10 - p00) / DistanceSquared(p10, p00),
                   Dot(p - p00, p01 - p00) / DistanceSquared(p01, p00));

        return ShapeSample{Interaction(p, n, ctx.time, uv), pdf};

    } else {
        // Uniformly sample shape and compute incident direction _wi_
        pstd::optional<ShapeSample> ss = Sample(u);
        DCHECK(ss.has_value());
        ss->intr.time = ctx.time;
        Vector3f wi = ss->intr.p() - ctx.p();
        if (LengthSquared(wi) == 0)
            return {};
        wi = Normalize(wi);

        // Convert uniform area sample PDF in _ss_ to solid angle measure
        ss->pdf /= AbsDot(ss->intr.n, -wi) / DistanceSquared(ctx.p(), ss->intr.p());
        if (IsInf(ss->pdf))
            return {};

        return ss;
    }
}

Float BilinearPatch::PDF(const ShapeSampleContext &ctx, const Vector3f &wi) const {
    // Intersect sample ray with shape geometry
    Ray ray = ctx.SpawnRay(wi);
    pstd::optional<ShapeIntersection> isect = Intersect(ray);
    CHECK_RARE(1e-6, !isect.has_value());
    if (!isect)
        return 0;

    // Get bilinear patch vertices in _p00_, _p01_, _p10_, and _p11_
    const BilinearPatchMesh *mesh = GetMesh();
    const int *v = &mesh->vertexIndices[4 * blpIndex];
    const Point3f &p00 = mesh->p[v[0]], &p10 = mesh->p[v[1]];
    const Point3f &p01 = mesh->p[v[2]], &p11 = mesh->p[v[3]];

    // Find normalized vectors to corners of bilinear patch
    Vector3f v00 = Normalize(p00 - ctx.p()), v10 = Normalize(p10 - ctx.p());
    Vector3f v01 = Normalize(p01 - ctx.p()), v11 = Normalize(p11 - ctx.p());

    if (IsRectangle(mesh) && !mesh->imageDistribution &&
        SphericalQuadArea(v00, v10, v11, v01) > MinSphericalSampleArea) {
        // Return PDF for sample in spherical rectangle
        Float pdf = 1 / SphericalQuadArea(v00, v10, v11, v01);
        if (ctx.ns != Normal3f(0, 0, 0)) {
            // Compute $\\cos \\theta$ weights for rectangle seen from _ctx.p()_
            Point3f rp = ctx.p();
            pstd::array<Float, 4> w = pstd::array<Float, 4>{
                std::max<Float>(0.01, AbsDot(Normalize(p00 - rp), ctx.ns)),
                std::max<Float>(0.01, AbsDot(Normalize(p10 - rp), ctx.ns)),
                std::max<Float>(0.01, AbsDot(Normalize(p01 - rp), ctx.ns)),
                std::max<Float>(0.01, AbsDot(Normalize(p11 - rp), ctx.ns))};

            Point2f u = InvertSphericalRectangleSample(rp, p00, p10 - p00, p01 - p00,
                                                       isect->intr.p());
            return BilinearPDF(u, w) * pdf;
        } else
            return pdf;

    } else {
        // Return solid angle PDF for sampling bilinear patch at _intr_
        Float pdf = PDF(isect->intr) / (AbsDot(isect->intr.n, -wi) /
                                        DistanceSquared(ctx.p(), isect->intr.p()));
        if (IsInf(pdf))
            pdf = 0;
        return pdf;
    }
}

std::string BilinearPatch::ToString() const {
    return StringPrintf(""[ BilinearPatch meshIndex: %d blpIndex: %d area: %f ]"",
                        meshIndex, blpIndex, area);
}

STAT_COUNTER(""Geometry/Spheres"", nSpheres);
STAT_COUNTER(""Geometry/Cylinders"", nCylinders);
STAT_COUNTER(""Geometry/Disks"", nDisks);

pstd::vector<ShapeHandle> ShapeHandle::Create(const std::string &name,
                                              const Transform *renderFromObject,
                                              const Transform *objectFromRender,
                                              bool reverseOrientation,
                                              const ParameterDictionary &parameters,
                                              const FileLoc *loc, Allocator alloc) {
    pstd::vector<ShapeHandle> shapes(alloc);
    if (name == ""sphere"") {
        shapes = {Sphere::Create(renderFromObject, objectFromRender, reverseOrientation,
                                 parameters, loc, alloc)};
        ++nSpheres;
    }
    // Create remaining single _Shape_ types
    else if (name == ""cylinder"") {
        shapes = {Cylinder::Create(renderFromObject, objectFromRender, reverseOrientation,
                                   parameters, loc, alloc)};
        ++nCylinders;
    } else if (name == ""disk"") {
        shapes = {Disk::Create(renderFromObject, objectFromRender, reverseOrientation,
                               parameters, loc, alloc)};
        ++nDisks;
    } else if (name == ""bilinearmesh"") {
        BilinearPatchMesh *mesh = BilinearPatch::CreateMesh(
            renderFromObject, reverseOrientation, parameters, loc, alloc);
        shapes = BilinearPatch::CreatePatches(mesh, alloc);
    }
    // Create multiple-_Shape_ types
    else if (name == ""curve"")
        shapes = Curve::Create(renderFromObject, objectFromRender, reverseOrientation,
                               parameters, loc, alloc);
    else if (name == ""trianglemesh"") {
        TriangleMesh *mesh = Triangle::CreateMesh(renderFromObject, reverseOrientation,
                                                  parameters, loc, alloc);
        shapes = Triangle::CreateTriangles(mesh, alloc);
    } else if (name == ""plymesh"") {
        std::string filename = ResolveFilename(parameters.GetOneString(""filename"", """"));
        TriQuadMesh plyMesh = TriQuadMesh::ReadPLY(filename);

        if (!plyMesh.triIndices.empty()) {
            TriangleMesh *mesh = alloc.new_object<TriangleMesh>(
                *renderFromObject, reverseOrientation, plyMesh.triIndices, plyMesh.p,
                std::vector<Vector3f>(), plyMesh.n, plyMesh.uv, plyMesh.faceIndices);
            shapes = Triangle::CreateTriangles(mesh, alloc);
        }

        if (!plyMesh.quadIndices.empty()) {
            BilinearPatchMesh *mesh = alloc.new_object<BilinearPatchMesh>(
                *renderFromObject, reverseOrientation, plyMesh.quadIndices, plyMesh.p,
                plyMesh.n, plyMesh.uv, plyMesh.faceIndices, nullptr /* image dist */);
            pstd::vector<ShapeHandle> quadMesh =
                BilinearPatch::CreatePatches(mesh, alloc);
            shapes.insert(shapes.end(), quadMesh.begin(), quadMesh.end());
        }
    } else if (name == ""loopsubdiv"") {
        int nLevels = parameters.GetOneInt(""levels"", 3);
        std::vector<int> vertexIndices = parameters.GetIntArray(""indices"");
        if (vertexIndices.empty())
            ErrorExit(loc, ""Vertex indices \\""indices\\"" not provided for ""
                           ""LoopSubdiv shape."");

        std::vector<Point3f> P = parameters.GetPoint3fArray(""P"");
        if (P.empty())
            ErrorExit(loc, ""Vertex positions \\""P\\"" not provided for LoopSubdiv shape."");

        // don't actually use this for now...
        std::string scheme = parameters.GetOneString(""scheme"", ""loop"");

        TriangleMesh *mesh = LoopSubdivide(renderFromObject, reverseOrientation, nLevels,
                                           vertexIndices, P, alloc);

        shapes = Triangle::CreateTriangles(mesh, alloc);
    } else
        ErrorExit(loc, ""%s: shape type unknown."", name);

    if (shapes.empty())
        ErrorExit(loc, ""%s: unable to create shape."", name);

    return shapes;
}

std::string ShapeHandle::ToString() const {
    if (ptr() == nullptr)
        return ""(nullptr)"";

    auto tostr = [&](auto ptr) { return ptr->ToString(); };
    return DispatchCPU(tostr);
}

// Shape Method Definitions
std::string ShapeSample::ToString() const {
    return StringPrintf(""[ ShapeSample intr: %s pdf: %f ]"", intr, pdf);
}

std::string ShapeIntersection::ToString() const {
    return StringPrintf(""[ ShapeIntersection intr: %s tHit: %f ]"", intr, tHit);
}

}  // namespace pbrt
",16287,True,3285.4843014342155,median
"//
// Licensed to the Apache Software Foundation (ASF) under one or more
// contributor license agreements.  See the NOTICE file distributed with
// this work for additional information regarding copyright ownership.
// The ASF licenses this file to You under the Apache License, Version 2.0
// (the ""License""); you may not use this file except in compliance with
// the License.  You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an ""AS IS"" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
Getting Started with Apache NiFi
================================
Apache NiFi Team <dev@nifi.apache.org>
:homepage: http://nifi.apache.org


Who is This Guide For?
----------------------

This guide is written for user who have never used, have had limited exposure to, or only accomplished specific tasks within NiFi.
This guide is not intended to be an exhaustive instruction manual or a reference guide. The
link:user-guide.html[User Guide] provides a great deal of information
and is intended to be a much more exhaustive resource and is very useful as a reference guide, as well.
This guide, in comparison, is intended to provide users with just the information needed in order
to understand how to work with NiFi in order to quickly and easily build powerful and agile dataflows.

Because some of the information in this guide is applicable only for first-time users while other
information may be applicable for those who have used NiFi a bit, this guide is broken up into
several different sections, some of which may not be useful for some readers. Feel free to jump to
the sections that are most appropriate for you.

This guide does expect that the user has a basic understanding of what NiFi is and does not
delve into this level of detail. This level of information can be found in the
link:overview.html[Overview] documentation.




Terminology Used in This Guide
------------------------------

In order to talk about NiFi, there are a few key terms that readers should be familiar with.
We will explain those NiFi-specific terms here, at a high level.


*FlowFile*: Each piece of ""User Data"" (i.e., data that the user brings into NiFi for processing and distribution) is
referred to as a FlowFile. A FlowFile is made up of two parts: Attributes and Content. The Content is the User Data
itself. Attributes are key-value pairs that are associated with the User Data.

*Processor*: The Processor is the NiFi component that is responsible for creating, sending, receiving, transforming, routing,
splitting, merging, and processing FlowFiles. It is the most important building block available to NiFi users to build their
dataflows.


Downloading and Installing NiFi
-------------------------------

NiFi can be downloaded from the link:http://nifi.apache.org/download.html[NiFi Downloads Page]. There are two packaging options
available: a ""tarball"" that is tailored more to Linux and a zip file that is more applicable for Windows users. Mac OSX users
may also use the tarball or can install via Homebrew.

To install via Homebrew, simply run the command `brew install nifi`.

For users who are not running OSX or do not have Homebrew installed, after downloading the version of NiFi that you
would like to use simply extract the archive to the location that you wish to run the application from.

For information on how to configure the instance of NiFi (for instance, to configure security, data storage
configuration, or the port that NiFi is running on), see the link:administration-guide.html[Admin Guide].


Starting NiFi
-------------

Once NiFi has been downloaded and installed as described above, it can be started by using the mechanism
appropriate for your operating system.

=== For Windows Users

For Windows users, navigate to the folder where NiFi was installed. Within this folder is a subfolder
named `bin`. Navigate to this subfolder and double-click the `run-nifi.bat` file.

This will launch NiFi and leave it running in the foreground. To shut down NiFi, select the window that
was launched and hold the Ctrl key while pressing C.


=== For Linux/Mac OSX users

For Linux and OSX users, use a Terminal window to navigate to the directory where NiFi was installed.
To run NiFi in the foreground, run `bin/nifi.sh run`. This will leave the application running until
the user presses Ctrl-C. At that time, it will initiate shutdown of the application.

To run NiFi in the background, instead run `bin/nifi.sh start`. This will initiate the application to
begin running. To check the status and see if NiFi is currently running, execute the command `bin/nifi.sh status`.
NiFi can be shutdown by executing the command `bin/nifi.sh stop`.


=== Installing as a Service

Currently, installing NiFi as a service is supported only for Linux and Mac OSX users. To install the application
as a service, navigate to the installation directory in a Terminal window and execute the command `bin/nifi.sh install`
to install the service with the default name `nifi`. To specify a custom name for the service, execute the command
with an optional second argument that is the name of the service. For example, to install NiFi as a service with the
name `dataflow`, use the command `bin/nifi.sh install dataflow`.

Once installed, the service can be started and stopped using the appropriate commands, such as `sudo service nifi start`
and `sudo service nifi stop`. Additionally, the running status can be checked via `sudo service nifi status`.



I Started NiFi. Now What?
-------------------------

Now that NiFi has been started, we can bring up the User Interface (UI) in order to create and monitor our dataflow.
To get started, open a web browser and navigate to `http://localhost:8080/nifi`. The port can be changed by
editing the `nifi.properties` file in the NiFi `conf` directory, but the default port is 8080.

This will bring up the User Interface, which at this point is a blank canvas for orchestrating a dataflow:

image:new-flow.png[""New Flow""]

Near the top of the UI are a few toolbars that will be very important to create your first dataflow:

image:nifi-toolbar-components.png[""Toolbar Components""]


=== Adding a Processor

We can now begin creating our dataflow by adding a Processor to our canvas. To do this, drag the Processor icon
(image:iconProcessor.png[""Processor""]) from the top-left of the screen into the middle of the canvas (the graph paper-like
background) and drop it there. This will give us a dialog that allows us to choose which Processor we want to add:

image:add-processor.png[""Add Processor""]

We have quite a few options to choose from. For the sake of becoming oriented with the system, let's say that we
just want to bring in files from our local disk into NiFi. When a developer creates a Processor, the developer can 
assign ""tags"" to that Processor. These can be thought of as keywords. We can filter by these tags or by Processor
name by typing into the Filter box in the top-right corner of the dialog. Type in the keywords that you would think
of when wanting to ingest files from a local disk. Typing in keyword ""file"", for instance, will provide us a few
different Processors that deal with files. Filtering by the term ""local"" will narrow down the list pretty quickly,
as well. If we select a Processor from the list,
we will see a brief description of the Processor near the bottom of the dialog. This should tell us exactly what
the Processor does. The description of the *GetFile* Processor tells us that it pulls data from our local disk
into NiFi and then removes the local file. We can then double-click the Processor type or select it and choose the
`Add` button. The Processor will be added to the canvas in the location that it was dropped.

=== Configuring a Processor

Now that we have added the GetFile Processor, we can configure it by right-clicking on the Processor and choosing
the `Configure` menu item. The provided dialog allows us to configure many different options that can be read about
in the link:user-guide.html[User Guide], but for the sake of this guide, we will focus on the Properties tab. Once
the Properties tab has been selected, we are given a list of several different properties that we can configure
for the Processor. The properties that are available depend on the type of Processor and are generally different
for each type. Properties that are in bold are required properties. The Processor cannot be started until all required
properties have been configured. The most important property to configure for GetFile is the directory from which
to pick up files. If we set the directory name to `./data-in`, this will cause the Processor to start picking up
any data in the `data-in` subdirectory of the NiFi Home directory. We can choose to configure several different
Properties for this Processor. If unsure what a particular Property does, we can hover over the Help icon (
image:iconInfo.png[""Help""]
)
next to the Property Name with the mouse in order to read a description of the property. Additionally, the
tooltip that is displayed when hovering over the Help icon will provide the default value for that property,
if one exists, information about whether or not the property supports the Expression Language (see the
<<ExpressionLanguage>> section below), and previously configured values for that property.

In order for this property to be valid, create a directory named `data-in` in the NiFi home directory and then
click the `Ok` button to close the dialog.


=== Connecting Processors

Each Processor has a set of defined ""Relationships"" that it is able to send data to. When a Processor finishes handling
a FlowFile, it transfers it to one of these Relationships. This allows a user to configure how to handle FlowFiles based
on the result of Processing. For example, many Processors define two Relationships: `success` and `failure`. Users are
then able to configure data to be routed through the flow one way if the Processor is able to successfully process
the data and route the data through the flow in a completely different manner if the Processor cannot process the
data for some reason. Or, depending on the use case, it may simply route both relationships to the same route through
the flow.

Now that we have added and configured our GetFile processor and applied the configuration, we can see in the
top-left corner of the Processor an Alert icon (
image:iconAlert.png[Alert]
) signaling that the Processor is not in a valid state. Hovering over this icon, we can see that the `success`
relationship has not been defined. This simply means that we have not told NiFi what to do with the data that the Processor
transfers to the `success` Relationship.

In order to address this, let's add another Processor that we can connect the GetFile Processor to, by following
the same steps above. This time, however, we will simply log the attributes that exist for the FlowFile. To do this,
we will add a LogAttributes Processor.

We can now send the output of the GetFile Processor to the LogAttribute Processor. Hover over the GetFile Processor
with the mouse and a Connection Icon (
image:iconConnection.png[Connection]
) will appear over the middle of the Processor. We can drag this icon from the GetFile Processor to the LogAttribute
Processor. This gives us a dialog to choose which Relationships we want to include for this connection. Because GetFile
has only a single Relationship, `success`, it is automatically selected for us.

Clicking on the Settings tab provides a handful of options for configuring how this Connection should behave:

image:connection-settings.png[Connection Settings]

We can give the Connection a name, if we like. Otherwise, the Connection name will be based on the selected Relationships.
We can also set an expiration for the data. By default, it is set to ""0 sec"" which indicates that the data should not
expire. However, we can change the value so that when data in this Connection reaches a certain age, it will automatically
be deleted (and a corresponding EXPIRE Provenance event will be created).

The backpressure thresholds allow us to specify how full the queue is allowed to become before the source Processor is
no longer scheduled to run. This allows us to handle cases where one Processor is capable of producing data faster than
the next Processor is capable of consuming that data. If the backpressure is configured for each Connection along the way,
the Processor that is bringing data into the system will eventually experience the backpressure and stop bringing in new
data so that our system has the ability to recover.

Finally, we have the Prioritizers on the right-hand side. This allows us to control how the data in this queue is ordered.
We can drag Prioritizers from the ""Available prioritizers"" list to the ""Selected prioritizers"" list in order to active
the prioritizer. If multiple prioritizers are activated, they will be evaluated such that the Prioritizer listed first
will be evaluated first and if two FlowFiles are determined to be equal according to that Prioritizers, the second Prioritizer
will be used.

For the sake of this discussion, we can simply click `Add`. to add the Connection to our graph. We should now see that the Alert 
icon has changed to a Stopped icon (
image:iconStop.png[Stopped]
). The LogAttribute Processor, however, is now invalid because its `success` Relationship has not been connected to
anything. Let's address this by signaling that data that is routed to `success` by LogAttribute should be ""Auto Terminated,""
meaning that NiFi should consider the FlowFile's processing complete and ""drop"" the data. To do this, we configure the
LogAttribute Processor. On the Settings tab, in the right-hand side we can check the box next to the `success` Relationship
to Auto Terminate the data. Clicking `OK` will close the dialog and show that both Processors are now stopped.


=== Starting and Stopping Processors

At this point, we have two Processors on our graph, but nothing is happening. In order to start the Processors, we can
click on each one individually and then right-click and choose the `Start` menu item. Alternatively, we can select the first
Processor, and then hold the Shift key while selecting the other Processor in order to select both. Then, we can
right-click and choose the `Start` menu item. As an alternative to using the context menu, we can select the Processors and
then click the Start icon in the toolbar at the top of the screen.

Once started, the icon in the top-left corner of the Processors will change from a stopped icon to a running icon. We can then
stop the Processors by using the Stop icon in the toolbar or the `Stop` menu item.

Once a Processor has started, we are not able to configure it anymore. Instead, when we right-click on the Processor, we are
given the option to view its current configuration. In order to configure a Processor, we must first stop the Processor and
wait for any tasks that may be executing to finish. The number of tasks currently executing is shown in the top-right
corner of the Processor, but nothing is shown there if there are currently no tasks.


=== Getting More Info for a Processor

With each Processor having the ability to expose multiple different Properties and Relationships, it can become quite
difficult to remember how all of the different pieces work for each Processor. To address this, you are able to right-click
on a Processor and choose the `Usage` menu item. This will provide you with the Processor's usage information, such as a
description of the Processor, the different Relationships that are available, when the different Relationships are used,
Properties that are exposed by the Processor and their documentation, as well as which FlowFile Attributes (if any) are
expected on incoming FlowFiles and which Attributes (if any) are added to outgoing FlowFiles.


=== Other Components

The toolbar that provides users the ability to drag and drop Processors onto the graph includes several other components
that can be used to build a dataflow. These components include Input and Output Ports, Funnels, Process Groups, and Remote
Process Groups. Due to the intended scope of this document, we will not discuss these elements here, but information is
readily available in the link:user-guide.html#building-dataflow[Building a Dataflow section] of the
link:user-guide.html[User Guide].



What Processors are Available
-----------------------------

In order to create an effective dataflow, the users must understand what types of Processors are available to them.
NiFi contains many different Processors out of the box. These Processors provide capabilities to ingest data from
numerous different systems, route, transform, process, split, and aggregate data, and distribute data to many systems.

The number of Processors that are available increases in nearly each release of NiFi. As a result, we will not attempt
to name each of the Processors that are available, but we will highlight some of the most frequently used Processors,
categorizing them by their functions.

=== Data Transformation
- *CompressContent*: Compress or Decompress Content
- *ConvertCharacterSet*: Convert the character set used to encode the content from one character set to another
- *EncryptContent*: Encrypt or Decrypt Content
- *ReplaceText*: Use Regular Expressions to modify textual Content
- *TransformXml*: Apply an XSLT transform to XML Content
- *TransformJSON*: Apply a JOLT specification to transform JSON Content

=== Routing and Mediation
- *ControlRate*: Throttle the rate at which data can flow through one part of the flow
- *DetectDuplicate*: Monitor for duplicate FlowFiles, based on some user-defined criteria. Often used in conjunction
	with HashContent
- *DistributeLoad*: Load balance or sample data by distributing only a portion of data to each user-defined Relationship
- *MonitorActivity*: Sends a notification when a user-defined period of time elapses without any data coming through a particular
	point in the flow. Optionally send a notification when dataflow resumes.
- *RouteOnAttribute*: Route FlowFile based on the attributes that it contains.
- *ScanAttribute*: Scans the user-defined set of Attributes on a FlowFile, checking to see if any of the Attributes match the terms
  found in a user-defined dictionary.
- *RouteOnContent*: Search Content of a FlowFile to see if it matches any user-defined Regular Expression. If so, the FlowFile is
  routed to the configured Relationship.
- *ScanContent*: Search Content of a FlowFile for terms that are present in a user-defined dictionary and route based on the
	presence or absence of those terms. The dictionary can consist of either textual entries or binary entries.
- *ValidateXml*: Validation XML Content against an XML Schema; routes FlowFile based on whether or not the Content of the FlowFile
	is valid according to the user-defined XML Schema.

=== Database Access
- *ConvertJSONToSQL*: Convert a JSON document into a SQL INSERT or UPDATE command that can then be passed to the PutSQL Processor
- *ExecuteSQL*: Executes a user-defined SQL SELECT command, writing the results to a FlowFile in Avro format
- *PutSQL*: Updates a database by executing the SQL DDM statement defined by the FlowFile's content
- *SelectHiveQL*: Executes a user-defined HiveQL SELECT command against an Apache Hive database, writing the results to a FlowFile in Avro or CSV format
- *PutHiveQL*: Updates a Hive database by executing the HiveQL DDM statement defined by the FlowFile's content

[[AttributeExtraction]]
=== Attribute Extraction
- *EvaluateJsonPath*: User supplies JSONPath Expressions (Similar to XPath, which is used for XML parsing/extraction), and these Expressions
  are then evaluated against the JSON Content to either replace the FlowFile Content or extract the value into the user-named Attribute.
- *EvaluateXPath*: User supplies XPath Expressions, and these Expressions are then evaluated against the XML Content to either
  replace the FlowFile Content or extract the value into the user-named Attribute.
- *EvaluateXQuery*: User supplies an XQuery query, and this query is then evaluated against the XML Content to either replace the FlowFile
  Content or extract the value into the user-named Attribute.
- *ExtractText*: User supplies one or more Regular Expressions that are then evaluated against the textual content of the FlowFile, and the
  values that are extracted are then added as user-named Attributes.
- *HashAttribute*: Performs a hashing function against the concatenation of a user-defined list of existing Attributes.
- *HashContent*: Performs a hashing function against the content of a FlowFile and adds the hash value as an Attribute.
- *IdentifyMimeType*: Evaluates the content of a FlowFile in order to determine what type of file the FlowFile encapsulates. This Processor is
  capable of detecting many different MIME Types, such as images, word processor documents, text, and compression formats just to name
	a few.
- *UpdateAttribute*: Adds or updates any number of user-defined Attributes to a FlowFile. This is useful for adding statically configured values,
  as well as deriving Attribute values dynamically by using the Expression Language. This processor also provides an ""Advanced User Interface,""
	allowing users to update Attributes conditionally, based on user-supplied rules.

=== System Interaction
- *ExecuteProcess*: Runs the user-defined Operating System command. The Process's StdOut is redirected such that the content that is written
  to StdOut becomes the content of the outbound FlowFile. This Processor is a Source Processor - its output is expected to generate a new FlowFile,
	and the system call is expected to receive no input. In order to provide input to the process, use the ExecuteStreamCommand Processor.

- *ExecuteStreamCommand*: Runs the user-defined Operating System command. The contents of the FlowFile are optionally streamed to the StdIn
  of the process. The content that is written to StdOut becomes the content of hte outbound FlowFile. This Processor cannot be used a Source Processor -
	it must be fed incoming FlowFiles in order to perform its work. To perform the same type of functionality with a Source Processor, see the
	ExecuteProcess Processor.

=== Data Ingestion
- *GetFile*: Streams the contents of a file from a local disk (or network-attached disk) into NiFi and then deletes the original file. This
  Processor is expected to move the file from one location to another location and is not to be used for copying the data.
- *GetFTP*: Downloads the contents of a remote file via FTP into NiFi and then deletes the original file. This Processor is expected to move
  the data from one location to another location and is not to be used for copying the data.
- *GetSFTP*: Downloads the contents of a remote file via SFTP into NiFi and then deletes the original file. This Processor is expected to move
  the data from one location to another location and is not to be used for copying the data.
- *GetJMSQueue*: Downloads a message from a JMS Queue and creates a FlowFile based on the contents of the JMS message. The JMS Properties are
  optionally copied over as Attributes, as well.
- *GetJMSTopic*: Downloads a message from a JMS Topic and creates a FlowFile based on the contents of the JMS message. The JMS Properties are
  optionally copied over as Attributes, as well. This Processor supports both durable and non-durable subscriptions.
- *GetHTTP*: Downloads the contents of a remote HTTP- or HTTPS-based URL into NiFi. The Processor will remember the ETag and Last-Modified Date
  in order to ensure that the data is not continually ingested.
- *ListenHTTP*: Starts an HTTP (or HTTPS) Server and listens for incoming connections. For any incoming POST request, the contents of the request
  are written out as a FlowFile, and a 200 response is returned.
- *ListenUDP*: Listens for incoming UDP packets and creates a FlowFile per packet or per bundle of packets (depending on configuration) and
  emits the FlowFile to the 'success' relationship.
- *GetHDFS*: Monitors a user-specified directory in HDFS. Whenever a new file enters HDFS, it is copied into NiFi and deleted from HDFS. This
  Processor is expected to move the file from one location to another location and is not to be used for copying the data. This Processor is also
	expected to be run On Primary Node only, if run within a cluster. In order to copy the data from HDFS and leave it in-tact, or to stream the data
	from multiple nodes in the cluster, see the ListHDFS Processor.
- *ListHDFS* / *FetchHDFS*: ListHDFS monitors a user-specified directory in HDFS and emits a FlowFile containing the filename for each file that it
  encounters. It then persists this state across the entire NiFi cluster by way of a Distributed Cache. These FlowFiles can then be fanned out across
	the cluster and sent to the FetchHDFS Processor, which is responsible for fetching the actual content of those files and emitting FlowFiles that contain
	the content fetched from HDFS.
- *FetchS3Object*: Fetches the contents of an object from the Amazon Web Services (AWS) Simple Storage Service (S3). The outbound FlowFile contains the contents
  received from S3.
- *GetKafka*: Consumes messages from Apache Kafka. The messages can be emitted as a FlowFile per message or can be batched together using a user-specified
  delimiter.
- *GetMongo*: Executes a user-specified query against MongoDB and writes the contents to a new FlowFile.
- *GetTwitter*: Allows Users to register a filter to listen to the Twitter ""garden hose"" or Enterprise endpoint, creating a FlowFile for each tweet
  that is received.

=== Data Egress / Sending Data
- *PutEmail*: Sends an E-mail to the configured recipients. The content of the FlowFile is optionally sent as an attachment.
- *PutFile*: Writes the contents of a FlowFile to a directory on the local (or network attached) file system.
- *PutFTP*: Copies the contents of a FlowFile to a remote FTP Server.
- *PutSFTP*: Copies the contents of a FlowFile to a remote SFTP Server.
- *PutJMS*: Sends the contents of a FlowFile as a JMS message to a JMS broker, optionally adding JMS Properties based on Attributes.
- *PutSQL*: Executes the contents of a FlowFile as a SQL DDL Statement (INSERT, UPDATE, or DELETE). The contents of the FlowFile must be a valid
  SQL statement. Attributes can be used as parameters so that the contents of the FlowFile can be parameterized SQL statements in order to avoid
	SQL injection attacks.
- *PutKafka*: Sends the contents of a FlowFile to Kafka as a message. The FlowFile can be sent as a single message or a delimiter, such as a
  new-line can be specified, in order to send many messages for a single FlowFile.
- *PutMongo*: Sends the contents of a FlowFile to Mongo as an INSERT or an UPDATE.

=== Splitting and Aggregation
- *SplitText*: SplitText takes in a single FlowFile whose contents are textual and splits it into 1 or more FlowFiles based on the configured
  number of lines. For example, the Processor can be configured to split a FlowFile into many FlowFiles, each of which is only 1 line.
- *SplitJson*: Allows the user to split a JSON object that is comprised of an array or many child objects into a FlowFile per JSON element.
- *SplitXml*: Allows the user to split an XML message into many FlowFiles, each containing a segment of the original. This is generally used when
  several XML elements have been joined together with a ""wrapper"" element. This Processor then allows those elements to be split out into individual
	XML elements.
- *UnpackContent*: Unpacks different types of archive formats, such as ZIP and TAR. Each file within the archive is then transferred as a single
  FlowFile.
- *MergeContent*: This Processor is responsible for merging many FlowFiles into a single FlowFile. The FlowFiles can be merged by concatenating their
  content together along with optional header, footer, and demarcator, or by specifying an archive format, such as ZIP or TAR. FlowFiles can be binned
	together based on a common attribute, or can be ""defragmented"" if they were split apart by some other Splitting process. The minimum and maximum
	size of each bin is user-specified, based on number of elements or total size of FlowFiles' contents, and an optional Timeout can be assigned as well
	so that FlowFiles will only wait for their bin to become full for a certain amount of time.
- *SegmentContent*: Segments a FlowFile into potentially many smaller FlowFiles based on some configured data size. The splitting is not performed
  against any sort of demarcator but rather just based on byte offsets. This is used before transmitting FlowFiles in order to provide lower latency
	by sending many different pieces in parallel. On the other side, these FlowFiles can then be reassembled by the MergeContent processor using the
	Defragment mode.
- *SplitContent*: Splits a single FlowFile into potentially many FlowFiles, similarly to SegmentContent. However, with SplitContent, the splitting
  is not performed on arbitrary byte boundaries but rather a byte sequence is specified on which to split the content.

=== HTTP
- *GetHTTP*: Downloads the contents of a remote HTTP- or HTTPS-based URL into NiFi. The Processor will remember the ETag and Last-Modified Date
  in order to ensure that the data is not continually ingested.
- *ListenHTTP*: Starts an HTTP (or HTTPS) Server and listens for incoming connections. For any incoming POST request, the contents of the request
  are written out as a FlowFile, and a 200 response is returned.
- *InvokeHTTP*: Performs an HTTP Request that is configured by the user. This Processor is much more versatile than the GetHTTP and PostHTTP
  but requires a bit more configuration. This Processor cannot be used as a Source Processor and is required to have incoming FlowFiles in order
	to be triggered to perform its task.
- *PostHTTP*: Performs an HTTP POST request, sending the contents of the FlowFile as the body of the message. This is often used in conjunction
  with ListenHTTP in order to transfer data between two different instances of NiFi in cases where Site-to-Site cannot be used (for instance,
	when the nodes cannot access each other directly and are able to communicate through an HTTP proxy).
	*Note*: HTTP is available as a link:user-guide.html#site-to-site[Site-to-Site] transport protocol in addition to the existing RAW socket transport. It also supports HTTP Proxy. Using HTTP Site-to-Site is recommended since it's more scalable, and can provide bi-directional data transfer using input/output ports with better user authentication and authorization.
- *HandleHttpRequest* / *HandleHttpResponse*: The HandleHttpRequest Processor is a Source Processor that starts an embedded HTTP(S) server
  similarly to ListenHTTP. However, it does not send a response to the client. Instead, the FlowFile is sent out with the body of the HTTP request
	as its contents and attributes for all of the typical Servlet parameters, headers, etc. as Attributes. The HandleHttpResponse then is able to
	send a response back to the client after the FlowFile has finished being processed. These Processors are always expected to be used in conjunction
	with one another and allow the user to visually create a Web Service within NiFi. This is particularly useful for adding a front-end to a non-web-
  based protocol or to add a simple web service around some functionality that is already performed by NiFi, such as data format conversion.

=== Amazon Web Services
- *FetchS3Object*: Fetches the content of an object stored in Amazon Simple Storage Service (S3). The content that is retrieved from S3
  is then written to the content of the FlowFile.
- *PutS3Object*: Writes the contents of a FlowFile to an Amazon S3 object using the configured credentials, key, and bucket name.
- *PutSNS*: Sends the contents of a FlowFile as a notification to the Amazon Simple Notification Service (SNS).
- *GetSQS*: Pulls a message from the Amazon Simple Queuing Service (SQS) and writes the contents of the message to the content of the FlowFile.
- *PutSQS*: Sends the contents of a FlowFile as a message to the Amazon Simple Queuing Service (SQS).
- *DeleteSQS*: Deletes a message from the Amazon Simple Queuing Service (SQS). This can be used in conjunction with the GetSQS in order to receive
  a message from SQS, perform some processing on it, and then delete the object from the queue only after it has successfully completed processing.


Working With Attributes
-----------------------
Each FlowFile is created with several Attributes, and these Attributes will change over the life of
the FlowFile. The concept of a FlowFile is extremely powerful and provides three primary benefits.
First, it allows the user to make routing decisions in the flow so that FlowFiles that meet some criteria
can be handled differently than other FlowFiles. This is done using the RouteOnAttribute and similar Processors.

Secondly, Attributes are used in order to configure Processors in such a way that the configuration of the
Processor is dependent on the data itself. For instance, the PutFile Processor is able to use the Attributes in order
to know where to store each FlowFile, while the directory and filename Attributes may be different for each FlowFile.

Finally, the Attributes provide extremely valuable context about the data. This is useful when reviewing the Provenance
data for a FlowFile. This allows the user to search for Provenance data that match specific criteria, and it also allows
the user to view this context when inspecting the details of a Provenance Event. By doing this, the user is then able
to gain valuable insight as to why the data was processed one way or another, simply by glancing at this context that is
carried along with the content.

=== Common Attributes

Each FlowFile has a minimum set of Attributes:

	- *filename*: A filename that can be used to store the data to a local or remote file system
	- *path*: The name of a directory that can be used to store the data to a local or remote file system
	- *uuid*: A Universally Unique Identifier that distinguishes the FlowFile from other FlowFiles in the system.
	- *entryDate*: The date and time at which the FlowFile entered the system (i.e., was created). The value of this
		attribute is a number that represents the number of milliseconds since midnight, Jan. 1, 1970 (UTC).
	- *lineageStartDate*: Any time that a FlowFile is cloned, merged, or split, this results in a ""child"" FlowFile being
		created. As those children are then cloned, merged, or split, a chain of ancestors is built. This value represents
		the date and time at which the oldest ancestor entered the system. Another way to think about this is that this
		attribute represents the latency of the FlowFile through the system. The value is a number that represents the number
		of milliseconds since midnight, Jan. 1, 1970 (UTC).
	- *fileSize*: This attribute represents the number of bytes taken up by the FlowFile's Content.

Note that the `uuid`, `entryDate`, `lineageStartDate`, and `fileSize` attributes are system-generated and cannot be changed.

=== Extracting Attributes

NiFi provides several different Processors out of the box for extracting Attributes from FlowFiles. A list of commonly used
Processors for this purpose can be found above in the <<AttributeExtraction>> section. This is a very common use case for building
custom Processors, as well. Many Processors are written to understand a specific data format and extract pertinent information from
a FlowFile's content, creating Attributes to hold that information, so that decisions can then be made about how to route or
process the data.

=== Adding User-Defined Attributes

In addition to having Processors that are able to extract particular pieces of information from FlowFile content into Attributes,
it is also common for users to want to add their own user-defined Attributes to each FlowFile at a particular place in the flow.
The UpdateAttribute Processor is designed specifically for this purpose. Users are able to add a new property to the Processor
in the Configure dialog by clicking the ""+"" button in the top-right corner of the Properties tab. The user is then
prompted to enter the name of the property and then a value. For each FlowFile that is processed by this UpdateAttribute
Processor, an Attribute will be added for each user-defined property. The name of the Attribute will be the same as the name of
the property that was added. The value of the Attribute will be the same as the value of the property.

The value of the property may contain the Expression Language, as well. This allows Attributes to be modified or added
based on other Attributes. For example, if we want to prepend the hostname that is processing a file as well as the date to
a filename, we could do this by adding a property with the name `filename` and the value `${hostname()}-${now():format('yyyy-dd-MM')}-${filename}`.
While this may seem confusing at first, the section below on <<ExpressionLanguage>> will help to clear up what is going on
here.

In addition to always adding a defined set of Attributes, the UpdateAttribute Processor has an Advanced UI that allows the user
to configure a set of rules for which Attributes should be added when. To access this capability, in the Configure dialog's
Properties tab, click the `Advanced` button at the bottom of the dialog. This will provide a UI that is tailored specifically
to this Processor, rather than the simple Properties table that is provided for all Processors. Within this UI, the user is able
to configure a rules engine, essentially, specifying rules that must match in order to have the configured Attributes added
to the FlowFile.

=== Routing on Attributes

One of the most powerful features of NiFi is the ability to route FlowFiles based on their Attributes. The primary mechanism
for doing this is the RouteOnAttribute Processor. This Processor, like UpdateAttribute, is configured by adding user-defined properties.
Any number of properties can be added by clicking the ""+"" button in the top-right corner of the Properties tab in the
Processor's Configure dialog.

Each FlowFile's Attributes will be compared against the configured properties to determine whether or not the FlowFile meets the
specified criteria. The value of each property is expected to be an Expression Language expression and return a boolean value.
For more on the Expression Language, see the <<ExpressionLanguage>> section below.

After evaluating the Expression Language expressions provided against the FlowFile's Attributes, the Processor determines how to
route the FlowFile based on the Routing Strategy selected. The most common strategy is the ""Route to Property name"" strategy. With this
strategy selected, the Processor will expose a Relationship for each property configured. If the FlowFile's Attributes satisfy the given
expression, a copy of the FlowFile will be routed to the corresponding Relationship. For example, if we had a new property with the name
""begins-with-r"" and the value ""${filename:startsWith(\\'r')}"" then any FlowFile whose filename starts with the letter 'r' will be routed
to that Relationship. All other FlowFiles will be routed to 'unmatched'.


[[ExpressionLanguage]]
=== Expression Language / Using Attributes in Property Values

As we extract Attributes from FlowFiles' contents and add user-defined Attributes, they don't do us much good as an operator unless
we have some mechanism by which we can use them. The NiFi Expression Language allows us to access and manipulate FlowFile Attribute
values as we configure our flows. Not all Processor properties allow the Expression Language to be used, but many do. In order to
determine whether or not a property supports the Expression Language, a user can hover over the Help icon (
icon:iconInfo.png[""Help""]
) in the Properties tab of the Processor Configure dialog. This will provide a tooltip that shows a description of the property, the
default value, if any, and whether or not the property supports the Expression Language.

For properties that do support the Expression Language, it is used by adding an expression within the opening `${` tag and the closing
`}` tag. An expression can be as simple as an attribute name. For example, to reference the `uuid` Attribute, we can simply use the
value `${uuid}`. If the Attribute name begins with any character other than a letter, or if it contains a character other than
a number, a letter, a period (.), or an underscore (_), the Attribute name will need to be quoted. For example, `${My Attribute Name}`
will be invalid, but `${'My Attribute Name'}` will refer to the Attribute `My Attribute Name`.

In addition to referencing Attribute values, we can perform a number of functions and comparisons on those Attributes. For example,
if we want to check if the `filename` attribute contains the letter 'r' without paying attention to case (upper case or lower case),
we can do this by using the expression `${filename:toLower():contains('r')}`. Note here that the functions are separated by colons.
We can chain together any number of functions to build up more complex expressions. It is also important to understand here that even
though we are calling `filename:toLower()`, this does not alter the value of the `filename` Attribute in anyway but rather just gives
us a new value to work with.

We can also embed one expression within another. For example, if we wanted to compare the value of the `attr1` Attribute to
the value of the `attr2` Attribute, we can do this with the following expression: `${attr1:equals( ${attr2} )}`.

The Expression Language contains many different functions that can be used in order to perform the tasks needed for routing and manipulating
Attributes. Functions exist for parsing and manipulating strings, comparing string and numeric values, manipulating and replacing values,
and comparing values. A full explanation of the different functions available is out of scope of this document, but the
link:expression-language-guide.html[Expression Language Guide] provides far greater detail for each of the functions.

In addition, this Expression Language guide is built in to the application so that users are able to easily see which functions are available
and see their documentation while typing. When setting the value of a property that supports the Expression Language, if the cursor is within
the Expression Language start and end tags, pressing Ctrl + Space on the keyword will provide a pop-up of all of the available functions and
will provide auto-complete functionality. Clicking on or using the keyboard to navigate to one of the functions listed in the pop-up will
cause a tooltip to show, which explains what the function does, the arguments that it expects, and the return type of the function.


Working With Templates
----------------------

As we use Processors to build more and more complex dataflows in NiFi, we often will find that we string together the same sequence
of Processors to perform some task. This can become tedious and inefficient. To address this, NiFi provides a concept of Templates.
A template can be thought of as a reusable sub-flow. To create a template, follow these steps:

- Select the components to include in the template. We can select multiple components by clicking on the first component and then holding
  the Shift key while selecting additional components (to include the Connections between those components), or by holding the Shift key
	while dragging a box around the desired components on the canvas.
- Select the Create Template Icon (
	image:iconNewTemplate.png[New Template Icon]
	) from the middle toolbar at the top of the screen.
- Provide a name and optionally comments about the template.
- Click the `Create` button.

Once we have created a template, we can now use it as a building block in our flow, just as we would a Processor. To do this, we will
click and drag the Template icon from the left-most toolbar onto our canvas. We can then choose the template that we would like to add
or our canvas and click the `Add` button.

Finally, we have the ability to manage our templates by using the Template Management dialog. To access this dialog, click the Template
icon in the top-right toolbar. From here, we can see which templates exist and filter the templates to find the templates of interest.
On the right-hand side of the table is icon to Export, or Download, the template as an XML file. This can then be provided to others so
that they can use your template.

To import a template into your NiFi instance, click the `Browse` button in the top-right corner of the dialog and navigate to the file on
your computer. Then click the `Import` button. The template will now show up in your table, and you can drag it onto your canvas as you would
any other template that you have created.

There are a few important notes to remember when working with templates:

- Any properties that are identified as being Sensitive Properties (such as a password that is configured in a Processor) will not be added to the template. These sensitive properties will have to be populated each time that the template is added to the canvas.
- If a component that is included in the template references a Controller Service, the Controller Service will also be added to the template. This means that each time that the template is added to the graph, it will create a copy of the Controller Service.


Monitoring NiFi
---------------

As data flows through your dataflow in NiFi, it is important to understand how well your system is performing in order to assess if you
will require more resources and in order to assess the health of your current resources. NiFi provides a few mechanisms for monitoring
your system.

=== Status Bar

Near the top of the NiFi screen is a blue bar that is referred to as the Status Bar. It contains a few important statistics about the current
health of NiFi. The number of Active Threads can indicate how hard NiFi is currently working, and the Queued stat indicates how many FlowFiles
are currently queued across the entire flow, as well as the total size of those FlowFiles.

If the NiFi instance is in a cluster, we will also see an indicator here telling us how many nodes are in the cluster and how many are currently
connected. In this case, the number of active threads and the queue size are indicative of all the sum of all nodes that are currently connected.

=== Component Statistics

Each Processor, Process Group, and Remote Process Group on the canvas provides several statistics about how much data has been processed
by the component. These statistics provide information about how much data has been processed in the past five minutes. This is a rolling
window and allows us to see things like the number of FlowFiles that have been consumed by a Processor, as well as the number of FlowFiles
that have been emitted by the Processor.

The connections between Processors also expose the number of items that are currently queued.

It may also be valuable to see historical values for these metrics and, if clustered, how the different nodes compare to one another.
In order to see this information, we can right-click on a component and choose the `Stats` menu item. This will show us a graph that spans
the time since NiFi was started, or up to 24 hours, whichever is less. The amount of time that is shown here can be extended or reduced
by changing the configuration in the properties file.

In the top-right corner is a drop-down that allows the user to select which metric they are viewing. The graph on the bottom allows the
user to select a smaller portion of the graph to zoom in.


=== Bulletins

In addition to the statistics provided by each component, a user will want to know if any problems occur. While we could monitor the
logs for anything interesting, it is much more convenient to have notifications pop up on the screen. If a Processor logs
anything as a WARNING or ERROR, we will see a ""Bulletin Indicator"" show up in the top-left-hand corner of the Processor. This indicator
looks like a sticky note and will be shown for five minutes after the event occurs. Hovering over the bulletin provides information about
what happened so that the user does not have to sift through log messages to find it. If in a cluster, the bulletin will also indicate which
node in the cluster emitted the bulletin. We can also change the log level at which bulletins will occur in the Settings tab of the Configure
dialog for a Processor.

If the framework emits a bulletin, we will also see this bulletin indicator occur in the Status Bar at the top of the screen.
The right-most icon in the NiFi Toolbar is the Bulletin Board icon. Clicking this icon will take us to the bulletin board where
we can see all bulletins that occur across the NiFi instance and can filter based on the component, the message, etc.


Data Provenance
---------------

NiFi keeps a very granular level of detail about each piece of data that it ingests. As the data is processed through
the system and is transformed, routed, split, aggregated, and distributed to other endpoints, this information is
all stored within NiFi's Provenance Repository. In order to search and view this information, we can click the Data Provenance icon (
image:iconProvenance.png[Data Provenance, width=28]) in the top-right corner of the canvas. This will provide us a table that lists
the Provenance events that we have searched for:

image:provenance-table.png[Provenance Table]

Initially, this table is populated with the most recent 1,000 Provenance Events that have occurred (though it may take a few
seconds for the information to be processed after the events occur). From this dialog, there is a `Search` button that allows the
user to search for events that happened by a particular Processor, for a particular FlowFile by filename or UUID, or several other
fields. The `nifi.properties` file provides the ability to configure which of these properties are indexed, or made searchable.
Additionally, the properties file also allows you to choose specific FlowFile Attributes that will be indexed. As a result, you can
choose which Attributes will be important to your specific dataflows and make those Attributes searchable.

[[EventDetails]]
=== Event Details
Once we have performed our search, our table will be populated only with the events that match the search criteria. From here, we
can choose the Info icon (
image:iconDetails.png[Details Icon]
) on the left-hand side of the table to view the details of that event:

image:event-details.png[Event Details]

From here, we can see exactly when that event occurred, which FlowFile the event affected, which component (Processor, etc.) performed the event,
how long the event took, and the overall time that the data had been in NiFi when the event occurred (total latency).

The next tab provides a listing of all Attributes that existed on the FlowFile at the time that the event occurred:

image:event-attributes.png[Event Attributes]

From here, we can see all the Attributes that existed on the FlowFile when the event occurred, as well as the previous values for those
Attributes. This allows us to know which Attributes changed as a result of this event and how they changed. Additionally, in the right-hand
corner is a checkbox that allows the user to see only those Attributes that changed. This may not be particularly useful if the FlowFile has
only a handful of Attributes, but can be very helpful when a FlowFile has hundreds of Attributes.

This is very important because it allows the user to understand the exact context in which the FlowFile was processed. It is helpful
to understand 'why' the FlowFile was processed the way that it was, especially when the Processor was configured using the Expression Language.

Finally, we have the Content tab:

image:event-content.png[Event Content]

This tab provides us information about where in the Content Repository the FlowFile's content was stored. If the event modified the content
of the FlowFile, we will see the 'before' and 'after' content claims. We are then given the option to Download the content or to View the
content within NiFi itself, if the data format is one that NiFi understands how to render.

Additionally, in the Replay section of the tab, there is a 'Submit' button that allows the user to re-insert the FlowFile into the flow and re-process it from exactly the point
at which the event happened. This provides a very powerful mechanism, as we are able to modify our flow in real time, re-process a FlowFile,
and then view the results. If they are not as expected, we can modify the flow again, and re-process the FlowFile again. We are able to perform
this iterative development of the flow until it is processing the data exactly as intended.

=== Lineage Graph

In addition to viewing the details of a Provenance event, we can also view the lineage of the FlowFile involved by clicking on the Lineage Icon (
image:iconLineage.png[Lineage]
) from the table view.

This provides us with a graphical representation of exactly what happened to that piece of data as it traversed the system:

image:lineage-graph-annotated.png[Lineage Graph]

From here, we can right-click on any of the events represented and click the `View Details` menu item to see the <<EventDetails>>.
This graphical representation shows us exactly which events occurred to the data. There are a few ""special"" event types to be
aware of. If we see a JOIN, FORK, or CLONE event, we can right-click and choose to Find Parents or Expand. This allows us to
see the lineage of parent FlowFiles and children FlowFiles that were created as well.

The slider in the bottom-left corner allows us to see the time at which these events occurred. By sliding it left and right, we can
see which events introduced latency into the system so that we have a very good understanding of where in our system we may need to
provide more resources, such as the number of Concurrent Tasks for a Processor. Or it may reveal, for example, that most of the latency
was introduced by a JOIN event, in which we were waiting for more FlowFiles to join together. In either case, the ability to easily
see where this is occurring is a very powerful feature that will help users to understand how the enterprise is operating.


Where To Go For More Information
--------------------------------

The NiFi community has built up a significant amount of documentation on how to use the software. The following guides are available, in
addition to this Getting Started Guide:

- link:overview.html[Apache NiFi Overview] - Provides an overview of what Apache NiFi is, what it does, and why it was created.
- link:user-guide.html[Apache NiFi User Guide] - A fairly extensive guide that is often used more as a Reference Guide, as it has pretty
  lengthy in discussing all of the different components that comprise the application. This guide is written with the NiFi Operator as its
	audience. It provides information on each of the different components available in NiFi and explains how to use the different features
	provided by the application.
- link:administration-guide.html[Administration Guide] - A guide for setting up and administering Apache NiFi for production environments.
  This guide provides information about the different system-level settings, such as setting up clusters of NiFi and securing access to the
	web UI and data.
- link:expression-language-guide.html[Express Language Guide] - A far more exhaustive guide for understanding the Expression Language than
  is provided above. This guide is the definitive documentation for the NiFi Expression Language. It provides an introduction to the EL
	and an explanation of each function, its arguments, and return types as well as providing examples.
- link:developer-guide.html[Developer's Guide] - While not an exhaustive guide to All Things NiFi Development, this guide does provide a
  comprehensive overview of the different API's available and how they should be used. In addition, it provides Best Practices for developing
	NiFi components and common Processor idioms to help aid in understanding the logic behind many of the existing NiFi components.
- link:https://cwiki.apache.org/confluence/display/NIFI/Contributor+Guide[Contributor's Guide] - A guide for explaining how to contribute
  work back to the Apache NiFi community so that others can make use of it.

Several blog postings have also been added to the Apache NiFi blog site:
link:https://blogs.apache.org/nifi/[https://blogs.apache.org/nifi/]

In addition to the blog and guides provided here, you can browse the different
link:https://nifi.apache.org/mailing_lists.html[NiFi Mailing Lists] or send an e-mail to one of the mailing lists at
link:mailto:users@nifi.apache.org[users@nifi.apache.org] or
link:mailto:dev@nifi.apache.org[dev@nifi.apache.org].

Many of the members of the NiFi community are also available on Twitter and actively monitor for tweets that mention @apachenifi.
",12208,False,2054.588219001523,median
"/*
 * Copyright (C) 2017-2019 Intel Corporation
 *
 * SPDX-License-Identifier: MIT
 *
 */

#include ""core/unit_tests/helpers/debug_manager_state_restore.h""
#include ""runtime/command_stream/preemption.h""
#include ""runtime/gmm_helper/gmm_helper.h""
#include ""runtime/helpers/flush_stamp.h""
#include ""runtime/mem_obj/buffer.h""
#include ""runtime/memory_manager/internal_allocation_storage.h""
#include ""runtime/os_interface/linux/drm_buffer_object.h""
#include ""runtime/os_interface/linux/drm_command_stream.h""
#include ""runtime/os_interface/linux/os_context_linux.h""
#include ""runtime/os_interface/linux/os_interface.h""
#include ""runtime/os_interface/os_context.h""
#include ""test.h""
#include ""unit_tests/fixtures/device_fixture.h""
#include ""unit_tests/helpers/execution_environment_helper.h""
#include ""unit_tests/helpers/hw_parse.h""
#include ""unit_tests/mocks/linux/mock_drm_command_stream_receiver.h""
#include ""unit_tests/mocks/mock_host_ptr_manager.h""
#include ""unit_tests/mocks/mock_program.h""
#include ""unit_tests/mocks/mock_submissions_aggregator.h""
#include ""unit_tests/os_interface/linux/drm_command_stream_fixture.h""

#include ""drm/i915_drm.h""
#include ""gmock/gmock.h""

using namespace NEO;

ACTION_P(copyIoctlParam, dstValue) {
    *dstValue = *static_cast<decltype(dstValue)>(arg1);
    return 0;
};

HWTEST_TEMPLATED_F(DrmCommandStreamTest, givenFlushStampWhenWaitCalledThenWaitForSpecifiedBoHandle) {
    FlushStamp handleToWait = 123;
    drm_i915_gem_wait expectedWait = {};
    drm_i915_gem_wait calledWait = {};
    expectedWait.bo_handle = static_cast<uint32_t>(handleToWait);
    expectedWait.timeout_ns = -1;

    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_WAIT, ::testing::_))
        .Times(1)
        .WillRepeatedly(copyIoctlParam(&calledWait));

    csr->waitForFlushStamp(handleToWait);
    EXPECT_TRUE(memcmp(&expectedWait, &calledWait, sizeof(drm_i915_gem_wait)) == 0);
}

HWTEST_TEMPLATED_F(DrmCommandStreamTest, makeResident) {
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_USERPTR, ::testing::_))
        .Times(0);
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_EXECBUFFER2, ::testing::_))
        .Times(0);
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_GEM_CLOSE, ::testing::_))
        .Times(0);
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_WAIT, ::testing::_))
        .Times(0);
    DrmAllocation graphicsAllocation(GraphicsAllocation::AllocationType::UNKNOWN, nullptr, nullptr, 1024, MemoryPool::MemoryNull, 1u);
    csr->makeResident(graphicsAllocation);
}

HWTEST_TEMPLATED_F(DrmCommandStreamTest, makeResidentTwiceTheSame) {
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_USERPTR, ::testing::_))
        .Times(0);
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_EXECBUFFER2, ::testing::_))
        .Times(0);
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_GEM_CLOSE, ::testing::_))
        .Times(0);
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_WAIT, ::testing::_))
        .Times(0);

    DrmAllocation graphicsAllocation(GraphicsAllocation::AllocationType::UNKNOWN, nullptr, nullptr, 1024, MemoryPool::MemoryNull, 1u);

    csr->makeResident(graphicsAllocation);
    csr->makeResident(graphicsAllocation);
}

HWTEST_TEMPLATED_F(DrmCommandStreamTest, makeResidentSizeZero) {
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_USERPTR, ::testing::_))
        .Times(0);
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_EXECBUFFER2, ::testing::_))
        .Times(0);
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_GEM_CLOSE, ::testing::_))
        .Times(0);
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_WAIT, ::testing::_))
        .Times(0);

    DrmAllocation graphicsAllocation(GraphicsAllocation::AllocationType::UNKNOWN, nullptr, nullptr, 0, MemoryPool::MemoryNull, 1u);

    csr->makeResident(graphicsAllocation);
}

HWTEST_TEMPLATED_F(DrmCommandStreamTest, makeResidentResized) {
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_USERPTR, ::testing::_))
        .Times(0);
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_EXECBUFFER2, ::testing::_))
        .Times(0);
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_GEM_CLOSE, ::testing::_))
        .Times(0);
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_WAIT, ::testing::_))
        .Times(0);

    DrmAllocation graphicsAllocation(GraphicsAllocation::AllocationType::UNKNOWN, nullptr, nullptr, 1024, MemoryPool::MemoryNull, 1u);
    DrmAllocation graphicsAllocation2(GraphicsAllocation::AllocationType::UNKNOWN, nullptr, nullptr, 8192, MemoryPool::MemoryNull, 1u);

    csr->makeResident(graphicsAllocation);
    csr->makeResident(graphicsAllocation2);
}

// matcher to check batch buffer offset and len on execbuffer2 call
MATCHER_P2(BoExecFlushEq, batch_start_offset, batch_len, """") {
    drm_i915_gem_execbuffer2 *exec2 = (drm_i915_gem_execbuffer2 *)arg;

    return (exec2->batch_start_offset == batch_start_offset) && (exec2->batch_len == batch_len);
}

// matcher to check DrmContextId
MATCHER_P2(BoExecFlushContextEq, drmContextId, numExecs, """") {
    auto execBuff2 = reinterpret_cast<drm_i915_gem_execbuffer2 *>(arg);

    bool allExecsWithTheSameId = (execBuff2->buffer_count == numExecs);
    allExecsWithTheSameId &= (execBuff2->rsvd1 == drmContextId);

    auto execObjects = reinterpret_cast<drm_i915_gem_exec_object2 *>(execBuff2->buffers_ptr);
    for (uint32_t i = 0; i < execBuff2->buffer_count - 1; i++) {
        allExecsWithTheSameId &= (execObjects[i].rsvd1 == drmContextId);
    }

    return allExecsWithTheSameId;
}

HWTEST_TEMPLATED_F(DrmCommandStreamTest, Flush) {
    auto expectedSize = alignUp(8u, MemoryConstants::cacheLineSize); // bbEnd
    int boHandle = 123;
    auto setBoHandle = [&](unsigned long request, void *arg) {
        auto userptr = static_cast<drm_i915_gem_userptr *>(arg);
        userptr->handle = boHandle;
        return 0;
    };

    ::testing::InSequence inSequence;
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_USERPTR, ::testing::_))
        .Times(1)
        .WillRepeatedly(::testing::Invoke(setBoHandle))
        .RetiresOnSaturation();
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_EXECBUFFER2, BoExecFlushEq(0u, expectedSize)))
        .Times(1)
        .WillRepeatedly(::testing::Return(0))
        .RetiresOnSaturation();
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_WAIT, ::testing::_))
        .Times(2)
        .RetiresOnSaturation();
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_GEM_CLOSE, ::testing::_))
        .Times(1)
        .RetiresOnSaturation();

    auto &cs = csr->getCS();
    auto commandBuffer = static_cast<DrmAllocation *>(cs.getGraphicsAllocation());
    ASSERT_NE(nullptr, commandBuffer);
    ASSERT_EQ(0u, reinterpret_cast<uintptr_t>(commandBuffer->getUnderlyingBuffer()) & 0xFFF);
    EXPECT_EQ(boHandle, commandBuffer->getBO()->peekHandle());

    CommandStreamReceiverHw<FamilyType>::addBatchBufferEnd(cs, nullptr);
    CommandStreamReceiverHw<FamilyType>::alignToCacheLine(cs);
    BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 0, 0, nullptr, false, false, QueueThrottle::MEDIUM, cs.getUsed(), &cs};
    auto availableSpacePriorToFlush = cs.getAvailableSpace();
    auto flushStamp = csr->flush(batchBuffer, csr->getResidencyAllocations());
    EXPECT_EQ(static_cast<uint64_t>(boHandle), flushStamp);
    EXPECT_NE(cs.getCpuBase(), nullptr);
    EXPECT_EQ(availableSpacePriorToFlush, cs.getAvailableSpace());
}

HWTEST_TEMPLATED_F(DrmCommandStreamTest, givenDrmContextIdWhenFlushingThenSetIdToAllExecBuffersAndObjects) {
    uint32_t expectedDrmContextId = 321;
    uint32_t numAllocations = 3;

    auto createdContextId = [&expectedDrmContextId](unsigned long request, void *arg) {
        auto contextCreate = static_cast<drm_i915_gem_context_create *>(arg);
        contextCreate->ctx_id = expectedDrmContextId;
        return 0;
    };

    auto allocation1 = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize});
    auto allocation2 = memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize});
    csr->makeResident(*allocation1);
    csr->makeResident(*allocation2);

    EXPECT_CALL(*mock, ioctl(::testing::_, ::testing::_)).WillRepeatedly(::testing::Return(0)).RetiresOnSaturation();

    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_CONTEXT_CREATE, ::testing::_))
        .Times(1)
        .WillRepeatedly(::testing::Invoke(createdContextId))
        .RetiresOnSaturation();

    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_EXECBUFFER2, BoExecFlushContextEq(expectedDrmContextId, numAllocations)))
        .Times(1)
        .WillRepeatedly(::testing::Return(0))
        .RetiresOnSaturation();

    osContext = std::make_unique<OsContextLinux>(*mock, 1, 1,
                                                 HwHelper::get(platformDevices[0]->platform.eRenderCoreFamily).getGpgpuEngineInstances()[0],
                                                 PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]), false);
    csr->setupContext(*osContext);

    auto &cs = csr->getCS();

    CommandStreamReceiverHw<FamilyType>::addBatchBufferEnd(cs, nullptr);
    CommandStreamReceiverHw<FamilyType>::alignToCacheLine(cs);
    BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 0, 0, nullptr, false, false, QueueThrottle::MEDIUM, cs.getUsed(), &cs};
    csr->flush(batchBuffer, csr->getResidencyAllocations());

    memoryManager->freeGraphicsMemory(allocation1);
    memoryManager->freeGraphicsMemory(allocation2);
}

HWTEST_TEMPLATED_F(DrmCommandStreamTest, FlushWithLowPriorityContext) {
    auto expectedSize = alignUp(8u, MemoryConstants::cacheLineSize); // bbEnd

    ::testing::InSequence inSequence;

    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_USERPTR, ::testing::_))
        .Times(1)
        .WillRepeatedly(::testing::Return(0))
        .RetiresOnSaturation();
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_EXECBUFFER2, BoExecFlushEq(0u, expectedSize)))
        .Times(1)
        .WillRepeatedly(::testing::Return(0))
        .RetiresOnSaturation();
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_WAIT, ::testing::_))
        .Times(2)
        .RetiresOnSaturation();
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_GEM_CLOSE, ::testing::_))
        .Times(1)
        .RetiresOnSaturation();

    auto &cs = csr->getCS();
    auto commandBuffer = static_cast<DrmAllocation *>(cs.getGraphicsAllocation());

    ASSERT_NE(nullptr, commandBuffer);
    ASSERT_EQ(0u, reinterpret_cast<uintptr_t>(commandBuffer->getUnderlyingBuffer()) & 0xFFF);

    CommandStreamReceiverHw<FamilyType>::addBatchBufferEnd(cs, nullptr);
    CommandStreamReceiverHw<FamilyType>::alignToCacheLine(cs);
    BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 0, 0, nullptr, false, true, QueueThrottle::MEDIUM, cs.getUsed(), &cs};
    csr->flush(batchBuffer, csr->getResidencyAllocations());
    EXPECT_NE(cs.getCpuBase(), nullptr);
}

HWTEST_TEMPLATED_F(DrmCommandStreamTest, FlushInvalidAddress) {
    ::testing::InSequence inSequence;

    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_USERPTR, ::testing::_))
        .Times(0)
        .RetiresOnSaturation();
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_EXECBUFFER2, BoExecFlushEq(0u, 8u)))
        .Times(0)
        .RetiresOnSaturation();
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_WAIT, ::testing::_))
        .Times(0)
        .RetiresOnSaturation();
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_GEM_CLOSE, ::testing::_))
        .Times(0)
        .RetiresOnSaturation();

    //allocate command buffer manually
    char *commandBuffer = new (std::nothrow) char[1024];
    ASSERT_NE(nullptr, commandBuffer);
    DrmAllocation commandBufferAllocation(GraphicsAllocation::AllocationType::COMMAND_BUFFER, nullptr, commandBuffer, 1024, MemoryPool::MemoryNull, 1u);
    LinearStream cs(&commandBufferAllocation);

    CommandStreamReceiverHw<FamilyType>::addBatchBufferEnd(cs, nullptr);
    CommandStreamReceiverHw<FamilyType>::alignToCacheLine(cs);
    BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 0, 0, nullptr, false, false, QueueThrottle::MEDIUM, cs.getUsed(), &cs};
    csr->flush(batchBuffer, csr->getResidencyAllocations());
    delete[] commandBuffer;
}

HWTEST_TEMPLATED_F(DrmCommandStreamTest, FlushNotEmptyBB) {
    uint32_t bbUsed = 16 * sizeof(uint32_t);
    auto expectedSize = alignUp(bbUsed + 8, MemoryConstants::cacheLineSize); // bbUsed + bbEnd

    ::testing::InSequence inSequence;

    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_USERPTR, ::testing::_))
        .Times(1)
        .WillRepeatedly(::testing::Return(0))
        .RetiresOnSaturation();
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_EXECBUFFER2, BoExecFlushEq(0u, expectedSize)))
        .Times(1)
        .WillRepeatedly(::testing::Return(0))
        .RetiresOnSaturation();
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_WAIT, ::testing::_))
        .Times(2)
        .RetiresOnSaturation();
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_GEM_CLOSE, ::testing::_))
        .Times(1)
        .RetiresOnSaturation();

    auto &cs = csr->getCS();
    cs.getSpace(bbUsed);

    CommandStreamReceiverHw<FamilyType>::addBatchBufferEnd(cs, nullptr);
    CommandStreamReceiverHw<FamilyType>::alignToCacheLine(cs);
    BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 0, 0, nullptr, false, false, QueueThrottle::MEDIUM, cs.getUsed(), &cs};
    csr->flush(batchBuffer, csr->getResidencyAllocations());
}

HWTEST_TEMPLATED_F(DrmCommandStreamTest, FlushNotEmptyNotPaddedBB) {
    uint32_t bbUsed = 15 * sizeof(uint32_t);

    ::testing::InSequence inSequence;

    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_USERPTR, ::testing::_))
        .Times(1)
        .WillRepeatedly(::testing::Return(0))
        .RetiresOnSaturation();
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_EXECBUFFER2, BoExecFlushEq(0u, bbUsed + 4)))
        .Times(1)
        .WillRepeatedly(::testing::Return(0))
        .RetiresOnSaturation();
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_WAIT, ::testing::_))
        .Times(2)
        .RetiresOnSaturation();
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_GEM_CLOSE, ::testing::_))
        .Times(1)
        .RetiresOnSaturation();

    auto &cs = csr->getCS();
    cs.getSpace(bbUsed);

    CommandStreamReceiverHw<FamilyType>::addBatchBufferEnd(cs, nullptr);
    CommandStreamReceiverHw<FamilyType>::alignToCacheLine(cs);
    BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 0, 0, nullptr, false, false, QueueThrottle::MEDIUM, cs.getUsed(), &cs};
    csr->flush(batchBuffer, csr->getResidencyAllocations());
}

HWTEST_TEMPLATED_F(DrmCommandStreamTest, FlushNotAligned) {
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_USERPTR, ::testing::_))
        .Times(1)
        .WillRepeatedly(::testing::Return(0));

    auto &cs = csr->getCS();
    auto commandBuffer = static_cast<DrmAllocation *>(cs.getGraphicsAllocation());

    //make sure command buffer with offset is not page aligned
    ASSERT_NE(0u, (reinterpret_cast<uintptr_t>(commandBuffer->getUnderlyingBuffer()) + 4) & (this->alignment - 1));
    ASSERT_EQ(4u, (reinterpret_cast<uintptr_t>(commandBuffer->getUnderlyingBuffer()) + 4) & 0x7F);

    auto expectedSize = alignUp(8u, MemoryConstants::cacheLineSize); // bbEnd

    EXPECT_CALL(*mock, ioctl(
                           DRM_IOCTL_I915_GEM_EXECBUFFER2,
                           BoExecFlushEq((reinterpret_cast<uintptr_t>(commandBuffer->getUnderlyingBuffer()) + 4) & (this->alignment - 1), expectedSize)))
        .Times(1)
        .WillRepeatedly(::testing::Return(0));
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_GEM_CLOSE, ::testing::_))
        .Times(1);
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_WAIT, ::testing::_))
        .Times(2);

    CommandStreamReceiverHw<FamilyType>::addBatchBufferEnd(cs, nullptr);
    CommandStreamReceiverHw<FamilyType>::alignToCacheLine(cs);

    BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 4, 0, nullptr, false, false, QueueThrottle::MEDIUM, cs.getUsed(), &cs};
    csr->flush(batchBuffer, csr->getResidencyAllocations());
}

ACTION_P(UserptrSetHandle, _set_handle) {
    struct drm_i915_gem_userptr *userptr = reinterpret_cast<drm_i915_gem_userptr *>(arg1);
    userptr->handle = _set_handle;
}

MATCHER_P(GemCloseEq, handle, """") {
    drm_gem_close *gemClose = (drm_gem_close *)arg;

    return (gemClose->handle == handle);
}

MATCHER(BoExecFlushCheckFlags, """") {
    drm_i915_gem_execbuffer2 *exec2 = (drm_i915_gem_execbuffer2 *)arg;
    drm_i915_gem_exec_object2 *exec_objects = (drm_i915_gem_exec_object2 *)exec2->buffers_ptr;

    for (unsigned int i = 0; i < exec2->buffer_count; i++) {
        EXPECT_TRUE(exec_objects[i].flags == (EXEC_OBJECT_PINNED | EXEC_OBJECT_SUPPORTS_48B_ADDRESS));
    }

    return true;
}

HWTEST_TEMPLATED_F(DrmCommandStreamTest, FlushCheckFlags) {
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_USERPTR, ::testing::_))
        .WillRepeatedly(::testing::Return(0));
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_GEM_CLOSE, ::testing::_))
        .WillRepeatedly(::testing::Return(0));
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_WAIT, ::testing::_))
        .WillRepeatedly(::testing::Return(0));

    auto &cs = csr->getCS();

    EXPECT_CALL(*mock, ioctl(
                           DRM_IOCTL_I915_GEM_EXECBUFFER2,
                           BoExecFlushCheckFlags()))
        .Times(1)
        .WillRepeatedly(::testing::Return(0));

    DrmAllocation allocation(GraphicsAllocation::AllocationType::UNKNOWN, nullptr, (void *)0x7FFFFFFF, 1024, MemoryPool::MemoryNull, 1u);
    DrmAllocation allocation2(GraphicsAllocation::AllocationType::UNKNOWN, nullptr, (void *)0x307FFFFFFF, 1024, MemoryPool::MemoryNull, 1u);
    csr->makeResident(allocation);
    csr->makeResident(allocation2);
    CommandStreamReceiverHw<FamilyType>::addBatchBufferEnd(cs, nullptr);
    CommandStreamReceiverHw<FamilyType>::alignToCacheLine(cs);
    BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 0, 0, nullptr, false, false, QueueThrottle::MEDIUM, cs.getUsed(), &cs};
    csr->flush(batchBuffer, csr->getResidencyAllocations());
}

HWTEST_TEMPLATED_F(DrmCommandStreamTest, CheckDrmFree) {
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_USERPTR, ::testing::_))
        .Times(1)
        .WillOnce(::testing::DoAll(UserptrSetHandle(17), ::testing::Return(0)));

    auto &cs = csr->getCS();
    auto commandBuffer = static_cast<DrmAllocation *>(cs.getGraphicsAllocation());

    //make sure command buffer with offset is not page aligned
    ASSERT_NE(0u, (reinterpret_cast<uintptr_t>(commandBuffer->getUnderlyingBuffer()) + 4) & (this->alignment - 1));
    ASSERT_EQ(4u, (reinterpret_cast<uintptr_t>(commandBuffer->getUnderlyingBuffer()) + 4) & 0x7F);

    auto expectedSize = alignUp(8u, MemoryConstants::cacheLineSize); // bbEnd

    EXPECT_CALL(*mock, ioctl(
                           DRM_IOCTL_I915_GEM_EXECBUFFER2,
                           BoExecFlushEq((reinterpret_cast<uintptr_t>(commandBuffer->getUnderlyingBuffer()) + 4) & (this->alignment - 1), expectedSize)))
        .Times(1)
        .WillRepeatedly(::testing::Return(0));
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_GEM_CLOSE, GemCloseEq(17u)))
        .Times(1);
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_WAIT, ::testing::_))
        .Times(2);

    DrmAllocation allocation(GraphicsAllocation::AllocationType::UNKNOWN, nullptr, nullptr, 1024, MemoryPool::MemoryNull, 1u);

    csr->makeResident(allocation);
    CommandStreamReceiverHw<FamilyType>::addBatchBufferEnd(cs, nullptr);
    CommandStreamReceiverHw<FamilyType>::alignToCacheLine(cs);
    BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 4, 0, nullptr, false, false, QueueThrottle::MEDIUM, cs.getUsed(), &cs};
    csr->flush(batchBuffer, csr->getResidencyAllocations());
}

HWTEST_TEMPLATED_F(DrmCommandStreamTest, GIVENCSRWHENgetDMTHENNotNull) {
    Drm *pDrm = nullptr;
    if (csr->getOSInterface()) {
        pDrm = csr->getOSInterface()->get()->getDrm();
    }
    ASSERT_NE(nullptr, pDrm);
}

HWTEST_TEMPLATED_F(DrmCommandStreamTest, CheckDrmFreeCloseFailed) {
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_USERPTR, ::testing::_))
        .Times(1)
        .WillOnce(::testing::DoAll(UserptrSetHandle(17), ::testing::Return(0)));

    auto &cs = csr->getCS();
    auto commandBuffer = static_cast<DrmAllocation *>(cs.getGraphicsAllocation());

    //make sure command buffer with offset is not page aligned
    ASSERT_NE(0u, (reinterpret_cast<uintptr_t>(commandBuffer->getUnderlyingBuffer()) + 4) & (this->alignment - 1));
    ASSERT_EQ(4u, (reinterpret_cast<uintptr_t>(commandBuffer->getUnderlyingBuffer()) + 4) & 0x7F);

    auto expectedSize = alignUp(8u, MemoryConstants::cacheLineSize); // bbEnd

    EXPECT_CALL(*mock, ioctl(
                           DRM_IOCTL_I915_GEM_EXECBUFFER2,
                           BoExecFlushEq((reinterpret_cast<uintptr_t>(commandBuffer->getUnderlyingBuffer()) + 4) & (this->alignment - 1), expectedSize)))
        .Times(1)
        .WillRepeatedly(::testing::Return(0));
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_GEM_CLOSE, GemCloseEq(17u)))
        .Times(1)
        .WillOnce(::testing::Return(-1));
    EXPECT_CALL(*mock, ioctl(DRM_IOCTL_I915_GEM_WAIT, ::testing::_))
        .Times(2);
    DrmAllocation allocation(GraphicsAllocation::AllocationType::UNKNOWN, nullptr, nullptr, 1024, MemoryPool::MemoryNull, 1u);

    csr->makeResident(allocation);
    CommandStreamReceiverHw<FamilyType>::addBatchBufferEnd(cs, nullptr);
    CommandStreamReceiverHw<FamilyType>::alignToCacheLine(cs);
    BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 4, 0, nullptr, false, false, QueueThrottle::MEDIUM, cs.getUsed(), &cs};
    csr->flush(batchBuffer, csr->getResidencyAllocations());
}

HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTest, givenDefaultDrmCSRWhenItIsCreatedThenGemCloseWorkerModeIsInactive) {
    EXPECT_EQ(gemCloseWorkerMode::gemCloseWorkerInactive, static_cast<const DrmCommandStreamReceiver<FamilyType> *>(csr)->peekGemCloseWorkerOperationMode());
}

HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTest, givenCommandStreamWhenItIsFlushedWithGemCloseWorkerInDefaultModeThenWorkerDecreasesTheRefCount) {
    auto commandBuffer = mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize});
    ASSERT_NE(nullptr, commandBuffer);
    LinearStream cs(commandBuffer);

    CommandStreamReceiverHw<FamilyType>::addBatchBufferEnd(cs, nullptr);
    CommandStreamReceiverHw<FamilyType>::alignToCacheLine(cs);
    auto storedBase = cs.getCpuBase();
    auto storedGraphicsAllocation = cs.getGraphicsAllocation();
    BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 0, 0, nullptr, false, false, QueueThrottle::MEDIUM, cs.getUsed(), &cs};
    csr->flush(batchBuffer, csr->getResidencyAllocations());
    EXPECT_EQ(cs.getCpuBase(), storedBase);
    EXPECT_EQ(cs.getGraphicsAllocation(), storedGraphicsAllocation);

    auto drmAllocation = static_cast<DrmAllocation *>(storedGraphicsAllocation);
    auto bo = drmAllocation->getBO();

    //spin until gem close worker finishes execution
    while (bo->getRefCount() > 1)
        ;

    mm->freeGraphicsMemory(commandBuffer);
}

HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTest, givenTaskThatRequiresLargeResourceCountWhenItIsFlushedThenExecStorageIsResized) {
    std::vector<GraphicsAllocation *> graphicsAllocations;

    auto &execStorage = static_cast<TestedDrmCommandStreamReceiver<FamilyType> *>(csr)->getExecStorage();
    execStorage.resize(0);

    for (auto id = 0; id < 10; id++) {
        auto graphicsAllocation = mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize});
        csr->makeResident(*graphicsAllocation);
        graphicsAllocations.push_back(graphicsAllocation);
    }
    auto commandBuffer = mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize});

    LinearStream cs(commandBuffer);

    CommandStreamReceiverHw<FamilyType>::addBatchBufferEnd(cs, nullptr);
    CommandStreamReceiverHw<FamilyType>::alignToCacheLine(cs);
    BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 0, 0, nullptr, false, false, QueueThrottle::MEDIUM, cs.getUsed(), &cs};
    csr->flush(batchBuffer, csr->getResidencyAllocations());

    EXPECT_EQ(11u, this->mock->execBuffer.buffer_count);
    mm->freeGraphicsMemory(commandBuffer);
    for (auto graphicsAllocation : graphicsAllocations) {
        mm->freeGraphicsMemory(graphicsAllocation);
    }
    EXPECT_EQ(11u, execStorage.size());
}

HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTest, givenGemCloseWorkerInactiveModeWhenMakeResidentIsCalledThenRefCountsAreNotUpdated) {
    auto dummyAllocation = static_cast<DrmAllocation *>(mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize}));

    auto bo = dummyAllocation->getBO();
    EXPECT_EQ(1u, bo->getRefCount());

    csr->makeResident(*dummyAllocation);
    EXPECT_EQ(1u, bo->getRefCount());

    csr->processResidency(csr->getResidencyAllocations());

    csr->makeNonResident(*dummyAllocation);
    EXPECT_EQ(1u, bo->getRefCount());

    mm->freeGraphicsMemory(dummyAllocation);
}

HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTest, GivenTwoAllocationsWhenBackingStorageIsDifferentThenMakeResidentShouldAddTwoLocations) {
    auto allocation = static_cast<DrmAllocation *>(mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize}));
    auto allocation2 = static_cast<DrmAllocation *>(mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize}));

    csr->makeResident(*allocation);
    csr->makeResident(*allocation2);

    auto osContextId = csr->getOsContext().getContextId();

    EXPECT_TRUE(allocation->isResident(osContextId));
    EXPECT_TRUE(allocation2->isResident(osContextId));

    csr->processResidency(csr->getResidencyAllocations());

    EXPECT_TRUE(allocation->isResident(osContextId));
    EXPECT_TRUE(allocation2->isResident(osContextId));

    EXPECT_EQ(getResidencyVector<FamilyType>().size(), 2u);

    csr->makeNonResident(*allocation);
    csr->makeNonResident(*allocation2);

    EXPECT_FALSE(allocation->isResident(osContextId));
    EXPECT_FALSE(allocation2->isResident(osContextId));

    EXPECT_EQ(getResidencyVector<FamilyType>().size(), 0u);
    mm->freeGraphicsMemory(allocation);
    mm->freeGraphicsMemory(allocation2);
}

HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTest, givenCommandStreamWithDuplicatesWhenItIsFlushedWithGemCloseWorkerInactiveModeThenCsIsNotNulled) {
    auto commandBuffer = static_cast<DrmAllocation *>(mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize}));
    auto dummyAllocation = static_cast<DrmAllocation *>(mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize}));
    ASSERT_NE(nullptr, commandBuffer);
    ASSERT_EQ(0u, reinterpret_cast<uintptr_t>(commandBuffer->getUnderlyingBuffer()) & 0xFFF);
    LinearStream cs(commandBuffer);

    csr->makeResident(*dummyAllocation);
    csr->makeResident(*dummyAllocation);

    CommandStreamReceiverHw<FamilyType>::addBatchBufferEnd(cs, nullptr);
    CommandStreamReceiverHw<FamilyType>::alignToCacheLine(cs);
    auto storedBase = cs.getCpuBase();
    auto storedGraphicsAllocation = cs.getGraphicsAllocation();
    BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 0, 0, nullptr, false, false, QueueThrottle::MEDIUM, cs.getUsed(), &cs};
    csr->flush(batchBuffer, csr->getResidencyAllocations());
    EXPECT_EQ(cs.getCpuBase(), storedBase);
    EXPECT_EQ(cs.getGraphicsAllocation(), storedGraphicsAllocation);

    mm->freeGraphicsMemory(dummyAllocation);
    mm->freeGraphicsMemory(commandBuffer);
}

HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTest, givenDrmCsrCreatedWithInactiveGemCloseWorkerPolicyThenThreadIsNotCreated) {
    this->executionEnvironment->osInterface = std::make_unique<OSInterface>();
    this->executionEnvironment->osInterface->get()->setDrm(mock.get());
    TestedDrmCommandStreamReceiver<FamilyType> testedCsr(gemCloseWorkerMode::gemCloseWorkerInactive,
                                                         *this->executionEnvironment);
    EXPECT_EQ(gemCloseWorkerMode::gemCloseWorkerInactive, testedCsr.peekGemCloseWorkerOperationMode());
}

class DrmCommandStreamBatchingTests : public DrmCommandStreamEnhancedTest {
  public:
    DrmAllocation *tagAllocation;
    DrmAllocation *preemptionAllocation;
    GraphicsAllocation *tmpAllocation;

    template <typename GfxFamily>
    void SetUpT() {
        DrmCommandStreamEnhancedTest::SetUpT<GfxFamily>();
        if (PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]) == PreemptionMode::MidThread) {
            tmpAllocation = GlobalMockSipProgram::sipProgram->getAllocation();
            GlobalMockSipProgram::sipProgram->resetAllocation(device->getMemoryManager()->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize}));
        }
        tagAllocation = static_cast<DrmAllocation *>(device->getDefaultEngine().commandStreamReceiver->getTagAllocation());
        preemptionAllocation = static_cast<DrmAllocation *>(device->getDefaultEngine().commandStreamReceiver->getPreemptionAllocation());
    }

    template <typename GfxFamily>
    void TearDownT() {
        if (PreemptionHelper::getDefaultPreemptionMode(*platformDevices[0]) == PreemptionMode::MidThread) {
            device->getMemoryManager()->freeGraphicsMemory((GlobalMockSipProgram::sipProgram)->getAllocation());
            GlobalMockSipProgram::sipProgram->resetAllocation(tmpAllocation);
        }
        DrmCommandStreamEnhancedTest::TearDownT<GfxFamily>();
    }
};

HWTEST_TEMPLATED_F(DrmCommandStreamBatchingTests, givenCSRWhenFlushIsCalledThenProperFlagsArePassed) {
    mock->reset();
    auto commandBuffer = mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize});
    auto dummyAllocation = mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize});
    ASSERT_NE(nullptr, commandBuffer);
    ASSERT_EQ(0u, reinterpret_cast<uintptr_t>(commandBuffer->getUnderlyingBuffer()) & 0xFFF);
    LinearStream cs(commandBuffer);

    csr->makeResident(*dummyAllocation);
    CommandStreamReceiverHw<FamilyType>::addBatchBufferEnd(cs, nullptr);
    CommandStreamReceiverHw<FamilyType>::alignToCacheLine(cs);

    BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 0, 0, nullptr, false, false, QueueThrottle::MEDIUM, cs.getUsed(), &cs};
    csr->flush(batchBuffer, csr->getResidencyAllocations());

    int ioctlExecCnt = 1;
    int ioctlUserPtrCnt = 2;

    auto engineFlag = static_cast<OsContextLinux &>(csr->getOsContext()).getEngineFlag();

    EXPECT_EQ(ioctlExecCnt + ioctlUserPtrCnt, this->mock->ioctl_cnt.total);
    EXPECT_EQ(ioctlExecCnt, this->mock->ioctl_cnt.execbuffer2);
    EXPECT_EQ(ioctlUserPtrCnt, this->mock->ioctl_cnt.gemUserptr);
    uint64_t flags = engineFlag | I915_EXEC_NO_RELOC;
    EXPECT_EQ(flags, this->mock->execBuffer.flags);

    mm->freeGraphicsMemory(dummyAllocation);
    mm->freeGraphicsMemory(commandBuffer);
}

HWTEST_TEMPLATED_F(DrmCommandStreamBatchingTests, givenCsrWhenDispatchPolicyIsSetToBatchingThenCommandBufferIsNotSubmitted) {
    mock->reset();
    csr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);

    auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
    static_cast<TestedDrmCommandStreamReceiver<FamilyType> *>(csr)->overrideSubmissionAggregator(mockedSubmissionsAggregator);

    auto commandBuffer = mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize});
    auto dummyAllocation = mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize});
    ASSERT_NE(nullptr, commandBuffer);
    ASSERT_EQ(0u, reinterpret_cast<uintptr_t>(commandBuffer->getUnderlyingBuffer()) & 0xFFF);
    IndirectHeap cs(commandBuffer);

    csr->makeResident(*dummyAllocation);

    csr->setTagAllocation(tagAllocation);
    DispatchFlags dispatchFlags;
    dispatchFlags.preemptionMode = PreemptionHelper::getDefaultPreemptionMode(device->getHardwareInfo());
    csr->flushTask(cs, 0u, cs, cs, cs, 0u, dispatchFlags, *device);

    //make sure command buffer is recorded
    auto &cmdBuffers = mockedSubmissionsAggregator->peekCommandBuffers();
    EXPECT_FALSE(cmdBuffers.peekIsEmpty());
    EXPECT_NE(nullptr, cmdBuffers.peekHead());

    //preemption allocation
    size_t csrSurfaceCount = (device->getPreemptionMode() == PreemptionMode::MidThread) ? 2 : 0;

    auto recordedCmdBuffer = cmdBuffers.peekHead();
    EXPECT_EQ(3u + csrSurfaceCount, recordedCmdBuffer->surfaces.size());

    //try to find all allocations
    auto elementInVector = std::find(recordedCmdBuffer->surfaces.begin(), recordedCmdBuffer->surfaces.end(), dummyAllocation);
    EXPECT_NE(elementInVector, recordedCmdBuffer->surfaces.end());

    elementInVector = std::find(recordedCmdBuffer->surfaces.begin(), recordedCmdBuffer->surfaces.end(), commandBuffer);
    EXPECT_NE(elementInVector, recordedCmdBuffer->surfaces.end());

    elementInVector = std::find(recordedCmdBuffer->surfaces.begin(), recordedCmdBuffer->surfaces.end(), tagAllocation);
    EXPECT_NE(elementInVector, recordedCmdBuffer->surfaces.end());

    EXPECT_EQ(static_cast<TestedDrmCommandStreamReceiver<FamilyType> *>(csr)->commandStream.getGraphicsAllocation(), recordedCmdBuffer->batchBuffer.commandBufferAllocation);

    int ioctlUserPtrCnt = 3;

    EXPECT_EQ(ioctlUserPtrCnt, this->mock->ioctl_cnt.total);
    EXPECT_EQ(ioctlUserPtrCnt, this->mock->ioctl_cnt.gemUserptr);

    EXPECT_EQ(0u, this->mock->execBuffer.flags);

    csr->flushBatchedSubmissions();

    mm->freeGraphicsMemory(dummyAllocation);
    mm->freeGraphicsMemory(commandBuffer);
}

HWTEST_TEMPLATED_F(DrmCommandStreamBatchingTests, givenRecordedCommandBufferWhenItIsSubmittedThenFlushTaskIsProperlyCalled) {
    mock->reset();
    csr->overrideDispatchPolicy(DispatchMode::BatchedDispatch);

    auto mockedSubmissionsAggregator = new mockSubmissionsAggregator();
    static_cast<TestedDrmCommandStreamReceiver<FamilyType> *>(csr)->overrideSubmissionAggregator(mockedSubmissionsAggregator);

    auto commandBuffer = mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize});
    IndirectHeap cs(commandBuffer);

    csr->setTagAllocation(tagAllocation);
    auto &submittedCommandBuffer = csr->getCS(1024);
    //use some bytes
    submittedCommandBuffer.getSpace(4);

    DispatchFlags dispatchFlags;
    dispatchFlags.guardCommandBufferWithPipeControl = true;
    dispatchFlags.preemptionMode = PreemptionHelper::getDefaultPreemptionMode(device->getHardwareInfo());
    csr->flushTask(cs, 0u, cs, cs, cs, 0u, dispatchFlags, *device);

    auto &cmdBuffers = mockedSubmissionsAggregator->peekCommandBuffers();
    auto storedCommandBuffer = cmdBuffers.peekHead();

    ResidencyContainer copyOfResidency = storedCommandBuffer->surfaces;
    copyOfResidency.push_back(storedCommandBuffer->batchBuffer.commandBufferAllocation);

    csr->flushBatchedSubmissions();

    EXPECT_TRUE(cmdBuffers.peekIsEmpty());

    auto commandBufferGraphicsAllocation = submittedCommandBuffer.getGraphicsAllocation();
    EXPECT_FALSE(commandBufferGraphicsAllocation->isResident(csr->getOsContext().getContextId()));

    //preemption allocation
    size_t csrSurfaceCount = (device->getPreemptionMode() == PreemptionMode::MidThread) ? 2 : 0;

    //validate that submited command buffer has what we want
    EXPECT_EQ(3u + csrSurfaceCount, this->mock->execBuffer.buffer_count);
    EXPECT_EQ(4u, this->mock->execBuffer.batch_start_offset);
    EXPECT_EQ(submittedCommandBuffer.getUsed(), this->mock->execBuffer.batch_len);

    drm_i915_gem_exec_object2 *exec_objects = (drm_i915_gem_exec_object2 *)this->mock->execBuffer.buffers_ptr;

    for (unsigned int i = 0; i < this->mock->execBuffer.buffer_count; i++) {
        int handle = exec_objects[i].handle;

        auto handleFound = false;
        for (auto &graphicsAllocation : copyOfResidency) {
            auto bo = static_cast<DrmAllocation *>(graphicsAllocation)->getBO();
            if (bo->peekHandle() == handle) {
                handleFound = true;
            }
        }
        EXPECT_TRUE(handleFound);
    }

    int ioctlExecCnt = 1;
    int ioctlUserPtrCnt = 2;
    EXPECT_EQ(ioctlExecCnt, this->mock->ioctl_cnt.execbuffer2);
    EXPECT_EQ(ioctlUserPtrCnt, this->mock->ioctl_cnt.gemUserptr);
    EXPECT_EQ(ioctlExecCnt + ioctlUserPtrCnt, this->mock->ioctl_cnt.total);

    mm->freeGraphicsMemory(commandBuffer);
}

HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTest, givenDrmAllocationWhenGetBufferObjectToModifyIsCalledForAGivenHandleIdThenTheCorrespondingBufferObjectGetsModified) {
    auto size = 1024u;
    auto allocation = new DrmAllocation(GraphicsAllocation::AllocationType::UNKNOWN, nullptr, nullptr, size, MemoryPool::MemoryNull, 1u);

    auto &bos = allocation->getBOs();
    for (auto handleId = 0u; handleId < maxHandleCount; handleId++) {
        EXPECT_EQ(nullptr, bos[handleId]);
    }

    for (auto handleId = 0u; handleId < maxHandleCount; handleId++) {
        allocation->getBufferObjectToModify(handleId) = this->createBO(size);
    }

    for (auto handleId = 0u; handleId < maxHandleCount; handleId++) {
        EXPECT_NE(nullptr, bos[handleId]);
    }

    mm->freeGraphicsMemory(allocation);
}

HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTest, makeResident) {
    auto buffer = this->createBO(1024);
    auto allocation = new DrmAllocation(GraphicsAllocation::AllocationType::UNKNOWN, buffer, nullptr, buffer->peekSize(), MemoryPool::MemoryNull, 1u);
    EXPECT_EQ(nullptr, allocation->getUnderlyingBuffer());

    csr->makeResident(*allocation);
    csr->processResidency(csr->getResidencyAllocations());

    EXPECT_TRUE(isResident<FamilyType>(buffer));
    EXPECT_EQ(1u, buffer->getRefCount());

    csr->makeNonResident(*allocation);
    EXPECT_FALSE(isResident<FamilyType>(buffer));
    EXPECT_EQ(1u, buffer->getRefCount());
    mm->freeGraphicsMemory(allocation);
}

HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTest, makeResidentOnly) {
    BufferObject *buffer1 = this->createBO(4096);
    BufferObject *buffer2 = this->createBO(4096);
    auto allocation1 = new DrmAllocation(GraphicsAllocation::AllocationType::UNKNOWN, buffer1, nullptr, buffer1->peekSize(), MemoryPool::MemoryNull, 1u);
    auto allocation2 = new DrmAllocation(GraphicsAllocation::AllocationType::UNKNOWN, buffer2, nullptr, buffer2->peekSize(), MemoryPool::MemoryNull, 1u);
    EXPECT_EQ(nullptr, allocation1->getUnderlyingBuffer());
    EXPECT_EQ(nullptr, allocation2->getUnderlyingBuffer());

    csr->makeResident(*allocation1);
    csr->makeResident(*allocation2);
    csr->processResidency(csr->getResidencyAllocations());

    EXPECT_TRUE(isResident<FamilyType>(buffer1));
    EXPECT_TRUE(isResident<FamilyType>(buffer2));
    EXPECT_EQ(1u, buffer1->getRefCount());
    EXPECT_EQ(1u, buffer2->getRefCount());

    // dont call makeNonResident on allocation2, any other makeNonResident call will clean this
    // we want to keep all makeResident calls before flush and makeNonResident everyting after flush
    csr->makeNonResident(*allocation1);

    mm->freeGraphicsMemory(allocation1);
    mm->freeGraphicsMemory(allocation2);
}

HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTest, makeResidentTwice) {
    auto buffer = this->createBO(1024);
    auto allocation = new DrmAllocation(GraphicsAllocation::AllocationType::UNKNOWN, buffer, nullptr, buffer->peekSize(), MemoryPool::MemoryNull, 1u);

    csr->makeResident(*allocation);
    csr->processResidency(csr->getResidencyAllocations());

    EXPECT_TRUE(isResident<FamilyType>(buffer));
    EXPECT_EQ(1u, buffer->getRefCount());

    csr->getResidencyAllocations().clear();
    csr->makeResident(*allocation);
    csr->processResidency(csr->getResidencyAllocations());

    EXPECT_TRUE(isResident<FamilyType>(buffer));
    EXPECT_EQ(1u, buffer->getRefCount());

    csr->makeNonResident(*allocation);
    EXPECT_FALSE(isResident<FamilyType>(buffer));
    EXPECT_EQ(1u, buffer->getRefCount());
    mm->freeGraphicsMemory(allocation);
}

HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTest, makeResidentTwiceWhenFragmentStorage) {
    auto ptr = (void *)0x1001;
    auto size = MemoryConstants::pageSize * 10;
    auto reqs = MockHostPtrManager::getAllocationRequirements(ptr, size);
    auto allocation = mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{false, size}, ptr);

    ASSERT_EQ(3u, allocation->fragmentsStorage.fragmentCount);

    csr->makeResident(*allocation);
    csr->makeResident(*allocation);

    csr->processResidency(csr->getResidencyAllocations());
    for (int i = 0; i < maxFragmentsCount; i++) {
        ASSERT_EQ(allocation->fragmentsStorage.fragmentStorageData[i].cpuPtr,
                  reqs.allocationFragments[i].allocationPtr);
        auto bo = allocation->fragmentsStorage.fragmentStorageData[i].osHandleStorage->bo;
        EXPECT_TRUE(isResident<FamilyType>(bo));
        EXPECT_EQ(1u, bo->getRefCount());
    }

    csr->makeNonResident(*allocation);
    for (int i = 0; i < maxFragmentsCount; i++) {
        auto bo = allocation->fragmentsStorage.fragmentStorageData[i].osHandleStorage->bo;
        EXPECT_FALSE(isResident<FamilyType>(bo));
        EXPECT_EQ(1u, bo->getRefCount());
    }
    mm->freeGraphicsMemory(allocation);
}

HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTest, givenFragmentedAllocationsWithResuedFragmentsWhenTheyAreMadeResidentThenFragmentsDoNotDuplicate) {
    mock->ioctl_expected.total = 9;
    //3 fragments
    auto ptr = (void *)0x1001;
    auto size = MemoryConstants::pageSize * 10;
    auto graphicsAllocation = mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{false, size}, ptr);

    auto offsetedPtr = (void *)((uintptr_t)ptr + size);
    auto size2 = MemoryConstants::pageSize - 1;

    auto graphicsAllocation2 = mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{false, size2}, offsetedPtr);

    //graphicsAllocation2 reuses one fragment from graphicsAllocation
    EXPECT_EQ(graphicsAllocation->fragmentsStorage.fragmentStorageData[2].residency, graphicsAllocation2->fragmentsStorage.fragmentStorageData[0].residency);

    csr->makeResident(*graphicsAllocation);
    csr->makeResident(*graphicsAllocation2);

    csr->processResidency(csr->getResidencyAllocations());

    auto &osContext = csr->getOsContext();

    EXPECT_TRUE(graphicsAllocation->fragmentsStorage.fragmentStorageData[0].residency->resident[osContext.getContextId()]);
    EXPECT_TRUE(graphicsAllocation->fragmentsStorage.fragmentStorageData[1].residency->resident[osContext.getContextId()]);
    EXPECT_TRUE(graphicsAllocation->fragmentsStorage.fragmentStorageData[2].residency->resident[osContext.getContextId()]);
    EXPECT_TRUE(graphicsAllocation2->fragmentsStorage.fragmentStorageData[0].residency->resident[osContext.getContextId()]);

    auto &residency = getResidencyVector<FamilyType>();

    EXPECT_EQ(3u, residency.size());

    csr->makeSurfacePackNonResident(csr->getResidencyAllocations());

    //check that each packet is not resident
    EXPECT_FALSE(graphicsAllocation->fragmentsStorage.fragmentStorageData[0].residency->resident[osContext.getContextId()]);
    EXPECT_FALSE(graphicsAllocation->fragmentsStorage.fragmentStorageData[1].residency->resident[osContext.getContextId()]);
    EXPECT_FALSE(graphicsAllocation->fragmentsStorage.fragmentStorageData[2].residency->resident[osContext.getContextId()]);
    EXPECT_FALSE(graphicsAllocation2->fragmentsStorage.fragmentStorageData[0].residency->resident[osContext.getContextId()]);

    EXPECT_EQ(0u, residency.size());

    csr->makeResident(*graphicsAllocation);
    csr->makeResident(*graphicsAllocation2);

    csr->processResidency(csr->getResidencyAllocations());

    EXPECT_TRUE(graphicsAllocation->fragmentsStorage.fragmentStorageData[0].residency->resident[osContext.getContextId()]);
    EXPECT_TRUE(graphicsAllocation->fragmentsStorage.fragmentStorageData[1].residency->resident[osContext.getContextId()]);
    EXPECT_TRUE(graphicsAllocation->fragmentsStorage.fragmentStorageData[2].residency->resident[osContext.getContextId()]);
    EXPECT_TRUE(graphicsAllocation2->fragmentsStorage.fragmentStorageData[0].residency->resident[osContext.getContextId()]);

    EXPECT_EQ(3u, residency.size());

    csr->makeSurfacePackNonResident(csr->getResidencyAllocations());

    EXPECT_EQ(0u, residency.size());

    EXPECT_FALSE(graphicsAllocation->fragmentsStorage.fragmentStorageData[0].residency->resident[osContext.getContextId()]);
    EXPECT_FALSE(graphicsAllocation->fragmentsStorage.fragmentStorageData[1].residency->resident[osContext.getContextId()]);
    EXPECT_FALSE(graphicsAllocation->fragmentsStorage.fragmentStorageData[2].residency->resident[osContext.getContextId()]);
    EXPECT_FALSE(graphicsAllocation2->fragmentsStorage.fragmentStorageData[0].residency->resident[osContext.getContextId()]);

    mm->freeGraphicsMemory(graphicsAllocation);
    mm->freeGraphicsMemory(graphicsAllocation2);
}

HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTest, GivenAllocationCreatedFromThreeFragmentsWhenMakeResidentIsBeingCalledThenAllFragmentsAreMadeResident) {
    auto ptr = (void *)0x1001;
    auto size = MemoryConstants::pageSize * 10;

    auto reqs = MockHostPtrManager::getAllocationRequirements(ptr, size);

    auto allocation = mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{false, size}, ptr);

    ASSERT_EQ(3u, allocation->fragmentsStorage.fragmentCount);

    csr->makeResident(*allocation);
    csr->processResidency(csr->getResidencyAllocations());

    for (int i = 0; i < maxFragmentsCount; i++) {
        ASSERT_EQ(allocation->fragmentsStorage.fragmentStorageData[i].cpuPtr,
                  reqs.allocationFragments[i].allocationPtr);
        auto bo = allocation->fragmentsStorage.fragmentStorageData[i].osHandleStorage->bo;
        EXPECT_TRUE(isResident<FamilyType>(bo));
        EXPECT_EQ(1u, bo->getRefCount());
    }
    csr->makeNonResident(*allocation);
    for (int i = 0; i < maxFragmentsCount; i++) {
        auto bo = allocation->fragmentsStorage.fragmentStorageData[i].osHandleStorage->bo;
        EXPECT_FALSE(isResident<FamilyType>(bo));
        EXPECT_EQ(1u, bo->getRefCount());
    }
    mm->freeGraphicsMemory(allocation);
}

HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTest, GivenAllocationsContainingDifferentCountOfFragmentsWhenAllocationIsMadeResidentThenAllFragmentsAreMadeResident) {
    auto ptr = (void *)0x1001;
    auto size = MemoryConstants::pageSize;
    auto size2 = 100u;

    auto reqs = MockHostPtrManager::getAllocationRequirements(ptr, size);

    auto allocation = mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{false, size}, ptr);

    ASSERT_EQ(2u, allocation->fragmentsStorage.fragmentCount);
    ASSERT_EQ(2u, reqs.requiredFragmentsCount);

    csr->makeResident(*allocation);
    csr->processResidency(csr->getResidencyAllocations());

    for (unsigned int i = 0; i < reqs.requiredFragmentsCount; i++) {
        ASSERT_EQ(allocation->fragmentsStorage.fragmentStorageData[i].cpuPtr,
                  reqs.allocationFragments[i].allocationPtr);
        auto bo = allocation->fragmentsStorage.fragmentStorageData[i].osHandleStorage->bo;
        EXPECT_TRUE(isResident<FamilyType>(bo));
        EXPECT_EQ(1u, bo->getRefCount());
    }
    csr->makeNonResident(*allocation);
    for (unsigned int i = 0; i < reqs.requiredFragmentsCount; i++) {
        auto bo = allocation->fragmentsStorage.fragmentStorageData[i].osHandleStorage->bo;
        EXPECT_FALSE(isResident<FamilyType>(bo));
        EXPECT_EQ(1u, bo->getRefCount());
    }
    mm->freeGraphicsMemory(allocation);
    csr->getResidencyAllocations().clear();

    auto allocation2 = mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{false, size2}, ptr);
    reqs = MockHostPtrManager::getAllocationRequirements(ptr, size2);

    ASSERT_EQ(1u, allocation2->fragmentsStorage.fragmentCount);
    ASSERT_EQ(1u, reqs.requiredFragmentsCount);

    csr->makeResident(*allocation2);
    csr->processResidency(csr->getResidencyAllocations());

    for (unsigned int i = 0; i < reqs.requiredFragmentsCount; i++) {
        ASSERT_EQ(allocation2->fragmentsStorage.fragmentStorageData[i].cpuPtr,
                  reqs.allocationFragments[i].allocationPtr);
        auto bo = allocation2->fragmentsStorage.fragmentStorageData[i].osHandleStorage->bo;
        EXPECT_TRUE(isResident<FamilyType>(bo));
        EXPECT_EQ(1u, bo->getRefCount());
    }
    csr->makeNonResident(*allocation2);
    for (unsigned int i = 0; i < reqs.requiredFragmentsCount; i++) {
        auto bo = allocation2->fragmentsStorage.fragmentStorageData[i].osHandleStorage->bo;
        EXPECT_FALSE(isResident<FamilyType>(bo));
        EXPECT_EQ(1u, allocation2->fragmentsStorage.fragmentStorageData[i].osHandleStorage->bo->getRefCount());
    }
    mm->freeGraphicsMemory(allocation2);
}

HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTest, GivenTwoAllocationsWhenBackingStorageIsTheSameThenMakeResidentShouldAddOnlyOneLocation) {
    auto ptr = (void *)0x1000;
    auto size = MemoryConstants::pageSize;
    auto ptr2 = (void *)0x1000;

    auto allocation = mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{false, size}, ptr);
    auto allocation2 = mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{false, size}, ptr2);

    csr->makeResident(*allocation);
    csr->makeResident(*allocation2);

    csr->processResidency(csr->getResidencyAllocations());

    EXPECT_EQ(getResidencyVector<FamilyType>().size(), 1u);

    csr->makeNonResident(*allocation);
    csr->makeNonResident(*allocation2);

    mm->freeGraphicsMemory(allocation);
    mm->freeGraphicsMemory(allocation2);
    csr->getResidencyAllocations().clear();
}

HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTest, makeResidentSizeZero) {
    std::unique_ptr<BufferObject> buffer(this->createBO(0));
    DrmAllocation allocation(GraphicsAllocation::AllocationType::UNKNOWN, buffer.get(), nullptr, buffer->peekSize(), MemoryPool::MemoryNull, 1u);
    EXPECT_EQ(nullptr, allocation.getUnderlyingBuffer());
    EXPECT_EQ(buffer->peekSize(), allocation.getUnderlyingBufferSize());

    csr->makeResident(allocation);
    csr->processResidency(csr->getResidencyAllocations());

    EXPECT_FALSE(isResident<FamilyType>(buffer.get()));
}

HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTest, Flush) {
    auto &cs = csr->getCS();
    auto commandBuffer = static_cast<DrmAllocation *>(cs.getGraphicsAllocation());
    ASSERT_EQ(0u, reinterpret_cast<uintptr_t>(commandBuffer->getUnderlyingBuffer()) & 0xFFF);

    CommandStreamReceiverHw<FamilyType>::addBatchBufferEnd(cs, nullptr);
    CommandStreamReceiverHw<FamilyType>::alignToCacheLine(cs);
    BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 0, 0, nullptr, false, false, QueueThrottle::MEDIUM, cs.getUsed(), &cs};
    csr->flush(batchBuffer, csr->getResidencyAllocations());
    EXPECT_NE(cs.getCpuBase(), nullptr);
    EXPECT_NE(cs.getGraphicsAllocation(), nullptr);
}

HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTest, ClearResidencyWhenFlushNotCalled) {
    auto allocation1 = static_cast<DrmAllocation *>(mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize}));
    auto allocation2 = static_cast<DrmAllocation *>(mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize}));
    ASSERT_NE(nullptr, allocation1);
    ASSERT_NE(nullptr, allocation2);

    EXPECT_EQ(getResidencyVector<FamilyType>().size(), 0u);
    csr->makeResident(*allocation1);
    csr->makeResident(*allocation2);
    csr->processResidency(csr->getResidencyAllocations());

    EXPECT_TRUE(isResident<FamilyType>(allocation1->getBO()));
    EXPECT_TRUE(isResident<FamilyType>(allocation2->getBO()));
    EXPECT_EQ(getResidencyVector<FamilyType>().size(), 2u);

    EXPECT_EQ(allocation1->getBO()->getRefCount(), 1u);
    EXPECT_EQ(allocation2->getBO()->getRefCount(), 1u);

    // makeNonResident without flush
    csr->makeNonResident(*allocation1);
    EXPECT_EQ(getResidencyVector<FamilyType>().size(), 0u);

    // everything is nonResident after first call
    EXPECT_FALSE(isResident<FamilyType>(allocation1->getBO()));
    EXPECT_FALSE(isResident<FamilyType>(allocation2->getBO()));
    EXPECT_EQ(allocation1->getBO()->getRefCount(), 1u);
    EXPECT_EQ(allocation2->getBO()->getRefCount(), 1u);

    mm->freeGraphicsMemory(allocation1);
    mm->freeGraphicsMemory(allocation2);
}

HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTest, FlushMultipleTimes) {
    auto &cs = csr->getCS();
    auto commandBuffer = static_cast<DrmAllocation *>(cs.getGraphicsAllocation());

    CommandStreamReceiverHw<FamilyType>::addBatchBufferEnd(cs, nullptr);
    CommandStreamReceiverHw<FamilyType>::alignToCacheLine(cs);
    BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 0, 0, nullptr, false, false, QueueThrottle::MEDIUM, cs.getUsed(), &cs};
    csr->flush(batchBuffer, csr->getResidencyAllocations());

    cs.replaceBuffer(commandBuffer->getUnderlyingBuffer(), commandBuffer->getUnderlyingBufferSize());
    cs.replaceGraphicsAllocation(commandBuffer);
    CommandStreamReceiverHw<FamilyType>::addBatchBufferEnd(cs, nullptr);
    CommandStreamReceiverHw<FamilyType>::alignToCacheLine(cs);
    BatchBuffer batchBuffer2{cs.getGraphicsAllocation(), 8, 0, nullptr, false, false, QueueThrottle::MEDIUM, cs.getUsed(), &cs};
    csr->flush(batchBuffer2, csr->getResidencyAllocations());

    auto allocation = mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize});
    ASSERT_NE(nullptr, allocation);
    auto allocation2 = mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize});
    ASSERT_NE(nullptr, allocation2);

    csr->makeResident(*allocation);
    csr->makeResident(*allocation2);

    csr->getInternalAllocationStorage()->storeAllocation(std::unique_ptr<GraphicsAllocation>(commandBuffer), REUSABLE_ALLOCATION);

    auto commandBuffer2 = mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize});
    ASSERT_NE(nullptr, commandBuffer2);
    cs.replaceBuffer(commandBuffer2->getUnderlyingBuffer(), commandBuffer2->getUnderlyingBufferSize());
    cs.replaceGraphicsAllocation(commandBuffer2);
    CommandStreamReceiverHw<FamilyType>::addBatchBufferEnd(cs, nullptr);
    CommandStreamReceiverHw<FamilyType>::alignToCacheLine(cs);
    BatchBuffer batchBuffer3{cs.getGraphicsAllocation(), 16, 0, nullptr, false, false, QueueThrottle::MEDIUM, cs.getUsed(), &cs};
    csr->flush(batchBuffer3, csr->getResidencyAllocations());
    csr->makeSurfacePackNonResident(csr->getResidencyAllocations());
    mm->freeGraphicsMemory(allocation);
    mm->freeGraphicsMemory(allocation2);

    csr->getInternalAllocationStorage()->storeAllocation(std::unique_ptr<GraphicsAllocation>(commandBuffer2), REUSABLE_ALLOCATION);
    commandBuffer2 = mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize});
    ASSERT_NE(nullptr, commandBuffer2);
    cs.replaceBuffer(commandBuffer2->getUnderlyingBuffer(), commandBuffer2->getUnderlyingBufferSize());
    cs.replaceGraphicsAllocation(commandBuffer2);
    CommandStreamReceiverHw<FamilyType>::addBatchBufferEnd(cs, nullptr);
    CommandStreamReceiverHw<FamilyType>::alignToCacheLine(cs);
    BatchBuffer batchBuffer4{cs.getGraphicsAllocation(), 24, 0, nullptr, false, false, QueueThrottle::MEDIUM, cs.getUsed(), &cs};
    csr->flush(batchBuffer4, csr->getResidencyAllocations());
}

HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTest, FlushNotEmptyBB) {
    int bbUsed = 16 * sizeof(uint32_t);

    auto &cs = csr->getCS();

    cs.getSpace(bbUsed);

    CommandStreamReceiverHw<FamilyType>::addBatchBufferEnd(cs, nullptr);
    CommandStreamReceiverHw<FamilyType>::alignToCacheLine(cs);
    BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 0, 0, nullptr, false, false, QueueThrottle::MEDIUM, cs.getUsed(), &cs};
    csr->flush(batchBuffer, csr->getResidencyAllocations());
}

HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTest, FlushNotEmptyNotPaddedBB) {
    int bbUsed = 15 * sizeof(uint32_t);

    auto &cs = csr->getCS();

    cs.getSpace(bbUsed);

    CommandStreamReceiverHw<FamilyType>::addBatchBufferEnd(cs, nullptr);
    CommandStreamReceiverHw<FamilyType>::alignToCacheLine(cs);
    BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 0, 0, nullptr, false, false, QueueThrottle::MEDIUM, cs.getUsed(), &cs};
    csr->flush(batchBuffer, csr->getResidencyAllocations());
}

HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTest, FlushNotAligned) {
    auto &cs = csr->getCS();
    auto commandBuffer = static_cast<DrmAllocation *>(cs.getGraphicsAllocation());

    //make sure command buffer with offset is not page aligned
    ASSERT_NE(0u, (reinterpret_cast<uintptr_t>(commandBuffer->getUnderlyingBuffer()) + 4) & 0xFFF);
    ASSERT_EQ(4u, (reinterpret_cast<uintptr_t>(commandBuffer->getUnderlyingBuffer()) + 4) & 0x7F);

    CommandStreamReceiverHw<FamilyType>::addBatchBufferEnd(cs, nullptr);
    CommandStreamReceiverHw<FamilyType>::alignToCacheLine(cs);
    BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 4, 0, nullptr, false, false, QueueThrottle::MEDIUM, cs.getUsed(), &cs};
    csr->flush(batchBuffer, csr->getResidencyAllocations());
}

HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTest, CheckDrmFree) {
    auto &cs = csr->getCS();
    auto commandBuffer = static_cast<DrmAllocation *>(cs.getGraphicsAllocation());

    //make sure command buffer with offset is not page aligned
    ASSERT_NE(0u, (reinterpret_cast<uintptr_t>(commandBuffer->getUnderlyingBuffer()) + 4) & 0xFFF);
    ASSERT_EQ(4u, (reinterpret_cast<uintptr_t>(commandBuffer->getUnderlyingBuffer()) + 4) & 0x7F);

    auto allocation = mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize});

    csr->makeResident(*allocation);
    CommandStreamReceiverHw<FamilyType>::addBatchBufferEnd(cs, nullptr);
    CommandStreamReceiverHw<FamilyType>::alignToCacheLine(cs);
    BatchBuffer batchBuffer{cs.getGraphicsAllocation(), 4, 0, nullptr, false, false, QueueThrottle::MEDIUM, cs.getUsed(), &cs};
    csr->flush(batchBuffer, csr->getResidencyAllocations());
    csr->makeNonResident(*allocation);
    mm->freeGraphicsMemory(allocation);
}

HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTest, MakeResidentClearResidencyAllocationsInCommandStreamReceiver) {
    auto allocation1 = mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize});
    auto allocation2 = mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize});

    ASSERT_NE(nullptr, allocation1);
    ASSERT_NE(nullptr, allocation2);

    csr->makeResident(*allocation1);
    csr->makeResident(*allocation2);
    EXPECT_NE(0u, csr->getResidencyAllocations().size());

    csr->processResidency(csr->getResidencyAllocations());
    csr->makeSurfacePackNonResident(csr->getResidencyAllocations());
    EXPECT_EQ(0u, csr->getResidencyAllocations().size());

    mm->freeGraphicsMemory(allocation1);
    mm->freeGraphicsMemory(allocation2);
}

HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTest, givenMultipleMakeResidentWhenMakeNonResidentIsCalledOnlyOnceThenSurfaceIsMadeNonResident) {
    auto allocation1 = mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize});

    ASSERT_NE(nullptr, allocation1);

    csr->makeResident(*allocation1);
    csr->makeResident(*allocation1);

    EXPECT_NE(0u, csr->getResidencyAllocations().size());

    csr->processResidency(csr->getResidencyAllocations());
    csr->makeSurfacePackNonResident(csr->getResidencyAllocations());

    EXPECT_EQ(0u, csr->getResidencyAllocations().size());
    EXPECT_FALSE(allocation1->isResident(csr->getOsContext().getContextId()));

    mm->freeGraphicsMemory(allocation1);
}

HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTest, makeNonResidentOnMemObjectCallsDrmCSMakeNonResidentWithGraphicsAllocation) {
    auto allocation1 = mm->allocateGraphicsMemoryWithProperties(MockAllocationProperties{0x1000});
    ASSERT_NE(nullptr, allocation1);

    auto &makeNonResidentResult = static_cast<TestedDrmCommandStreamReceiver<FamilyType> *>(csr)->makeNonResidentResult;
    csr->makeResident(*allocation1);

    makeNonResidentResult.called = false;
    makeNonResidentResult.allocation = nullptr;

    csr->makeNonResident(*allocation1);

    EXPECT_TRUE(makeNonResidentResult.called);
    EXPECT_EQ(allocation1, makeNonResidentResult.allocation);
    EXPECT_EQ(0u, csr->getEvictionAllocations().size());

    mm->freeGraphicsMemory(allocation1);
}

class DrmMockBuffer : public Buffer {
  public:
    static DrmMockBuffer *create() {
        char *data = static_cast<char *>(::alignedMalloc(128, 64));
        DrmAllocation *alloc = new (std::nothrow) DrmAllocation(GraphicsAllocation::AllocationType::UNKNOWN, nullptr, &data, sizeof(data), MemoryPool::MemoryNull, 1u);
        return new DrmMockBuffer(data, 128, alloc);
    }

    ~DrmMockBuffer() override {
        ::alignedFree(data);
        delete gfxAllocation;
    }

    DrmMockBuffer(char *data, size_t size, DrmAllocation *alloc) : Buffer(nullptr, CL_MEM_USE_HOST_PTR, size, data, data, alloc, true, false, false),
                                                                   data(data),
                                                                   gfxAllocation(alloc) {
    }

    void setArgStateful(void *memory, bool forceNonAuxMode, bool disableL3, bool alignSizeForAuxTranslation, bool isReadOnly) override {
    }

  protected:
    char *data;
    DrmAllocation *gfxAllocation;
};

HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTest, BufferResidency) {
    std::unique_ptr<Buffer> buffer(DrmMockBuffer::create());

    auto osContextId = csr->getOsContext().getContextId();

    ASSERT_FALSE(buffer->getGraphicsAllocation()->isResident(osContextId));
    ASSERT_GT(buffer->getSize(), 0u);

    //make it resident 8 times
    for (int c = 0; c < 8; c++) {
        csr->makeResident(*buffer->getGraphicsAllocation());
        csr->processResidency(csr->getResidencyAllocations());
        EXPECT_TRUE(buffer->getGraphicsAllocation()->isResident(osContextId));
        EXPECT_EQ(buffer->getGraphicsAllocation()->getResidencyTaskCount(osContextId), csr->peekTaskCount() + 1);
    }

    csr->makeNonResident(*buffer->getGraphicsAllocation());
    EXPECT_FALSE(buffer->getGraphicsAllocation()->isResident(osContextId));

    csr->makeNonResident(*buffer->getGraphicsAllocation());
    EXPECT_FALSE(buffer->getGraphicsAllocation()->isResident(osContextId));
}

HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTest, givenDrmCommandStreamReceiverWhenMemoryManagerIsCreatedThenItHasHostMemoryValidationEnabledByDefault) {
    EXPECT_TRUE(mm->isValidateHostMemoryEnabled());
}

HWTEST_TEMPLATED_F(DrmCommandStreamTest, givenDrmCommandStreamWhenGettingMocsThenProperValueIsReturned) {
    auto mocs = platform()->peekExecutionEnvironment()->getGmmHelper()->getMOCS(GMM_RESOURCE_USAGE_OCL_BUFFER_CACHELINE_MISALIGNED);
    auto expectedMocs = GmmHelper::cacheDisabledIndex;
    EXPECT_EQ(mocs, expectedMocs);

    mocs = platform()->peekExecutionEnvironment()->getGmmHelper()->getMOCS(0);
    expectedMocs = GmmHelper::cacheEnabledIndex;
    EXPECT_EQ(mocs, expectedMocs);
}

HWTEST_TEMPLATED_F(DrmCommandStreamEnhancedTest, givenAllocationWithSingleBufferObjectWhenMakeResidentBufferObjectsIsCalledThenTheBufferObjectIsMadeResident) {
    auto size = 1024u;
    auto bo = this->createBO(size);
    BufferObjects bos{{bo}};
    auto allocation = new DrmAllocation(GraphicsAllocation::AllocationType::UNKNOWN, bos, nullptr, 0u, size, MemoryPool::LocalMemory);
    EXPECT_EQ(bo, allocation->getBO());

    makeResidentBufferObjects<FamilyType>(allocation);
    EXPECT_TRUE(isResident<FamilyType>(bo));

    mm->freeGraphicsMemory(allocation);
}
",16155,True,3543.377904178436,median
"= MeNUS - User Guide
:site-section: UserGuide
:toc:
:toc-title:
:toc-placement: preamble
:sectnums:
:imagesDir: images
:stylesDir: stylesheets
:xrefstyle: full
:experimental:
ifdef::env-github[]
:tip-caption: :bulb:
:note-caption: :information_source:
:warning-caption: :warning:
endif::[]
:repoURL: https://github.com/CS2103-AY1819S1-F10-4/main/tree/master
:toclevels: 3

By: `Team CS2103-AY1819S1-F10-4`      Since: `Sep 2018`      Licence: `MIT`

// tag::intro[]
== Welcome to MeNUS
link:{repoURL}[MeNUS] empowers you to improve the **m**anagement and its **e**fficiency of your restaurants in **NUS**.

As long as you feel that you are using too many complex and expensive systems to manage your restaurants,
link:{repoURL}[MeNUS] is here to help you and it is the only restaurant management system you will ever need.

Introducing link:{repoURL}[MeNUS], a revolutionary restaurant management desktop application that is *optimized for
users who prefer to work with a Command Line Interface (CLI) while still having the benefits of a Graphical User
Interface (GUI)*. If you can type fast, link:{repoURL}[MeNUS] allows you to manage core aspects of your restaurants --
accounts (i.e. employees), menus, ingredients, sales and reservations management -- all within a single application!

=== Legend
The following *3* callouts will be used throughout the documentation which you may wish to pay attention to as it may
contain important details:

[NOTE]
Just for your info, do not be alarmed. Be sure to read these notes as it might contain some important information.

[TIP]
Perhaps something can be done using another approach, but it is up to you to decide. Tips are often not important and
 can be safely ignored.

[WARNING]
Some things might go wrong if you are not careful, or did not follow the instructions correctly. You are strongly
advised to read whatever is in this block.

[[user-interface]]
=== A Quick Look at MeNUS

*MeNUS*’s user interface is split into a few sections. These sections are highlighted in the image below.

image::UserInterfaceHighlight.png[width=""1000""]

Let's get started!
// end::intro[]

== Quick Start
Follow this installation guide to get *MeNUS* up and running on your computer.

.  Ensure you have Java version `9` or later installed in your Computer.

[NOTE]
====
* If you are unsure which Java version is installed, you may refer to this link:https://www.java.com/en/download/help/version_manual.xml[link].
* You may install the current version of Java link:https://www.oracle.com/technetwork/java/javase/downloads/index.html[here].
====

.  Download the latest `menus.jar` link:https://github.com/CS2103-AY1819S1-F10-4/main/releases[here].
.  Copy the file to the folder you want to use as the home folder.
.  Double-click the file to start the app. The GUI should appear in a few seconds.
+
image::Ui.png[width=""790""]
+
.  Type the command in the command box and press kbd:[Enter] to execute it. +
e.g. typing *`help`* and pressing kbd:[Enter] will open the help window.
.  Some example commands you can try:
* **`help`** : Opens up the help page
* **`login`**`id/root pw/1122qq` : Logs in to the root account
* **`add-item`**`n/Apple p/2.00 t/fruit` : Creates a new item in the menu
* *`exit`* : Exits the application

.  Refer to <<Commands>> for details of each command.

[[Components]]
== Components
*MeNUS* consists of five core components: accounts (i.e. employees), menus, ingredients, sales and reservations
management.

=== Accounts
image:account.png[width=""50""] +
* You can create an account for each of your employee to manage the application on your behalf, which gives them
access to the other core components.

=== Menus
image:menu.png[width=""50""] +
You can manage the menu by adding, editing or remove items from the menu.

=== Ingredients
image:ingredient.png[width=""50""] +
You can keep track of the ingredient availability in your restaurant.

=== Sales
image:sales.png[width=""50""] +
The built-in Sales Management component in MeNUS provides you with the tools you will need to keep track of financial
 records efficiently. Several analytical features are also incorporated to assist you in financial decision-making
 and devising marketing strategies.

=== Reservations
image:reservation.png[width=""50""] +
You can keep track of customer reservations on the system.

[[Features]]
== Key Features
=== Convenience
*MeNUS* is an integrated application that will provide you with the utmost convenience and tools you will need to
manage your restaurants. It allows you to:

* Export data to `.xml` (default) or Excel file `[coming in v2.0]`.

=== Security
We understand that digital security is your biggest concern. *MeNUS* is capable of securing your restaurants' data by:

* Encrypting all data using state of the art encryption scheme `[coming in v2.0]`.
* Requiring users to be authenticated before they can execute any commands.
* Providing accountability through logging of system events.

=== Efficiency
Time is money. *MeNUS* ensures that the application will:

* Load within 5 seconds.
* Execute commands within split of a second and update the GUI almost instantaneously.

[[Commands]]
== Commands
*MeNUS* is jam-packed with features and it may be daunting for new users. The subsequent sections of the user guide
provides a step by step walk-through of all the commands *MeNUS* has to offer.

Do read our short explanation about Command Format below so that the subsequent portions of this section will make sense to you.
====
*Command Format*

* Words in `UPPER_CASE` are the parameters to be supplied by the user e.g. in `add-item n/ITEM_NAME`, `ITEM_NAME` is a
parameter which can be used as `add-item n/Burger`.
* Items in square brackets are optional e.g `n/ITEM_NAME [t/TAG]` can be used as `n/Burger t/beef` or as `n/Burger`.
* Items with `…`​ after them can be used multiple times including zero times e.g. `[t/TAG]...` can be used as
`{nbsp}` (i.e. 0 times), `t/Italian`, `t/Italian t/Wednesday` etc.
* Parameters can be in any order e.g. if the command specifies `n/ITEM_NAME p/ITEM_PRICE`, `p/ITEM_PRICE n/ITEM_NAME`
 is also acceptable.
====

As this is a management system, only the following commands can be executed without being authenticated (i.e. as guest):

====
`help`, `login`, `select-item`, `find-item`, `filter-menu`, `list-items`, `today-special`, `exit`
====

=== General
The commands in this section does not tie to any of the 5 components.

==== Viewing help : `help` or `h`
Opens up the help window. Very useful if you are a new user. +
Format: `help` or `h`

==== Listing entered commands : `history` or `hist`
Lists all the commands that you have entered in reverse chronological order. +
Format: `history` or `hist`
[NOTE]
====
Pressing the kbd:[&uarr;] and kbd:[&darr;] arrows will display the previous and next input respectively in the command box
====

// tag::undoredo[]
==== Undoing previous command : `undo` or `u`

Restores the restaurant book to the state before the previous _undoable_ command was executed. +
Format: `undo` or `u`

[NOTE]
====
Undoable commands: those commands that modify the restaurant book's contents
====

Examples:

* `register id/root pw/1122qq` `n/Ang Zhi Kai` +
`undo` (reverses the `register id/root pw/1122qq n/Ang Zhi Kai` command) +

* `undo` +
The `undo` command fails as there are no undoable commands executed previously.

* `deregister id/root` +
`clear` +
`undo` (reverses the `clear` command) +
`undo` (reverses the `deregister id/root` command) +

==== Redoing the previously undone command : `redo` or `r`

Reverses the most recent `undo` command. +
Format: `redo` or `r`

Examples:

* `delete-item-index 1` +
`undo` (reverses the `delete-item-index 1` command) +
`redo` (reapplies the `delete-item-index 1` command) +

* `delete-item-index 1` +
`redo` +
The `redo` command fails as there are no `undo` commands executed previously.

* `delete-item-index 1` +
`clear` +
`undo` (reverses the `clear` command) +
`undo` (reverses the `delete-item-index 1` command) +
`redo` (reapplies the `delete-item-index 1` command) +
`redo` (reapplies the `clear` command) +

[NOTE]
Undo and redo commands do not refresh the detailed panel
// end::undoredo[]

==== Clearing all entries : `clear` or `c`

Clears all entries from the restaurant book. +
Format: `clear` or `c`

==== Saving the data

Restaurant book data are saved in the hard disk automatically after any command that changes the data. No manual
saving is required.

==== Exiting the program : `exit` or `ex`

Exits the program. +
Format: `exit` or `ex`

// tag::accountmanagement[]
=== Accounts Management
==== Logging in: `login`

Logs into an existing account. +
Format: `login id/USERNAME pw/PASSWORD`

Examples:

* `login id/root pw/1122qq`

[NOTE]
====
To testers: You may access the application using the default `root` account: `login id/root pw/1122qq`
====

==== Logging out: `logout`

Logs out of the account. +
Format: `logout`

[NOTE]
====
History will automatically be cleared upon logging out
====

==== Creating user account: `register` or `reg`

Creates a new user account. +
Format: `register id/USERNAME pw/PASSWORD n/FULL_NAME` or `reg id/USERNAME pw/PASSWORD n/FULL_NAME`

[NOTE]
====
This command will be improved in the future to support user role (i.e. privilege system). See <<Register-Improvement>,
Section 5.7.1, “Improving registration [coming in v2.0]”>> for more information
====

Examples:

* `register id/azhikai pw/1122qq n/Ang Zhi Kai`
* `reg id/azhikai pw/1122qq n/Ang Zhi Kai`

==== Changing user password: `change-password` or `cp`

Edits the password of the current logged in user account. +
Format: `change-password npw/NEW_PASSWORD` or `cp npw/NEW_PASSWORD`

Examples:

* `change-password npw/1122qq`
* `cp npw/1122qq`

==== Deleting user account: `deregister` or `dereg`

Deletes an existing user account. +
Format: `deregister id/USERNAME` or `dereg id/USERNAME`

[NOTE]
====
This command will only be executable by a highly privileged user in the future. See <<User-Role>,
Section 5.7.2, “Creating user role [coming in v2.0]”>> for more information
====

Examples:

* `deregister id/azhikai`
* `dereg id/azhikai`

==== Select user account: `select-account` or `sa`
Selects the account identified by the index number. +
Format: `select-account INDEX` or `sa INDEX`

****
* The index refers to the index number shown in the displayed item list
* The index *must be a positive integer* `1, 2, 3, ...`
****

[NOTE]
====
Selecting the account does not render any data on the detailed panel due to the simplicity of the data itself
====

Examples:

* `list-accounts` +
`select-account 2` +
Selects the 2nd account in the list.
* `fa azhikai` +
`sa 1` +
Selects the 1st account in the results of the `find-account` command.

==== Locating account by username: `find-account` or `fa`

Finds account whose username contains the keyword. +
Format: `find-account KEYWORD` or `fa KEYWORD`

****
* The search is case insensitive. e.g `Root` will match `root`
* Only the username is searched
* Only one keyword is allowed since `username` does not contain spaces
* Full keyword is not necessary; e.g. `roo` and `root` will match `root`
****

Examples:

* `find-account root` or `fa root` +
Return any accounts whose username contains the string `root`

==== List user accounts: `list-accounts` or `la`

List all user accounts. +
Format: `list-accounts` or `la`

[WARNING]
====
Passwords are not and should not be displayed
====
// end::accountmanagement[]

// tag::ingredientmanagement[]
=== Ingredients Management
This section explains how you may use the commands relating to the Ingredient Management feature.

[[add-ingredient]]
==== Adding an ingredient: `add-ingredient` or `add-ing`

Adds a new ingredient to the ingredient list. +
Format: `add-ingredient n/INGREDIENT_NAME u/UNIT_TYPE p/PRICE_PER_UNIT m/MINIMUM`

[NOTE]
====
* MINIMUM refers to the number of units below which an ingredient will be considered low in stock count
* When a new ingredient is first added, its number of units is set to zero
====

Examples:

* `add-ingredient n/cod fish u/kilogram p/20 m/1` +
Adds the ingredient `cod fish` with a price of `$20/kilogram` and minimum threshold of `1 unit`.

[[list-ingredients]]
==== Listing all ingredients : `list-ingredients` or `list-ing`

Shows a list of all ingredients in the ingredient list. +
Format: `list-ingredients`

[[low-stock]]
==== Listing ingredients with low stock count: `low-stock`

Shows a list of ingredients that are low in stock count. +
Format: `low-stock`

[NOTE]
====
An ingredient is low in stock count when the number of units available is less than its minimum threshold
====

[[delete-ingredient]]
==== Removing an ingredient: `delete-ingredient` or `delete-ing`

Deletes the specified ingredient from the ingredient list. +
Format: `delete-ingredient INDEX` or `delete-ingredient INGREDIENT_NAME`

[NOTE]
====
* Deletes the ingredient at the specified `INDEX`
* `INDEX` refers to the index number shown in the displayed ingredient list
* `INDEX` *must be a positive integer* 1, 2, 3, ...
* Alternatively, deletes the ingredient with the specified `INGREDIENT_NAME`
====

Examples:

* `list-ingredients` +
`delete-ingredient 1` +
`list-ingredients` +
Deletes the 1st ingredient in the ingredient list.

* `delete-ingredient cod fish` +
`list-ingredients` +
Deletes the ingredient `cod fish` from the ingredient list.

[[edit-ingredient]]
==== Editing an ingredient: `edit-ingredient` or `edit-ing`

Edits an ingredient in the ingredient list. +
Format: `edit-ingredient INDEX [n/INGREDIENT_NAME] [u/UNIT_TYPE] [p/PRICE_PER_UNIT] [m/MINIMUM]` or `edit-ingredient
on/ORIGINAL_INGREDIENT_NAME [n/NEW_INGREDIENT_NAME] [u/UNIT_TYPE] [p/PRICE_PER_UNIT] [m/MINIMUM]`

[NOTE]
====
* Edits the ingredient at the specified `INDEX`. The index refers to the index number shown in the displayed ingredient list. The index *must be a positive integer* 1, 2, 3, ...
* Existing values will be updated to the input values
* Alternatively, edits the ingredient with the specified `ORIGINAL_INGREDIENT_NAME`
* If both `INDEX` and `ORIGINAL_INGREDIENT_NAME` are specified and valid, the edit will be done according to `INDEX`
====

[WARNING]
====
At least one of the optional fields must be provided!
====

Examples:

* `edit-ingredient 3 n/thin fries` +
Edits the name of the 3rd ingredient to `thin fries`.

* `edit-ingredient 4 u/1.5ml bottle p/1.20`  +
Edits the unit type and price per unit of the 4th ingredient to `1.5ml bottle` and `1.20` respectively.

* `edit-ingredient on/ketchup n/tomato ketchup`  +
Edits the name of `ketchup` to `tomato ketchup`.

[[stockup]]
==== Stocking up an ingredient: `stockup`

Increases the number of units of an ingredient or multiple ingredients. +
Format: `stockup n/INGREDIENT_NAME... nu/NUMBER_OF_UNITS...`

[WARNING]
====
* `NUMBER_OF_UNITS` for an ingredient must follow the `INGREDIENT_NAME` for that particular ingredient
* If the same ingredient is specified more than once, the last `NUMBER_OF_UNITS` will supercede
====

Examples:

* `stockup n/cod fish nu/5` +
Stocks up `5 units` of `cod fish`.
* `stockup n/chicken thigh nu/10 n/fries nu/20 n/tomato ketchup nu/50` +
Stocks up `10 units` of `chicken thigh`, `20 units` of `fries` and `50 units` of `tomato ketchup`.

[[select-ingredient]]
==== Selecting an ingredient: `select-ingredient` or `select-ing`

Selects the ingredient identified by the index number used in the displayed ingredient list. +
Format: `select-ingredient INDEX` or `select-ing INDEX`

[NOTE]
====
* Selects the ingredient and displays the details of the ingredient at the specified `INDEX`
* The index refers to the index number shown in the displayed ingredient list
* The index *must be a positive integer* `1, 2, 3, ...`
====

Examples:

* `list-ingredients` +
`select-ingredient 2` +
Selects the 2nd ingredient in the displayed ingredient list.
* `low-stock` +
`select-ingredient 1` +
Selects the 1st ingredient in the results of the `low-stock` command.
// end::ingredientmanagement[]

// tag::menuPart1[]
=== Menu Management
[[add-item]]
==== Adding an item to the menu: `add-item` or `ai`

Adds an item to the menu +
Format: `add-item n/ITEM_NAME p/ITEM_PRICE [t/TAG]...`

****
* `ITEM_NAME` and `ITEM_PRICE` must be provided
* An item can have any number of tags (including 0)
* `ITEM_NAME` should only contain alphanumeric characters and spaces, and it should not be blank
* `ITEM_PRICE` should only contain numbers(no negative), at most 2 decimal place and smaller than or equals to
2,147,483,647
* You cannot add items with the same name
****

Examples:

* `add-item n/Burger p/2`
* `ai n/Burger Set p/4.5 t/Set`

==== Editing an item in the menu : `edit-item` or `ei`

Edits an existing item in the menu. +
Format: `edit-item INDEX [n/ITEM_NAME] [p/ITEM_PRICE] [t/TAG]...`

****
* Edits the item at the specified `INDEX`. The index refers to the index number shown in the displayed item list
* The index *must be a positive integer* 1, 2, 3, ...
* At least one of the optional fields must be provided
* Existing values will be updated to the input values
* When editing tags, the existing tags of the item will be removed i.e adding of tags is not cumulative
* You can remove all the item's tags by typing `t/` without specifying any tags after it
* Editing item price will remove discount given by `discount-item` command
****

Examples:

* `edit-item 1 n/burger p/3` +
Edits the name and price of the 1st item to be `burger` and `3` respectively.
* `ei 2 p/4 t/` +
Edits the price of the 2nd item to be `4` and clears all existing tags.

==== Deleting an item by index: `delete-item-index` or `dii`

Deletes the specified item from the menu. +
Format: `delete-item-index INDEX [ei/INDEX]`

****
* Deletes the item(s) specified by `INDEX`
* The index refers to the index number shown in the displayed item list
* The index *must be a positive integer* 1, 2, 3, ...
* You can delete a range of items by adding the ending index `ei\\INDEX`
* The ending index can not be smaller than starting index
****

Examples:

* `list-items` +
`delete-item-index 2` +
Deletes the 2nd item in the menu.
* `fi Cheese` +
`dii 1 ei/3` +
Deletes 1st item, 2nd item and 3rd item in the results of the `find-item` command.

==== Deleting an item by name: `delete-item-name` or `din`

Deletes the specified item from the menu. +
Format: `delete-item-name ITEM_NAME`

****
* Deletes the item by the specified `ITEM_NAME`
* The `ITEM_NAME` *must be in the menu*
* `ITEM_NAME` is case-insensitive. e.g `burger` will match `Burger`
****

Examples:

* `delete-item-name Apple Juice` +
Deletes the `Apple Juice` item from the menu.
* `din Cheese Fries` +
Deletes the `Cheese Fries` item from the menu.
//end::menuPart1[]

==== Listing all items in the menu : `list-items` or `li`

Shows a list of all items in the menu. +
Format: `list-items`

==== Clearing all entries : `clear-menu` or `cm`

Clears all entries from the menu. +
Format: `clear-menu`

==== Selecting an item : `select-item` or `si`

Selects the item identified by the index number used in the menu. +
Format: `select-item INDEX`

****
* Selects the item and loads the page the item at the specified `INDEX`
* The index refers to the index number shown in the displayed item list
* The index *must be a positive integer* `1, 2, 3, ...`
****

Examples:

* `list-items` +
`select-item 2` +
Selects the 2nd item in the menu.
* `fi Burger` +
`si 1` +
Selects the 1st item in the results of the `find-item` command.

==== Locating items by name: `find-item` or `fi`

Finds items whose names contain any of the given keywords. +
Format: `find-item KEYWORD [MORE_KEYWORDS]...`

****
* The search is case insensitive. e.g `burger` will match `Burger`
* The order of the keywords does not matter. e.g. `Cheese Burger` will match `Burger Cheese`
* Only the name is searched
* Only full words will be matched e.g. `Bur` will not match `Burger`
* Items matching at least one keyword will be returned (i.e. `OR` search). e.g. `Cheese Burger` will return
`Cheese Burger`, `Cheese Fries` and `Beef Burger`
****

Examples:

* `find-item Burger` +
Returns `burger` and `Cheese Burger`
* `fi Cheese Chocolate Fruit` +
Returns any item having names `Cheese`, `Chocolate`, or `Fruit`

//tag::menuPart2[]
==== Filter menu by tag: `filter-menu` or `fm`

Finds items whose tags match any of the given keywords. +
Format: `filter-menu KEYWORD [MORE_KEYWORDS]...`

****
* The search is case insensitive. e.g `burger` will match `Burger`
* Only filter by tag
* Only full words will be matched e.g. `Bur` will not match `Burger`
* Items with tags matching at least one keyword will be returned (i.e. `OR` search). e.g. `drinks burger` will return
items that are tagged with drinks or burger
****

[NOTE]
`KEYWORD` for `filter-menu` must be alphanumeric

Examples:

* `filter-menu monday` +
Returns any item that contains tag `monday`
* `fm set monday` +
Returns any item that contains tag `set` or `monday`
//end::menuPart2[]

==== Sort menu : `sort-menu` or `sm`

Sort the menu by name or price. +
Format: `sort-menu SORTING_METHOD`

****
* Sort the menu by name or price
* `SORTING_METHOD` refers the method to sort menu: name or price
* Case-insensitive, it can be: `sort-menu name` or `sort-menu NAME`
* Only one of the sorting method should be provided
****

Examples:

* `sort-menu name` +
Sorts the menu by item name in lexicographical order.
* `sm PRICE` +
Sorts the menu by item price in ascending order(lowest to highest).

//tag::menuPart3[]
==== Giving a discount to an item : `discount-item` or `dci`

Gives the item identified by the index number used in the displayed item list a discount. +
Format: `discount-item INDEX|ALL [ei/INDEX] dp/PERCENTAGE`

****
* You can remove discount by typing `0` for the percentage
* You can give a discount to all items in the displayed item list by typing `ALL`(case-insensitive) instead of a
specified `INDEX`
* You can give a discount to a range of items by adding the ending index `ei\\INDEX`
* The ending index can not be smaller than starting index
* The percentage should only contain numbers(no negative), and it should be at most 2 digits(no decimal place)
****

Examples:

* `list-items` +
`discount-item 2 dp/20` +
Give the 2nd item in the menu a 20% discount.
* `fi Cheese` +
`dci ALL dp/0` +
Revert all items in the results of the `find-item` command to original price.
* `li` +
`dci 1 ei/3 dp/50` +
Give the 1st item to the 3rd item in the menu a 50% discount.
//end::menuPart3[]

==== Today's specials : `today-special` or `ts`

Lists the items that have been tagged with `DAY_OF_THE_WEEK` in the menu. +
Format: `today-special`

****
* `DAY_OF_THE_WEEK` refers to Monday, Tuesday, ..., Sunday
****
Examples:

* `today-special` +
If today is Monday +
List the items that have been tagged with `Monday` in the menu.

==== Adding recipe to item : `recipe-item` or `ri`

Adds recipe to the item identified by the index number used in the menu. +
Format: `recipe-item INDEX r/RECIPE`

****
* Adds a recipe to the item at the specified `INDEX`
* If the item has a recipe already, it will overwite the existing recipe
* The index refers to the index number shown in the displayed item list
* The index *must be a positive integer* `1, 2, 3, ...`
* You can remove recipe by typing `r/` without specifying any recipe after it
****

Examples:

* `recipe-item 1 r/Some Recipe` +
Add/Update the recipe of the 1st item to be `Some Recipe`.
* `fi Cheese` +
`ri 1 r/Other Recipe` +
Add/Update the recipe of the 1st item in the results of the `find-item` command to be `Other Recipe`.

[[add-required-ingredient]]
==== Adding required ingredients: `add-required-ingredients` or `ari`

Adds required ingredients to the item identified by the index number used in the menu. +
Format: `add-required-ingredients INDEX n/INGREDIENT_NAME... nu/NUMBER_OF_INGREDIENTS...`

****
* Adds required ingredients to the item at the specified `INDEX`.
* If the item has required ingredients already, it will overwrite the existing required ingredients.
* The index refers to the index number shown in the displayed item list.
* The index *must be a positive integer* `1, 2, 3, ...`
* NUMBER_OF_INGREDIENTS for an ingredient must be paired with the INGREDIENT_NAME for that particular ingredient.
e.g. `n/apple nu/3` or `nu/3 n/apple`
* You can remove required ingredients by not including any `n/INGREDIENT_NAME... nu/NUMBER_OF_INGREDIENTS...`
e.g. `add-required-ingredients INDEX`
****

Examples:

* `add-required-ingredients 1 n/Apple nu/3` +
Add/Update the required ingredients of the 1st item.
* `fi Cheese` +
`ari 1 n/chicken thigh u/10 n/potato u/20` +
Add/Update the recipe of the 1st item in the results of the `find-item` command.

//tag::reservations[]
=== Reservations Management
==== Adding a reservation: `add-reservation` or `ar`

Adds a new reservation to the reservations list. +
Format: `add-reservation n/NAME px/PAX d/DATE ti/TIME` or `ar n/NAME px/PAX d/DATE ti/TIME`

[NOTE]
====
* We use natural language processing to parse the date and time values
* For example, phrases like `21st Dec` or `12 p.m.` will be accepted. Try it out!
====

[WARNING]
====
* Try to avoid ambiguous language as it might be interpreted incorrectly
* For example, `3/12` is ambiguous as it could mean `3rd December` or `12th March`!
* If you want to be sure, we recommend using these formats:
** `DATE`: `DD-MM-YYYY`
** `TIME`: `HH:MM`
* Dates that have already passed will be rejected
====

Examples:

* `add-reservation n/TAN px/4 d/21-07-2019 ti/10:00`
* `ar n/ONG px/2 d/21st July ti/10am`
* `ar n/LEE px/8 d/next tuesday ti/8 p.m.`

==== Listing all reservations : `list-reservations` or `lr`

Shows a list of all reservations in the reservations list. +
Format: `list-reservations` or `lr`

==== Editing a reservation: `edit-reservation` or `er`

Edits an reservation in the reservation list. +
Format: `edit-reservation INDEX [n/NAME] [px/PAX] [d/DATE] [ti/TIME]` or `er INDEX [n/NAME] [px/PAX] [d/DATE] [ti/TIME]`

****
* Edits the reservation at the specified `INDEX`. The index refers to the index number shown in the
displayed reservations list. The index *must be a positive integer* 1, 2, 3, ...
* At least one of the optional fields must be provided.
* Existing values will be updated to the input values.
****

Examples:

* `edit-reservation 2 d/31-12-2019 ti/18:00` +
Edits the time of the 2nd reservation in the list to `31st Dec 2019, 1800` hrs.

* `er 6 n/ONG px/4`  +
Edits the name and pax of the 6th reservation to `ONG` and `4` respectively.

==== Sorting reservations list: `sort-reservations` or `sortr`

Sorts the reservations list by Date/Time. +
Format: `sort-reservations` or `sortr`

==== Deleting a reservation: `delete-reservation` or `dr`

Deletes the specified reservation from the reservations list. +
Format: `delete-reservation INDEX` or `dr INDEX`

****
* Deletes the reservation at the specified `INDEX`.
* The index refers to the index number shown in the displayed reservations list.
* The index *must be a positive integer* 1, 2, 3, ...
****

Examples:

* `list-reservations` +
`delete-reservation 2` +
`list-reservations` +
Deletes the 2nd reservation in the reservations list.

* `list-reservations` +
`dr 5` +
`list-reservations` +
Deletes the 5th reservation in the reservations list.

==== Selecting a reservation : `select-reservation` or `sr`

Selects the reservation identified by the index number used in the displayed reservations list. +
Format: `select-reservation INDEX` or `sr INDEX`

****
* Selects the reservation at the specified `INDEX`.
* The index refers to the index number shown in the displayed reservation list.
* The index *must be a positive integer* `1, 2, 3, ...`
****

Examples:

* `list-reservations` +
`select-reservation 2` +
Selects the 2nd reservation in the reservations list.

* `list-reservations` +
`select-reservation 7` +
Selects the 7th reservation in the reservations list.
//end::reservations[]

// tag::salesmanagement[]
=== Sales Management

The following are sales-related commands to help you with financial tracking and analysis. The terms **""sales record""**
and **""record list""** will be used frequently under this section so it is advisable to first understand their
definition in the <<sales-record, glossary>>.

[[record-sales]]
==== Recording sales volume of an item: `record-sales` or `rs`

Records the sales volume of an item within a specific day into the record list. +
Format: `record-sales d/DATE n/ITEM_NAME q/QUANTITY_SOLD p/ITEM_PRICE` or `rs d/DATE n/ITEM_NAME q/QUANTITY_SOLD
p/ITEM_PRICE` +

****
* `DATE` must be written in the DD-MM-YYYY format.
* `DATE` must exist in the calendar.
* Both `DATE` and `ITEM_NAME` cannot be same as another record in the record list.
* `ITEM_NAME` is case insensitive. ""Cheesy Pasta"" and ""cheesy pasta"" are regarded as the same item.
****

Examples:

* `record-sales d/25-09-2018 n/Fried Rice q/35 p/5.50`
* `rs d/25-09-2018 n/Fried Rice q/35 p/5.50`

[[auto-ingredient-update]]
**Auto-ingredient update mechanism**

`record-sales` also determines all the ingredients you used and automatically deducts them from the ingredient
list, subjected to the following conditions: +
1) The item exists in the menu. +
See <<add-item, Section 5.4.1, “Adding an item to the menu"">> for more information. +
2) The required ingredients to make one unit of `ITEM_NAME` is specified. +
See <<add-required-ingredient, Section 5.4.14, “Add required ingredients"">> for more information. +
3) All required ingredients exist in the ingredient list. +
See <<add-ingredient, Section 5.3.1, “Adding an ingredient"">> for more information. +
4) There are sufficient ingredients to make `QUANTITY_SOLD` units of `ITEM_NAME`. +
See <<stockup, Section 5.3.6, “Stocking up an ingredient"">> for more information.

[NOTE]
====
Sales volume will still be recorded even if some of the above conditions are not met. However, ingredient list
will not be updated
====

[NOTE]
====
[[ingredients-used]]**Ingredient used**: MeNUS will remember the name and quantity of ingredients you used as long as
the item and its required ingredients have been specified in the menu component
====

[TIP]
====
If you recorded a sales volume by mistake, you can use the `Undo` command to recover the deducted ingredients,
provided that the ingredients have been deducted automatically
====

[[display-sales]]
==== Display sales report: `display-sales` or `dis`

Generate and display the sales report for a specific day. +
Format: `display-sales DATE` or `dis DATE`

****
* `DATE` must be written in the DD-MM-YYYY format.
* `DATE` must exist in the calendar.
* There must be at least one sales record associated with the specified `DATE`.
****

Examples:

* `display-sales 30-09-2018`
* `dis 30-09-2018` +
Displays the sales report dated 30-09-2018.

The following (Figure 5.6.2.1) is an example of what you will see if the sales report is generated and displayed
correctly:

image::display-sales-pic.png[width=""465""]
_Figure 5.6.2.1: Sales Report_

==== Deleting a sales record: `delete-sales` or `des`

Deletes the sales record identified by the index. +
Format: `delete-sales INDEX` or `des INDEX`

****
* Deletes the record at the specified `INDEX`.
* `INDEX` refers to the index number shown in the record list.
* `INDEX` *must be a positive integer* 1, 2, 3, ...
****

[NOTE]
====
Deleting a sales record will not undo the effect of <<auto-ingredient-update, ""Auto-ingredient update"">> which may or
 may not have happened during recording
====

Examples:

* `delete-sales 2`
* `des 2` +
Deletes the 2nd record from the record list.

==== Editing a sales record: `edit-sales` or `es`

Edits the sales record identified by the index. +
Format: `edit-sales INDEX [d/DATE] [n/ITEM_NAME] [q/QUANTITY_SOLD] [p/ITEM_PRICE]` or `es INDEX [d/DATE]
[n/ITEM_NAME] [q/QUANTITY_SOLD] [p/ITEM_PRICE]`

****
* Edits the record at the specified `INDEX`.
* `INDEX` refers to the index number shown in the record list.
* `INDEX` *must be a positive integer* 1, 2, 3, ...
* At least one of the optional fields must be provided.
* Existing values will be updated to the input values.
****

[WARNING]
====
Editing a sales record will permanently delete its <<ingredients-used, ""Ingredient used"">> data
====

[NOTE]
====
Editing a sales record will **not** update the ingredient list. See <<auto-ingredient-update, Auto-ingredient
update>> for more information
====

Examples:

* `edit-sales 3 n/Fried Omelet`
* `es 3 n/Fried Omelet` +
Edits the item name of the 3rd record to be ""Fried Omelet"".

* `edit-sales 7 q/37 p/6.50`
* `es 7 q/37 p/6.50` +
Edits the quantity sold and price of the 7th record to be 37 and 6.50 respectively.
// end::salesmanagement[]

[[chart-sales]]
==== Display sales chart of date and revenue: `chart-sales` or `cs`

Generates and displays the sales chart of revenue against date. +
Format: `chart-sales` or `cs`

****
* Record list must not be empty.
* Only existing dates in the record list are tabulated and shown.
****

The following (Figure 5.6.5.1) is an example of what you will see if the sales chart is generated and displayed correctly:

image::chart-sales-pic.png[width=""550""]
_Figure 5.6.5.1: Sales Chart of revenue against date_

// tag::rankdates[]

[[rank-date]]
==== Ranking dates according to total revenue: `rank-date` or `rad`

Ranks and displays all existing dates in the record list based on the total revenue. +
Format: `rank-date` or `rad`

****
* Record list must not be empty.
****

[TIP]
====
You can generate the sales report of a specific date to get a more detailed analysis. See <<display-sales,
Section 5.6.2, “Display sales report"">> for more information
====


The following (Figure 5.6.6.1) is an example of what you will see if the ranking is generated and displayed correctly:

image::rank-date-pic.png[width=""325""]
_Figure 5.6.6.1: Ranking of dates by revenue_

// end::rankdates[]

[[rank-item]]
==== Ranking items according to total revenue: `rank-item` or `rai`

Ranks and displays all items according to their total revenue accumulated in past sales records. +
Format: `rank-item` or `rai`

****
* Record list must not be empty.
****

[TIP]
====
You can check the sales history of a specific item to get a more detailed analysis. This feature will be available
in v2.0. See <<check-history, Section 5.7.6, “Checking item sales history"">> for more information
====

The following (Figure 5.6.7.1) is an example of what you will see if the ranking is generated and displayed correctly:

image::rank-item-pic.png[width=""325""]
_Figure 5.6.7.1: Ranking of items by revenue_

==== Selecting a sales record : `select-sales` or `ss`

Selects the sales record identified by the index number used in the record list. +
Format: `select-sales INDEX` or `ss INDEX`

****
* Loads the record list and selects the record at the specified `INDEX`.
* `INDEX` refers to the index number shown in the displayed record list.
* `INDEX` *must be a positive integer* `1, 2, 3, ...`
****

Examples:

`select-sales 2` +
Selects the 2nd record in the record list.

`ss 6` +
Selects the 6th record in the record list.

=== Upcoming Features
[[Register-Improvement]]
==== Improving registration `[coming in v2.0]`
Improves the existing `register` command by including role (i.e. privilege system).

Format: `register id/USERNAME pw/PASSWORD n/FULL_NAME r/ROLE_ID` or `reg id/USERNAME pw/PASSWORD n/FULL_NAME r/ROLE_ID`

Examples:

* `register id/azhikai pw/1122qq n/Ang Zhi Kai r/999`
* `reg id/azhikai pw/1122qq n/Ang Zhi Kai r/999`

[[User-Role]]
==== Creating user role `[coming in v2.0]`
Creates a user role. User assigned with higher ranking role can execute more commands. +
[TIP]
====
When the application is in its default state, this command can only be executed by the `root` account
which has the default role of `Administrator`
====
Format: `create-role r/RANK n/ROLE_NAME` or `cr r/RANK n/ROLE_NAME`

Examples:

* `create-role r/999 n/Owner`
* `cr id/999 n/Owner`
* `create-role r/2 n/Supervisor`
* `create-role r/1 n/Employee`

==== Editing user role `[coming in v2.0]`
Edits an existing user role. +
Format: `edit-role r/RANK [nr/NEW_RANK] [n/ROLE_NAME]` or `er r/RANK [nr/NEW_RANK] [n/ROLE_NAME]`

Examples:

* `edit-role r/999 n/Administrator`
* `er id/999 n/Administrator`
* `edit-role r/2 nr/3 n/Manager`

==== Deleting user role `[coming in v2.0]`
Deletes an existing user role. +
Format: `delete-role r/RANK` or `dr r/RANK`

Examples:

* `delete-role r/999`
* `dr id/999`

// tag::salesv20[]
==== Auto-compute sales profit `[coming in v2.0]`
Automatically determines the cost incurred in each sales record and computes its profit. The concept of profit
will be extended to the following features: +
 1) <<display-sales, Section 5.6.2, “Display sales report"">> - Include a profit column in the sales report +
 2) <<chart-sales, Section 5.6.5, “Display sales chart"">> - Display sales chart of date and profit +
 3) <<rank-date, Section 5.6.6, “Ranking dates"">> - Rank dates by profit +
 4) <<rank-item, Section 5.6.7, “Ranking items"">> - Rank items by profit

[NOTE]
====
A negative profit denotes a loss
====

[[check-history]]
==== Checking item sales history `[coming in v2.0]`
Generates the item sales report that consists of all past records associated with that item. +
Format: `check-history n/ITEM_NAME` or `ch n/ITEM_NAME`

Examples:

* `check-history n/Fried Rice`
* `ch n/Fried Rice`

==== Exporting sales report `[coming in v2.0]`
Exports the sales report of a specific date into a pdf file. The generated .pdf sales report will be more
detailed than that displayed in app. +
Format: `export-sales DATE` or `exs DATE`

==== Exporting sales chart `[coming in v2.0]`
Exports the sales chart into a pdf file. +
Format: `export-chart` or `exc`
// end::salesv20[]

==== Checking item sales history `[coming in v2.0]`
Generates the item sales report that consists of all records associated with that item. +
Format: `check-history n/ITEM_NAME` or `ch n/ITEM_NAME`

* `check-history n/Fried Rice`
* `ch n/Fried Rice`

==== Showing history of past stock ups and consumption `[coming in v2.0]`

Shows the history of past ingredient stock ups or consumption. +
Format: `view-history [STOCKUP] [CONSUMPTION]`  or `vh [STOCKUP] [CONSUMPTION]`

Examples:

* `view-history stockup`
* `view-history consumption`
* `vh stockup consumption`

// tag::menuv2[]
==== Exporting menu `[coming in v2.0]`

Exports the menu to a particular file path. +
Format: `export-menu fp/FILEPATH fn/FILENAME`

Examples:

* `export-menu fp/test/ fn/menu.txt` +
Export the menu to test folder with the file name `menu.txt`

==== Importing menu `[coming in v2.0]`

Imports an existing menu from specified file path to replace current menu. +
Format: `import-menu fp/FILEPATH fn/FILENAME`

Examples:

* `import-menu fp/test/ fn/menu.txt` +
Import the menu.txt from test folder to replace current menu.

==== Support for multiple menus `[coming in v2.0]`
User will be able to manage multiple menus without the need of exporting and importing for different version of the
current menu.
// end::menuv2[]

== Frequently Asked Questions (FAQ)

*Q: How do I transfer my data to another Computer?* +
*A*: Install the application in the other computer and overwrite the empty data file it creates with the file that
contains the data of your previous *MeNUS* folder.

*Q: Where do I find the latest release of the application?* +
*A*: You can find all releases link:https://github.com/CS2103-AY1819S1-F10-4/main/releases[here].

== Command Summary
[width=""100%"",cols=""10%,<45%,<45%"",options=""header"",]
|=======================================================================
|COMMAND |FORMAT |EXAMPLE
|*Help* |`help` |`help`
|*Clear* |`clear` |`clear`
|*History* |`history` |`history`
|*Undo* |`undo` |`undo`
|*Redo* |`redo` |`redo`
|*Login* |`login id/USERNAME pw/PASSWORD` |`login id/root pw/1122qq`
|*Logout* |`logout` |`logout`
|*Create account* |`register id/USERNAME pw/PASSWORD n/FULL_NAME` |`register id/azhikai pw/1122qq n/Ang Zhi Kai`
|*Change password* |`change-password npw/NEW_PASSWORD` |`change-password npw/newp@55w0rd`
|*Delete account* |`deregister id/USERNAME` |`deregister id/azhikai`
|*Find account* |`find-account KEYWORD` |`find-account root`
|*Select account* |`select-account INDEX` |`select-account 1`
|*List accounts* |`list-accounts` |`list-accounts`
|*Add ingredient* |`add-ingredient n/INGREDIENT_NAME u/UNIT_TYPE p/PRICE_PER_UNIT m/MINIMUM` |`add-ingredient n/cod
fish u/kilogram p/20 m/1`
|*List ingredients* |`list-ingredients` |`list-ingredients`
|*List ingredients with low stock count* |`low-stock` |`low-stock`
|*Edit ingredient* |`edit-ingredient INDEX [n/INGREDIENT_NAME] [u/UNIT_TYPE] [p/PRICE_PER_UNIT] [m/MINIMUM]` or
`edit-ingredient on/ORIGINAL_INGREDIENT_NAME [n/NEW_INGREDIENT_NAME] [u/UNIT_TYPE] [p/PRICE_PER_UNIT] [m/MINIMUM]`
|`edit-ingredient 3 n/thin fries` or `edit-ingredient on/ketchup n/tomato ketchup`
|*Delete ingredient* |`delete-ingredient INDEX` or `delete-ingredient INGREDIENT_NAME` |`delete-ingredient 1` or
`delete-ingredient cod fish`
|*Stock up* |`stockup n/INGREDIENT_NAME... nu/NUMBER_OF_UNITS...` |`stockup n/cod fish nu/5`
|*Select ingredient* |`select-ingredient INDEX` |`select-ingredient 3`
|*Add item* |`add-item n/ITEM_NAME p/ITEM_PRICE [t/TAG]...` |`add-item n/Burger Set p/3 t/set`
|*List items* |`list-items` |`list-items`
|*Edit item* |`edit-item INDEX [n/ITEM_NAME] [p/ITEM_PRICE] [t/TAG]...` |`edit-item 2 n/Fries p/3`
|*Delete item by index* |`delete-item-index INDEX` |`delete-item-index 3`
|*Delete item by name* |`delete-item-name ITEM_NAME` |`delete-item-name burger`
|*Select item* |`select-item INDEX` |`select-item 3`
|*Find item* |`find-item KEYWORD [MORE_KEYWORDS]...` |`find-item Cheese Burger`
|*List items* |`list-items` |`list-items`
|*Clear menu* |`clear-menu` |`clear-menu`
|*Filter menu* |`filter-menu KEYWORD [MORE_KEYWORDS]...` |`filter-menu cheese`
|*Sort menu* |`sort-menu SORTING_METHOD` |`sort-menu NAME`
|*Discount item* |`discount-item INDEX/ALL [ei/INDEX] dp/PERCENTAGE` |`discount-item 2 dp/20`
|*Today's special* |`today-special` |`today-special`
|*Add recipe to item* |`recipe-item r/RECIPE` |`recipe-item r/some recipe`
|*Add required ingredients to item* |`add-required-ingredients n/INGREDIENT_NAME nu/NUMBER_OF_INGREDIENTS`
|`add-required-ingredients n/Apple nu/3`
|*Add reservation* |`add-reservation n/NAME px/PAX d/DATE ti/TIME` |`add-reservation n/TAN px/4 d/21-07-2019 ti/10:00`
|*Edit reservation* |`edit-reservation INDEX [n/NAME] [px/PAX] [d/DATE] [ti/TIME]` |`edit-reservation 2 px/2`
|*Delete reservation* |`delete-reservation INDEX` |`delete-reservation 2`
|*Select reservation* |`select-reservation INDEX` |`select-reservation 1`
|*List reservation* |`list-reservations` |`list-reservations`
|*Sort reservation* |`sort-reservations` |`sort-reservations`
|*Record sales volume* |`record-sales d/DATE n/ITEM_NAME q/QUANTITY_SOLD p/ITEM_PRICE` |`record-sales d/25-09-2018 n/Fried Rice q/35 p/5.50`
|*Display sales report* |`display-sales DATE` |`display-sales 25-09-2018`
|*Edit sales record* |`edit-sales INDEX [d/DATE] [n/ITEM_NAME] [q/QUANTITY_SOLD] [p/ITEM_PRICE]` |`edit-sales 3 n/Fried Omelet p/7.99`
|*Delete sales record* |`delete-sales INDEX` |`delete-sales 2`
|*Display sales chart* |`chart-sales` |`chart-sales`
|*Rank items by total revenue* |`rank-item` |`rank-item`
|*Rank dates by total revenue* |`rank-date` | `rank-date`
|*Select sales record* |`select-sales INDEX` |`select-sales 3`
|=======================================================================

[appendix]
== Acronyms

[[gui]] GUI::
*Graphical User Interface* allows the use of icons or other visual indicators to interact with electronic devices,
rather than using only text via the command line.

// tag::salesglossary[]
[[sales-record]] Sales record::
A *sales record* is created whenever you <<record-sales, record the sales volume of an item>>. It is represented by a
single entry in the record list. It comprises 6 different attributes, namely +
1) `Date` of which the item was sold +
2) `Name` of the item +
3) `Quantity` of the item sold +
4) `Price` per item +
5) `Total revenue` earned +
6) `Ingredient used` to make the amount of item as specified by the quantity sold. +

[[record-list]] Record list::
The *record list* contains all the sales records you have recorded till date. It is shown under the
`List of data` section of the sales component in MeNUS's <<user-interface, user interface>>.
// end::salesglossary[]
",12236,False,2374.035147474453,median
"/*
 constraint.cpp

 Copyright (c) 2014, 2015, 2016 Terumasa Tadano

 This file is distributed under the terms of the MIT license.
 Please see the file 'LICENCE.txt' in the root directory 
 or http://opensource.org/licenses/mit-license.php for information.
*/

#include ""constraint.h""
#include ""combination.h""
#include ""constants.h""
#include ""error.h""
#include ""fcs.h""
#include ""cluster.h""
#include ""mathfunctions.h""
#include ""memory.h""
#include ""rref.h""
#include ""symmetry.h""
#include ""system.h""
#include ""timer.h""
#include ""xml_parser.h""
#include <iostream>
#include <iomanip>
#include <boost/bimap.hpp>
#include <algorithm>
#include <unordered_set>
#include <map>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>
#include <boost/foreach.hpp>
#include <boost/lexical_cast.hpp>

using namespace ALM_NS;

Constraint::Constraint()
{
    set_default_variables();
}

Constraint::~Constraint()
{
    deallocate_variables();
}

void Constraint::set_default_variables()
{
    constraint_mode = 11;
    rotation_axis = """";
    fix_harmonic = false;
    fix_cubic = false;
    constraint_algebraic = 1;
    fc2_file = """";
    fc3_file = """";
    exist_constraint = false;
    extra_constraint_from_symmetry = false;
    const_mat = nullptr;
    const_rhs = nullptr;
    const_symmetry = nullptr;
    const_fix = nullptr;
    const_relate = nullptr;
    const_relate_rotation = nullptr;
    index_bimap = nullptr;
    number_of_constraints = 0;
    tolerance_constraint = eps8;
}

void Constraint::deallocate_variables()
{
    if (const_symmetry) {
        deallocate(const_symmetry);
    }
    if (const_fix) {
        deallocate(const_fix);
    }
    if (const_relate) {
        deallocate(const_relate);
    }
    if (const_relate_rotation) {
        deallocate(const_relate_rotation);
    }
    if (index_bimap) {
        deallocate(index_bimap);
    }
    if (const_mat) {
        deallocate(const_mat);
    }
    if (const_rhs) {
        deallocate(const_rhs);
    }
}

void Constraint::setup(const System *system,
                       const Fcs *fcs,
                       const Cluster *cluster,
                       const Symmetry *symmetry,
                       const int linear_model,
                       const int verbosity,
                       Timer *timer)
{
    timer->start_clock(""constraint"");

    if (verbosity > 0) {
        std::cout << "" CONSTRAINT"" << std::endl;
        std::cout << "" =========="" << std::endl << std::endl;
    }

    constraint_algebraic = constraint_mode / 10;
    constraint_mode = constraint_mode % 10;
    const auto maxorder = cluster->get_maxorder();

    if (linear_model == 2) {
        if (constraint_mode > 1) {
            warn(""Constraint::setup"", ""Sorry, only ICONST = 11 is supported \\n""
                                      ""                      when LMODEL = enet. We set ICONST = 11 in this run.\\n"");
            constraint_mode = 1;
        }
        constraint_algebraic = 1;
    }

    switch (constraint_mode) {
        case 0: // do nothing
            impose_inv_T = false;
            impose_inv_R = false;
            if (verbosity > 0) {
                std::cout << ""  ICONST = 0: Constraint for translational/rotational invariance"" << std::endl;
                std::cout << ""              will NOT be considered."" << std::endl;
            }
            break;
        case 1:
            impose_inv_T = true;
            impose_inv_R = false;
            if (verbosity > 0) {
                std::cout << ""  ICONST = 1: Constraints for translational invariance"" << std::endl;
                std::cout << ""              will be considered."" << std::endl;
            }
            break;
        case 2:
            impose_inv_T = true;
            impose_inv_R = true;
            exclude_last_R = true;
            if (verbosity > 0) {
                std::cout << ""  ICONST = 2: Constraints for translational and rotational invariance"" << std::endl;
                std::cout << ""              will be considered. Axis of rotation is "" << rotation_axis << std::endl;
                std::cout << ""              Rotational invariance of the maximum order will be neglected"" << std::endl;
            }
            break;
        case 3:
            impose_inv_T = true;
            impose_inv_R = true;
            exclude_last_R = false;
            if (verbosity > 0) {
                std::cout << ""  ICONST = 3: Constraints for translational and rotational invariance"" << std::endl;
                std::cout << ""              will be considered. Axis of rotation is "" << rotation_axis << std::endl;
            }
            break;
        default:
            exit(""Constraint::setup"", ""invalid constraint_mode"", constraint_mode);
            break;
    }

    if (fcs->get_forceconstant_basis() == ""Lattice"" && impose_inv_R) {
        exit(""Constraint::setup()"", ""Sorry, rotational invariance with FCSYM_BASIS = Lattice is ""
                                    ""not supported.\\n Use FCSYM_BASIS = Cartesian instead."");
    }

    if (verbosity > 0) std::cout << std::endl;

    if (const_symmetry) {
        deallocate(const_symmetry);
    }
    if (const_fix) {
        deallocate(const_fix);
    }
    if (const_relate) {
        deallocate(const_relate);
    }
    if (index_bimap) {
        deallocate(index_bimap);
    }

    allocate(const_fix, maxorder);
    allocate(const_relate, maxorder);
    allocate(index_bimap, maxorder);
    allocate(const_symmetry, maxorder);
    allocate(const_translation, maxorder);
    allocate(const_rotation_self, maxorder);
    allocate(const_rotation_cross, maxorder);
    allocate(const_self, maxorder);

    for (auto order = 0; order < maxorder; ++order) {
        const_translation[order].clear();
        const_rotation_self[order].clear();
        const_rotation_cross[order].clear();
        const_self[order].clear();
        const_fix[order].clear();
    }

    if (fix_harmonic) {

        if (verbosity > 0) {
            std::cout << ""  FC2XML is given : Harmonic force constants will be "" << std::endl;
            std::cout << ""                    fixed to the values given in "" << fc2_file << std::endl;
            std::cout << std::endl;
        }

        fix_forceconstants_to_file(0,
                                   symmetry,
                                   fcs,
                                   fc2_file,
                                   const_fix[0]);
    }

    fix_cubic = fix_cubic & (cluster->get_maxorder() > 1);
    if (fix_cubic) {

        if (verbosity > 0) {
            std::cout << ""  FC3XML is given : Cubic force constants will be "" << std::endl;
            std::cout << ""                    fixed to the values given in "" << fc3_file << std::endl;
            std::cout << std::endl;
        }

        fix_forceconstants_to_file(1,
                                   symmetry,
                                   fcs,
                                   fc3_file,
                                   const_fix[1]);
    }

    generate_symmetry_constraint_in_cartesian(system->get_supercell().number_of_atoms,
                                              symmetry,
                                              cluster,
                                              fcs,
                                              verbosity);


    extra_constraint_from_symmetry = false;

    for (auto order = 0; order < cluster->get_maxorder(); ++order) {
        if (!const_symmetry[order].empty()) extra_constraint_from_symmetry = true;
    }

    if (impose_inv_T) {
        // const_translation is updated.
        generate_translational_constraint(system->get_supercell(),
                                          symmetry,
                                          cluster,
                                          fcs,
                                          verbosity);
    }

    if (impose_inv_R) {
        generate_rotational_constraint(system,
                                       symmetry,
                                       cluster,
                                       fcs,
                                       verbosity,
                                       tolerance_constraint);
    }

    // Merge intra-order constrants and do reduction

    for (auto order = 0; order < maxorder; ++order) {

        const auto nparam = fcs->get_nequiv()[order].size();

        const_self[order].reserve(
                const_translation[order].size()
                + const_rotation_self[order].size()
                + const_symmetry[order].size());

        // The order of const_symmetry and const_translation
        // should not be changed since the rref_sparse is sensitive to
        // the numerical accuracy of the input matrix.
        const_self[order].insert(const_self[order].end(),
                                 const_symmetry[order].begin(),
                                 const_symmetry[order].end());

        const_self[order].insert(const_self[order].end(),
                                 const_translation[order].begin(),
                                 const_translation[order].end());

        const_self[order].insert(const_self[order].end(),
                                 const_rotation_self[order].begin(),
                                 const_rotation_self[order].end());

//        rref_sparse(nparam, const_self[order], tolerance_constraint);
        rref_sparse(nparam, const_self[order], tolerance_constraint);
    }

    get_mapping_constraint(maxorder,
                           fcs->get_nequiv(),
                           const_self,
                           const_fix,
                           const_relate,
                           index_bimap);

#ifdef _DEBUG
    for (auto order = 0; order < maxorder; ++order) {
        std::cout << ""const_relate:\\n"";

        for (const auto &it: const_relate[order]) {
            std::cout << std::setw(5) << it.p_index_target;
            std::cout << "" : "";
            for (auto m = 0; m < it.alpha.size(); ++m) {
                std::cout << ""("" << std::setw(15) << it.alpha[m] << "", "" << std::setw(5) << it.p_index_orig[m] << "") "";
            }
            std::cout << std::endl;
        }

        std::cout << ""\\nindex_bimap:\\n"";

        for (const auto &it: index_bimap[order]) {
            std::cout << std::setw(5) << it.left << "" <--> "" << it.right << std::endl;
        }

    }

#endif

    if (!constraint_algebraic) {

        size_t Pmax = 0;
        size_t nparams = 0;
        for (auto order = 0; order < maxorder; ++order) {
            Pmax += const_self[order].size()
                    + const_rotation_cross[order].size();
        }
        if (fix_harmonic) {
            Pmax -= const_self[0].size();
            Pmax += fcs->get_nequiv()[0].size();
        }
        if (fix_cubic) {
            Pmax -= const_self[1].size();
            Pmax += fcs->get_nequiv()[1].size();
        }
        for (auto order = 0; order < maxorder; ++order) {
            nparams += fcs->get_nequiv()[order].size();
        }

        if (const_mat) {
            deallocate(const_mat);
        }
        allocate(const_mat, Pmax, nparams);

        if (const_rhs) {
            deallocate(const_rhs);
        }
        allocate(const_rhs, Pmax);

        // const_mat and const_rhs are updated.
        number_of_constraints = calc_constraint_matrix(maxorder,
                                                       fcs->get_nequiv(),
                                                       nparams);
    }

    exist_constraint
            = impose_inv_T
              || fix_harmonic
              || fix_cubic
              || extra_constraint_from_symmetry;

    if (verbosity > 0) {
        if (exist_constraint) {

            int order;

            if (impose_inv_T || impose_inv_R) {
                std::cout << ""  Number of constraints [T-inv, R-inv (self), R-inv (cross)]:"" << std::endl;
                for (order = 0; order < maxorder; ++order) {
                    std::cout << ""   "" << std::setw(8) << cluster->get_ordername(order);
                    std::cout << "" "" << std::setw(6) << const_translation[order].size();
                    std::cout << std::setw(5) << const_rotation_self[order].size();
                    std::cout << std::setw(5) << const_rotation_cross[order].size();
                    std::cout << std::endl;
                }
                std::cout << std::endl;
            }

            if (extra_constraint_from_symmetry) {
                std::cout << ""  There are constraints from crystal symmetry."" << std::endl;
                std::cout << ""  The number of such constraints for each order:"" << std::endl;
                for (order = 0; order < maxorder; ++order) {
                    std::cout << ""   "" << std::setw(8) << cluster->get_ordername(order);
                    std::cout << "" "" << std::setw(6) << const_symmetry[order].size();
                    std::cout << std::endl;
                }
                std::cout << std::endl;
            }

            if (extra_constraint_from_symmetry) {
                std::cout << ""  Constraints of T-inv, R-inv (self), and those from crystal symmetry are merged.""
                          << std::endl;
            } else {
                std::cout << ""  Constraints of T-inv and R-inv (self) are merged."" << std::endl;
            }
            std::cout << ""  If there are redundant constraints, they are removed in this process."" << std::endl;
            std::cout << std::endl;
            std::cout << ""  Number of inequivalent constraints (self, cross) : "" << std::endl;

            for (order = 0; order < maxorder; ++order) {
                std::cout << ""   "" << std::setw(8) << cluster->get_ordername(order);
                std::cout << "" "" << std::setw(6) << const_self[order].size();
                std::cout << std::setw(5) << const_rotation_cross[order].size();
                std::cout << std::endl;
            }
            std::cout << std::endl;

            if (constraint_algebraic) {

                std::cout << ""  ICONST >= 10 : Constraints will be considered algebraically.""
                          << std::endl << std::endl;

                if (impose_inv_R) {
                    std::cout << ""  WARNING : Inter-order constraints for rotational invariance will be neglected.""
                              << std::endl;
                }

                for (order = 0; order < maxorder; ++order) {
                    std::cout << ""  Number of free"" << std::setw(9) << cluster->get_ordername(order)
                              << "" FCs : "" << index_bimap[order].size() << std::endl;
                }
                std::cout << std::endl;

            } else {

                std::cout << ""  Total number of constraints = "" << number_of_constraints << std::endl << std::endl;

            }
        }
        timer->print_elapsed();
        std::cout << "" -------------------------------------------------------------------"" << std::endl;
        std::cout << std::endl;
    }


    deallocate(const_translation);
    const_translation = nullptr;
    deallocate(const_rotation_self);
    const_rotation_self = nullptr;
    deallocate(const_rotation_cross);
    const_rotation_cross = nullptr;
    deallocate(const_self);
    const_self = nullptr;

    timer->stop_clock(""constraint"");
}

size_t Constraint::calc_constraint_matrix(const int maxorder,
                                          const std::vector<size_t> *nequiv,
                                          const size_t nparams) const
{
    size_t i, j;
    int order;
    double *arr_tmp;
    std::vector<ConstraintClass> const_total;

    const_total.clear();
    allocate(arr_tmp, nparams);

    size_t nshift = 0;

    for (order = 0; order < maxorder; ++order) {
        const auto nelems = nequiv[order].size();

        if (const_fix[order].empty()) {
            for (auto &p: const_self[order]) {
                for (i = 0; i < nparams; ++i) arr_tmp[i] = 0.0;
                for (const auto &it: p) {
                    arr_tmp[nshift + it.first] = it.second;
                }
                const_total.emplace_back(nparams, arr_tmp);
            }
        }
        nshift += nelems;
    }


    const auto nconst1 = const_total.size();

    // Inter-order constraints
    size_t nshift2 = 0;
    for (order = 0; order < maxorder; ++order) {
        if (order > 0) {
            if (const_fix[order - 1].empty() && const_fix[order].empty()) {
                for (auto &p: const_rotation_cross[order]) {
                    for (i = 0; i < nparams; ++i) arr_tmp[i] = 0.0;
                    for (const auto &it: p) {
                        arr_tmp[nshift2 + it.first] = it.second;
                    }
                    const_total.emplace_back(nparams, arr_tmp);
                }
            }

            nshift2 += nequiv[order - 1].size();
        }
    }
    deallocate(arr_tmp);

    if (nconst1 != const_total.size())
        remove_redundant_rows(nparams, const_total, tolerance_constraint);

    auto nconst = const_total.size();

    if (fix_harmonic) nconst += nequiv[0].size();
    if (fix_cubic) nconst += nequiv[1].size();

    for (i = 0; i < nconst; ++i) {
        for (j = 0; j < nparams; ++j) {
            const_mat[i][j] = 0.0;
        }
        const_rhs[i] = 0.0;
    }

    size_t irow = 0;
    size_t icol = 0;
    size_t ishift = 0;

    if (fix_harmonic) {

        for (const auto &p: const_fix[0]) {
            i = p.p_index_target;
            const_mat[i][i] = 1.0;
            const_rhs[i] = p.val_to_fix;
        }

        irow += const_fix[0].size();
        icol += const_fix[0].size();
        ishift += const_fix[0].size();
    }

    if (fix_cubic && maxorder > 1) {

        const auto ishift2 = nequiv[0].size();

        for (const auto &p: const_fix[1]) {
            i = p.p_index_target;
            const_mat[i + ishift][i + ishift2] = 1.0;
            const_rhs[i + ishift] = p.val_to_fix;
        }

        irow += const_fix[1].size();
        icol += const_fix[1].size();
    }

    for (auto &p: const_total) {
        for (i = 0; i < nparams; ++i) {
            const_mat[irow][i] = p.w_const[i];
        }
        ++irow;
    }
    const_total.clear();

    return nconst;
}


void Constraint::get_mapping_constraint(const int nmax,
                                        const std::vector<size_t> *nequiv,
                                        const ConstraintSparseForm *const_in,
                                        std::vector<ConstraintTypeFix> *const_fix_out,
                                        std::vector<ConstraintTypeRelate> *const_relate_out,
                                        boost::bimap<size_t, size_t> *index_bimap_out) const
{
    // If const_fix_out[order] is not empty as input, it assumes that fix_forceconstant[order] is true.
    // In this case, const_fix_out[order] is not updated.

    int order;
    size_t i;

    std::vector<ConstraintDoubleElement> ConstVec;

    for (order = 0; order < nmax; ++order) {

        if (const_fix_out[order].empty()) {

            size_t p_index_target;
            std::vector<double> alpha_tmp;
            std::vector<size_t> p_index_tmp;

            for (auto p = const_in[order].rbegin(); p != const_in[order].rend(); ++p) {

                alpha_tmp.clear();
                p_index_tmp.clear();

#ifndef _USE_MAP_FOR_CONSTRAINT
                ConstVec.clear();
                ConstVec.reserve((*p).size());
                for (const auto &p2: (*p)) {
                    ConstVec.emplace_back(p2.first, p2.second);
                }
                std::sort(ConstVec.begin(), ConstVec.end());

                p_index_target = ConstVec[0].col;

                auto nsize = ConstVec.size();
                alpha_tmp.resize(nsize - 1);
                p_index_tmp.resize(nsize - 1);

                for (i = 1; i < nsize; ++i) {
                    alpha_tmp[i - 1] = ConstVec[i].val;
                    p_index_tmp[i - 1] = ConstVec[i].col;
                }

#else
                auto counter = 0;
                for (const auto &p2 : (*p)) {
                    if (counter == 0) {
                        p_index_target = p2.first;
                    } else {
                        alpha_tmp.push_back(p2.second);
                        p_index_tmp.push_back(p2.first);
                }
                    ++counter;
                    }
#endif

                if (!alpha_tmp.empty()) {
                    const_relate_out[order].emplace_back(p_index_target,
                                                         alpha_tmp, p_index_tmp);
                } else {
                    const_fix_out[order].emplace_back(p_index_target, 0.0);
                }
            }
        }
    }

    std::vector<int> *has_constraint;
    allocate(has_constraint, nmax);
    size_t nparam;
    for (order = 0; order < nmax; ++order) {

        nparam = nequiv[order].size();
        has_constraint[order].resize(nparam, 0);

        for (i = 0; i < const_fix_out[order].size(); ++i) {
            has_constraint[order][const_fix_out[order][i].p_index_target] = 1;
        }

        for (i = 0; i < const_relate_out[order].size(); ++i) {
            has_constraint[order][const_relate_out[order][i].p_index_target] = 2;
        }
    }

    size_t icount;

    for (order = 0; order < nmax; ++order) {
        nparam = nequiv[order].size();

        icount = 0;
        for (i = 0; i < nparam; ++i) {
            if (has_constraint[order][i] == 0) {
                index_bimap_out[order].insert(
                        boost::bimap<size_t, size_t>::value_type(icount, i));
                ++icount;
            }
        }
    }

    deallocate(has_constraint);
}

int Constraint::get_constraint_mode() const
{
    return constraint_mode;
}

void Constraint::set_constraint_mode(const int constraint_mode_in)
{
    constraint_mode = constraint_mode_in;
}

size_t Constraint::get_number_of_constraints() const
{
    return number_of_constraints;
}

std::string Constraint::get_fc_file(const int order) const
{
    switch (order) {
        case 2:
            return fc2_file;
        case 3:
            return fc3_file;
        default:
            return """";
    }
}

void Constraint::set_fc_file(const int order,
                             const std::string fc_file)
{
    switch (order) {
        case 2:
            fc2_file = fc_file;
            break;
        case 3:
            fc3_file = fc_file;
            break;
        default:
            break;
    }
}

bool Constraint::get_fix_harmonic() const
{
    return fix_harmonic;
}

void Constraint::set_fix_harmonic(const bool fix_harmonic_in)
{
    fix_harmonic = fix_harmonic_in;
}

bool Constraint::get_fix_cubic() const
{
    return fix_cubic;
}

void Constraint::set_fix_cubic(const bool fix_cubic_in)
{
    fix_cubic = fix_cubic_in;
}

int Constraint::get_constraint_algebraic() const
{
    return constraint_algebraic;
}

double **Constraint::get_const_mat() const
{
    return const_mat;
}

double *Constraint::get_const_rhs() const
{
    return const_rhs;
}

double Constraint::get_tolerance_constraint() const
{
    return tolerance_constraint;
}

void Constraint::set_tolerance_constraint(const double tol)
{
    tolerance_constraint = tol;
}

bool Constraint::get_exist_constraint() const
{
    return exist_constraint;
}

bool Constraint::get_extra_constraint_from_symmetry() const
{
    return extra_constraint_from_symmetry;
}

std::string Constraint::get_rotation_axis() const
{
    return rotation_axis;
}

void Constraint::set_rotation_axis(const std::string rotation_axis_in)
{
    rotation_axis = rotation_axis_in;
}

const ConstraintSparseForm &Constraint::get_const_symmetry(const int order) const
{
    return const_symmetry[order];
}

const std::vector<ConstraintTypeFix> &Constraint::get_const_fix(const int order) const
{
    return const_fix[order];
}

void Constraint::set_const_fix_val_to_fix(const int order,
                                          const size_t idx,
                                          const double val)
{
    const_fix[order][idx].val_to_fix = val;
}

const std::vector<ConstraintTypeRelate> &Constraint::get_const_relate(const int order) const
{
    return const_relate[order];
}

const boost::bimap<size_t, size_t> &Constraint::get_index_bimap(const int order) const
{
    return index_bimap[order];
}

void Constraint::generate_symmetry_constraint_in_cartesian(const size_t nat,
                                                           const Symmetry *symmetry,
                                                           const Cluster *cluster,
                                                           const Fcs *fcs,
                                                           const int verbosity) const
{
    // Create constraint matrices arising from the crystal symmetry.

    const auto maxorder = cluster->get_maxorder();
    auto has_constraint_from_symm = false;
    std::vector<std::vector<double>> const_tmp;

    if (fcs->get_forceconstant_basis() == ""Cartesian"") {
        for (auto isym = 0; isym < symmetry->get_nsym(); ++isym) {
            if (!symmetry->get_SymmData()[isym].compatible_with_cartesian) {
                has_constraint_from_symm = true;
                break;
            }
        }
    } else {
        for (auto isym = 0; isym < symmetry->get_nsym(); ++isym) {
            if (!symmetry->get_SymmData()[isym].compatible_with_lattice) {
                has_constraint_from_symm = true;
                break;
            }
        }
    }

    has_constraint_from_symm = has_constraint_from_symm & (verbosity > 0);

    if (has_constraint_from_symm) {
        std::cout << ""  Generating constraints from crystal symmetry"" << std::endl;
        if (fcs->get_forceconstant_basis() == ""Lattice"") {
            std::cout << ""  in crystallographic (fractional) coordinates ..."" << std::endl;
        } else {
            std::cout << ""  in Cartesian coordinates ..."" << std::endl;
        }
    }

    for (auto order = 0; order < maxorder; ++order) {
        if (has_constraint_from_symm) {
            std::cout << ""   "" << std::setw(8) << cluster->get_ordername(order);
        }

        if (fcs->get_forceconstant_basis() == ""Lattice"") {
            fcs->get_constraint_symmetry_in_integer(nat,
                                                    symmetry,
                                                    order,
                                                    fcs->get_forceconstant_basis(),
                                                    fcs->get_fc_table()[order],
                                                    fcs->get_nequiv()[order].size(),
                                                    tolerance_constraint,
                                                    const_symmetry[order], true);
        } else {
            fcs->get_constraint_symmetry(nat,
                                         symmetry,
                                         order,
                                         fcs->get_forceconstant_basis(),
                                         fcs->get_fc_table()[order],
                                         fcs->get_nequiv()[order].size(),
                                         tolerance_constraint,
                                         const_symmetry[order], true);
        }

        if (has_constraint_from_symm) {
            std::cout << "" done."" << std::endl;
        }
    }

    if (has_constraint_from_symm) {
        std::cout << ""  Finished !"" << std::endl << std::endl;
    }
}


void Constraint::generate_translational_constraint(const Cell &supercell,
                                                   const Symmetry *symmetry,
                                                   const Cluster *cluster,
                                                   const Fcs *fcs,
                                                   const int verbosity) const
{
    // Create constraint matrix for the translational invariance (aka acoustic sum rule).

    if (verbosity > 0) {
        std::cout << ""  Generating constraints for translational invariance ..."" << std::endl;
    }

    for (auto order = 0; order < cluster->get_maxorder(); ++order) {

        if (verbosity > 0)
            std::cout << ""   "" << std::setw(8) << cluster->get_ordername(order) << "" ..."";

        const auto nparams = fcs->get_nequiv()[order].size();

        if (nparams == 0) {
            if (verbosity > 0) std::cout << ""  No parameters! Skipped."" << std::endl;
            continue;
        }

        get_constraint_translation(supercell,
                                   symmetry,
                                   cluster,
                                   fcs,
                                   order,
                                   fcs->get_fc_table()[order],
                                   fcs->get_nequiv()[order].size(),
                                   const_translation[order], true);

        if (verbosity > 0) std::cout << "" done."" << std::endl;
    }

    if (verbosity > 0) std::cout << ""  Finished !"" << std::endl << std::endl;
}


void Constraint::get_constraint_translation(const Cell &supercell,
                                            const Symmetry *symmetry,
                                            const Cluster *cluster,
                                            const Fcs *fcs,
                                            const int order,
                                            const std::vector<FcProperty> &fc_table,
                                            const size_t nparams,
                                            ConstraintSparseForm &const_out,
                                            const bool do_rref) const
{
    // Generate equality constraint for the acoustic sum rule.

    int i, j;
    int iat, jat, icrd, jcrd;
    int idata;
    int loc_nonzero;

    int *ind;
    int *intarr, *intarr_copy;
    int **xyzcomponent;

    int ixyz;
    const auto natmin = symmetry->get_nat_prim();
    const auto nat = supercell.number_of_atoms;

    unsigned int isize;

    std::vector<int> data;
    std::unordered_set<FcProperty> list_found;
    std::unordered_set<FcProperty>::iterator iter_found;
    std::vector<std::vector<int>> data_vec;
    std::vector<FcProperty> list_vec;
    std::vector<int> const_now;

    typedef std::vector<ConstraintIntegerElement> ConstEntry;
    std::vector<ConstEntry> constraint_all;

    ConstEntry const_tmp;

    if (order < 0) return;

    if (nparams == 0) return;

    allocate(ind, order + 2);

    // Create force constant table for search

    list_found.clear();

    for (const auto &p: fc_table) {
        for (i = 0; i < order + 2; ++i) {
            ind[i] = p.elems[i];
        }
        if (list_found.find(FcProperty(order + 2, p.sign,
                                       ind, p.mother)) != list_found.end()) {
            exit(""get_constraint_translation"", ""Duplicate interaction list found"");
        }
        list_found.insert(FcProperty(order + 2, p.sign,
                                     ind, p.mother));
    }

    deallocate(ind);

    // Generate xyz component for each order

    const auto nxyz = static_cast<int>(std::pow(static_cast<double>(3), order + 1));
    allocate(xyzcomponent, nxyz, order + 1);
    fcs->get_xyzcomponent(order + 1, xyzcomponent);

    allocate(intarr, order + 2);
    allocate(intarr_copy, order + 2);

    const_now.resize(nparams);

    for (i = 0; i < natmin; ++i) {

        iat = symmetry->get_map_p2s()[i][0];

        // Generate atom pairs for each order

        if (order == 0) {


            for (icrd = 0; icrd < 3; ++icrd) {

                intarr[0] = 3 * iat + icrd;

                for (jcrd = 0; jcrd < 3; ++jcrd) {

                    // Reset the temporary array for another constraint
                    for (j = 0; j < nparams; ++j) const_now[j] = 0;

                    for (jat = 0; jat < 3 * nat; jat += 3) {
                        intarr[1] = jat + jcrd;

                        iter_found = list_found.find(FcProperty(order + 2, 1.0,
                                                                intarr, 1));

                        //  If found an IFC
                        if (iter_found != list_found.end()) {
                            // Round the coefficient to integer
                            const_now[(*iter_found).mother] += nint((*iter_found).sign);
                        }

                    }
                    // Add to the constraint list
                    if (!is_allzero(const_now, loc_nonzero)) {
                        if (const_now[loc_nonzero] < 0) {
                            for (j = 0; j < nparams; ++j) const_now[j] *= -1;
                        }
                        const_tmp.clear();
                        for (j = 0; j < nparams; ++j) {
                            if (std::abs(const_now[j]) > 0) {
                                const_tmp.emplace_back(j, const_now[j]);
                            }
                        }
                        constraint_all.emplace_back(const_tmp);
                    }
                }
            }

        } else {

            // Anharmonic cases

            auto intlist(cluster->get_interaction_pair(order, i));
            std::sort(intlist.begin(), intlist.end());

            data_vec.clear();
            // Generate data_vec that contains possible interacting clusters.
            // Each cluster contains (order + 1) atoms, and the last atom index
            // will be treated seperately below.
            CombinationWithRepetition<int> g2(intlist.begin(), intlist.end(), order);
            do {
                data = g2.now();

                intarr[0] = iat;

                for (isize = 0; isize < data.size(); ++isize) {
                    intarr[isize + 1] = data[isize];
                }

                if (cluster->satisfy_nbody_rule(order + 1, intarr, order)) {
                    if (cluster->is_incutoff(order + 1, intarr, order, supercell.kind)) {
                        // Add to list if the atoms interact with each other.
                        data_vec.push_back(data);
                    }
                }

            } while (g2.next());

            const auto ndata = data_vec.size();

            // Use openmp for acceleration if possible
#ifdef _OPENMP
#pragma omp parallel
#endif
            {
                int *intarr_omp, *intarr_copy_omp;

                allocate(intarr_omp, order + 2);
                allocate(intarr_copy_omp, order + 2);

                std::vector<int> data_omp;
                std::vector<int> const_now_omp;

                ConstEntry const_tmp_omp;
                std::vector<ConstEntry> constraint_list_omp;

                const_now_omp.resize(nparams);
#ifdef _OPENMP
#pragma omp for private(isize, ixyz, jcrd, j, jat, iter_found, loc_nonzero), schedule(guided), nowait
#endif
                for (idata = 0; idata < ndata; ++idata) {

                    data_omp = data_vec[idata];

                    intarr_omp[0] = iat;
                    for (isize = 0; isize < data_omp.size(); ++isize) {
                        intarr_omp[isize + 1] = data_omp[isize];
                    }

                    // Loop for xyz component
                    for (ixyz = 0; ixyz < nxyz; ++ixyz) {
                        // Loop for the xyz index of the last atom
                        for (jcrd = 0; jcrd < 3; ++jcrd) {

                            // Reset the temporary array for another constraint
                            for (j = 0; j < nparams; ++j) const_now_omp[j] = 0;

                            // Loop for the last atom index
                            for (jat = 0; jat < 3 * nat; jat += 3) {
                                intarr_omp[order + 1] = jat / 3;

                                if (cluster->satisfy_nbody_rule(order + 2, intarr_omp, order)) {
                                    for (j = 0; j < order + 1; ++j) {
                                        intarr_copy_omp[j] = 3 * intarr_omp[j] + xyzcomponent[ixyz][j];
                                    }
                                    intarr_copy_omp[order + 1] = jat + jcrd;

                                    sort_tail(order + 2, intarr_copy_omp);

                                    iter_found = list_found.find(FcProperty(order + 2, 1.0,
                                                                            intarr_copy_omp, 1));
                                    if (iter_found != list_found.end()) {
                                        const_now_omp[(*iter_found).mother] += nint((*iter_found).sign);
                                    }

                                }
                            } // close loop jat

                            // Add the constraint to the private array
                            if (!is_allzero(const_now_omp, loc_nonzero)) {
                                if (const_now_omp[loc_nonzero] < 0) {
                                    for (j = 0; j < nparams; ++j) const_now_omp[j] *= -1;
                                }

                                const_tmp_omp.clear();
                                for (j = 0; j < nparams; ++j) {
                                    if (std::abs(const_now_omp[j]) > 0) {
                                        const_tmp_omp.emplace_back(j, const_now_omp[j]);
                                    }
                                }
                                if (const_tmp_omp.empty()) {
                                    std::cout << ""This cannot happen"" << std::endl;
                                }
                                constraint_list_omp.emplace_back(const_tmp_omp);
                            }
                        }
                    }

                } // close idata (openmp main loop)

                deallocate(intarr_omp);
                deallocate(intarr_copy_omp);

                // Merge vectors
#pragma omp critical
                {
                    for (const auto &it: constraint_list_omp) {
                        constraint_all.emplace_back(it);
                    }
                }
                constraint_list_omp.clear();
            } // close openmp

            intlist.clear();
        } // close if
    }     // close loop i

    deallocate(xyzcomponent);
    deallocate(intarr);
    deallocate(intarr_copy);

    std::sort(constraint_all.begin(), constraint_all.end());
    constraint_all.erase(std::unique(constraint_all.begin(),
                                     constraint_all.end()),
                         constraint_all.end());

    MapConstraintElement const_tmp2;
    auto division_factor = 1.0;
    int counter;
    const_out.clear();

    for (const auto &it: constraint_all) {
        const_tmp2.clear();
        counter = 0;
        for (const auto &it2: it) {
            if (counter == 0) {
                division_factor = 1.0 / it2.val;
            }
            const_tmp2[it2.col] = it2.val * division_factor;
            ++counter;
        }
        const_out.emplace_back(const_tmp2);
    }
    constraint_all.clear();
    if (do_rref) rref_sparse(nparams, const_out, eps8);
}

void Constraint::generate_rotational_constraint(const System *system,
                                                const Symmetry *symmetry,
                                                const Cluster *cluster,
                                                const Fcs *fcs,
                                                const int verbosity,
                                                const double tolerance)
{
    // Create constraints for the rotational invariance

    if (verbosity > 0)
        std::cout << ""  Generating constraints for rotational invariance ..."" << std::endl;

#ifdef _DEBUG
    std::ofstream ofs_constraint;
    ofs_constraint.open(""CONSTRAINT"", std::ios::out);
#endif

    int i, j;
    int iat, jat;
    int icrd, jcrd;
    int order;
    const auto maxorder = cluster->get_maxorder();
    const auto natmin = symmetry->get_nat_prim();
    int mu, nu;
    int ixyz, nxyz{0}, nxyz2;
    int mu_lambda, lambda;
    int levi_factor;

    int *ind;
    int **xyzcomponent = nullptr;
    int **xyzcomponent2 = nullptr;
    size_t *nparams, nparam_sub;
    int *interaction_index, *interaction_atom;
    int *interaction_tmp;
    int loc_nonzero;

    std::vector<double> arr_constraint;
    std::vector<double> arr_constraint_self;
    std::vector<double> arr_constraint_lower;

    bool valid_rotation_axis[3][3];

    double vec_for_rot[3];

    std::vector<int> interaction_list;

    std::unordered_set<FcProperty> list_found;
    std::unordered_set<FcProperty> list_found_last;
    std::unordered_set<FcProperty>::iterator iter_found;

    CombinationWithRepetition<int> g;

    std::vector<int> atom_tmp;
    std::vector<std::vector<int>> cell_dummy;
    std::set<InteractionCluster>::iterator iter_cluster;

    typedef std::vector<ConstraintDoubleElement> ConstEntry;
    ConstEntry const_tmp;
    std::vector<ConstEntry> *const_self_vec, *const_cross_vec;

    allocate(const_self_vec, maxorder);
    allocate(const_cross_vec, maxorder);

    setup_rotation_axis(valid_rotation_axis);

    allocate(ind, maxorder + 1);
    allocate(nparams, maxorder);

    for (order = 0; order < maxorder; ++order) {

        nparams[order] = fcs->get_nequiv()[order].size();

        if (order == 0) {
            if (verbosity > 0) {
                std::cout << ""   Constraints between "" << std::setw(8)
                          << ""1st-order IFCs (which are zero) and ""
                          << std::setw(8) << cluster->get_ordername(order) << "" ..."";
            }

            nparam_sub = nparams[order];
        } else {
            if (verbosity > 0) {
                std::cout << ""   Constraints between "" << std::setw(8)
                          << cluster->get_ordername(order - 1) << "" and ""
                          << std::setw(8) << cluster->get_ordername(order) << "" ..."";
            }

            nparam_sub = nparams[order] + nparams[order - 1];
        }
        arr_constraint.resize(nparam_sub);
        arr_constraint_self.resize(nparams[order]);

        if (order > 0) arr_constraint_lower.resize(nparams[order - 1]);

        allocate(interaction_atom, order + 2);
        allocate(interaction_index, order + 2);
        allocate(interaction_tmp, order + 2);
        const_self_vec[order].clear();
        const_cross_vec[order].clear();

        if (order > 0) {
            list_found_last = list_found;
            nxyz = static_cast<int>(pow(static_cast<double>(3), order));
            allocate(xyzcomponent, nxyz, order);
            fcs->get_xyzcomponent(order, xyzcomponent);
        }

        list_found.clear();

        for (auto p = fcs->get_fc_table()[order].begin(); p != fcs->get_fc_table()[order].end(); ++p) {
            for (i = 0; i < order + 2; ++i) {
                ind[i] = (*p).elems[i];
            }
            list_found.insert(FcProperty(order + 2, (*p).sign,
                                         ind, (*p).mother));
        }

        for (i = 0; i < natmin; ++i) {

            iat = symmetry->get_map_p2s()[i][0];

            interaction_atom[0] = iat;

            if (order == 0) {

                auto interaction_list_now(cluster->get_interaction_pair(order, i));
                std::sort(interaction_list_now.begin(), interaction_list_now.end());

                // Special treatment for harmonic force constants

                for (icrd = 0; icrd < 3; ++icrd) {

                    interaction_index[0] = 3 * iat + icrd;

                    for (mu = 0; mu < 3; ++mu) {

                        for (nu = 0; nu < 3; ++nu) {

                            if (!valid_rotation_axis[mu][nu]) continue;

                            // Clear history

                            for (j = 0; j < nparam_sub; ++j) arr_constraint[j] = 0.0;

                            for (auto &iter_list: interaction_list_now) {

                                jat = iter_list;
                                interaction_index[1] = 3 * jat + mu;
                                iter_found = list_found.find(FcProperty(order + 2, 1.0,
                                                                        interaction_index, 1));

                                atom_tmp.clear();
                                atom_tmp.push_back(jat);
                                cell_dummy.clear();
                                iter_cluster = cluster->get_interaction_cluster(order, i).find(
                                        InteractionCluster(atom_tmp, cell_dummy));

                                if (iter_cluster == cluster->get_interaction_cluster(order, i).end()) {
                                    exit(""generate_rotational_constraint"",
                                         ""cluster not found ..."");
                                } else {
                                    for (j = 0; j < 3; ++j) vec_for_rot[j] = 0.0;

                                    const auto nsize_equiv = (*iter_cluster).cell.size();

                                    for (j = 0; j < nsize_equiv; ++j) {
                                        for (auto k = 0; k < 3; ++k) {
                                            vec_for_rot[k]
                                                    += system->get_x_image()[(*iter_cluster).cell[j][0]][jat][k];
                                        }
                                    }

                                    for (j = 0; j < 3; ++j) {
                                        vec_for_rot[j] /= static_cast<double>(nsize_equiv);
                                    }
                                }


                                if (iter_found != list_found.end()) {
                                    arr_constraint[(*iter_found).mother] += (*iter_found).sign * vec_for_rot[nu];
                                }

                                // Exchange mu <--> nu and repeat again. 
                                // Note that the sign is inverted (+ --> -) in the summation

                                interaction_index[1] = 3 * jat + nu;
                                iter_found = list_found.find(FcProperty(order + 2, 1.0,
                                                                        interaction_index, 1));
                                if (iter_found != list_found.end()) {
                                    arr_constraint[(*iter_found).mother]
                                            -= (*iter_found).sign * vec_for_rot[mu];
                                }
                            }

                            if (!is_allzero(arr_constraint, tolerance, loc_nonzero)) {
                                // Add to constraint list
                                if (arr_constraint[loc_nonzero] < 0.0) {
                                    for (j = 0; j < nparam_sub; ++j) arr_constraint[j] *= -1.0;
                                }
                                const_tmp.clear();
                                for (j = 0; j < nparam_sub; ++j) {
                                    if (std::abs(arr_constraint[j]) >= tolerance) {
                                        const_tmp.emplace_back(j, arr_constraint[j]);
                                    }
                                }
                                const_self_vec[order].emplace_back(const_tmp);
                            }

                        } // nu
                    }     // mu
                }
            } else {

                // Constraint between different orders

                auto interaction_list_now(cluster->get_interaction_pair(order, i));
                auto interaction_list_old(cluster->get_interaction_pair(order - 1, i));
                std::sort(interaction_list_now.begin(), interaction_list_now.end());
                std::sort(interaction_list_old.begin(), interaction_list_old.end());

                for (icrd = 0; icrd < 3; ++icrd) {

                    interaction_index[0] = 3 * iat + icrd;

                    const CombinationWithRepetition<int> g_now(interaction_list_now.begin(),
                                                               interaction_list_now.end(), order);
                    const CombinationWithRepetition<int> g_old(interaction_list_old.begin(),
                                                               interaction_list_old.end(), order);

                    // m    -th order --> (m-1)-th order
                    // (m-1)-th order -->     m-th order
                    // 2-different directions to find all constraints

                    for (unsigned int direction = 0; direction < 2; ++direction) {

                        if (direction == 0) {
                            g = g_now;
                            interaction_list = interaction_list_now;
                        } else {
                            g = g_old;
                            interaction_list = interaction_list_old;
                        }

                        // Loop for the interacting pairs

                        do {
                            auto data = g.now();

                            for (size_t idata = 0; idata < data.size(); ++idata) {
                                interaction_atom[idata + 1] = data[idata];
                            }

                            for (ixyz = 0; ixyz < nxyz; ++ixyz) {

                                for (j = 0; j < order; ++j)
                                    interaction_index[j + 1] = 3 * interaction_atom[j + 1] + xyzcomponent[ixyz][j];

                                for (mu = 0; mu < 3; ++mu) {

                                    for (nu = 0; nu < 3; ++nu) {

                                        if (!valid_rotation_axis[mu][nu]) continue;

                                        // Search for a new constraint below

                                        for (j = 0; j < nparam_sub; ++j) arr_constraint[j] = 0.0;

                                        // Loop for m_{N+1}, a_{N+1}
                                        for (auto &iter_list: interaction_list) {
                                            jat = iter_list;

                                            interaction_atom[order + 1] = jat;
                                            if (!cluster->is_incutoff(order + 2,
                                                                      interaction_atom,
                                                                      order,
                                                                      system->get_supercell().kind))
                                                continue;

                                            atom_tmp.clear();

                                            for (j = 1; j < order + 2; ++j) {
                                                atom_tmp.push_back(interaction_atom[j]);
                                            }
                                            std::sort(atom_tmp.begin(), atom_tmp.end());

                                            iter_cluster = cluster->get_interaction_cluster(order, i).find(
                                                    InteractionCluster(atom_tmp,
                                                                       cell_dummy));
                                            if (iter_cluster != cluster->get_interaction_cluster(order, i).end()) {

                                                int iloc = -1;

                                                for (j = 0; j < atom_tmp.size(); ++j) {
                                                    if (atom_tmp[j] == jat) {
                                                        iloc = j;
                                                        break;
                                                    }
                                                }

                                                if (iloc == -1) {
                                                    exit(""generate_rotational_constraint"", ""This cannot happen."");
                                                }

                                                for (j = 0; j < 3; ++j) vec_for_rot[j] = 0.0;

                                                const auto nsize_equiv = (*iter_cluster).cell.size();

                                                for (j = 0; j < nsize_equiv; ++j) {
                                                    for (auto k = 0; k < 3; ++k) {
                                                        vec_for_rot[k] += system->get_x_image()[(*iter_cluster).cell[j][
                                                                iloc]][jat][k];
                                                    }
                                                }

                                                for (j = 0; j < 3; ++j) {
                                                    vec_for_rot[j] /= static_cast<double>(nsize_equiv);
                                                }
                                            }


                                            // mu, nu

                                            interaction_index[order + 1] = 3 * jat + mu;
                                            for (j = 0; j < order + 2; ++j) interaction_tmp[j] = interaction_index[j];

                                            sort_tail(order + 2, interaction_tmp);

                                            iter_found = list_found.
                                                    find(FcProperty(order + 2, 1.0, interaction_tmp, 1));
                                            if (iter_found != list_found.end()) {
                                                arr_constraint[nparams[order - 1] + (*iter_found).mother]
                                                        += (*iter_found).sign * vec_for_rot[nu];
                                            }

                                            // Exchange mu <--> nu and repeat again.

                                            interaction_index[order + 1] = 3 * jat + nu;
                                            for (j = 0; j < order + 2; ++j) interaction_tmp[j] = interaction_index[j];

                                            sort_tail(order + 2, interaction_tmp);

                                            iter_found = list_found.
                                                    find(FcProperty(order + 2, 1.0, interaction_tmp, 1));
                                            if (iter_found != list_found.end()) {
                                                arr_constraint[nparams[order - 1] + (*iter_found).mother]
                                                        -= (*iter_found).sign * vec_for_rot[mu];
                                            }
                                        }

                                        for (lambda = 0; lambda < order + 1; ++lambda) {

                                            mu_lambda = interaction_index[lambda] % 3;

                                            for (jcrd = 0; jcrd < 3; ++jcrd) {

                                                for (j = 0; j < order + 1; ++j)
                                                    interaction_tmp[j] = interaction_index[j
                                                    ];

                                                interaction_tmp[lambda] = 3 * interaction_atom[lambda] + jcrd;

                                                levi_factor = 0;

                                                for (j = 0; j < 3; ++j) {
                                                    levi_factor += levi_civita(j, mu, nu) * levi_civita(
                                                            j, mu_lambda, jcrd);
                                                }

                                                if (levi_factor == 0) continue;

                                                sort_tail(order + 1, interaction_tmp);

                                                iter_found = list_found_last.find(FcProperty(order + 1, 1.0,
                                                                                             interaction_tmp, 1));
                                                if (iter_found != list_found_last.end()) {
                                                    arr_constraint[(*iter_found).mother]
                                                            += (*iter_found).sign * static_cast<double>(levi_factor);
                                                }
                                            }
                                        }

                                        if (!is_allzero(arr_constraint, tolerance, loc_nonzero)) {

                                            // A Candidate for another constraint found !
                                            // Add to the appropriate set

                                            if (arr_constraint[loc_nonzero] < 0.0) {
                                                for (j = 0; j < nparam_sub; ++j) arr_constraint[j] *= -1.0;
                                            }
                                            for (j = 0; j < nparams[order]; ++j) {
                                                arr_constraint_self[j] = arr_constraint[j + nparams[order - 1]];
                                            }
                                            for (j = 0; j < nparams[order - 1]; ++j) {
                                                arr_constraint_lower[j] = arr_constraint[j];
                                            }

                                            const_tmp.clear();

                                            if (is_allzero(arr_constraint_self, tolerance, loc_nonzero)) {
                                                // If all elements of the ""order""th order is zero,
                                                // the constraint is intraorder of the ""order-1""th order.
                                                for (j = 0; j < nparams[order - 1]; ++j) {
                                                    if (std::abs(arr_constraint_lower[j]) >= tolerance) {
                                                        const_tmp.emplace_back(j, arr_constraint_lower[j]);
                                                    }
                                                }
                                                const_self_vec[order - 1].emplace_back(const_tmp);

                                            } else if (is_allzero(arr_constraint_lower, tolerance, loc_nonzero)) {
                                                // If all elements of the ""order-1""th order is zero,
                                                // the constraint is intraorder of the ""order""th order.
                                                for (j = 0; j < nparams[order]; ++j) {
                                                    if (std::abs(arr_constraint_self[j]) >= tolerance) {
                                                        const_tmp.emplace_back(j, arr_constraint_self[j]);
                                                    }
                                                }
                                                const_self_vec[order].emplace_back(const_tmp);

                                            } else {
                                                // If nonzero elements exist in both of the ""order-1"" and ""order"",
                                                // the constraint is intrerorder.

                                                for (j = 0; j < nparam_sub; ++j) {
                                                    if (std::abs(arr_constraint[j]) >= tolerance) {
                                                        const_tmp.emplace_back(j, arr_constraint[j]);
                                                    }
                                                }
                                                const_cross_vec[order].emplace_back(const_tmp);
                                            }
                                        }

                                    } // nu
                                }     // mu

                            } // ixyz

                        } while (g.next());

                    } // direction
                }     // icrd
            }

            // Additional constraint for the last order.
            // All IFCs over maxorder-th order are neglected.

            if (order == maxorder - 1 && !exclude_last_R) {

                auto interaction_list_now(cluster->get_interaction_pair(order, i));
                std::sort(interaction_list_now.begin(), interaction_list_now.end());

                nxyz2 = static_cast<int>(pow(static_cast<double>(3), order + 1));
                allocate(xyzcomponent2, nxyz2, order + 1);
                fcs->get_xyzcomponent(order + 1, xyzcomponent2);

                for (icrd = 0; icrd < 3; ++icrd) {

                    interaction_index[0] = 3 * interaction_atom[0] + icrd;

                    CombinationWithRepetition<int> g_now(interaction_list_now.begin(),
                                                         interaction_list_now.end(), order + 1);
                    do {

                        auto data = g_now.now();

                        for (auto idata = 0; idata < data.size(); ++idata)
                            interaction_atom[idata + 1] = data[idata];

                        for (ixyz = 0; ixyz < nxyz2; ++ixyz) {

                            for (j = 0; j < order + 1; ++j)
                                interaction_index[j + 1] = 3 * interaction_atom[j + 1] + xyzcomponent2[ixyz][j];

                            for (mu = 0; mu < 3; ++mu) {

                                for (nu = 0; nu < 3; ++nu) {

                                    if (!valid_rotation_axis[mu][nu]) continue;

                                    for (j = 0; j < nparams[order]; ++j) arr_constraint_self[j] = 0.0;

                                    for (lambda = 0; lambda < order + 2; ++lambda) {

                                        mu_lambda = interaction_index[lambda] % 3;

                                        for (jcrd = 0; jcrd < 3; ++jcrd) {

                                            for (j = 0; j < order + 2; ++j)
                                                interaction_tmp[j] = interaction_index[j];

                                            interaction_tmp[lambda] = 3 * interaction_atom[lambda] + jcrd;

                                            levi_factor = 0;
                                            for (j = 0; j < 3; ++j) {
                                                levi_factor += levi_civita(j, mu, nu) * levi_civita(j, mu_lambda, jcrd);
                                            }

                                            if (levi_factor == 0) continue;

                                            sort_tail(order + 2, interaction_tmp);

                                            iter_found = list_found.find(FcProperty(order + 2, 1.0,
                                                                                    interaction_tmp, 1));
                                            if (iter_found != list_found.end()) {
                                                arr_constraint_self[(*iter_found).mother]
                                                        += (*iter_found).sign * static_cast<double>(levi_factor);
                                            }
                                        } // jcrd
                                    }     // lambda

                                    if (!is_allzero(arr_constraint_self, tolerance, loc_nonzero)) {
                                        if (arr_constraint_self[loc_nonzero] < 0.0) {
                                            for (j = 0; j < nparams[order]; ++j) arr_constraint_self[j] *= -1.0;
                                        }
                                        const_tmp.clear();
                                        for (j = 0; j < nparams[order]; ++j) {
                                            if (std::abs(arr_constraint_self[j]) >= tolerance) {
                                                const_tmp.emplace_back(j, arr_constraint_self[j]);
                                            }
                                        }
                                        const_self_vec[order].emplace_back(const_tmp);
                                    }

                                } // nu
                            }     // mu

                        } // ixyz


                    } while (g_now.next());

                } // icrd

                deallocate(xyzcomponent2);
            }
        } // iat

        if (verbosity > 0) std::cout << "" done."" << std::endl;

        if (order > 0) {
            deallocate(xyzcomponent);
        }
        deallocate(interaction_tmp);
        deallocate(interaction_index);
        deallocate(interaction_atom);
    } // order

    int counter;
    MapConstraintElement const_copy;
    auto division_factor = 1.0;

    for (order = 0; order < maxorder; ++order) {
        // Sort & unique
        std::sort(const_self_vec[order].begin(), const_self_vec[order].end());
        const_self_vec[order].erase(std::unique(const_self_vec[order].begin(),
                                                const_self_vec[order].end()),
                                    const_self_vec[order].end());
        std::sort(const_cross_vec[order].begin(), const_cross_vec[order].end());
        const_cross_vec[order].erase(std::unique(const_cross_vec[order].begin(),
                                                 const_cross_vec[order].end()),
                                     const_cross_vec[order].end());

        // Copy to the return variable
        for (const auto &it: const_self_vec[order]) {
            const_copy.clear();
            counter = 0;
            for (const auto &it2: it) {
                if (counter == 0) {
                    division_factor = 1.0 / it2.val;
                }
                const_copy[it2.col] = it2.val * division_factor;
                ++counter;
            }
            const_rotation_self[order].emplace_back(const_copy);
        }
        const_self_vec[order].clear();

        for (const auto &it: const_cross_vec[order]) {
            const_copy.clear();
            counter = 0;
            for (const auto &it2: it) {
                if (counter == 0) {
                    division_factor = 1.0 / it2.val;
                }
                const_copy[it2.col] = it2.val * division_factor;
                ++counter;
            }
            const_rotation_cross[order].emplace_back(const_copy);
        }
        const_cross_vec[order].clear();

        //  Perform rref
        rref_sparse(nparams[order],
                    const_rotation_self[order],
                    eps6);

        if (order > 0) {
            rref_sparse(nparams[order - 1] + nparams[order],
                        const_rotation_cross[order],
                        eps6);
        }

    }

    if (verbosity > 0) std::cout << ""  Finished !"" << std::endl << std::endl;

    deallocate(ind);
    deallocate(nparams);
    deallocate(const_self_vec);
    deallocate(const_cross_vec);
}


int Constraint::levi_civita(const int i,
                            const int j,
                            const int k) const
{
    return (j - i) * (k - i) * (k - j) / 2;
}


void Constraint::setup_rotation_axis(bool flag[3][3])
{
    for (auto mu = 0; mu < 3; ++mu) {
        for (auto nu = 0; nu < 3; ++nu) {
            if (mu == nu) {
                flag[mu][nu] = false;
            } else {
                flag[mu][nu] = true;
            }
        }
    }
    std::sort(rotation_axis.begin(), rotation_axis.end());

    if (rotation_axis == ""x"") {
        flag[0][1] = false;
        flag[1][0] = false;
        flag[0][2] = false;
        flag[2][0] = false;
    } else if (rotation_axis == ""y"") {
        flag[0][1] = false;
        flag[1][0] = false;
        flag[1][2] = false;
        flag[2][1] = false;
    } else if (rotation_axis == ""z"") {
        flag[0][2] = false;
        flag[2][0] = false;
        flag[1][2] = false;
        flag[2][1] = false;
    } else if (rotation_axis == ""xy"") {
        flag[0][1] = false;
        flag[1][0] = false;
    } else if (rotation_axis == ""yz"") {
        flag[1][2] = false;
        flag[2][1] = false;
    } else if (rotation_axis == ""xz"") {
        flag[0][2] = false;
        flag[2][0] = false;
    } else if (rotation_axis == ""xyz"") {
        // do nothing
    } else {
        warn(""setup_rotation_axis"",
             ""Invalid rotation_axis. Default value(xyz) will be used."");
    }
}


void Constraint::fix_forceconstants_to_file(const int order,
                                            const Symmetry *symmetry,
                                            const Fcs *fcs,
                                            const std::string file_to_fix,
                                            std::vector<ConstraintTypeFix> &const_out) const
{
    using namespace boost::property_tree;
    ptree pt;

    try {
        read_xml(file_to_fix, pt);
    }
    catch (std::exception &e) {
        if (order == 0) {
            auto str_error = ""Cannot open file FC2XML ( "" + file_to_fix + "" )"";
        } else if (order == 1) {
            auto str_error = ""Cannot open file FC3XML ( "" + file_to_fix + "" )"";
        }
        exit(""fix_forceconstants_to_file"", ""Failed to open "", file_to_fix.c_str());
    }

    const auto nat_ref = boost::lexical_cast<size_t>(
            get_value_from_xml(pt, ""Data.Structure.NumberOfAtoms""));
    const auto ntran_ref = boost::lexical_cast<size_t>(
            get_value_from_xml(pt, ""Data.Symmetry.NumberOfTranslations""));
    const auto natmin_ref = nat_ref / ntran_ref;

    if (natmin_ref != symmetry->get_nat_prim()) {
        exit(""fix_forceconstants_to_file"",
             ""The number of atoms in the primitive cell is not consistent."");
    }

    const auto nfcs = fcs->get_nequiv()[order].size();

    if (order == 0) {
        const auto nfcs_ref = boost::lexical_cast<size_t>(
                get_value_from_xml(pt, ""Data.ForceConstants.HarmonicUnique.NFC2""));

        if (nfcs_ref != nfcs) {
            exit(""fix_forceconstants_to_file"",
                 ""The number of harmonic force constants is not consistent."");
        }

        std::string preferred_basis_ref = boost::lexical_cast<std::string>(
                get_value_from_xml(pt, ""Data.ForceConstants.HarmonicUnique.Basis"", 0));

        if (preferred_basis_ref == """") preferred_basis_ref = ""Cartesian"";

        if (preferred_basis_ref != fcs->get_forceconstant_basis()) {
            exit(""fix_forceconstants_to_file"",
                 ""The basis of harmonic force constants is not consistent."");
        }
    } else if (order == 1) {
        const auto nfcs_ref = boost::lexical_cast<size_t>(
                get_value_from_xml(pt, ""Data.ForceConstants.CubicUnique.NFC3""));

        if (nfcs_ref != nfcs) {
            exit(""fix_forceconstants_to_file"",
                 ""The number of cubic force constants is not consistent."");
        }

        std::string preferred_basis_ref = boost::lexical_cast<std::string>(
                get_value_from_xml(pt, ""Data.ForceConstants.CubicUnique.Basis"", 0));
        if (preferred_basis_ref == """") preferred_basis_ref = ""Cartesian"";

        if (preferred_basis_ref != fcs->get_forceconstant_basis()) {
            exit(""fix_forceconstants_to_file"",
                 ""The basis of cubic force constants is not consistent."");
        }
    }

    int **intpair_ref;
    double *fcs_ref;

    allocate(fcs_ref, nfcs);
    allocate(intpair_ref, nfcs, 3);

    int counter = 0;

    if (order == 0) {
        BOOST_FOREACH(const ptree::value_type &child_, pt.get_child(""Data.ForceConstants.HarmonicUnique"")) {
                        if (child_.first == ""FC2"") {
                            const auto &child = child_.second;
                            const auto str_intpair = child.get<std::string>(""<xmlattr>.pairs"");
                            const auto str_multiplicity = child.get<std::string>(""<xmlattr>.multiplicity"");

                            std::istringstream is(str_intpair);
                            is >> intpair_ref[counter][0] >> intpair_ref[counter][1];
                            fcs_ref[counter] = boost::lexical_cast<double>(child.data());
                            ++counter;
                        }
                    }
    } else if (order == 1) {
        BOOST_FOREACH(const ptree::value_type &child_, pt.get_child(""Data.ForceConstants.CubicUnique"")) {
                        if (child_.first == ""FC3"") {
                            const auto &child = child_.second;
                            const auto str_intpair = child.get<std::string>(""<xmlattr>.pairs"");
                            const auto str_multiplicity = child.get<std::string>(""<xmlattr>.multiplicity"");

                            std::istringstream is(str_intpair);
                            is >> intpair_ref[counter][0] >> intpair_ref[counter][1] >> intpair_ref[counter][2];
                            fcs_ref[counter] = boost::lexical_cast<double>(child.data());
                            ++counter;
                        }
                    }
    }

    const auto nterms = order + 2;

    std::unordered_set<FcProperty> list_found;
    std::unordered_set<FcProperty>::iterator iter_found;

    list_found.clear();

    for (auto &list_tmp: fcs->get_fc_table()[order]) {
        list_found.insert(FcProperty(list_tmp));
    }

    for (auto i = 0; i < nfcs; ++i) {
        iter_found = list_found.find(FcProperty(nterms, 1.0,
                                                intpair_ref[i], 1));
        if (iter_found == list_found.end()) {
            exit(""fix_forceconstants_to_file"",
                 ""Cannot find equivalent force constant, number: "",
                 i + 1);
        }
        const_out.emplace_back(ConstraintTypeFix((*iter_found).mother, fcs_ref[i]));
    }
    deallocate(intpair_ref);
    deallocate(fcs_ref);

    list_found.clear();
}


bool Constraint::is_allzero(const int n,
                            const double *arr,
                            const int nshift) const
{
    for (auto i = nshift; i < n; ++i) {
        if (std::abs(arr[i]) > eps10) {
            return false;
        }
    }
    return true;
}

bool Constraint::is_allzero(const std::vector<int> &vec,
                            int &loc) const
{
    loc = -1;
    for (auto i = 0; i < vec.size(); ++i) {
        if (std::abs(vec[i]) > 0) {
            loc = i;
            return false;
        }
    }
    return true;
}

bool Constraint::is_allzero(const std::vector<double> &vec,
                            const double tol,
                            int &loc,
                            const int nshift) const
{
    loc = -1;
    const auto n = vec.size();
    for (auto i = nshift; i < n; ++i) {
        if (std::abs(vec[i]) > tol) {
            loc = i;
            return false;
        }
    }
    return true;
}


void Constraint::remove_redundant_rows(const size_t n,
                                       std::vector<ConstraintClass> &Constraint_vec,
                                       const double tolerance) const
{
    size_t i, j;

    auto nparam = n;
    const auto nconst = Constraint_vec.size();
    double *arr_tmp;
    double **mat_tmp;

    size_t nrank;

    if (nconst > 0) {

        allocate(mat_tmp, nconst, nparam);

        i = 0;

        for (auto &p: Constraint_vec) {
            for (j = 0; j < nparam; ++j) {
                mat_tmp[i][j] = p.w_const[j];
            }
            ++i;
        }

        rref(nconst, nparam, mat_tmp, nrank, tolerance);

        allocate(arr_tmp, nparam);

        Constraint_vec.clear();

        for (i = 0; i < nrank; ++i) {
            for (j = 0; j < nparam; ++j) arr_tmp[j] = 0.0;
            long iloc = -1;
            for (j = 0; j < nparam; ++j) {
                if (std::abs(mat_tmp[i][j]) < tolerance) {
                    arr_tmp[j] = 0.0;
                } else {
                    arr_tmp[j] = mat_tmp[i][j];
                }
                if (std::abs(arr_tmp[j]) >= tolerance) {
                    iloc = j;
                }
            }

            if (iloc != -1) {
                Constraint_vec.emplace_back(nparam, arr_tmp);
            }
        }

        deallocate(mat_tmp);
        deallocate(arr_tmp);

    }
}

void Constraint::print_constraint(const ConstraintSparseForm &const_in) const
{
    const auto nconst = const_in.size();
    auto counter = 0;
    std::cout << std::endl;
    std::cout << ""TOTAL CONST SIZE :"" << std::setw(6) << nconst << std::endl;
    for (const auto &it: const_in) {
        std::cout << ""CONST : "" << std::setw(5) << counter + 1 << std::endl;
        for (const auto &it2: it) {
            std::cout << std::setw(5) << it2.first + 1;
            std::cout << std::setw(15) << it2.second << std::endl;
        }
        std::cout << std::endl;
        ++counter;
    }
}
",16136,True,2885.0381957411537,median
"/*
* Copyright (c) 2012-2020, Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the ""Software""),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/
//!
//! \\file     vphal_render_sfc_base.cpp
//! \\brief    VPHAL SFC rendering component
//! \\details  The SFC renderer supports Scaling, IEF, CSC/ColorFill and Rotation.
//!           It's responsible for setting up HW states and generating the SFC
//!           commands.
//!
#include ""vphal_render_vebox_base.h""
#include ""vphal_render_ief.h""
#include ""vphal_render_sfc_base.h""

#if __VPHAL_SFC_SUPPORTED

//!
//! \\brief Constants used to derive Line Buffer sizes
//!
#define SFC_CACHELINE_SIZE_IN_BYTES                     (512 / 8)
#define SFC_AVS_LINEBUFFER_SIZE_PER_VERTICAL_PIXEL      (5 * SFC_CACHELINE_SIZE_IN_BYTES / 8)
#define SFC_IEF_LINEBUFFER_SIZE_PER_VERTICAL_PIXEL      (1 * SFC_CACHELINE_SIZE_IN_BYTES / 4)

//!
//! \\brief    Initialize SFC Output Surface Command parameters
//! \\details  Initialize MHW SFC Output Surface Command parameters from SFC Pipe output Surface
//! \\param    [in] pSfcPipeOutSurface
//!           pointer to SFC Pipe output Surface
//! \\param    [out] pMhwOutSurfParams
//!           pointer to SFC Output Surface Command parameters
//! \\return   MOS_STATUS
//!
MOS_STATUS VpHal_InitMhwOutSurfParams(
    PVPHAL_SURFACE                           pSfcPipeOutSurface,
    PMHW_SFC_OUT_SURFACE_PARAMS              pMhwOutSurfParams)
{
    MOS_STATUS                   eStatus = MOS_STATUS_SUCCESS;

    VPHAL_RENDER_CHK_NULL(pSfcPipeOutSurface);
    VPHAL_RENDER_CHK_NULL(pMhwOutSurfParams);

    MOS_ZeroMemory(pMhwOutSurfParams, sizeof(*pMhwOutSurfParams));

    pMhwOutSurfParams->ChromaSiting                = pSfcPipeOutSurface->ChromaSiting;
    pMhwOutSurfParams->dwWidth                     = pSfcPipeOutSurface->dwWidth;
    pMhwOutSurfParams->dwHeight                    = pSfcPipeOutSurface->dwHeight;
    pMhwOutSurfParams->dwPitch                     = pSfcPipeOutSurface->dwPitch;
    pMhwOutSurfParams->TileType                    = pSfcPipeOutSurface->TileType;
    pMhwOutSurfParams->TileModeGMM                 = pSfcPipeOutSurface->TileModeGMM;
    pMhwOutSurfParams->bGMMTileEnabled             = pSfcPipeOutSurface->bGMMTileEnabled;
    pMhwOutSurfParams->pOsResource                 = &(pSfcPipeOutSurface->OsResource);
    pMhwOutSurfParams->Format                      = pSfcPipeOutSurface->Format;
    pMhwOutSurfParams->bCompressible               = pSfcPipeOutSurface->bCompressible;
    pMhwOutSurfParams->dwCompressionFormat         = pSfcPipeOutSurface->CompressionFormat;
    pMhwOutSurfParams->dwSurfaceXOffset            = pSfcPipeOutSurface->YPlaneOffset.iXOffset;
    pMhwOutSurfParams->dwSurfaceYOffset            = pSfcPipeOutSurface->YPlaneOffset.iYOffset;

    if (pSfcPipeOutSurface->dwPitch > 0)
    {
        pMhwOutSurfParams->dwUYoffset = ((pSfcPipeOutSurface->UPlaneOffset.iSurfaceOffset - pSfcPipeOutSurface->YPlaneOffset.iSurfaceOffset) / pSfcPipeOutSurface->dwPitch) + pSfcPipeOutSurface->UPlaneOffset.iYOffset;
    }

finish:
    return eStatus;
}

//!
//! \\brief    Get SFC Rotation mode parameter
//! \\details  Get MHW SFC Rotation mode parameter
//! \\param    [in] Rotation
//!           VPHAL roration mode parameter
//! \\return   MHW_ROTATION
//!
MHW_ROTATION VpHal_GetMhwRotationParam(VPHAL_ROTATION Rotation)
{
    switch (Rotation)
    {
        case VPHAL_ROTATION_90:
            return MHW_ROTATION_90;                         // 90 Degree Rotation

        case VPHAL_ROTATION_180:
            return MHW_ROTATION_180;                        // 180 Degree Rotation

        case VPHAL_ROTATION_270:
            return MHW_ROTATION_270;                        // 270 Degree Rotation

        case VPHAL_MIRROR_HORIZONTAL:
            return MHW_MIRROR_HORIZONTAL;                   // Horizontal Mirror

        case VPHAL_MIRROR_VERTICAL:
            return MHW_MIRROR_VERTICAL;                     // Vertical Mirror

        case VPHAL_ROTATE_90_MIRROR_VERTICAL:
            return MHW_ROTATION_270;                        // 270 Degree rotation and Horizontal Mirror

        case VPHAL_ROTATE_90_MIRROR_HORIZONTAL:
            return MHW_ROTATION_90;                         // 90 Degree rotation and Horizontal Mirror

        default:
        case VPHAL_ROTATION_IDENTITY:
            return MHW_ROTATION_IDENTITY;
    }
}

bool VphalSfcState::IsFormatMMCSupported(
    MOS_FORMAT                  Format)
{
    // Check if Sample Format is supported
    if ((Format != Format_NV12) &&
        (Format != Format_UYVY) &&
        (Format != Format_YUYV))
    {
        VPHAL_RENDER_NORMALMESSAGE(""Unsupported Format '0x%08x' for SFC MMC."", Format);
        return false;
    }

    return true;
}

VphalSfcState::VphalSfcState(
    PMOS_INTERFACE       osInterface,
    PRENDERHAL_INTERFACE renderHal,
    PMHW_SFC_INTERFACE   sfcInterface)
{
    VPHAL_RENDER_ASSERT(osInterface);
    VPHAL_RENDER_ASSERT(renderHal);
    VPHAL_RENDER_ASSERT(sfcInterface);

    m_renderHal       = renderHal;
    m_sfcInterface    = sfcInterface;
    m_osInterface     = osInterface;

    // Allocate AVS state
    VpHal_RndrCommonInitAVSParams(
        &m_AvsParameters,
        POLYPHASE_Y_COEFFICIENT_TABLE_SIZE_G9,
        POLYPHASE_UV_COEFFICIENT_TABLE_SIZE_G9);
}

VphalSfcState::~VphalSfcState()
{
    VpHal_RndrCommonDestroyAVSParams(&m_AvsParameters);
    MOS_FreeMemAndSetNull(m_renderData.SfcStateParams);
}

bool VphalSfcState::IsOutputCapable(
    bool            isColorFill,
    PVPHAL_SURFACE  src,
    PVPHAL_SURFACE  renderTarget)
{
    bool isOutputCapable = false;

    VPHAL_RENDER_NORMALMESSAGE(
        ""isColorFill %d, \\
         src->rcDst.top %d, \\
         src->rcDst.left %d, \\
         renderTarget->TileType %d, \\
         renderTarget->Format %d"",
        isColorFill,
        src->rcDst.top,
        src->rcDst.left,
        renderTarget->TileType,
        renderTarget->Format);

    // H/W does not support ColorFill, the (OffsetX, OffsetY)
    // of scaled region not being (0, 0) or the tile type not being
    // Tile_Y on NV12/P010/P016 output surface. Disable SFC even if other
    // features are supported.
    if ((isColorFill         ||
        src->rcDst.top  != 0 ||
        src->rcDst.left != 0 ||
        renderTarget->TileType != MOS_TILE_Y) &&
        (renderTarget->Format == Format_NV12 ||
         renderTarget->Format == Format_P010 ||
         renderTarget->Format == Format_P016))
    {
        isOutputCapable = false;
    }
    else
    {
        isOutputCapable = true;
    }

    return isOutputCapable;
}

void VphalSfcState::AdjustBoundary(
    PVPHAL_SURFACE              pSurface,
    uint32_t*                   pdwSurfaceWidth,
    uint32_t*                   pdwSurfaceHeight)
{
    uint32_t        dwVeboxHeight;
    uint32_t        dwVeboxWidth;
    uint32_t        dwVeboxBottom;
    uint32_t        dwVeboxRight;
    MEDIA_WA_TABLE *pWaTable = nullptr;

    VPHAL_RENDER_CHK_NULL_NO_STATUS(m_sfcInterface);
    VPHAL_RENDER_CHK_NULL_NO_STATUS(m_osInterface);
    VPHAL_RENDER_CHK_NULL_NO_STATUS(pSurface);
    VPHAL_RENDER_CHK_NULL_NO_STATUS(pdwSurfaceWidth);
    VPHAL_RENDER_CHK_NULL_NO_STATUS(pdwSurfaceHeight);

    pWaTable = m_osInterface->pfnGetWaTable(m_osInterface);
    VPHAL_RENDER_CHK_NULL_NO_STATUS(pWaTable);

    if (MEDIA_IS_WA(pWaTable, WaVeboxInputHeight16Aligned) &&
       (pSurface->Format == Format_NV12                    ||
        pSurface->Format == Format_P010                    ||
        pSurface->Format == Format_P016))
    {
        m_sfcInterface->m_veHeightAlignment = 16;
    }
    else
    {
        m_sfcInterface->m_veHeightAlignment = MHW_SFC_VE_HEIGHT_ALIGN;
    }

    // For the VEBOX output to SFC, the width is multiple of 16 and height
    // is multiple of 4
    dwVeboxHeight = pSurface->dwHeight;
    dwVeboxWidth  = pSurface->dwWidth;
    dwVeboxBottom = (uint32_t)pSurface->rcMaxSrc.bottom;
    dwVeboxRight  = (uint32_t)pSurface->rcMaxSrc.right;

    if(pSurface->bDirectionalScalar)
    {
        dwVeboxHeight *= 2;
        dwVeboxWidth  *= 2;
        dwVeboxBottom *= 2;
        dwVeboxRight  *= 2;
    }

    *pdwSurfaceHeight = MOS_ALIGN_CEIL(
        MOS_MIN(dwVeboxHeight, MOS_MAX(dwVeboxBottom, MHW_VEBOX_MIN_HEIGHT)),
        m_sfcInterface->m_veHeightAlignment);
    *pdwSurfaceWidth  = MOS_ALIGN_CEIL(
        MOS_MIN(dwVeboxWidth, MOS_MAX(dwVeboxRight, MHW_VEBOX_MIN_WIDTH)),
        m_sfcInterface->m_veWidthAlignment);

finish:
    return;
}

bool VphalSfcState::IsOutputPipeSfcFeasible(
    PCVPHAL_RENDER_PARAMS       pcRenderParams,
    PVPHAL_SURFACE              pSrcSurface,
    PVPHAL_SURFACE              pRenderTarget)
{
    VPHAL_RENDER_NORMALMESSAGE(
        ""IsDisabled %d, \\
         uDstCount %d, \\
         Rotation %d, \\
         pTarget[0]->TileType %d, \\
         IsFormatSupported %d, \\
         InputFormat %d, \\
         OutputFormat %d, \\
         pCompAlpha %p, \\
         pDeinterlaceParams %p, \\
         bQueryVariance %d"",
        IsDisabled(),
        pcRenderParams->uDstCount,
        pSrcSurface->Rotation,
        pcRenderParams->pTarget[0]->TileType,
        IsFormatSupported(pSrcSurface, pcRenderParams->pTarget[0], pcRenderParams->pCompAlpha),
        pSrcSurface->Format,
        pcRenderParams->pTarget[0]->Format,
        pcRenderParams->pCompAlpha,
        pSrcSurface->pDeinterlaceParams,
        pSrcSurface->bQueryVariance);

    //!
    //! \\brief SFC can be the output pipe when the following conditions are all met
    //!        1.  User feature keys value ""SFC Disable"" is false
    //!        2.  Single render target only
    //!        3.  Rotation disabled or ONLY Rotation enabled when the SFC output is Y-tile
    //!        4.  i/o format is supported by SFC, taking into account the alpha fill info
    //!        5.  Comp DI(ARGB/ABGR) is disabled
    //!        6.  Variance Query is disabled
    //!
    if (IsDisabled()                            == false                                        &&
        pcRenderParams->uDstCount               == 1                                            &&
        (pSrcSurface->Rotation                  == VPHAL_ROTATION_IDENTITY                      ||
         (pSrcSurface->Rotation                 <= VPHAL_ROTATION_270                           &&
          pcRenderParams->pTarget[0]->TileType  == MOS_TILE_Y))                                 &&
        IsFormatSupported(pSrcSurface, pcRenderParams->pTarget[0], pcRenderParams->pCompAlpha)  &&
        (pSrcSurface->pDeinterlaceParams        == nullptr                                      ||
         (pSrcSurface->Format != Format_A8R8G8B8 && pSrcSurface->Format != Format_A8B8G8R8))    &&
        pSrcSurface->bQueryVariance             == false)
    {
        // For platforms with VEBOX disabled but procamp enabled, go Render path
        if (MEDIA_IS_SKU(m_renderHal->pSkuTable, FtrDisableVEBoxFeatures) && pSrcSurface->pProcampParams != nullptr)
        {
            return false;
        }

        return true;
    }

    return false;
}

VPHAL_OUTPUT_PIPE_MODE VphalSfcState::GetOutputPipe(
    PVPHAL_SURFACE              pSrc,
    PVPHAL_SURFACE              pRenderTarget,
    PCVPHAL_RENDER_PARAMS       pcRenderParams)
{
    float                       fScaleX;
    float                       fScaleY;
    uint32_t                    dwSurfaceWidth;
    uint32_t                    dwSurfaceHeight;
    VPHAL_OUTPUT_PIPE_MODE      OutputPipe;
    bool                        bColorFill;
    uint16_t                    wWidthAlignUnit;
    uint16_t                    wHeightAlignUnit;
    uint32_t                    dwSourceRegionWidth;
    uint32_t                    dwSourceRegionHeight;
    uint32_t                    dwOutputRegionWidth;
    uint32_t                    dwOutputRegionHeight;
    uint32_t                    dwSfcMaxWidth;
    uint32_t                    dwSfcMaxHeight;
    uint32_t                    dwSfcMinWidth;
    uint32_t                    dwSfcMinHeight;

    OutputPipe = VPHAL_OUTPUT_PIPE_MODE_COMP;

    VPHAL_RENDER_CHK_NULL_NO_STATUS(m_sfcInterface);
    VPHAL_RENDER_CHK_NULL_NO_STATUS(pSrc);
    VPHAL_RENDER_CHK_NULL_NO_STATUS(pRenderTarget);
    VPHAL_RENDER_CHK_NULL_NO_STATUS(pcRenderParams);

    dwSfcMaxWidth       = m_sfcInterface->m_maxWidth;
    dwSfcMaxHeight      = m_sfcInterface->m_maxHeight;
    dwSfcMinWidth       = m_sfcInterface->m_minWidth;
    dwSfcMinHeight      = m_sfcInterface->m_minHeight;
    wWidthAlignUnit     = 1;
    wHeightAlignUnit    = 1;

    // Check if the feature can be supported by SFC output pipe
    if (!IsOutputPipeSfcFeasible(pcRenderParams, pSrc, pRenderTarget))
    {
        VPHAL_RENDER_NORMALMESSAGE(""Feature or surface format not supported by SFC Pipe."");
        OutputPipe = VPHAL_OUTPUT_PIPE_MODE_COMP;
        return OutputPipe;
    }

    // Get the SFC input surface size from Vebox
    AdjustBoundary(
        pSrc,
        &dwSurfaceWidth,
        &dwSurfaceHeight);

    // Apply alignment restriction to the source and scaled regions.
    switch(pRenderTarget->Format)
    {
        case Format_NV12:
            wWidthAlignUnit     = 2;
            wHeightAlignUnit    = 2;
            break;
        case Format_YUY2:
        case Format_UYVY:
            wWidthAlignUnit     = 2;
            break;
        default:
            break;
    }

    // Region of the input frame which needs to be processed by SFC
    dwSourceRegionHeight = MOS_ALIGN_FLOOR(
                            MOS_MIN((uint32_t)(pSrc->rcSrc.bottom - pSrc->rcSrc.top), dwSurfaceHeight),
                            wHeightAlignUnit);
    dwSourceRegionWidth  = MOS_ALIGN_FLOOR(
                            MOS_MIN((uint32_t)(pSrc->rcSrc.right  - pSrc->rcSrc.left), dwSurfaceWidth),
                            wWidthAlignUnit);

    // Size of the Output Region over the Render Target
    dwOutputRegionHeight = MOS_ALIGN_CEIL(
                            (uint32_t)(pSrc->rcDst.bottom - pSrc->rcDst.top),
                            wHeightAlignUnit);
    dwOutputRegionWidth  = MOS_ALIGN_CEIL(
                            (uint32_t)(pSrc->rcDst.right - pSrc->rcDst.left),
                            wWidthAlignUnit);

    // SFC i/o width and height should fall into the range of [128, 4K]
    if (OUT_OF_BOUNDS(dwSurfaceWidth, dwSfcMinWidth, dwSfcMaxWidth)         ||
        OUT_OF_BOUNDS(dwSurfaceHeight, dwSfcMinHeight, dwSfcMaxHeight)      ||
        OUT_OF_BOUNDS(dwSourceRegionWidth, dwSfcMinWidth, dwSfcMaxWidth)    ||
        OUT_OF_BOUNDS(dwSourceRegionHeight, dwSfcMinHeight, dwSfcMaxHeight) ||
        OUT_OF_BOUNDS(dwOutputRegionWidth, dwSfcMinWidth, dwSfcMaxWidth)    ||
        OUT_OF_BOUNDS(dwOutputRegionHeight, dwSfcMinHeight, dwSfcMaxHeight) ||
        OUT_OF_BOUNDS(pRenderTarget->dwWidth, dwSfcMinWidth, dwSfcMaxWidth) ||
        OUT_OF_BOUNDS(pRenderTarget->dwHeight, dwSfcMinHeight, dwSfcMaxHeight))
    {
        VPHAL_RENDER_NORMALMESSAGE(""Surface dimensions not supported by SFC Pipe."");
        OutputPipe = VPHAL_OUTPUT_PIPE_MODE_COMP;
        return OutputPipe;
    }

    // Size of the Output Region over the Render Target
    dwOutputRegionHeight = MOS_MIN(dwOutputRegionHeight, pRenderTarget->dwHeight);
    dwOutputRegionWidth  = MOS_MIN(dwOutputRegionWidth, pRenderTarget->dwWidth);

    // Calculate the scaling ratio
    // Both source region and scaled region are pre-rotated
    if (pSrc->Rotation == VPHAL_ROTATION_IDENTITY ||
        pSrc->Rotation == VPHAL_ROTATION_180      ||
        pSrc->Rotation == VPHAL_MIRROR_HORIZONTAL ||
        pSrc->Rotation == VPHAL_MIRROR_VERTICAL)
    {
        fScaleX      = (float)dwOutputRegionWidth  / (float)dwSourceRegionWidth;
        fScaleY      = (float)dwOutputRegionHeight / (float)dwSourceRegionHeight;
    }
    else
    {
        // VPHAL_ROTATION_90 || VPHAL_ROTATION_270 || VPHAL_ROTATE_90_MIRROR_VERTICAL || VPHAL_ROTATE_90_MIRROR_HORIZONTAL
        fScaleX      = (float)dwOutputRegionHeight / (float)dwSourceRegionWidth;
        fScaleY      = (float)dwOutputRegionWidth  / (float)dwSourceRegionHeight;
    }

    // SFC scaling range is [0.125, 8] for both X and Y direction.
    if ((fScaleX < 0.125F)  || (fScaleX > 8.0F) ||
        (fScaleY < 0.125F)  || (fScaleY > 8.0F))
    {
        VPHAL_RENDER_NORMALMESSAGE(""Scaling factor not supported by SFC Pipe."");
        OutputPipe = VPHAL_OUTPUT_PIPE_MODE_COMP;
        return OutputPipe;
    }

    if (MEDIA_IS_WA(m_renderHal->pWaTable, WaDisableSFCSrcCrop) &&
        dwSurfaceHeight > 1120 &&
        (((pSrc->rcSrc.left > 0) || (dwSurfaceWidth - pSrc->rcSrc.right > 0))      ||
         ((pSrc->rcSrc.bottom > 1120) && (pSrc->rcSrc.bottom < (int32_t)dwSurfaceHeight)) ||
         ((pSrc->rcSrc.top > 1120) && (pSrc->rcSrc.top < (int32_t)dwSurfaceHeight))       ||
         (pSrc->rcSrc.bottom < (int32_t)dwSurfaceHeight)))
    {
        VPHAL_RENDER_NORMALMESSAGE(""Fallback to comp path as SW WA for SFC Cropping TDR."");
        OutputPipe = VPHAL_OUTPUT_PIPE_MODE_COMP;
        return OutputPipe;
    }

    // if ScalingPreference == Composition, switch to use composition path
    // This flag can be set by app.
    if (pSrc->ScalingPreference == VPHAL_SCALING_PREFER_COMP)
    {
        VPHAL_RENDER_NORMALMESSAGE(""DDI set ScalingPreference to Composition to use render for scaling."");
        OutputPipe = VPHAL_OUTPUT_PIPE_MODE_COMP;
        return OutputPipe;
    }

    bColorFill = (pcRenderParams->pColorFillParams &&
                  (!RECT1_CONTAINS_RECT2(pSrc->rcDst, pRenderTarget->rcDst))) ?
                 true : false;

    if (IsOutputCapable(bColorFill, pSrc, pRenderTarget))
    {
        OutputPipe = VPHAL_OUTPUT_PIPE_MODE_SFC;
    }
    else
    {
        OutputPipe = VPHAL_OUTPUT_PIPE_MODE_COMP;
    }

finish:
    return OutputPipe;
}

void VphalSfcState::DetermineCscParams(
    PVPHAL_SURFACE                  src,
    PVPHAL_SURFACE                  renderTarget)
{
    // Determine if CSC is required in SFC pipe
    if (IS_RGB_CSPACE(src->ColorSpace))
    {
        if (IS_YUV_CSPACE(renderTarget->ColorSpace))
        {
            m_renderData.SfcInputCspace = renderTarget->ColorSpace;
        }
        else if (MEDIA_IS_HDCONTENT(src->dwWidth, src->dwHeight))
        {
            m_renderData.SfcInputCspace = CSpace_BT709;
        }
        else
        {
            m_renderData.SfcInputCspace = CSpace_BT601;
        }
    }
    else
    {
        m_renderData.SfcInputCspace = src->ColorSpace;
    }

    if (m_renderData.SfcInputCspace != renderTarget->ColorSpace)
    {
        m_renderData.bCSC = true;
    }
}

void VphalSfcState::DetermineInputFormat(
    PVPHAL_SURFACE                  src,
    PVPHAL_VEBOX_RENDER_DATA        veboxRenderData)
{
    // Determine SFC input surface format
    if (IS_RGB_FORMAT(src->Format))
    {
        m_renderData.SfcInputFormat = Format_AYUV;
    }
    else if (veboxRenderData->bDeinterlace)
    {
        m_renderData.SfcInputFormat = Format_YUY2;
    }
    else
    {
        m_renderData.SfcInputFormat = src->Format;
    }
}

void VphalSfcState::SetRenderingFlags(
    PVPHAL_COLORFILL_PARAMS         pColorFillParams,
    PVPHAL_ALPHA_PARAMS             pAlphaParams,
    PVPHAL_SURFACE                  pSrc,
    PVPHAL_SURFACE                  pRenderTarget,
    PVPHAL_VEBOX_RENDER_DATA        pRenderData)
{
    PRENDERHAL_INTERFACE    pRenderHal;
    float                   fScaleX;
    float                   fScaleY;
    uint32_t                dwSurfaceWidth;
    uint32_t                dwSurfaceHeight;
    uint16_t                wWidthAlignUnit;
    uint16_t                wHeightAlignUnit;
    uint32_t                dwSourceRegionWidth;
    uint32_t                dwSourceRegionHeight;
    uint32_t                dwOutputRegionWidth;
    uint32_t                dwOutputRegionHeight;
    uint32_t                dwVeboxBottom;
    uint32_t                dwVeboxRight;
    VPHAL_COLORPACK         dstColorPack;

    VPHAL_RENDER_CHK_NULL_NO_STATUS(pSrc);
    VPHAL_RENDER_CHK_NULL_NO_STATUS(pRenderTarget);

    pRenderHal       = m_renderHal;
    wWidthAlignUnit  = 1;
    wHeightAlignUnit = 1;
    dwVeboxBottom    = (uint32_t)pSrc->rcSrc.bottom;
    dwVeboxRight     = (uint32_t)pSrc->rcSrc.right;
    dstColorPack     = VpHal_GetSurfaceColorPack(pRenderTarget->Format);

    // Get the SFC input surface size from Vebox
    AdjustBoundary(
        pSrc,
        &dwSurfaceWidth,
        &dwSurfaceHeight);

    // Apply alignment restriction to the source and scaled regions.
    switch (dstColorPack)
    {
        case VPHAL_COLORPACK_420:
            wWidthAlignUnit     = 2;
            wHeightAlignUnit    = 2;
            break;
        case VPHAL_COLORPACK_422:
            wWidthAlignUnit     = 2;
            break;
        default:
            break;
    }

    if(pSrc->bDirectionalScalar)
    {
        dwVeboxBottom *= 2;
        dwVeboxRight  *= 2;
    }

    // Region of the input frame which needs to be processed by SFC
    dwSourceRegionHeight = MOS_ALIGN_FLOOR(
                            MOS_MIN((uint32_t)(dwVeboxBottom - pSrc->rcSrc.top), dwSurfaceHeight),
                            wHeightAlignUnit);
    dwSourceRegionWidth  = MOS_ALIGN_FLOOR(
                            MOS_MIN((uint32_t)(dwVeboxRight  - pSrc->rcSrc.left), dwSurfaceWidth),
                            wWidthAlignUnit);

    // Size of the Output Region over the Render Target
    dwOutputRegionHeight = MOS_ALIGN_CEIL(
                            MOS_MIN((uint32_t)(pSrc->rcDst.bottom - pSrc->rcDst.top), pRenderTarget->dwHeight),
                            wHeightAlignUnit);
    dwOutputRegionWidth  = MOS_ALIGN_CEIL(
                            MOS_MIN((uint32_t)(pSrc->rcDst.right - pSrc->rcDst.left), pRenderTarget->dwWidth),
                            wWidthAlignUnit);

    // Calculate the scaling ratio
    // Both source region and scaled region are pre-rotated
    if (pSrc->Rotation == VPHAL_ROTATION_IDENTITY ||
        pSrc->Rotation == VPHAL_ROTATION_180      ||
        pSrc->Rotation == VPHAL_MIRROR_HORIZONTAL ||
        pSrc->Rotation == VPHAL_MIRROR_VERTICAL)
    {
        fScaleX      = (float)dwOutputRegionWidth  / (float)dwSourceRegionWidth;
        fScaleY      = (float)dwOutputRegionHeight / (float)dwSourceRegionHeight;
    }
    else
    {
        // VPHAL_ROTATION_90 || VPHAL_ROTATION_270 || VPHAL_ROTATE_90_MIRROR_VERTICAL || VPHAL_ROTATE_90_MIRROR_HORIZONTAL
        fScaleX      = (float)dwOutputRegionHeight / (float)dwSourceRegionWidth;
        fScaleY      = (float)dwOutputRegionWidth  / (float)dwSourceRegionHeight;
    }

    // Set RenderData flags
    m_renderData.bScaling   = ((fScaleX == 1.0F) && (fScaleY == 1.0F)) ?
                                 false : true;

    m_renderData.bColorFill = (pColorFillParams && pSrc->InterlacedScalingType == ISCALING_NONE &&
                                  (!RECT1_CONTAINS_RECT2(pSrc->rcDst, pRenderTarget->rcDst))) ?
                                 true : false;

    m_renderData.bIEF       = (pSrc->pIEFParams              &&
                                  pSrc->pIEFParams->bEnabled    &&
                                  (pSrc->pIEFParams->fIEFFactor > 0.0f)) ?
                                 true : false;

    // Determine if CSC is required in SFC pipe
    DetermineCscParams(
        pSrc,
        pRenderTarget);

    // Determine SFC input surface format
    DetermineInputFormat(
        pSrc,
        pRenderData);

    m_renderData.fScaleX            = fScaleX;
    m_renderData.fScaleY            = fScaleY;
    m_renderData.pColorFillParams   = m_renderData.bColorFill ? pColorFillParams : nullptr;
    m_renderData.pAvsParams         = &m_AvsParameters;
    m_renderData.pAlphaParams       = pAlphaParams;
    m_renderData.pSfcPipeOutSurface = pRenderTarget;
    m_renderData.SfcRotation        = pSrc->Rotation;
    m_renderData.SfcScalingMode     = pSrc->ScalingMode;

    // In SFC, we have a lot of HW restrictions on Chroma Sitting Programming.
    // So prevent any invalid input for SFC to avoid HW problems.
    // Prevent invalid input for input surface and format.
    m_renderData.SfcSrcChromaSiting = pSrc->ChromaSiting;
    if (m_renderData.SfcSrcChromaSiting == MHW_CHROMA_SITING_NONE)
    {
        m_renderData.SfcSrcChromaSiting = (CHROMA_SITING_HORZ_LEFT | CHROMA_SITING_VERT_CENTER);
    }
    switch (VpHal_GetSurfaceColorPack(m_renderData.SfcInputFormat))
    {
        case VPHAL_COLORPACK_422:
            m_renderData.SfcSrcChromaSiting = (m_renderData.SfcSrcChromaSiting & 0x7) | CHROMA_SITING_VERT_TOP;
            break;
        case VPHAL_COLORPACK_444:
            m_renderData.SfcSrcChromaSiting = CHROMA_SITING_HORZ_LEFT | CHROMA_SITING_VERT_TOP;
            break;
        default:
            break;
    }
    // Prevent invalid input for output surface and format
    if (pRenderTarget->ChromaSiting == MHW_CHROMA_SITING_NONE)
    {
        pRenderTarget->ChromaSiting = (CHROMA_SITING_HORZ_LEFT | CHROMA_SITING_VERT_CENTER);
    }
    switch (dstColorPack)
    {
        case VPHAL_COLORPACK_422:
            pRenderTarget->ChromaSiting = (pRenderTarget->ChromaSiting & 0x7) | CHROMA_SITING_VERT_TOP;
            break;
        case VPHAL_COLORPACK_444:
            pRenderTarget->ChromaSiting = CHROMA_SITING_HORZ_LEFT | CHROMA_SITING_VERT_TOP;
            break;
        default:
            break;
    }

    m_renderData.bForcePolyPhaseCoefs = VpHal_IsChromaUpSamplingNeeded(pSrc, pRenderTarget);

    // Cache Render Target pointer
    pRenderData->pRenderTarget = pRenderTarget;

    VPHAL_RENDER_NORMALMESSAGE(
        ""RenderData: bScaling %d, bColorFill %d, bIEF %d, SfcInputFormat %d, SfcRotation %d, SfcScalingMode %d, SfcSrcChromaSiting %d"",
        m_renderData.bScaling,
        m_renderData.bColorFill,
        m_renderData.bIEF,
        m_renderData.SfcInputFormat,
        m_renderData.SfcRotation,
        m_renderData.SfcScalingMode,
        m_renderData.SfcSrcChromaSiting);

finish:
    return;
}

bool VphalSfcState::IsFormatSupported(
    PVPHAL_SURFACE              pSrcSurface,
    PVPHAL_SURFACE              pOutSurface,
    PVPHAL_ALPHA_PARAMS         pAlphaParams)
{
    // Init to false for in case the input parameters are nullptr
    bool ret  = false;

    VPHAL_RENDER_CHK_NULL_NO_STATUS(pSrcSurface);
    VPHAL_RENDER_CHK_NULL_NO_STATUS(pOutSurface);

    // Default to true
    ret = true;

    // Check if Input Format is supported
    if (!IsInputFormatSupported(pSrcSurface))
    {
        VPHAL_RENDER_NORMALMESSAGE(""Unsupported Source Format '0x%08x' for SFC."", pSrcSurface->Format);
        ret = false;
        return ret;
    }

    // SFC can not support fp16 output. HDR path is the only way to handle any fp16 output.
    // Before entering into HDR path, it is possible that we need to use SFC to do P010->ARGB10.
    // As for SFC is needed or not, we use bHDRSfc to decide.
    if (pOutSurface->Format == Format_A16R16G16B16F ||
        pOutSurface->Format == Format_A16B16G16R16F)
    {
        ret = false;
        return ret;
    }

    // Check if Output Format is supported
    if (!IsOutputFormatSupported(pOutSurface))
    {
        ret = false;
        return ret;
    }

    // Check if the input/output combination is supported, given certain alpha fill mode.
    // So far SFC only supports filling constant alpha.
    if (pAlphaParams &&
        pAlphaParams->AlphaMode == VPHAL_ALPHA_FILL_MODE_SOURCE_STREAM)
    {
        if ((pOutSurface->Format == Format_A8R8G8B8    ||
             pOutSurface->Format == Format_A8B8G8R8    ||
             pOutSurface->Format == Format_R10G10B10A2 ||
             pOutSurface->Format == Format_B10G10R10A2 ||
             pOutSurface->Format == Format_Y410        ||
             pOutSurface->Format == Format_Y416        ||
             pOutSurface->Format == Format_AYUV)       &&
            (pSrcSurface->Format == Format_A8B8G8R8    ||
             pSrcSurface->Format == Format_A8R8G8B8    ||
             pSrcSurface->Format == Format_Y410        ||
             pSrcSurface->Format == Format_Y416        ||
             pSrcSurface->Format == Format_AYUV))
        {
            ret = false;
        }
    }

finish:
    return ret;
}

void VphalSfcState::FreeResources()
{
    // Free AVS Line Buffer surface for SFC
    m_osInterface->pfnFreeResource(
        m_osInterface,
        &m_AVSLineBufferSurface.OsResource);

    // Free IEF Line Buffer surface for SFC
    m_osInterface->pfnFreeResource(
        m_osInterface,
        &m_IEFLineBufferSurface.OsResource);

    return;
}

MOS_STATUS VphalSfcState::AllocateResources()
{
    MOS_STATUS              eStatus;
    uint32_t                dwWidth;
    uint32_t                dwHeight;
    uint32_t                dwSize;
    bool                    bAllocated;
    PMHW_SFC_STATE_PARAMS   pSfcStateParams;

    eStatus         = MOS_STATUS_UNKNOWN;
    bAllocated      = false;
    pSfcStateParams = m_renderData.SfcStateParams;

    // Allocate AVS Line Buffer surface----------------------------------------------
    dwWidth  = 1;
    dwHeight = pSfcStateParams->dwInputFrameHeight * SFC_AVS_LINEBUFFER_SIZE_PER_VERTICAL_PIXEL;
    dwSize   = dwWidth * dwHeight;

    VPHAL_RENDER_CHK_STATUS(VpHal_ReAllocateSurface(
        m_osInterface,
        &m_AVSLineBufferSurface,
        ""SfcAVSLineBufferSurface"",
        Format_Buffer,
        MOS_GFXRES_BUFFER,
        MOS_TILE_LINEAR,
        dwSize,
        1,
        false,
        MOS_MMC_DISABLED,
        &bAllocated));

    // Allocate IEF Line Buffer surface----------------------------------------------
    dwWidth  = 1;
    dwHeight = pSfcStateParams->dwScaledRegionHeight * SFC_IEF_LINEBUFFER_SIZE_PER_VERTICAL_PIXEL;
    dwSize   = dwWidth * dwHeight;

    VPHAL_RENDER_CHK_STATUS(VpHal_ReAllocateSurface(
        m_osInterface,
        &m_IEFLineBufferSurface,
        ""SfcIEFLineBufferSurface"",
        Format_Buffer,
        MOS_GFXRES_BUFFER,
        MOS_TILE_LINEAR,
        dwSize,
        1,
        false,
        MOS_MMC_DISABLED,
        &bAllocated));

finish:
    if (eStatus != MOS_STATUS_SUCCESS)
    {
        FreeResources();
    }

    return eStatus;
}

void VphalSfcState::GetOutputWidthHeightAlignUnit(
    MOS_FORMAT              outputFormat,
    uint16_t                &widthAlignUnit,
    uint16_t                &heightAlignUnit)
{
    widthAlignUnit  = 1;
    heightAlignUnit = 1;

    switch (VpHal_GetSurfaceColorPack(outputFormat))
    {
        case VPHAL_COLORPACK_420:
            widthAlignUnit  = 2;
            heightAlignUnit = 2;
            break;
        case VPHAL_COLORPACK_422:
            widthAlignUnit  = 2;
            break;
        default:
            break;
    }
}

void VphalSfcState::SetSfcStateInputOrderingMode(
    PVPHAL_VEBOX_RENDER_DATA    veboxRenderData,
    PMHW_SFC_STATE_PARAMS       sfcStateParams)
{
    sfcStateParams->dwVDVEInputOrderingMode = MEDIASTATE_SFC_INPUT_ORDERING_VE_4x8;
}

MOS_STATUS VphalSfcState::SetSfcStateParams(
    PVPHAL_VEBOX_RENDER_DATA    pRenderData,
    PVPHAL_SURFACE              pSrcSurface,
    PVPHAL_SURFACE              pOutSurface)
{
    MOS_STATUS                  eStatus;
    PMOS_INTERFACE              pOsInterface;
    PMHW_SFC_STATE_PARAMS       pSfcStateParams;
    PVPHAL_ALPHA_PARAMS         pAlphaParams;
    VPHAL_COLOR_SAMPLE_8        Src;
    VPHAL_CSPACE                src_cspace, dst_cspace;
    uint16_t                    wOutputWidthAlignUnit;
    uint16_t                    wOutputHeightAlignUnit;
    uint16_t                    wInputWidthAlignUnit;
    uint16_t                    wInputHeightAlignUnit;
    uint32_t                    dwSurfaceWidth;
    uint32_t                    dwSurfaceHeight;
    uint32_t                    dwVeboxBottom;
    uint32_t                    dwVeboxRight;
    VPHAL_GET_SURFACE_INFO      Info;
    VPHAL_COLORPACK             dstColorPack;

    VPHAL_RENDER_CHK_NULL(pSrcSurface);
    VPHAL_RENDER_CHK_NULL(pOutSurface);

    eStatus                = MOS_STATUS_UNKNOWN;
    pOsInterface           = m_osInterface;
    pSfcStateParams        = m_renderData.SfcStateParams;
    pAlphaParams           = m_renderData.pAlphaParams;
    wOutputWidthAlignUnit  = 1;
    wOutputHeightAlignUnit = 1;
    wInputWidthAlignUnit   = 1;
    wInputHeightAlignUnit  = 1;
    dwVeboxBottom          = (uint32_t)pSrcSurface->rcSrc.bottom;
    dwVeboxRight           = (uint32_t)pSrcSurface->rcSrc.right;
    dstColorPack           = VpHal_GetSurfaceColorPack(pOutSurface->Format);

    VPHAL_RENDER_CHK_NULL(pSfcStateParams);
    MOS_ZeroMemory(pSfcStateParams, sizeof(*pSfcStateParams));

    pSfcStateParams->sfcPipeMode = MEDIASTATE_SFC_PIPE_VE_TO_SFC;

    // Setup General params
    // Set chroma subsampling type according to the Vebox output, but
    // when Vebox is bypassed, set it according to the source surface format.
    if (pRenderData->bIECP)
    {
        pSfcStateParams->dwInputChromaSubSampling = MEDIASTATE_SFC_CHROMA_SUBSAMPLING_444;
        m_renderData.SfcSrcChromaSiting           = MHW_CHROMA_SITING_HORZ_LEFT | MHW_CHROMA_SITING_VERT_TOP;
        pSfcStateParams->b8tapChromafiltering     = true;
    }
    else if (pRenderData->bDeinterlace)
    {
        pSfcStateParams->dwInputChromaSubSampling = MEDIASTATE_SFC_CHROMA_SUBSAMPLING_422H;
        pSfcStateParams->b8tapChromafiltering     = false;
    }
    else
    {
        if (m_renderData.SfcInputFormat == Format_NV12   ||
            (m_renderData.SfcInputFormat == Format_P010) ||
            (m_renderData.SfcInputFormat == Format_P016))
        {
            pSfcStateParams->dwInputChromaSubSampling = MEDIASTATE_SFC_CHROMA_SUBSAMPLING_420;
            pSfcStateParams->b8tapChromafiltering     = false;
        }
        else if (VpHal_GetSurfaceColorPack(m_renderData.SfcInputFormat) == VPHAL_COLORPACK_422)
        {
            pSfcStateParams->dwInputChromaSubSampling = MEDIASTATE_SFC_CHROMA_SUBSAMPLING_422H;
            pSfcStateParams->b8tapChromafiltering     = false;
        }
        else if (VpHal_GetSurfaceColorPack(m_renderData.SfcInputFormat) == VPHAL_COLORPACK_444)
        {
            pSfcStateParams->dwInputChromaSubSampling = MEDIASTATE_SFC_CHROMA_SUBSAMPLING_444;
            pSfcStateParams->b8tapChromafiltering     = true;
        }
        else
        {
            pSfcStateParams->dwInputChromaSubSampling = MEDIASTATE_SFC_CHROMA_SUBSAMPLING_400;
            pSfcStateParams->b8tapChromafiltering     = false;
        }
    }

    // Default to Horizontal Left, Vertical Top
    pSfcStateParams->dwChromaDownSamplingVerticalCoef   = (pOutSurface->ChromaSiting & MHW_CHROMA_SITING_VERT_CENTER) ?
                                                          MEDIASTATE_SFC_CHROMA_DOWNSAMPLING_COEF_4_OVER_8 :
                                                          MEDIASTATE_SFC_CHROMA_DOWNSAMPLING_COEF_0_OVER_8;
    pSfcStateParams->dwChromaDownSamplingHorizontalCoef = (pOutSurface->ChromaSiting & MHW_CHROMA_SITING_HORZ_CENTER) ?
                                                          MEDIASTATE_SFC_CHROMA_DOWNSAMPLING_COEF_4_OVER_8 :
                                                          MEDIASTATE_SFC_CHROMA_DOWNSAMPLING_COEF_0_OVER_8;

    // Set the Pre-AVS chroma downsampling param according to SFC i/o chroma subsampling type
    switch (pSfcStateParams->dwInputChromaSubSampling)
    {
        case MEDIASTATE_SFC_CHROMA_SUBSAMPLING_444:
            if (dstColorPack == VPHAL_COLORPACK_420)
            {
                pSfcStateParams->dwChromaDownSamplingMode = MEDIASTATE_SFC_CHROMA_DOWNSAMPLING_444TO420;
            }
            else if (dstColorPack == VPHAL_COLORPACK_422)
            {
                pSfcStateParams->dwChromaDownSamplingMode = MEDIASTATE_SFC_CHROMA_DOWNSAMPLING_444TO422;
            }
            break;

        case MEDIASTATE_SFC_CHROMA_SUBSAMPLING_422H:
            if (dstColorPack == VPHAL_COLORPACK_420)
            {
                pSfcStateParams->dwChromaDownSamplingMode = MEDIASTATE_SFC_CHROMA_DOWNSAMPLING_422TO420;
            }
            break;

        default:
            pSfcStateParams->dwChromaDownSamplingMode = MEDIASTATE_SFC_CHROMA_DOWNSAMPLING_DISABLED;
            break;
    }

    VPHAL_RENDER_NORMALMESSAGE(""SfcStateParams: dwInputChromaSubSampling %d, b8tapChromafiltering %d, dwChromaDownSamplingMode %d."",
        pSfcStateParams->dwInputChromaSubSampling,
        pSfcStateParams->b8tapChromafiltering,
        pSfcStateParams->dwChromaDownSamplingMode);

    SetSfcStateInputOrderingMode(pRenderData, pSfcStateParams);

    pSfcStateParams->OutputFrameFormat = pOutSurface->Format;

    pSfcStateParams->fChromaSubSamplingXSiteOffset = 0.0F;
    pSfcStateParams->fChromaSubSamplingYSiteOffset = 0.0F;

    // Setup all parameters in SFC_STATE related to Scaling and AVS
    pSfcStateParams->dwAVSFilterMode = (m_renderData.SfcScalingMode == VPHAL_SCALING_BILINEAR) ?
                                       MEDIASTATE_SFC_AVS_FILTER_BILINEAR                         :
                                       MEDIASTATE_SFC_AVS_FILTER_8x8;

    // Get the SFC input surface size from Vebox
    AdjustBoundary(
        pSrcSurface,
        &dwSurfaceWidth,
        &dwSurfaceHeight);

    // This should be set to the height and width of the frame streaming from Vebox
    pSfcStateParams->dwInputFrameHeight             = dwSurfaceHeight;
    pSfcStateParams->dwInputFrameWidth              = dwSurfaceWidth;

    // Apply alignment restriction to the Region of the output frame.
    GetOutputWidthHeightAlignUnit(
        pSfcStateParams->OutputFrameFormat,
        wOutputWidthAlignUnit,
        wOutputHeightAlignUnit);

    // Apply alignment restriction to Region of the input frame.
    GetInputWidthHeightAlignUnit(
        m_renderData.SfcInputFormat,
        pSfcStateParams->OutputFrameFormat,
        wInputWidthAlignUnit,
        wInputHeightAlignUnit);

    if(pSrcSurface->bDirectionalScalar)
    {
        dwVeboxBottom *= 2;
        dwVeboxRight  *= 2;
    }

    // This should be set to the height and width of the Render Target
    pSfcStateParams->dwOutputFrameHeight            = MOS_ALIGN_CEIL(pOutSurface->dwHeight, wOutputHeightAlignUnit);
    pSfcStateParams->dwOutputFrameWidth             = MOS_ALIGN_CEIL(pOutSurface->dwWidth,  wOutputWidthAlignUnit);

    // Region of the input frame which needs to be processed by SFC
    pSfcStateParams->dwSourceRegionVerticalOffset   = MOS_ALIGN_CEIL((uint32_t)pSrcSurface->rcSrc.top,  wInputHeightAlignUnit);
    pSfcStateParams->dwSourceRegionHorizontalOffset = MOS_ALIGN_CEIL((uint32_t)pSrcSurface->rcSrc.left, wInputWidthAlignUnit);
    pSfcStateParams->dwSourceRegionHeight           = MOS_ALIGN_FLOOR(
                                                        MOS_MIN((uint32_t)(dwVeboxBottom - pSrcSurface->rcSrc.top), pSfcStateParams->dwInputFrameHeight),
                                                        wInputHeightAlignUnit);
    pSfcStateParams->dwSourceRegionWidth            = MOS_ALIGN_FLOOR(
                                                        MOS_MIN((uint32_t)(dwVeboxRight  - pSrcSurface->rcSrc.left), pSfcStateParams->dwInputFrameWidth),
                                                        wInputWidthAlignUnit);

    // Size of the Scaled Region over the Render Target
    pSfcStateParams->dwScaledRegionHeight           = MOS_ALIGN_CEIL(MOS_UF_ROUND(m_renderData.fScaleY * pSfcStateParams->dwSourceRegionHeight), wOutputHeightAlignUnit);
    pSfcStateParams->dwScaledRegionWidth            = MOS_ALIGN_CEIL(MOS_UF_ROUND(m_renderData.fScaleX * pSfcStateParams->dwSourceRegionWidth), wOutputWidthAlignUnit);

    // Scaled region is pre-rotated. Adjust its width and height with those of the output frame
    if (m_renderData.SfcRotation == VPHAL_ROTATION_IDENTITY ||
        m_renderData.SfcRotation == VPHAL_ROTATION_180      ||
        m_renderData.SfcRotation == VPHAL_MIRROR_HORIZONTAL ||
        m_renderData.SfcRotation == VPHAL_MIRROR_VERTICAL)
    {
        pSfcStateParams->dwScaledRegionHeight = MOS_MIN(pSfcStateParams->dwScaledRegionHeight, pSfcStateParams->dwOutputFrameHeight);
        pSfcStateParams->dwScaledRegionWidth  = MOS_MIN(pSfcStateParams->dwScaledRegionWidth, pSfcStateParams->dwOutputFrameWidth);
    }
    else
    {
        pSfcStateParams->dwScaledRegionHeight = MOS_MIN(pSfcStateParams->dwScaledRegionHeight, pSfcStateParams->dwOutputFrameWidth);
        pSfcStateParams->dwScaledRegionWidth  = MOS_MIN(pSfcStateParams->dwScaledRegionWidth, pSfcStateParams->dwOutputFrameHeight);
    }

    // Refine the Scaling ratios in the X and Y direction. SFC output Scaled size may be changed based on the restriction of SFC alignment.
    // The scaling ratio could be changed and not equal to the fScaleX/Y.
    // Driver must make sure that the scaling ratio should be matched with the output/input size before send to HW
    pSfcStateParams->fAVSXScalingRatio              = (float)pSfcStateParams->dwScaledRegionWidth / (float)pSfcStateParams->dwSourceRegionWidth;
    pSfcStateParams->fAVSYScalingRatio              = (float)pSfcStateParams->dwScaledRegionHeight / (float)pSfcStateParams->dwSourceRegionHeight;

    pSfcStateParams->dwScaledRegionVerticalOffset   = MOS_ALIGN_FLOOR((uint32_t)pSrcSurface->rcDst.top,  wOutputHeightAlignUnit);
    pSfcStateParams->dwScaledRegionHorizontalOffset = MOS_ALIGN_FLOOR((uint32_t)pSrcSurface->rcDst.left, wOutputWidthAlignUnit);

    // Enable Adaptive Filtering for YUV input only, if it is being upscaled
    // in either direction. We must check for this before clamping the SF.
    if (IS_YUV_FORMAT(m_renderData.SfcInputFormat) &&
        (m_renderData.fScaleX > 1.0F               ||
         m_renderData.fScaleY > 1.0F))
    {
        pSfcStateParams->bBypassXAdaptiveFilter = false;
        pSfcStateParams->bBypassYAdaptiveFilter = false;
    }
    else
    {
        pSfcStateParams->bBypassXAdaptiveFilter = true;
        pSfcStateParams->bBypassYAdaptiveFilter = true;
    }

    if (IS_RGB_FORMAT(m_renderData.SfcInputFormat) &&
        pSfcStateParams->b8tapChromafiltering == true)
    {
        pSfcStateParams->bRGBAdaptive = true;
    }
    else
    {
        pSfcStateParams->bRGBAdaptive = false;
    }

    pSfcStateParams->bAVSChromaUpsamplingEnable = (m_renderData.bScaling || m_renderData.bForcePolyPhaseCoefs);

    // Rotation params
    if (m_renderData.SfcRotation <= VPHAL_ROTATION_270)
    {
        // Rotation only
        pSfcStateParams->RotationMode  = VpHal_GetMhwRotationParam(m_renderData.SfcRotation);
        pSfcStateParams->bMirrorEnable = false;
    }
    else if (m_renderData.SfcRotation <= VPHAL_MIRROR_VERTICAL)
    {
        // Mirror only
        pSfcStateParams->dwMirrorType  = VpHal_GetMhwRotationParam(m_renderData.SfcRotation) - 4;
        pSfcStateParams->RotationMode  = MHW_ROTATION_IDENTITY;
        pSfcStateParams->bMirrorEnable = true;
    }
    else
    {
        // Rotation + Mirror
        pSfcStateParams->dwMirrorType  = MHW_MIRROR_HORIZONTAL;
        pSfcStateParams->RotationMode  = VpHal_GetMhwRotationParam(m_renderData.SfcRotation);
        pSfcStateParams->bMirrorEnable = true;
    }

    VPHAL_RENDER_NORMALMESSAGE(""SfcStateParams: dwMirrorType %d, RotationMode %d, bMirrorEnable %d."",
        pSfcStateParams->dwMirrorType,
        pSfcStateParams->RotationMode,
        pSfcStateParams->bMirrorEnable);

    // ColorFill params
    if (m_renderData.bColorFill)
    {
        pSfcStateParams->bColorFillEnable = true;

        Src.dwValue = m_renderData.pColorFillParams->Color;
        src_cspace  = m_renderData.pColorFillParams->CSpace;
        dst_cspace  = pOutSurface->ColorSpace;

        // Convert BG color only if not done so before. CSC is expensive!
        if ((m_colorFillColorSrc.dwValue   != Src.dwValue) ||
            (m_colorFillSrcCspace          != src_cspace)  ||
            (m_colorFillRTCspace           != dst_cspace))
        {
            // Clean history Dst BG Color if hit unsupported format
            if (!VpHal_CSC_8(&m_colorFillColorDst, &Src, src_cspace, dst_cspace))
            {
                MOS_ZeroMemory(&m_colorFillColorDst, sizeof(m_colorFillColorDst));
            }

            // store the values for next iteration
            m_colorFillColorSrc    = Src;
            m_colorFillSrcCspace   = src_cspace;
            m_colorFillRTCspace    = dst_cspace;
        }

        if (IS_YUV_FORMAT(pOutSurface->Format) || (pOutSurface->Format == Format_AYUV))
        {
            pSfcStateParams->fColorFillYRPixel = (float)m_colorFillColorDst.Y / 255.0F;
            pSfcStateParams->fColorFillUGPixel = (float)m_colorFillColorDst.U / 255.0F;
            pSfcStateParams->fColorFillVBPixel = (float)m_colorFillColorDst.V / 255.0F;
        }
        else
        {
            // Swap the channel here because HW only natively supports XBGR output
            if ((pOutSurface->Format == Format_A8R8G8B8) || (pOutSurface->Format == Format_X8R8G8B8) || (pOutSurface->Format == Format_R10G10B10A2))
            {
                pSfcStateParams->fColorFillYRPixel = (float)m_colorFillColorDst.B / 255.0F;
                pSfcStateParams->fColorFillUGPixel = (float)m_colorFillColorDst.G / 255.0F;
                pSfcStateParams->fColorFillVBPixel = (float)m_colorFillColorDst.R / 255.0F;
            }
            else
            {
                pSfcStateParams->fColorFillYRPixel = (float)m_colorFillColorDst.R / 255.0F;
                pSfcStateParams->fColorFillUGPixel = (float)m_colorFillColorDst.G / 255.0F;
                pSfcStateParams->fColorFillVBPixel = (float)m_colorFillColorDst.B / 255.0F;
            }
        }
        pSfcStateParams->fColorFillAPixel  = (float)Src.A / 255.0F;
    }

    if (pAlphaParams)
    {
        switch (pAlphaParams->AlphaMode)
        {
        case VPHAL_ALPHA_FILL_MODE_NONE:
            if (pOutSurface->Format == Format_A8R8G8B8    ||
                pOutSurface->Format == Format_A8B8G8R8    ||
                pOutSurface->Format == Format_R10G10B10A2 ||
                pOutSurface->Format == Format_B10G10R10A2 ||
                pOutSurface->Format == Format_AYUV        ||
                pOutSurface->Format == Format_Y410        ||
                pOutSurface->Format == Format_Y416)
            {
                pSfcStateParams->fAlphaPixel      = pAlphaParams->fAlpha;
                pSfcStateParams->fColorFillAPixel = pAlphaParams->fAlpha;
            }
            else
            {
                pSfcStateParams->fAlphaPixel      = 1.0F;
            }
            break;

            case VPHAL_ALPHA_FILL_MODE_BACKGROUND:
                pSfcStateParams->fAlphaPixel = m_renderData.bColorFill ?
                    pSfcStateParams->fColorFillAPixel : 1.0F;
                break;

            case VPHAL_ALPHA_FILL_MODE_SOURCE_STREAM:
            case VPHAL_ALPHA_FILL_MODE_OPAQUE:
            default:
                pSfcStateParams->fAlphaPixel      = 1.0F;
                pSfcStateParams->fColorFillAPixel = 1.0F;
        }
    }
    else
    {
        pSfcStateParams->fAlphaPixel = 1.0F;
    }

    // CSC params
    pSfcStateParams->bCSCEnable      = m_renderData.bCSC;

    // ARGB8,ABGR10 output format need to enable swap
    if (pOutSurface->Format == Format_X8R8G8B8 ||
        pOutSurface->Format == Format_A8R8G8B8 ||
        pOutSurface->Format == Format_R10G10B10A2)
    {
        pSfcStateParams->bRGBASwapEnable = true;
    }
    else
    {
        pSfcStateParams->bRGBASwapEnable = false;
    }

    if (IS_RGB_CSPACE(pSrcSurface->ColorSpace))
    {
        pSfcStateParams->bInputColorSpace = true;
    }
    else
    {
        pSfcStateParams->bInputColorSpace = false;
    }

    VPHAL_RENDER_NORMALMESSAGE(""SfcStateParams: bCSCEnable %d, bRGBASwapEnable %d, bMirrorEnable %d."",
        pSfcStateParams->bCSCEnable,
        pSfcStateParams->bRGBASwapEnable,
        pSfcStateParams->bMirrorEnable);

    // Set MMC status
    VPHAL_RENDER_CHK_STATUS(SetSfcMmcStatus(
        pRenderData,
        pOutSurface,
        pSfcStateParams));

    VPHAL_RENDER_CHK_STATUS(AllocateResources());

    // Set OS resources used by SFC state
    pSfcStateParams->pOsResAVSLineBuffer = &m_AVSLineBufferSurface.OsResource;
    pSfcStateParams->pOsResIEFLineBuffer = &m_IEFLineBufferSurface.OsResource;
    pSfcStateParams->pOsResOutputSurface = &pOutSurface->OsResource;

    MOS_ZeroMemory(&Info, sizeof(VPHAL_GET_SURFACE_INFO));

    Info.S3dChannel = pOutSurface->Channel;
    Info.ArraySlice = m_currentChannel;

    VPHAL_RENDER_CHK_STATUS(VpHal_GetSurfaceInfo(
        pOsInterface,
        &Info,
        pOutSurface));

    pSfcStateParams->dwOutputSurfaceOffset  = pOutSurface->YPlaneOffset.iSurfaceOffset;
    pSfcStateParams->wOutputSurfaceUXOffset = (uint16_t) pOutSurface->UPlaneOffset.iXOffset;
    pSfcStateParams->wOutputSurfaceUYOffset = (uint16_t) pOutSurface->UPlaneOffset.iYOffset;
    pSfcStateParams->wOutputSurfaceVXOffset = (uint16_t) pOutSurface->VPlaneOffset.iXOffset;
    pSfcStateParams->wOutputSurfaceVYOffset = (uint16_t) pOutSurface->VPlaneOffset.iYOffset;

finish:
    return eStatus;
}

MOS_STATUS VphalSfcState::SetSfcMmcStatus(
    PVPHAL_VEBOX_RENDER_DATA renderData,
    PVPHAL_SURFACE           outSurface,
    PMHW_SFC_STATE_PARAMS    sfcStateParams)
{
    MOS_STATUS       eStatus = MOS_STATUS_SUCCESS;

    if (IsFormatMMCSupported(outSurface->Format)        &&                 // SFC output MMC only support several format
        (renderData->Component      == COMPONENT_VPreP) &&                 // SFC output MMC only enable in Vprep
        (renderData->bEnableMMC     == true)            &&
        (outSurface->bCompressible  == true)            &&
        (outSurface->TileType       == MOS_TILE_Y))
    {
        if ((m_renderData.fScaleX >= 0.5F) &&
            (m_renderData.fScaleY >= 0.5F))
        {
            sfcStateParams->bMMCEnable = true;
            sfcStateParams->MMCMode    = MOS_MMC_HORIZONTAL;
        }
        else if ((m_renderData.fScaleX < 0.5F) &&
                 (m_renderData.fScaleY < 0.5F))
        {
            sfcStateParams->bMMCEnable = true;
            sfcStateParams->MMCMode    = MOS_MMC_VERTICAL;
        }
        else
        {
            sfcStateParams->bMMCEnable = false;
            sfcStateParams->MMCMode    = MOS_MMC_DISABLED;
        }

        VPHAL_RENDER_NORMALMESSAGE(""SfcStateParams: bMMCEnable %d, MMCMode %d."",
            sfcStateParams->bMMCEnable,
            sfcStateParams->MMCMode);

        // Set mmc status output surface for output surface
        m_osInterface->pfnSetMemoryCompressionMode(m_osInterface, &outSurface->OsResource, MOS_MEMCOMP_STATE(sfcStateParams->MMCMode));
    }

    return eStatus;
}

MOS_STATUS VphalSfcState::SetAvsStateParams()
{
    MOS_STATUS                  eStatus = MOS_STATUS_SUCCESS;
    PMHW_SFC_AVS_STATE          pMhwAvsState;

    VPHAL_RENDER_CHK_NULL(m_sfcInterface);

    pMhwAvsState    = &m_avsState.AvsStateParams;

    pMhwAvsState->dwInputHorizontalSiting = (m_renderData.SfcSrcChromaSiting  & MHW_CHROMA_SITING_HORZ_CENTER) ? SFC_AVS_INPUT_SITING_COEF_4_OVER_8 :
                                            ((m_renderData.SfcSrcChromaSiting & MHW_CHROMA_SITING_HORZ_RIGHT)  ? SFC_AVS_INPUT_SITING_COEF_8_OVER_8 :
                                            SFC_AVS_INPUT_SITING_COEF_0_OVER_8);

    pMhwAvsState->dwInputVerticalSitting  = (m_renderData.SfcSrcChromaSiting  & MHW_CHROMA_SITING_VERT_CENTER) ? SFC_AVS_INPUT_SITING_COEF_4_OVER_8 :
                                            ((m_renderData.SfcSrcChromaSiting & MHW_CHROMA_SITING_VERT_BOTTOM) ? SFC_AVS_INPUT_SITING_COEF_8_OVER_8 :
                                            SFC_AVS_INPUT_SITING_COEF_0_OVER_8);

    if (m_renderData.SfcSrcChromaSiting == MHW_CHROMA_SITING_NONE)
    {
        m_renderData.SfcSrcChromaSiting = MHW_CHROMA_SITING_HORZ_LEFT | MHW_CHROMA_SITING_VERT_TOP;

        if (VpHal_GetSurfaceColorPack(m_renderData.SfcInputFormat) == VPHAL_COLORPACK_420)  // For 420, default is Left & Center, else default is Left & Top
        {
            pMhwAvsState->dwInputVerticalSitting = SFC_AVS_INPUT_SITING_COEF_4_OVER_8;
        }
    }

    m_renderData.pAvsParams->bForcePolyPhaseCoefs = m_renderData.bForcePolyPhaseCoefs;

    VPHAL_RENDER_CHK_STATUS(m_sfcInterface->SetSfcSamplerTable(
        &m_avsState.LumaCoeffs,
        &m_avsState.ChromaCoeffs,
        m_renderData.pAvsParams,
        m_renderData.SfcInputFormat,
        m_renderData.fScaleX,
        m_renderData.fScaleY,
        m_renderData.SfcSrcChromaSiting,
        true,
        0,
        0));

finish:
    return eStatus;
}

void VphalSfcState::SetIefStateCscParams(
    PMHW_SFC_STATE_PARAMS           sfcStateParams,
    PMHW_SFC_IEF_STATE_PARAMS       iefStateParams)
{

    // Setup CSC params
    if (m_renderData.bCSC)
    {
        sfcStateParams->bCSCEnable = true;
        iefStateParams->bCSCEnable = true;

        // Calculate matrix if not done so before. CSC is expensive!
        if ((m_cscInputCspace  != m_renderData.SfcInputCspace)    ||
            (m_cscRTCspace     != m_renderData.pSfcPipeOutSurface->ColorSpace))
        {
            // Get the matrix to use for conversion
            VpHal_GetCscMatrix(
                m_renderData.SfcInputCspace,
                m_renderData.pSfcPipeOutSurface->ColorSpace,
                m_cscCoeff,
                m_cscInOffset,
                m_cscOutOffset);

            // Store it for next BLT
            m_cscInputCspace   = m_renderData.SfcInputCspace;
            m_cscRTCspace      = m_renderData.pSfcPipeOutSurface->ColorSpace;
        }

        // Copy the values into IEF Params
        iefStateParams->pfCscCoeff     = m_cscCoeff;
        iefStateParams->pfCscInOffset  = m_cscInOffset;
        iefStateParams->pfCscOutOffset = m_cscOutOffset;
    }

}

void VphalSfcState::SetIefStateParams(
    PVPHAL_VEBOX_RENDER_DATA        veboxRenderData,
    PMHW_SFC_STATE_PARAMS           sfcStateParams,
    PVPHAL_SURFACE                  inputSurface)
{
    PMHW_SFC_IEF_STATE_PARAMS   iefStateParams;

    MOS_UNUSED(veboxRenderData);
    VPHAL_RENDER_CHK_NULL_NO_STATUS(sfcStateParams);
    VPHAL_RENDER_CHK_NULL_NO_STATUS(inputSurface);

    iefStateParams = &m_renderData.IEFStateParams;
    MOS_ZeroMemory(iefStateParams, sizeof(*iefStateParams));

    // Setup IEF and STE params
    if (m_renderData.bIEF)
    {
        Ief ief(
            inputSurface);

        ief.SetHwState(
            sfcStateParams,
            iefStateParams);
    } // end of setup IEF and STE params

    // Setup CSC params
    SetIefStateCscParams(
        sfcStateParams,
        iefStateParams);

finish:
    return;
}

MOS_STATUS VphalSfcState::UpdateRenderingFlags(
    PVPHAL_SURFACE                  pSrcSurface,
    PVPHAL_SURFACE                  pOutSurface,
    PVPHAL_VEBOX_RENDER_DATA        pRenderData)
{
    MOS_STATUS                      eStatus;

    MOS_UNUSED(pSrcSurface);
    MOS_UNUSED(pOutSurface);
    MOS_UNUSED(pRenderData);

    eStatus = MOS_STATUS_SUCCESS;

    return eStatus;
}

MOS_STATUS VphalSfcState::SetupSfcState(
    PVPHAL_SURFACE                  pSrcSurface,
    PVPHAL_SURFACE                  pOutSurface,
    PVPHAL_VEBOX_RENDER_DATA        pRenderData)
{
    MOS_STATUS                      eStatus;
    PMOS_INTERFACE                  pOsInterface;
    PRENDERHAL_INTERFACE            pRenderHal;

    VPHAL_RENDER_CHK_NULL(pSrcSurface);
    VPHAL_RENDER_CHK_NULL(pOutSurface);
    VPHAL_RENDER_CHK_NULL(pRenderData);

    eStatus        = MOS_STATUS_UNKNOWN;
    pOsInterface   = m_osInterface;
    pRenderHal     = m_renderHal;

    // Update SFC rendering flags if any
    VPHAL_RENDER_CHK_STATUS(UpdateRenderingFlags(
        pSrcSurface,
        pOutSurface,
        pRenderData));

    // Setup params related to SFC_STATE
    VPHAL_RENDER_CHK_STATUS(SetSfcStateParams(
            pRenderData,
            pSrcSurface,
            pOutSurface));

    // Setup params related to SFC_AVS_STATE
    if (m_renderData.bScaling ||
        m_renderData.bForcePolyPhaseCoefs)
    {
        VPHAL_RENDER_CHK_STATUS(SetAvsStateParams());
    }

    // Setup params related to SFC_IEF_STATE
    if (m_renderData.bIEF ||
        m_renderData.bCSC)
    {
        SetIefStateParams(
            pRenderData,
            m_renderData.SfcStateParams,
            pSrcSurface);
    }

finish:
    return eStatus;
}

MOS_STATUS VphalSfcState::SendSfcCmd(
    PVPHAL_VEBOX_RENDER_DATA        pRenderData,
    PMOS_COMMAND_BUFFER             pCmdBuffer)
{
    PMHW_SFC_INTERFACE              pSfcInterface;
    MHW_SFC_LOCK_PARAMS             SfcLockParams;
    MOS_STATUS                      eStatus;
    MHW_SFC_OUT_SURFACE_PARAMS      OutSurfaceParam;

    VPHAL_RENDER_CHK_NULL(m_sfcInterface);
    VPHAL_RENDER_CHK_NULL(m_osInterface);
    VPHAL_RENDER_CHK_NULL(pRenderData);
    VPHAL_RENDER_CHK_NULL(pCmdBuffer);

    eStatus                 = MOS_STATUS_SUCCESS;
    pSfcInterface           = m_sfcInterface;

    // Ensure VEBOX can write
    m_osInterface->pfnSyncOnResource(
        m_osInterface,
        &m_renderData.pSfcPipeOutSurface->OsResource,
        MOS_GPU_CONTEXT_VEBOX,
        true);

    if (m_renderData.pSfcPipeOutSurface->bOverlay)
    {
        m_osInterface->pfnSyncOnOverlayResource(
            m_osInterface,
            &m_renderData.pSfcPipeOutSurface->OsResource,
            MOS_GPU_CONTEXT_VEBOX);
    }

    // Setup params for SFC Lock command
    SfcLockParams.sfcPipeMode           = MhwSfcInterface::SFC_PIPE_MODE_VEBOX;
    SfcLockParams.bOutputToMemory = (pRenderData->bDeinterlace || pRenderData->bDenoise);

    // Send SFC_LOCK command to acquire SFC pipe for Vebox
    VPHAL_RENDER_CHK_STATUS(pSfcInterface->AddSfcLock(
        pCmdBuffer,
        &SfcLockParams));

    VPHAL_RENDER_CHK_STATUS(VpHal_InitMhwOutSurfParams(
        m_renderData.pSfcPipeOutSurface,
        &OutSurfaceParam));

    // Send SFC MMCD cmd
    VPHAL_RENDER_CHK_STATUS(RenderSfcMmcCMD(
        pSfcInterface,
        m_renderHal->pMhwMiInterface,
        m_osInterface,
        &OutSurfaceParam,
        pCmdBuffer));

    // Send SFC_STATE command
    VPHAL_RENDER_CHK_STATUS(pSfcInterface->AddSfcState(
        pCmdBuffer,
        m_renderData.SfcStateParams,
        &OutSurfaceParam));

    if (m_renderData.bScaling ||
        m_renderData.bForcePolyPhaseCoefs)
    {
        // Send SFC_AVS_STATE command
        VPHAL_RENDER_CHK_STATUS(pSfcInterface->AddSfcAvsState(
            pCmdBuffer,
            &m_avsState.AvsStateParams));

        // Send SFC_AVS_LUMA_TABLE command
        VPHAL_RENDER_CHK_STATUS(pSfcInterface->AddSfcAvsLumaTable(
            pCmdBuffer,
            &m_avsState.LumaCoeffs));

        // Send SFC_AVS_CHROMA_TABLE command
        VPHAL_RENDER_CHK_STATUS(pSfcInterface->AddSfcAvsChromaTable(
            pCmdBuffer,
            &m_avsState.ChromaCoeffs));
    }

    // Send SFC_IEF_STATE command
    if (m_renderData.bIEF || m_renderData.bCSC)
    {
        VPHAL_RENDER_CHK_STATUS(pSfcInterface->AddSfcIefState(
            pCmdBuffer,
            &m_renderData.IEFStateParams));
    }

    // Send SFC_FRAME_START command to start processing a frame
    VPHAL_RENDER_CHK_STATUS(pSfcInterface->AddSfcFrameStart(
        pCmdBuffer,
        MhwSfcInterface::SFC_PIPE_MODE_VEBOX));

finish:
    return eStatus;
}

#endif // __VPHAL_SFC_SUPPORTED
",16179,True,3300.148101352262,median
"= Stream Evaluator Reference
:page-tocclass: right
:page-toclevels: 1
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// ""License""); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// ""AS IS"" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.


Stream evaluators are different then stream sources or stream decorators. Both
stream sources and stream decorators return streams of tuples. Stream evaluators are more like
a traditional function that evaluates its parameters and
returns an result. That result can be a single value, array, map or other structure.

Stream evaluators can be nested so that the output of an evaluator becomes the input
for another evaluator.

Stream evaluators can be called in different contexts. For example a stream evaluator
can be called on its own or it can be called within the context of a streaming expression.

== abs

The `abs` function will return the absolute value of the provided single parameter. The `abs` function will fail to execute if the value is non-numeric. If a null value is found then null will be returned as the result.

=== abs Parameters

* `Field Name | Raw Number | Number Evaluator`

=== abs Syntax

The expressions below show the various ways in which you can use the `abs` evaluator. Only one parameter is accepted. Returns a numeric value.

[source,text]
----
abs(1) // 1, not really a good use case for it
abs(-1) // 1, not really a good use case for it
abs(add(fieldA,fieldB)) // absolute value of fieldA + fieldB
abs(fieldA) // absolute value of fieldA
----

== acos

The `acos` function returns the trigonometric arccosine of a number.

=== acos Parameters

* `Field Name | Raw Number | Number Evaluator`: The value to return the arccosine of.

=== acos Syntax

[source,text]
----
acos(100.4)  // returns the arccosine of 100.4
acos(fieldA) // returns the arccosine for fieldA.
if(gt(fieldA,fieldB),sin(fieldA),sin(fieldB)) // if fieldA > fieldB then return the arccosine of fieldA, else return the arccosine of fieldB
----

== add

The `add` function will take 2 or more numeric values and add them together. The `add` function will fail to execute if any of the values are non-numeric. If a null value is found then null will be returned as the result.

=== add Parameters

* `Field Name | Raw Number | Number Evaluator`
* `Field Name | Raw Number | Number Evaluator`
* `......`
* `Field Name | Raw Number | Number Evaluator`

=== add Syntax

The expressions below show the various ways in which you can use the `add` evaluator. The number and order of these parameters do not matter and is not limited except that at least two parameters are required. Returns a numeric value.

[source,text]
----
add(1,2,3,4) // 1 + 2 + 3 + 4 == 10
add(1,fieldA) // 1 + value of fieldA
add(fieldA,1.4) // value of fieldA + 1.4
add(fieldA,fieldB,fieldC) // value of fieldA + value of fieldB + value of fieldC
add(fieldA,div(fieldA,fieldB)) // value of fieldA + (value of fieldA / value of fieldB)
add(fieldA,if(gt(fieldA,fieldB),fieldA,fieldB)) // if fieldA > fieldB then fieldA + fieldA, else fieldA + fieldB
----

== analyze

The `analyze` function analyzes text using a Lucene/Solr analyzer and returns a list of tokens
emitted by the analyzer. The `analyze` function can be called on its own or within the
`<<stream-decorator-reference.adoc#select,select>>` and `<<stream-decorator-reference.adoc#cartesianproduct,cartesianProduct>>` streaming expressions.

=== analyze Parameters

* `Field Name` | `Raw Text`: Either the field in a tuple or the raw text to be analyzed.
* `Analyzer Field Name`: The field name of the analyzer to use to analyze the text.

=== analyze Syntax

The expressions below show the various ways in which you can use the `analyze` evaluator.

* Analyze the raw text: `analyze(""hello world"", analyzerField)`
* Analyze a text field within a `select` expression. This will annotate tuples with the output of the analyzer: `select(expr, analyze(textField, analyzerField) as outField)`
* Analyze a text field with a `cartesianProduct` expression. This will stream each token emitted by the analyzer in its own tuple: `cartesianProduct(expr, analyze(textField, analyzer) as outField)`

== and

The `and` function will return the logical AND of at least 2 boolean parameters. The function will fail to execute if any parameters are non-boolean or null. Returns a boolean value.

=== and Parameters

* `Field Name | Raw Boolean | Boolean Evaluator`
* `Field Name | Raw Boolean | Boolean Evaluator`
* `......`
* `Field Name | Raw Boolean | Boolean Evaluator`

=== and Syntax

The expressions below show the various ways in which you can use the `and` evaluator. At least two parameters are required, but there is no limit to how many you can use.

[source,text]
----
and(true,fieldA) // true && fieldA
and(fieldA,fieldB) // fieldA && fieldB
and(or(fieldA,fieldB),fieldC) // (fieldA || fieldB) && fieldC
and(fieldA,fieldB,fieldC,or(fieldD,fieldE),fieldF)
----

== anova

The `anova` function calculates the https://en.wikipedia.org/wiki/Analysis_of_variance[analysis of variance] for two or more numeric arrays.

=== anova Parameters

//TODO fill in details of Parameters
* `numeric array` ... (two or more)

=== anova Syntax

[source,text]
anova(numericArray1, numericArray2) // calculates ANOVA for two numeric arrays
anova(numericArray1, numericArray2, numericArray2) // calculates ANOVA for three numeric arrays

== array

The `array` function returns an array of numerics or other objects including other arrays.

=== array Parameters

//TODO fill in details of Parameters
* `numeric` | `array` ...

=== array Syntax

[source,text]
array(1, 2, 3)  // Array of numerics
array(array(1,2,3), array(4,5,6)) // Array of arrays

== asin
The `asin` function returns the trigonometric arcsine of a number.

=== asin Parameters

* `Field Name | Raw Number | Number Evaluator`: The value to return the arcsine of.

=== asin Syntax

[source,text]
----
asin(100.4)  // returns the sine of 100.4
asine(fieldA) // returns the sine for fieldA.
if(gt(fieldA,fieldB),asin(fieldA),asin(fieldB)) // if fieldA > fieldB then return the asine of fieldA, else return the asine of fieldB
----

== atan

The `atan` function returns the trigonometric arctangent of a number.

=== atan Parameters

* `Field Name | Raw Number | Number Evaluator`: The value to return the arctangent of.

=== atan Syntax

[source,text]
----
atan(100.4)  // returns the arctangent of 100.4
atan(fieldA) // returns the arctangent for fieldA.
if(gt(fieldA,fieldB),atan(fieldA),atan(fieldB)) // if fieldA > fieldB then return the arctanget of fieldA, else return the arctangent of fieldB
----

== betaDistribution

The `betaDistribution` function returns a https://en.wikipedia.org/wiki/Beta_distribution[beta probability distribution]
based on its parameters. This function is part of the
probability distribution framework and is designed to work with the `<<sample>>`, `<<kolmogorovSmirnov>>` and `<<cumulativeProbability>>` functions.

=== betaDistribution Parameters

* `double`: shape1
* `double`: shape2

=== betaDistribution Returns

A probability distribution function.

=== betaDistribution Syntax

[source,text]
betaDistribution(1, 5)

== binomialCoefficient

The `binomialCoefficient` function returns a https://en.wikipedia.org/wiki/Binomial_coefficient[Binomial Coefficient], the number of k-element subsets that can
be selected from an n-element set.

=== binomialCoefficient Parameters

* `integer`: [n] set
* `integer`: [k] subset

=== binomialCoefficient Returns

A long value: The number of k-element subsets that can be selected from an n-element set.

=== binomialCoefficient Syntax

[source,text]
binomialCoefficient(8, 3) // Returns the number of 3 element subsets from an 8 element set.

== binomialDistribution

The `binomialDistribution` function returns a https://en.wikipedia.org/wiki/Binomial_distribution[binomial probability distribution]
based on its parameters. This function is part of the probability distribution framework and is designed to
work with the `<<sample>>`, `<<probability>>` and `<<cumulativeProbability>>` functions.

=== binomialDistribution Parameters

* `integer`: number of trials
* `double`: probability of success

=== binomialDistribution Returns

A probability distribution function.

=== binomialDistribution Syntax

[source,text]
binomialDistribution(1000, .5)

== canberraDistance

The `canberraDistance` function calculates the https://en.wikipedia.org/wiki/Canberra_distance[Canberra distance] of two numeric arrays.

=== canberraDistance Parameters

* `numeric array`
* `numeric array`

=== canberraDistance Returns

A numeric.

=== canberraDistance Syntax

[source,text]
canberraDistance(numericArray1, numuericArray2))

== cbrt

The `cbrt` function returns the trigonometric cube root of a number.

=== cbrt Parameters

* `Field Name | Raw Number | Number Evaluator`: The value to return the cube root of.

=== cbrt Syntax

[source,text]
----
cbrt(100.4)  // returns the square root of 100.4
cbrt(fieldA) // returns the square root for fieldA.
if(gt(fieldA,fieldB),cbrt(fieldA),cbrt(fieldB)) // if fieldA > fieldB then return the cbrt of fieldA, else return the cbrt of fieldB
----

== ceil
The `ceil` function rounds a decimal value to the next highest whole number.

=== ceil Parameters

* `Field Name | Raw Number | Number Evaluator`: The decimal to round up.

=== ceil Syntax

The expressions below show the various ways in which you can use the `ceil` evaluator.

[source,text]
----
ceil(100.4) // returns 101.
ceil(fieldA) // returns the next highest whole number for fieldA.
if(gt(fieldA,fieldB),ceil(fieldA),ceil(fieldB)) // if fieldA > fieldB then return the ceil of fieldA, else return the ceil of fieldB.
----

== chebyshevDistance

The `chebyshevDistance` function calculates the https://en.wikipedia.org/wiki/Chebyshev_distance[Chebyshev distance] of two numeric arrays.

=== chebyshevDistance Parameters

* `numeric array`
* `numeric array`

=== chebyshevDistance Returns

A numeric.

=== chebyshevDistance Syntax

[source,text]
chebyshevDistance(numericArray1, numuericArray2))


== col

The `col` function returns a numeric array from a list of Tuples. The `col`
function is used to create numeric arrays from stream sources.

=== col Parameters

//TODO fill in details of Parameters
* `list of Tuples`
* `field name`: The field to create the array from.


=== col Syntax

[source,text]
col(tupleList, fieldName)

== constantDistribution

The `constantDistribution` function returns a constant probability distribution based on its parameter.
This function is part of the probability distribution framework and is designed to
work with the `<<sample>>` and `<<cumulativeProbability>>` functions.

When sampled the constant distribution always returns its constant value.

=== constantDistribution Parameters

* `double`: constant value

=== constantDistribution Returns

A probability distribution function.

=== constantDistribution Syntax

[source,text]
constantDistribution(constantValue)

== conv

The `conv` function returns the https://en.wikipedia.org/wiki/Convolution[convolution] of two numeric arrays.

=== conv Parameters

* `numeric array`
* `numeric array`

=== conv Syntax

[source,text]
conv(numericArray1, numericArray2)

== copyOf

The `copyOf` function creates a copy of a numeric array.

=== copyOf Parameters

* `numeric array`
* `length`: The length of the copied array. The returned array will be right padded with zeros if the length parameter exceeds the size of the original array.

=== copyOf Syntax

[source,text]
copyOf(numericArray, length)

== copyOfRange

The `copyOfRange` function creates a copy of a range of a numeric array.

=== copyOfRange Parameters

//TODO fill in details of Parameters
* `numeric array`
* `start index`
* `end index`

=== copyOfRange Syntax

[source,text]
copyOfRange(numericArray, startIndex, endIndex)

== corr

The `corr` function returns the Pearson Product Moment Correlation of two numeric arrays.

=== corr Parameters

//TODO fill in details of Parameters
* `numeric array`
* `numeric array`

=== corr Returns

A double between -1 and 1.

=== corr Syntax

[source,text]
corr(numericArray1, numericArray2)

== cos
The `cos` function returns the trigonometric cosine of a number.

=== cos Parameters

* `Field Name | Raw Number | Number Evaluator`: The value to return the hyperbolic cosine of.

=== cos Syntax

[source,text]
----
cos(100.4)  // returns the arccosine of 100.4
cos(fieldA) // returns the arccosine for fieldA.
if(gt(fieldA,fieldB),cos(fieldA),cos(fieldB)) // if fieldA > fieldB then return the arccosine of fieldA, else return the cosine of fieldB
----

== cosineSimilarity

The `cosineSimilarity` function returns the https://en.wikipedia.org/wiki/Cosine_similarity[cosine similarity] of two numeric arrays.

=== cosineSimilarity Parameters

* `numeric array`
* `numeric array`

=== cosineSimilarity Returns

A numeric.

=== cosineSimilarity Syntax

[source,text]
----
cosineSimilarity(numericArray, numericArray)
----

== cov

The `cov` function returns the covariance of two numeric arrays.

=== cov Parameters

//TODO fill in details of Parameters
* `numeric array`
* `numeric array`

=== cov Syntax

[source,text]
cov(numericArray, numericArray)

== cumulativeProbability

The `cumulativeProbability` function returns the cumulative probability of a random variable within a
probability distribution. The cumulative probability is the total probability of
all random variables less then or equal to a random variable.

=== cumulativeProbability Parameters

* `probability distribution`
* `number`: Value to compute the probability for.

=== cumulativeProbability Returns

A double: the cumulative probability.

=== cumulativeProbability Syntax

[source,text]
cumulativeProbability(normalDistribution(500, 25), 502) // Returns the cumulative probability of the random sample 502 in a normal distribution with a mean of 500 and standard deviation of 25.

== describe

The `describe` function returns a tuple containing the descriptive statistics for an array.

=== describe Parameters

* `numeric array`

=== describe Syntax

[source,text]
describe(numericArray)

== distance

The `distance` function calculates the Euclidian distance of two numeric arrays.

=== distance Parameters

* `numeric array`
* `numeric array`

=== distance Syntax

[source,text]
distance(numericArray1, numuericArray2))

== div

The `div` function will take two numeric values and divide them. The function will fail to execute if any of the values are non-numeric or null, or the 2nd value is 0. Returns a numeric value.

=== div Parameters

* `Field Name | Raw Number | Number Evaluator`
* `Field Name | Raw Number | Number Evaluator`

=== div Syntax

The expressions below show the various ways in which you can use the `div` evaluator. The first value will be divided by the second and as such the second cannot be 0.

[source,text]
----
div(1,2) // 1 / 2
div(1,fieldA) // 1 / fieldA
div(fieldA,1.4) // fieldA / 1.4
div(fieldA,add(fieldA,fieldB)) // fieldA / (fieldA + fieldB)
----

== dotProduct

The `dotProduct` function returns the https://en.wikipedia.org/wiki/Dot_product[dotproduct] of a numeric array.

=== dotProduct Parameters

* `numeric array`

=== dotProduct Returns

A number.

=== dotProduct Syntax

[source,text]
dotProduct(numericArray)

== earthMoversDistance

The `earthMoversDistance` function calculates the https://en.wikipedia.org/wiki/Earth_mover%27s_distance[Earth Movers distance] of two numeric arrays.

=== earthMoversDistance Parameters

* `numeric array`
* `numeric array`

=== earthMoversDistance Returns

A numeric.

=== earthMoversDistance Syntax

[source,text]
earthMoversDistance(numericArray1, numericArray2))

== ebeAdd

The `ebeAdd` function performs an element-by-element addition of two numeric arrays.

=== ebeAdd Parameters

* `numeric array`
* `numeric array`

=== ebeAdd Returns

A numeric array.

=== ebeAdd Syntax

[source,text]
ebeAdd(numericArray, numericArray)

== ebeDivide

The `ebeDivide` function performs an element-by-element division of two numeric arrays.

=== ebeDivide Parameters

* `numeric array`
* `numeric array`

=== ebeDivide Returns

A numeric array.

=== ebeDivide Syntax

[source,text]
ebeDivide(numericArray, numericArray)

== ebeMultiple

The `ebeMultiply` function performs an element-by-element multiplication of two numeric arrays.

=== ebeMultiply Parameters

* `numeric array`
* `numeric array`

=== ebeMultiply Returns

A numeric array.

=== ebeMultiply Syntax

[source,text]
ebeMultiply(numericArray, numericArray)

== ebeSubtract

The `ebeSubtract` function performs an element-by-element subtraction of two numeric arrays.

=== ebeSubtract Parameters

* `numeric array`
* `numeric array`

=== ebeSubtract Returns

A numeric array.

=== ebeSubtract Syntax

[source,text]
ebeSubtract(numericArray, numericArray)

== empiricalDistribution

The `empiricalDistribution` function returns https://en.wikipedia.org/wiki/Empirical_distribution_function[empirical distribution function], a continuous probability distribution function based
on an actual data set. This function is part of the probability distribution framework and is designed to work with the `<<sample>>`, `<<kolmogorovSmirnov>>` and `<<cumulativeProbability>>` functions.

This function is designed to work with continuous data. To build a distribution from
a discrete data set use the `<<enumeratedDistribution>>`.

=== empiricalDistribution Parameters

* `numeric array`: empirical observations

=== empiricalDistribution Returns

A probability distribution function.

=== empiricalDistribution Syntax

empiricalDistribution(numericArray)

== enumeratedDistribution

The `enumeratedDistribution` function returns a discrete probability distribution function based
on an actual data set or a pre-defined set of data and probabilities.
This function is part of the probability distribution framework and is designed to
work with the `<<sample>>`, `<<probability>>` and `<<cumulativeProbability>>` functions.

The enumeratedDistribution can be called in two different scenarios:

1) Single array of discrete values. This works like an empirical distribution for
discrete data.

2) An array of singleton discrete values and an array of double values representing
the probabilities of the discrete values.

This function is designed to work with discrete data. To build a distribution from
a continuous data set use the `<<empiricalDistribution>>`.

=== enumeratedDistribution Parameters

* `integer array`: discrete observations or singleton discrete values.
* `double array`: (Optional) values representing the probabilities of the singleton discrete values.

=== enumeratedDistribution Returns

A probability distribution function.

=== enumeratedDistribution Syntax

[source,text]
enumeratedDistribution(integerArray) // This creates an enumerated distribution from the observations in the numeric array.
enumeratedDistribution(array(1,2,3,4), array(.25,.25,.25,.25)) // This creates an enumerated distribution with four discrete values (1,2,3,4) each with a probability of .25.

== eor

The `eor` function will return the logical exclusive or of at least two boolean parameters. The function will fail to execute if any parameters are non-boolean or null. Returns a boolean value.

=== eor Parameters

* `Field Name | Raw Boolean | Boolean Evaluator`
* `Field Name | Raw Boolean | Boolean Evaluator`
* `......`
* `Field Name | Raw Boolean | Boolean Evaluator`

=== eor Syntax

The expressions below show the various ways in which you can use the `eor` evaluator. At least two parameters are required, but there is no limit to how many you can use.

[source,text]
----
eor(true,fieldA) // true iff fieldA is false
eor(fieldA,fieldB) // true iff either fieldA or fieldB is true but not both
eor(eq(fieldA,fieldB),eq(fieldC,fieldD)) // true iff either fieldA == fieldB or fieldC == fieldD but not both
----

== eq

The `eq` function will return whether all the parameters are equal, as per Java's standard `equals(...)` function. The function accepts parameters of any type, but will fail to execute if all the parameters are not of the same type. That is, all are Boolean, all are String, or all are Numeric. If any any parameters are null and there is at least one parameter that is not null then false will be returned. Returns a boolean value.

=== eq Parameters

* `Field Name | Raw Value | Evaluator`
* `Field Name | Raw Value | Evaluator`
* `......`
* `Field Name | Raw Value | Evaluator`

=== eq Syntax

The expressions below show the various ways in which you can use the `eq` evaluator.

[source,text]
----
eq(1,2) // 1 == 2
eq(1,fieldA) // 1 == fieldA
eq(fieldA,val(foo)) fieldA == ""foo""
eq(add(fieldA,fieldB),6) // fieldA + fieldB == 6
----

== expMovingAge

The `expMovingAverage` function computes an  https://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average[exponential moving average] for a numeric array.

=== expMovingAge Parameters

* `numeric array`: The array to compute the exponential moving average from.
* `integer`: window size

=== expMovingAvg Returns

A numeric array. The first element of the returned array will start from the windowSize-1 index of the original array.

=== expMovingAvg Syntax

[source,text]
----
expMovingAvg(numericArray, 5) //Computes an exponential moving average with a window size of 5.
----

== factorial

The `factorial` function returns the https://en.wikipedia.org/wiki/Factorial[factorial] of its parameter.

=== factorial Parameters

* `integer`: The value to compute the factorial for. The largest supported value of this parameter is 170.

=== factorial Returns

A double.

=== factorial Syntax

[source,text]
----
factorial(100) //Computes the factorial of 100
----

== finddelay

The `finddelay` function performs a cross-correlation between two numeric arrays and returns the delay.

=== finddelay Parameters

* `numeric array`
* `numeric array`

=== finddelay Syntax

[source,text]
finddelay(numericArray1, numericArray2)

== floor
The `floor` function rounds a decimal value to the next lowest whole number.

=== floor Parameters

* `Field Name | Raw Number | Number Evaluator`: The decimal to round down.

=== floor Syntax

The expressions below show the various ways in which you can use the `floor` evaluator.

[source,text]
----
floor(100.4) // returns 100.
ceil(fieldA) // returns the next lowestt whole number for fieldA.
if(gt(fieldA,fieldB),floor(fieldA),floor(fieldB)) // if fieldA > fieldB then return the floor of fieldA, else return the floor of fieldB.
----

== freqTable

The `freqTable` function returns a https://en.wikipedia.org/wiki/Frequency_distribution[frequency distribution] from
an array of discrete values.

This function is designed to work with discrete values. To work with continuous data
use the `<<hist>>` function.

=== freqTable Parameters

* `integer array`: The values to build the frequency distribution from.

=== freqTable Returns

A list of tuples containing the frequency information for each discrete value.

=== freqTable Syntax

[source,text]
----
freqTable(integerArray)
----

== gammaDistribution

The `gammaDistribution` function returns a https://en.wikipedia.org/wiki/Gamma_distribution[gamma probability distribution] based on its parameters. This function is part of the
probability distribution framework and is designed to work with the `<<sample>>`, `<<kolmogorovSmirnov>>` and `<<cumulativeProbability>>` functions.

=== gammaDistribution Parameters

* `double`: shape
* `double`: scale

=== gammaDistribution Returns

A probability distribution function,

=== gammaDistribution Syntax

[source,text]
gammaDistribution(1, 10)

== gt

The `gt` function will return whether the first parameter is greater than the second parameter. The function accepts numeric or string parameters, but will fail to execute if all the parameters are not of the same type. That is, all are String or all are Numeric. If any any parameters are null then an error will be raised. Returns a boolean value.

=== gt Parameters

* `Field Name | Raw Value | Evaluator`
* `Field Name | Raw Value | Evaluator`

=== gt Syntax

The expressions below show the various ways in which you can use the `gt` evaluator.

[source,text]
----
gt(1,2) // 1 > 2
gt(1,fieldA) // 1 > fieldA
gt(fieldA,val(foo)) // fieldA > ""foo""
gt(add(fieldA,fieldB),6) // fieldA + fieldB > 6
----

== gteq

The `gteq` function will return whether the first parameter is greater than or equal to the second parameter. The function accepts numeric and string parameters, but will fail to execute if all the parameters are not of the same type. That is, all are String or all are Numeric. If any any parameters are null then an error will be raised. Returns a boolean value.

=== gteq Parameters

* `Field Name | Raw Value | Evaluator`
* `Field Name | Raw Value | Evaluator`

=== gteq Syntax

The expressions below show the various ways in which you can use the `gteq` evaluator.

[source,text]
----
gteq(1,2) // 1 >= 2
gteq(1,fieldA) // 1 >= fieldA
gteq(fieldA,val(foo)) fieldA >= ""foo""
gteq(add(fieldA,fieldB),6) // fieldA + fieldB >= 6
----

== hist

The `hist` function creates a histogram from a numeric array. The hist function is designed
to work with continuous variables.

=== hist Parameters

//TODO fill in details of Parameters
* `numeric array`
* `bins`: The number of bins in the histogram. Each returned tuple contains
summary statistics for the observations that were within the bin.

=== hist Syntax

[source,text]
hist(numericArray, bins)

== hsin
The `hsin` function returns the trigonometric hyperbolic sine of a number.

=== hsin Parameters

* `Field Name | Raw Number | Number Evaluator`: The value to return the hyperbolic sine of.

=== hsin Syntax

[source,text]
----
hsin(100.4)  // returns the hsine of 100.4
hsin(fieldA) // returns the hsine for fieldA.
if(gt(fieldA,fieldB),sin(fieldA),sin(fieldB)) // if fieldA > fieldB then return the hsine of fieldA, else return the hsine of fieldB
----

== if

The `if` function works like a standard conditional if/then statement. If the first parameter is true, then the second parameter will be returned, else the third parameter will be returned. The function accepts a boolean as the first parameter and anything as the second and third parameters. An error will occur if the first parameter is not a boolean or is null.

=== if Parameters

* `Field Name | Raw Value | Boolean Evaluator`
* `Field Name | Raw Value | Evaluator`
* `Field Name | Raw Value | Evaluator`

=== if Syntax

The expressions below show the various ways in which you can use the `if` evaluator.

[source,text]
----
if(fieldA,fieldB,fieldC) // if fieldA is true then fieldB else fieldC
if(gt(fieldA,5), fieldA, 5) // if fieldA > 5 then fieldA else 5
if(eq(fieldB,null), null, div(fieldA,fieldB)) // if fieldB is null then null else fieldA / fieldB
----


== kendallsCorr

The `kendallsCorr` function returns the https://en.wikipedia.org/wiki/Kendall_rank_correlation_coefficient[Kendall's Tau-b Rank Correlation] of two numeric arrays.

=== kendallsCorr Parameters

* `numeric array`
* `numeric array`

=== kendalsCorr Returns

A double between -1 and 1.

=== kendalsCorr Syntax

[source,text]
kendallsCorr(numericArray1, numericArray2)

== length

The `length` function returns the length of a numeric array.

=== length Parameters

//TODO fill in details of Parameters
* `numeric array`

=== length Syntax

[source,text]
length(numericArray)

== log

The `log` function will return the natural log of the provided single parameter. The `log` function will fail to execute if the value is non-numeric. If a null value is found, then null will be returned as the result.

=== log Parameters

* `Field Name | Raw Number | Number Evaluator`

=== log Syntax

The expressions below show the various ways in which you can use the `log` evaluator. Only one parameter is accepted. Returns a numeric value.

[source,text]
----
log(100)
log(add(fieldA,fieldB))
log(fieldA)
----

== logNormalDistribution

The `logNormalDistribution` function returns a https://en.wikipedia.org/wiki/Log-normal_distribution[log normal probability distribution] based on its parameters. This function is part of the probability distribution framework and is designed to
work with the `<<sample>>`, `<<kolmogorovSmirnov>>` and `<<cumulativeProbability>>` functions.

=== logNormalDistribution Parameters

* `double`: shape
* `double`: scale

=== logNormalDistribution Returns

A probability distribution function.

=== logNormalDistribution Syntax

[source,text]
logNormalDistribution(.3, .0)

== kolmogorovSmirnov

The `kolmogorovSmirnov` function performs a https://en.wikipedia.org/wiki/Kolmogorov%E2%80%93Smirnov_test[Kolmogorov Smirnov test],
between a reference continuous probability distribution and a sample set.

The supported distribution functions are: `<<empiricalDistribution>>`, `<<normalDistribution>>`, `<<logNormalDistribution>>`, `<<weibullDistribution>>`, `<<gammaDistribution>>`, and `<<betaDistribution>>`.

=== kolmogorovSmirnov Parameters

* `continuous probability distribution`: Reference distribution
* `numeric array`: sample set

=== kolmogorovSmirnov Returns

A result tuple: A tuple containing the p-value and d-statistic for the test result.

=== kolmogorovSmirnov Syntax

[source,text]
kolmogorovSmirnov(normalDistribution(10, 2), sampleSet)

== lt

The `lt` function will return whether the first parameter is less than the second parameter. The function accepts numeric or string parameters, but will fail to execute if all the parameters are not of the same type. That is, all are String or all are Numeric. If any any parameters are null then an error will be raised. Returns a boolean value.

=== lt Parameters

* `Field Name | Raw Value | Evaluator`
* `Field Name | Raw Value | Evaluator`

=== lt Syntax

The expressions below show the various ways in which you can use the `lt` evaluator.

[source,text]
----
lt(1,2) // 1 < 2
lt(1,fieldA) // 1 < fieldA
lt(fieldA,val(foo)) fieldA < ""foo""
lt(add(fieldA,fieldB),6) // fieldA + fieldB < 6
----

== lteq

The `lteq` function will return whether the first parameter is less than or equal to the second parameter. The function accepts numeric and string parameters, but will fail to execute if all the parameters are not of the same type. That is, all are String or all are Numeric. If any any parameters are null then an error will be raised. Returns a boolean value.

=== lteq Parameters

* `Field Name | Raw Value | Evaluator`
* `Field Name | Raw Value | Evaluator`

=== lteq Syntax

The expressions below show the various ways in which you can use the `lteq` evaluator.

[source,text]
----
lteq(1,2) // 1 <= 2
lteq(1,fieldA) // 1 <= fieldA
lteq(fieldA,val(foo)) fieldA <= ""foo""
lteq(add(fieldA,fieldB),6) // fieldA + fieldB <= 6
----

== manhattanDistance

The `manhattanDistance` function calculates the https://en.wiktionary.org/wiki/Manhattan_distance[Manhattan distance] of two numeric arrays.

=== manhattanDistance Parameters

* `numeric array`
* `numeric array`

=== manhattanDistance Returns

A numeric.

=== manhattanDistance Syntax

[source,text]
manhattanDistance(numericArray1, numuericArray2))

== meanDifference

The `meanDifference` function calculates the mean of the differences following the element-by-element subtraction between two numeric arrays.

=== meanDifference Parameters

* `numeric array`
* `numeric array`

=== meanDifference Returns

A numeric.

=== meanDifference Syntax

[source,text]
----
meanDifference(numericArray, numericArray)
----

== mod
The `mod` function returns the remainder (modulo) of the first parameter divided by the second parameter.

=== mod Parameters

* `Field Name | Raw Number | Number Evaluator`: Parameter 1
* `Field Name | Raw Number | Number Evaluator`: Parameter 2

=== mod Syntax

The expressions below show the various ways in which you can use the `mod` evaluator.

[source,text]
----
mod(100,3) // returns the remainder of 100 / 3 .
mod(100,fieldA) // returns the remainder of 100 divided by the value of fieldA.
mod(fieldA,1.4) // returns the remainder of fieldA divided by 1.4.
if(gt(fieldA,fieldB),mod(fieldA,fieldB),mod(fieldB,fieldA)) // if fieldA > fieldB then return the remainder of fieldA/fieldB, else return the remainder of fieldB/fieldA.
----

== monteCarlo

The `monteCarlo` function performs a https://en.wikipedia.org/wiki/Monte_Carlo_method[Monte Carlo simulation]
based on its parameters. The `monteCarlo` function runs another function a specified number of times and returns the results.
The function being run typically has one or more variables that are drawn from probability
distributions on each run. The `<<sample>>` function is used in the function to draw the samples.

The simulation's result array can then be treated as an empirical distribution to understand
the probabilities of the simulation results.

=== monteCarlo Parameters

* `numeric function`: The function being run by the simulation, which must return a numeric value.
* `integer`: The number of times to run the function.

=== monteCarlo Returns

A numeric array: The results of simulation runs.

=== monteCarlo Syntax

[source,text]
let(a=uniformIntegerDistribution(1, 6),
    b=uniformIntegerDistribution(1, 6),
    c=monteCarlo(add(sample(a), sample(b)), 1000))

In the expression above the `monteCarlo` function is running the function `add(sample(a), sample(b))`
1000 times and returning the result. Each time the function is run samples are drawn from the
probability distributions stored in variables `a` and `b`.

== movingAvg

The `movingAvg` function calculates a https://en.wikipedia.org/wiki/Moving_average[moving average] over an array of numbers.

=== movingAvg Parameters

* `numeric array`
* `window size`

=== movingAvg Returns

A numeric array. The first element of the returned array will start from the windowSize-1 index of the original array.

=== movingAvg Syntax

[source,text]
movingAverage(numericArray, 30)

== movingMedian

The `movingMedian` function calculates a moving median over an array of numbers.

=== movingMedian Parameters

* `numeric array`
* `window size`

=== movingMedian Returns

A numeric array. The first element of the returned array will start from the windowSize-1 index of the original array.

=== movingMedian Syntax

[source,text]
movingMedian(numericArray, 30)

== mult

The `mult` function will take two or more numeric values and multiply them together. The `mult` function will fail to execute if any of the values are non-numeric. If a null value is found then null will be returned as the result.

=== mult Parameters

* `Field Name | Raw Number | Number Evaluator`
* `Field Name | Raw Number | Number Evaluator`
* `......`
* `Field Name | Raw Number | Number Evaluator`

=== mult Syntax

The expressions below show the various ways in which you can use the `mult` evaluator. The number and order of these parameters do not matter and is not limited except that at least two parameters are required. Returns a numeric value.

[source,text]
----
mult(1,2,3,4) // 1 * 2 * 3 * 4
mult(1,fieldA) // 1 * value of fieldA
mult(fieldA,1.4) // value of fieldA * 1.4
mult(fieldA,fieldB,fieldC) // value of fieldA * value of fieldB * value of fieldC
mult(fieldA,div(fieldA,fieldB)) // value of fieldA * (value of fieldA / value of fieldB)
mult(fieldA,if(gt(fieldA,fieldB),fieldA,fieldB)) // if fieldA > fieldB then fieldA * fieldA, else fieldA * fieldB
----

== normalDistribution

The `normalDistribution` function returns a https://en.wikipedia.org/wiki/Normal_distribution[normal probability distribution]
based on its parameters. This function is part of the probability distribution framework and is designed to
work with the `<<sample>>`, `<<kolmogorovSmirnov>>` and `<<cumulativeProbability>>` functions.

=== normalDistribution Parameters

* `double`: mean
* `double`: standard deviation

=== normalDistribution Returns

A probability distribution function.

=== normalDistribution Syntax

[source,text]
normalDistribution(mean, stddev)

== normalize

The `normalize` function normalizes a numeric array so that values within the array
have a mean of 0 and standard deviation of 1.

=== normalize Parameters

* `numeric array`

=== normalize Syntax

[source,text]
normalize(numericArray)

== not

The `not` function will return the logical NOT of a single boolean parameter. The function will fail to execute if the parameter is non-boolean or null. Returns a boolean value.

=== not Parameters

* `Field Name | Raw Boolean | Boolean Evaluator`

=== not Syntax

The expressions below show the various ways in which you can use the `not` evaluator. Only one parameter is allowed.

[source,text]
----
not(true) // false
not(fieldA) // true if fieldA is false else false
not(eq(fieldA,fieldB)) // true if fieldA != fieldB
----

== or

The `or` function will return the logical OR of at least 2 boolean parameters. The function will fail to execute if any parameters are non-boolean or null. Returns a boolean value.

=== or Parameters

* `Field Name | Raw Boolean | Boolean Evaluator`
* `Field Name | Raw Boolean | Boolean Evaluator`
* `......`
* `Field Name | Raw Boolean | Boolean Evaluator`

=== or Syntax

The expressions below show the various ways in which you can use the `or` evaluator. At least two parameters are required, but there is no limit to how many you can use.

[source,text]
----
or(true,fieldA) // true || fieldA
or(fieldA,fieldB) // fieldA || fieldB
or(and(fieldA,fieldB),fieldC) // (fieldA && fieldB) || fieldC
or(fieldA,fieldB,fieldC,and(fieldD,fieldE),fieldF)
----

== poissonDistribution

The `poissonDistribution` function returns a https://en.wikipedia.org/wiki/Poisson_distribution[poisson probability distribution]
based on its parameter. This function is part of the probability distribution framework and is designed to
work with the `<<sample>>`, `<<probability>>` and `<<cumulativeProbability>>` functions.

=== poissonDistribution Parameters

* `double`: mean

=== poissonDistribution Returns

A probability distribution function.

=== poissonDistribution Syntax

[source,text]
poissonDistribution(mean)

== polyFit

The `polyFit` function performs https://en.wikipedia.org/wiki/Curve_fitting#Fitting_lines_and_polynomial_functions_to_data_points[polynomial curve fitting].

=== polyFit Parameters

* `numeric array`: (Optional) x values. If omitted a sequence will be created for the x values.
* `numeric array`: y values
* `integer`: (Optional) polynomial degree. Defaults to 3.

=== polyFit Returns

A numeric array: curve that was fit to the data points.

=== polyFit Syntax

[source,text]
polyFit(yValues) // This creates the xValues automatically and fits a curve through the data points using the default 3 degree polynomial.
polyFit(yValues, 5) // This creates the xValues automatically and fits a curve through the data points using a 5 degree polynomial.
polyFit(xValues, yValues, 5) // This will fit a curve through the data points using a 5 degree polynomial.

== polyfitDerivative

The `polyfitDerivative` function returns the derivative of the curve created by the polynomial curve fitter.

=== polyfitDerivative Parameters

* `numeric array`: (Optional) x values. If omitted a sequence will be created for the x values.
* `numeric array`: y values
* `integer`: (Optional) polynomial degree. Defaults to 3.

=== polyfitDerivative Returns

A numeric array: The curve for the derivative created by the polynomial curve fitter.

=== polyfitDerivative Syntax

[source,text]
polyfitDerivative(yValues) // This creates the xValues automatically and returns the polyfit derivative
polyfitDerivative(yValues, 5) //  This creates the xValues automatically and fits a curve through the data points using a 5 degree polynomial and returns the polyfit derivative.
polyfitDerivative(xValues, yValues, 5) // This will fit a curve through the data points using a 5 degree polynomial and returns the polyfit derivative.

== pow
The `pow` function returns the value of its first parameter raised to the power of its second parameter.

=== pow Parameters

* `Field Name | Raw Number | Number Evaluator`: Parameter 1
* `Field Name | Raw Number | Number Evaluator`: Parameter 2

=== pow Syntax

The expressions below show the various ways in which you can use the `pow` evaluator.

[source,text]
----
pow(2,3) // returns 2 raised to the 3rd power.
pow(4,fieldA) // returns 4 raised by the value of fieldA.
pow(fieldA,1.4) // returns the value of fieldA raised by 1.4.
if(gt(fieldA,fieldB),pow(fieldA,fieldB),pow(fieldB,fieldA)) // if fieldA > fieldB then raise fieldA by fieldB, else raise fieldB by fieldA.
----

== predict

The `predict` function predicts the value of an dependent variable based on
the output of the regress function.

=== predict Parameters

//TODO fill in details of Parameters
* `regress output`
* `numeric predictor`

=== predict Syntax

[source,text]
predict(regressOutput, predictor)

== primes
The `primes` function returns an array of prime numbers starting from a specified number.

=== primes Parameters

* `integer`: The number of primes to return in the list
* `integer`: The starting point for returning the primes

=== primes Returns

A numeric array.

=== primes Syntax

[source,text]
----
primes(100, 2000) // returns 100 primes starting from 2000
----

== probability

The `probability` function returns the probability of a random variable within a discrete probability distribution.

=== probability Parameters

* `discrete probability distribution`: poissonDistribution | binomialDistribution | uniformDistribution | enumeratedDistribution
* `integer`: Value of the random variable to compute the probability for.

=== probability Returns

A double: the probability.

=== probability Syntax

[source,text]
probability(poissonDistribution(10), 7) // Returns the probability of a random sample of 7 in a poisson distribution with a mean of 10.

== rank

The `rank` performs a rank transformation on a numeric array.

=== rank Parameters

//TODO fill in details of Parameters
* `numeric array`

=== rank Syntax

[source,text]
rank(numericArray)

== raw

The `raw` function will return whatever raw value is the parameter. This is useful for cases where you want to use a string as part of another evaluator.

=== raw Parameters

* `Raw Value`

=== raw Syntax

The expressions below show the various ways in which you can use the `raw` evaluator. Whatever is inside will be returned as-is. Internal evaluators are considered strings and are not evaluated.

[source,text]
----
raw(foo) // ""foo""
raw(count(*)) // ""count(*)""
raw(45) // 45
raw(true) // ""true"" (note: this returns the string ""true"" and not the boolean true)
eq(raw(fieldA), fieldA) // true if the value of fieldA equals the string ""fieldA""
----

== regress

The `regress` function performs a simple regression of two numeric arrays.

The result of this expression is also used by the `<<predict>>` and `<<residuals>>` functions.

=== regress Parameters

//TODO fill in details of Parameters
* `numeric array`
* `numeric array`

=== regress Syntax

[source,text]
regress(numericArray1, numericArray2)

== residuals

The `residuals` function takes three parameters: a simple regression model, an array of predictor values
and an array of actual values. The residuals function applies the simple regression model to the
array of predictor values and computes a predictions array. The predicted values array is then
subtracted from the actual value array to compute the residuals array.

=== residuals Parameters

* `regress output`
* `numeric array`: The array of predictor values
* `numeric array`: The array of actual values

=== residuals Returns

A numeric array of residuals.

=== residuals Syntax

[source,text]
residuals(regressOutput, numericArray, numericArray)

== rev

The `rev` function reverses the order of a numeric array.

=== rev Parameters

* `numeric array`

=== rev Syntax

[source,text]
rev(numericArray)

== round

The `round` function returns the closest whole number to the argument.

=== round Parameters

* `Field Name | Raw Number | Number Evaluator`: The value to return the square root of.

=== round Syntax

[source,text]
----
round(100.4)
round(fieldA)
if(gt(fieldA,fieldB),sqrt(fieldA),sqrt(fieldB)) // if fieldA > fieldB then return the round of fieldA, else return the round of fieldB
----

== sample

The `sample` function can be used to draw random samples from a probability distribution.

=== sample Parameters

* `probability distribution`: The distribution to sample.
* `integer`: (Optional) Sample size. Defaults to 1.

=== sample Returns

Either a single numeric random sample, or a numeric array depending on the sample size parameter.

=== sample Syntax

[source,text]
sample(poissonDistribution(5)) // Returns a single random sample from a poissonDistribution with mean of 5.
sample(poissonDistribution(5), 1000) // Returns 1000 random samples from poissonDistribution with a mean of 5.

== scale

The `scale` function multiplies all the elements of an array by a number.

=== scale Parameters

//TODO fill in details of Parameters
* `number`
* `numeric array`

=== scale Syntax

[source,text]
scale(number, numericArray)

== sequence

The `sequence` function returns an array of numbers based on its parameters.

=== sequence Parameters

//TODO fill in details of Parameters
* `length`
* `start`
* `stride`

=== sequence Syntax

[source,text]
sequence(100, 0, 1) // Returns a sequence of length 100, starting from 0 with a stride of 1.

== sin
The `sin` function returns the trigonometric sine of a number.

=== sin Parameters

* `Field Name | Raw Number | Number Evaluator`: The value to return the sine of.

=== sin Syntax

[source,text]
----
sin(100.4)  // returns the sine of 100.4
sine(fieldA) // returns the sine for fieldA.
if(gt(fieldA,fieldB),sin(fieldA),sin(fieldB)) // if fieldA > fieldB then return the sine of fieldA, else return the sine of fieldB
----

== spearmansCorr

The `spearmansCorr` function returns the https://en.wikipedia.org/wiki/Spearman%27s_rank_correlation_coefficient[Spearmans Rank Correlation] of two numeric arrays.

=== spearmansCorr Parameters

* `numeric array`
* `numeric array`

=== spearmansCorr Returns

A double between -1 and 1.

=== spearmansCorr Syntax

[source,text]
spearmansCorr(numericArray1, numericArray2)

== sqrt

The `sqrt` function returns the trigonometric square root of a number.

=== sqrt Parameters

* `Field Name | Raw Number | Number Evaluator`: The value to return the square root of.

=== sqrt Syntax

[source,text]
----
sqrt(100.4)  // returns the square root of 100.4
sqrt(fieldA) // returns the square root for fieldA.
if(gt(fieldA,fieldB),sqrt(fieldA),sqrt(fieldB)) // if fieldA > fieldB then return the sqrt of fieldA, else return the sqrt of fieldB
----

== sub

The `sub` function will take 2 or more numeric values and subtract them, from left to right. The `sub` function will fail to execute if any of the values are non-numeric. If a null value is found then `null` will be returned as the result.

=== sub Parameters

* `Field Name | Raw Number | Number Evaluator`
* `Field Name | Raw Number | Number Evaluator`
* `......`
* `Field Name | Raw Number | Number Evaluator`

=== sub Syntax

The expressions below show the various ways in which you can use the `sub` evaluator. The number of these parameters does not matter and is not limited except that at least two parameters are required. Returns a numeric value.

[source,text]
----
sub(1,2,3,4) // 1 - 2 - 3 - 4
sub(1,fieldA) // 1 - value of fieldA
sub(fieldA,1.4) // value of fieldA - 1.4
sub(fieldA,fieldB,fieldC) // value of fieldA - value of fieldB - value of fieldC
sub(fieldA,div(fieldA,fieldB)) // value of fieldA - (value of fieldA / value of fieldB)
if(gt(fieldA,fieldB),sub(fieldA,fieldB),sub(fieldB,fieldA)) // if fieldA > fieldB then fieldA - fieldB, else fieldB - field
----

== sumDifference

The `sumDifference` function calculates the sum of the differences following an element-by-element subtraction between two numeric arrays.

=== sumDifference Parameters

* `numeric array`
* `numeric array`

=== sumDifference Returns

A numeric.

=== sumDifference Syntax

[source,text]
----
sumDifference(numericArray, numericArray)
----

== uniformDistribution

The `uniformDistribution` function returns a https://en.wikipedia.org/wiki/Uniform_distribution_(continuous)[continuous uniform probability distribution]
based on its parameters. See the `<<uniformIntegerDistribution>>` to work with discrete uniform distributions. This function is part of the
probability distribution framework and is designed to work with the `<<sample>>` and `<<cumulativeProbability>>` functions.

=== uniforDistribution Parameters

* `double`: start
* `double`: end

=== uniformDistribution Returns

A probability distribution function.

=== uniformDistribution Syntax

[source,text]
uniformDistribution(0.0, 100.0)

== uniformIntegerDistribution

The `uniformIntegerDistribution` function returns a https://en.wikipedia.org/wiki/Discrete_uniform_distribution[discrete uniform probability distribution]
based on its parameters. See the `<<uniformDistribution>>` to work with continuous uniform distributions. This function is part of the
probability distribution framework and is designed to work with the `<<sample>>`, `<<probability>>` and `<<cumulativeProbability>>` functions.

=== uniformIntegerDistribution Parameters

* `integer`: start
* `integer`: end

=== uniformIntegerDistribution Returns

A probability distribution function.

=== uniformIntegerDistribution Syntax

[source,text]
uniformDistribution(1, 6)

== weibullDistribution

The `weibullDistribution` function returns a https://en.wikipedia.org/wiki/Weibull_distribution[Weibull probability distribution]
based on its parameters. This function is part of the
probability distribution framework and is designed to work with the `<<sample>>`, `<<kolmogorovSmirnov>>` and `<<cumulativeProbability>>` functions.

=== weibullDistribution Parameters

* `double`: shape
* `double`: scale

=== weibullDistribution Returns

A probability distribution function.

=== weibullDistribution Syntax

[source,text]
weibullDistribution(.5, 10)

== zipFDistribution

The `zipFDistribution` function returns a https://en.wikipedia.org/wiki/Zeta_distribution[ZipF distribution]
based on its parameters. This function is part of the
probability distribution framework and is designed to work with the `<<sample>>`,
`<<probability>>` and `<<cumulativeProbability>>` functions.

=== zipFDistribution Parameters

* `integer`: size
* `double`: exponent

=== zipFDistribution Returns

A probability distribution function.

=== zipFDistribution Syntax

[source,text]
zipFDistribution(5000, 1.0)
",12336,True,2959.9966082305014,median